[WIP] Disable debuginfo generation

Author: bjorn3

src/base.rs

@@ -26,15 +26,15 @@ pub(crate) struct CodegenedFunction {
     func_id: FuncId,
     func: Function,
     clif_comments: CommentWriter,
-    func_debug_cx: Option<FunctionDebugContext>,
+    //func_debug_cx: Option<FunctionDebugContext>,
     inline_asm: String,
 }
 
 pub(crate) fn codegen_fn<'tcx>(
     tcx: TyCtxt<'tcx>,
     cgu_name: Symbol,
-    mut debug_context: Option<&mut DebugContext>,
-    type_dbg: &mut TypeDebugContext<'tcx>,
+    //mut debug_context: Option<&mut DebugContext>,
+    //type_dbg: &mut TypeDebugContext<'tcx>,
     cached_func: Function,
     module: &mut dyn Module,
     instance: Instance<'tcx>,
@@ -65,9 +65,9 @@ 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() {
-        func.collect_debug_info();
-    }
+    //if cx.debug_context.is_some() {
+    //    func.collect_debug_info();
+    //}
 
     let mut bcx = FunctionBuilder::new(&mut func, &mut func_ctx);
 
@@ -84,23 +84,22 @@ pub(crate) fn codegen_fn<'tcx>(
     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) = debug_context.as_deref_mut() {
+    /*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
-    };
+    None
+    };*/
 
     let exception_slot = bcx.declare_var(pointer_type);
 
     let mut fx = FunctionCx {
         module,
-        debug_context,
+        //debug_context,
         tcx,
         target_config,
         pointer_type,
         constants_cx: ConstantCx::new(),
-        func_debug_cx,
-
+        //func_debug_cx,
         cgu_name,
         instance,
         symbol_name,
@@ -125,7 +124,7 @@ pub(crate) fn codegen_fn<'tcx>(
     // Recover all necessary data from fx, before accessing func will prevent future access to it.
     let symbol_name = fx.symbol_name;
     let clif_comments = fx.clif_comments;
-    let func_debug_cx = fx.func_debug_cx;
+    //let func_debug_cx = fx.func_debug_cx;
     let inline_asm = fx.inline_asm;
 
     fx.constants_cx.finalize(fx.tcx, &mut *fx.module);
@@ -144,7 +143,14 @@ 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, inline_asm }
+    CodegenedFunction {
+        symbol_name,
+        func_id,
+        func,
+        clif_comments,
+        //func_debug_cx,
+        inline_asm,
+    }
 }
 
 pub(crate) fn compile_fn(
@@ -153,7 +159,7 @@ pub(crate) fn compile_fn(
     should_write_ir: bool,
     cached_context: &mut Context,
     module: &mut dyn Module,
-    debug_context: Option<&mut DebugContext>,
+    //debug_context: Option<&mut DebugContext>,
     global_asm: &mut String,
     codegened_func: CodegenedFunction,
 ) {
@@ -248,6 +254,7 @@ pub(crate) fn compile_fn(
         }
     }
 
+    /*
     // Define debuginfo for function
     profiler.generic_activity("generate debug info").run(|| {
         if let Some(debug_context) = debug_context {
@@ -258,6 +265,7 @@ pub(crate) fn compile_fn(
             );
         }
     });
+    */
 }
 
 fn verify_func(tcx: TyCtxt<'_>, writer: &crate::pretty_clif::CommentWriter, func: &Function) {

src/common.rs

@@ -270,13 +270,12 @@ pub(crate) fn create_wrapper_function(
 
 pub(crate) struct FunctionCx<'m, 'clif, 'tcx: 'm> {
     pub(crate) module: &'m mut dyn Module,
-    pub(crate) debug_context: Option<&'clif mut DebugContext>,
+    //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) func_debug_cx: Option<FunctionDebugContext>,
     pub(crate) cgu_name: Symbol,
     pub(crate) instance: Instance<'tcx>,
     pub(crate) symbol_name: String,
@@ -406,14 +405,14 @@ impl<'tcx> FunctionCx<'_, '_, 'tcx> {
     }
 
     pub(crate) fn set_debug_loc(&mut self, source_info: mir::SourceInfo) {
-        if let Some(debug_context) = &mut self.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);
 
             let source_loc =
                 self.func_debug_cx.as_mut().unwrap().add_dbg_loc(file_id, line, column);
             self.bcx.set_srcloc(source_loc);
-        }
+        }*/
     }
 
     pub(crate) fn get_caller_location(&mut self, source_info: mir::SourceInfo) -> CValue<'tcx> {

src/driver/aot.rs

