1 // See doc.rs for documentation.
4 use rustc_codegen_ssa::mir::debuginfo::VariableKind::*;
6 use self::metadata::{file_metadata, type_metadata, TypeMap};
7 use self::namespace::mangled_name_of_instance;
8 use self::source_loc::InternalDebugLocation::{self, UnknownLocation};
9 use self::type_names::compute_debuginfo_type_name;
10 use self::utils::{create_DIArray, is_node_local_to_unit, span_start, DIB};
13 use crate::llvm::debuginfo::{
14 DIArray, DIBuilder, DIFile, DIFlags, DILexicalBlock, DISPFlags, DIScope, DIType,
16 use rustc::middle::codegen_fn_attrs::CodegenFnAttrFlags;
17 use rustc::ty::subst::{GenericArgKind, SubstsRef};
18 use rustc_hir::def_id::{CrateNum, DefId, DefIdMap, LOCAL_CRATE};
20 use crate::abi::FnAbi;
21 use crate::builder::Builder;
22 use crate::common::CodegenCx;
23 use crate::value::Value;
25 use rustc::session::config::{self, DebugInfo};
26 use rustc::ty::{self, Instance, InstanceDef, ParamEnv, Ty};
27 use rustc_codegen_ssa::debuginfo::type_names;
28 use rustc_codegen_ssa::mir::debuginfo::{DebugScope, FunctionDebugContext, VariableKind};
29 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
30 use rustc_data_structures::small_c_str::SmallCStr;
31 use rustc_index::vec::IndexVec;
35 use std::cell::RefCell;
36 use std::ffi::CString;
38 use rustc::ty::layout::{self, HasTyCtxt, LayoutOf, Size};
39 use rustc_codegen_ssa::traits::*;
40 use rustc_span::symbol::Symbol;
41 use rustc_span::{self, BytePos, Pos, Span};
42 use smallvec::SmallVec;
52 pub use self::create_scope_map::compute_mir_scopes;
53 pub use self::metadata::create_global_var_metadata;
54 pub use self::metadata::extend_scope_to_file;
55 pub use self::source_loc::set_source_location;
57 #[allow(non_upper_case_globals)]
58 const DW_TAG_auto_variable: c_uint = 0x100;
59 #[allow(non_upper_case_globals)]
60 const DW_TAG_arg_variable: c_uint = 0x101;
62 /// A context object for maintaining all state needed by the debuginfo module.
63 pub struct CrateDebugContext<'a, 'tcx> {
64 llcontext: &'a llvm::Context,
65 llmod: &'a llvm::Module,
66 builder: &'a mut DIBuilder<'a>,
67 created_files: RefCell<FxHashMap<(Option<String>, Option<String>), &'a DIFile>>,
68 created_enum_disr_types: RefCell<FxHashMap<(DefId, layout::Primitive), &'a DIType>>,
70 type_map: RefCell<TypeMap<'a, 'tcx>>,
71 namespace_map: RefCell<DefIdMap<&'a DIScope>>,
73 // This collection is used to assert that composite types (structs, enums,
74 // ...) have their members only set once:
75 composite_types_completed: RefCell<FxHashSet<&'a DIType>>,
78 impl Drop for CrateDebugContext<'a, 'tcx> {
81 llvm::LLVMRustDIBuilderDispose(&mut *(self.builder as *mut _));
86 impl<'a, 'tcx> CrateDebugContext<'a, 'tcx> {
87 pub fn new(llmod: &'a llvm::Module) -> Self {
88 debug!("CrateDebugContext::new");
89 let builder = unsafe { llvm::LLVMRustDIBuilderCreate(llmod) };
90 // DIBuilder inherits context from the module, so we'd better use the same one
91 let llcontext = unsafe { llvm::LLVMGetModuleContext(llmod) };
96 created_files: Default::default(),
97 created_enum_disr_types: Default::default(),
98 type_map: Default::default(),
99 namespace_map: RefCell::new(Default::default()),
100 composite_types_completed: Default::default(),
105 /// Creates any deferred debug metadata nodes
106 pub fn finalize(cx: &CodegenCx<'_, '_>) {
107 if cx.dbg_cx.is_none() {
113 if gdb::needs_gdb_debug_scripts_section(cx) {
114 // Add a .debug_gdb_scripts section to this compile-unit. This will
115 // cause GDB to try and load the gdb_load_rust_pretty_printers.py file,
116 // which activates the Rust pretty printers for binary this section is
118 gdb::get_or_insert_gdb_debug_scripts_section_global(cx);
122 llvm::LLVMRustDIBuilderFinalize(DIB(cx));
123 // Debuginfo generation in LLVM by default uses a higher
124 // version of dwarf than macOS currently understands. We can
125 // instruct LLVM to emit an older version of dwarf, however,
126 // for macOS to understand. For more info see #11352
127 // This can be overridden using --llvm-opts -dwarf-version,N.
128 // Android has the same issue (#22398)
129 if cx.sess().target.target.options.is_like_osx
130 || cx.sess().target.target.options.is_like_android
132 llvm::LLVMRustAddModuleFlag(cx.llmod, "Dwarf Version\0".as_ptr().cast(), 2)
135 // Indicate that we want CodeView debug information on MSVC
136 if cx.sess().target.target.options.is_like_msvc {
137 llvm::LLVMRustAddModuleFlag(cx.llmod, "CodeView\0".as_ptr().cast(), 1)
140 // Prevent bitcode readers from deleting the debug info.
141 let ptr = "Debug Info Version\0".as_ptr();
142 llvm::LLVMRustAddModuleFlag(cx.llmod, ptr.cast(), llvm::LLVMRustDebugMetadataVersion());
146 impl DebugInfoBuilderMethods<'tcx> for Builder<'a, 'll, 'tcx> {
149 dbg_context: &FunctionDebugContext<&'ll DIScope>,
150 variable_name: ast::Name,
151 variable_type: Ty<'tcx>,
152 scope_metadata: &'ll DIScope,
153 variable_alloca: Self::Value,
155 indirect_offsets: &[Size],
156 variable_kind: VariableKind,
159 assert!(!dbg_context.source_locations_enabled);
162 let file = span_start(cx, span).file;
163 let file_metadata = file_metadata(cx, &file.name, dbg_context.defining_crate);
165 let loc = span_start(cx, span);
166 let type_metadata = type_metadata(cx, variable_type, span);
168 let (argument_index, dwarf_tag) = match variable_kind {
169 ArgumentVariable(index) => (index as c_uint, DW_TAG_arg_variable),
170 LocalVariable => (0, DW_TAG_auto_variable),
172 let align = cx.align_of(variable_type);
174 // Convert the direct and indirect offsets to address ops.
175 let op_deref = || unsafe { llvm::LLVMRustDIBuilderCreateOpDeref() };
176 let op_plus_uconst = || unsafe { llvm::LLVMRustDIBuilderCreateOpPlusUconst() };
177 let mut addr_ops = SmallVec::<[_; 8]>::new();
179 if direct_offset.bytes() > 0 {
180 addr_ops.push(op_plus_uconst());
181 addr_ops.push(direct_offset.bytes() as i64);
183 for &offset in indirect_offsets {
184 addr_ops.push(op_deref());
185 if offset.bytes() > 0 {
186 addr_ops.push(op_plus_uconst());
187 addr_ops.push(offset.bytes() as i64);
191 let name = SmallCStr::new(&variable_name.as_str());
192 let metadata = unsafe {
193 llvm::LLVMRustDIBuilderCreateVariable(
201 cx.sess().opts.optimize != config::OptLevel::No,
204 align.bytes() as u32,
207 source_loc::set_debug_location(
209 InternalDebugLocation::new(scope_metadata, loc.line, loc.col.to_usize()),
212 let debug_loc = llvm::LLVMGetCurrentDebugLocation(self.llbuilder);
213 let instr = llvm::LLVMRustDIBuilderInsertDeclareAtEnd(
218 addr_ops.len() as c_uint,
223 llvm::LLVMSetInstDebugLocation(self.llbuilder, instr);
225 source_loc::set_debug_location(self, UnknownLocation);
228 fn set_source_location(
230 debug_context: &mut FunctionDebugContext<&'ll DIScope>,
234 set_source_location(debug_context, &self, scope, span)
236 fn insert_reference_to_gdb_debug_scripts_section_global(&mut self) {
237 gdb::insert_reference_to_gdb_debug_scripts_section_global(self)
240 fn set_var_name(&mut self, value: &'ll Value, name: &str) {
241 // Avoid wasting time if LLVM value names aren't even enabled.
242 if self.sess().fewer_names() {
246 // Only function parameters and instructions are local to a function,
247 // don't change the name of anything else (e.g. globals).
248 let param_or_inst = unsafe {
249 llvm::LLVMIsAArgument(value).is_some() || llvm::LLVMIsAInstruction(value).is_some()
255 // Avoid replacing the name if it already exists.
256 // While we could combine the names somehow, it'd
257 // get noisy quick, and the usefulness is dubious.
258 if llvm::get_value_name(value).is_empty() {
259 llvm::set_value_name(value, name.as_bytes());
264 impl DebugInfoMethods<'tcx> for CodegenCx<'ll, 'tcx> {
265 fn create_function_debug_context(
267 instance: Instance<'tcx>,
268 fn_abi: &FnAbi<'tcx, Ty<'tcx>>,
271 ) -> Option<FunctionDebugContext<&'ll DIScope>> {
272 if self.sess().opts.debuginfo == DebugInfo::None {
276 if let InstanceDef::Item(def_id) = instance.def {
277 if self.tcx().codegen_fn_attrs(def_id).flags.contains(CodegenFnAttrFlags::NO_DEBUG) {
284 // This can be the case for functions inlined from another crate
286 // FIXME(simulacrum): Probably can't happen; remove.
290 let def_id = instance.def_id();
291 let containing_scope = get_containing_scope(self, instance);
292 let loc = span_start(self, span);
293 let file_metadata = file_metadata(self, &loc.file.name, def_id.krate);
295 let function_type_metadata = unsafe {
296 let fn_signature = get_function_signature(self, fn_abi);
297 llvm::LLVMRustDIBuilderCreateSubroutineType(DIB(self), file_metadata, fn_signature)
300 // Find the enclosing function, in case this is a closure.
301 let def_key = self.tcx().def_key(def_id);
302 let mut name = def_key.disambiguated_data.data.to_string();
304 let enclosing_fn_def_id = self.tcx().closure_base_def_id(def_id);
306 // Get_template_parameters() will append a `<...>` clause to the function
307 // name if necessary.
308 let generics = self.tcx().generics_of(enclosing_fn_def_id);
309 let substs = instance.substs.truncate_to(self.tcx(), generics);
310 let template_parameters =
311 get_template_parameters(self, &generics, substs, file_metadata, &mut name);
313 // Get the linkage_name, which is just the symbol name
314 let linkage_name = mangled_name_of_instance(self, instance);
316 let scope_line = span_start(self, span).line;
318 let function_name = CString::new(name).unwrap();
319 let linkage_name = SmallCStr::new(&linkage_name.name.as_str());
321 let mut flags = DIFlags::FlagPrototyped;
323 if fn_abi.ret.layout.abi.is_uninhabited() {
324 flags |= DIFlags::FlagNoReturn;
327 let mut spflags = DISPFlags::SPFlagDefinition;
328 if is_node_local_to_unit(self, def_id) {
329 spflags |= DISPFlags::SPFlagLocalToUnit;
331 if self.sess().opts.optimize != config::OptLevel::No {
332 spflags |= DISPFlags::SPFlagOptimized;
334 if let Some((id, _)) = self.tcx.entry_fn(LOCAL_CRATE) {
336 spflags |= DISPFlags::SPFlagMainSubprogram;
340 let fn_metadata = unsafe {
341 llvm::LLVMRustDIBuilderCreateFunction(
344 function_name.as_ptr(),
345 linkage_name.as_ptr(),
348 function_type_metadata,
349 scope_line as c_uint,
358 // Initialize fn debug context (including scopes).
359 // FIXME(eddyb) figure out a way to not need `Option` for `scope_metadata`.
360 let null_scope = DebugScope {
361 scope_metadata: None,
362 file_start_pos: BytePos(0),
363 file_end_pos: BytePos(0),
365 let mut fn_debug_context = FunctionDebugContext {
366 scopes: IndexVec::from_elem(null_scope, &mir.source_scopes),
367 source_locations_enabled: false,
368 defining_crate: def_id.krate,
371 // Fill in all the scopes, with the information from the MIR body.
372 compute_mir_scopes(self, mir, fn_metadata, &mut fn_debug_context);
374 return Some(fn_debug_context);
376 fn get_function_signature<'ll, 'tcx>(
377 cx: &CodegenCx<'ll, 'tcx>,
378 fn_abi: &FnAbi<'tcx, Ty<'tcx>>,
380 if cx.sess().opts.debuginfo == DebugInfo::Limited {
381 return create_DIArray(DIB(cx), &[]);
384 let mut signature = Vec::with_capacity(fn_abi.args.len() + 1);
386 // Return type -- llvm::DIBuilder wants this at index 0
387 signature.push(if fn_abi.ret.is_ignore() {
390 Some(type_metadata(cx, fn_abi.ret.layout.ty, rustc_span::DUMMY_SP))
394 if cx.sess().target.target.options.is_like_msvc {
396 // There is a bug in MSDIA that leads to a crash when it encounters
397 // a fixed-size array of `u8` or something zero-sized in a
398 // function-type (see #40477).
399 // As a workaround, we replace those fixed-size arrays with a
400 // pointer-type. So a function `fn foo(a: u8, b: [u8; 4])` would
401 // appear as `fn foo(a: u8, b: *const u8)` in debuginfo,
402 // and a function `fn bar(x: [(); 7])` as `fn bar(x: *const ())`.
403 // This transformed type is wrong, but these function types are
404 // already inaccurate due to ABI adjustments (see #42800).
405 signature.extend(fn_abi.args.iter().map(|arg| {
406 let t = arg.layout.ty;
407 let t = match t.kind {
409 if (ct == cx.tcx.types.u8) || cx.layout_of(ct).is_zst() =>
411 cx.tcx.mk_imm_ptr(ct)
415 Some(type_metadata(cx, t, rustc_span::DUMMY_SP))
422 .map(|arg| Some(type_metadata(cx, arg.layout.ty, rustc_span::DUMMY_SP))),
426 create_DIArray(DIB(cx), &signature[..])
429 fn get_template_parameters<'ll, 'tcx>(
430 cx: &CodegenCx<'ll, 'tcx>,
431 generics: &ty::Generics,
432 substs: SubstsRef<'tcx>,
433 file_metadata: &'ll DIFile,
434 name_to_append_suffix_to: &mut String,
436 if substs.types().next().is_none() {
437 return create_DIArray(DIB(cx), &[]);
440 name_to_append_suffix_to.push('<');
441 for (i, actual_type) in substs.types().enumerate() {
443 name_to_append_suffix_to.push_str(",");
447 cx.tcx.normalize_erasing_regions(ParamEnv::reveal_all(), actual_type);
448 // Add actual type name to <...> clause of function name
449 let actual_type_name = compute_debuginfo_type_name(cx.tcx(), actual_type, true);
450 name_to_append_suffix_to.push_str(&actual_type_name[..]);
452 name_to_append_suffix_to.push('>');
454 // Again, only create type information if full debuginfo is enabled
455 let template_params: Vec<_> = if cx.sess().opts.debuginfo == DebugInfo::Full {
456 let names = get_parameter_names(cx, generics);
460 .filter_map(|(kind, name)| {
461 if let GenericArgKind::Type(ty) = kind.unpack() {
463 cx.tcx.normalize_erasing_regions(ParamEnv::reveal_all(), ty);
464 let actual_type_metadata =
465 type_metadata(cx, actual_type, rustc_span::DUMMY_SP);
466 let name = SmallCStr::new(&name.as_str());
468 Some(llvm::LLVMRustDIBuilderCreateTemplateTypeParameter(
472 actual_type_metadata,
487 return create_DIArray(DIB(cx), &template_params[..]);
490 fn get_parameter_names(cx: &CodegenCx<'_, '_>, generics: &ty::Generics) -> Vec<Symbol> {
491 let mut names = generics
493 .map_or(vec![], |def_id| 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 Some(type_metadata(cx, impl_self_ty, rustc_span::DUMMY_SP))
523 // For trait method impls we still use the "parallel namespace"
529 self_type.unwrap_or_else(|| {
530 namespace::item_namespace(
533 krate: instance.def_id().krate,
536 .def_key(instance.def_id())
538 .expect("get_containing_scope: missing parent?"),
545 fn create_vtable_metadata(&self, ty: Ty<'tcx>, vtable: Self::Value) {
546 metadata::create_vtable_metadata(self, ty, vtable)
549 fn extend_scope_to_file(
551 scope_metadata: &'ll DIScope,
552 file: &rustc_span::SourceFile,
553 defining_crate: CrateNum,
554 ) -> &'ll DILexicalBlock {
555 metadata::extend_scope_to_file(&self, scope_metadata, file, defining_crate)
558 fn debuginfo_finalize(&self) {