[clang] adds `__add_volatile` as a compiler built-in

[cjdb]

Merged into D116203.

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,
     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_class,     // C++ class type
     TST_interface, // C++ (Microsoft-specific) __interface type
     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_add_const,       // __add_const extension
+    TST_add_volatile,    // __add_volatile extension
     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_2(__is_trivially_assignable, IsTriviallyAssignable, KEYCXX)
 TYPE_TRAIT_N(__is_trivially_constructible, IsTriviallyConstructible, KEYCXX)
 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_const, KEYCXX)
+KEYWORD(__add_volatile, KEYCXX)
 
 // Clang-only C++ Type Traits
 TYPE_TRAIT_2(__reference_binds_to_temporary, ReferenceBindsToTemporary, KEYCXX)
 
 // Embarcadero Expression Traits
 EXPRESSION_TRAIT(__is_lvalue_expr, IsLValueExpr, KEYCXX)
 EXPRESSION_TRAIT(__is_rvalue_expr, IsRValueExpr, KEYCXX)
 

clang/include/clang/Sema/DeclSpec.h

public:
   static const TST TST_class = clang::TST_class;
   static const TST TST_typename = clang::TST_typename;
   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_add_const = clang::TST_add_const;
+  static const TST TST_add_volatile = clang::TST_add_volatile;
   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;

clang/lib/AST/ItaniumMangle.cpp

