Initial check in
Bug: 137197907
diff --git a/src/librustc_codegen_llvm/debuginfo/mod.rs b/src/librustc_codegen_llvm/debuginfo/mod.rs
new file mode 100644
index 0000000..57e4ac0
--- /dev/null
+++ b/src/librustc_codegen_llvm/debuginfo/mod.rs
@@ -0,0 +1,554 @@
+// See doc.rs for documentation.
+mod doc;
+
+use rustc_codegen_ssa::debuginfo::VariableAccess::*;
+use rustc_codegen_ssa::debuginfo::VariableKind::*;
+
+use self::utils::{DIB, span_start, create_DIArray, is_node_local_to_unit};
+use self::namespace::mangled_name_of_instance;
+use self::type_names::compute_debuginfo_type_name;
+use self::metadata::{type_metadata, file_metadata, TypeMap};
+use self::source_loc::InternalDebugLocation::{self, UnknownLocation};
+
+use crate::llvm;
+use crate::llvm::debuginfo::{DIFile, DIType, DIScope, DIBuilder, DISubprogram, DIArray, DIFlags,
+ DISPFlags, DILexicalBlock};
+use rustc::hir::CodegenFnAttrFlags;
+use rustc::hir::def_id::{DefId, CrateNum, LOCAL_CRATE};
+use rustc::ty::subst::{SubstsRef, UnpackedKind};
+
+use crate::abi::Abi;
+use crate::common::CodegenCx;
+use crate::builder::Builder;
+use crate::monomorphize::Instance;
+use crate::value::Value;
+use rustc::ty::{self, ParamEnv, Ty, InstanceDef};
+use rustc::mir;
+use rustc::session::config::{self, DebugInfo};
+use rustc::util::nodemap::{DefIdMap, FxHashMap, FxHashSet};
+use rustc_data_structures::small_c_str::SmallCStr;
+use rustc_data_structures::indexed_vec::IndexVec;
+use rustc_codegen_ssa::debuginfo::{FunctionDebugContext, MirDebugScope, VariableAccess,
+ VariableKind, FunctionDebugContextData};
+
+use libc::c_uint;
+use std::cell::RefCell;
+use std::ffi::CString;
+
+use syntax_pos::{self, Span, Pos};
+use syntax::ast;
+use syntax::symbol::{Symbol, InternedString};
+use rustc::ty::layout::{self, LayoutOf, HasTyCtxt};
+use rustc_codegen_ssa::traits::*;
+
+pub mod gdb;
+mod utils;
+mod namespace;
+mod type_names;
+pub mod metadata;
+mod create_scope_map;
+mod source_loc;
+
+pub use self::create_scope_map::{create_mir_scopes};
+pub use self::metadata::create_global_var_metadata;
+pub use self::metadata::extend_scope_to_file;
+pub use self::source_loc::set_source_location;
+
+#[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<'a, 'tcx> {
+ llcontext: &'a llvm::Context,
+ llmod: &'a llvm::Module,
+ builder: &'a mut DIBuilder<'a>,
+ created_files: RefCell<FxHashMap<(Symbol, Symbol), &'a DIFile>>,
+ created_enum_disr_types: RefCell<FxHashMap<(DefId, layout::Primitive), &'a DIType>>,
+
+ type_map: RefCell<TypeMap<'a, 'tcx>>,
+ namespace_map: RefCell<DefIdMap<&'a DIScope>>,
+
+ // This collection is used to assert that composite types (structs, enums,
+ // ...) have their members only set once:
+ composite_types_completed: RefCell<FxHashSet<&'a DIType>>,
+}
+
+impl Drop for CrateDebugContext<'a, 'tcx> {
+ fn drop(&mut self) {
+ unsafe {
+ llvm::LLVMRustDIBuilderDispose(&mut *(self.builder as *mut _));
+ }
+ }
+}
+
+impl<'a, 'tcx> CrateDebugContext<'a, 'tcx> {
+ pub fn new(llmod: &'a llvm::Module) -> Self {
+ debug!("CrateDebugContext::new");
+ let builder = unsafe { llvm::LLVMRustDIBuilderCreate(llmod) };
+ // DIBuilder inherits context from the module, so we'd better use the same one
+ let llcontext = unsafe { llvm::LLVMGetModuleContext(llmod) };
+ CrateDebugContext {
+ llcontext,
+ llmod,
+ builder,
+ created_files: Default::default(),
+ created_enum_disr_types: Default::default(),
+ type_map: Default::default(),
+ namespace_map: RefCell::new(Default::default()),
+ composite_types_completed: Default::default(),
+ }
+ }
+}
+
+/// Creates any deferred debug metadata nodes
+pub fn finalize(cx: &CodegenCx<'_, '_>) {
+ if cx.dbg_cx.is_none() {
+ return;
+ }
+
+ debug!("finalize");
+
+ 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::LLVMRustDIBuilderFinalize(DIB(cx));
+ // Debuginfo generation in LLVM by default uses a higher
+ // version of dwarf than macOS currently understands. We can
+ // instruct LLVM to emit an older version of dwarf, however,
+ // for macOS 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());
+ };
+}
+
+impl DebugInfoBuilderMethods<'tcx> for Builder<'a, 'll, 'tcx> {
+ fn declare_local(
+ &mut self,
+ dbg_context: &FunctionDebugContext<&'ll DISubprogram>,
+ variable_name: ast::Name,
+ variable_type: Ty<'tcx>,
+ scope_metadata: &'ll DIScope,
+ variable_access: VariableAccess<'_, &'ll Value>,
+ variable_kind: VariableKind,
+ span: Span,
+ ) {
+ assert!(!dbg_context.get_ref(span).source_locations_enabled);
+ let cx = self.cx();
+
+ let file = span_start(cx, span).file;
+ let file_metadata = file_metadata(cx,
+ &file.name,
+ dbg_context.get_ref(span).defining_crate);
+
+ 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 => (0, DW_TAG_auto_variable)
+ };
+ let align = cx.align_of(variable_type);
+
+ let name = SmallCStr::new(&variable_name.as_str());
+ match (variable_access, &[][..]) {
+ (DirectVariable { alloca }, address_operations) |
+ (IndirectVariable {alloca, address_operations}, _) => {
+ let metadata = unsafe {
+ llvm::LLVMRustDIBuilderCreateVariable(
+ 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,
+ DIFlags::FlagZero,
+ argument_index,
+ align.bytes() as u32,
+ )
+ };
+ source_loc::set_debug_location(self,
+ InternalDebugLocation::new(scope_metadata, loc.line, loc.col.to_usize()));
+ unsafe {
+ let debug_loc = llvm::LLVMGetCurrentDebugLocation(self.llbuilder);
+ let instr = llvm::LLVMRustDIBuilderInsertDeclareAtEnd(
+ DIB(cx),
+ alloca,
+ metadata,
+ address_operations.as_ptr(),
+ address_operations.len() as c_uint,
+ debug_loc,
+ self.llbb());
+
+ llvm::LLVMSetInstDebugLocation(self.llbuilder, instr);
+ }
+ source_loc::set_debug_location(self, UnknownLocation);
+ }
+ }
+ }
+
+ fn set_source_location(
+ &mut self,
+ debug_context: &mut FunctionDebugContext<&'ll DISubprogram>,
+ scope: Option<&'ll DIScope>,
+ span: Span,
+ ) {
+ set_source_location(debug_context, &self, scope, span)
+ }
+ fn insert_reference_to_gdb_debug_scripts_section_global(&mut self) {
+ gdb::insert_reference_to_gdb_debug_scripts_section_global(self)
+ }
+
+ fn set_value_name(&mut self, value: &'ll Value, name: &str) {
+ let cname = SmallCStr::new(name);
+ unsafe {
+ llvm::LLVMSetValueName(value, cname.as_ptr());
+ }
+ }
+}
+
+impl DebugInfoMethods<'tcx> for CodegenCx<'ll, 'tcx> {
+ fn create_function_debug_context(
+ &self,
+ instance: Instance<'tcx>,
+ sig: ty::FnSig<'tcx>,
+ llfn: &'ll Value,
+ mir: &mir::Mir<'_>,
+ ) -> FunctionDebugContext<&'ll DISubprogram> {
+ if self.sess().opts.debuginfo == DebugInfo::None {
+ return FunctionDebugContext::DebugInfoDisabled;
+ }
+
+ if let InstanceDef::Item(def_id) = instance.def {
+ if self.tcx().codegen_fn_attrs(def_id).flags.contains(CodegenFnAttrFlags::NO_DEBUG) {
+ return FunctionDebugContext::FunctionWithoutDebugInfo;
+ }
+ }
+
+ let span = mir.span;
+
+ // This can be the case for functions inlined from another crate
+ if span.is_dummy() {
+ // FIXME(simulacrum): Probably can't happen; remove.
+ return FunctionDebugContext::FunctionWithoutDebugInfo;
+ }
+
+ let def_id = instance.def_id();
+ let containing_scope = get_containing_scope(self, instance);
+ let loc = span_start(self, span);
+ let file_metadata = file_metadata(self, &loc.file.name, def_id.krate);
+
+ let function_type_metadata = unsafe {
+ let fn_signature = get_function_signature(self, sig);
+ llvm::LLVMRustDIBuilderCreateSubroutineType(DIB(self), file_metadata, fn_signature)
+ };
+
+ // Find the enclosing function, in case this is a closure.
+ let def_key = self.tcx().def_key(def_id);
+ let mut name = def_key.disambiguated_data.data.to_string();
+
+ let enclosing_fn_def_id = self.tcx().closure_base_def_id(def_id);
+
+ // Get_template_parameters() will append a `<...>` clause to the function
+ // name if necessary.
+ let generics = self.tcx().generics_of(enclosing_fn_def_id);
+ let substs = instance.substs.truncate_to(self.tcx(), generics);
+ let template_parameters = get_template_parameters(self,
+ &generics,
+ substs,
+ file_metadata,
+ &mut name);
+
+ // Get the linkage_name, which is just the symbol name
+ let linkage_name = mangled_name_of_instance(self, instance);
+
+ let scope_line = span_start(self, span).line;
+
+ let function_name = CString::new(name).unwrap();
+ let linkage_name = SmallCStr::new(&linkage_name.as_str());
+
+ let mut flags = DIFlags::FlagPrototyped;
+
+ if self.layout_of(sig.output()).abi.is_uninhabited() {
+ flags |= DIFlags::FlagNoReturn;
+ }
+
+ let mut spflags = DISPFlags::SPFlagDefinition;
+ if is_node_local_to_unit(self, def_id) {
+ spflags |= DISPFlags::SPFlagLocalToUnit;
+ }
+ if self.sess().opts.optimize != config::OptLevel::No {
+ spflags |= DISPFlags::SPFlagOptimized;
+ }
+ if let Some((id, _)) = self.tcx.entry_fn(LOCAL_CRATE) {
+ if id == def_id {
+ spflags |= DISPFlags::SPFlagMainSubprogram;
+ }
+ }
+
+ let fn_metadata = unsafe {
+ llvm::LLVMRustDIBuilderCreateFunction(
+ DIB(self),
+ containing_scope,
+ function_name.as_ptr(),
+ linkage_name.as_ptr(),
+ file_metadata,
+ loc.line as c_uint,
+ function_type_metadata,
+ scope_line as c_uint,
+ flags,
+ spflags,
+ llfn,
+ template_parameters,
+ None)
+ };
+
+ // Initialize fn debug context (including scope map and namespace map)
+ let fn_debug_context = FunctionDebugContextData {
+ fn_metadata,
+ source_locations_enabled: false,
+ defining_crate: def_id.krate,
+ };
+
+ return FunctionDebugContext::RegularContext(fn_debug_context);
+
+ fn get_function_signature<'ll, 'tcx>(
+ cx: &CodegenCx<'ll, 'tcx>,
+ sig: ty::FnSig<'tcx>,
+ ) -> &'ll DIArray {
+ if cx.sess().opts.debuginfo == DebugInfo::Limited {
+ return create_DIArray(DIB(cx), &[]);
+ }
+
+ let mut signature = Vec::with_capacity(sig.inputs().len() + 1);
+
+ // Return type -- llvm::DIBuilder wants this at index 0
+ signature.push(match sig.output().sty {
+ ty::Tuple(ref tys) if tys.is_empty() => None,
+ _ => Some(type_metadata(cx, sig.output(), syntax_pos::DUMMY_SP))
+ });
+
+ let inputs = if sig.abi == Abi::RustCall {
+ &sig.inputs()[..sig.inputs().len() - 1]
+ } else {
+ sig.inputs()
+ };
+
+ // Arguments types
+ if cx.sess().target.target.options.is_like_msvc {
+ // FIXME(#42800):
+ // There is a bug in MSDIA that leads to a crash when it encounters
+ // a fixed-size array of `u8` or something zero-sized in a
+ // function-type (see #40477).
+ // As a workaround, we replace those fixed-size arrays with a
+ // pointer-type. So a function `fn foo(a: u8, b: [u8; 4])` would
+ // appear as `fn foo(a: u8, b: *const u8)` in debuginfo,
+ // and a function `fn bar(x: [(); 7])` as `fn bar(x: *const ())`.
+ // This transformed type is wrong, but these function types are
+ // already inaccurate due to ABI adjustments (see #42800).
+ signature.extend(inputs.iter().map(|&t| {
+ let t = match t.sty {
+ ty::Array(ct, _)
+ if (ct == cx.tcx.types.u8) || cx.layout_of(ct).is_zst() => {
+ cx.tcx.mk_imm_ptr(ct)
+ }
+ _ => t
+ };
+ Some(type_metadata(cx, t, syntax_pos::DUMMY_SP))
+ }));
+ } else {
+ signature.extend(inputs.iter().map(|t| {
+ Some(type_metadata(cx, t, syntax_pos::DUMMY_SP))
+ }));
+ }
+
+ if sig.abi == Abi::RustCall && !sig.inputs().is_empty() {
+ if let ty::Tuple(args) = sig.inputs()[sig.inputs().len() - 1].sty {
+ signature.extend(
+ args.iter().map(|argument_type| {
+ Some(type_metadata(cx, argument_type, syntax_pos::DUMMY_SP))
+ })
+ );
+ }
+ }
+
+ create_DIArray(DIB(cx), &signature[..])
+ }
+
+ fn get_template_parameters<'ll, 'tcx>(
+ cx: &CodegenCx<'ll, 'tcx>,
+ generics: &ty::Generics,
+ substs: SubstsRef<'tcx>,
+ file_metadata: &'ll DIFile,
+ name_to_append_suffix_to: &mut String,
+ ) -> &'ll DIArray {
+ if substs.types().next().is_none() {
+ return create_DIArray(DIB(cx), &[]);
+ }
+
+ name_to_append_suffix_to.push('<');
+ for (i, actual_type) in substs.types().enumerate() {
+ if i != 0 {
+ name_to_append_suffix_to.push_str(",");
+ }
+
+ let actual_type =
+ cx.tcx.normalize_erasing_regions(ParamEnv::reveal_all(), actual_type);
+ // 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[..]);
+ }
+ name_to_append_suffix_to.push('>');
+
+ // Again, only create type information if full debuginfo is enabled
+ let template_params: Vec<_> = if cx.sess().opts.debuginfo == DebugInfo::Full {
+ let names = get_parameter_names(cx, generics);
+ substs.iter().zip(names).filter_map(|(kind, name)| {
+ if let UnpackedKind::Type(ty) = kind.unpack() {
+ let actual_type =
+ cx.tcx.normalize_erasing_regions(ParamEnv::reveal_all(), ty);
+ let actual_type_metadata =
+ type_metadata(cx, actual_type, syntax_pos::DUMMY_SP);
+ let name = SmallCStr::new(&name.as_str());
+ Some(unsafe {
+ Some(llvm::LLVMRustDIBuilderCreateTemplateTypeParameter(
+ DIB(cx),
+ None,
+ name.as_ptr(),
+ actual_type_metadata,
+ file_metadata,
+ 0,
+ 0,
+ ))
+ })
+ } else {
+ None
+ }
+ }).collect()
+ } else {
+ vec![]
+ };
+
+ return create_DIArray(DIB(cx), &template_params[..]);
+ }
+
+ fn get_parameter_names(cx: &CodegenCx<'_, '_>,
+ generics: &ty::Generics)
+ -> Vec<InternedString> {
+ let mut names = generics.parent.map_or(vec![], |def_id| {
+ get_parameter_names(cx, cx.tcx.generics_of(def_id))
+ });
+ names.extend(generics.params.iter().map(|param| param.name));
+ names
+ }
+
+ fn get_containing_scope<'ll, 'tcx>(
+ cx: &CodegenCx<'ll, 'tcx>,
+ instance: Instance<'tcx>,
+ ) -> &'ll DIScope {
+ // First, let's see if this is a method within an inherent impl. Because
+ // if yes, we want to make the result subroutine DIE a child of the
+ // subroutine's self-type.
+ let self_type = cx.tcx.impl_of_method(instance.def_id()).and_then(|impl_def_id| {
+ // If the method does *not* belong to a trait, proceed
+ if cx.tcx.trait_id_of_impl(impl_def_id).is_none() {
+ let impl_self_ty = cx.tcx.subst_and_normalize_erasing_regions(
+ instance.substs,
+ ty::ParamEnv::reveal_all(),
+ &cx.tcx.type_of(impl_def_id),
+ );
+
+ // Only "class" methods are generally understood by LLVM,
+ // so avoid methods on other types (e.g., `<*mut T>::null`).
+ match impl_self_ty.sty {
+ ty::Adt(def, ..) if !def.is_box() => {
+ Some(type_metadata(cx, impl_self_ty, syntax_pos::DUMMY_SP))
+ }
+ _ => None
+ }
+ } else {
+ // For trait method impls we still use the "parallel namespace"
+ // strategy
+ None
+ }
+ });
+
+ self_type.unwrap_or_else(|| {
+ namespace::item_namespace(cx, DefId {
+ krate: instance.def_id().krate,
+ index: cx.tcx
+ .def_key(instance.def_id())
+ .parent
+ .expect("get_containing_scope: missing parent?")
+ })
+ })
+ }
+ }
+
+ fn create_vtable_metadata(
+ &self,
+ ty: Ty<'tcx>,
+ vtable: Self::Value,
+ ) {
+ metadata::create_vtable_metadata(self, ty, vtable)
+ }
+
+ fn create_mir_scopes(
+ &self,
+ mir: &mir::Mir<'_>,
+ debug_context: &mut FunctionDebugContext<&'ll DISubprogram>,
+ ) -> IndexVec<mir::SourceScope, MirDebugScope<&'ll DIScope>> {
+ create_scope_map::create_mir_scopes(self, mir, debug_context)
+ }
+
+ fn extend_scope_to_file(
+ &self,
+ scope_metadata: &'ll DIScope,
+ file: &syntax_pos::SourceFile,
+ defining_crate: CrateNum,
+ ) -> &'ll DILexicalBlock {
+ metadata::extend_scope_to_file(&self, scope_metadata, file, defining_crate)
+ }
+
+ fn debuginfo_finalize(&self) {
+ finalize(self)
+ }
+
+ fn debuginfo_upvar_decls_ops_sequence(&self, byte_offset_of_var_in_env: u64) -> [i64; 4] {
+ unsafe {
+ [llvm::LLVMRustDIBuilderCreateOpDeref(),
+ llvm::LLVMRustDIBuilderCreateOpPlusUconst(),
+ byte_offset_of_var_in_env as i64,
+ llvm::LLVMRustDIBuilderCreateOpDeref()]
+ }
+ }
+}
