feat(attr): Gen & pass JITDwarfShortName on demand

src/attributes.rs

@@ -7,6 +7,7 @@ use rustc_attr::InstructionSetAttr;
 #[cfg(feature = "master")]
 use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags;
 use rustc_middle::ty;
+use rustc_session::config::DebugInfo;
 use rustc_span::symbol::sym;
 
 use crate::gcc_util::{check_tied_features, to_gcc_features};
@@ -40,7 +41,8 @@ pub fn from_fn_attrs<'gcc, 'tcx>(
     #[cfg_attr(not(feature = "master"), allow(unused_variables))] func: Function<'gcc>,
     instance: ty::Instance<'tcx>,
 ) {
-    let codegen_fn_attrs = cx.tcx.codegen_fn_attrs(instance.def_id());
+    let def_id = instance.def_id();
+    let codegen_fn_attrs = cx.tcx.codegen_fn_attrs(def_id);
 
     #[cfg(feature = "master")]
     {
@@ -69,6 +71,16 @@ pub fn from_fn_attrs<'gcc, 'tcx>(
         if codegen_fn_attrs.flags.contains(CodegenFnAttrFlags::FFI_CONST) {
             func.add_attribute(FnAttribute::Const);
         }
+        if cx.sess().opts.debuginfo != DebugInfo::None
+            && !codegen_fn_attrs.flags.contains(CodegenFnAttrFlags::NO_MANGLE)
+            && codegen_fn_attrs.export_name.is_none()
+        {
+            let parent = cx.get_or_create_module(&instance);
+            let signature = cx.tcx.symbol_name(instance).to_string();
+            //let signature = cx.tcx.def_path_str(instance.def_id());
+            func.add_attribute(FnAttribute::JITDwarfShortName(signature));
+            func.set_parent_debug_namespace(parent);
+        }
     }
 
     let function_features = codegen_fn_attrs

src/base.rs

@@ -183,6 +183,11 @@ pub fn compile_codegen_unit(
         {
             let cx = CodegenCx::new(&context, cgu, tcx, target_info.supports_128bit_int());
 
+            // This should be set before the code is generated.
+            if cx.sess().opts.debuginfo != DebugInfo::None {
+                context.set_mangled_function_name(true);
+            }
+
             let mono_items = cgu.items_in_deterministic_order(tcx);
             for &(mono_item, data) in &mono_items {
                 mono_item.predefine::<Builder<'_, '_, '_>>(&cx, data.linkage, data.visibility);

src/context.rs

@@ -1,7 +1,8 @@
 use std::cell::{Cell, RefCell};
 
 use gccjit::{
-    Block, CType, Context, Function, FunctionPtrType, FunctionType, LValue, Location, RValue, Type,
+    Block, CType, Context, DebugNamespace, Function, FunctionPtrType, FunctionType, LValue,
+    Location, RValue, Type,
 };
 use rustc_codegen_ssa::base::wants_msvc_seh;
 use rustc_codegen_ssa::errors as ssa_errors;
@@ -86,6 +87,7 @@ pub struct CodegenCx<'gcc, 'tcx> {
     /// Cache generated vtables
     pub vtables:
         RefCell<FxHashMap<(Ty<'tcx>, Option<ty::PolyExistentialTraitRef<'tcx>>), RValue<'gcc>>>,
+    pub modules: RefCell<FxHashMap<Instance<'tcx>, DebugNamespace>>,
 
     // TODO(antoyo): improve the SSA API to not require those.
     /// Mapping from function pointer type to indexes of on stack parameters.
@@ -315,6 +317,7 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
             on_stack_params: Default::default(),
             on_stack_function_params: Default::default(),
             vtables: Default::default(),
+            modules: Default::default(),
             const_globals: Default::default(),
             global_lvalues: Default::default(),
             const_str_cache: Default::default(),

src/declare.rs

@@ -1,8 +1,9 @@
+use gccjit::{DebugNamespace, Function, FunctionType, GlobalKind, LValue, RValue, Type};
 #[cfg(feature = "master")]
 use gccjit::{FnAttribute, ToRValue};
-use gccjit::{Function, FunctionType, GlobalKind, LValue, RValue, Type};
 use rustc_codegen_ssa::traits::BaseTypeMethods;
-use rustc_middle::ty::Ty;
+//use rustc_middle::query::Key;
+use rustc_middle::ty::{Instance, Ty};
 use rustc_span::Symbol;
 use rustc_target::abi::call::FnAbi;
 
@@ -153,6 +154,28 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
         // TODO(antoyo): use a different field than globals, because this seems to return a function?
         self.globals.borrow().get(name).cloned()
     }
+
+    #[inline]
+    pub fn get_or_create_module(&self, instance: &Instance<'tcx>) -> DebugNamespace {
+        let mut bor = self.modules.borrow_mut();
+        if let Some(debug_namespace) = bor.get(&instance) {
+            *debug_namespace
+        } else {
+
+            let parent = None;
+            /* let parent = if let Some(parent) = self.tcx.opt_parent(instance.def_id()) {
+             *     let parent = todo!();
+             *     Some(self.get_or_create_module(parent))
+             * } else {
+             *     None
+             * }; */
+            let name = self.tcx.symbol_name(*instance).name;
+
+            let debug_namespace = self.context.new_debug_namespace(name, parent);
+            bor.insert(*instance, debug_namespace);
+            *bor.get(&instance).unwrap()
+        }
+    }
 }
 
 /// Declare a function.