1 use super::metadata::file_metadata;
3 use rustc_codegen_ssa::mir::debuginfo::{DebugScope, FunctionDebugContext};
4 use rustc_codegen_ssa::traits::*;
6 use crate::common::CodegenCx;
8 use crate::llvm::debuginfo::{DILocation, DIScope};
9 use rustc_middle::mir::{Body, SourceScope};
10 use rustc_middle::ty::layout::FnAbiOf;
11 use rustc_middle::ty::{self, Instance};
12 use rustc_session::config::DebugInfo;
14 use rustc_index::bit_set::BitSet;
15 use rustc_index::vec::Idx;
17 /// Produces DIScope DIEs for each MIR Scope which has variables defined in it.
18 // FIXME(eddyb) almost all of this should be in `rustc_codegen_ssa::mir::debuginfo`.
19 pub fn compute_mir_scopes<'ll, 'tcx>(
20 cx: &CodegenCx<'ll, 'tcx>,
21 instance: Instance<'tcx>,
23 debug_context: &mut FunctionDebugContext<&'ll DIScope, &'ll DILocation>,
25 // Find all scopes with variables defined in them.
26 let variables = if cx.sess().opts.debuginfo == DebugInfo::Full {
27 let mut vars = BitSet::new_empty(mir.source_scopes.len());
28 // FIXME(eddyb) take into account that arguments always have debuginfo,
29 // irrespective of their name (assuming full debuginfo is enabled).
30 // NOTE(eddyb) actually, on second thought, those are always in the
31 // function scope, which always exists.
32 for var_debug_info in &mir.var_debug_info {
33 vars.insert(var_debug_info.source_info.scope);
37 // Nothing to emit, of course.
40 let mut instantiated = BitSet::new_empty(mir.source_scopes.len());
41 // Instantiate all scopes.
42 for idx in 0..mir.source_scopes.len() {
43 let scope = SourceScope::new(idx);
44 make_mir_scope(cx, instance, mir, &variables, debug_context, &mut instantiated, scope);
46 assert!(instantiated.count() == mir.source_scopes.len());
49 fn make_mir_scope<'ll, 'tcx>(
50 cx: &CodegenCx<'ll, 'tcx>,
51 instance: Instance<'tcx>,
53 variables: &Option<BitSet<SourceScope>>,
54 debug_context: &mut FunctionDebugContext<&'ll DIScope, &'ll DILocation>,
55 instantiated: &mut BitSet<SourceScope>,
58 if instantiated.contains(scope) {
62 let scope_data = &mir.source_scopes[scope];
63 let parent_scope = if let Some(parent) = scope_data.parent_scope {
64 make_mir_scope(cx, instance, mir, variables, debug_context, instantiated, parent);
65 debug_context.scopes[parent]
67 // The root is the function itself.
68 let loc = cx.lookup_debug_loc(mir.span.lo());
69 debug_context.scopes[scope] = DebugScope {
70 file_start_pos: loc.file.start_pos,
71 file_end_pos: loc.file.end_pos,
72 ..debug_context.scopes[scope]
74 instantiated.insert(scope);
78 if let Some(vars) = variables && !vars.contains(scope) && scope_data.inlined.is_none() {
79 // Do not create a DIScope if there are no variables defined in this
80 // MIR `SourceScope`, and it's not `inlined`, to avoid debuginfo bloat.
81 debug_context.scopes[scope] = parent_scope;
82 instantiated.insert(scope);
86 let loc = cx.lookup_debug_loc(scope_data.span.lo());
87 let file_metadata = file_metadata(cx, &loc.file);
89 let dbg_scope = match scope_data.inlined {
90 Some((callee, _)) => {
91 // FIXME(eddyb) this would be `self.monomorphize(&callee)`
92 // if this is moved to `rustc_codegen_ssa::mir::debuginfo`.
93 let callee = cx.tcx.subst_and_normalize_erasing_regions(
95 ty::ParamEnv::reveal_all(),
98 let callee_fn_abi = cx.fn_abi_of_instance(callee, ty::List::empty());
99 cx.dbg_scope_fn(callee, callee_fn_abi, None)
102 llvm::LLVMRustDIBuilderCreateLexicalBlock(
104 parent_scope.dbg_scope,
112 let inlined_at = scope_data.inlined.map(|(_, callsite_span)| {
113 // FIXME(eddyb) this doesn't account for the macro-related
114 // `Span` fixups that `rustc_codegen_ssa::mir::debuginfo` does.
115 let callsite_scope = parent_scope.adjust_dbg_scope_for_span(cx, callsite_span);
116 cx.dbg_loc(callsite_scope, parent_scope.inlined_at, callsite_span)
119 debug_context.scopes[scope] = DebugScope {
121 inlined_at: inlined_at.or(parent_scope.inlined_at),
122 file_start_pos: loc.file.start_pos,
123 file_end_pos: loc.file.end_pos,
125 instantiated.insert(scope);