// Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 or the MIT license // , at your // option. This file may not be copied, modified, or distributed // except according to those terms. // See doc.rs for documentation. mod doc; use self::VariableAccess::*; use self::VariableKind::*; use self::utils::{DIB, span_start, assert_type_for_node_id, contains_nodebug_attribute, create_DIArray, is_node_local_to_unit}; use self::namespace::{namespace_for_item, NamespaceTreeNode}; use self::type_names::compute_debuginfo_type_name; use self::metadata::{type_metadata, diverging_type_metadata}; use self::metadata::{file_metadata, scope_metadata, TypeMap, compile_unit_metadata}; use self::source_loc::InternalDebugLocation; use llvm; use llvm::{ModuleRef, ContextRef, ValueRef}; use llvm::debuginfo::{DIFile, DIType, DIScope, DIBuilderRef, DISubprogram, DIArray, DIDescriptor, FlagPrototyped}; use middle::def_id::DefId; use middle::infer::normalize_associated_type; use middle::subst::{self, Substs}; use rustc_front; use rustc_front::hir; use trans::common::{NodeIdAndSpan, CrateContext, FunctionContext, Block}; use trans; use trans::{monomorphize, type_of}; use middle::infer; use middle::ty::{self, Ty}; use session::config::{self, FullDebugInfo, LimitedDebugInfo, NoDebugInfo}; use util::nodemap::{NodeMap, FnvHashMap, FnvHashSet}; use rustc::front::map as hir_map; use libc::c_uint; use std::cell::{Cell, RefCell}; use std::ffi::CString; use std::ptr; use std::rc::Rc; use syntax::codemap::{Span, Pos}; use syntax::{abi, ast, codemap}; use syntax::attr::IntType; use syntax::parse::token::{self, special_idents}; pub mod gdb; mod utils; mod namespace; mod type_names; mod metadata; mod create_scope_map; mod source_loc; pub use self::source_loc::set_source_location; pub use self::source_loc::clear_source_location; pub use self::source_loc::start_emitting_source_locations; pub use self::source_loc::get_cleanup_debug_loc_for_ast_node; pub use self::source_loc::with_source_location_override; pub use self::metadata::create_match_binding_metadata; pub use self::metadata::create_argument_metadata; pub use self::metadata::create_captured_var_metadata; pub use self::metadata::create_global_var_metadata; pub use self::metadata::create_local_var_metadata; #[allow(non_upper_case_globals)] const DW_TAG_auto_variable: c_uint = 0x100; #[allow(non_upper_case_globals)] const DW_TAG_arg_variable: c_uint = 0x101; /// A context object for maintaining all state needed by the debuginfo module. pub struct CrateDebugContext<'tcx> { llcontext: ContextRef, builder: DIBuilderRef, current_debug_location: Cell, created_files: RefCell>, created_enum_disr_types: RefCell>, type_map: RefCell>, namespace_map: RefCell, Rc>>, // This collection is used to assert that composite types (structs, enums, // ...) have their members only set once: composite_types_completed: RefCell>, } impl<'tcx> CrateDebugContext<'tcx> { pub fn new(llmod: ModuleRef) -> CrateDebugContext<'tcx> { debug!("CrateDebugContext::new"); let builder = unsafe { llvm::LLVMDIBuilderCreate(llmod) }; // DIBuilder inherits context from the module, so we'd better use the same one let llcontext = unsafe { llvm::LLVMGetModuleContext(llmod) }; return CrateDebugContext { llcontext: llcontext, builder: builder, current_debug_location: Cell::new(InternalDebugLocation::UnknownLocation), created_files: RefCell::new(FnvHashMap()), created_enum_disr_types: RefCell::new(FnvHashMap()), type_map: RefCell::new(TypeMap::new()), namespace_map: RefCell::new(FnvHashMap()), composite_types_completed: RefCell::new(FnvHashSet()), }; } } pub enum FunctionDebugContext { RegularContext(Box), DebugInfoDisabled, FunctionWithoutDebugInfo, } impl FunctionDebugContext { fn get_ref<'a>(&'a self, cx: &CrateContext, span: Span) -> &'a FunctionDebugContextData { match *self { FunctionDebugContext::RegularContext(box ref data) => data, FunctionDebugContext::DebugInfoDisabled => { cx.sess().span_bug(span, FunctionDebugContext::debuginfo_disabled_message()); } FunctionDebugContext::FunctionWithoutDebugInfo => { cx.sess().span_bug(span, FunctionDebugContext::should_be_ignored_message()); } } } fn debuginfo_disabled_message() -> &'static str { "debuginfo: Error trying to access FunctionDebugContext although debug info is disabled!" } fn should_be_ignored_message() -> &'static str { "debuginfo: Error trying to access FunctionDebugContext for function that should be \ ignored by debug info!" } } pub struct FunctionDebugContextData { scope_map: RefCell>, fn_metadata: DISubprogram, argument_counter: Cell, source_locations_enabled: Cell, source_location_override: Cell, } pub enum VariableAccess<'a> { // The llptr given is an alloca containing the variable's value DirectVariable { alloca: ValueRef }, // The llptr given is an alloca containing the start of some pointer chain // leading to the variable's content. IndirectVariable { alloca: ValueRef, address_operations: &'a [i64] } } pub enum VariableKind { ArgumentVariable(usize /*index*/), LocalVariable, CapturedVariable, } /// Create any deferred debug metadata nodes pub fn finalize(cx: &CrateContext) { if cx.dbg_cx().is_none() { return; } debug!("finalize"); let _ = compile_unit_metadata(cx); if gdb::needs_gdb_debug_scripts_section(cx) { // Add a .debug_gdb_scripts section to this compile-unit. This will // cause GDB to try and load the gdb_load_rust_pretty_printers.py file, // which activates the Rust pretty printers for binary this section is // contained in. gdb::get_or_insert_gdb_debug_scripts_section_global(cx); } unsafe { llvm::LLVMDIBuilderFinalize(DIB(cx)); llvm::LLVMDIBuilderDispose(DIB(cx)); // Debuginfo generation in LLVM by default uses a higher // version of dwarf than OS X currently understands. We can // instruct LLVM to emit an older version of dwarf, however, // for OS X to understand. For more info see #11352 // This can be overridden using --llvm-opts -dwarf-version,N. // Android has the same issue (#22398) if cx.sess().target.target.options.is_like_osx || cx.sess().target.target.options.is_like_android { llvm::LLVMRustAddModuleFlag(cx.llmod(), "Dwarf Version\0".as_ptr() as *const _, 2) } // Indicate that we want CodeView debug information on MSVC if cx.sess().target.target.options.is_like_msvc { llvm::LLVMRustAddModuleFlag(cx.llmod(), "CodeView\0".as_ptr() as *const _, 1) } // Prevent bitcode readers from deleting the debug info. let ptr = "Debug Info Version\0".as_ptr(); llvm::LLVMRustAddModuleFlag(cx.llmod(), ptr as *const _, llvm::LLVMRustDebugMetadataVersion()); }; } /// Creates the function-specific debug context. /// /// Returns the FunctionDebugContext for the function which holds state needed /// for debug info creation. The function may also return another variant of the /// FunctionDebugContext enum which indicates why no debuginfo should be created /// for the function. pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, fn_ast_id: ast::NodeId, param_substs: &Substs<'tcx>, llfn: ValueRef) -> FunctionDebugContext { if cx.sess().opts.debuginfo == NoDebugInfo { return FunctionDebugContext::DebugInfoDisabled; } // Clear the debug location so we don't assign them in the function prelude. // Do this here already, in case we do an early exit from this function. source_loc::set_debug_location(cx, InternalDebugLocation::UnknownLocation); if fn_ast_id == ast::DUMMY_NODE_ID { // This is a function not linked to any source location, so don't // generate debuginfo for it. return FunctionDebugContext::FunctionWithoutDebugInfo; } let empty_generics = rustc_front::util::empty_generics(); let fnitem = cx.tcx().map.get(fn_ast_id); let (name, fn_decl, generics, top_level_block, span, has_path) = match fnitem { hir_map::NodeItem(ref item) => { if contains_nodebug_attribute(&item.attrs) { return FunctionDebugContext::FunctionWithoutDebugInfo; } match item.node { hir::ItemFn(ref fn_decl, _, _, _, ref generics, ref top_level_block) => { (item.name, fn_decl, generics, top_level_block, item.span, true) } _ => { cx.sess().span_bug(item.span, "create_function_debug_context: item bound to non-function"); } } } hir_map::NodeImplItem(impl_item) => { match impl_item.node { hir::ImplItemKind::Method(ref sig, ref body) => { if contains_nodebug_attribute(&impl_item.attrs) { return FunctionDebugContext::FunctionWithoutDebugInfo; } (impl_item.name, &sig.decl, &sig.generics, body, impl_item.span, true) } _ => { cx.sess().span_bug(impl_item.span, "create_function_debug_context() \ called on non-method impl item?!") } } } hir_map::NodeExpr(ref expr) => { match expr.node { hir::ExprClosure(_, ref fn_decl, ref top_level_block) => { let name = format!("fn{}", token::gensym("fn")); let name = token::intern(&name[..]); (name, fn_decl, // This is not quite right. It should actually inherit // the generics of the enclosing function. &empty_generics, top_level_block, expr.span, // Don't try to lookup the item path: false) } _ => cx.sess().span_bug(expr.span, "create_function_debug_context: expected an expr_fn_block here") } } hir_map::NodeTraitItem(trait_item) => { match trait_item.node { hir::MethodTraitItem(ref sig, Some(ref body)) => { if contains_nodebug_attribute(&trait_item.attrs) { return FunctionDebugContext::FunctionWithoutDebugInfo; } (trait_item.name, &sig.decl, &sig.generics, body, trait_item.span, true) } _ => { cx.sess() .bug(&format!("create_function_debug_context: \ unexpected sort of node: {:?}", fnitem)) } } } hir_map::NodeForeignItem(..) | hir_map::NodeVariant(..) | hir_map::NodeStructCtor(..) => { return FunctionDebugContext::FunctionWithoutDebugInfo; } _ => cx.sess().bug(&format!("create_function_debug_context: \ unexpected sort of node: {:?}", fnitem)) }; // This can be the case for functions inlined from another crate if span == codemap::DUMMY_SP { return FunctionDebugContext::FunctionWithoutDebugInfo; } let loc = span_start(cx, span); let file_metadata = file_metadata(cx, &loc.file.name); let function_type_metadata = unsafe { let fn_signature = get_function_signature(cx, fn_ast_id, param_substs, span); llvm::LLVMDIBuilderCreateSubroutineType(DIB(cx), file_metadata, fn_signature) }; // Get_template_parameters() will append a `<...>` clause to the function // name if necessary. let mut function_name = name.to_string(); let template_parameters = get_template_parameters(cx, generics, param_substs, file_metadata, &mut function_name); // There is no hir_map::Path for hir::ExprClosure-type functions. For now, // just don't put them into a namespace. In the future this could be improved // somehow (storing a path in the hir_map, or construct a path using the // enclosing function). let (linkage_name, containing_scope) = if has_path { let fn_ast_def_id = cx.tcx().map.local_def_id(fn_ast_id); let namespace_node = namespace_for_item(cx, fn_ast_def_id); let linkage_name = namespace_node.mangled_name_of_contained_item( &function_name[..]); let containing_scope = namespace_node.scope; (linkage_name, containing_scope) } else { (function_name.clone(), file_metadata) }; // Clang sets this parameter to the opening brace of the function's block, // so let's do this too. let scope_line = span_start(cx, top_level_block.span).line; let is_local_to_unit = is_node_local_to_unit(cx, fn_ast_id); let function_name = CString::new(function_name).unwrap(); let linkage_name = CString::new(linkage_name).unwrap(); let fn_metadata = unsafe { llvm::LLVMDIBuilderCreateFunction( DIB(cx), containing_scope, function_name.as_ptr(), linkage_name.as_ptr(), file_metadata, loc.line as c_uint, function_type_metadata, is_local_to_unit, true, scope_line as c_uint, FlagPrototyped as c_uint, cx.sess().opts.optimize != config::OptLevel::No, llfn, template_parameters, ptr::null_mut()) }; let scope_map = create_scope_map::create_scope_map(cx, &fn_decl.inputs, &*top_level_block, fn_metadata, fn_ast_id); // Initialize fn debug context (including scope map and namespace map) let fn_debug_context = box FunctionDebugContextData { scope_map: RefCell::new(scope_map), fn_metadata: fn_metadata, argument_counter: Cell::new(1), source_locations_enabled: Cell::new(false), source_location_override: Cell::new(false), }; return FunctionDebugContext::RegularContext(fn_debug_context); fn get_function_signature<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, fn_ast_id: ast::NodeId, param_substs: &Substs<'tcx>, error_reporting_span: Span) -> DIArray { if cx.sess().opts.debuginfo == LimitedDebugInfo { return create_DIArray(DIB(cx), &[]); } // Return type -- llvm::DIBuilder wants this at index 0 assert_type_for_node_id(cx, fn_ast_id, error_reporting_span); let fn_type = cx.tcx().node_id_to_type(fn_ast_id); let fn_type = monomorphize::apply_param_substs(cx.tcx(), param_substs, &fn_type); let (sig, abi) = match fn_type.sty { ty::TyBareFn(_, ref barefnty) => { let sig = cx.tcx().erase_late_bound_regions(&barefnty.sig); let sig = infer::normalize_associated_type(cx.tcx(), &sig); (sig, barefnty.abi) } ty::TyClosure(def_id, ref substs) => { let closure_type = cx.tcx().closure_type(def_id, substs); let sig = cx.tcx().erase_late_bound_regions(&closure_type.sig); let sig = infer::normalize_associated_type(cx.tcx(), &sig); (sig, closure_type.abi) } _ => cx.sess().bug("get_function_metdata: Expected a function type!") }; let mut signature = Vec::with_capacity(sig.inputs.len() + 1); // Return type -- llvm::DIBuilder wants this at index 0 signature.push(match sig.output { ty::FnConverging(ret_ty) => match ret_ty.sty { ty::TyTuple(ref tys) if tys.is_empty() => ptr::null_mut(), _ => type_metadata(cx, ret_ty, codemap::DUMMY_SP) }, ty::FnDiverging => diverging_type_metadata(cx) }); let inputs = &if abi == abi::RustCall { type_of::untuple_arguments(cx, &sig.inputs) } else { sig.inputs }; // Arguments types for &argument_type in inputs { signature.push(type_metadata(cx, argument_type, codemap::DUMMY_SP)); } return create_DIArray(DIB(cx), &signature[..]); } fn get_template_parameters<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, generics: &hir::Generics, param_substs: &Substs<'tcx>, file_metadata: DIFile, name_to_append_suffix_to: &mut String) -> DIArray { let self_type = param_substs.self_ty(); let self_type = normalize_associated_type(cx.tcx(), &self_type); // Only true for static default methods: let has_self_type = self_type.is_some(); if !generics.is_type_parameterized() && !has_self_type { return create_DIArray(DIB(cx), &[]); } name_to_append_suffix_to.push('<'); // The list to be filled with template parameters: let mut template_params: Vec = Vec::with_capacity(generics.ty_params.len() + 1); // Handle self type if has_self_type { let actual_self_type = self_type.unwrap(); // Add self type name to <...> clause of function name let actual_self_type_name = compute_debuginfo_type_name( cx, actual_self_type, true); name_to_append_suffix_to.push_str(&actual_self_type_name[..]); if generics.is_type_parameterized() { name_to_append_suffix_to.push_str(","); } // Only create type information if full debuginfo is enabled if cx.sess().opts.debuginfo == FullDebugInfo { let actual_self_type_metadata = type_metadata(cx, actual_self_type, codemap::DUMMY_SP); let name = special_idents::type_self.name.as_str(); let name = CString::new(name.as_bytes()).unwrap(); let param_metadata = unsafe { llvm::LLVMDIBuilderCreateTemplateTypeParameter( DIB(cx), ptr::null_mut(), name.as_ptr(), actual_self_type_metadata, file_metadata, 0, 0) }; template_params.push(param_metadata); } } // Handle other generic parameters let actual_types = param_substs.types.get_slice(subst::FnSpace); for (index, &hir::TyParam{ name, .. }) in generics.ty_params.iter().enumerate() { let actual_type = actual_types[index]; // Add actual type name to <...> clause of function name let actual_type_name = compute_debuginfo_type_name(cx, actual_type, true); name_to_append_suffix_to.push_str(&actual_type_name[..]); if index != generics.ty_params.len() - 1 { name_to_append_suffix_to.push_str(","); } // Again, only create type information if full debuginfo is enabled if cx.sess().opts.debuginfo == FullDebugInfo { let actual_type_metadata = type_metadata(cx, actual_type, codemap::DUMMY_SP); let name = CString::new(name.as_str().as_bytes()).unwrap(); let param_metadata = unsafe { llvm::LLVMDIBuilderCreateTemplateTypeParameter( DIB(cx), ptr::null_mut(), name.as_ptr(), actual_type_metadata, file_metadata, 0, 0) }; template_params.push(param_metadata); } } name_to_append_suffix_to.push('>'); return create_DIArray(DIB(cx), &template_params[..]); } } fn declare_local<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, variable_name: ast::Name, variable_type: Ty<'tcx>, scope_metadata: DIScope, variable_access: VariableAccess, variable_kind: VariableKind, span: Span) { let cx: &CrateContext = bcx.ccx(); let filename = span_start(cx, span).file.name.clone(); let file_metadata = file_metadata(cx, &filename[..]); let loc = span_start(cx, span); let type_metadata = type_metadata(cx, variable_type, span); let (argument_index, dwarf_tag) = match variable_kind { ArgumentVariable(index) => (index as c_uint, DW_TAG_arg_variable), LocalVariable | CapturedVariable => (0, DW_TAG_auto_variable) }; let name = CString::new(variable_name.as_str().as_bytes()).unwrap(); match (variable_access, &[][..]) { (DirectVariable { alloca }, address_operations) | (IndirectVariable {alloca, address_operations}, _) => { let metadata = unsafe { llvm::LLVMDIBuilderCreateVariable( DIB(cx), dwarf_tag, scope_metadata, name.as_ptr(), file_metadata, loc.line as c_uint, type_metadata, cx.sess().opts.optimize != config::OptLevel::No, 0, address_operations.as_ptr(), address_operations.len() as c_uint, argument_index) }; source_loc::set_debug_location(cx, InternalDebugLocation::new(scope_metadata, loc.line, loc.col.to_usize())); unsafe { let debug_loc = llvm::LLVMGetCurrentDebugLocation(cx.raw_builder()); let instr = llvm::LLVMDIBuilderInsertDeclareAtEnd( DIB(cx), alloca, metadata, address_operations.as_ptr(), address_operations.len() as c_uint, debug_loc, bcx.llbb); llvm::LLVMSetInstDebugLocation(trans::build::B(bcx).llbuilder, instr); } } } match variable_kind { ArgumentVariable(_) | CapturedVariable => { assert!(!bcx.fcx .debug_context .get_ref(cx, span) .source_locations_enabled .get()); source_loc::set_debug_location(cx, InternalDebugLocation::UnknownLocation); } _ => { /* nothing to do */ } } } #[derive(Copy, Clone, PartialEq, Eq, Debug)] pub enum DebugLoc { At(ast::NodeId, Span), None } impl DebugLoc { pub fn apply(&self, fcx: &FunctionContext) { match *self { DebugLoc::At(node_id, span) => { source_loc::set_source_location(fcx, node_id, span); } DebugLoc::None => { source_loc::clear_source_location(fcx); } } } } pub trait ToDebugLoc { fn debug_loc(&self) -> DebugLoc; } impl ToDebugLoc for hir::Expr { fn debug_loc(&self) -> DebugLoc { DebugLoc::At(self.id, self.span) } } impl ToDebugLoc for NodeIdAndSpan { fn debug_loc(&self) -> DebugLoc { DebugLoc::At(self.id, self.span) } } impl ToDebugLoc for Option { fn debug_loc(&self) -> DebugLoc { match *self { Some(NodeIdAndSpan { id, span }) => DebugLoc::At(id, span), None => DebugLoc::None } } }