src/librustc_trans/debuginfo/mod.rs

   1 // Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 // See doc.rs for documentation.
  12 mod doc;
  13
  14 use self::VariableAccess::*;
  15 use self::VariableKind::*;
  16
  17 use self::utils::{DIB, span_start, create_DIArray, is_node_local_to_unit};
  18 use self::namespace::mangled_name_of_item;
  19 use self::type_names::compute_debuginfo_type_name;
  20 use self::metadata::{type_metadata, file_metadata, TypeMap};
  21 use self::source_loc::InternalDebugLocation::{self, UnknownLocation};
  22
  23 use llvm;
  24 use llvm::{ModuleRef, ContextRef, ValueRef};
  25 use llvm::debuginfo::{DIFile, DIType, DIScope, DIBuilderRef, DISubprogram, DIArray, DIFlags};
  26 use rustc::hir::def_id::DefId;
  27 use rustc::ty::subst::Substs;
  28
  29 use abi::Abi;
  30 use common::CrateContext;
  31 use builder::Builder;
  32 use monomorphize::{self, Instance};
  33 use rustc::ty::{self, Ty};
  34 use rustc::mir;
  35 use session::config::{self, FullDebugInfo, LimitedDebugInfo, NoDebugInfo};
  36 use util::nodemap::{DefIdMap, FxHashMap, FxHashSet};
  37
  38 use libc::c_uint;
  39 use std::cell::{Cell, RefCell};
  40 use std::ffi::CString;
  41 use std::ptr;
  42
  43 use syntax_pos::{self, Span, Pos};
  44 use syntax::ast;
  45 use rustc::ty::layout;
  46
  47 pub mod gdb;
  48 mod utils;
  49 mod namespace;
  50 mod type_names;
  51 pub mod metadata;
  52 mod create_scope_map;
  53 mod source_loc;
  54
  55 pub use self::create_scope_map::{create_mir_scopes, MirDebugScope};
  56 pub use self::source_loc::start_emitting_source_locations;
  57 pub use self::metadata::create_global_var_metadata;
  58 pub use self::metadata::extend_scope_to_file;
  59 pub use self::source_loc::set_source_location;
  60
  61 #[allow(non_upper_case_globals)]
  62 const DW_TAG_auto_variable: c_uint = 0x100;
  63 #[allow(non_upper_case_globals)]
  64 const DW_TAG_arg_variable: c_uint = 0x101;
  65
  66 /// A context object for maintaining all state needed by the debuginfo module.
  67 pub struct CrateDebugContext<'tcx> {
  68     llcontext: ContextRef,
  69     builder: DIBuilderRef,
  70     created_files: RefCell<FxHashMap<String, DIFile>>,
  71     created_enum_disr_types: RefCell<FxHashMap<(DefId, layout::Integer), DIType>>,
  72
  73     type_map: RefCell<TypeMap<'tcx>>,
  74     namespace_map: RefCell<DefIdMap<DIScope>>,
  75
  76     // This collection is used to assert that composite types (structs, enums,
  77     // ...) have their members only set once:
  78     composite_types_completed: RefCell<FxHashSet<DIType>>,
  79 }
  80
  81 impl<'tcx> CrateDebugContext<'tcx> {
  82     pub fn new(llmod: ModuleRef) -> CrateDebugContext<'tcx> {
  83         debug!("CrateDebugContext::new");
  84         let builder = unsafe { llvm::LLVMRustDIBuilderCreate(llmod) };
  85         // DIBuilder inherits context from the module, so we'd better use the same one
  86         let llcontext = unsafe { llvm::LLVMGetModuleContext(llmod) };
  87         CrateDebugContext {
  88             llcontext: llcontext,
  89             builder: builder,
  90             created_files: RefCell::new(FxHashMap()),
  91             created_enum_disr_types: RefCell::new(FxHashMap()),
  92             type_map: RefCell::new(TypeMap::new()),
  93             namespace_map: RefCell::new(DefIdMap()),
  94             composite_types_completed: RefCell::new(FxHashSet()),
  95         }
  96     }
  97 }
  98
  99 pub enum FunctionDebugContext {
 100     RegularContext(FunctionDebugContextData),
 101     DebugInfoDisabled,
 102     FunctionWithoutDebugInfo,
 103 }
 104
 105 impl FunctionDebugContext {
 106     fn get_ref<'a>(&'a self, span: Span) -> &'a FunctionDebugContextData {
 107         match *self {
 108             FunctionDebugContext::RegularContext(ref data) => data,
 109             FunctionDebugContext::DebugInfoDisabled => {
 110                 span_bug!(span, "{}", FunctionDebugContext::debuginfo_disabled_message());
 111             }
 112             FunctionDebugContext::FunctionWithoutDebugInfo => {
 113                 span_bug!(span, "{}", FunctionDebugContext::should_be_ignored_message());
 114             }
 115         }
 116     }
 117
 118     fn debuginfo_disabled_message() -> &'static str {
 119         "debuginfo: Error trying to access FunctionDebugContext although debug info is disabled!"
 120     }
 121
 122     fn should_be_ignored_message() -> &'static str {
 123         "debuginfo: Error trying to access FunctionDebugContext for function that should be \
 124          ignored by debug info!"
 125     }
 126 }
 127
 128 pub struct FunctionDebugContextData {
 129     fn_metadata: DISubprogram,
 130     source_locations_enabled: Cell<bool>,
 131 }
 132
 133 pub enum VariableAccess<'a> {
 134     // The llptr given is an alloca containing the variable's value
 135     DirectVariable { alloca: ValueRef },
 136     // The llptr given is an alloca containing the start of some pointer chain
 137     // leading to the variable's content.
 138     IndirectVariable { alloca: ValueRef, address_operations: &'a [i64] }
 139 }
 140
 141 pub enum VariableKind {
 142     ArgumentVariable(usize /*index*/),
 143     LocalVariable,
 144     CapturedVariable,
 145 }
 146
 147 /// Create any deferred debug metadata nodes
 148 pub fn finalize(cx: &CrateContext) {
 149     if cx.dbg_cx().is_none() {
 150         return;
 151     }
 152
 153     debug!("finalize");
 154
 155     if gdb::needs_gdb_debug_scripts_section(cx) {
 156         // Add a .debug_gdb_scripts section to this compile-unit. This will
 157         // cause GDB to try and load the gdb_load_rust_pretty_printers.py file,
 158         // which activates the Rust pretty printers for binary this section is
 159         // contained in.
 160         gdb::get_or_insert_gdb_debug_scripts_section_global(cx);
 161     }
 162
 163     unsafe {
 164         llvm::LLVMRustDIBuilderFinalize(DIB(cx));
 165         llvm::LLVMRustDIBuilderDispose(DIB(cx));
 166         // Debuginfo generation in LLVM by default uses a higher
 167         // version of dwarf than OS X currently understands. We can
 168         // instruct LLVM to emit an older version of dwarf, however,
 169         // for OS X to understand. For more info see #11352
 170         // This can be overridden using --llvm-opts -dwarf-version,N.
 171         // Android has the same issue (#22398)
 172         if cx.sess().target.target.options.is_like_osx ||
 173            cx.sess().target.target.options.is_like_android {
 174             llvm::LLVMRustAddModuleFlag(cx.llmod(),
 175                                         "Dwarf Version\0".as_ptr() as *const _,
 176                                         2)
 177         }
 178
 179         // Indicate that we want CodeView debug information on MSVC
 180         if cx.sess().target.target.options.is_like_msvc {
 181             llvm::LLVMRustAddModuleFlag(cx.llmod(),
 182                                         "CodeView\0".as_ptr() as *const _,
 183                                         1)
 184         }
 185
 186         // Prevent bitcode readers from deleting the debug info.
 187         let ptr = "Debug Info Version\0".as_ptr();
 188         llvm::LLVMRustAddModuleFlag(cx.llmod(), ptr as *const _,
 189                                     llvm::LLVMRustDebugMetadataVersion());
 190     };
 191 }
 192
 193 /// Creates the function-specific debug context.
 194 ///
 195 /// Returns the FunctionDebugContext for the function which holds state needed
 196 /// for debug info creation. The function may also return another variant of the
 197 /// FunctionDebugContext enum which indicates why no debuginfo should be created
 198 /// for the function.
 199 pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
 200                                                instance: Instance<'tcx>,
 201                                                sig: &ty::FnSig<'tcx>,
 202                                                abi: Abi,
 203                                                llfn: ValueRef,
 204                                                mir: &mir::Mir) -> FunctionDebugContext {
 205     if cx.sess().opts.debuginfo == NoDebugInfo {
 206         return FunctionDebugContext::DebugInfoDisabled;
 207     }
 208
 209     for attr in cx.tcx().get_attrs(instance.def).iter() {
 210         if attr.check_name("no_debug") {
 211             return FunctionDebugContext::FunctionWithoutDebugInfo;
 212         }
 213     }
 214
 215     let containing_scope = get_containing_scope(cx, instance);
 216     let span = mir.span;
 217
 218     // This can be the case for functions inlined from another crate
 219     if span == syntax_pos::DUMMY_SP {
 220         // FIXME(simulacrum): Probably can't happen; remove.
 221         return FunctionDebugContext::FunctionWithoutDebugInfo;
 222     }
 223
 224     let loc = span_start(cx, span);
 225     let file_metadata = file_metadata(cx, &loc.file.name, &loc.file.abs_path);
 226
 227     let function_type_metadata = unsafe {
 228         let fn_signature = get_function_signature(cx, sig, abi);
 229         llvm::LLVMRustDIBuilderCreateSubroutineType(DIB(cx), file_metadata, fn_signature)
 230     };
 231
 232     // Find the enclosing function, in case this is a closure.
 233     let def_key = cx.tcx().def_key(instance.def);
 234     let mut name = def_key.disambiguated_data.data.to_string();
 235     let name_len = name.len();
 236
 237     let fn_def_id = cx.tcx().closure_base_def_id(instance.def);
 238
 239     // Get_template_parameters() will append a `<...>` clause to the function
 240     // name if necessary.
 241     let generics = cx.tcx().item_generics(fn_def_id);
 242     let substs = instance.substs.truncate_to(cx.tcx(), generics);
 243     let template_parameters = get_template_parameters(cx,
 244                                                       &generics,
 245                                                       substs,
 246                                                       file_metadata,
 247                                                       &mut name);
 248
 249     // Build the linkage_name out of the item path and "template" parameters.
 250     let linkage_name = mangled_name_of_item(cx, instance.def, &name[name_len..]);
 251
 252     let scope_line = span_start(cx, span).line;
 253
 254     let local_id = cx.tcx().hir.as_local_node_id(instance.def);
 255     let is_local_to_unit = local_id.map_or(false, |id| is_node_local_to_unit(cx, id));
 256
 257     let function_name = CString::new(name).unwrap();
 258     let linkage_name = CString::new(linkage_name).unwrap();
 259
 260     let mut flags = DIFlags::FlagPrototyped;
 261     match *cx.sess().entry_fn.borrow() {
 262         Some((id, _)) => {
 263             if local_id == Some(id) {
 264                 flags = flags | DIFlags::FlagMainSubprogram;
 265             }
 266         }
 267         None => {}
 268     };
 269
 270     let fn_metadata = unsafe {
 271         llvm::LLVMRustDIBuilderCreateFunction(
 272             DIB(cx),
 273             containing_scope,
 274             function_name.as_ptr(),
 275             linkage_name.as_ptr(),
 276             file_metadata,
 277             loc.line as c_uint,
 278             function_type_metadata,
 279             is_local_to_unit,
 280             true,
 281             scope_line as c_uint,
 282             flags,
 283             cx.sess().opts.optimize != config::OptLevel::No,
 284             llfn,
 285             template_parameters,
 286             ptr::null_mut())
 287     };
 288
 289     // Initialize fn debug context (including scope map and namespace map)
 290     let fn_debug_context = FunctionDebugContextData {
 291         fn_metadata: fn_metadata,
 292         source_locations_enabled: Cell::new(false),
 293     };
 294
 295     return FunctionDebugContext::RegularContext(fn_debug_context);
 296
 297     fn get_function_signature<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
 298                                         sig: &ty::FnSig<'tcx>,
 299                                         abi: Abi) -> DIArray {
 300         if cx.sess().opts.debuginfo == LimitedDebugInfo {
 301             return create_DIArray(DIB(cx), &[]);
 302         }
 303
 304         let mut signature = Vec::with_capacity(sig.inputs().len() + 1);
 305
 306         // Return type -- llvm::DIBuilder wants this at index 0
 307         signature.push(match sig.output().sty {
 308             ty::TyTuple(ref tys) if tys.is_empty() => ptr::null_mut(),
 309             _ => type_metadata(cx, sig.output(), syntax_pos::DUMMY_SP)
 310         });
 311
 312         let inputs = if abi == Abi::RustCall {
 313             &sig.inputs()[..sig.inputs().len() - 1]
 314         } else {
 315             sig.inputs()
 316         };
 317
 318         // Arguments types
 319         for &argument_type in inputs {
 320             signature.push(type_metadata(cx, argument_type, syntax_pos::DUMMY_SP));
 321         }
 322
 323         if abi == Abi::RustCall && !sig.inputs().is_empty() {
 324             if let ty::TyTuple(args) = sig.inputs()[sig.inputs().len() - 1].sty {
 325                 for &argument_type in args {
 326                     signature.push(type_metadata(cx, argument_type, syntax_pos::DUMMY_SP));
 327                 }
 328             }
 329         }
 330
 331         return create_DIArray(DIB(cx), &signature[..]);
 332     }
 333
 334     fn get_template_parameters<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
 335                                          generics: &ty::Generics<'tcx>,
 336                                          substs: &Substs<'tcx>,
 337                                          file_metadata: DIFile,
 338                                          name_to_append_suffix_to: &mut String)
 339                                          -> DIArray
 340     {
 341         if substs.types().next().is_none() {
 342             return create_DIArray(DIB(cx), &[]);
 343         }
 344
 345         name_to_append_suffix_to.push('<');
 346         for (i, actual_type) in substs.types().enumerate() {
 347             if i != 0 {
 348                 name_to_append_suffix_to.push_str(",");
 349             }
 350
 351             let actual_type = cx.tcx().normalize_associated_type(&actual_type);
 352             // Add actual type name to <...> clause of function name
 353             let actual_type_name = compute_debuginfo_type_name(cx,
 354                                                                actual_type,
 355                                                                true);
 356             name_to_append_suffix_to.push_str(&actual_type_name[..]);
 357         }
 358         name_to_append_suffix_to.push('>');
 359
 360         // Again, only create type information if full debuginfo is enabled
 361         let template_params: Vec<_> = if cx.sess().opts.debuginfo == FullDebugInfo {
 362             let names = get_type_parameter_names(cx, generics);
 363             substs.types().zip(names).map(|(ty, name)| {
 364                 let actual_type = cx.tcx().normalize_associated_type(&ty);
 365                 let actual_type_metadata = type_metadata(cx, actual_type, syntax_pos::DUMMY_SP);
 366                 let name = CString::new(name.as_str().as_bytes()).unwrap();
 367                 unsafe {
 368                     llvm::LLVMRustDIBuilderCreateTemplateTypeParameter(
 369                         DIB(cx),
 370                         ptr::null_mut(),
 371                         name.as_ptr(),
 372                         actual_type_metadata,
 373                         file_metadata,
 374                         0,
 375                         0)
 376                 }
 377             }).collect()
 378         } else {
 379             vec![]
 380         };
 381
 382         return create_DIArray(DIB(cx), &template_params[..]);
 383     }
 384
 385     fn get_type_parameter_names<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
 386                                           generics: &ty::Generics<'tcx>)
 387                                           -> Vec<ast::Name> {
 388         let mut names = generics.parent.map_or(vec![], |def_id| {
 389             get_type_parameter_names(cx, cx.tcx().item_generics(def_id))
 390         });
 391         names.extend(generics.types.iter().map(|param| param.name));
 392         names
 393     }
 394
 395     fn get_containing_scope<'ccx, 'tcx>(cx: &CrateContext<'ccx, 'tcx>,
 396                                         instance: Instance<'tcx>)
 397                                         -> DIScope {
 398         // First, let's see if this is a method within an inherent impl. Because
 399         // if yes, we want to make the result subroutine DIE a child of the
 400         // subroutine's self-type.
 401         let self_type = cx.tcx().impl_of_method(instance.def).and_then(|impl_def_id| {
 402             // If the method does *not* belong to a trait, proceed
 403             if cx.tcx().trait_id_of_impl(impl_def_id).is_none() {
 404                 let impl_self_ty = cx.tcx().item_type(impl_def_id);
 405                 let impl_self_ty = cx.tcx().erase_regions(&impl_self_ty);
 406                 let impl_self_ty = monomorphize::apply_param_substs(cx.shared(),
 407                                                                     instance.substs,
 408                                                                     &impl_self_ty);
 409
 410                 // Only "class" methods are generally understood by LLVM,
 411                 // so avoid methods on other types (e.g. `<*mut T>::null`).
 412                 match impl_self_ty.sty {
 413                     ty::TyAdt(def, ..) if !def.is_box() => {
 414                         Some(type_metadata(cx, impl_self_ty, syntax_pos::DUMMY_SP))
 415                     }
 416                     _ => None
 417                 }
 418             } else {
 419                 // For trait method impls we still use the "parallel namespace"
 420                 // strategy
 421                 None
 422             }
 423         });
 424
 425         self_type.unwrap_or_else(|| {
 426             namespace::item_namespace(cx, DefId {
 427                 krate: instance.def.krate,
 428                 index: cx.tcx()
 429                          .def_key(instance.def)
 430                          .parent
 431                          .expect("get_containing_scope: missing parent?")
 432             })
 433         })
 434     }
 435 }
 436
 437 pub fn declare_local<'a, 'tcx>(bcx: &Builder<'a, 'tcx>,
 438                                dbg_context: &FunctionDebugContext,
 439                                variable_name: ast::Name,
 440                                variable_type: Ty<'tcx>,
 441                                scope_metadata: DIScope,
 442                                variable_access: VariableAccess,
 443                                variable_kind: VariableKind,
 444                                span: Span) {
 445     let cx = bcx.ccx;
 446
 447     let file = span_start(cx, span).file;
 448     let filename = file.name.clone();
 449     let file_metadata = file_metadata(cx, &filename[..], &file.abs_path);
 450
 451     let loc = span_start(cx, span);
 452     let type_metadata = type_metadata(cx, variable_type, span);
 453
 454     let (argument_index, dwarf_tag) = match variable_kind {
 455         ArgumentVariable(index) => (index as c_uint, DW_TAG_arg_variable),
 456         LocalVariable    |
 457         CapturedVariable => (0, DW_TAG_auto_variable)
 458     };
 459     let align = ::type_of::align_of(cx, variable_type);
 460
 461     let name = CString::new(variable_name.as_str().as_bytes()).unwrap();
 462     match (variable_access, &[][..]) {
 463         (DirectVariable { alloca }, address_operations) |
 464         (IndirectVariable {alloca, address_operations}, _) => {
 465             let metadata = unsafe {
 466                 llvm::LLVMRustDIBuilderCreateVariable(
 467                     DIB(cx),
 468                     dwarf_tag,
 469                     scope_metadata,
 470                     name.as_ptr(),
 471                     file_metadata,
 472                     loc.line as c_uint,
 473                     type_metadata,
 474                     cx.sess().opts.optimize != config::OptLevel::No,
 475                     DIFlags::FlagZero,
 476                     argument_index,
 477                     align as u64,
 478                 )
 479             };
 480             source_loc::set_debug_location(bcx,
 481                 InternalDebugLocation::new(scope_metadata, loc.line, loc.col.to_usize()));
 482             unsafe {
 483                 let debug_loc = llvm::LLVMGetCurrentDebugLocation(bcx.llbuilder);
 484                 let instr = llvm::LLVMRustDIBuilderInsertDeclareAtEnd(
 485                     DIB(cx),
 486                     alloca,
 487                     metadata,
 488                     address_operations.as_ptr(),
 489                     address_operations.len() as c_uint,
 490                     debug_loc,
 491                     bcx.llbb());
 492
 493                 llvm::LLVMSetInstDebugLocation(bcx.llbuilder, instr);
 494             }
 495         }
 496     }
 497
 498     match variable_kind {
 499         ArgumentVariable(_) | CapturedVariable => {
 500             assert!(!dbg_context.get_ref(span).source_locations_enabled.get());
 501             source_loc::set_debug_location(bcx, UnknownLocation);
 502         }
 503         _ => { /* nothing to do */ }
 504     }
 505 }