Pass code-model through Module IR to [llc]

[Esme]

Summary

Currently, the code-model specified in IR can't be captured by LLC.
This patch fixes that.

[MaskRay]

Thanks. This makes sense to me.

llvm/test/tools/llc/codemodel.ll

1 ↗

(On Diff #440108)

Add ; REQUIRES: x86-registered-target

llvm/tools/llc/llc.cpp

579

drop braces

For Optional, the convention is to use its operator bool() instead of hasValue.

[Esme]

Addressed comments.
Thanks! @MaskRay

[shchenz]

llvm/include/llvm/Target/TargetMachine.h

226

We may can implement this simple function in the header.

llvm/test/tools/llc/codemodel.ll

2 ↗

(On Diff #440116)

Can we add more cases? For example, changing the code model by using command option to verify:
1: the command option will override the IR input
2: different code models generate different instructions. (Not sure X86 will have different final assembly for below case for different code models, if no difference on X86, we can use some PPC target codes). With this we can verify that the code model in the IR is taken into account by the llc.

[MaskRay]

LGTM when @shchenz is happy

FWIW, I'd use [llc] instead of ... to LLC for the subject.

[shchenz]

Looks great! Thanks for adding this support.

llvm/include/llvm/Target/TargetMachine.h

public:
   void setRequiresStructuredCFG(bool Value) { RequireStructuredCFG = Value; }
 
   /// Returns the code generation relocation model. The choices are static, PIC,
   /// and dynamic-no-pic, and target default.
   Reloc::Model getRelocationModel() const;
 
   /// Returns the code model. The choices are small, kernel, medium, large, and
   /// target default.
-  CodeModel::Model getCodeModel() const;
+  CodeModel::Model getCodeModel() const { return CMModel; }
+
+  /// Set the code model.
+  void setCodeModel(CodeModel::Model CM) { CMModel = CM; }
 
   bool isPositionIndependent() const;
 
   bool shouldAssumeDSOLocal(const Module &M, const GlobalValue *GV) const;
 
   /// Returns true if this target uses emulated TLS.
   bool useEmulatedTLS() const;
 

llvm/lib/Target/TargetMachine.cpp

#define RESET_OPTION(X, Y)                                              \
   RESET_OPTION(NoSignedZerosFPMath, "no-signed-zeros-fp-math");
   RESET_OPTION(ApproxFuncFPMath, "approx-func-fp-math");
 }
 
 /// Returns the code generation relocation model. The choices are static, PIC,
 /// and dynamic-no-pic.
 Reloc::Model TargetMachine::getRelocationModel() const { return RM; }
 
-/// Returns the code model. The choices are small, kernel, medium, large, and
-/// target default.
-CodeModel::Model TargetMachine::getCodeModel() const { return CMModel; }
-
 /// Get the IR-specified TLS model for Var.
 static TLSModel::Model getSelectedTLSModel(const GlobalValue *GV) {
   switch (GV->getThreadLocalMode()) {
   case GlobalVariable::NotThreadLocal:
     llvm_unreachable("getSelectedTLSModel for non-TLS variable");
     break;
   case GlobalVariable::GeneralDynamicTLSModel:
     return TLSModel::GeneralDynamic;

llvm/test/tools/llc/codemodel-1.ll

+; REQUIRES: x86-registered-target
+; RUN: llc %s -o - | FileCheck %s --check-prefix=CHECK-LARGE
+
+;; Check the llc option will override the IR input.
+; RUN: llc -code-model=small %s -o - | FileCheck %s --check-prefix=CHECK-SMALL
+
+target triple = "x86_64-unknown-linux-gnu"
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+
+!llvm.module.flags = !{!0, !1}
+
+!0 = !{i32 1, !"wchar_size", i32 4}
+!1 = !{i32 1, !"Code Model", i32 4}
+
+@data = internal constant [0 x i32] []
+
+define i32* @foo() nounwind readonly {
+entry:
+; CHECK-LARGE: movabsq $data, %rax
+; CHECK-SMALL: movl    $data, %eax
+    ret i32* getelementptr ([0 x i32], [0 x i32]* @data, i64 0, i64 0)
+}

llvm/test/tools/llc/codemodel-2.ll

+; REQUIRES: x86-registered-target
+; RUN: llc %s -o - | FileCheck %s --check-prefix=CHECK-SMALL
+
+;; Check the llc option will override the IR input.
+; RUN: llc -code-model=large %s -o - | FileCheck %s --check-prefix=CHECK-LARGE
+
+target triple = "x86_64-unknown-linux-gnu"
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+
+!llvm.module.flags = !{!0, !1}
+
+!0 = !{i32 1, !"wchar_size", i32 4}
+!1 = !{i32 1, !"Code Model", i32 1}
+
+@data = internal constant [0 x i32] []
+
+define i32* @foo() nounwind readonly {
+entry:
+; CHECK-LARGE: movabsq $data, %rax
+; CHECK-SMALL: movl    $data, %eax
+    ret i32* getelementptr ([0 x i32], [0 x i32]* @data, i64 0, i64 0)
+}

llvm/tools/llc/llc.cpp

if (DwarfDirectory.getPosition()) {
       // syntax prior to DWARFv5. Let the target decide the default
       // value.
       Options.MCOptions.MCUseDwarfDirectory =
           MCTargetOptions::DefaultDwarfDirectory;
     }
   };
 
   Optional<Reloc::Model> RM = codegen::getExplicitRelocModel();
+  Optional<CodeModel::Model> CM = codegen::getExplicitCodeModel();
 
   const Target *TheTarget = nullptr;
   std::unique_ptr<TargetMachine> Target;
 
   // If user just wants to list available options, skip module loading
   if (!SkipModule) {
     auto SetDataLayout =
         [&](StringRef DataLayoutTargetTriple) -> Optional<std::string> {
auto SetDataLayout =
       // On AIX, setting the relocation model to anything other than PIC is
       // considered a user error.
       if (TheTriple.isOSAIX() && RM && *RM != Reloc::PIC_)
         reportError("invalid relocation model, AIX only supports PIC",
                     InputFilename);
 
       InitializeOptions(TheTriple);
       Target = std::unique_ptr<TargetMachine>(TheTarget->createTargetMachine(
-          TheTriple.getTriple(), CPUStr, FeaturesStr, Options, RM,
-          codegen::getExplicitCodeModel(), OLvl));
+          TheTriple.getTriple(), CPUStr, FeaturesStr, Options, RM, CM, OLvl));
       assert(Target && "Could not allocate target machine!");
 
       return Target->createDataLayout().getStringRepresentation();
     };
     if (InputLanguage == "mir" ||
         (InputLanguage == "" && StringRef(InputFilename).endswith(".mir"))) {
       MIR = createMIRParserFromFile(InputFilename, Err, Context,
                                     setMIRFunctionAttributes);
       if (MIR)
         M = MIR->parseIRModule(SetDataLayout);
     } else {
       M = parseIRFile(InputFilename, Err, Context, SetDataLayout);
     }
     if (!M) {
       Err.print(argv[0], WithColor::error(errs(), argv[0]));
       return 1;
     }
     if (!TargetTriple.empty())
       M->setTargetTriple(Triple::normalize(TargetTriple));
+
+    Optional<CodeModel::Model> CM_IR = M->getCodeModel();
+    if (!CM && CM_IR)
+      Target->setCodeModel(CM_IR.getValue());
   } else {
     TheTriple = Triple(Triple::normalize(TargetTriple));
     if (TheTriple.getTriple().empty())
       TheTriple.setTriple(sys::getDefaultTargetTriple());
 
     // Get the target specific parser.
     std::string Error;
     TheTarget =
         TargetRegistry::lookupTarget(codegen::getMArch(), TheTriple, Error);
     if (!TheTarget) {
       WithColor::error(errs(), argv[0]) << Error;
       return 1;
     }
 
     // On AIX, setting the relocation model to anything other than PIC is
     // considered a user error.
     if (TheTriple.isOSAIX() && RM && *RM != Reloc::PIC_) {
       WithColor::error(errs(), argv[0])
           << "invalid relocation model, AIX only supports PIC.\n";
       return 1;
     }
 
     InitializeOptions(TheTriple);
     Target = std::unique_ptr<TargetMachine>(TheTarget->createTargetMachine(
-        TheTriple.getTriple(), CPUStr, FeaturesStr, Options, RM,
-        codegen::getExplicitCodeModel(), OLvl));
+        TheTriple.getTriple(), CPUStr, FeaturesStr, Options, RM, CM, OLvl));
     assert(Target && "Could not allocate target machine!");
 
     // If we don't have a module then just exit now. We do this down
     // here since the CPU/Feature help is underneath the target machine
     // creation.
     return 0;
   }