[Clang] Make nomerge attribute a function attribute as well as a statement attribute.

[zequanwu]

Summary

Make nomerge attribute a function attribute as well as a statement attribute to extend the functionality of nomerge attribute.

For functions already have nomerge attribute, don't add nomerge attribute at the call-site of this function.

[zequanwu]

start a new diff to make nomerge attribute a function attribute as well as a statement attribute.

[rnk]

Nice, that wasn't too difficult. I had some suggestions for improving the test case, and I'd like to hear from Aaron.

clang/test/CodeGen/attr-nomerge.cpp

8

Hm, virtual functions, there's something worth thinking about. In this case, the attribute must appear on the call site if we want it to work as the user expects. I don't see the indirect call site for the virtual call in the IR below. I think it's worth testing for that. Consider taking A* and B* parameters to defeat any frontend devirtualization optimizations.

17

I would leave this declaration as it was, so that all the statement attribute test cases you wrote below remain as they were, and the attribute continues to appear at the call site.

The f declaration below gives you coverage of the free function declaration case.

[zequanwu]

Add test for virutal function.

clang/test/CodeGen/attr-nomerge.cpp

8

If devirtualization failed, then only statement attribute would work.

[zequanwu]

clang/test/CodeGen/attr-nomerge.cpp

17

I added [[clang::nomerge]] to bar in order to test that the generated IR should attach nomerge to call-sites which callee function already has this attribute.

[rnk]

clang/test/CodeGen/attr-nomerge.cpp

8

Fair enough, that is similar to how not_tail_called works. Can you also update AttrDocs.td to mention the limitation?

17

Well, from the tests below, it seems like the attribute is *not* present on the call sites. Is that what you intended?

[zequanwu]

Add docs.

clang/test/CodeGen/attr-nomerge.cpp

17

oops, I meant "shouldn't attach", because it's not necessary to have it.

[aaron.ballman]

In general, I think this is reasonable -- there's a bit more work to be done before it's ready to land, but this is heading in the right direction.

clang/include/clang/Basic/Attr.td

562

I think this should be an InheritableAttr, like DeclOrTypeAttr. With type/decl attributes, those are almost always for things like calling conventions or other cases where inheritance of the attribute is really likely to be the correct default. It's less clear to me that the same is true for stmt/decl attributes aside from the observation that most decl attributes are inheritable. We may need to come up with a better approach for inheritance here at some point when we find a stmt/decl attribute that should not be inheritable.

clang/lib/Sema/SemaDeclAttr.cpp

2260

No need for this function, you can set let SimpleHandler = 1; in Attr.td -- the common attribute handler code should handle checking the subject list for you automatically.

7914

Then this can become handleSimpleAttribute<NoMergeAttr>(S, D, AL);

clang/test/CodeGen/attr-nomerge.cpp

91

Can you also add a test case to demonstrate that inheriting the attribute on a later redeclaration works? It can either be a codegen test or an AST dump test.

clang/test/Sema/attr-nomerge.cpp

11

This diagnostic is no longer correct -- nomerge now applies to more things. You may need to teach the clang attribute emitter about stmt/decl attribute types so that it can generate a better diagnostic in diagnoseAppertainsTo().

[zequanwu]

address comments.

clang/test/CodeGen/attr-nomerge.cpp

91

Do you mean something like this?

[aaron.ballman]

clang/include/clang/Basic/Attr.td

1326

Related to my comments in ClangAttrEmitter.cpp, I think you should make these changes instead.

clang/test/CodeGen/attr-nomerge.cpp

91

Close. I was thinking something like:

int g(int i); // No attr

void something() {
  // call g() here
}

[[clang::nomerge]] int g(int i);

void something_else() {
  // call g() here
}

int g(int i) { return i; }

void something_else_again() {
  // call g() here
}

So this tests that the attribute is inherited on redeclarations properly and it also tests the merging behavior when the declaration may not have yet had the attribute attached.

