Add support for storing code model to LLVM module IR

src/librustc_codegen_llvm/context.rs

@@ -22,7 +22,7 @@ use rustc_session::Session;
 use rustc_span::source_map::{Span, DUMMY_SP};
 use rustc_span::symbol::Symbol;
 use rustc_target::abi::{HasDataLayout, LayoutOf, PointeeInfo, Size, TargetDataLayout, VariantIdx};
-use rustc_target::spec::{HasTargetSpec, RelocModel, Target, TlsModel};
+use rustc_target::spec::{CodeModel, HasTargetSpec, RelocModel, Target, TlsModel};
 
 use std::cell::{Cell, RefCell};
 use std::ffi::CStr;
@@ -99,6 +99,16 @@ fn to_llvm_tls_model(tls_model: TlsModel) -> llvm::ThreadLocalMode {
     }
 }
 
+fn to_llvm_code_model(code_model: CodeModel) -> llvm::CodeModel {
+    match code_model {
+        CodeModel::Tiny => llvm::CodeModel::Tiny,
+        CodeModel::Small => llvm::CodeModel::Small,
+        CodeModel::Kernel => llvm::CodeModel::Kernel,
+        CodeModel::Medium => llvm::CodeModel::Medium,
+        CodeModel::Large => llvm::CodeModel::Large,
+    }
+}
+
 fn strip_function_ptr_alignment(data_layout: String) -> String {
     // FIXME: Make this more general.
     data_layout.replace("-Fi8-", "-")
@@ -181,6 +191,10 @@ pub unsafe fn create_module(
         }
     }
 
+    if let Some(code_model) = sess.code_model() {
+        llvm::LLVMRustSetModuleCodeModel(llmod, to_llvm_code_model(code_model));
+    }
+
     // If skipping the PLT is enabled, we need to add some module metadata
     // to ensure intrinsic calls don't use it.
     if !sess.needs_plt() {

src/librustc_codegen_llvm/llvm/ffi.rs

@@ -2129,6 +2129,7 @@ extern "C" {
     pub fn LLVMRustUnsetComdat(V: &Value);
     pub fn LLVMRustSetModulePICLevel(M: &Module);
     pub fn LLVMRustSetModulePIELevel(M: &Module);
+    pub fn LLVMRustSetModuleCodeModel(M: &Module, Model: CodeModel);
     pub fn LLVMRustModuleBufferCreate(M: &Module) -> &'static mut ModuleBuffer;
     pub fn LLVMRustModuleBufferPtr(p: &ModuleBuffer) -> *const u8;
     pub fn LLVMRustModuleBufferLen(p: &ModuleBuffer) -> usize;

src/rustllvm/PassWrapper.cpp

@@ -1163,6 +1163,20 @@ extern "C" void LLVMRustSetModulePIELevel(LLVMModuleRef M) {
   unwrap(M)->setPIELevel(PIELevel::Level::Large);
 }
 
+//  Linking object files with different code models is undefined behavior
+//  because the compiler would have to generate additional code (to span
+//  longer jumps) if a larger code model is used with a smaller one.
+//  Therefore we will treat attempts to mix code models as an error.
+//
+// See https://reviews.llvm.org/D52322 and https://reviews.llvm.org/D52323.
+extern "C" void LLVMRustSetModuleCodeModel(LLVMModuleRef M,
+                                           LLVMRustCodeModel Model) {
+  auto CM = fromRust(Model);
+  if (!CM.hasValue())
+    return;
+  unwrap(M)->setCodeModel(*CM);
+}
+
 // Here you'll find an implementation of ThinLTO as used by the Rust compiler
 // right now. This ThinLTO support is only enabled on "recent ish" versions of
 // LLVM, and otherwise it's just blanket rejected from other compilers.

src/test/codegen/codemodels.rs

@@ -0,0 +1,18 @@
+// revisions: NOMODEL MODEL-SMALL MODEL-KERNEL MODEL-MEDIUM MODEL-LARGE
+//[NOMODEL] compile-flags:
+//[MODEL-SMALL] compile-flags: -C code-model=small
+//[MODEL-KERNEL] compile-flags: --target=x86_64-unknown-linux-gnu -C code-model=kernel
+//[MODEL-MEDIUM] compile-flags: --target=x86_64-unknown-linux-gnu -C code-model=medium
+//[MODEL-LARGE] compile-flags: -C code-model=large
+
+#![crate_type = "lib"]
+
+// MODEL-SMALL: !llvm.module.flags = !{{{.*}}}
+// MODEL-SMALL: !{{[0-9]+}} = !{i32 1, !"Code Model", i32 1}
+// MODEL-KERNEL: !llvm.module.flags = !{{{.*}}}
+// MODEL-KERNEL: !{{[0-9]+}} = !{i32 1, !"Code Model", i32 2}
+// MODEL-MEDIUM: !llvm.module.flags = !{{{.*}}}
+// MODEL-MEDIUM: !{{[0-9]+}} = !{i32 1, !"Code Model", i32 3}
+// MODEL-LARGE: !llvm.module.flags = !{{{.*}}}
+// MODEL-LARGE: !{{[0-9]+}} = !{i32 1, !"Code Model", i32 4}
+// NOMODEL-NOT: Code Model