Add builtin trait for add/remove cv (and similar)

[zoecarver]

Summary

This patch adds six builtins: __remove_cv, __remove_cosnt, __remove_volatile, __add_cv, __add_const, and __add_volatile. I have added two stress tests to show the performace improvements. The __remove_cv test sees a 160% build time imporvement while the __add_cv test sees an 8% improvement.

This patch is based on D67052.

I will submit a patch for implementing these in libc++ after this lands.

[zoecarver]

• diff from D67052, not master

[zoecarver]

Generate diff based on D67052 (arc wasn't working so I had to do it manually this time).

[lebedev.ri]

The __remove_cv test sees a 160% build time imporvement while the __add_cv test sees an 8% improvement.

Those numbers are specifically for those macrobenchmarks, right?
What impact does this have on some real-world code?
I'm just curious as to cost/benefit here.

[zoecarver]

@lebedev.ri after adding _only_ these builtins to libc++ the type trait tests run several seconds faster. I think if we update _all_ the type traits to use builtins then, it could increase speed of the type trait tests by as much as 50% (if not more).

[EricWF]

LGTM other than the inline comments.
I'll take a second pass at this once they're addressed.

Let's land the patch this week!

clang/include/clang/Sema/DeclSpec.h

419

Is the block of values for these identifiers contiguous? Can we work towards writing this as min <= x <= max?

clang/lib/Parse/ParseDeclCXX.cpp

1094

It would be really cool if we could simplify these conversions to static_cast<DeclSpec::TST>(Tok.getKind() - base);

That said, it's probably easier to land this patch as is.

clang/lib/Sema/SemaType.cpp

8475

I don't know that we need add_foo, because if I want to optimize my type-trait, I'll just write T const.

Adding code to clang has a maintenance cost; and that's non-trivial. The remove_foo traits add a lot of value, and that justifies the cost.

clang/test/SemaCXX/add_cv.cpp

43

Clang tests normally test:

(A) The diagnostics that emit when people seriously misuse.
(B) Just some failures.

libcxx/test/libcxx/utilities/meta/stress_tests/stress_test_add_cv.sh.cpp

2

I think we probably want to keep the libc++ changes in a separate patch.

[zoecarver]

Closing in favor of D67052.

clang/include/clang/AST/Type.h

 
 /// A unary type transform, which is a type constructed from another.
 class UnaryTransformType : public Type {
 public:
   enum UTTKind {
     EnumUnderlyingType,
     RemoveReferenceType,
     AddRValueType,
-    AddLValueType
+    AddLValueType,
+    RemoveCV,
+    RemoveConst,
+    RemoveVolatile,
+    AddCV,
+    AddConst,
+    AddVolatile
   };
 
 private:
   /// The untransformed type.
   QualType BaseType;
 
   /// The transformed type if not dependent, otherwise the same as BaseType.
   QualType UnderlyingType;

clang/include/clang/Basic/Specifiers.h

enum TypeSpecifierType {
     TST_typename,     // Typedef, C++ class-name or enum name, etc.
     TST_typeofType,
     TST_typeofExpr,
     TST_decltype,         // C++11 decltype
     TST_underlyingType,   // __underlying_type for C++11
     TST_addLValueReferenceType, // __add_lvalue_reference
     TST_addRValueReferenceType, // __add_rvalue_reference
     TST_removeReferenceType, // __remove_reference
+    TST_removeCV, // __remove_cv
+    TST_removeConst, // __remove_const
+    TST_removeVolatile, // __remove_volatile
+    TST_addCV, // __add_cv
+    TST_addConst, // __add_const
+    TST_addVolatile, // __add_volatile
     TST_auto,             // C++11 auto
     TST_decltype_auto,    // C++1y decltype(auto)
     TST_auto_type,        // __auto_type extension
     TST_unknown_anytype,  // __unknown_anytype extension
     TST_atomic,           // C11 _Atomic
 #define GENERIC_IMAGE_TYPE(ImgType, Id) TST_##ImgType##_t, // OpenCL image types
 #include "clang/Basic/OpenCLImageTypes.def"
     TST_error // erroneous type

clang/include/clang/Basic/TokenKinds.def

 TYPE_TRAIT_1(__is_trivially_copyable, IsTriviallyCopyable, KEYCXX)
 TYPE_TRAIT_1(__is_union, IsUnion, KEYCXX)
 TYPE_TRAIT_1(__has_unique_object_representations,
              HasUniqueObjectRepresentations, KEYCXX)
 KEYWORD(__underlying_type                  , KEYCXX)
 KEYWORD(__add_lvalue_reference             , KEYCXX)
 KEYWORD(__add_rvalue_reference             , KEYCXX)
 KEYWORD(__remove_reference                 , KEYCXX)
+KEYWORD(__remove_cv                        , KEYCXX)
+KEYWORD(__remove_const                     , KEYCXX)
+KEYWORD(__remove_volatile                  , KEYCXX)
+KEYWORD(__add_cv                           , KEYCXX)
+KEYWORD(__add_const                        , KEYCXX)
+KEYWORD(__add_volatile                     , KEYCXX)
 
 // Clang-only C++ Type Traits
 TYPE_TRAIT_2(__reference_binds_to_temporary, ReferenceBindsToTemporary, KEYCXX)
 
 // Embarcadero Expression Traits
 KEYWORD(__is_lvalue_expr            , KEYCXX)
 KEYWORD(__is_rvalue_expr            , KEYCXX)
 

clang/include/clang/Parse/Parser.h

ParseAttributeWithTypeArg(IdentifierInfo &AttrName,
                             SourceLocation ScopeLoc, ParsedAttr::Syntax Syntax);
 
   void ParseTypeofSpecifier(DeclSpec &DS);
   SourceLocation ParseDecltypeSpecifier(DeclSpec &DS);
   void AnnotateExistingDecltypeSpecifier(const DeclSpec &DS,
                                          SourceLocation StartLoc,
                                          SourceLocation EndLoc);
   void ParseUnderlyingTypeSpecifier(DeclSpec &DS);
-  DeclSpec::TST ReferenceTransformTokToDeclSpec();
-  void ParseAddReferenceTypeSpecifier(DeclSpec &DS);
+  DeclSpec::TST TypeTransformTokToDeclSpec();
+  void ParseTypeTransformTypeSpecifier(DeclSpec &DS);
   void ParseAtomicSpecifier(DeclSpec &DS);
 
   ExprResult ParseAlignArgument(SourceLocation Start,
                                 SourceLocation &EllipsisLoc);
   void ParseAlignmentSpecifier(ParsedAttributes &Attrs,
                                SourceLocation *endLoc = nullptr);
 
   VirtSpecifiers::Specifier isCXX11VirtSpecifier(const Token &Tok) const;

clang/include/clang/Sema/DeclSpec.h

public:
   static const TST TST_typeofType = clang::TST_typeofType;
   static const TST TST_typeofExpr = clang::TST_typeofExpr;
   static const TST TST_decltype = clang::TST_decltype;
   static const TST TST_decltype_auto = clang::TST_decltype_auto;
   static const TST TST_underlyingType = clang::TST_underlyingType;
   static const TST TST_addLValueReferenceType = clang::TST_addLValueReferenceType;
   static const TST TST_addRValueReferenceType = clang::TST_addRValueReferenceType;
   static const TST TST_removeReferenceType = clang::TST_removeReferenceType;
+  static const TST TST_removeCV = clang::TST_removeCV;
+  static const TST TST_removeConst = clang::TST_removeConst;
+  static const TST TST_removeVolatile = clang::TST_removeVolatile;
+  static const TST TST_addCV = clang::TST_addCV;
+  static const TST TST_addConst = clang::TST_addConst;
+  static const TST TST_addVolatile = clang::TST_addVolatile;
   static const TST TST_auto = clang::TST_auto;
   static const TST TST_auto_type = clang::TST_auto_type;
   static const TST TST_unknown_anytype = clang::TST_unknown_anytype;
   static const TST TST_atomic = clang::TST_atomic;
 #define GENERIC_IMAGE_TYPE(ImgType, Id) \
   static const TST TST_##ImgType##_t = clang::TST_##ImgType##_t;
 #include "clang/Basic/OpenCLImageTypes.def"
   static const TST TST_error = clang::TST_error;
private:
   SourceLocation TQ_pipeLoc;
 
   WrittenBuiltinSpecs writtenBS;
   void SaveWrittenBuiltinSpecs();
 
   ObjCDeclSpec *ObjCQualifiers;
 
   static bool isTypeRep(TST T) {
     return (T == TST_typename || T == TST_typeofType ||
             T == TST_underlyingType || T == TST_atomic||
             T == TST_addLValueReferenceType || T == TST_addRValueReferenceType ||
-            T == TST_removeReferenceType);
+            T == TST_removeReferenceType ||
+            T == TST_removeCV || T == TST_removeConst || T == TST_removeVolatile ||
+            T == TST_addCV || T == TST_addConst || T == TST_addVolatile);
   }
   static bool isExprRep(TST T) {
     return (T == TST_typeofExpr || T == TST_decltype);
   }
 
   DeclSpec(const DeclSpec &) = delete;
   void operator=(const DeclSpec &) = delete;
 public:

clang/lib/Format/FormatToken.cpp

bool FormatToken::isSimpleTypeSpecifier() const {
   case tok::kw__Float16:
   case tok::kw___float128:
   case tok::kw_wchar_t:
   case tok::kw_bool:
   case tok::kw___underlying_type:
   case tok::kw___add_lvalue_reference:
   case tok::kw___add_rvalue_reference:
   case tok::kw___remove_reference:
+  case tok::kw___remove_cv:
+  case tok::kw___remove_const:
+  case tok::kw___remove_volatile:
+  case tok::kw___add_cv:
+  case tok::kw___add_const:
+  case tok::kw___add_volatile:
   case tok::annot_typename:
   case tok::kw_char8_t:
   case tok::kw_char16_t:
   case tok::kw_char32_t:
   case tok::kw_typeof:
   case tok::kw_decltype:
     return true;
   default:

clang/lib/Lex/PPMacroExpansion.cpp

EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this,
           return llvm::StringSwitch<bool>(II->getName())
               .Case("__array_rank", true)
               .Case("__array_extent", true)
               .Case("__reference_binds_to_temporary", true)
               .Case("__underlying_type", true)
               .Case("__add_lvalue_reference", true)
               .Case("__add_rvalue_reference", true)
               .Case("__remove_reference", true)
+              .Case("__remove_cv", true)
+              .Case("__remove_const", true)
+              .Case("__remove_volatile", true)
+              .Case("__add_cv", true)
+              .Case("__add_const", true)
+              .Case("__add_volatile", true)
               .Default(false);
         } else {
           return llvm::StringSwitch<bool>(II->getName())
               // Report builtin templates as being builtins.
               .Case("__make_integer_seq", LangOpts.CPlusPlus)
               .Case("__type_pack_element", LangOpts.CPlusPlus)
               // Likewise for some builtin preprocessor macros.
               // FIXME: This is inconsistent; we usually suggest detecting

clang/lib/Parse/ParseDecl.cpp

#include "clang/Basic/OpenCLImageTypes.def"
 
     case tok::kw___underlying_type:
       ParseUnderlyingTypeSpecifier(DS);
       continue;
 
     case tok::kw___remove_reference:
     case tok::kw___add_rvalue_reference:
     case tok::kw___add_lvalue_reference:
-      ParseAddReferenceTypeSpecifier(DS);
+    case tok::kw___remove_cv:
+    case tok::kw___remove_const:
+    case tok::kw___remove_volatile:
+    case tok::kw___add_cv:
+    case tok::kw___add_const:
+    case tok::kw___add_volatile:
+      ParseTypeTransformTypeSpecifier(DS);
       continue;
 
     case tok::kw__Atomic:
       // C11 6.7.2.4/4:
       //   If the _Atomic keyword is immediately followed by a left parenthesis,
       //   it is interpreted as a type specifier (with a type name), not as a
       //   type qualifier.
       if (!getLangOpts().C11)

clang/lib/Parse/ParseDeclCXX.cpp

void Parser::ParseUnderlyingTypeSpecifier(DeclSpec &DS) {
   unsigned DiagID;
   if (DS.SetTypeSpecType(DeclSpec::TST_underlyingType, StartLoc, PrevSpec,
                          DiagID, Result.get(),
                          Actions.getASTContext().getPrintingPolicy()))
     Diag(StartLoc, DiagID) << PrevSpec;
   DS.setTypeofParensRange(T.getRange());
 }
 
-DeclSpec::TST Parser::ReferenceTransformTokToDeclSpec() {
+DeclSpec::TST Parser::TypeTransformTokToDeclSpec() {
   switch (Tok.getKind()) {
   case tok::kw___add_lvalue_reference:
     return DeclSpec::TST_addLValueReferenceType;
   case tok::kw___add_rvalue_reference:
     return DeclSpec::TST_addRValueReferenceType;
   case tok::kw___remove_reference:
     return DeclSpec::TST_removeReferenceType;
+  case tok::kw___remove_cv:
+    return DeclSpec::TST_removeCV;
+  case tok::kw___remove_const:
+    return DeclSpec::TST_removeConst;
+  case tok::kw___remove_volatile:
+    return DeclSpec::TST_removeVolatile;
+  case tok::kw___add_cv:
+    return DeclSpec::TST_addCV;
+  case tok::kw___add_const:
+    return DeclSpec::TST_addConst;
+  case tok::kw___add_volatile:
+    return DeclSpec::TST_addVolatile;
   default:
     assert(false && "Not a reference type specifier");
   }
 }
 
-void Parser::ParseAddReferenceTypeSpecifier(DeclSpec &DS) {
-  DeclSpec::TST ReferenceTransformTST = ReferenceTransformTokToDeclSpec();
+void Parser::ParseTypeTransformTypeSpecifier(DeclSpec &DS) {
+  DeclSpec::TST TypeTransformTST = TypeTransformTokToDeclSpec();
 
   SourceLocation StartLoc = ConsumeToken();
   BalancedDelimiterTracker T(*this, tok::l_paren);
   if (T.expectAndConsume(diag::err_expected_lparen_after,
                          "reference manipulation builtin",
                          tok::r_paren)) return;
 
   TypeResult BaseTyResult = ParseTypeName();
   if (BaseTyResult.isInvalid()) {
     SkipUntil(tok::r_paren, StopAtSemi);
     return;
   }
 
   T.consumeClose();
   if (T.getCloseLocation().isInvalid()) return;
 
   const char *PrevSpec;
   unsigned DiagID;
-  if (DS.SetTypeSpecType(ReferenceTransformTST,
+  if (DS.SetTypeSpecType(TypeTransformTST,
                          StartLoc, PrevSpec,
                          DiagID, BaseTyResult.get(),
                          Actions.getASTContext().getPrintingPolicy())) {
     Diag(StartLoc, DiagID) << PrevSpec;
   }
   DS.setTypeofParensRange(T.getRange());
 }
 

clang/lib/Sema/DeclSpec.cpp

case TST_typeofExpr:
       if (Expr *E = DS.getRepAsExpr())
         return E->getType()->isFunctionType();
       return false;
 
     case TST_underlyingType:
     case TST_addLValueReferenceType:
     case TST_addRValueReferenceType:
     case TST_removeReferenceType:
+    case TST_removeCV:
+    case TST_removeConst:
+    case TST_removeVolatile:
+    case TST_addCV:
+    case TST_addConst:
+    case TST_addVolatile:
     case TST_typename:
     case TST_typeofType: {
       QualType QT = DS.getRepAsType().get();
       if (QT.isNull())
         return false;
 
       if (const LocInfoType *LIT = dyn_cast<LocInfoType>(QT))
         QT = LIT->getType();
const char *DeclSpec::getSpecifierName(DeclSpec::TST T,
   case DeclSpec::TST_auto:        return "auto";
   case DeclSpec::TST_auto_type:   return "__auto_type";
   case DeclSpec::TST_decltype:    return "(decltype)";
   case DeclSpec::TST_decltype_auto: return "decltype(auto)";
   case DeclSpec::TST_underlyingType: return "__underlying_type";
   case DeclSpec::TST_addLValueReferenceType: return "__add_lvalue_reference";
   case DeclSpec::TST_addRValueReferenceType: return "__add_rvalue_reference";
   case DeclSpec::TST_removeReferenceType: return "__remove_reference";
+  case DeclSpec::TST_removeCV: return "__remove_cv";
+  case DeclSpec::TST_removeConst: return "__remove_const";
+  case DeclSpec::TST_removeVolatile: return "__remove_volatile";
+  case DeclSpec::TST_addCV: return "__add_cv";
+  case DeclSpec::TST_addConst: return "__add_const";
+  case DeclSpec::TST_addVolatile: return "__add_volatile";
   case DeclSpec::TST_unknown_anytype: return "__unknown_anytype";
   case DeclSpec::TST_atomic: return "_Atomic";
 #define GENERIC_IMAGE_TYPE(ImgType, Id) \
   case DeclSpec::TST_##ImgType##_t: \
     return #ImgType "_t";
 #include "clang/Basic/OpenCLImageTypes.def"
   case DeclSpec::TST_error:       return "(error)";
   }

clang/lib/Sema/SemaDecl.cpp

bool Sema::isSimpleTypeSpecifier(tok::TokenKind Kind) const {
   case tok::kw__Float16:
   case tok::kw___float128:
   case tok::kw_wchar_t:
   case tok::kw_bool:
   case tok::kw___underlying_type:
   case tok::kw___add_lvalue_reference:
   case tok::kw___add_rvalue_reference:
   case tok::kw___remove_reference:
+  case tok::kw___remove_cv:
+  case tok::kw___remove_const:
+  case tok::kw___remove_volatile:
+  case tok::kw___add_cv:
+  case tok::kw___add_const:
+  case tok::kw___add_volatile:
   case tok::kw___auto_type:
     return true;
 
   case tok::annot_typename:
   case tok::kw_char16_t:
   case tok::kw_char32_t:
   case tok::kw_typeof:
   case tok::annot_decltype:
static bool RebuildDeclaratorInCurrentInstantiation(Sema &S, Declarator &D,
   DeclSpec &DS = D.getMutableDeclSpec();
   switch (DS.getTypeSpecType()) {
   case DeclSpec::TST_typename:
   case DeclSpec::TST_typeofType:
   case DeclSpec::TST_underlyingType:
   case DeclSpec::TST_addLValueReferenceType:
   case DeclSpec::TST_addRValueReferenceType:
   case DeclSpec::TST_removeReferenceType:
+  case DeclSpec::TST_removeCV:
+  case DeclSpec::TST_removeConst:
+  case DeclSpec::TST_removeVolatile:
+  case DeclSpec::TST_addCV:
+  case DeclSpec::TST_addConst:
+  case DeclSpec::TST_addVolatile:
   case DeclSpec::TST_atomic: {
     // Grab the type from the parser.
     TypeSourceInfo *TSI = nullptr;
     QualType T = S.GetTypeFromParser(DS.getRepAsType(), &TSI);
     if (T.isNull() || !T->isDependentType()) break;
 
     // Make sure there's a type source info.  This isn't really much
     // of a waste; most dependent types should have type source info

clang/lib/Sema/SemaTemplateVariadic.cpp

bool Sema::containsUnexpandedParameterPacks(Declarator &D) {
   const DeclSpec &DS = D.getDeclSpec();
   switch (DS.getTypeSpecType()) {
   case TST_typename:
   case TST_typeofType:
   case TST_underlyingType:
   case TST_addLValueReferenceType:
   case TST_addRValueReferenceType:
   case TST_removeReferenceType:
+  case TST_removeCV:
+  case TST_removeConst:
+  case TST_removeVolatile:
+  case TST_addCV:
+  case TST_addConst:
+  case TST_addVolatile:
   case TST_atomic: {
     QualType T = DS.getRepAsType().get();
     if (!T.isNull() && T->containsUnexpandedParameterPack())
       return true;
     break;
   }
 
   case TST_typeofExpr:

clang/lib/Sema/SemaType.cpp

TSTToUnaryTransformType(DeclSpec::TST SwitchTST) {
   case TST_addLValueReferenceType:
     return UnaryTransformType::AddLValueType;
   case TST_addRValueReferenceType:
     return UnaryTransformType::AddRValueType;
   case TST_removeReferenceType:
     return UnaryTransformType::RemoveReferenceType;
   case TST_underlyingType:
     return UnaryTransformType::EnumUnderlyingType;
+  case TST_removeCV:
+    return UnaryTransformType::RemoveCV;
+  case TST_removeConst:
+    return UnaryTransformType::RemoveConst;
+  case TST_removeVolatile:
+    return UnaryTransformType::RemoveVolatile;
+  case TST_addCV:
+    return UnaryTransformType::AddCV;
+  case TST_addConst:
+    return UnaryTransformType::AddConst;
+  case TST_addVolatile:
+    return UnaryTransformType::AddVolatile;
   default:
     assert(false && "Cannot map TST to unary transform type");
   }
 }
 
 /// Convert the specified declspec to the appropriate type
 /// object.
 /// \param state Specifies the declarator containing the declaration specifier
case DeclSpec::TST_underlyingType:
     if (Result.isNull()) {
       Result = Context.IntTy;
       declarator.setInvalidType(true);
     }
     break;
   case DeclSpec::TST_addLValueReferenceType:
   case DeclSpec::TST_addRValueReferenceType:
   case DeclSpec::TST_removeReferenceType:
+  case DeclSpec::TST_removeCV:
+  case DeclSpec::TST_removeConst:
+  case DeclSpec::TST_removeVolatile:
+  case DeclSpec::TST_addCV:
+  case DeclSpec::TST_addConst:
+  case DeclSpec::TST_addVolatile:
     Result = S.GetTypeFromParser(DS.getRepAsType());
     assert(!Result.isNull() &&
            "Reference manipulation type transform may not have received a type.");
     Result = S.BuildUnaryTransformType(Result,
                                        TSTToUnaryTransformType(DS.getTypeSpecType()),
                                        DS.getTypeSpecTypeLoc());
     if (Result.isNull()) {
       declarator.setInvalidType(true);
case UnaryTransformType::AddRValueType: {
     return Context.getUnaryTransformType(BaseType, Underlying,
                                          UnaryTransformType::AddRValueType);
   }
   case UnaryTransformType::RemoveReferenceType: {
     QualType Underlying = BaseType.getNonReferenceType();
     return Context.getUnaryTransformType(BaseType, Underlying,
                                          UnaryTransformType::RemoveReferenceType);
   }
+  case UnaryTransformType::RemoveCV: {
+    SplitQualType Split = BaseType.getSplitUnqualifiedType();
+    Qualifiers Quals = BaseType.getQualifiers();
+    Quals.removeConst();
+    Quals.removeVolatile();
+    QualType Underlying(Split.Ty, Quals.getAsOpaqueValue());
+    return Context.getUnaryTransformType(BaseType, Underlying,
+                                         UnaryTransformType::RemoveCV);
+  }
+  case UnaryTransformType::RemoveConst: {
+    SplitQualType Split = BaseType.getSplitUnqualifiedType();
+    Qualifiers Quals = BaseType.getQualifiers();
+    Quals.removeConst();
+    QualType Underlying(Split.Ty, Quals.getAsOpaqueValue());
+    return Context.getUnaryTransformType(BaseType, Underlying,
+                                         UnaryTransformType::RemoveConst);
+  }
+  case UnaryTransformType::RemoveVolatile: {
+    SplitQualType Split = BaseType.getSplitUnqualifiedType();
+    Qualifiers Quals = BaseType.getQualifiers();
+    Quals.removeVolatile();
+    QualType Underlying(Split.Ty, Quals.getAsOpaqueValue());
+    return Context.getUnaryTransformType(BaseType, Underlying,
+                                         UnaryTransformType::RemoveVolatile);
+  }
+  case UnaryTransformType::AddCV: {
+    QualType Underlying = BaseType.withConst().withVolatile();
+    return Context.getUnaryTransformType(BaseType, Underlying,
+                                         UnaryTransformType::AddCV);
+  }
+  case UnaryTransformType::AddConst: {
+    QualType Underlying = BaseType.withConst();
+    return Context.getUnaryTransformType(BaseType, Underlying,
+                                         UnaryTransformType::AddConst);
+  }
+  case UnaryTransformType::AddVolatile: {
+    QualType Underlying = BaseType.withVolatile();
+    return Context.getUnaryTransformType(BaseType, Underlying,
+                                         UnaryTransformType::AddVolatile);
+  }
   }
   llvm_unreachable("unknown unary transform type");
 }
 
 QualType Sema::BuildAtomicType(QualType T, SourceLocation Loc) {
   if (!T->isDependentType()) {
     // FIXME: It isn't entirely clear whether incomplete atomic types
     // are allowed or not; for simplicity, ban them for the moment.

clang/test/SemaCXX/add_cv.cpp

+// RUN: %clang_cc1 -std=c++11 %s
+
+template<class T>
+struct remove_const
+{
+  typedef __remove_const(T) type;
+};
+
+template<class T>
+struct remove_volatile
+{
+  typedef __remove_volatile(T) type;
+};
+
+template<class T>
+struct remove_cv
+{
+  typedef __remove_cv(T) type;
+};
+
+template<class T>
+struct add_const
+{
+  typedef __add_const(T) type;
+};
+
+template<class T>
+struct add_volatile
+{
+  typedef __add_volatile(T) type;
+};
+
+template<class T>
+struct add_cv
+{
+  typedef __add_cv(T) type;
+};
+
+template<class T>
+struct test
+{
+  static const bool value =
+    __is_same(typename remove_const<T>::type, T) &&
+    __is_same(typename remove_const<const volatile T>::type, volatile T) &&
+    __is_same(typename remove_const<const T>::type, T) &&
+
+    __is_same(typename remove_volatile<T>::type, T) &&
+    __is_same(typename remove_volatile<const volatile T>::type, const T) &&
+    __is_same(typename remove_volatile<volatile T>::type, T) &&
+
+    __is_same(typename remove_cv<const volatile T>::type, T) &&
+    __is_same(typename remove_cv<T>::type, T) &&
+    __is_same(typename remove_cv<const T>::type, T) &&
+    __is_same(typename remove_cv<volatile T>::type, T) &&
+
+    __is_same(typename add_const<const T>::type, const T) &&
+    __is_same(typename add_const<volatile T>::type, const volatile T) &&
+    __is_same(typename add_const<T>::type, const T) &&
+
+    __is_same(typename add_volatile<volatile T>::type, volatile T) &&
+    __is_same(typename add_volatile<const T>::type, const volatile T) &&
+    __is_same(typename add_volatile<T>::type, volatile T) &&
+
+    __is_same(typename add_cv<T>::type, const volatile T) &&
+    __is_same(typename add_cv<const volatile T>::type, const volatile T) &&
+    __is_same(typename add_cv<const T>::type, const volatile T) &&
+    __is_same(typename add_cv<volatile T>::type, const volatile T);
+};
+
+struct Foo { };
+
+template<class T>
+struct Bar { };
+
+template<class T>
+class Baz { };
+
+static_assert(test<int>::value, "");
+static_assert(test<int[]>::value, "");
+static_assert(test<int[8]>::value, "");
+static_assert(test<Foo>::value, "");
+static_assert(test<Bar<int>>::value, "");
+static_assert(test<Baz<int>>::value, "");

libcxx/test/libcxx/utilities/meta/stress_tests/stress_test_add_cv.sh.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This is a dummy feature that prevents this test from running by default.
+
+// The table below compares the compile time and object size for each of the
+// variants listed in the RUN script.
+//
+//  Impl                       Compile Time      Object Size
+// ----------------------------------------------------------
+// new_add_cv:       22.710 s          121 K
+// std::add_cv:      25.643 s          121 K
+//
+// RUN: %cxx %flags %compile_flags -c %s -o %S/orig.o -ggdb  -ggnu-pubnames -ftemplate-depth=5000 -ftime-trace -std=c++17
+// RUN: %cxx %flags %compile_flags -c %s -o %S/new.o -ggdb  -ggnu-pubnames -ftemplate-depth=5000 -ftime-trace -std=c++17 -DTEST_NEW
+
+#include <type_traits>
+
+#include "test_macros.h"
+#include "template_cost_testing.h"
+
+template <int N> struct Arg { enum { value = 1 }; };
+
+#ifdef TEST_NEW
+
+template <class T>
+struct new_add_cv
+{
+  typedef __add_cv(T) type;
+};
+
+#define TEST_CASE_NOP()  new_add_cv< Arg< __COUNTER__ > >{},
+#define TEST_CASE_TYPE() typename new_add_cv< Arg< __COUNTER__ > >::type,
+
+#else
+
+#define TEST_CASE_NOP()  std::add_cv< Arg< __COUNTER__ > >{},
+#define TEST_CASE_TYPE() typename std::add_cv< Arg< __COUNTER__ > >::type,
+
+#endif
+
+int sink(...);
+
+int x = sink(
+  REPEAT_10000(TEST_CASE_NOP)
+  REPEAT_10000(TEST_CASE_NOP) 42
+);
+
+void Foo( REPEAT_10000(TEST_CASE_TYPE) int) { }
+
+void escape() {
+
+sink(&x);
+sink(&Foo);
+}
+
+

libcxx/test/libcxx/utilities/meta/stress_tests/stress_test_remove_cv.sh.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This is a dummy feature that prevents this test from running by default.
+
+// The table below compares the compile time and object size for each of the
+// variants listed in the RUN script.
+//
+//  Impl                       Compile Time      Object Size
+// ----------------------------------------------------------
+// new_remove_cv:       23.594 s          121 K
+// std::remove_cv:      38.817 s          121 K
+//
+// RUN: %cxx %flags %compile_flags -c %s -o %S/orig.o -ggdb  -ggnu-pubnames -ftemplate-depth=5000 -ftime-trace -std=c++17
+// RUN: %cxx %flags %compile_flags -c %s -o %S/new.o -ggdb  -ggnu-pubnames -ftemplate-depth=5000 -ftime-trace -std=c++17 -DTEST_NEW
+
+#include <type_traits>
+
+#include "test_macros.h"
+#include "template_cost_testing.h"
+
+template <int N> struct Arg { enum { value = 1 }; };
+
+#ifdef TEST_NEW
+
+template <class T>
+struct new_remove_cv
+{
+  typedef __remove_cv(T) type;
+};
+
+#define TEST_CASE_NOP()  new_remove_cv< Arg< __COUNTER__ > >{},
+#define TEST_CASE_TYPE() typename new_remove_cv< Arg< __COUNTER__ > >::type,
+
+#else
+
+#define TEST_CASE_NOP()  std::remove_cv< Arg< __COUNTER__ > >{},
+#define TEST_CASE_TYPE() typename std::remove_cv< Arg< __COUNTER__ > >::type,
+
+#endif
+
+int sink(...);
+
+int x = sink(
+  REPEAT_10000(TEST_CASE_NOP)
+  REPEAT_10000(TEST_CASE_NOP) 42
+);
+
+void Foo( REPEAT_10000(TEST_CASE_TYPE) int) { }
+
+void escape() {
+
+sink(&x);
+sink(&Foo);
+}
+
+