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.
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.
11 // See doc.rs for documentation.
14 use self::VariableAccess::*;
15 use self::VariableKind::*;
17 use self::utils::{DIB, span_start, assert_type_for_node_id, contains_nodebug_attribute,
18 create_DIArray, is_node_local_to_unit};
19 use self::namespace::{namespace_for_item, NamespaceTreeNode};
20 use self::type_names::compute_debuginfo_type_name;
21 use self::metadata::{type_metadata, diverging_type_metadata};
22 use self::metadata::{file_metadata, scope_metadata, TypeMap, compile_unit_metadata};
23 use self::source_loc::InternalDebugLocation;
26 use llvm::{ModuleRef, ContextRef, ValueRef};
27 use llvm::debuginfo::{DIFile, DIType, DIScope, DIBuilderRef, DISubprogram, DIArray,
28 DIDescriptor, FlagPrototyped};
29 use middle::def_id::DefId;
30 use middle::infer::normalize_associated_type;
31 use middle::subst::{self, Substs};
35 use trans::common::{NodeIdAndSpan, CrateContext, FunctionContext, Block};
37 use trans::{monomorphize, type_of};
39 use middle::ty::{self, Ty};
40 use session::config::{self, FullDebugInfo, LimitedDebugInfo, NoDebugInfo};
41 use util::nodemap::{NodeMap, FnvHashMap, FnvHashSet};
42 use rustc::front::map as hir_map;
45 use std::cell::{Cell, RefCell};
46 use std::ffi::CString;
50 use syntax::codemap::{Span, Pos};
51 use syntax::{abi, ast, codemap};
52 use syntax::attr::IntType;
53 use syntax::parse::token::{self, special_idents};
63 pub use self::source_loc::set_source_location;
64 pub use self::source_loc::clear_source_location;
65 pub use self::source_loc::start_emitting_source_locations;
66 pub use self::source_loc::get_cleanup_debug_loc_for_ast_node;
67 pub use self::source_loc::with_source_location_override;
68 pub use self::metadata::create_match_binding_metadata;
69 pub use self::metadata::create_argument_metadata;
70 pub use self::metadata::create_captured_var_metadata;
71 pub use self::metadata::create_global_var_metadata;
72 pub use self::metadata::create_local_var_metadata;
74 #[allow(non_upper_case_globals)]
75 const DW_TAG_auto_variable: c_uint = 0x100;
76 #[allow(non_upper_case_globals)]
77 const DW_TAG_arg_variable: c_uint = 0x101;
79 /// A context object for maintaining all state needed by the debuginfo module.
80 pub struct CrateDebugContext<'tcx> {
81 llcontext: ContextRef,
82 builder: DIBuilderRef,
83 current_debug_location: Cell<InternalDebugLocation>,
84 created_files: RefCell<FnvHashMap<String, DIFile>>,
85 created_enum_disr_types: RefCell<FnvHashMap<(DefId, IntType), DIType>>,
87 type_map: RefCell<TypeMap<'tcx>>,
88 namespace_map: RefCell<FnvHashMap<Vec<ast::Name>, Rc<NamespaceTreeNode>>>,
90 // This collection is used to assert that composite types (structs, enums,
91 // ...) have their members only set once:
92 composite_types_completed: RefCell<FnvHashSet<DIType>>,
95 impl<'tcx> CrateDebugContext<'tcx> {
96 pub fn new(llmod: ModuleRef) -> CrateDebugContext<'tcx> {
97 debug!("CrateDebugContext::new");
98 let builder = unsafe { llvm::LLVMDIBuilderCreate(llmod) };
99 // DIBuilder inherits context from the module, so we'd better use the same one
100 let llcontext = unsafe { llvm::LLVMGetModuleContext(llmod) };
101 return CrateDebugContext {
102 llcontext: llcontext,
104 current_debug_location: Cell::new(InternalDebugLocation::UnknownLocation),
105 created_files: RefCell::new(FnvHashMap()),
106 created_enum_disr_types: RefCell::new(FnvHashMap()),
107 type_map: RefCell::new(TypeMap::new()),
108 namespace_map: RefCell::new(FnvHashMap()),
109 composite_types_completed: RefCell::new(FnvHashSet()),
114 pub enum FunctionDebugContext {
115 RegularContext(Box<FunctionDebugContextData>),
117 FunctionWithoutDebugInfo,
120 impl FunctionDebugContext {
121 fn get_ref<'a>(&'a self,
124 -> &'a FunctionDebugContextData {
126 FunctionDebugContext::RegularContext(box ref data) => data,
127 FunctionDebugContext::DebugInfoDisabled => {
128 cx.sess().span_bug(span,
129 FunctionDebugContext::debuginfo_disabled_message());
131 FunctionDebugContext::FunctionWithoutDebugInfo => {
132 cx.sess().span_bug(span,
133 FunctionDebugContext::should_be_ignored_message());
138 fn debuginfo_disabled_message() -> &'static str {
139 "debuginfo: Error trying to access FunctionDebugContext although debug info is disabled!"
142 fn should_be_ignored_message() -> &'static str {
143 "debuginfo: Error trying to access FunctionDebugContext for function that should be \
144 ignored by debug info!"
148 pub struct FunctionDebugContextData {
149 scope_map: RefCell<NodeMap<DIScope>>,
150 fn_metadata: DISubprogram,
151 argument_counter: Cell<usize>,
152 source_locations_enabled: Cell<bool>,
153 source_location_override: Cell<bool>,
156 pub enum VariableAccess<'a> {
157 // The llptr given is an alloca containing the variable's value
158 DirectVariable { alloca: ValueRef },
159 // The llptr given is an alloca containing the start of some pointer chain
160 // leading to the variable's content.
161 IndirectVariable { alloca: ValueRef, address_operations: &'a [i64] }
164 pub enum VariableKind {
165 ArgumentVariable(usize /*index*/),
170 /// Create any deferred debug metadata nodes
171 pub fn finalize(cx: &CrateContext) {
172 if cx.dbg_cx().is_none() {
177 let _ = compile_unit_metadata(cx);
179 if gdb::needs_gdb_debug_scripts_section(cx) {
180 // Add a .debug_gdb_scripts section to this compile-unit. This will
181 // cause GDB to try and load the gdb_load_rust_pretty_printers.py file,
182 // which activates the Rust pretty printers for binary this section is
184 gdb::get_or_insert_gdb_debug_scripts_section_global(cx);
188 llvm::LLVMDIBuilderFinalize(DIB(cx));
189 llvm::LLVMDIBuilderDispose(DIB(cx));
190 // Debuginfo generation in LLVM by default uses a higher
191 // version of dwarf than OS X currently understands. We can
192 // instruct LLVM to emit an older version of dwarf, however,
193 // for OS X to understand. For more info see #11352
194 // This can be overridden using --llvm-opts -dwarf-version,N.
195 // Android has the same issue (#22398)
196 if cx.sess().target.target.options.is_like_osx ||
197 cx.sess().target.target.options.is_like_android {
198 llvm::LLVMRustAddModuleFlag(cx.llmod(),
199 "Dwarf Version\0".as_ptr() as *const _,
203 // Prevent bitcode readers from deleting the debug info.
204 let ptr = "Debug Info Version\0".as_ptr();
205 llvm::LLVMRustAddModuleFlag(cx.llmod(), ptr as *const _,
206 llvm::LLVMRustDebugMetadataVersion());
210 /// Creates the function-specific debug context.
212 /// Returns the FunctionDebugContext for the function which holds state needed
213 /// for debug info creation. The function may also return another variant of the
214 /// FunctionDebugContext enum which indicates why no debuginfo should be created
215 /// for the function.
216 pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
217 fn_ast_id: ast::NodeId,
218 param_substs: &Substs<'tcx>,
219 llfn: ValueRef) -> FunctionDebugContext {
220 if cx.sess().opts.debuginfo == NoDebugInfo {
221 return FunctionDebugContext::DebugInfoDisabled;
224 // Clear the debug location so we don't assign them in the function prelude.
225 // Do this here already, in case we do an early exit from this function.
226 source_loc::set_debug_location(cx, InternalDebugLocation::UnknownLocation);
228 if fn_ast_id == ast::DUMMY_NODE_ID {
229 // This is a function not linked to any source location, so don't
230 // generate debuginfo for it.
231 return FunctionDebugContext::FunctionWithoutDebugInfo;
234 let empty_generics = rustc_front::util::empty_generics();
236 let fnitem = cx.tcx().map.get(fn_ast_id);
238 let (name, fn_decl, generics, top_level_block, span, has_path) = match fnitem {
239 hir_map::NodeItem(ref item) => {
240 if contains_nodebug_attribute(&item.attrs) {
241 return FunctionDebugContext::FunctionWithoutDebugInfo;
245 hir::ItemFn(ref fn_decl, _, _, _, ref generics, ref top_level_block) => {
246 (item.name, fn_decl, generics, top_level_block, item.span, true)
249 cx.sess().span_bug(item.span,
250 "create_function_debug_context: item bound to non-function");
254 hir_map::NodeImplItem(impl_item) => {
255 match impl_item.node {
256 hir::ImplItemKind::Method(ref sig, ref body) => {
257 if contains_nodebug_attribute(&impl_item.attrs) {
258 return FunctionDebugContext::FunctionWithoutDebugInfo;
269 cx.sess().span_bug(impl_item.span,
270 "create_function_debug_context() \
271 called on non-method impl item?!")
275 hir_map::NodeExpr(ref expr) => {
277 hir::ExprClosure(_, ref fn_decl, ref top_level_block) => {
278 let name = format!("fn{}", token::gensym("fn"));
279 let name = token::intern(&name[..]);
281 // This is not quite right. It should actually inherit
282 // the generics of the enclosing function.
286 // Don't try to lookup the item path:
289 _ => cx.sess().span_bug(expr.span,
290 "create_function_debug_context: expected an expr_fn_block here")
293 hir_map::NodeTraitItem(trait_item) => {
294 match trait_item.node {
295 hir::MethodTraitItem(ref sig, Some(ref body)) => {
296 if contains_nodebug_attribute(&trait_item.attrs) {
297 return FunctionDebugContext::FunctionWithoutDebugInfo;
309 .bug(&format!("create_function_debug_context: \
310 unexpected sort of node: {:?}",
315 hir_map::NodeForeignItem(..) |
316 hir_map::NodeVariant(..) |
317 hir_map::NodeStructCtor(..) => {
318 return FunctionDebugContext::FunctionWithoutDebugInfo;
320 _ => cx.sess().bug(&format!("create_function_debug_context: \
321 unexpected sort of node: {:?}",
325 // This can be the case for functions inlined from another crate
326 if span == codemap::DUMMY_SP {
327 return FunctionDebugContext::FunctionWithoutDebugInfo;
330 let loc = span_start(cx, span);
331 let file_metadata = file_metadata(cx, &loc.file.name);
333 let function_type_metadata = unsafe {
334 let fn_signature = get_function_signature(cx,
338 llvm::LLVMDIBuilderCreateSubroutineType(DIB(cx), file_metadata, fn_signature)
341 // Get_template_parameters() will append a `<...>` clause to the function
342 // name if necessary.
343 let mut function_name = name.to_string();
344 let template_parameters = get_template_parameters(cx,
350 // There is no hir_map::Path for hir::ExprClosure-type functions. For now,
351 // just don't put them into a namespace. In the future this could be improved
352 // somehow (storing a path in the hir_map, or construct a path using the
353 // enclosing function).
354 let (linkage_name, containing_scope) = if has_path {
355 let fn_ast_def_id = cx.tcx().map.local_def_id(fn_ast_id);
356 let namespace_node = namespace_for_item(cx, fn_ast_def_id);
357 let linkage_name = namespace_node.mangled_name_of_contained_item(
359 let containing_scope = namespace_node.scope;
360 (linkage_name, containing_scope)
362 (function_name.clone(), file_metadata)
365 // Clang sets this parameter to the opening brace of the function's block,
366 // so let's do this too.
367 let scope_line = span_start(cx, top_level_block.span).line;
369 let is_local_to_unit = is_node_local_to_unit(cx, fn_ast_id);
371 let function_name = CString::new(function_name).unwrap();
372 let linkage_name = CString::new(linkage_name).unwrap();
373 let fn_metadata = unsafe {
374 llvm::LLVMDIBuilderCreateFunction(
377 function_name.as_ptr(),
378 linkage_name.as_ptr(),
381 function_type_metadata,
384 scope_line as c_uint,
385 FlagPrototyped as c_uint,
386 cx.sess().opts.optimize != config::OptLevel::No,
392 let scope_map = create_scope_map::create_scope_map(cx,
398 // Initialize fn debug context (including scope map and namespace map)
399 let fn_debug_context = box FunctionDebugContextData {
400 scope_map: RefCell::new(scope_map),
401 fn_metadata: fn_metadata,
402 argument_counter: Cell::new(1),
403 source_locations_enabled: Cell::new(false),
404 source_location_override: Cell::new(false),
409 return FunctionDebugContext::RegularContext(fn_debug_context);
411 fn get_function_signature<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
412 fn_ast_id: ast::NodeId,
413 param_substs: &Substs<'tcx>,
414 error_reporting_span: Span) -> DIArray {
415 if cx.sess().opts.debuginfo == LimitedDebugInfo {
416 return create_DIArray(DIB(cx), &[]);
419 // Return type -- llvm::DIBuilder wants this at index 0
420 assert_type_for_node_id(cx, fn_ast_id, error_reporting_span);
421 let fn_type = cx.tcx().node_id_to_type(fn_ast_id);
422 let fn_type = monomorphize::apply_param_substs(cx.tcx(), param_substs, &fn_type);
424 let (sig, abi) = match fn_type.sty {
425 ty::TyBareFn(_, ref barefnty) => {
426 let sig = cx.tcx().erase_late_bound_regions(&barefnty.sig);
427 let sig = infer::normalize_associated_type(cx.tcx(), &sig);
430 ty::TyClosure(def_id, ref substs) => {
431 let closure_type = cx.tcx().closure_type(def_id, substs);
432 let sig = cx.tcx().erase_late_bound_regions(&closure_type.sig);
433 let sig = infer::normalize_associated_type(cx.tcx(), &sig);
434 (sig, closure_type.abi)
437 _ => cx.sess().bug("get_function_metdata: Expected a function type!")
440 let mut signature = Vec::with_capacity(sig.inputs.len() + 1);
442 // Return type -- llvm::DIBuilder wants this at index 0
443 signature.push(match sig.output {
444 ty::FnConverging(ret_ty) => match ret_ty.sty {
445 ty::TyTuple(ref tys) if tys.is_empty() => ptr::null_mut(),
446 _ => type_metadata(cx, ret_ty, codemap::DUMMY_SP)
448 ty::FnDiverging => diverging_type_metadata(cx)
451 let inputs = &if abi == abi::RustCall {
452 type_of::untuple_arguments(cx, &sig.inputs)
458 for &argument_type in inputs {
459 signature.push(type_metadata(cx, argument_type, codemap::DUMMY_SP));
462 return create_DIArray(DIB(cx), &signature[..]);
465 fn get_template_parameters<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
466 generics: &hir::Generics,
467 param_substs: &Substs<'tcx>,
468 file_metadata: DIFile,
469 name_to_append_suffix_to: &mut String)
472 let self_type = param_substs.self_ty();
473 let self_type = normalize_associated_type(cx.tcx(), &self_type);
475 // Only true for static default methods:
476 let has_self_type = self_type.is_some();
478 if !generics.is_type_parameterized() && !has_self_type {
479 return create_DIArray(DIB(cx), &[]);
482 name_to_append_suffix_to.push('<');
484 // The list to be filled with template parameters:
485 let mut template_params: Vec<DIDescriptor> =
486 Vec::with_capacity(generics.ty_params.len() + 1);
490 let actual_self_type = self_type.unwrap();
491 // Add self type name to <...> clause of function name
492 let actual_self_type_name = compute_debuginfo_type_name(
497 name_to_append_suffix_to.push_str(&actual_self_type_name[..]);
499 if generics.is_type_parameterized() {
500 name_to_append_suffix_to.push_str(",");
503 // Only create type information if full debuginfo is enabled
504 if cx.sess().opts.debuginfo == FullDebugInfo {
505 let actual_self_type_metadata = type_metadata(cx,
509 let name = special_idents::type_self.name.as_str();
511 let name = CString::new(name.as_bytes()).unwrap();
512 let param_metadata = unsafe {
513 llvm::LLVMDIBuilderCreateTemplateTypeParameter(
517 actual_self_type_metadata,
523 template_params.push(param_metadata);
527 // Handle other generic parameters
528 let actual_types = param_substs.types.get_slice(subst::FnSpace);
529 for (index, &hir::TyParam{ name, .. }) in generics.ty_params.iter().enumerate() {
530 let actual_type = actual_types[index];
531 // Add actual type name to <...> clause of function name
532 let actual_type_name = compute_debuginfo_type_name(cx,
535 name_to_append_suffix_to.push_str(&actual_type_name[..]);
537 if index != generics.ty_params.len() - 1 {
538 name_to_append_suffix_to.push_str(",");
541 // Again, only create type information if full debuginfo is enabled
542 if cx.sess().opts.debuginfo == FullDebugInfo {
543 let actual_type_metadata = type_metadata(cx, actual_type, codemap::DUMMY_SP);
544 let name = CString::new(name.as_str().as_bytes()).unwrap();
545 let param_metadata = unsafe {
546 llvm::LLVMDIBuilderCreateTemplateTypeParameter(
550 actual_type_metadata,
555 template_params.push(param_metadata);
559 name_to_append_suffix_to.push('>');
561 return create_DIArray(DIB(cx), &template_params[..]);
565 fn declare_local<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
566 variable_name: ast::Name,
567 variable_type: Ty<'tcx>,
568 scope_metadata: DIScope,
569 variable_access: VariableAccess,
570 variable_kind: VariableKind,
572 let cx: &CrateContext = bcx.ccx();
574 let filename = span_start(cx, span).file.name.clone();
575 let file_metadata = file_metadata(cx, &filename[..]);
577 let loc = span_start(cx, span);
578 let type_metadata = type_metadata(cx, variable_type, span);
580 let (argument_index, dwarf_tag) = match variable_kind {
581 ArgumentVariable(index) => (index as c_uint, DW_TAG_arg_variable),
583 CapturedVariable => (0, DW_TAG_auto_variable)
586 let name = CString::new(variable_name.as_str().as_bytes()).unwrap();
587 match (variable_access, &[][..]) {
588 (DirectVariable { alloca }, address_operations) |
589 (IndirectVariable {alloca, address_operations}, _) => {
590 let metadata = unsafe {
591 llvm::LLVMDIBuilderCreateVariable(
599 cx.sess().opts.optimize != config::OptLevel::No,
601 address_operations.as_ptr(),
602 address_operations.len() as c_uint,
605 source_loc::set_debug_location(cx, InternalDebugLocation::new(scope_metadata,
607 loc.col.to_usize()));
609 let debug_loc = llvm::LLVMGetCurrentDebugLocation(cx.raw_builder());
610 let instr = llvm::LLVMDIBuilderInsertDeclareAtEnd(
614 address_operations.as_ptr(),
615 address_operations.len() as c_uint,
619 llvm::LLVMSetInstDebugLocation(trans::build::B(bcx).llbuilder, instr);
624 match variable_kind {
625 ArgumentVariable(_) | CapturedVariable => {
629 .source_locations_enabled
631 source_loc::set_debug_location(cx, InternalDebugLocation::UnknownLocation);
633 _ => { /* nothing to do */ }
637 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
639 At(ast::NodeId, Span),
644 pub fn apply(&self, fcx: &FunctionContext) {
646 DebugLoc::At(node_id, span) => {
647 source_loc::set_source_location(fcx, node_id, span);
650 source_loc::clear_source_location(fcx);
656 pub trait ToDebugLoc {
657 fn debug_loc(&self) -> DebugLoc;
660 impl ToDebugLoc for hir::Expr {
661 fn debug_loc(&self) -> DebugLoc {
662 DebugLoc::At(self.id, self.span)
666 impl ToDebugLoc for NodeIdAndSpan {
667 fn debug_loc(&self) -> DebugLoc {
668 DebugLoc::At(self.id, self.span)
672 impl ToDebugLoc for Option<NodeIdAndSpan> {
673 fn debug_loc(&self) -> DebugLoc {
675 Some(NodeIdAndSpan { id, span }) => DebugLoc::At(id, span),
676 None => DebugLoc::None