@@ -349,15 +349,15 @@ fn emit_cgu(
     prof: &SelfProfilerRef,
     name: String,
     module: UnwindModule<ObjectModule>,
-    debug: Option<DebugContext>,
+    //debug: Option<DebugContext>,
     global_asm_object_file: Option<PathBuf>,
     producer: &str,
 ) -> Result<ModuleCodegenResult, String> {
     let mut product = module.finish();
 
-    if let Some(mut debug) = debug {
-        debug.emit(&mut product);
-    }
+    // if let Some(mut debug) = debug {
+    //     debug.emit(&mut product);
+    // }
 
     let module_regular = emit_module(
         output_filenames,
@@ -512,15 +512,15 @@ fn codegen_cgu_content(
     tcx: TyCtxt<'_>,
     module: &mut dyn Module,
     cgu_name: rustc_span::Symbol,
-) -> (Option<DebugContext>, Vec<CodegenedFunction>, String) {
+) -> (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 debug_context = DebugContext::new(tcx, module.isa(), false, cgu_name.as_str());
+    //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();
+    //let mut type_dbg = TypeDebugContext::default();
     super::predefine_mono_items(tcx, module, &mono_items);
     let mut codegened_functions = vec![];
     for (mono_item, item_data) in mono_items {
@@ -546,8 +546,8 @@ fn codegen_cgu_content(
                 let codegened_function = crate::base::codegen_fn(
                     tcx,
                     cgu_name,
-                    debug_context.as_mut(),
-                    &mut type_dbg,
+                    //debug_context.as_mut(),
+                    //&mut type_dbg,
                     Function::new(),
                     module,
                     instance,
@@ -556,9 +556,9 @@ fn codegen_cgu_content(
             }
             MonoItem::Static(def_id) => {
                 let data_id = crate::constant::codegen_static(tcx, module, def_id);
-                if let Some(debug_context) = debug_context.as_mut() {
-                    debug_context.define_static(tcx, &mut type_dbg, def_id, data_id);
-                }
+                // if let Some(debug_context) = debug_context.as_mut() {
+                //     debug_context.define_static(tcx, &mut type_dbg, def_id, data_id);
+                // }
             }
             MonoItem::GlobalAsm(item_id) => {
                 rustc_codegen_ssa::base::codegen_global_asm(
@@ -570,7 +570,7 @@ fn codegen_cgu_content(
     }
     crate::main_shim::maybe_create_entry_wrapper(tcx, module, false, cgu.is_primary());
 
-    (debug_context, codegened_functions, global_asm)
+    (codegened_functions, global_asm)
 }
 
 fn module_codegen(
@@ -583,8 +583,7 @@ fn module_codegen(
 ) -> OngoingModuleCodegen {
     let mut module = make_module(tcx.sess, cgu_name.as_str().to_string());
 
-    let (mut debug_context, codegened_functions, mut global_asm) =
-        codegen_cgu_content(tcx, &mut module, cgu_name);
+    let (codegened_functions, mut global_asm) = codegen_cgu_content(tcx, &mut module, cgu_name);
 
     let cgu_name = cgu_name.as_str().to_owned();
 
@@ -609,7 +608,7 @@ fn module_codegen(
                     should_write_ir,
                     &mut cached_context,
                     &mut module,
-                    debug_context.as_mut(),
+                    //debug_context.as_mut(),
                     &mut global_asm,
                     codegened_func,
                 );
@@ -634,7 +633,7 @@ fn module_codegen(
                     &profiler,
                     cgu_name,
                     module,
-                    debug_context,
+                    //debug_context,
                     global_asm_object_file,
                     &producer,
                 )

src/driver/jit.rs

@@ -64,7 +64,7 @@ pub(crate) fn run_jit(tcx: TyCtxt<'_>, jit_args: Vec<String>) -> ! {
                         tcx,
                         &output_filenames,
                         should_write_ir,
-                        debug_context.as_mut(),
+                        //debug_context.as_mut(),
                         &mut cached_context,
                         &mut jit_module,
                         inst,
@@ -124,7 +124,7 @@ fn codegen_and_compile_fn<'tcx>(
     tcx: TyCtxt<'tcx>,
     output_filenames: &OutputFilenames,
     should_write_ir: bool,
-    mut debug_context: Option<&mut DebugContext>,
+    //mut debug_context: Option<&mut DebugContext>,
     cached_context: &mut Context,
     module: &mut dyn Module,
     instance: Instance<'tcx>,
@@ -146,8 +146,8 @@ fn codegen_and_compile_fn<'tcx>(
         let codegened_func = crate::base::codegen_fn(
             tcx,
             sym::dummy_cgu_name,
-            debug_context.as_deref_mut(),
-            &mut TypeDebugContext::default(),
+            //debug_context.as_deref_mut(),
+            //&mut TypeDebugContext::default(),
             cached_func,
             module,
             instance,
@@ -160,7 +160,7 @@ fn codegen_and_compile_fn<'tcx>(
             should_write_ir,
             cached_context,
             module,
-            debug_context.as_deref_mut(),
+            //debug_context.as_deref_mut(),
             &mut global_asm,
             codegened_func,
         );