[Clang][Attribute] Introduce linkage attribute to specify the exact LLVM linkage type for functions or variables

[strimo378]

Summary

Currently, it is not possible to specify all available LLVM linkage types of variables or functions from the C programming language. This patch adds a linkage attribute (__attribute__((linkage("...")))__) that allows to specify the LLVM linkage type https://llvm.org/docs/LangRef.html#linkage-types via an attribute. It is similar to the visible attribute that allows to specify the LLVM visibility styles.

The attribute is dominant and overrides any linkage type specified by other specifiers (e.g. static) or attributes (e.g. __attribute__((weak))).

There was a previous discussion about adding a linkonce_odr_linkage attribute https://reviews.llvm.org/D18095

I use the attribute in my C++-to-C transpiler to generate C code with the same LLVM IR as the original C++ code. Especially, template function use linkonce_odr is relevant for optimization and cannot generated in C right now. Projects like the LLVM C Backend could also profit from it ... https://github.com/JuliaHubOSS/llvm-cbe

[rjmccall]

I understand that you're adding this for your project's internal purposes, but it's a permanent language feature that I don't think we want.

[aaron.ballman]

In D158242#4597968, @rjmccall wrote:

I understand that you're adding this for your project's internal purposes, but it's a permanent language feature that I don't think we want.

+1 -- I'm wary of exposing internal LLVM implementation details through a user-facing attribute like this.

[strimo378]

I'm wary of exposing internal LLVM implementation details through a user-facing attribute like this.

@aaron.ballman That means you would be more open to an attribute like __attribute__((onedefinitionrule)) because it is part of the C++ standard?

[aaron.ballman]

In D158242#4598692, @strimo378 wrote:

I'm wary of exposing internal LLVM implementation details through a user-facing attribute like this.

@aaron.ballman That means you would be more open to an attribute like __attribute__((onedefinitionrule)) because it is part of the C++ standard?

It depends entirely on what the attribute would do, how it is used in-tree, how users would use it, etc.

clang/include/clang/Basic/Attr.td

def Visibility : InheritableAttr {
   let Spellings = [GCC<"visibility">];
   let Args = [EnumArgument<"Visibility", "VisibilityType",
                            ["default", "hidden", "internal", "protected"],
                            ["Default", "Hidden", "Hidden", "Protected"]>];
   let MeaningfulToClassTemplateDefinition = 1;
   let Documentation = [Undocumented];
 }
 
+def Linkage : InheritableAttr {
+  let Clone = 0;
+  let Spellings = [GCC<"linkage">];
+  let Args = [EnumArgument<"Linkage", "LinkageType",
+                           ["external", "available_externally", "linkonce", "linkonce_odr", "weak", "weak_odr", "appending", "internal", "private", "external_weak", "common"],
+                           ["External", "AvailableExternally", "LinkOnceAny", "LinkOnceODR", "WeakAny", "WeakODR", "Appending", "Internal", "Private", "ExternalWeak", "Common"]>];
+  let MeaningfulToClassTemplateDefinition = 1;
+  let Documentation = [Undocumented];
+}
+
 def TypeVisibility : InheritableAttr {
   let Clone = 0;
   let Spellings = [Clang<"type_visibility">];
   let Args = [EnumArgument<"Visibility", "VisibilityType",
                            ["default", "hidden", "internal", "protected"],
                            ["Default", "Hidden", "Hidden", "Protected"]>];
 //  let Subjects = [Tag, ObjCInterface, Namespace];
   let Documentation = [Undocumented];

clang/lib/CodeGen/CodeGenModule.cpp

if (Context.getTargetInfo().getTriple().isKnownWindowsMSVCEnvironment() &&
     return true;
 
   return false;
 }
 
 llvm::GlobalValue::LinkageTypes
 CodeGenModule::getLLVMLinkageForDeclarator(const DeclaratorDecl *D,
                                            GVALinkage Linkage) {
+
+  if (const auto *A = D->getAttr<LinkageAttr>()) {
+    switch (A->getLinkage()) {
+    case LinkageAttr::Private:
+      return llvm::GlobalValue::PrivateLinkage;
+    case LinkageAttr::Internal:
+      return llvm::GlobalValue::InternalLinkage;
+    case LinkageAttr::WeakAny:
+      return llvm::GlobalValue::WeakAnyLinkage;
+    case LinkageAttr::WeakODR:
+      return llvm::GlobalValue::WeakODRLinkage;
+    case LinkageAttr::LinkOnceAny:
+      return llvm::GlobalValue::LinkOnceAnyLinkage;
+    case LinkageAttr::LinkOnceODR:
+      return llvm::GlobalValue::LinkOnceODRLinkage;
+    case LinkageAttr::AvailableExternally:
+      return llvm::GlobalValue::AvailableExternallyLinkage;
+    case LinkageAttr::Appending:
+      return llvm::GlobalValue::AppendingLinkage;
+    case LinkageAttr::Common:
+      return llvm::GlobalValue::CommonLinkage;
+    case LinkageAttr::ExternalWeak:
+      return llvm::GlobalValue::ExternalWeakLinkage;
+    case LinkageAttr::External:
+      return llvm::GlobalValue::ExternalLinkage;
+    default:
+      llvm_unreachable("unknown linkage");
+    }
+  }
+
   if (Linkage == GVA_Internal)
     return llvm::Function::InternalLinkage;
 
   if (D->hasAttr<WeakAttr>())
     return llvm::GlobalVariable::WeakAnyLinkage;
 
   if (const auto *FD = D->getAsFunction())
     if (FD->isMultiVersion() && Linkage == GVA_AvailableExternally)

clang/lib/Sema/SemaDeclAttr.cpp

static void handleConstructorAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
   }
   if (AL.getNumArgs() &&
       !checkUInt32Argument(S, AL, AL.getArgAsExpr(0), priority))
     return;
 
   D->addAttr(::new (S.Context) ConstructorAttr(S.Context, AL, priority));
 }
 
