Remove global_asm from CodegenCx

Author: bjorn3

src/base.rs

@@ -26,6 +26,7 @@ pub(crate) struct CodegenedFunction {
     func: Function,
     clif_comments: CommentWriter,
     func_debug_cx: Option<FunctionDebugContext>,
+    inline_asm: String,
 }
 
 pub(crate) fn codegen_fn<'tcx>(
@@ -105,6 +106,7 @@ pub(crate) fn codegen_fn<'tcx>(
 
         clif_comments,
         next_ssa_var: 0,
+        inline_asm: String::new(),
         inline_asm_index: 0,
     };
 
@@ -116,6 +118,7 @@ pub(crate) fn codegen_fn<'tcx>(
     let symbol_name = fx.symbol_name;
     let clif_comments = fx.clif_comments;
     let func_debug_cx = fx.func_debug_cx;
+    let inline_asm = fx.inline_asm;
 
     fx.constants_cx.finalize(fx.tcx, &mut *fx.module);
 
@@ -133,7 +136,7 @@ pub(crate) fn codegen_fn<'tcx>(
     // Verify function
     verify_func(tcx, &clif_comments, &func);
 
-    CodegenedFunction { symbol_name, func_id, func, clif_comments, func_debug_cx }
+    CodegenedFunction { symbol_name, func_id, func, clif_comments, func_debug_cx, inline_asm }
 }
 
 pub(crate) fn compile_fn(
@@ -142,12 +145,14 @@ pub(crate) fn compile_fn(
     output_filenames: &OutputFilenames,
     cached_context: &mut Context,
     module: &mut dyn Module,
+    global_asm: &mut String,
     codegened_func: CodegenedFunction,
 ) {
     let _timer =
         profiler.generic_activity_with_arg("compile function", &*codegened_func.symbol_name);
 
     let clif_comments = codegened_func.clif_comments;
+    global_asm.push_str(&codegened_func.inline_asm);
 
     // Store function in context
     let context = cached_context;

src/common.rs

@@ -293,6 +293,7 @@ pub(crate) struct FunctionCx<'m, 'clif, 'tcx: 'm> {
     /// This should only be accessed by `CPlace::new_var`.
     pub(crate) next_ssa_var: u32,
 
+    pub(crate) inline_asm: String,
     pub(crate) inline_asm_index: u32,
 }
 

src/driver/aot.rs

@@ -512,7 +512,7 @@ fn codegen_cgu_content(
     tcx: TyCtxt<'_>,
     module: &mut dyn Module,
     cgu_name: rustc_span::Symbol,
-) -> (CodegenCx, Vec<CodegenedFunction>) {
+) -> (CodegenCx, Vec<CodegenedFunction>, String) {
     let _timer = tcx.prof.generic_activity_with_arg("codegen cgu", cgu_name.as_str());
 
     let cgu = tcx.codegen_unit(cgu_name);
@@ -524,6 +524,7 @@ fn codegen_cgu_content(
         tcx.sess.opts.debuginfo != DebugInfo::None,
         cgu_name,
     );
+    let mut global_asm = String::new();
     let mut type_dbg = TypeDebugContext::default();
     super::predefine_mono_items(tcx, module, &mono_items);
     let mut codegened_functions = vec![];
@@ -533,7 +534,7 @@ fn codegen_cgu_content(
                 if tcx.codegen_fn_attrs(instance.def_id()).flags.contains(CodegenFnAttrFlags::NAKED)
                 {
                     rustc_codegen_ssa::mir::naked_asm::codegen_naked_asm(
-                        &mut GlobalAsmContext { tcx, global_asm: &mut cx.global_asm },
+                        &mut GlobalAsmContext { tcx, global_asm: &mut global_asm },
                         instance,
                         MonoItemData {
                             linkage: RLinkage::External,
@@ -565,15 +566,15 @@ fn codegen_cgu_content(
             }
             MonoItem::GlobalAsm(item_id) => {
                 rustc_codegen_ssa::base::codegen_global_asm(
-                    &mut GlobalAsmContext { tcx, global_asm: &mut cx.global_asm },
+                    &mut GlobalAsmContext { tcx, global_asm: &mut global_asm },
                     item_id,
                 );
             }
         }
     }
     crate::main_shim::maybe_create_entry_wrapper(tcx, module, false, cgu.is_primary());
 
-    (cx, codegened_functions)
+    (cx, codegened_functions, global_asm)
 }
 
 fn module_codegen(
@@ -586,7 +587,8 @@ fn module_codegen(
 ) -> OngoingModuleCodegen {
     let mut module = make_module(tcx.sess, cgu_name.as_str().to_string());
 
-    let (mut cx, codegened_functions) = codegen_cgu_content(tcx, &mut module, cgu_name);
+    let (mut cx, codegened_functions, mut global_asm) =
+        codegen_cgu_content(tcx, &mut module, cgu_name);
 
     let cgu_name = cgu_name.as_str().to_owned();
 
@@ -610,6 +612,7 @@ fn module_codegen(
                     &output_filenames,
                     &mut cached_context,
                     &mut module,
+                    &mut global_asm,
                     codegened_func,
                 );
             }
@@ -620,7 +623,7 @@ fn module_codegen(
                 crate::global_asm::compile_global_asm(
                     &global_asm_config,
                     &cgu_name,
-                    &cx.global_asm,
+                    global_asm,
                     invocation_temp.as_deref(),
                 )
             })?;

src/driver/jit.rs

@@ -80,10 +80,6 @@ pub(crate) fn run_jit(tcx: TyCtxt<'_>, jit_args: Vec<String>) -> ! {
         }
     });
 
-    if !cx.global_asm.is_empty() {
-        tcx.dcx().fatal("Inline asm is not supported in JIT mode");
-    }
-
     crate::main_shim::maybe_create_entry_wrapper(tcx, &mut jit_module, true, true);
 
     tcx.dcx().abort_if_errors();
@@ -153,14 +149,20 @@ fn codegen_and_compile_fn<'tcx>(
             module,
             instance,
         );
+
+        let mut global_asm = String::new();
         crate::base::compile_fn(
             cx,
             &tcx.prof,
             output_filenames,
             cached_context,
             module,
+            &mut global_asm,
             codegened_func,
         );
+        if !global_asm.is_empty() {
+            tcx.dcx().fatal("Inline asm is not supported in JIT mode");
+        }
     });
 }
 

