[Clang] Support `address_space` attribute in `#pragma clang attribute

[egorzhdan]

Summary

This change adds support for type attributes (for example, address_space) in pragmas, so that the following code now compiles correctly:

#pragma clang attribute push (__attribute__ ((address_space(1))), apply_to=variable(is_global))

int var;

#pragma clang attribute pop

Since the attribute matching logic (attr::SubjectMatchRule) applies to an already constructed Decl, we first determine the declaration's type ignoring pragma attributes, then construct the Decl, and then recalculate its type if any type attribute was applied.

rdar://78269223

[aaron.ballman]

I am not particularly comfortable with allowing type attributes to be applied via #pragma clang attribute; the interface for that pragma is centered around declarations and not types, and I'm not certain how viable the idea is to shotgun blast out type attributes in practice.

For example, the way things are in this patch gives the user control over what *declarations* to apply the type attribute to. That's already a little confused -- these are type attributes, so (in general) they apply in places where types are named even when no declaration is involved: sizeof(type), alignof(type), etc. As a concrete example, this makes it easy to apply a calling convention type attribute to a function declaration, but would be very hard to also apply it to type casts. But this patch does not give the user control over what *types* to apply the type attribute to, either. Instead, it likely relies on the "if it can't be applied, it won't be applied" logic, which could get very costly for other type attributes. Consider a nullability type attribute that can only be applied to a pointer type -- there's no way to limit the application to just pointer types, let alone to just pointer types of a specific type.

I'd like some more justification as to why this functionality should be supported. If there's a strong case to be made for support it, then I think we can consider how the interface needs to change to support it. But as it stands, I'm not sold on that this is something we should do.

clang/test/AST/address_space_attribute.cpp

38–39

This looks like a bug -- address space attributes do not typically apply to a parameter: https://godbolt.org/z/rrfh5bnMe

[egorzhdan]

Thanks @aaron.ballman for your feedback. I will probably abandon this change until we have a more compelling reason to apply attributes to types via pragmas.

clang/include/clang/Basic/Attr.td

def AbiTag : Attr {
   let Subjects = SubjectList<[Struct, Var, Function, Namespace], ErrorDiag>;
   let MeaningfulToClassTemplateDefinition = 1;
   let Documentation = [AbiTagsDocs];
 }
 
 def AddressSpace : TypeAttr {
   let Spellings = [Clang<"address_space">];
   let Args = [IntArgument<"AddressSpace">];
+  let PragmaAttributeSupport = 1;
   let Documentation = [Undocumented];
 }
 
 def Alias : Attr {
   let Spellings = [GCC<"alias">];
   let Args = [StringArgument<"Aliasee">];
   let Subjects = SubjectList<[Function, GlobalVar], ErrorDiag>;
   let Documentation = [Undocumented];

clang/include/clang/Sema/Sema.h

public:
   void AddKnownFunctionAttributesForReplaceableGlobalAllocationFunction(
       FunctionDecl *FD);
   void AddKnownFunctionAttributes(FunctionDecl *FD);
 
   // More parsing and symbol table subroutines.
 
   void ProcessPragmaWeak(Scope *S, Decl *D);
   // Decl attributes - this routine is the top level dispatcher.
-  void ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD);
+  void ProcessDeclAttributes(Scope *S, Decl *D, Declarator &PD);
   // Helper for delayed processing of attributes.
   void ProcessDeclAttributeDelayed(Decl *D,
                                    const ParsedAttributesView &AttrList);
   void ProcessDeclAttributeList(Scope *S, Decl *D, const ParsedAttributesView &AL,
                              bool IncludeCXX11Attributes = true);
   bool ProcessAccessDeclAttributeList(AccessSpecDecl *ASDecl,
                                    const ParsedAttributesView &AttrList);
 

   /// Called on well-formed '\#pragma clang attribute pop'.
   void ActOnPragmaAttributePop(SourceLocation PragmaLoc,
                                const IdentifierInfo *Namespace);
 
   /// Adds the attributes that have been specified using the
   /// '\#pragma clang attribute push' directives to the given declaration.
   void AddPragmaAttributes(Scope *S, Decl *D);
 
+  /// Adds the type attributes (e.g. address_space) that have been specified
+  /// using the '\#pragma clang attribute push' directives to the given
+  /// declaration's type.
+  void AddPragmaTypeAttributes(Scope *TheScope, ValueDecl *TheDecl,
+                               Declarator &TheDeclarator);
+
   void DiagnoseUnterminatedPragmaAttribute();
 
   /// Called on well formed \#pragma clang optimize.
   void ActOnPragmaOptimize(bool On, SourceLocation PragmaLoc);
 
   /// Get the location for the currently active "\#pragma clang optimize
   /// off". If this location is invalid, then the state of the pragma is "on".
   SourceLocation getOptimizeOffPragmaLocation() const {

clang/lib/Sema/SemaAttr.cpp

void Sema::ActOnPragmaAttributePop(SourceLocation PragmaLoc,
 
   if (Namespace)
     Diag(PragmaLoc, diag::err_pragma_attribute_stack_mismatch)
         << 0 << Namespace->getName();
   else
     Diag(PragmaLoc, diag::err_pragma_attribute_stack_mismatch) << 1;
 }
 
-void Sema::AddPragmaAttributes(Scope *S, Decl *D) {
-  if (PragmaAttributeStack.empty())
+static void
+forEachPragmaAttribute(Sema *TheSema, Decl *TheDecl,
+                       llvm::function_ref<bool(ParsedAttr *)> Block) {
+  if (TheSema->PragmaAttributeStack.empty())
     return;
-  for (auto &Group : PragmaAttributeStack) {
+  for (auto &Group : TheSema->PragmaAttributeStack) {
     for (auto &Entry : Group.Entries) {
       ParsedAttr *Attribute = Entry.Attribute;
       assert(Attribute && "Expected an attribute");
       assert(Attribute->isPragmaClangAttribute() &&
              "expected #pragma clang attribute");
 
       // Ensure that the attribute can be applied to the given declaration.
       bool Applies = false;
       for (const auto &Rule : Entry.MatchRules) {
-        if (Attribute->appliesToDecl(D, Rule)) {
+        if (Attribute->appliesToDecl(TheDecl, Rule)) {
           Applies = true;
           break;
         }
       }
       if (!Applies)
         continue;
-      Entry.IsUsed = true;
-      PragmaAttributeCurrentTargetDecl = D;
-      ParsedAttributesView Attrs;
-      Attrs.addAtEnd(Attribute);
-      ProcessDeclAttributeList(S, D, Attrs);
-      PragmaAttributeCurrentTargetDecl = nullptr;
-    }
+      TheSema->PragmaAttributeCurrentTargetDecl = TheDecl;
+      Entry.IsUsed |= Block(Attribute);
+      TheSema->PragmaAttributeCurrentTargetDecl = nullptr;
+    }
+  }
+}
+
+void Sema::AddPragmaAttributes(Scope *S, Decl *D) {
+  forEachPragmaAttribute(this, D, [&](ParsedAttr *Attribute) {
+    if (Attribute->isTypeAttr())
+      return false;
+
+    return true;
+  });
+
+void Sema::AddPragmaTypeAttributes(Scope *TheScope, ValueDecl *TheDecl,
+                                   Declarator &TheDeclarator) {
+  bool AddedTypeAttrs = false;
+  forEachPragmaAttribute(this, TheDecl, [&](ParsedAttr *Attribute) {
+    if (!Attribute->isTypeAttr())
+      return false;
+
+    TheDeclarator.getAttributes().addAtEnd(Attribute);
+    AddedTypeAttrs = true;
+    return true;
+  });
+
+  if (AddedTypeAttrs) {
+    // Recalculate the type of the declaration after type attributes were added.
+    TypeSourceInfo *NewType = GetTypeForDeclarator(TheDeclarator, TheScope);
+    TheDecl->setType(NewType->getType());
   }
 }
 
 void Sema::PrintPragmaAttributeInstantiationPoint() {
   assert(PragmaAttributeCurrentTargetDecl && "Expected an active declaration");
   Diags.Report(PragmaAttributeCurrentTargetDecl->getBeginLoc(),
                diag::note_pragma_attribute_applied_decl_here);
 }

clang/lib/Sema/SemaDeclAttr.cpp

if (ND) {
       }
     }
   }
 }
 
 /// ProcessDeclAttributes - Given a declarator (PD) with attributes indicated in
 /// it, apply them to D.  This is a bit tricky because PD can have attributes
 /// specified in many different places, and we need to find and apply them all.
-void Sema::ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD) {
+void Sema::ProcessDeclAttributes(Scope *S, Decl *D, Declarator &PD) {
   // Apply decl attributes from the DeclSpec if present.
   if (!PD.getDeclSpec().getAttributes().empty())
     ProcessDeclAttributeList(S, D, PD.getDeclSpec().getAttributes());
 
   // Walk the declarator structure, applying decl attributes that were in a type
   // position to the decl itself.  This handles cases like:
   //   int *__attr__(x)** D;
   // when X is a decl attribute.
   for (unsigned i = 0, e = PD.getNumTypeObjects(); i != e; ++i)
     ProcessDeclAttributeList(S, D, PD.getTypeObject(i).getAttrs(),
                              /*IncludeCXX11Attributes=*/false);
 
   // Finally, apply any attributes on the decl itself.
   ProcessDeclAttributeList(S, D, PD.getAttributes());
 
   // Apply additional attributes specified by '#pragma clang attribute'.
   AddPragmaAttributes(S, D);
+  if (auto *VD = dyn_cast<ValueDecl>(D))
+    AddPragmaTypeAttributes(S, VD, PD);
 }
 
 /// Is the given declaration allowed to use a forbidden type?
 /// If so, it'll still be annotated with an attribute that makes it
 /// illegal to actually use.
 static bool isForbiddenTypeAllowed(Sema &S, Decl *D,
                                    const DelayedDiagnostic &diag,
                                    UnavailableAttr::ImplicitReason &reason) {

clang/test/AST/address_space_attribute.cpp

void func() {
 
   // CHECK: VarDecl {{.*}} z '__attribute__((address_space(3))) int *'
   [[clang::address_space(3)]] int *z;
 }
 
 void func2() {
   func<2>();
 }
+
+#pragma clang attribute push (__attribute__((address_space(4))), apply_to=variable(is_global))
+volatile int f;
+// CHECK: VarDecl {{.*}} 'volatile __attribute__((address_space(4))) int'
+#pragma clang attribute pop
+
+#pragma clang attribute push (__attribute__((address_space(5))), apply_to=variable(is_parameter))
+void func3(volatile int g) {}
+// CHECK: ParmVarDecl {{.*}} 'volatile __attribute__((address_space(5))) int'
+#pragma clang attribute pop
+
+#pragma clang attribute push (__attribute__((address_space(6))), apply_to=field)
+volatile int g;
+// Verify that the attribute is not applied to a declaration that does not match the filter.
+// CHECK: VarDecl {{.*}} 'volatile int'
+#pragma clang attribute pop

clang/test/Misc/pragma-attribute-supported-attributes-list.test

 // RUN: clang-tblgen -gen-clang-test-pragma-attribute-supported-attributes -I%src_include_dir %src_include_dir/clang/Basic/Attr.td -o - | FileCheck %s
 
 // The number of supported attributes should never go down!
 
 // CHECK: #pragma clang attribute supports the following attributes:
 // CHECK-NEXT: AMDGPUFlatWorkGroupSize (SubjectMatchRule_function)
 // CHECK-NEXT: AMDGPUNumSGPR (SubjectMatchRule_function)
 // CHECK-NEXT: AMDGPUNumVGPR (SubjectMatchRule_function)
 // CHECK-NEXT: AMDGPUWavesPerEU (SubjectMatchRule_function)
 // CHECK-NEXT: AVRSignal (SubjectMatchRule_function)
 // CHECK-NEXT: AbiTag (SubjectMatchRule_record_not_is_union, SubjectMatchRule_variable, SubjectMatchRule_function, SubjectMatchRule_namespace)
 // CHECK-NEXT: AcquireHandle (SubjectMatchRule_function, SubjectMatchRule_type_alias, SubjectMatchRule_variable_is_parameter)
+// CHECK-NEXT: AddressSpace ()
 // CHECK-NEXT: Alias (SubjectMatchRule_function, SubjectMatchRule_variable_is_global)
 // CHECK-NEXT: AlignValue (SubjectMatchRule_variable, SubjectMatchRule_type_alias)
 // CHECK-NEXT: AlwaysDestroy (SubjectMatchRule_variable)
 // CHECK-NEXT: AlwaysInline (SubjectMatchRule_function)
 // CHECK-NEXT: Annotate ()
 // CHECK-NEXT: AnyX86NoCfCheck (SubjectMatchRule_hasType_functionType)
 // CHECK-NEXT: ArcWeakrefUnavailable (SubjectMatchRule_objc_interface)
 // CHECK-NEXT: ArmBuiltinAlias (SubjectMatchRule_function)

clang/test/Parser/pragma-attribute.cpp

 int x = 0;
 _Pragma("clang attribute push (__attribute__((annotate(\"hi\"))), apply_to = function)");
 
 _Pragma("clang attribute push (__attribute__((annotate(\"hi\"))), apply_to = any(function(is_method ))"); // expected-error {{expected ')'}}
 }
 
 _Pragma("clang attribute pop");
 
-#pragma clang attribute push (__attribute__((address_space(0))), apply_to=variable) // expected-error {{attribute 'address_space' is not supported by '#pragma clang attribute'}}
-
 // Check support for CXX11 style attributes
 #pragma clang attribute push ([[noreturn]], apply_to = any(function))
 #pragma clang attribute pop
 
 #pragma clang attribute push ([[clang::disable_tail_calls]], apply_to = function)
 #pragma clang attribute pop
 
 #pragma clang attribute push ([[gnu::abi_tag]], apply_to=any(function))