if (T->isDependentType()) {
 
     switch (T->getUTTKind()) {
       case UnaryTransformType::EnumUnderlyingType:
         Out << "3eut";
         break;
       case UnaryTransformType::AddConst:
         Out << "3ac";
         break;
+      case UnaryTransformType::AddVolatile:
+        Out << "3av";
+        break;
     }
   }
 
   mangleType(T->getBaseType());
 }
 
 void CXXNameMangler::mangleType(const AutoType *T) {
   assert(T->getDeducedType().isNull() &&

clang/lib/AST/JSONNodeDumper.cpp

 void JSONNodeDumper::VisitUnaryTransformType(const UnaryTransformType *UTT) {
   switch (UTT->getUTTKind()) {
   case UnaryTransformType::EnumUnderlyingType:
     JOS.attribute("transformKind", "underlying_type");
     break;
   case UnaryTransformType::AddConst:
     JOS.attribute("transformedKind", "add_const");
     break;
+  case UnaryTransformType::AddVolatile:
+    JOS.attribute("transformedKind", "add_volatile");
+    break;
   }
 }
 
 void JSONNodeDumper::VisitTagType(const TagType *TT) {
   JOS.attribute("decl", createBareDeclRef(TT->getDecl()));
 }
 
 void JSONNodeDumper::VisitTemplateTypeParmType(

clang/lib/AST/TypePrinter.cpp

 void TypePrinter::printDecltypeAfter(const DecltypeType *T, raw_ostream &OS) {}
 
 void TypePrinter::printUnaryTransformBefore(const UnaryTransformType *T,
                                             raw_ostream &OS) {
   IncludeStrongLifetimeRAII Strong(Policy);
 
   switch (T->getUTTKind()) {
     case UnaryTransformType::EnumUnderlyingType:
-    case UnaryTransformType::AddConst: {
-      constexpr std::array<const char *, 2> Transformation = {
-          "__underlying_type", "__add_const"};
+    case UnaryTransformType::AddConst:
+    case UnaryTransformType::AddVolatile: {
+      constexpr std::array<const char *, 3> Transformation = {
+          "__underlying_type", "__add_const", "__add_volatile"};
       OS << Transformation[T->getUTTKind()] << '(';
       print(T->getBaseType(), OS, StringRef());
       OS << ')';
       spaceBeforePlaceHolder(OS);
       return;
     }
   }
 
   printBefore(T->getBaseType(), OS);
 }
 
 void TypePrinter::printUnaryTransformAfter(const UnaryTransformType *T,
                                            raw_ostream &OS) {
   IncludeStrongLifetimeRAII Strong(Policy);
 
   switch (T->getUTTKind()) {
     case UnaryTransformType::EnumUnderlyingType:
     case UnaryTransformType::AddConst:
+    case UnaryTransformType::AddVolatile:
       return;
   }
 
   printAfter(T->getBaseType(), OS);
 }
 
 void TypePrinter::printAutoBefore(const AutoType *T, raw_ostream &OS) {
   // If the type has been deduced, do not print 'auto'.

clang/lib/Format/FormatToken.cpp

bool FormatToken::isSimpleTypeSpecifier() const {
   case tok::kw___bf16:
   case tok::kw__Float16:
   case tok::kw___float128:
   case tok::kw___ibm128:
   case tok::kw_wchar_t:
   case tok::kw_bool:
   case tok::kw___underlying_type:
   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:
   case tok::kw__Atomic:
     return true;

clang/lib/Lex/PPMacroExpansion.cpp

EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this, false,
               II->getName().startswith("__has_"))
             return true;
           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_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", getLangOpts().CPlusPlus)
               .Case("__type_pack_element", getLangOpts().CPlusPlus)
               // Likewise for some builtin preprocessor macros.
               // FIXME: This is inconsistent; we usually suggest detecting

clang/lib/Parse/ParseDecl.cpp

case tok::annot_pragma_ms_pointers_to_members:
       HandlePragmaMSPointersToMembers();
       continue;
 
     case tok::kw___underlying_type:
       ParseUnderlyingTypeSpecifier(DS);
       continue;
 
     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.
#include "clang/Basic/OpenCLImageTypes.def"
     AttrsLastTime = false;
   }
 }
 
 DeclSpec::TST Parser::TypeTransformTokToDeclSpec() {
   switch (Tok.getKind()) {
   case tok::kw___add_const:
     return DeclSpec::TST_add_const;
+  case tok::kw___add_volatile:
+    return DeclSpec::TST_add_volatile;
   }
 
   __builtin_unreachable();
 }
 
 void Parser::ParseTypeTransformTypeSpecifier(DeclSpec &DS) {
   DeclSpec::TST TypeTransformTST = TypeTransformTokToDeclSpec();
   SourceLocation StartLoc = ConsumeToken();

clang/lib/Parse/ParseDeclCXX.cpp

void Parser::ParseClassSpecifier(tok::TokenKind TagTokKind,
 
   // Source location used by FIXIT to insert misplaced
   // C++11 attributes
   SourceLocation AttrFixitLoc = Tok.getLocation();
 
   if (TagType == DeclSpec::TST_struct && Tok.isNot(tok::identifier) &&
       !Tok.isAnnotation() && Tok.getIdentifierInfo() &&
       Tok.isOneOf(
-          tok::kw___add_const, tok::kw___is_abstract, tok::kw___is_aggregate,
-          tok::kw___is_arithmetic, tok::kw___is_array, tok::kw___is_assignable,
-          tok::kw___is_base_of, tok::kw___is_class, tok::kw___is_complete_type,
-          tok::kw___is_compound, tok::kw___is_const, tok::kw___is_constructible,
-          tok::kw___is_convertible, tok::kw___is_convertible_to,
-          tok::kw___is_destructible, tok::kw___is_empty, tok::kw___is_enum,
-          tok::kw___is_floating_point, tok::kw___is_final,
-          tok::kw___is_function, tok::kw___is_fundamental,
+          tok::kw___add_const, tok::kw___add_volatile, tok::kw___is_abstract,
+          tok::kw___is_aggregate, tok::kw___is_arithmetic, tok::kw___is_array,
+          tok::kw___is_assignable, tok::kw___is_base_of, tok::kw___is_class,
+          tok::kw___is_complete_type, tok::kw___is_compound, tok::kw___is_const,
+          tok::kw___is_constructible, tok::kw___is_convertible,
+          tok::kw___is_convertible_to, tok::kw___is_destructible,
+          tok::kw___is_empty, tok::kw___is_enum, tok::kw___is_floating_point,
+          tok::kw___is_final, tok::kw___is_function, tok::kw___is_fundamental,
           tok::kw___is_integral, tok::kw___is_interface_class,
           tok::kw___is_literal, tok::kw___is_lvalue_expr,
           tok::kw___is_lvalue_reference, tok::kw___is_member_function_pointer,
           tok::kw___is_member_object_pointer, tok::kw___is_member_pointer,
           tok::kw___is_nothrow_assignable, tok::kw___is_nothrow_constructible,
           tok::kw___is_nothrow_destructible, tok::kw___is_object,
           tok::kw___is_pod, tok::kw___is_pointer, tok::kw___is_polymorphic,
           tok::kw___is_reference, tok::kw___is_rvalue_expr,

clang/lib/Sema/DeclSpec.cpp

#include "clang/Basic/OpenCLImageTypes.def"
     case TST_decltype:
     case TST_typeofExpr:
       if (Expr *E = DS.getRepAsExpr())
         return E->getType()->isFunctionType();
       return false;
 
     case TST_underlyingType:
     case TST_add_const:
+    case TST_add_volatile:
     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_typeofExpr:  return "typeof";
   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_add_const:
     return "__add_const";
+  case DeclSpec::TST_add_volatile:
+    return "__add_volatile";
   case DeclSpec::TST_unknown_anytype: return "__unknown_anytype";
   case DeclSpec::TST_atomic: return "_Atomic";
   case DeclSpec::TST_BFloat16: return "__bf16";
 #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___bf16:
   case tok::kw__Float16:
   case tok::kw___float128:
   case tok::kw___ibm128:
   case tok::kw_wchar_t:
   case tok::kw_bool:
   case tok::kw___underlying_type:
   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,
   // few cases here.
 
   DeclSpec &DS = D.getMutableDeclSpec();
   switch (DS.getTypeSpecType()) {
   case DeclSpec::TST_typename:
   case DeclSpec::TST_typeofType:
   case DeclSpec::TST_underlyingType:
   case DeclSpec::TST_add_const:
+  case DeclSpec::TST_add_volatile:
   case DeclSpec::TST_atomic: {
     // Grab the type from the parser.
     TypeSourceInfo *TSI = nullptr;
     QualType T = S.GetTypeFromParser(DS.getRepAsType(), &TSI);
     if (T.isNull() || !T->isInstantiationDependentType()) 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_add_const:
+  case TST_add_volatile:
   case TST_atomic: {
     QualType T = DS.getRepAsType().get();
     if (!T.isNull() && T->containsUnexpandedParameterPack())
       return true;
     break;
   }
 
   case TST_typeofExpr:

clang/lib/Sema/SemaType.cpp

getImageAccess(const ParsedAttributesView &Attrs) {
   return OpenCLAccessAttr::Keyword_read_only;
 }
 
 static UnaryTransformType::UTTKind
 TSTToUnaryTransformType(DeclSpec::TST SwitchTST) {
   switch (SwitchTST) {
   case TST_add_const:
     return UnaryTransformType::AddConst;
+  case TST_add_volatile:
+    return UnaryTransformType::AddVolatile;
   case TST_underlyingType:
     return UnaryTransformType::EnumUnderlyingType;
   default:
     llvm_unreachable("attempted to parse a non-unary transform builtin");
   }
 }
 
 /// Convert the specified declspec to the appropriate type
case DeclSpec::TST_decltype: {
     if (Result.isNull()) {
       Result = Context.IntTy;
       declarator.setInvalidType(true);
     }
     break;
   }
   case DeclSpec::TST_underlyingType:
   case DeclSpec::TST_add_const:
+  case DeclSpec::TST_add_volatile:
     Result = S.GetTypeFromParser(DS.getRepAsType());
     assert(!Result.isNull() && "Didn't get a type for the transformation?");
     Result = S.BuildUnaryTransformType(
         Result, TSTToUnaryTransformType(DS.getTypeSpecType()),
         DS.getTypeSpecTypeLoc());
     if (Result.isNull()) {
       if (DS.getTypeSpecType() == DeclSpec::TST_underlyingType)
         Result = Context.IntTy;
void VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
       assert(DS.getRepAsType());
       TypeSourceInfo *TInfo = nullptr;
       Sema::GetTypeFromParser(DS.getRepAsType(), &TInfo);
       TL.setUnderlyingTInfo(TInfo);
     }
     void VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
       // Make sure it is a unary transform type
       assert(DS.getTypeSpecType() >= DeclSpec::TST_underlyingType &&
-             DS.getTypeSpecType() <= DeclSpec::TST_add_const);
+             DS.getTypeSpecType() <= DeclSpec::TST_add_volatile);
       TL.setKWLoc(DS.getTypeSpecTypeLoc());
       TL.setParensRange(DS.getTypeofParensRange());
       assert(DS.getRepAsType());
       TypeSourceInfo *TInfo = nullptr;
       Sema::GetTypeFromParser(DS.getRepAsType(), &TInfo);
       TL.setUnderlyingTInfo(TInfo);
     }
     void VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
case UnaryTransformType::AddConst: {
     Qualifiers Quals = BaseType.getQualifiers();
     if (BaseType->isReferenceType() || BaseType->isFunctionType())
       return BaseType;
     Quals.addConst();
     QualType Underlying(Split.Ty, Quals.getAsOpaqueValue());
     return Context.getUnaryTransformType(BaseType, Underlying,
                                          UnaryTransformType::AddConst);
   }
+  case UnaryTransformType::AddVolatile: {
+    SplitQualType Split = BaseType.getSplitUnqualifiedType();
+    Qualifiers Quals = BaseType.getQualifiers();
+    if (BaseType->isReferenceType() || BaseType->isFunctionType())
+      return BaseType;
+    Quals.addVolatile();
+    QualType Underlying(Split.Ty, Quals.getAsOpaqueValue());
+    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>
 using add_const_t = __add_const(T);
 
 template <class T>
 constexpr bool check_add_cv() {
   static_assert(__is_same(__add_const(T), const T), "");
+  static_assert(__is_same(__add_volatile(T), volatile T), "");
   return true;
 }
 
 static_assert(check_add_cv<void>(), "");
 static_assert(check_add_cv<int>(), "");
 static_assert(check_add_cv<const int>(), "");
 static_assert(check_add_cv<volatile int>(), "");
 static_assert(check_add_cv<const volatile int>(), "");