[clang] Add per-global code model attribute

clang/include/clang/Basic/Attr.td

@@ -2718,6 +2718,14 @@ def PragmaClangTextSection : InheritableAttr {
   let Documentation = [InternalOnly];
 }
 
+def CodeModel : InheritableAttr {
+  let Spellings = [GCC<"model">];
+  let Args = [StringArgument<"Model">];
+  let Subjects =
+      SubjectList<[ GlobalVar ], 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 yet 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,19 @@ CodeGenModule::GetOrCreateLLVMGlobal(StringRef MangledName, llvm::Type *Ty,
         isExternallyVisible(D->getLinkageAndVisibility().getLinkage()))
       GV->setSection(".cp.rodata");
 
+    // Handle code model attribute
+    if (D->hasAttr<CodeModelAttr>()) {
+      if (const CodeModelAttr *CMA = D->getAttr<CodeModelAttr>()) {
+        auto CM = llvm::StringSwitch<llvm::CodeModel::Model>(CMA->getModel())
+                      .Case("tiny", llvm::CodeModel::Tiny)
+                      .Case("kernel", llvm::CodeModel::Kernel)
+                      .Case("medium", llvm::CodeModel::Medium)
+                      .Case("large", llvm::CodeModel::Large)
+                      .Default(llvm::CodeModel::Small);
+        GV->setCodeModel(CM);
+      }
+    }
+
     // 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,33 @@ static void handleSectionAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
   }
 }
 
+static void handleCodeModelAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
+  StringRef CM;
+  StringRef Str;
+  SourceLocation LiteralLoc;
+  bool Ok = false;
+  // Check that it is a string.
+  if (!S.checkStringLiteralArgumentAttr(AL, 0, Str, &LiteralLoc))
+    return;
+
+  CM = Str;
+  if (S.getASTContext().getTargetInfo().getTriple().isLoongArch()) {
+    Ok = CM == "normal" || CM == "medium" || CM == "extreme";
+    CM = llvm::StringSwitch<StringRef>(CM)
+             .Case("normal", "small")
+             .Case("extreme", "large")
+             .Default(CM);
+  }
+
+  // Check that the value is acceptable.
+  if (!Ok) {
+    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 +9336,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,37 @@
+// 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;
+}
+
+// CHECK: @v5 ={{.*}} global i32 0, code_model "large"
+thread_local int v5 __attribute__((model("extreme")));
+
+struct S {
+  double d;
+};
+
+// CHECK: @v6 ={{.*}} global {{.*}}, code_model "medium"
+S v6 __attribute__((model("medium")));
+
+typedef void (*F)();
+
+// CHECK: @v7 ={{.*}} global ptr null, code_model "large"
+F v7 __attribute__((model("extreme")));

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

@@ -48,6 +48,7 @@
 // CHECK-NEXT: CarriesDependency (SubjectMatchRule_variable_is_parameter, SubjectMatchRule_objc_method, SubjectMatchRule_function)
 // CHECK-NEXT: Cleanup (SubjectMatchRule_variable_is_local)
 // CHECK-NEXT: CmseNSEntry (SubjectMatchRule_function)
+// CHECK-NEXT: CodeModel (SubjectMatchRule_variable_is_global)
 // CHECK-NEXT: Cold (SubjectMatchRule_function)
 // CHECK-NEXT: Common (SubjectMatchRule_variable)
 // CHECK-NEXT: ConstInit (SubjectMatchRule_variable_is_global)

clang/test/Sema/attr-model.c

@@ -0,0 +1,31 @@
+// 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 !__has_attribute(model)
+#error "Should support model attribute"
+#endif
+
+int a __attribute((model("tiny")));    // expected-error {{code_model 'tiny' is not yet supported on this target}}
+int b __attribute((model("small")));   // expected-error {{code_model 'small' is not yet supported on this target}}
+int c __attribute((model("normal")));  // aarch64-error {{code_model 'normal' is not yet supported on this target}} \
+                                       // mips64-error {{code_model 'normal' is not yet supported on this target}} \
+                                       // powerpc64-error {{code_model 'normal' is not yet supported on this target}} \
+                                       // riscv64-error {{code_model 'normal' is not yet supported on this target}} \
+                                       // x86_64-error {{code_model 'normal' is not yet supported on this target}}
+int d __attribute((model("kernel")));  // expected-error {{code_model 'kernel' is not yet supported on this target}}
+int e __attribute((model("medium")));  // aarch64-error {{code_model 'medium' is not yet supported on this target}} \
+                                       // mips64-error {{code_model 'medium' is not yet supported on this target}} \
+                                       // powerpc64-error {{code_model 'medium' is not yet supported on this target}} \
+                                       // riscv64-error {{code_model 'medium' is not yet supported on this target}} \
+                                       // x86_64-error {{code_model 'medium' is not yet supported on this target}}
+int f __attribute((model("large")));   // expected-error {{code_model 'large' is not yet supported on this target}}
+int g __attribute((model("extreme"))); // aarch64-error {{code_model 'extreme' is not yet supported on this target}} \
+                                       // mips64-error {{code_model 'extreme' is not yet supported on this target}} \
+                                       // powerpc64-error {{code_model 'extreme' is not yet supported on this target}} \
+                                       // riscv64-error {{code_model 'extreme' is not yet supported on this target}} \
+                                       // x86_64-error {{code_model 'extreme' is not yet supported on this target}}
+void __attribute((model("extreme"))) h() {} // expected-error {{'model' attribute only applies to global variables}}