[clang] Add per-global code model attribute

clang/include/clang/AST/Attr.h

@@ -25,6 +25,7 @@
 #include "clang/Basic/Sanitizers.h"
 #include "clang/Basic/SourceLocation.h"
 #include "llvm/Frontend/HLSL/HLSLResource.h"
+#include "llvm/Support/CodeGen.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/VersionTuple.h"
 #include "llvm/Support/raw_ostream.h"

clang/include/clang/Basic/Attr.td

@@ -143,6 +143,11 @@ def ExternalGlobalVar : SubsetSubject<Var,
                                !S->isLocalExternDecl()}],
                              "external global variables">;
 
+def NonTLSGlobalVar : SubsetSubject<Var,
+                             [{S->hasGlobalStorage() &&
+                               S->getTLSKind() == 0}],
+                             "non-TLS global variables">;
+
 def InlineFunction : SubsetSubject<Function,
                              [{S->isInlineSpecified()}], "inline functions">;
 
@@ -431,6 +436,7 @@ def TargetAArch64 : TargetArch<["aarch64", "aarch64_be", "aarch64_32"]>;
 def TargetAnyArm : TargetArch<!listconcat(TargetARM.Arches, TargetAArch64.Arches)>;
 def TargetAVR : TargetArch<["avr"]>;
 def TargetBPF : TargetArch<["bpfel", "bpfeb"]>;
+def TargetLoongArch : TargetArch<["loongarch32", "loongarch64"]>;
 def TargetMips32 : TargetArch<["mips", "mipsel"]>;
 def TargetAnyMips : TargetArch<["mips", "mipsel", "mips64", "mips64el"]>;
 def TargetMSP430 : TargetArch<["msp430"]>;
@@ -2718,6 +2724,15 @@ def PragmaClangTextSection : InheritableAttr {
   let Documentation = [InternalOnly];
 }
 