+static void handleLinkageAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
+  // Linkage attributes don't mean anything on a typedef.
+  if (isa<TypedefNameDecl>(D)) {
+    S.Diag(AL.getRange().getBegin(), diag::warn_attribute_ignored) << AL;
+    return;
+  }
+
+  // Check that the argument is a string literal.
+  StringRef TypeStr;
+  SourceLocation LiteralLoc;
+  if (!S.checkStringLiteralArgumentAttr(AL, 0, TypeStr, &LiteralLoc))
+    return;
+
+  LinkageAttr::LinkageType type;
+  if (!LinkageAttr::ConvertStrToLinkageType(TypeStr, type)) {
+    S.Diag(LiteralLoc, diag::warn_attribute_type_not_supported)
+        << AL << TypeStr;
+    return;
+  }
+
+  D->addAttr(::new (S.Context) LinkageAttr(S.Context, AL, type));
+}
+
 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));
 }
default:
     }
     // N.B., ClangAttrEmitter.cpp emits a diagnostic helper that ensures a
     // statement attribute is not written on a declaration, but this code is
     // needed for type attributes as well as statement attributes in Attr.td
     // that do not list any subjects.
     S.Diag(AL.getLoc(), diag::err_attribute_invalid_on_decl)
         << AL << AL.isRegularKeywordAttribute() << D->getLocation();
     break;
+  case ParsedAttr::AT_Linkage:
+    handleLinkageAttr(S, D, AL);
+    break;
   case ParsedAttr::AT_Interrupt:
     handleInterruptAttr(S, D, AL);
     break;
   case ParsedAttr::AT_X86ForceAlignArgPointer:
     handleX86ForceAlignArgPointerAttr(S, D, AL);
     break;
   case ParsedAttr::AT_ReadOnlyPlacement:
     handleSimpleAttribute<ReadOnlyPlacementAttr>(S, D, AL);

clang/test/CodeGen/attr-linkage.c

+// RUN: %clang_cc1 -emit-llvm -Wno-gcc-compat -O1 -disable-llvm-passes -o - %s | FileCheck %s
+
+int v01 __attribute__((linkage("external")));
+int v02 __attribute__((linkage("available_externally")));
+int v03 __attribute__((linkage("linkonce")));
+int v04 __attribute__((linkage("linkonce_odr")));
+int v05 __attribute__((linkage("weak")));
+int v06 __attribute__((linkage("weak_odr")));
+int v07[3] __attribute__((linkage("appending")));
+int v08 __attribute__((linkage("internal")));
+int v09 __attribute__((linkage("private")));
+int v10 __attribute__((linkage("external_weak")));
+int v11 __attribute__((linkage("common")));
+
+// CHECK: @v01 = global i32 0
+// CHECK: @v02 = available_externally global i32 0
+// CHECK: @v03 = linkonce global i32 0
+// CHECK: @v04 = linkonce_odr global i32 0
+// CHECK: @v05 = weak global i32 0
+// CHECK: @v06 = weak_odr global i32 0
+// CHECK: @v07 = appending global [3 x i32] zeroinitializer
+// CHECK: @v08 = internal global i32 0
+// CHECK: @v09 = private global i32 0
+// CHECK: @v10 = extern_weak global i32 0
+// CHECK: @v11 = common global i32 0
+
+void f01(void) __attribute__((linkage("external"))) {};
+void f02(void) __attribute__((linkage("available_externally"))) {};
+void f03(void) __attribute__((linkage("linkonce"))) {};
+void f04(void) __attribute__((linkage("linkonce_odr"))) {};
+void f05(void) __attribute__((linkage("weak"))) {};
+void f06(void) __attribute__((linkage("weak_odr"))) {};
+// appending is only applicable to variables
+void f08(void) __attribute__((linkage("internal"))) {};
+void f09(void) __attribute__((linkage("private"))) {};
+void f10(void) __attribute__((linkage("external_weak"))) {};
+// common is only applicable to variables
+
+// CHECK: define dso_local void @f01()
+// CHECK: define available_externally void @f02()
+// CHECK: define linkonce void @f03()
+// CHECK: define linkonce_odr void @f04()
+// CHECK: define weak void @f05()
+// CHECK: define weak_odr void @f06()
+// CHECK: define internal void @f08()
+// CHECK: define private void @f09()
+// CHECK: define extern_weak void @f10()