Get rid of CodegenCx

Author: bjorn3

src/base.rs

@@ -13,6 +13,7 @@ use rustc_middle::ty::adjustment::PointerCoercion;
 use rustc_middle::ty::layout::{FnAbiOf, HasTypingEnv};
 use rustc_middle::ty::print::with_no_trimmed_paths;
 use rustc_session::config::OutputFilenames;
+use rustc_span::Symbol;
 
 use crate::constant::ConstantCx;
 use crate::debuginfo::{FunctionDebugContext, TypeDebugContext};
@@ -31,7 +32,8 @@ pub(crate) struct CodegenedFunction {
 
 pub(crate) fn codegen_fn<'tcx>(
     tcx: TyCtxt<'tcx>,
-    cx: &mut crate::CodegenCx,
+    cgu_name: Symbol,
+    mut debug_context: Option<&mut DebugContext>,
     type_dbg: &mut TypeDebugContext<'tcx>,
     cached_func: Function,
     module: &mut dyn Module,
@@ -63,7 +65,7 @@ pub(crate) fn codegen_fn<'tcx>(
     func.clear();
     func.name = UserFuncName::user(0, func_id.as_u32());
     func.signature = sig;
-    if cx.debug_context.is_some() {
+    if debug_context.is_some() {
         func.collect_debug_info();
     }
 
@@ -79,9 +81,10 @@ pub(crate) fn codegen_fn<'tcx>(
     // Make FunctionCx
     let target_config = module.target_config();
     let pointer_type = target_config.pointer_type();
+    assert_eq!(pointer_ty(tcx), pointer_type);
     let clif_comments = crate::pretty_clif::CommentWriter::new(tcx, instance, fn_abi);
 
-    let func_debug_cx = if let Some(debug_context) = &mut cx.debug_context {
+    let func_debug_cx = if let Some(debug_context) = debug_context.as_deref_mut() {
         Some(debug_context.define_function(tcx, type_dbg, instance, fn_abi, &symbol_name, mir.span))
     } else {
         None
@@ -91,14 +94,15 @@ pub(crate) fn codegen_fn<'tcx>(
     bcx.declare_var(exception_slot, pointer_type);
 
     let mut fx = FunctionCx {
-        cx,
         module,
+        debug_context,
         tcx,
         target_config,
         pointer_type,
         constants_cx: ConstantCx::new(),
         func_debug_cx,
 
+        cgu_name,
         instance,
         symbol_name,
         mir,
@@ -128,7 +132,7 @@ pub(crate) fn codegen_fn<'tcx>(
 
     fx.constants_cx.finalize(fx.tcx, &mut *fx.module);
 
-    if cx.should_write_ir {
+    if crate::pretty_clif::should_write_ir(tcx.sess) {
         crate::pretty_clif::write_clif_file(
             tcx.output_filenames(()),
             &symbol_name,
@@ -146,11 +150,12 @@ pub(crate) fn codegen_fn<'tcx>(
 }
 
 pub(crate) fn compile_fn(
-    cx: &mut crate::CodegenCx,
     profiler: &SelfProfilerRef,
     output_filenames: &OutputFilenames,
+    should_write_ir: bool,
     cached_context: &mut Context,
     module: &mut dyn Module,
+    debug_context: Option<&mut DebugContext>,
     global_asm: &mut String,
     codegened_func: CodegenedFunction,
 ) {
@@ -195,7 +200,7 @@ pub(crate) fn compile_fn(
 
     // Define function
     profiler.generic_activity("define function").run(|| {
-        context.want_disasm = cx.should_write_ir;
+        context.want_disasm = should_write_ir;
         match module.define_function(codegened_func.func_id, context) {
             Ok(()) => {}
             Err(ModuleError::Compilation(CodegenError::ImplLimitExceeded)) => {
@@ -225,7 +230,7 @@ pub(crate) fn compile_fn(
         }
     });
 
-    if cx.should_write_ir {
+    if should_write_ir {
         // Write optimized function to file for debugging
         crate::pretty_clif::write_clif_file(
             output_filenames,
@@ -246,7 +251,6 @@ pub(crate) fn compile_fn(
     }
 
     // Define debuginfo for function
-    let debug_context = &mut cx.debug_context;
     profiler.generic_activity("generate debug info").run(|| {
         if let Some(debug_context) = debug_context {
             codegened_func.func_debug_cx.unwrap().finalize(

src/common.rs

@@ -6,6 +6,7 @@ use rustc_middle::ty::TypeFoldable;
 use rustc_middle::ty::layout::{
     self, FnAbiError, FnAbiOfHelpers, FnAbiRequest, LayoutError, LayoutOfHelpers,
 };
+use rustc_span::Symbol;
 use rustc_span::source_map::Spanned;
 use rustc_target::callconv::FnAbi;
 use rustc_target::spec::{HasTargetSpec, Target};
@@ -268,14 +269,15 @@ pub(crate) fn create_wrapper_function(
 }
 
 pub(crate) struct FunctionCx<'m, 'clif, 'tcx: 'm> {
-    pub(crate) cx: &'clif mut crate::CodegenCx,
     pub(crate) module: &'m mut dyn Module,
+    pub(crate) debug_context: Option<&'clif mut DebugContext>,
     pub(crate) tcx: TyCtxt<'tcx>,
     pub(crate) target_config: TargetFrontendConfig, // Cached from module
     pub(crate) pointer_type: Type,                  // Cached from module
     pub(crate) constants_cx: ConstantCx,
     pub(crate) func_debug_cx: Option<FunctionDebugContext>,
 
+    pub(crate) cgu_name: Symbol,
     pub(crate) instance: Instance<'tcx>,
     pub(crate) symbol_name: String,
     pub(crate) mir: &'tcx Body<'tcx>,
@@ -407,7 +409,7 @@ impl<'tcx> FunctionCx<'_, '_, 'tcx> {
     }
 
     pub(crate) fn set_debug_loc(&mut self, source_info: mir::SourceInfo) {
-        if let Some(debug_context) = &mut self.cx.debug_context {
+        if let Some(debug_context) = &mut self.debug_context {
             let (file_id, line, column) =
                 debug_context.get_span_loc(self.tcx, self.mir.span, source_info.span);
 

src/debuginfo/mod.rs

@@ -20,6 +20,7 @@ use rustc_codegen_ssa::debuginfo::type_names;
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::DefIdMap;
 use rustc_session::Session;
+use rustc_session::config::DebugInfo;
 use rustc_span::{FileNameDisplayPreference, SourceFileHash, StableSourceFileId};
 use rustc_target::callconv::FnAbi;
 
@@ -53,7 +54,19 @@ pub(crate) struct FunctionDebugContext {
 }
 
 impl DebugContext {
-    pub(crate) fn new(tcx: TyCtxt<'_>, isa: &dyn TargetIsa, cgu_name: &str) -> Self {
+    pub(crate) fn new(
+        tcx: TyCtxt<'_>,
+        isa: &dyn TargetIsa,
+        force_disable_debuginfo: bool,
+        cgu_name: &str,
+    ) -> Option<Self> {
+        if tcx.sess.opts.debuginfo == DebugInfo::None
+            || force_disable_debuginfo
+            || tcx.sess.target.options.is_like_windows
+        {
+            return None;
+        }
+
         let encoding = Encoding {
             format: Format::Dwarf32,
             // FIXME this should be configurable
@@ -146,7 +159,7 @@ impl DebugContext {
             AttributeValue::Udata(isa.frontend_config().pointer_bytes().into()),
         );
 
-        DebugContext {
+        Some(DebugContext {
             endian,
             dwarf,
             unit_range_list: RangeList(Vec::new()),
@@ -155,7 +168,7 @@ impl DebugContext {
             namespace_map: DefIdMap::default(),
             array_size_type,
             filename_display_preference,
-        }
+        })
     }
 
     fn item_namespace(&mut self, tcx: TyCtxt<'_>, def_id: DefId) -> UnitEntryId {

src/driver/aot.rs

@@ -25,9 +25,8 @@ use rustc_middle::mir::mono::{
     CodegenUnit, Linkage as RLinkage, MonoItem, MonoItemData, Visibility,
 };
 use rustc_session::Session;
-use rustc_session::config::{DebugInfo, OutFileName, OutputFilenames, OutputType};
+use rustc_session::config::{OutFileName, OutputFilenames, OutputType};
 
-use crate::CodegenCx;
 use crate::base::CodegenedFunction;
 use crate::concurrency_limiter::{ConcurrencyLimiter, ConcurrencyLimiterToken};
 use crate::debuginfo::TypeDebugContext;
@@ -512,18 +511,13 @@ fn codegen_cgu_content(
     tcx: TyCtxt<'_>,
     module: &mut dyn Module,
     cgu_name: rustc_span::Symbol,
-) -> (CodegenCx, Vec<CodegenedFunction>, String) {
+) -> (Option<DebugContext>, Vec<CodegenedFunction>, String) {
     let _timer = tcx.prof.generic_activity_with_arg("codegen cgu", cgu_name.as_str());
 
     let cgu = tcx.codegen_unit(cgu_name);
     let mono_items = cgu.items_in_deterministic_order(tcx);
 
-    let mut cx = crate::CodegenCx::new(
-        tcx,
-        module.isa(),
-        tcx.sess.opts.debuginfo != DebugInfo::None,
-        cgu_name,
-    );
+    let mut debug_context = DebugContext::new(tcx, module.isa(), false, cgu_name.as_str());
     let mut global_asm = String::new();
     let mut type_dbg = TypeDebugContext::default();
     super::predefine_mono_items(tcx, module, &mono_items);
@@ -550,7 +544,8 @@ fn codegen_cgu_content(
                 }
                 let codegened_function = crate::base::codegen_fn(
                     tcx,
-                    &mut cx,
+                    cgu_name,
+                    debug_context.as_mut(),
                     &mut type_dbg,
                     Function::new(),
                     module,
@@ -560,7 +555,7 @@ fn codegen_cgu_content(
             }
             MonoItem::Static(def_id) => {
                 let data_id = crate::constant::codegen_static(tcx, module, def_id);
-                if let Some(debug_context) = &mut cx.debug_context {
+                if let Some(debug_context) = debug_context.as_mut() {
                     debug_context.define_static(tcx, &mut type_dbg, def_id, data_id);
                 }
             }
@@ -574,7 +569,7 @@ fn codegen_cgu_content(
     }
     crate::main_shim::maybe_create_entry_wrapper(tcx, module, false, cgu.is_primary());
 
-    (cx, codegened_functions, global_asm)
+    (debug_context, codegened_functions, global_asm)
 }
 
 fn module_codegen(
@@ -587,7 +582,7 @@ fn module_codegen(
 ) -> OngoingModuleCodegen {
     let mut module = make_module(tcx.sess, cgu_name.as_str().to_string());
 
-    let (mut cx, codegened_functions, mut global_asm) =
+    let (mut debug_context, codegened_functions, mut global_asm) =
         codegen_cgu_content(tcx, &mut module, cgu_name);
 
     let cgu_name = cgu_name.as_str().to_owned();
@@ -597,6 +592,7 @@ fn module_codegen(
     let profiler = tcx.prof.clone();
     let invocation_temp = tcx.sess.invocation_temp.clone();
     let output_filenames = tcx.output_filenames(()).clone();
+    let should_write_ir = crate::pretty_clif::should_write_ir(tcx.sess);
 
     OngoingModuleCodegen::Async(std::thread::spawn(move || {
         profiler.clone().generic_activity_with_arg("compile functions", &*cgu_name).run(|| {
@@ -607,11 +603,12 @@ fn module_codegen(
             let mut cached_context = Context::new();
             for codegened_func in codegened_functions {
                 crate::base::compile_fn(
-                    &mut cx,
                     &profiler,
                     &output_filenames,
+                    should_write_ir,
                     &mut cached_context,
                     &mut module,
+                    debug_context.as_mut(),
                     &mut global_asm,
                     codegened_func,
                 );
@@ -636,7 +633,7 @@ fn module_codegen(
                     &profiler,
                     cgu_name,
                     module,
-                    cx.debug_context,
+                    debug_context,
                     global_asm_object_file,
                     &producer,
                 )

src/driver/jit.rs

@@ -12,12 +12,11 @@ use rustc_session::Session;
 use rustc_session::config::OutputFilenames;
 use rustc_span::sym;
 
-use crate::CodegenCx;
 use crate::debuginfo::TypeDebugContext;
 use crate::prelude::*;
 use crate::unwind_module::UnwindModule;
 
-fn create_jit_module(tcx: TyCtxt<'_>) -> (UnwindModule<JITModule>, CodegenCx) {
+fn create_jit_module(tcx: TyCtxt<'_>) -> (UnwindModule<JITModule>, Option<DebugContext>) {
     let crate_info = CrateInfo::new(tcx, "dummy_target_cpu".to_string());
 
     let isa = crate::build_isa(tcx.sess, true);
@@ -26,7 +25,7 @@ fn create_jit_module(tcx: TyCtxt<'_>) -> (UnwindModule<JITModule>, CodegenCx) {
     jit_builder.symbol_lookup_fn(dep_symbol_lookup_fn(tcx.sess, crate_info));
     let mut jit_module = UnwindModule::new(JITModule::new(jit_builder), false);
 
-    let cx = crate::CodegenCx::new(tcx, jit_module.isa(), false, sym::dummy_cgu_name);
+    let cx = DebugContext::new(tcx, jit_module.isa(), false, "dummy_cgu_name");
 
     crate::allocator::codegen(tcx, &mut jit_module);
 
@@ -43,7 +42,8 @@ pub(crate) fn run_jit(tcx: TyCtxt<'_>, jit_args: Vec<String>) -> ! {
     }
 
     let output_filenames = tcx.output_filenames(());
-    let (mut jit_module, mut cx) = create_jit_module(tcx);
+    let should_write_ir = crate::pretty_clif::should_write_ir(tcx.sess);
+    let (mut jit_module, mut debug_context) = create_jit_module(tcx);
     let mut cached_context = Context::new();
 
     let cgus = tcx.collect_and_partition_mono_items(()).codegen_units;
@@ -63,7 +63,8 @@ pub(crate) fn run_jit(tcx: TyCtxt<'_>, jit_args: Vec<String>) -> ! {
                     codegen_and_compile_fn(
                         tcx,
                         &output_filenames,
-                        &mut cx,
+                        should_write_ir,
+                        debug_context.as_mut(),
                         &mut cached_context,
                         &mut jit_module,
                         inst,
@@ -122,7 +123,8 @@ pub(crate) fn run_jit(tcx: TyCtxt<'_>, jit_args: Vec<String>) -> ! {
 fn codegen_and_compile_fn<'tcx>(
     tcx: TyCtxt<'tcx>,
     output_filenames: &OutputFilenames,
-    cx: &mut crate::CodegenCx,
+    should_write_ir: bool,
+    mut debug_context: Option<&mut DebugContext>,
     cached_context: &mut Context,
     module: &mut dyn Module,
     instance: Instance<'tcx>,
@@ -143,7 +145,8 @@ fn codegen_and_compile_fn<'tcx>(
         let cached_func = std::mem::replace(&mut cached_context.func, Function::new());
         let codegened_func = crate::base::codegen_fn(
             tcx,
-            cx,
+            sym::dummy_cgu_name,
+            debug_context.as_deref_mut(),
             &mut TypeDebugContext::default(),
             cached_func,
             module,
@@ -152,11 +155,12 @@ fn codegen_and_compile_fn<'tcx>(
 
         let mut global_asm = String::new();
         crate::base::compile_fn(
-            cx,
             &tcx.prof,
             output_filenames,
+            should_write_ir,
             cached_context,
             module,
+            debug_context.as_deref_mut(),
             &mut global_asm,
             codegened_func,
         );

src/inline_asm.rs

@@ -125,7 +125,7 @@ pub(crate) fn codegen_inline_asm_terminator<'tcx>(
                     let wrapper_name = format!(
                         "{}__inline_asm_{}_wrapper_n{}",
                         fx.symbol_name,
-                        fx.cx.cgu_name.as_str().replace('.', "__").replace('-', "_"),
+                        fx.cgu_name.as_str().replace('.', "__").replace('-', "_"),
                         fx.inline_asm_index,
                     );
                     fx.inline_asm_index += 1;
@@ -189,7 +189,7 @@ pub(crate) fn codegen_inline_asm_inner<'tcx>(
     let asm_name = format!(
         "{}__inline_asm_{}_n{}",
         fx.symbol_name,
-        fx.cx.cgu_name.as_str().replace('.', "__").replace('-', "_"),
+        fx.cgu_name.as_str().replace('.', "__").replace('-', "_"),
         fx.inline_asm_index,
     );
     fx.inline_asm_index += 1;