+def CodeModel : InheritableAttr, TargetSpecificAttr<TargetLoongArch> {
+  let Spellings = [GCC<"model">];
+  let Args = [EnumArgument<"Model", "llvm::CodeModel::Model",
+              ["normal", "medium", "extreme"], ["Small", "Medium", "Large"],
+              /*opt=*/0, /*fake=*/0, /*isExternalType=*/1>];
+  let Subjects = SubjectList<[NonTLSGlobalVar], ErrorDiag>;
+  let Documentation = [CodeModelDocs];
+}
+
 def Sentinel : InheritableAttr {
   let Spellings = [GCC<"sentinel">];
   let Args = [DefaultIntArgument<"Sentinel", 0>,

clang/include/clang/Basic/AttrDocs.td

@@ -57,6 +57,15 @@ global variable or function should be in after translation.
   let Heading = "section, __declspec(allocate)";
 }
 
+def CodeModelDocs : Documentation {
+  let Category = DocCatVariable;
+  let Content = [{
+The ``model`` attribute allows overriding the translation unit's
+code model (specified by ``-mcmodel``) for a specific global variable.
+  }];
+  let Heading = "model";
+}
+
 def UsedDocs : Documentation {
   let Category = DocCatFunction;
   let Content = [{

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -3408,6 +3408,8 @@ def warn_objc_redundant_literal_use : Warning<
 def err_attr_tlsmodel_arg : Error<"tls_model must be \"global-dynamic\", "
   "\"local-dynamic\", \"initial-exec\" or \"local-exec\"">;
 
+def err_attr_codemodel_arg : Error<"code model '%0' is not supported on this target">;
+
 def err_aix_attr_unsupported_tls_model : Error<"TLS model '%0' is not yet supported on AIX">;
 
 def err_tls_var_aligned_over_maximum : Error<

clang/lib/CodeGen/CodeGenModule.cpp

@@ -4841,6 +4841,10 @@ CodeGenModule::GetOrCreateLLVMGlobal(StringRef MangledName, llvm::Type *Ty,
         isExternallyVisible(D->getLinkageAndVisibility().getLinkage()))
       GV->setSection(".cp.rodata");
 
+    // Handle code model attribute
+    if (const auto *CMA = D->getAttr<CodeModelAttr>())
+      GV->setCodeModel(CMA->getModel());
+
     // Check if we a have a const declaration with an initializer, we may be
     // able to emit it as available_externally to expose it's value to the
     // optimizer.

clang/lib/Sema/SemaDeclAttr.cpp

@@ -3369,6 +3369,22 @@ static void handleSectionAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
   }
 }
 
+static void handleCodeModelAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
+  StringRef Str;
+  SourceLocation LiteralLoc;
+  // Check that it is a string.
+  if (!S.checkStringLiteralArgumentAttr(AL, 0, Str, &LiteralLoc))
+    return;
+
+  llvm::CodeModel::Model CM;
+  if (!CodeModelAttr::ConvertStrToModel(Str, CM)) {
+    S.Diag(LiteralLoc, diag::err_attr_codemodel_arg) << Str;
+    return;
+  }
+
+  D->addAttr(::new (S.Context) CodeModelAttr(S.Context, AL, CM));
+}
+
 // This is used for `__declspec(code_seg("segname"))` on a decl.
 // `#pragma code_seg("segname")` uses checkSectionName() instead.
 static bool checkCodeSegName(Sema &S, SourceLocation LiteralLoc,
@@ -9309,6 +9325,9 @@ ProcessDeclAttribute(Sema &S, Scope *scope, Decl *D, const ParsedAttr &AL,
   case ParsedAttr::AT_Section:
     handleSectionAttr(S, D, AL);
     break;
+  case ParsedAttr::AT_CodeModel:
+    handleCodeModelAttr(S, D, AL);
+    break;
   case ParsedAttr::AT_RandomizeLayout:
     handleRandomizeLayoutAttr(S, D, AL);
     break;

clang/test/CodeGen/LoongArch/attributes.cpp

@@ -0,0 +1,34 @@
+// RUN: %clang_cc1 -emit-llvm -triple loongarch64 %s -o - | FileCheck %s
+
+// CHECK: @_ZL2v1 ={{.*}} global i32 0, code_model "small"
+static int v1 __attribute__((model("normal")));
+
+void use1() {
+  v1 = 1;
+}
+
+// CHECK: @v2 ={{.*}} global i32 0, code_model "medium"
+int v2 __attribute__((model("medium")));
+
+// CHECK: @v3 ={{.*}} global float 0.000000e+00, code_model "large"
+float v3 __attribute__((model("extreme")));
+
+// CHECK: @_ZL2v4IiE ={{.*}} global i32 0, code_model "medium"
+template <typename T>
+static T v4 __attribute__((model("medium")));
+
+void use2() {
+  v4<int> = 1;
+}
+
+struct S {
+  double d;
+};
+
+// CHECK: @v5 ={{.*}} global {{.*}}, code_model "medium"
+S v5 __attribute__((model("medium")));
+
+typedef void (*F)();
+
+// CHECK: @v6 ={{.*}} global ptr null, code_model "large"
+F v6 __attribute__((model("extreme")));

clang/test/Sema/attr-model.cpp

@@ -0,0 +1,64 @@
+// RUN: %clang_cc1 -triple aarch64 -verify=expected,aarch64 -fsyntax-only %s
+// RUN: %clang_cc1 -triple loongarch64 -verify=expected,loongarch64 -fsyntax-only %s
+// RUN: %clang_cc1 -triple mips64 -verify=expected,mips64 -fsyntax-only %s
+// RUN: %clang_cc1 -triple powerpc64 -verify=expected,powerpc64 -fsyntax-only %s
+// RUN: %clang_cc1 -triple riscv64 -verify=expected,riscv64 -fsyntax-only %s
+// RUN: %clang_cc1 -triple x86_64 -verify=expected,x86_64 -fsyntax-only %s
+
+#if defined(__loongarch__) && !__has_attribute(model)
+#error "Should support model attribute"
+#endif
+
+int a __attribute((model("tiny")));    // aarch64-warning {{unknown attribute 'model' ignored}} \
+                                       // loongarch64-error {{code model 'tiny' is not supported on this target}} \
+                                       // mips64-warning {{unknown attribute 'model' ignored}} \
+                                       // powerpc64-warning {{unknown attribute 'model' ignored}} \
+                                       // riscv64-warning {{unknown attribute 'model' ignored}} \
+                                       // x86_64-warning {{unknown attribute 'model' ignored}}
+int b __attribute((model("small")));   // aarch64-warning {{unknown attribute 'model' ignored}} \
+                                       // loongarch64-error {{code model 'small' is not supported on this target}} \
+                                       // mips64-warning {{unknown attribute 'model' ignored}} \
+                                       // powerpc64-warning {{unknown attribute 'model' ignored}} \
+                                       // riscv64-warning {{unknown attribute 'model' ignored}} \
+                                       // x86_64-warning {{unknown attribute 'model' ignored}}
+int c __attribute((model("normal")));  // aarch64-warning {{unknown attribute 'model' ignored}} \
+                                       // mips64-warning {{unknown attribute 'model' ignored}} \
+                                       // powerpc64-warning {{unknown attribute 'model' ignored}} \
+                                       // riscv64-warning {{unknown attribute 'model' ignored}} \
+                                       // x86_64-warning {{unknown attribute 'model' ignored}}
+int d __attribute((model("kernel")));  // aarch64-warning {{unknown attribute 'model' ignored}} \
+                                       // loongarch64-error {{code model 'kernel' is not supported on this target}} \
+                                       // mips64-warning {{unknown attribute 'model' ignored}} \
+                                       // powerpc64-warning {{unknown attribute 'model' ignored}} \
+                                       // riscv64-warning {{unknown attribute 'model' ignored}} \
+                                       // x86_64-warning {{unknown attribute 'model' ignored}}
+int e __attribute((model("medium")));  // aarch64-warning {{unknown attribute 'model' ignored}} \
+                                       // mips64-warning {{unknown attribute 'model' ignored}} \
+                                       // powerpc64-warning {{unknown attribute 'model' ignored}} \
+                                       // riscv64-warning {{unknown attribute 'model' ignored}} \
+                                       // x86_64-warning {{unknown attribute 'model' ignored}}
+int f __attribute((model("large")));   // aarch64-warning {{unknown attribute 'model' ignored}} \
+                                       // loongarch64-error {{code model 'large' is not supported on this target}} \
+                                       // mips64-warning {{unknown attribute 'model' ignored}} \
+                                       // powerpc64-warning {{unknown attribute 'model' ignored}} \
+                                       // riscv64-warning {{unknown attribute 'model' ignored}} \
+                                       // x86_64-warning {{unknown attribute 'model' ignored}}
+int g __attribute((model("extreme"))); // aarch64-warning {{unknown attribute 'model' ignored}} \
+                                       // mips64-warning {{unknown attribute 'model' ignored}} \
+                                       // powerpc64-warning {{unknown attribute 'model' ignored}} \
+                                       // riscv64-warning {{unknown attribute 'model' ignored}} \
+                                       // x86_64-warning {{unknown attribute 'model' ignored}}
+
+void __attribute((model("extreme"))) h() {} // aarch64-warning {{unknown attribute 'model' ignored}} \
+                                            // loongarch64-error {{'model' attribute only applies to non-TLS global variables}} \
+                                            // mips64-warning {{unknown attribute 'model' ignored}} \
+                                            // powerpc64-warning {{unknown attribute 'model' ignored}} \
+                                            // riscv64-warning {{unknown attribute 'model' ignored}} \
+                                            // x86_64-warning {{unknown attribute 'model' ignored}}
+
+thread_local int i __attribute((model("extreme"))); // aarch64-warning {{unknown attribute 'model' ignored}} \
+                                                    // loongarch64-error {{'model' attribute only applies to non-TLS global variables}} \
+                                                    // mips64-warning {{unknown attribute 'model' ignored}} \
+                                                    // powerpc64-warning {{unknown attribute 'model' ignored}} \
+                                                    // riscv64-warning {{unknown attribute 'model' ignored}} \
+                                                    // x86_64-warning {{unknown attribute 'model' ignored}}