clang/utils/TableGen/ClangAttrEmitter.cpp

3449–3450

I think this will do the wrong thing when the subject list has more than one entry (I think this will add statements to the list once for each subject). As an experiment, can you add ObjCMethod to the list of subjects for NoMerge in Attr.td? Do the resulting diagnostics list "statements" once or twice?

Thinking a bit deeper on this -- I think my original advice may have been too ambitious (we don't yet have support for automatically grabbing the names of statements for diagnostics like we do for declarations). Trying to add that as part of this patch would be a big ask, so I think a better approach is to use a custom diagnostic in Attr.td. I'll add a comment there to this effect.

[zequanwu]

address comments.

clang/utils/TableGen/ClangAttrEmitter.cpp

3449–3450

You're right. If I just add ObjCMethod to the list of subjects for NoMerge, the "statements" shows twice in the diag.

[aaron.ballman]

LGTM! Thank you for this!

clang/include/clang/AST/Attr.h

public:
 
   // Implement isa/cast/dyncast/etc.
   static bool classof(const Attr *A) {
     return A->getKind() >= attr::FirstInheritableAttr &&
            A->getKind() <= attr::LastInheritableAttr;
   }
 };
 
+class DeclOrStmtAttr : public InheritableAttr {
+protected:
+  DeclOrStmtAttr(ASTContext &Context, const AttributeCommonInfo &CommonInfo,
+                 attr::Kind AK, bool IsLateParsed,
+                 bool InheritEvenIfAlreadyPresent)
+      : InheritableAttr(Context, CommonInfo, AK, IsLateParsed,
+                        InheritEvenIfAlreadyPresent) {}
+
+public:
+  static bool classof(const Attr *A) {
+    return A->getKind() >= attr::FirstDeclOrStmtAttr &&
+           A->getKind() <= attr::LastDeclOrStmtAttr;
+  }
+};
+
 class InheritableParamAttr : public InheritableAttr {
 protected:
   InheritableParamAttr(ASTContext &Context,
                        const AttributeCommonInfo &CommonInfo, attr::Kind AK,
                        bool IsLateParsed, bool InheritEvenIfAlreadyPresent)
       : InheritableAttr(Context, CommonInfo, AK, IsLateParsed,
                         InheritEvenIfAlreadyPresent) {}
 

clang/include/clang/Basic/Attr.td

 
 /// A type attribute is not processed on a declaration or a statement.
 class TypeAttr : Attr;
 
 /// A stmt attribute is not processed on a declaration or a type.
 class StmtAttr : Attr;
 
 /// An inheritable attribute is inherited by later redeclarations.
 class InheritableAttr : Attr {
   // Set to true if this attribute can be duplicated on a subject when inheriting
   // attributes from prior declarations.
   bit InheritEvenIfAlreadyPresent = 0;
 }
 
 /// Some attributes, like calling conventions, can appear in either the
 /// declaration or the type position. These attributes are morally type
 /// attributes, but have historically been written on declarations.
 class DeclOrTypeAttr : InheritableAttr;
 
+/// A attribute is either a declaration attribute or a statement attribute.
+class DeclOrStmtAttr : InheritableAttr;
+
 /// A target-specific attribute.  This class is meant to be used as a mixin
 /// with InheritableAttr or Attr depending on the attribute's needs.
 class TargetSpecificAttr<TargetSpec target> {
   TargetSpec Target = target;
   // Attributes are generally required to have unique spellings for their names
   // so that the parser can determine what kind of attribute it has parsed.
   // However, target-specific attributes are special in that the attribute only
   // "exists" for a given target. So two target-specific attributes can share
def Likely : StmtAttr {
   let Documentation = [LikelihoodDocs];
 }
 
 def Unlikely : StmtAttr {
   let Spellings = [CXX11<"", "unlikely", 201803>, C2x<"clang", "unlikely">];
   let Documentation = [LikelihoodDocs];
 }
 
-def NoMerge : StmtAttr {
+def NoMerge : DeclOrStmtAttr {
   let Spellings = [Clang<"nomerge">];
   let Documentation = [NoMergeDocs];
+  let InheritEvenIfAlreadyPresent = 1;
+  let Subjects = SubjectList<[Function], ErrorDiag, "functions and statements">;
+  let SimpleHandler = 1;
 }
 
 def FastCall : DeclOrTypeAttr {
   let Spellings = [GCC<"fastcall">, Keyword<"__fastcall">,
                    Keyword<"_fastcall">];
 //  let Subjects = [Function, ObjCMethod];
   let Documentation = [FastCallDocs];
 }

clang/include/clang/Basic/AttrDocs.td

def NoMergeDocs : Documentation {
   let Content = [{
 If a statement is marked ``nomerge`` and contains call expressions, those call
 expressions inside the statement will not be merged during optimization. This 
 attribute can be used to prevent the optimizer from obscuring the source
 location of certain calls. For example, it will prevent tail merging otherwise
 identical code sequences that raise an exception or terminate the program. Tail
 merging normally reduces the precision of source location information, making
 stack traces less useful for debugging. This attribute gives the user control
-over the tradeoff between code size and debug information precision.
+over the tradeoff between code size and debug information precision. 
+
+``nomerge`` attribute can also be used as function attribute to prevent all 
+calls to the specified function from merging. It has no effect on indirect 
+calls.
   }];
 }
 
 def AssertCapabilityDocs : Documentation {
   let Category = DocCatFunction;
   let Heading = "assert_capability, assert_shared_capability";
   let Content = [{
 Marks a function that dynamically tests whether a capability is held, and halts

clang/lib/CodeGen/CGCall.cpp

if (const FunctionDecl *Fn = dyn_cast<FunctionDecl>(TargetDecl)) {
       const bool IsVirtualCall = MD && MD->isVirtual();
       // Don't use [[noreturn]], _Noreturn or [[no_builtin]] for a call to a
       // virtual function. These attributes are not inherited by overloads.
       if (!(AttrOnCallSite && IsVirtualCall)) {
         if (Fn->isNoReturn())
           FuncAttrs.addAttribute(llvm::Attribute::NoReturn);
         NBA = Fn->getAttr<NoBuiltinAttr>();
       }
+      if (!AttrOnCallSite && TargetDecl->hasAttr<NoMergeAttr>())
+        FuncAttrs.addAttribute(llvm::Attribute::NoMerge);
     }
 
     // 'const', 'pure' and 'noalias' attributed functions are also nounwind.
     if (TargetDecl->hasAttr<ConstAttr>()) {
       FuncAttrs.addAttribute(llvm::Attribute::ReadNone);
       FuncAttrs.addAttribute(llvm::Attribute::NoUnwind);
     } else if (TargetDecl->hasAttr<PureAttr>()) {
       FuncAttrs.addAttribute(llvm::Attribute::ReadOnly);
#endif
 
   if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(CurFuncDecl))
     if (FD->hasAttr<StrictFPAttr>())
       // All calls within a strictfp function are marked strictfp
       Attrs =
         Attrs.addAttribute(getLLVMContext(), llvm::AttributeList::FunctionIndex,
                            llvm::Attribute::StrictFP);
 
-  // Add call-site nomerge attribute if exists.
-  if (InNoMergeAttributedStmt)
-    Attrs =
-      Attrs.addAttribute(getLLVMContext(), llvm::AttributeList::FunctionIndex,
+  // Add nomerge attribute to the call-site if the callee function doesn't have
+  // the attribute.
+  if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(TargetDecl))
+    if (!FD->hasAttr<NoMergeAttr>() && InNoMergeAttributedStmt)
+      Attrs = Attrs.addAttribute(getLLVMContext(),
+                                 llvm::AttributeList::FunctionIndex,
                                  llvm::Attribute::NoMerge);
 
   // Apply some call-site-specific attributes.
   // TODO: work this into building the attribute set.
 
   // Apply always_inline to all calls within flatten functions.
   // FIXME: should this really take priority over __try, below?
   if (CurCodeDecl && CurCodeDecl->hasAttr<FlattenAttr>() &&
       !(TargetDecl && TargetDecl->hasAttr<NoInlineAttr>())) {

clang/lib/CodeGen/CodeGenModule.cpp

if (D->hasAttr<ColdAttr>()) {
         B.addAttribute(llvm::Attribute::OptimizeForSize);
       B.addAttribute(llvm::Attribute::Cold);
     }
 
     if (D->hasAttr<MinSizeAttr>())
       B.addAttribute(llvm::Attribute::MinSize);
   }
 
+  if (D->hasAttr<NoMergeAttr>())
+    B.addAttribute(llvm::Attribute::NoMerge);
+
   F->addAttributes(llvm::AttributeList::FunctionIndex, B);
 
   unsigned alignment = D->getMaxAlignment() / Context.getCharWidth();
   if (alignment)
     F->setAlignment(llvm::Align(alignment));
 
   if (!D->hasAttr<AlignedAttr>())
     if (LangOpts.FunctionAlignment)

clang/lib/Sema/SemaDeclAttr.cpp

static void handleDestructorAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
   uint32_t priority = DestructorAttr::DefaultPriority;
   if (AL.getNumArgs() &&
       !checkUInt32Argument(S, AL, AL.getArgAsExpr(0), priority))
     return;
 
   D->addAttr(::new (S.Context) DestructorAttr(S.Context, AL, priority));
 }
 
 template <typename AttrTy>
 static void handleAttrWithMessage(Sema &S, Decl *D, const ParsedAttr &AL) {
   // Handle the case where the attribute has a text message.
   StringRef Str;
   if (AL.getNumArgs() == 1 && !S.checkStringLiteralArgumentAttr(AL, 0, Str))
     return;
 
   D->addAttr(::new (S.Context) AttrTy(S.Context, AL, Str));
 }
static void ProcessDeclAttribute(Sema &S, Scope *scope, Decl *D,
   case ParsedAttr::AT_NotTailCalled:
     handleSimpleAttributeWithExclusions<NotTailCalledAttr, AlwaysInlineAttr>(
         S, D, AL);
     break;
   case ParsedAttr::AT_DisableTailCalls:
     handleSimpleAttributeWithExclusions<DisableTailCallsAttr, NakedAttr>(S, D,
                                                                          AL);
     break;
+  case ParsedAttr::AT_NoMerge:
+    handleSimpleAttribute<NoMergeAttr>(S, D, AL);
+    break;
   case ParsedAttr::AT_Visibility:
     handleVisibilityAttr(S, D, AL, false);
     break;
   case ParsedAttr::AT_TypeVisibility:
     handleVisibilityAttr(S, D, AL, true);
     break;
   case ParsedAttr::AT_WarnUnusedResult:
     handleWarnUnusedResult(S, D, AL);

clang/test/CodeGen/attr-nomerge.cpp

 // RUN: %clang_cc1 -S -emit-llvm %s -triple x86_64-unknown-linux-gnu -o - | FileCheck %s
 
-bool bar();
-void f(bool, bool);
+class A {
+public:
+  [[clang::nomerge]] A();
+  [[clang::nomerge]] ~A();
+  [[clang::nomerge]] void f();
+  [[clang::nomerge]] virtual void g();
+  [[clang::nomerge]] static void f1();
+};
 
-void foo(int i) {
+class B : public A {
+public:
+  void g() override;
+};
+
+[[clang::nomerge]] bool bar();
+[[clang::nomerge]] void f(bool, bool);
+
+void foo(int i, A *ap, B *bp) {
   [[clang::nomerge]] bar();
   [[clang::nomerge]] (i = 4, bar());
   [[clang::nomerge]] (void)(bar());
   [[clang::nomerge]] f(bar(), bar());
   [[clang::nomerge]] [] { bar(); bar(); }(); // nomerge only applies to the anonymous function call
   [[clang::nomerge]] for (bar(); bar(); bar()) {}
   [[clang::nomerge]] { asm("nop"); }
   bar();
+
+  ap->g();
+  bp->g();
+
+  A a;
+  a.f();
+  a.g();
+  A::f1();
+
+  B b;
+  b.g();
+}
+
+int g(int i);
+
+void something() {
+  g(1);
+}
+
+[[clang::nomerge]] int g(int i);
+
+void something_else() {
+  g(1);
+}
+
+int g(int i) { return i; }
+
+void something_else_again() {
+  g(1);
 }
-// CHECK: call zeroext i1 @_Z3barv() #[[NOMERGEATTR:[0-9]+]]
-// CHECK: call zeroext i1 @_Z3barv() #[[NOMERGEATTR]]
-// CHECK: call zeroext i1 @_Z3barv() #[[NOMERGEATTR]]
-// CHECK: call zeroext i1 @_Z3barv() #[[NOMERGEATTR]]
-// CHECK: call zeroext i1 @_Z3barv() #[[NOMERGEATTR]]
-// CHECK: call void @_Z1fbb({{.*}}) #[[NOMERGEATTR]]
-// CHECK: call void @"_ZZ3fooiENK3$_0clEv"(%class.anon* {{[^,]*}} %ref.tmp) #[[NOMERGEATTR]]
-// CHECK: call zeroext i1 @_Z3barv() #[[NOMERGEATTR]]
-// CHECK: call zeroext i1 @_Z3barv() #[[NOMERGEATTR]]
-// CHECK: call zeroext i1 @_Z3barv() #[[NOMERGEATTR]]
-// CHECK: call void asm {{.*}} #[[NOMERGEATTR2:[0-9]+]]
-// CHECK: call zeroext i1 @_Z3barv()
-// CHECK: attributes #[[NOMERGEATTR]] = { nomerge }
-// CHECK: attributes #[[NOMERGEATTR2]] = { nomerge nounwind }
+
+// CHECK: call zeroext i1 @_Z3barv(){{$}}
+// CHECK: call zeroext i1 @_Z3barv(){{$}}
+// CHECK: call zeroext i1 @_Z3barv(){{$}}
+// CHECK: call zeroext i1 @_Z3barv(){{$}}
+// CHECK: call zeroext i1 @_Z3barv(){{$}}
+// CHECK: call void @_Z1fbb({{.*}}){{$}}
+// CHECK: call void @"_ZZ3fooiP1AP1BENK3$_0clEv"{{.*}} #[[ATTR0:[0-9]+]]
+// CHECK: call zeroext i1 @_Z3barv(){{$}}
+// CHECK: call zeroext i1 @_Z3barv(){{$}}
+// CHECK: call zeroext i1 @_Z3barv(){{$}}
+// CHECK: call void asm sideeffect "nop"{{.*}} #[[ATTR1:[0-9]+]]
+// CHECK: call zeroext i1 @_Z3barv(){{$}}
+// CHECK: %[[AG:.*]] = load void (%class.A*)*, void (%class.A*)**
+// CHECK-NEXT: call void %[[AG]](%class.A* nonnull dereferenceable
+// CHECK: %[[BG:.*]] = load void (%class.B*)*, void (%class.B*)**
+// CHECK-NEXT: call void %[[BG]](%class.B* nonnull dereferenceable
+
+
+// CHECK-DAG: declare zeroext i1 @_Z3barv() #[[ATTR2:[0-9]+]]
+// CHECK-DAG: declare void @_Z1fbb(i1 zeroext, i1 zeroext) #[[ATTR2]]
+// CHECK-DAG: declare void @_ZN1AC1Ev{{.*}} #[[ATTR2]]
+// CHECK-DAG: declare void @_ZN1A1fEv{{.*}} #[[ATTR2]]
+// CHECK-DAG: declare void @_ZN1A1gEv{{.*}} #[[ATTR2]]
+// CHECK-DAG: declare void @_ZN1A2f1Ev{{.*}} #[[ATTR2]]
+// CHECK-DAG: declare void @_ZN1AC2Ev{{.*}} #[[ATTR2]]
+// CHECK-DAG: declare void @_ZN1AD1Ev{{.*}} #[[ATTR3:[0-9]+]]
+// CHECK-DAG: declare void @_ZN1AD2Ev{{.*}} #[[ATTR3]]
+// CHECK-DAG: define i32 @_Z1gi(i32 %i) #[[ATTR4:[0-9]+]] {
+
+// CHECK-DAG: attributes #[[ATTR0]] = {{{.*}}nomerge{{.*}}}
+// CHECK-DAG: attributes #[[ATTR1]] = {{{.*}}nomerge{{.*}}}
+// CHECK-DAG: attributes #[[ATTR2]] = {{{.*}}nomerge{{.*}}}
+// CHECK-DAG: attributes #[[ATTR3]] = {{{.*}}nomerge{{.*}}}
+// CHECK-DAG: attributes #[[ATTR4]] = {{{.*}}nomerge{{.*}}}

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

 // CHECK-NEXT: NoBuiltin (SubjectMatchRule_function)
 // CHECK-NEXT: NoCommon (SubjectMatchRule_variable)
 // CHECK-NEXT: NoDebug (SubjectMatchRule_type_alias, SubjectMatchRule_hasType_functionType, SubjectMatchRule_objc_method, SubjectMatchRule_variable_not_is_parameter)
 // CHECK-NEXT: NoDestroy (SubjectMatchRule_variable)
 // CHECK-NEXT: NoDuplicate (SubjectMatchRule_function)
 // CHECK-NEXT: NoEscape (SubjectMatchRule_variable_is_parameter)
 // CHECK-NEXT: NoInline (SubjectMatchRule_function)
 // CHECK-NEXT: NoInstrumentFunction (SubjectMatchRule_function)
+// CHECK-NEXT: NoMerge (SubjectMatchRule_function)
 // CHECK-NEXT: NoMicroMips (SubjectMatchRule_function)
 // CHECK-NEXT: NoMips16 (SubjectMatchRule_function)
 // CHECK-NEXT: NoSanitize (SubjectMatchRule_function, SubjectMatchRule_objc_method, SubjectMatchRule_variable_is_global)
 // CHECK-NEXT: NoSanitizeSpecific (SubjectMatchRule_function, SubjectMatchRule_variable_is_global)
 // CHECK-NEXT: NoSpeculativeLoadHardening (SubjectMatchRule_function, SubjectMatchRule_objc_method)
 // CHECK-NEXT: NoSplitStack (SubjectMatchRule_function)
 // CHECK-NEXT: NoStackProtector (SubjectMatchRule_function)
 // CHECK-NEXT: NoThreadSafetyAnalysis (SubjectMatchRule_function)

clang/test/Sema/attr-nomerge.cpp

 // RUN: %clang_cc1 -verify -fsyntax-only %s
 
 void bar();
 
 void foo() {
   [[clang::nomerge]] bar();
   [[clang::nomerge(1, 2)]] bar(); // expected-error {{'nomerge' attribute takes no arguments}}
   int x;
   [[clang::nomerge]] x = 10; // expected-warning {{nomerge attribute is ignored because there exists no call expression inside the statement}}
 
-  [[clang::nomerge]] label: bar(); // expected-error {{'nomerge' attribute cannot be applied to a declaration}}
+  [[clang::nomerge]] label: bar(); // expected-error {{'nomerge' attribute only applies to functions and statements}}
 
 }
 
-int f();
+[[clang::nomerge]] int f();
 
-[[clang::nomerge]] static int i = f(); // expected-error {{'nomerge' attribute cannot be applied to a declaration}}
+[[clang::nomerge]] static int i = f(); // expected-error {{'nomerge' attribute only applies to functions and statements}}

clang/utils/TableGen/ClangAttrEmitter.cpp

namespace {
   };
 
 } // end anonymous namespace
 
 static const AttrClassDescriptor AttrClassDescriptors[] = {
   { "ATTR", "Attr" },
   { "TYPE_ATTR", "TypeAttr" },
   { "STMT_ATTR", "StmtAttr" },
+  { "DECL_OR_STMT_ATTR", "DeclOrStmtAttr" },
   { "INHERITABLE_ATTR", "InheritableAttr" },
   { "DECL_OR_TYPE_ATTR", "DeclOrTypeAttr" },
   { "INHERITABLE_PARAM_ATTR", "InheritableParamAttr" },
   { "PARAMETER_ABI_ATTR", "ParameterABIAttr" }
 };
 
 static void emitDefaultDefine(raw_ostream &OS, StringRef name,
                               const char *superName) {
for (const auto *Subject : Subjects) {
     } else {
       // The node may contain a list of elements itself, so split the elements
       // by a comma, and trim any whitespace.
       SmallVector<StringRef, 2> Frags;
       llvm::SplitString(V, Frags, ",");
       for (auto Str : Frags) {
         DiagList.push_back(std::string(Str.trim()));
       }
     }
   }
 
   if (DiagList.empty()) {
     PrintFatalError(S.getLoc(),
                     "Could not deduce diagnostic argument for Attr subjects");
     return "";
   }
 
   // FIXME: this is not particularly good for localization purposes and ideally
for (auto I = Attrs.begin(), E = Attrs.end(); I != E; ++I) {
     OS << "    HasCustomParsing = ";
     OS << Attr.getValueAsBit("HasCustomParsing") << ";\n";
     OS << "    IsTargetSpecific = ";
     OS << Attr.isSubClassOf("TargetSpecificAttr") << ";\n";
     OS << "    IsType = ";
     OS << (Attr.isSubClassOf("TypeAttr") ||
            Attr.isSubClassOf("DeclOrTypeAttr")) << ";\n";
     OS << "    IsStmt = ";
-    OS << Attr.isSubClassOf("StmtAttr") << ";\n";
+    OS << (Attr.isSubClassOf("StmtAttr") || Attr.isSubClassOf("DeclOrStmtAttr"))
+       << ";\n";
     OS << "    IsKnownToGCC = ";
     OS << IsKnownToGCC(Attr) << ";\n";
     OS << "    IsSupportedByPragmaAttribute = ";
     OS << PragmaAttributeSupport.isAttributedSupported(*I->second) << ";\n";
     if (!Spellings.empty())
       OS << "    Spellings = " << I->first << "Spellings;\n";
     OS << "  }\n";
     GenerateAppertainsTo(Attr, OS);

llvm/include/llvm/IR/Attributes.td

 def NoImplicitFloat : EnumAttr<"noimplicitfloat">;
 
 /// inline=never.
 def NoInline : EnumAttr<"noinline">;
 
 /// Function is called early and/or often, so lazy binding isn't worthwhile.
 def NonLazyBind : EnumAttr<"nonlazybind">;
 
-/// Disable merging for call sites
+/// Disable merging for specified functions or call sites.
 def NoMerge : EnumAttr<"nomerge">;
 
 /// Pointer is known to be not null.
 def NonNull : EnumAttr<"nonnull">;
 
 /// The function does not recurse.
 def NoRecurse : EnumAttr<"norecurse">;