src/librustc_codegen_llvm/debuginfo/mod.rs

   1 // See doc.rs for documentation.
   2 mod doc;
   3
   4 use rustc_codegen_ssa::mir::debuginfo::VariableKind::*;
   5
   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};
  11
  12 use crate::llvm;
  13 use crate::llvm::debuginfo::{
  14     DIArray, DIBuilder, DIFile, DIFlags, DILexicalBlock, DISPFlags, DIScope, DIType,
  15 };
  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};
  19
  20 use crate::abi::FnAbi;
  21 use crate::builder::Builder;
  22 use crate::common::CodegenCx;
  23 use crate::value::Value;
  24 use rustc::mir;
  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;
  32
  33 use libc::c_uint;
  34 use log::debug;
  35 use std::cell::RefCell;
  36 use std::ffi::CString;
  37
  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;
  43 use syntax::ast;
  44
  45 mod create_scope_map;
  46 pub mod gdb;
  47 pub mod metadata;
  48 mod namespace;
  49 mod source_loc;
  50 mod utils;
  51
  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;
  56
  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;
  61
  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>>,
  69
  70     type_map: RefCell<TypeMap<'a, 'tcx>>,
  71     namespace_map: RefCell<DefIdMap<&'a DIScope>>,
  72
  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>>,
  76 }
  77
  78 impl Drop for CrateDebugContext<'a, 'tcx> {
  79     fn drop(&mut self) {
  80         unsafe {
  81             llvm::LLVMRustDIBuilderDispose(&mut *(self.builder as *mut _));
  82         }
  83     }
  84 }
  85
  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) };
  92         CrateDebugContext {
  93             llcontext,
  94             llmod,
  95             builder,
  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(),
 101         }
 102     }
 103 }
 104
 105 /// Creates any deferred debug metadata nodes
 106 pub fn finalize(cx: &CodegenCx<'_, '_>) {
 107     if cx.dbg_cx.is_none() {
 108         return;
 109     }
 110
 111     debug!("finalize");
 112
 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
 117         // contained in.
 118         gdb::get_or_insert_gdb_debug_scripts_section_global(cx);
 119     }
 120
 121     unsafe {
 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
 131         {
 132             llvm::LLVMRustAddModuleFlag(cx.llmod, "Dwarf Version\0".as_ptr().cast(), 2)
 133         }
 134
 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)
 138         }
 139
 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());
 143     };
 144 }
 145
 146 impl DebugInfoBuilderMethods<'tcx> for Builder<'a, 'll, 'tcx> {
 147     fn declare_local(
 148         &mut self,
 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,
 154         direct_offset: Size,
 155         indirect_offsets: &[Size],
 156         variable_kind: VariableKind,
 157         span: Span,
 158     ) {
 159         assert!(!dbg_context.source_locations_enabled);
 160         let cx = self.cx();
 161
 162         let file = span_start(cx, span).file;
 163         let file_metadata = file_metadata(cx, &file.name, dbg_context.defining_crate);
 164
 165         let loc = span_start(cx, span);
 166         let type_metadata = type_metadata(cx, variable_type, span);
 167
 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),
 171         };
 172         let align = cx.align_of(variable_type);
 173
 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();
 178
 179         if direct_offset.bytes() > 0 {
 180             addr_ops.push(op_plus_uconst());
 181             addr_ops.push(direct_offset.bytes() as i64);
 182         }
 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);
 188             }
 189         }
 190
 191         let name = SmallCStr::new(&variable_name.as_str());
 192         let metadata = unsafe {
 193             llvm::LLVMRustDIBuilderCreateVariable(
 194                 DIB(cx),
 195                 dwarf_tag,
 196                 scope_metadata,
 197                 name.as_ptr(),
 198                 file_metadata,
 199                 loc.line as c_uint,
 200                 type_metadata,
 201                 cx.sess().opts.optimize != config::OptLevel::No,
 202                 DIFlags::FlagZero,
 203                 argument_index,
 204                 align.bytes() as u32,
 205             )
 206         };
 207         source_loc::set_debug_location(
 208             self,
 209             InternalDebugLocation::new(scope_metadata, loc.line, loc.col.to_usize()),
 210         );
 211         unsafe {
 212             let debug_loc = llvm::LLVMGetCurrentDebugLocation(self.llbuilder);
 213             let instr = llvm::LLVMRustDIBuilderInsertDeclareAtEnd(
 214                 DIB(cx),
 215                 variable_alloca,
 216                 metadata,
 217                 addr_ops.as_ptr(),
 218                 addr_ops.len() as c_uint,
 219                 debug_loc,
 220                 self.llbb(),
 221             );
 222
 223             llvm::LLVMSetInstDebugLocation(self.llbuilder, instr);
 224         }
 225         source_loc::set_debug_location(self, UnknownLocation);
 226     }
 227
 228     fn set_source_location(
 229         &mut self,
 230         debug_context: &mut FunctionDebugContext<&'ll DIScope>,
 231         scope: &'ll DIScope,
 232         span: Span,
 233     ) {
 234         set_source_location(debug_context, &self, scope, span)
 235     }
 236     fn insert_reference_to_gdb_debug_scripts_section_global(&mut self) {
 237         gdb::insert_reference_to_gdb_debug_scripts_section_global(self)
 238     }
 239
 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() {
 243             return;
 244         }
 245
 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()
 250         };
 251         if !param_or_inst {
 252             return;
 253         }
 254
 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());
 260         }
 261     }
 262 }
 263
 264 impl DebugInfoMethods<'tcx> for CodegenCx<'ll, 'tcx> {
 265     fn create_function_debug_context(
 266         &self,
 267         instance: Instance<'tcx>,
 268         fn_abi: &FnAbi<'tcx, Ty<'tcx>>,
 269         llfn: &'ll Value,
 270         mir: &mir::Body<'_>,
 271     ) -> Option<FunctionDebugContext<&'ll DIScope>> {
 272         if self.sess().opts.debuginfo == DebugInfo::None {
 273             return None;
 274         }
 275
 276         if let InstanceDef::Item(def_id) = instance.def {
 277             if self.tcx().codegen_fn_attrs(def_id).flags.contains(CodegenFnAttrFlags::NO_DEBUG) {
 278                 return None;
 279             }
 280         }
 281
 282         let span = mir.span;
 283
 284         // This can be the case for functions inlined from another crate
 285         if span.is_dummy() {
 286             // FIXME(simulacrum): Probably can't happen; remove.
 287             return None;
 288         }
 289
 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);
 294
 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)
 298         };
 299
 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();
 303
 304         let enclosing_fn_def_id = self.tcx().closure_base_def_id(def_id);
 305
 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);
 312
 313         // Get the linkage_name, which is just the symbol name
 314         let linkage_name = mangled_name_of_instance(self, instance);
 315
 316         let scope_line = span_start(self, span).line;
 317
 318         let function_name = CString::new(name).unwrap();
 319         let linkage_name = SmallCStr::new(&linkage_name.name.as_str());
 320
 321         let mut flags = DIFlags::FlagPrototyped;
 322
 323         if fn_abi.ret.layout.abi.is_uninhabited() {
 324             flags |= DIFlags::FlagNoReturn;
 325         }
 326
 327         let mut spflags = DISPFlags::SPFlagDefinition;
 328         if is_node_local_to_unit(self, def_id) {
 329             spflags |= DISPFlags::SPFlagLocalToUnit;
 330         }
 331         if self.sess().opts.optimize != config::OptLevel::No {
 332             spflags |= DISPFlags::SPFlagOptimized;
 333         }
 334         if let Some((id, _)) = self.tcx.entry_fn(LOCAL_CRATE) {
 335             if id == def_id {
 336                 spflags |= DISPFlags::SPFlagMainSubprogram;
 337             }
 338         }
 339
 340         let fn_metadata = unsafe {
 341             llvm::LLVMRustDIBuilderCreateFunction(
 342                 DIB(self),
 343                 containing_scope,
 344                 function_name.as_ptr(),
 345                 linkage_name.as_ptr(),
 346                 file_metadata,
 347                 loc.line as c_uint,
 348                 function_type_metadata,
 349                 scope_line as c_uint,
 350                 flags,
 351                 spflags,
 352                 llfn,
 353                 template_parameters,
 354                 None,
 355             )
 356         };
 357
 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),
 364         };
 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,
 369         };
 370
 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);
 373
 374         return Some(fn_debug_context);
 375
 376         fn get_function_signature<'ll, 'tcx>(
 377             cx: &CodegenCx<'ll, 'tcx>,
 378             fn_abi: &FnAbi<'tcx, Ty<'tcx>>,
 379         ) -> &'ll DIArray {
 380             if cx.sess().opts.debuginfo == DebugInfo::Limited {
 381                 return create_DIArray(DIB(cx), &[]);
 382             }
 383
 384             let mut signature = Vec::with_capacity(fn_abi.args.len() + 1);
 385
 386             // Return type -- llvm::DIBuilder wants this at index 0
 387             signature.push(if fn_abi.ret.is_ignore() {
 388                 None
 389             } else {
 390                 Some(type_metadata(cx, fn_abi.ret.layout.ty, rustc_span::DUMMY_SP))
 391             });
 392
 393             // Arguments types
 394             if cx.sess().target.target.options.is_like_msvc {
 395                 // FIXME(#42800):
 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 {
 408                         ty::Array(ct, _)
 409                             if (ct == cx.tcx.types.u8) || cx.layout_of(ct).is_zst() =>
 410                         {
 411                             cx.tcx.mk_imm_ptr(ct)
 412                         }
 413                         _ => t,
 414                     };
 415                     Some(type_metadata(cx, t, rustc_span::DUMMY_SP))
 416                 }));
 417             } else {
 418                 signature.extend(
 419                     fn_abi
 420                         .args
 421                         .iter()
 422                         .map(|arg| Some(type_metadata(cx, arg.layout.ty, rustc_span::DUMMY_SP))),
 423                 );
 424             }
 425
 426             create_DIArray(DIB(cx), &signature[..])
 427         }
 428
 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,
 435         ) -> &'ll DIArray {
 436             if substs.types().next().is_none() {
 437                 return create_DIArray(DIB(cx), &[]);
 438             }
 439
 440             name_to_append_suffix_to.push('<');
 441             for (i, actual_type) in substs.types().enumerate() {
 442                 if i != 0 {
 443                     name_to_append_suffix_to.push_str(",");
 444                 }
 445
 446                 let actual_type =
 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[..]);
 451             }
 452             name_to_append_suffix_to.push('>');
 453
 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);
 457                 substs
 458                     .iter()
 459                     .zip(names)
 460                     .filter_map(|(kind, name)| {
 461                         if let GenericArgKind::Type(ty) = kind.unpack() {
 462                             let actual_type =
 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());
 467                             Some(unsafe {
 468                                 Some(llvm::LLVMRustDIBuilderCreateTemplateTypeParameter(
 469                                     DIB(cx),
 470                                     None,
 471                                     name.as_ptr(),
 472                                     actual_type_metadata,
 473                                     file_metadata,
 474                                     0,
 475                                     0,
 476                                 ))
 477                             })
 478                         } else {
 479                             None
 480                         }
 481                     })
 482                     .collect()
 483             } else {
 484                 vec![]
 485             };
 486
 487             return create_DIArray(DIB(cx), &template_params[..]);
 488         }
 489
 490         fn get_parameter_names(cx: &CodegenCx<'_, '_>, generics: &ty::Generics) -> Vec<Symbol> {
 491             let mut names = generics
 492                 .parent
 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));
 495             names
 496         }
 497
 498         fn get_containing_scope<'ll, 'tcx>(
 499             cx: &CodegenCx<'ll, 'tcx>,
 500             instance: Instance<'tcx>,
 501         ) -> &'ll DIScope {
 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(
 509                         instance.substs,
 510                         ty::ParamEnv::reveal_all(),
 511                         &cx.tcx.type_of(impl_def_id),
 512                     );
 513
 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))
 519                         }
 520                         _ => None,
 521                     }
 522                 } else {
 523                     // For trait method impls we still use the "parallel namespace"
 524                     // strategy
 525                     None
 526                 }
 527             });
 528
 529             self_type.unwrap_or_else(|| {
 530                 namespace::item_namespace(
 531                     cx,
 532                     DefId {
 533                         krate: instance.def_id().krate,
 534                         index: cx
 535                             .tcx
 536                             .def_key(instance.def_id())
 537                             .parent
 538                             .expect("get_containing_scope: missing parent?"),
 539                     },
 540                 )
 541             })
 542         }
 543     }
 544
 545     fn create_vtable_metadata(&self, ty: Ty<'tcx>, vtable: Self::Value) {
 546         metadata::create_vtable_metadata(self, ty, vtable)
 547     }
 548
 549     fn extend_scope_to_file(
 550         &self,
 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)
 556     }
 557
 558     fn debuginfo_finalize(&self) {
 559         finalize(self)
 560     }
 561 }