src/global_asm.rs

@@ -168,7 +168,7 @@ impl GlobalAsmConfig {
 pub(crate) fn compile_global_asm(
     config: &GlobalAsmConfig,
     cgu_name: &str,
-    global_asm: &str,
+    global_asm: String,
     invocation_temp: Option<&str>,
 ) -> Result<Option<PathBuf>, String> {
     if global_asm.is_empty() {

src/inline_asm.rs

@@ -175,7 +175,7 @@ pub(crate) fn codegen_inline_asm_inner<'tcx>(
     fx.inline_asm_index += 1;
 
     let generated_asm = asm_gen.generate_asm_wrapper(&asm_name);
-    fx.cx.global_asm.push_str(&generated_asm);
+    fx.inline_asm.push_str(&generated_asm);
 
     let mut inputs = Vec::new();
     let mut outputs = Vec::new();

src/lib.rs

@@ -126,7 +126,6 @@ impl<F: Fn() -> String> Drop for PrintOnPanic<F> {
 /// inside a single codegen unit with the exception of the Cranelift [`Module`](cranelift_module::Module).
 struct CodegenCx {
     should_write_ir: bool,
-    global_asm: String,
     debug_context: Option<DebugContext>,
     cgu_name: Symbol,
 }
@@ -142,7 +141,6 @@ impl CodegenCx {
         };
         CodegenCx {
             should_write_ir: crate::pretty_clif::should_write_ir(tcx),
-            global_asm: String::new(),
             debug_context,
             cgu_name,
         }