[Clang] Add addrsig attribute to mark global functions/variables as address significant.

[zequanwu]

Summary

Functions or variables with this attribute will not have local_unnamed_addr/unnamed_addr in IR. So, they will show up in address-significant table.

[zequanwu]

Split clang change and IR change.

[aaron.ballman]

I'm not opposed to the attribute per se, but I'd like to understand the motivation behind it a bit more. It seems like it solves a special edge case for a specific linker and I'm wondering if that's sufficient motivation for the community to support the attribute or not.

clang/test/Sema/attr-addrsig.c

8

You should also have a test that the attribute does not accept any arguments.

[zequanwu]

This overlaps with the functionality of attribute used.

clang/include/clang/Basic/Attr.td

 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 Addrsig : InheritableAttr {
+  let Spellings = [Clang<"addrsig">];
+  let Documentation = [AddrsigDocs];
+  let Subjects = SubjectList<[Function, Var]>;
+  let SimpleHandler = 1;
+}
+
 def FastCall : DeclOrTypeAttr {
   let Spellings = [GCC<"fastcall">, Keyword<"__fastcall">,
                    Keyword<"_fastcall">];
 //  let Subjects = [Function, ObjCMethod];
   let Documentation = [FastCallDocs];
 }
 
 def RegCall : DeclOrTypeAttr {

clang/include/clang/Basic/AttrDocs.td

 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 AddrsigDocs : Documentation {
+  let Category = DocCatFunction;
+  let Content = [{
+Functions or variables attached with ``addrsig`` will be put into the
+address-significant table, which disables identical code folding (ICF) on 
+setions in it (only useful when linking with lld). For the COFF port of lld, the
+default icf (``/OPT:safeicf``) will fold code sections regardless the existance 
+of address-significant table. So, ``/OPT:safeicf`` is needed if you don't want 
+code sections folding when they are in the table.
+  }];
+}
+
 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
 the program if it is not held.
   }];
 }

clang/lib/CodeGen/CodeGenModule.cpp

void CodeGenModule::SetFunctionAttributes(GlobalDecl GD, llvm::Function *F,
   }
 
   if (isa<CXXConstructorDecl>(FD) || isa<CXXDestructorDecl>(FD))
     F->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
   else if (const auto *MD = dyn_cast<CXXMethodDecl>(FD))
     if (MD->isVirtual())
       F->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
 
+  if (FD->hasAttr<AddrsigAttr>())
+    F->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Significant);
+
   // Don't emit entries for function declarations in the cross-DSO mode. This
   // is handled with better precision by the receiving DSO. But if jump tables
   // are non-canonical then we need type metadata in order to produce the local
   // jump table.
   if (!CodeGenOpts.SanitizeCfiCrossDso ||
       !CodeGenOpts.SanitizeCfiCanonicalJumpTables)
     CreateFunctionTypeMetadataForIcall(FD, F);
 
if (!GV || GV->getValueType() != InitType ||
     cast<llvm::GlobalValue>(Entry)->eraseFromParent();
   }
 
   MaybeHandleStaticInExternC(D, GV);
 
   if (D->hasAttr<AnnotateAttr>())
     AddGlobalAnnotations(D, GV);
 
+  if (D->hasAttr<AddrsigAttr>())
+    GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Significant);
+
   // Set the llvm linkage type as appropriate.
   llvm::GlobalValue::LinkageTypes Linkage =
       getLLVMLinkageVarDefinition(D, GV->isConstant());
 
   // CUDA B.2.1 "The __device__ qualifier declares a variable that resides on
   // the device. [...]"
   // CUDA B.2.2 "The __constant__ qualifier, optionally used together with
   // __device__, declares a variable that: [...]

clang/test/CodeGenCXX/attr-addrsig.cpp

+// RUN: %clang_cc1 -S -emit-llvm %s -triple x86_64-unknown-linux-gnu -O2 -o - | FileCheck %s
+
+// CHECK: @i1 = {{.*}}unnamed_addr
+// CHECK-NEXT: @i2 = {{.*}}unnamed_addr
+int i1;
+int i2 = 0;
+
+// CHECK: @i3 = {{.*}}significant_addr
+// CHECK-NEXT: @i4 = {{.*}}significant_addr
+[[clang::addrsig]] int i3;
+[[clang::addrsig]] int i4 = 0;
+
+// CHECK-DAG: declare void @_Z2f1i{{.*}}unnamed_addr
+void f1(int i);
+// CHECK-DAG: define dso_local i32 @_Z2f2i{{.*}}unnamed_addr
+int f2(int i) {
+    f1(i);
+    return i * 2;
+}
+
+// CHECK-DAG: declare void @_Z2f3i{{.*}}significant_addr
+[[clang::addrsig]] void f3(int i);
+void f3(int i);
+// CHECK-DAG: define dso_local i32 @_Z2f4i{{.*}}significant_addr
+[[clang::addrsig]] int f4(int i) {
+    f3(i);
+    return i * 2;
+}
+
+
+// CHECK-DAG: declare void @_ZN1AC1Ev{{.*}}unnamed_addr
+// CHECK-DAG: declare void @_ZN1AD1Ev{{.*}}unnamed_addr
+// CHECK-DAG: declare void @_ZN1A2f1Ev{{.*}}unnamed_addr
+// CHECK-DAG: declare void @_ZN1A2f2Ev{{.*}}unnamed_addr
+
+// CHECK-DAG: declare void @_ZN1BC1Ev{{.*}}significant_addr
+// CHECK-DAG: declare void @_ZN1BD1Ev{{.*}}significant_addr
+// CHECK-DAG: declare void @_ZN1B2f1Ev{{.*}}significant_addr
+// CHECK-DAG: declare void @_ZN1B2f2Ev{{.*}}significant_addr
+struct A {
+    A();
+    ~A();
+    void f1();
+    virtual void f2();
+};
+
+struct B {
+    [[clang::addrsig]] B();
+    [[clang::addrsig]] ~B();
+    [[clang::addrsig]] void f1();
+    [[clang::addrsig]] virtual void f2();
+};
+
+void test() {
+    A a;
+    B b;
+    a.f1();
+    a.f2();
+    b.f1();
+    b.f2();
+}

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: Addrsig (SubjectMatchRule_function, SubjectMatchRule_variable)
 // CHECK-NEXT: Alias (SubjectMatchRule_function, SubjectMatchRule_variable_is_global)
 // CHECK-NEXT: AlignValue (SubjectMatchRule_variable, SubjectMatchRule_type_alias)
 // CHECK-NEXT: AllocSize (SubjectMatchRule_function)
 // 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)

clang/test/Sema/attr-addrsig.c

+// RUN: %clang_cc1 -verify -fsyntax-only %s
+
+__attribute__((addrsig)) int i;
+
+__attribute__((addrsig)) void f();
+__attribute__((addrsig)) void g() {}
+
+struct __attribute__((addrsig)) A {}; // expected-warning {{'addrsig' attribute only applies to functions and variables}}