1 #![doc = include_str!("doc.md")]
3 use rustc_codegen_ssa::mir::debuginfo::VariableKind::*;
5 use self::metadata::{file_metadata, type_metadata, TypeMap};
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, FxHashSet};
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::{HasTyCtxt, LayoutOf};
29 use rustc_middle::ty::subst::{GenericArgKind, SubstsRef};
30 use rustc_middle::ty::{self, Instance, ParamEnv, Ty, TypeFoldable};
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, Span};
35 use rustc_target::abi::{Primitive, Size};
38 use smallvec::SmallVec;
39 use std::cell::RefCell;
49 pub use self::create_scope_map::compute_mir_scopes;
50 pub use self::metadata::create_global_var_metadata;
51 pub use self::metadata::extend_scope_to_file;
53 #[allow(non_upper_case_globals)]
54 const DW_TAG_auto_variable: c_uint = 0x100;
55 #[allow(non_upper_case_globals)]
56 const DW_TAG_arg_variable: c_uint = 0x101;
58 /// A context object for maintaining all state needed by the debuginfo module.
59 pub struct CrateDebugContext<'a, 'tcx> {
60 llcontext: &'a llvm::Context,
61 llmod: &'a llvm::Module,
62 builder: &'a mut DIBuilder<'a>,
63 created_files: RefCell<FxHashMap<(Option<String>, Option<String>), &'a DIFile>>,
64 created_enum_disr_types: RefCell<FxHashMap<(DefId, Primitive), &'a DIType>>,
66 type_map: RefCell<TypeMap<'a, 'tcx>>,
67 namespace_map: RefCell<DefIdMap<&'a DIScope>>,
69 // This collection is used to assert that composite types (structs, enums,
70 // ...) have their members only set once:
71 composite_types_completed: RefCell<FxHashSet<&'a DIType>>,
74 impl Drop for CrateDebugContext<'a, 'tcx> {
77 llvm::LLVMRustDIBuilderDispose(&mut *(self.builder as *mut _));
82 impl<'a, 'tcx> CrateDebugContext<'a, 'tcx> {
83 pub fn new(llmod: &'a llvm::Module) -> Self {
84 debug!("CrateDebugContext::new");
85 let builder = unsafe { llvm::LLVMRustDIBuilderCreate(llmod) };
86 // DIBuilder inherits context from the module, so we'd better use the same one
87 let llcontext = unsafe { llvm::LLVMGetModuleContext(llmod) };
92 created_files: Default::default(),
93 created_enum_disr_types: Default::default(),
94 type_map: Default::default(),
95 namespace_map: RefCell::new(Default::default()),
96 composite_types_completed: Default::default(),
100 pub fn finalize(&self, sess: &Session) {
102 llvm::LLVMRustDIBuilderFinalize(self.builder);
104 // Debuginfo generation in LLVM by default uses a higher
105 // version of dwarf than macOS currently understands. We can
106 // instruct LLVM to emit an older version of dwarf, however,
107 // for macOS to understand. For more info see #11352
108 // This can be overridden using --llvm-opts -dwarf-version,N.
109 // Android has the same issue (#22398)
110 if let Some(version) = sess.target.dwarf_version {
111 llvm::LLVMRustAddModuleFlag(self.llmod, "Dwarf Version\0".as_ptr().cast(), version)
114 // Indicate that we want CodeView debug information on MSVC
115 if sess.target.is_like_msvc {
116 llvm::LLVMRustAddModuleFlag(self.llmod, "CodeView\0".as_ptr().cast(), 1)
119 // Prevent bitcode readers from deleting the debug info.
120 let ptr = "Debug Info Version\0".as_ptr();
121 llvm::LLVMRustAddModuleFlag(
124 llvm::LLVMRustDebugMetadataVersion(),
130 /// Creates any deferred debug metadata nodes
131 pub fn finalize(cx: &CodegenCx<'_, '_>) {
132 if let Some(dbg_cx) = &cx.dbg_cx {
135 if gdb::needs_gdb_debug_scripts_section(cx) {
136 // Add a .debug_gdb_scripts section to this compile-unit. This will
137 // cause GDB to try and load the gdb_load_rust_pretty_printers.py file,
138 // which activates the Rust pretty printers for binary this section is
140 gdb::get_or_insert_gdb_debug_scripts_section_global(cx);
143 dbg_cx.finalize(cx.sess());
147 impl DebugInfoBuilderMethods for Builder<'a, 'll, 'tcx> {
148 // FIXME(eddyb) find a common convention for all of the debuginfo-related
149 // names (choose between `dbg`, `debug`, `debuginfo`, `debug_info` etc.).
152 dbg_var: &'ll DIVariable,
153 dbg_loc: &'ll DILocation,
154 variable_alloca: Self::Value,
156 indirect_offsets: &[Size],
158 // Convert the direct and indirect offsets to address ops.
159 // FIXME(eddyb) use `const`s instead of getting the values via FFI,
160 // the values should match the ones in the DWARF standard anyway.
161 let op_deref = || unsafe { llvm::LLVMRustDIBuilderCreateOpDeref() };
162 let op_plus_uconst = || unsafe { llvm::LLVMRustDIBuilderCreateOpPlusUconst() };
163 let mut addr_ops = SmallVec::<[_; 8]>::new();
165 if direct_offset.bytes() > 0 {
166 addr_ops.push(op_plus_uconst());
167 addr_ops.push(direct_offset.bytes() as i64);
169 for &offset in indirect_offsets {
170 addr_ops.push(op_deref());
171 if offset.bytes() > 0 {
172 addr_ops.push(op_plus_uconst());
173 addr_ops.push(offset.bytes() as i64);
178 // FIXME(eddyb) replace `llvm.dbg.declare` with `llvm.dbg.addr`.
179 llvm::LLVMRustDIBuilderInsertDeclareAtEnd(
184 addr_ops.len() as c_uint,
191 fn set_dbg_loc(&mut self, dbg_loc: &'ll DILocation) {
193 let dbg_loc_as_llval = llvm::LLVMRustMetadataAsValue(self.cx().llcx, dbg_loc);
194 llvm::LLVMSetCurrentDebugLocation(self.llbuilder, dbg_loc_as_llval);
198 fn insert_reference_to_gdb_debug_scripts_section_global(&mut self) {
199 gdb::insert_reference_to_gdb_debug_scripts_section_global(self)
202 fn set_var_name(&mut self, value: &'ll Value, name: &str) {
203 // Avoid wasting time if LLVM value names aren't even enabled.
204 if self.sess().fewer_names() {
208 // Only function parameters and instructions are local to a function,
209 // don't change the name of anything else (e.g. globals).
210 let param_or_inst = unsafe {
211 llvm::LLVMIsAArgument(value).is_some() || llvm::LLVMIsAInstruction(value).is_some()
217 // Avoid replacing the name if it already exists.
218 // While we could combine the names somehow, it'd
219 // get noisy quick, and the usefulness is dubious.
220 if llvm::get_value_name(value).is_empty() {
221 llvm::set_value_name(value, name.as_bytes());
226 /// A source code location used to generate debug information.
227 // FIXME(eddyb) rename this to better indicate it's a duplicate of
228 // `rustc_span::Loc` rather than `DILocation`, perhaps by making
229 // `lookup_char_pos` return the right information instead.
230 pub struct DebugLoc {
231 /// Information about the original source file.
232 pub file: Lrc<SourceFile>,
233 /// The (1-based) line number.
235 /// The (1-based) column number.
239 impl CodegenCx<'ll, '_> {
240 /// Looks up debug source information about a `BytePos`.
241 // FIXME(eddyb) rename this to better indicate it's a duplicate of
242 // `lookup_char_pos` rather than `dbg_loc`, perhaps by making
243 // `lookup_char_pos` return the right information instead.
244 pub fn lookup_debug_loc(&self, pos: BytePos) -> DebugLoc {
245 let (file, line, col) = match self.sess().source_map().lookup_line(pos) {
246 Ok(SourceFileAndLine { sf: file, line }) => {
247 let line_pos = file.line_begin_pos(pos);
249 // Use 1-based indexing.
250 let line = (line + 1) as u32;
251 let col = (pos - line_pos).to_u32() + 1;
255 Err(file) => (file, UNKNOWN_LINE_NUMBER, UNKNOWN_COLUMN_NUMBER),
258 // For MSVC, omit the column number.
259 // Otherwise, emit it. This mimics clang behaviour.
260 // See discussion in https://github.com/rust-lang/rust/issues/42921
261 if self.sess().target.is_like_msvc {
262 DebugLoc { file, line, col: UNKNOWN_COLUMN_NUMBER }
264 DebugLoc { file, line, col }
269 impl DebugInfoMethods<'tcx> for CodegenCx<'ll, 'tcx> {
270 fn create_function_debug_context(
272 instance: Instance<'tcx>,
273 fn_abi: &FnAbi<'tcx, Ty<'tcx>>,
275 mir: &mir::Body<'tcx>,
276 ) -> Option<FunctionDebugContext<&'ll DIScope, &'ll DILocation>> {
277 if self.sess().opts.debuginfo == DebugInfo::None {
281 // Initialize fn debug context (including scopes).
282 // FIXME(eddyb) figure out a way to not need `Option` for `dbg_scope`.
283 let empty_scope = DebugScope {
286 file_start_pos: BytePos(0),
287 file_end_pos: BytePos(0),
289 let mut fn_debug_context =
290 FunctionDebugContext { scopes: IndexVec::from_elem(empty_scope, &mir.source_scopes) };
292 // Fill in all the scopes, with the information from the MIR body.
297 self.dbg_scope_fn(instance, fn_abi, Some(llfn)),
298 &mut fn_debug_context,
301 Some(fn_debug_context)
306 instance: Instance<'tcx>,
307 fn_abi: &FnAbi<'tcx, Ty<'tcx>>,
308 maybe_definition_llfn: Option<&'ll Value>,
310 let def_id = instance.def_id();
311 let containing_scope = get_containing_scope(self, instance);
312 let span = self.tcx.def_span(def_id);
313 let loc = self.lookup_debug_loc(span.lo());
314 let file_metadata = file_metadata(self, &loc.file);
316 let function_type_metadata = unsafe {
317 let fn_signature = get_function_signature(self, fn_abi);
318 llvm::LLVMRustDIBuilderCreateSubroutineType(DIB(self), fn_signature)
321 let mut name = String::new();
322 type_names::push_item_name(self.tcx(), def_id, false, &mut name);
324 // Find the enclosing function, in case this is a closure.
325 let enclosing_fn_def_id = self.tcx().typeck_root_def_id(def_id);
327 // Get_template_parameters() will append a `<...>` clause to the function
328 // name if necessary.
329 let generics = self.tcx().generics_of(enclosing_fn_def_id);
330 let substs = instance.substs.truncate_to(self.tcx(), generics);
331 let template_parameters = get_template_parameters(self, generics, substs, &mut name);
333 let linkage_name = &mangled_name_of_instance(self, instance).name;
334 // Omit the linkage_name if it is the same as subprogram name.
335 let linkage_name = if &name == linkage_name { "" } else { linkage_name };
337 // FIXME(eddyb) does this need to be separate from `loc.line` for some reason?
338 let scope_line = loc.line;
340 let mut flags = DIFlags::FlagPrototyped;
342 if fn_abi.ret.layout.abi.is_uninhabited() {
343 flags |= DIFlags::FlagNoReturn;
346 let mut spflags = DISPFlags::SPFlagDefinition;
347 if is_node_local_to_unit(self, def_id) {
348 spflags |= DISPFlags::SPFlagLocalToUnit;
350 if self.sess().opts.optimize != config::OptLevel::No {
351 spflags |= DISPFlags::SPFlagOptimized;
353 if let Some((id, _)) = self.tcx.entry_fn(()) {
355 spflags |= DISPFlags::SPFlagMainSubprogram;
360 return llvm::LLVMRustDIBuilderCreateFunction(
363 name.as_ptr().cast(),
365 linkage_name.as_ptr().cast(),
369 function_type_metadata,
373 maybe_definition_llfn,
379 fn get_function_signature<'ll, 'tcx>(
380 cx: &CodegenCx<'ll, 'tcx>,
381 fn_abi: &FnAbi<'tcx, Ty<'tcx>>,
383 if cx.sess().opts.debuginfo == DebugInfo::Limited {
384 return create_DIArray(DIB(cx), &[]);
387 let mut signature = Vec::with_capacity(fn_abi.args.len() + 1);
389 // Return type -- llvm::DIBuilder wants this at index 0
390 signature.push(if fn_abi.ret.is_ignore() {
393 Some(type_metadata(cx, fn_abi.ret.layout.ty, rustc_span::DUMMY_SP))
397 if cx.sess().target.is_like_msvc {
399 // There is a bug in MSDIA that leads to a crash when it encounters
400 // a fixed-size array of `u8` or something zero-sized in a
401 // function-type (see #40477).
402 // As a workaround, we replace those fixed-size arrays with a
403 // pointer-type. So a function `fn foo(a: u8, b: [u8; 4])` would
404 // appear as `fn foo(a: u8, b: *const u8)` in debuginfo,
405 // and a function `fn bar(x: [(); 7])` as `fn bar(x: *const ())`.
406 // This transformed type is wrong, but these function types are
407 // already inaccurate due to ABI adjustments (see #42800).
408 signature.extend(fn_abi.args.iter().map(|arg| {
409 let t = arg.layout.ty;
410 let t = match t.kind() {
412 if (*ct == cx.tcx.types.u8) || cx.layout_of(ct).is_zst() =>
414 cx.tcx.mk_imm_ptr(ct)
418 Some(type_metadata(cx, t, rustc_span::DUMMY_SP))
425 .map(|arg| Some(type_metadata(cx, arg.layout.ty, rustc_span::DUMMY_SP))),
429 create_DIArray(DIB(cx), &signature[..])
432 fn get_template_parameters<'ll, 'tcx>(
433 cx: &CodegenCx<'ll, 'tcx>,
434 generics: &ty::Generics,
435 substs: SubstsRef<'tcx>,
436 name_to_append_suffix_to: &mut String,
438 type_names::push_generic_params(
440 cx.tcx.normalize_erasing_regions(ty::ParamEnv::reveal_all(), substs),
441 name_to_append_suffix_to,
444 if substs.types().next().is_none() {
445 return create_DIArray(DIB(cx), &[]);
448 // Again, only create type information if full debuginfo is enabled
449 let template_params: Vec<_> = if cx.sess().opts.debuginfo == DebugInfo::Full {
450 let names = get_parameter_names(cx, generics);
451 iter::zip(substs, names)
452 .filter_map(|(kind, name)| {
453 if let GenericArgKind::Type(ty) = kind.unpack() {
455 cx.tcx.normalize_erasing_regions(ParamEnv::reveal_all(), ty);
456 let actual_type_metadata =
457 type_metadata(cx, actual_type, rustc_span::DUMMY_SP);
458 let name = name.as_str();
460 Some(llvm::LLVMRustDIBuilderCreateTemplateTypeParameter(
463 name.as_ptr().cast(),
465 actual_type_metadata,
477 create_DIArray(DIB(cx), &template_params[..])
480 fn get_parameter_names(cx: &CodegenCx<'_, '_>, generics: &ty::Generics) -> Vec<Symbol> {
481 let mut names = generics.parent.map_or_else(Vec::new, |def_id| {
482 get_parameter_names(cx, cx.tcx.generics_of(def_id))
484 names.extend(generics.params.iter().map(|param| param.name));
488 fn get_containing_scope<'ll, 'tcx>(
489 cx: &CodegenCx<'ll, 'tcx>,
490 instance: Instance<'tcx>,
492 // First, let's see if this is a method within an inherent impl. Because
493 // if yes, we want to make the result subroutine DIE a child of the
494 // subroutine's self-type.
495 let self_type = cx.tcx.impl_of_method(instance.def_id()).and_then(|impl_def_id| {
496 // If the method does *not* belong to a trait, proceed
497 if cx.tcx.trait_id_of_impl(impl_def_id).is_none() {
498 let impl_self_ty = cx.tcx.subst_and_normalize_erasing_regions(
500 ty::ParamEnv::reveal_all(),
501 cx.tcx.type_of(impl_def_id),
504 // Only "class" methods are generally understood by LLVM,
505 // so avoid methods on other types (e.g., `<*mut T>::null`).
506 match impl_self_ty.kind() {
507 ty::Adt(def, ..) if !def.is_box() => {
508 // Again, only create type information if full debuginfo is enabled
509 if cx.sess().opts.debuginfo == DebugInfo::Full
510 && !impl_self_ty.definitely_needs_subst(cx.tcx)
512 Some(type_metadata(cx, impl_self_ty, rustc_span::DUMMY_SP))
514 Some(namespace::item_namespace(cx, def.did))
520 // For trait method impls we still use the "parallel namespace"
526 self_type.unwrap_or_else(|| {
527 namespace::item_namespace(
530 krate: instance.def_id().krate,
533 .def_key(instance.def_id())
535 .expect("get_containing_scope: missing parent?"),
545 inlined_at: Option<&'ll DILocation>,
547 ) -> &'ll DILocation {
548 let DebugLoc { line, col, .. } = self.lookup_debug_loc(span.lo());
550 unsafe { llvm::LLVMRustDIBuilderCreateDebugLocation(line, col, scope, inlined_at) }
553 fn create_vtable_metadata(
556 trait_ref: Option<ty::PolyExistentialTraitRef<'tcx>>,
559 metadata::create_vtable_metadata(self, ty, trait_ref, vtable)
562 fn extend_scope_to_file(
564 scope_metadata: &'ll DIScope,
565 file: &rustc_span::SourceFile,
566 ) -> &'ll DILexicalBlock {
567 metadata::extend_scope_to_file(self, scope_metadata, file)
570 fn debuginfo_finalize(&self) {
574 // FIXME(eddyb) find a common convention for all of the debuginfo-related
575 // names (choose between `dbg`, `debug`, `debuginfo`, `debug_info` etc.).
578 variable_name: Symbol,
579 variable_type: Ty<'tcx>,
580 scope_metadata: &'ll DIScope,
581 variable_kind: VariableKind,
583 ) -> &'ll DIVariable {
584 let loc = self.lookup_debug_loc(span.lo());
585 let file_metadata = file_metadata(self, &loc.file);
587 let type_metadata = type_metadata(self, variable_type, span);
589 let (argument_index, dwarf_tag) = match variable_kind {
590 ArgumentVariable(index) => (index as c_uint, DW_TAG_arg_variable),
591 LocalVariable => (0, DW_TAG_auto_variable),
593 let align = self.align_of(variable_type);
595 let name = variable_name.as_str();
597 llvm::LLVMRustDIBuilderCreateVariable(
601 name.as_ptr().cast(),
609 align.bytes() as u32,