1 #![doc = include_str!("doc.md")]
3 use rustc_codegen_ssa::mir::debuginfo::VariableKind::*;
5 use self::metadata::{file_metadata, type_di_node};
6 use self::metadata::{UNKNOWN_COLUMN_NUMBER, UNKNOWN_LINE_NUMBER};
7 use self::namespace::mangled_name_of_instance;
8 use self::utils::{create_DIArray, is_node_local_to_unit, DIB};
10 use crate::abi::FnAbi;
11 use crate::builder::Builder;
12 use crate::common::CodegenCx;
14 use crate::llvm::debuginfo::{
15 DIArray, DIBuilder, DIFile, DIFlags, DILexicalBlock, DILocation, DISPFlags, DIScope, DIType,
18 use crate::value::Value;
20 use rustc_codegen_ssa::debuginfo::type_names;
21 use rustc_codegen_ssa::mir::debuginfo::{DebugScope, FunctionDebugContext, VariableKind};
22 use rustc_codegen_ssa::traits::*;
23 use rustc_data_structures::fx::FxHashMap;
24 use rustc_data_structures::sync::Lrc;
25 use rustc_hir::def_id::{DefId, DefIdMap};
26 use rustc_index::vec::IndexVec;
27 use rustc_middle::mir;
28 use rustc_middle::ty::layout::LayoutOf;
29 use rustc_middle::ty::subst::{GenericArgKind, SubstsRef};
30 use rustc_middle::ty::{self, Instance, ParamEnv, Ty, TypeVisitable};
31 use rustc_session::config::{self, DebugInfo};
32 use rustc_session::Session;
33 use rustc_span::symbol::Symbol;
34 use rustc_span::{self, BytePos, Pos, SourceFile, SourceFileAndLine, SourceFileHash, Span};
35 use rustc_target::abi::Size;
38 use smallvec::SmallVec;
39 use std::cell::OnceCell;
40 use std::cell::RefCell;
50 pub use self::create_scope_map::compute_mir_scopes;
51 pub use self::metadata::build_global_var_di_node;
52 pub use self::metadata::extend_scope_to_file;
54 #[allow(non_upper_case_globals)]
55 const DW_TAG_auto_variable: c_uint = 0x100;
56 #[allow(non_upper_case_globals)]
57 const DW_TAG_arg_variable: c_uint = 0x101;
59 /// A context object for maintaining all state needed by the debuginfo module.
60 pub struct CodegenUnitDebugContext<'ll, 'tcx> {
61 llcontext: &'ll llvm::Context,
62 llmod: &'ll llvm::Module,
63 builder: &'ll mut DIBuilder<'ll>,
64 created_files: RefCell<FxHashMap<Option<(u128, SourceFileHash)>, &'ll DIFile>>,
66 type_map: metadata::TypeMap<'ll, 'tcx>,
67 namespace_map: RefCell<DefIdMap<&'ll DIScope>>,
68 recursion_marker_type: OnceCell<&'ll DIType>,
71 impl Drop for CodegenUnitDebugContext<'_, '_> {
74 llvm::LLVMRustDIBuilderDispose(&mut *(self.builder as *mut _));
79 impl<'ll, 'tcx> CodegenUnitDebugContext<'ll, 'tcx> {
80 pub fn new(llmod: &'ll llvm::Module) -> Self {
81 debug!("CodegenUnitDebugContext::new");
82 let builder = unsafe { llvm::LLVMRustDIBuilderCreate(llmod) };
83 // DIBuilder inherits context from the module, so we'd better use the same one
84 let llcontext = unsafe { llvm::LLVMGetModuleContext(llmod) };
85 CodegenUnitDebugContext {
89 created_files: Default::default(),
90 type_map: Default::default(),
91 namespace_map: RefCell::new(Default::default()),
92 recursion_marker_type: OnceCell::new(),
96 pub fn finalize(&self, sess: &Session) {
98 llvm::LLVMRustDIBuilderFinalize(self.builder);
100 if !sess.target.is_like_msvc {
101 // Debuginfo generation in LLVM by default uses a higher
102 // version of dwarf than macOS currently understands. We can
103 // instruct LLVM to emit an older version of dwarf, however,
104 // for macOS to understand. For more info see #11352
105 // This can be overridden using --llvm-opts -dwarf-version,N.
106 // Android has the same issue (#22398)
107 let dwarf_version = sess
111 .unwrap_or(sess.target.default_dwarf_version);
112 llvm::LLVMRustAddModuleFlag(
114 llvm::LLVMModFlagBehavior::Warning,
115 "Dwarf Version\0".as_ptr().cast(),
119 // Indicate that we want CodeView debug information on MSVC
120 llvm::LLVMRustAddModuleFlag(
122 llvm::LLVMModFlagBehavior::Warning,
123 "CodeView\0".as_ptr().cast(),
128 // Prevent bitcode readers from deleting the debug info.
129 let ptr = "Debug Info Version\0".as_ptr();
130 llvm::LLVMRustAddModuleFlag(
132 llvm::LLVMModFlagBehavior::Warning,
134 llvm::LLVMRustDebugMetadataVersion(),
140 /// Creates any deferred debug metadata nodes
141 pub fn finalize(cx: &CodegenCx<'_, '_>) {
142 if let Some(dbg_cx) = &cx.dbg_cx {
145 if gdb::needs_gdb_debug_scripts_section(cx) {
146 // Add a .debug_gdb_scripts section to this compile-unit. This will
147 // cause GDB to try and load the gdb_load_rust_pretty_printers.py file,
148 // which activates the Rust pretty printers for binary this section is
150 gdb::get_or_insert_gdb_debug_scripts_section_global(cx);
153 dbg_cx.finalize(cx.sess());
157 impl<'ll> DebugInfoBuilderMethods for Builder<'_, 'll, '_> {
158 // FIXME(eddyb) find a common convention for all of the debuginfo-related
159 // names (choose between `dbg`, `debug`, `debuginfo`, `debug_info` etc.).
162 dbg_var: &'ll DIVariable,
163 dbg_loc: &'ll DILocation,
164 variable_alloca: Self::Value,
166 indirect_offsets: &[Size],
167 fragment: Option<Range<Size>>,
169 // Convert the direct and indirect offsets and fragment byte range to address ops.
170 // FIXME(eddyb) use `const`s instead of getting the values via FFI,
171 // the values should match the ones in the DWARF standard anyway.
172 let op_deref = || unsafe { llvm::LLVMRustDIBuilderCreateOpDeref() };
173 let op_plus_uconst = || unsafe { llvm::LLVMRustDIBuilderCreateOpPlusUconst() };
174 let op_llvm_fragment = || unsafe { llvm::LLVMRustDIBuilderCreateOpLLVMFragment() };
175 let mut addr_ops = SmallVec::<[u64; 8]>::new();
177 if direct_offset.bytes() > 0 {
178 addr_ops.push(op_plus_uconst());
179 addr_ops.push(direct_offset.bytes() as u64);
181 for &offset in indirect_offsets {
182 addr_ops.push(op_deref());
183 if offset.bytes() > 0 {
184 addr_ops.push(op_plus_uconst());
185 addr_ops.push(offset.bytes() as u64);
188 if let Some(fragment) = fragment {
189 // `DW_OP_LLVM_fragment` takes as arguments the fragment's
190 // offset and size, both of them in bits.
191 addr_ops.push(op_llvm_fragment());
192 addr_ops.push(fragment.start.bits() as u64);
193 addr_ops.push((fragment.end - fragment.start).bits() as u64);
197 // FIXME(eddyb) replace `llvm.dbg.declare` with `llvm.dbg.addr`.
198 llvm::LLVMRustDIBuilderInsertDeclareAtEnd(
203 addr_ops.len() as c_uint,
210 fn set_dbg_loc(&mut self, dbg_loc: &'ll DILocation) {
212 let dbg_loc_as_llval = llvm::LLVMRustMetadataAsValue(self.cx().llcx, dbg_loc);
213 llvm::LLVMSetCurrentDebugLocation(self.llbuilder, dbg_loc_as_llval);
217 fn insert_reference_to_gdb_debug_scripts_section_global(&mut self) {
218 gdb::insert_reference_to_gdb_debug_scripts_section_global(self)
221 fn set_var_name(&mut self, value: &'ll Value, name: &str) {
222 // Avoid wasting time if LLVM value names aren't even enabled.
223 if self.sess().fewer_names() {
227 // Only function parameters and instructions are local to a function,
228 // don't change the name of anything else (e.g. globals).
229 let param_or_inst = unsafe {
230 llvm::LLVMIsAArgument(value).is_some() || llvm::LLVMIsAInstruction(value).is_some()
236 // Avoid replacing the name if it already exists.
237 // While we could combine the names somehow, it'd
238 // get noisy quick, and the usefulness is dubious.
239 if llvm::get_value_name(value).is_empty() {
240 llvm::set_value_name(value, name.as_bytes());
245 /// A source code location used to generate debug information.
246 // FIXME(eddyb) rename this to better indicate it's a duplicate of
247 // `rustc_span::Loc` rather than `DILocation`, perhaps by making
248 // `lookup_char_pos` return the right information instead.
249 pub struct DebugLoc {
250 /// Information about the original source file.
251 pub file: Lrc<SourceFile>,
252 /// The (1-based) line number.
254 /// The (1-based) column number.
258 impl CodegenCx<'_, '_> {
259 /// Looks up debug source information about a `BytePos`.
260 // FIXME(eddyb) rename this to better indicate it's a duplicate of
261 // `lookup_char_pos` rather than `dbg_loc`, perhaps by making
262 // `lookup_char_pos` return the right information instead.
263 pub fn lookup_debug_loc(&self, pos: BytePos) -> DebugLoc {
264 let (file, line, col) = match self.sess().source_map().lookup_line(pos) {
265 Ok(SourceFileAndLine { sf: file, line }) => {
266 let line_pos = file.line_begin_pos(pos);
268 // Use 1-based indexing.
269 let line = (line + 1) as u32;
270 let col = (pos - line_pos).to_u32() + 1;
274 Err(file) => (file, UNKNOWN_LINE_NUMBER, UNKNOWN_COLUMN_NUMBER),
277 // For MSVC, omit the column number.
278 // Otherwise, emit it. This mimics clang behaviour.
279 // See discussion in https://github.com/rust-lang/rust/issues/42921
280 if self.sess().target.is_like_msvc {
281 DebugLoc { file, line, col: UNKNOWN_COLUMN_NUMBER }
283 DebugLoc { file, line, col }
288 impl<'ll, 'tcx> DebugInfoMethods<'tcx> for CodegenCx<'ll, 'tcx> {
289 fn create_function_debug_context(
291 instance: Instance<'tcx>,
292 fn_abi: &FnAbi<'tcx, Ty<'tcx>>,
294 mir: &mir::Body<'tcx>,
295 ) -> Option<FunctionDebugContext<&'ll DIScope, &'ll DILocation>> {
296 if self.sess().opts.debuginfo == DebugInfo::None {
300 // Initialize fn debug context (including scopes).
301 let empty_scope = DebugScope {
302 dbg_scope: self.dbg_scope_fn(instance, fn_abi, Some(llfn)),
304 file_start_pos: BytePos(0),
305 file_end_pos: BytePos(0),
307 let mut fn_debug_context =
308 FunctionDebugContext { scopes: IndexVec::from_elem(empty_scope, &mir.source_scopes) };
310 // Fill in all the scopes, with the information from the MIR body.
311 compute_mir_scopes(self, instance, mir, &mut fn_debug_context);
313 Some(fn_debug_context)
318 instance: Instance<'tcx>,
319 fn_abi: &FnAbi<'tcx, Ty<'tcx>>,
320 maybe_definition_llfn: Option<&'ll Value>,
324 let def_id = instance.def_id();
325 let containing_scope = get_containing_scope(self, instance);
326 let span = tcx.def_span(def_id);
327 let loc = self.lookup_debug_loc(span.lo());
328 let file_metadata = file_metadata(self, &loc.file);
330 let function_type_metadata = unsafe {
331 let fn_signature = get_function_signature(self, fn_abi);
332 llvm::LLVMRustDIBuilderCreateSubroutineType(DIB(self), fn_signature)
335 let mut name = String::new();
336 type_names::push_item_name(tcx, def_id, false, &mut name);
338 // Find the enclosing function, in case this is a closure.
339 let enclosing_fn_def_id = tcx.typeck_root_def_id(def_id);
341 // We look up the generics of the enclosing function and truncate the substs
342 // to their length in order to cut off extra stuff that might be in there for
343 // closures or generators.
344 let generics = tcx.generics_of(enclosing_fn_def_id);
345 let substs = instance.substs.truncate_to(tcx, generics);
347 type_names::push_generic_params(
349 tcx.normalize_erasing_regions(ty::ParamEnv::reveal_all(), substs),
353 let template_parameters = get_template_parameters(self, generics, substs);
355 let linkage_name = &mangled_name_of_instance(self, instance).name;
356 // Omit the linkage_name if it is the same as subprogram name.
357 let linkage_name = if &name == linkage_name { "" } else { linkage_name };
359 // FIXME(eddyb) does this need to be separate from `loc.line` for some reason?
360 let scope_line = loc.line;
362 let mut flags = DIFlags::FlagPrototyped;
364 if fn_abi.ret.layout.abi.is_uninhabited() {
365 flags |= DIFlags::FlagNoReturn;
368 let mut spflags = DISPFlags::SPFlagDefinition;
369 if is_node_local_to_unit(self, def_id) {
370 spflags |= DISPFlags::SPFlagLocalToUnit;
372 if self.sess().opts.optimize != config::OptLevel::No {
373 spflags |= DISPFlags::SPFlagOptimized;
375 if let Some((id, _)) = tcx.entry_fn(()) {
377 spflags |= DISPFlags::SPFlagMainSubprogram;
382 return llvm::LLVMRustDIBuilderCreateFunction(
385 name.as_ptr().cast(),
387 linkage_name.as_ptr().cast(),
391 function_type_metadata,
395 maybe_definition_llfn,
401 fn get_function_signature<'ll, 'tcx>(
402 cx: &CodegenCx<'ll, 'tcx>,
403 fn_abi: &FnAbi<'tcx, Ty<'tcx>>,
405 if cx.sess().opts.debuginfo == DebugInfo::Limited {
406 return create_DIArray(DIB(cx), &[]);
409 let mut signature = Vec::with_capacity(fn_abi.args.len() + 1);
411 // Return type -- llvm::DIBuilder wants this at index 0
412 signature.push(if fn_abi.ret.is_ignore() {
415 Some(type_di_node(cx, fn_abi.ret.layout.ty))
419 if cx.sess().target.is_like_msvc {
421 // There is a bug in MSDIA that leads to a crash when it encounters
422 // a fixed-size array of `u8` or something zero-sized in a
423 // function-type (see #40477).
424 // As a workaround, we replace those fixed-size arrays with a
425 // pointer-type. So a function `fn foo(a: u8, b: [u8; 4])` would
426 // appear as `fn foo(a: u8, b: *const u8)` in debuginfo,
427 // and a function `fn bar(x: [(); 7])` as `fn bar(x: *const ())`.
428 // This transformed type is wrong, but these function types are
429 // already inaccurate due to ABI adjustments (see #42800).
430 signature.extend(fn_abi.args.iter().map(|arg| {
431 let t = arg.layout.ty;
432 let t = match t.kind() {
434 if (*ct == cx.tcx.types.u8) || cx.layout_of(*ct).is_zst() =>
436 cx.tcx.mk_imm_ptr(*ct)
440 Some(type_di_node(cx, t))
444 .extend(fn_abi.args.iter().map(|arg| Some(type_di_node(cx, arg.layout.ty))));
447 create_DIArray(DIB(cx), &signature[..])
450 fn get_template_parameters<'ll, 'tcx>(
451 cx: &CodegenCx<'ll, 'tcx>,
452 generics: &ty::Generics,
453 substs: SubstsRef<'tcx>,
455 if substs.types().next().is_none() {
456 return create_DIArray(DIB(cx), &[]);
459 // Again, only create type information if full debuginfo is enabled
460 let template_params: Vec<_> = if cx.sess().opts.debuginfo == DebugInfo::Full {
461 let names = get_parameter_names(cx, generics);
462 iter::zip(substs, names)
463 .filter_map(|(kind, name)| {
464 if let GenericArgKind::Type(ty) = kind.unpack() {
466 cx.tcx.normalize_erasing_regions(ParamEnv::reveal_all(), ty);
467 let actual_type_metadata = type_di_node(cx, actual_type);
468 let name = name.as_str();
470 Some(llvm::LLVMRustDIBuilderCreateTemplateTypeParameter(
473 name.as_ptr().cast(),
475 actual_type_metadata,
487 create_DIArray(DIB(cx), &template_params)
490 fn get_parameter_names(cx: &CodegenCx<'_, '_>, generics: &ty::Generics) -> Vec<Symbol> {
491 let mut names = generics.parent.map_or_else(Vec::new, |def_id| {
492 get_parameter_names(cx, cx.tcx.generics_of(def_id))
494 names.extend(generics.params.iter().map(|param| param.name));
498 fn get_containing_scope<'ll, 'tcx>(
499 cx: &CodegenCx<'ll, 'tcx>,
500 instance: Instance<'tcx>,
502 // First, let's see if this is a method within an inherent impl. Because
503 // if yes, we want to make the result subroutine DIE a child of the
504 // subroutine's self-type.
505 let self_type = cx.tcx.impl_of_method(instance.def_id()).and_then(|impl_def_id| {
506 // If the method does *not* belong to a trait, proceed
507 if cx.tcx.trait_id_of_impl(impl_def_id).is_none() {
508 let impl_self_ty = cx.tcx.subst_and_normalize_erasing_regions(
510 ty::ParamEnv::reveal_all(),
511 cx.tcx.type_of(impl_def_id),
514 // Only "class" methods are generally understood by LLVM,
515 // so avoid methods on other types (e.g., `<*mut T>::null`).
516 match impl_self_ty.kind() {
517 ty::Adt(def, ..) if !def.is_box() => {
518 // Again, only create type information if full debuginfo is enabled
519 if cx.sess().opts.debuginfo == DebugInfo::Full
520 && !impl_self_ty.needs_subst()
522 Some(type_di_node(cx, impl_self_ty))
524 Some(namespace::item_namespace(cx, def.did()))
530 // For trait method impls we still use the "parallel namespace"
536 self_type.unwrap_or_else(|| {
537 namespace::item_namespace(
540 krate: instance.def_id().krate,
543 .def_key(instance.def_id())
545 .expect("get_containing_scope: missing parent?"),
555 inlined_at: Option<&'ll DILocation>,
557 ) -> &'ll DILocation {
558 let DebugLoc { line, col, .. } = self.lookup_debug_loc(span.lo());
560 unsafe { llvm::LLVMRustDIBuilderCreateDebugLocation(line, col, scope, inlined_at) }
563 fn create_vtable_debuginfo(
566 trait_ref: Option<ty::PolyExistentialTraitRef<'tcx>>,
569 metadata::create_vtable_di_node(self, ty, trait_ref, vtable)
572 fn extend_scope_to_file(
574 scope_metadata: &'ll DIScope,
575 file: &rustc_span::SourceFile,
576 ) -> &'ll DILexicalBlock {
577 metadata::extend_scope_to_file(self, scope_metadata, file)
580 fn debuginfo_finalize(&self) {
584 // FIXME(eddyb) find a common convention for all of the debuginfo-related
585 // names (choose between `dbg`, `debug`, `debuginfo`, `debug_info` etc.).
588 variable_name: Symbol,
589 variable_type: Ty<'tcx>,
590 scope_metadata: &'ll DIScope,
591 variable_kind: VariableKind,
593 ) -> &'ll DIVariable {
594 let loc = self.lookup_debug_loc(span.lo());
595 let file_metadata = file_metadata(self, &loc.file);
597 let type_metadata = type_di_node(self, variable_type);
599 let (argument_index, dwarf_tag) = match variable_kind {
600 ArgumentVariable(index) => (index as c_uint, DW_TAG_arg_variable),
601 LocalVariable => (0, DW_TAG_auto_variable),
603 let align = self.align_of(variable_type);
605 let name = variable_name.as_str();
607 llvm::LLVMRustDIBuilderCreateVariable(
611 name.as_ptr().cast(),
619 align.bytes() as u32,