nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-28 01:34:21 +00:00
Code Issues Packages Projects Releases Wiki Activity

rustc_codegen_llvm: Remove (almost) unused span parameter from many functions in metadata.rs.

Browse Source
This commit is contained in:
Michael Woerister 2022-01-10 15:59:52 +01:00
parent a34c079752
commit 9a79ab6c0b
2 changed files with 51 additions and 130 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

162
compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
View File

@ -27,18 +27,18 @@ use rustc_fs_util::path_to_c_string;
use rustc_hir::def::CtorKind; use rustc_hir::def::CtorKind;
use rustc_hir::def_id::{DefId, LOCAL_CRATE}; use rustc_hir::def_id::{DefId, LOCAL_CRATE};
use rustc_index::vec::{Idx, IndexVec}; use rustc_index::vec::{Idx, IndexVec};
use rustc_middle::bug;
use rustc_middle::mir::{self, GeneratorLayout}; use rustc_middle::mir::{self, GeneratorLayout};
use rustc_middle::ty::layout::{self, IntegerExt, LayoutOf, PrimitiveExt, TyAndLayout}; use rustc_middle::ty::layout::{self, IntegerExt, LayoutOf, PrimitiveExt, TyAndLayout};
use rustc_middle::ty::subst::GenericArgKind; use rustc_middle::ty::subst::GenericArgKind;
use rustc_middle::ty::{ use rustc_middle::ty::{
self, AdtKind, GeneratorSubsts, Instance, ParamEnv, Ty, TyCtxt, COMMON_VTABLE_ENTRIES, self, AdtKind, GeneratorSubsts, Instance, ParamEnv, Ty, TyCtxt, COMMON_VTABLE_ENTRIES,
}; };
use rustc_middle::{bug, span_bug};
use rustc_query_system::ich::NodeIdHashingMode; use rustc_query_system::ich::NodeIdHashingMode;
use rustc_session::config::{self, DebugInfo}; use rustc_session::config::{self, DebugInfo};
use rustc_span::symbol::Symbol; use rustc_span::symbol::Symbol;
use rustc_span::FileNameDisplayPreference; use rustc_span::FileNameDisplayPreference;
use rustc_span::{self, SourceFile, SourceFileHash, Span}; use rustc_span::{self, SourceFile, SourceFileHash};
use rustc_target::abi::{Abi, Align, HasDataLayout, Integer, TagEncoding}; use rustc_target::abi::{Abi, Align, HasDataLayout, Integer, TagEncoding};
use rustc_target::abi::{Int, Pointer, F32, F64}; use rustc_target::abi::{Int, Pointer, F32, F64};
use rustc_target::abi::{Primitive, Size, VariantIdx, Variants}; use rustc_target::abi::{Primitive, Size, VariantIdx, Variants};
@ -381,9 +381,8 @@ fn fixed_vec_metadata<'ll, 'tcx>(
unique_type_id: UniqueTypeId, unique_type_id: UniqueTypeId,
array_or_slice_type: Ty<'tcx>, array_or_slice_type: Ty<'tcx>,
element_type: Ty<'tcx>, element_type: Ty<'tcx>,
span: Span,
) -> MetadataCreationResult<'ll> { ) -> MetadataCreationResult<'ll> {
let element_type_metadata = type_metadata(cx, element_type, span); let element_type_metadata = type_metadata(cx, element_type);
return_if_metadata_created_in_meantime!(cx, unique_type_id); return_if_metadata_created_in_meantime!(cx, unique_type_id);
@ -416,11 +415,10 @@ fn vec_slice_metadata<'ll, 'tcx>(
slice_ptr_type: Ty<'tcx>, slice_ptr_type: Ty<'tcx>,
element_type: Ty<'tcx>, element_type: Ty<'tcx>,
unique_type_id: UniqueTypeId, unique_type_id: UniqueTypeId,
span: Span,
) -> MetadataCreationResult<'ll> { ) -> MetadataCreationResult<'ll> {
let data_ptr_type = cx.tcx.mk_imm_ptr(element_type); let data_ptr_type = cx.tcx.mk_imm_ptr(element_type);
let data_ptr_metadata = type_metadata(cx, data_ptr_type, span); let data_ptr_metadata = type_metadata(cx, data_ptr_type);
return_if_metadata_created_in_meantime!(cx, unique_type_id); return_if_metadata_created_in_meantime!(cx, unique_type_id);
@ -442,7 +440,7 @@ fn vec_slice_metadata<'ll, 'tcx>(
}, },
MemberDescription { MemberDescription {
name: "length".to_owned(), name: "length".to_owned(),
type_metadata: type_metadata(cx, cx.tcx.types.usize, span), type_metadata: type_metadata(cx, cx.tcx.types.usize),
offset: pointer_size, offset: pointer_size,
size: usize_size, size: usize_size,
align: usize_align, align: usize_align,
@ -452,8 +450,6 @@ fn vec_slice_metadata<'ll, 'tcx>(
}, },
]; ];
let file_metadata = unknown_file_metadata(cx);
let metadata = composite_type_metadata( let metadata = composite_type_metadata(
cx, cx,
slice_ptr_type, slice_ptr_type,
@ -461,8 +457,6 @@ fn vec_slice_metadata<'ll, 'tcx>(
unique_type_id, unique_type_id,
member_descriptions, member_descriptions,
NO_SCOPE_METADATA, NO_SCOPE_METADATA,
file_metadata,
span,
); );
MetadataCreationResult::new(metadata, false) MetadataCreationResult::new(metadata, false)
} }
@ -471,7 +465,6 @@ fn subroutine_type_metadata<'ll, 'tcx>(
cx: &CodegenCx<'ll, 'tcx>, cx: &CodegenCx<'ll, 'tcx>,
unique_type_id: UniqueTypeId, unique_type_id: UniqueTypeId,
signature: ty::PolyFnSig<'tcx>, signature: ty::PolyFnSig<'tcx>,
span: Span,
) -> MetadataCreationResult<'ll> { ) -> MetadataCreationResult<'ll> {
let signature = let signature =
cx.tcx.normalize_erasing_late_bound_regions(ty::ParamEnv::reveal_all(), signature); cx.tcx.normalize_erasing_late_bound_regions(ty::ParamEnv::reveal_all(), signature);
@ -480,12 +473,12 @@ fn subroutine_type_metadata<'ll, 'tcx>(
// return type // return type
match signature.output().kind() { match signature.output().kind() {
ty::Tuple(tys) if tys.is_empty() => None, ty::Tuple(tys) if tys.is_empty() => None,
_ => Some(type_metadata(cx, signature.output(), span)), _ => Some(type_metadata(cx, signature.output())),
}, },
) )
.chain( .chain(
// regular arguments // regular arguments
signature.inputs().iter().map(|argument_type| Some(type_metadata(cx, argument_type, span))), signature.inputs().iter().map(|argument_type| Some(type_metadata(cx, argument_type))),
) )
.collect(); .collect();
@ -541,8 +534,6 @@ fn trait_pointer_metadata<'ll, 'tcx>(
None => (NO_SCOPE_METADATA, compute_debuginfo_type_name(cx.tcx, trait_type, true)), None => (NO_SCOPE_METADATA, compute_debuginfo_type_name(cx.tcx, trait_type, true)),
}; };
let file_metadata = unknown_file_metadata(cx);
let layout = cx.layout_of(cx.tcx.mk_mut_ptr(trait_type)); let layout = cx.layout_of(cx.tcx.mk_mut_ptr(trait_type));
assert_eq!(abi::FAT_PTR_ADDR, 0); assert_eq!(abi::FAT_PTR_ADDR, 0);
@ -553,11 +544,7 @@ fn trait_pointer_metadata<'ll, 'tcx>(
let member_descriptions = vec![ let member_descriptions = vec![
MemberDescription { MemberDescription {
name: "pointer".to_owned(), name: "pointer".to_owned(),
type_metadata: type_metadata( type_metadata: type_metadata(cx, cx.tcx.mk_mut_ptr(cx.tcx.types.u8)),
cx,
cx.tcx.mk_mut_ptr(cx.tcx.types.u8),
rustc_span::DUMMY_SP,
),
offset: layout.fields.offset(0), offset: layout.fields.offset(0),
size: data_ptr_field.size, size: data_ptr_field.size,
align: data_ptr_field.align.abi, align: data_ptr_field.align.abi,
@ -567,7 +554,7 @@ fn trait_pointer_metadata<'ll, 'tcx>(
}, },
MemberDescription { MemberDescription {
name: "vtable".to_owned(), name: "vtable".to_owned(),
type_metadata: type_metadata(cx, vtable_field.ty, rustc_span::DUMMY_SP), type_metadata: type_metadata(cx, vtable_field.ty),
offset: layout.fields.offset(1), offset: layout.fields.offset(1),
size: vtable_field.size, size: vtable_field.size,
align: vtable_field.align.abi, align: vtable_field.align.abi,
@ -584,16 +571,10 @@ fn trait_pointer_metadata<'ll, 'tcx>(
unique_type_id, unique_type_id,
member_descriptions, member_descriptions,
containing_scope, containing_scope,
file_metadata,
rustc_span::DUMMY_SP,
) )
} }
pub fn type_metadata<'ll, 'tcx>( pub fn type_metadata<'ll, 'tcx>(cx: &CodegenCx<'ll, 'tcx>, t: Ty<'tcx>) -> &'ll DIType {
cx: &CodegenCx<'ll, 'tcx>,
t: Ty<'tcx>,
usage_site_span: Span,
) -> &'ll DIType {
// Get the unique type ID of this type. // Get the unique type ID of this type.
let unique_type_id = { let unique_type_id = {
let mut type_map = debug_context(cx).type_map.borrow_mut(); let mut type_map = debug_context(cx).type_map.borrow_mut();
@ -630,14 +611,14 @@ pub fn type_metadata<'ll, 'tcx>(
debug!("type_metadata: {:?}", t); debug!("type_metadata: {:?}", t);
let ptr_metadata = |ty: Ty<'tcx>| match *ty.kind() { let ptr_metadata = |ty: Ty<'tcx>| match *ty.kind() {
ty::Slice(typ) => Ok(vec_slice_metadata(cx, t, typ, unique_type_id, usage_site_span)), ty::Slice(typ) => Ok(vec_slice_metadata(cx, t, typ, unique_type_id)),
ty::Str => Ok(vec_slice_metadata(cx, t, cx.tcx.types.u8, unique_type_id, usage_site_span)), ty::Str => Ok(vec_slice_metadata(cx, t, cx.tcx.types.u8, unique_type_id)),
ty::Dynamic(..) => Ok(MetadataCreationResult::new( ty::Dynamic(..) => Ok(MetadataCreationResult::new(
trait_pointer_metadata(cx, ty, Some(t), unique_type_id), trait_pointer_metadata(cx, ty, Some(t), unique_type_id),
false, false,
)), )),
_ => { _ => {
let pointee_metadata = type_metadata(cx, ty, usage_site_span); let pointee_metadata = type_metadata(cx, ty);
if let Some(metadata) = if let Some(metadata) =
debug_context(cx).type_map.borrow().find_metadata_for_unique_id(unique_type_id) debug_context(cx).type_map.borrow().find_metadata_for_unique_id(unique_type_id)
@ -656,10 +637,8 @@ pub fn type_metadata<'ll, 'tcx>(
ty::Tuple(elements) if elements.is_empty() => { ty::Tuple(elements) if elements.is_empty() => {
MetadataCreationResult::new(basic_type_metadata(cx, t), false) MetadataCreationResult::new(basic_type_metadata(cx, t), false)
} }
ty::Array(typ, _) | ty::Slice(typ) => { ty::Array(typ, _) | ty::Slice(typ) => fixed_vec_metadata(cx, unique_type_id, t, typ),
fixed_vec_metadata(cx, unique_type_id, t, typ, usage_site_span) ty::Str => fixed_vec_metadata(cx, unique_type_id, t, cx.tcx.types.i8),
}
ty::Str => fixed_vec_metadata(cx, unique_type_id, t, cx.tcx.types.i8, usage_site_span),
ty::Dynamic(..) => { ty::Dynamic(..) => {
MetadataCreationResult::new(trait_pointer_metadata(cx, t, None, unique_type_id), false) MetadataCreationResult::new(trait_pointer_metadata(cx, t, None, unique_type_id), false)
} }
@ -710,8 +689,7 @@ pub fn type_metadata<'ll, 'tcx>(
type_map.borrow_mut().register_type_with_metadata(t, temp_type); type_map.borrow_mut().register_type_with_metadata(t, temp_type);
let fn_metadata = let fn_metadata =
subroutine_type_metadata(cx, unique_type_id, t.fn_sig(cx.tcx), usage_site_span) subroutine_type_metadata(cx, unique_type_id, t.fn_sig(cx.tcx)).metadata;
.metadata;
type_map.borrow_mut().remove_type(t); type_map.borrow_mut().remove_type(t);
@ -721,15 +699,8 @@ pub fn type_metadata<'ll, 'tcx>(
ty::Closure(def_id, substs) => { ty::Closure(def_id, substs) => {
let upvar_tys: Vec<_> = substs.as_closure().upvar_tys().collect(); let upvar_tys: Vec<_> = substs.as_closure().upvar_tys().collect();
let containing_scope = get_namespace_for_item(cx, def_id); let containing_scope = get_namespace_for_item(cx, def_id);
prepare_tuple_metadata( prepare_tuple_metadata(cx, t, &upvar_tys, unique_type_id, Some(containing_scope))
cx, .finalize(cx)
t,
&upvar_tys,
unique_type_id,
usage_site_span,
Some(containing_scope),
)
.finalize(cx)
} }
ty::Generator(def_id, substs, _) => { ty::Generator(def_id, substs, _) => {
let upvar_tys: Vec<_> = substs let upvar_tys: Vec<_> = substs
@ -737,25 +708,18 @@ pub fn type_metadata<'ll, 'tcx>(
.prefix_tys() .prefix_tys()
.map(|t| cx.tcx.normalize_erasing_regions(ParamEnv::reveal_all(), t)) .map(|t| cx.tcx.normalize_erasing_regions(ParamEnv::reveal_all(), t))
.collect(); .collect();
prepare_enum_metadata(cx, t, def_id, unique_type_id, usage_site_span, upvar_tys) prepare_enum_metadata(cx, t, def_id, unique_type_id, upvar_tys).finalize(cx)
.finalize(cx)
} }
ty::Adt(def, ..) => match def.adt_kind() { ty::Adt(def, ..) => match def.adt_kind() {
AdtKind::Struct => { AdtKind::Struct => prepare_struct_metadata(cx, t, unique_type_id).finalize(cx),
prepare_struct_metadata(cx, t, unique_type_id, usage_site_span).finalize(cx) AdtKind::Union => prepare_union_metadata(cx, t, unique_type_id).finalize(cx),
}
AdtKind::Union => {
prepare_union_metadata(cx, t, unique_type_id, usage_site_span).finalize(cx)
}
AdtKind::Enum => { AdtKind::Enum => {
prepare_enum_metadata(cx, t, def.did, unique_type_id, usage_site_span, vec![]) prepare_enum_metadata(cx, t, def.did, unique_type_id, vec![]).finalize(cx)
.finalize(cx)
} }
}, },
ty::Tuple(elements) => { ty::Tuple(elements) => {
let tys: Vec<_> = elements.iter().map(|k| k.expect_ty()).collect(); let tys: Vec<_> = elements.iter().map(|k| k.expect_ty()).collect();
prepare_tuple_metadata(cx, t, &tys, unique_type_id, usage_site_span, NO_SCOPE_METADATA) prepare_tuple_metadata(cx, t, &tys, unique_type_id, NO_SCOPE_METADATA).finalize(cx)
.finalize(cx)
} }
// Type parameters from polymorphized functions. // Type parameters from polymorphized functions.
ty::Param(_) => MetadataCreationResult::new(param_type_metadata(cx, t), false), ty::Param(_) => MetadataCreationResult::new(param_type_metadata(cx, t), false),
@ -770,8 +734,7 @@ pub fn type_metadata<'ll, 'tcx>(
let metadata_for_uid = match type_map.find_metadata_for_unique_id(unique_type_id) { let metadata_for_uid = match type_map.find_metadata_for_unique_id(unique_type_id) {
Some(metadata) => metadata, Some(metadata) => metadata,
None => { None => {
span_bug!( bug!(
usage_site_span,
"expected type metadata for unique \ "expected type metadata for unique \
type ID '{}' to already be in \ type ID '{}' to already be in \
the `debuginfo::TypeMap` but it \ the `debuginfo::TypeMap` but it \
@ -785,8 +748,7 @@ pub fn type_metadata<'ll, 'tcx>(
match type_map.find_metadata_for_type(t) { match type_map.find_metadata_for_type(t) {
Some(metadata) => { Some(metadata) => {
if metadata != metadata_for_uid { if metadata != metadata_for_uid {
span_bug!( bug!(
usage_site_span,
"mismatch between `Ty` and \ "mismatch between `Ty` and \
`UniqueTypeId` maps in \ `UniqueTypeId` maps in \
`debuginfo::TypeMap`. \ `debuginfo::TypeMap`. \
@ -1283,7 +1245,6 @@ impl<'ll, 'tcx> MemberDescriptionFactory<'ll, 'tcx> {
struct StructMemberDescriptionFactory<'tcx> { struct StructMemberDescriptionFactory<'tcx> {
ty: Ty<'tcx>, ty: Ty<'tcx>,
variant: &'tcx ty::VariantDef, variant: &'tcx ty::VariantDef,
span: Span,
} }
impl<'tcx> StructMemberDescriptionFactory<'tcx> { impl<'tcx> StructMemberDescriptionFactory<'tcx> {
@ -1305,7 +1266,7 @@ impl<'tcx> StructMemberDescriptionFactory<'tcx> {
let field = layout.field(cx, i); let field = layout.field(cx, i);
MemberDescription { MemberDescription {
name, name,
type_metadata: type_metadata(cx, field.ty, self.span), type_metadata: type_metadata(cx, field.ty),
offset: layout.fields.offset(i), offset: layout.fields.offset(i),
size: field.size, size: field.size,
align: field.align.abi, align: field.align.abi,
@ -1322,7 +1283,6 @@ fn prepare_struct_metadata<'ll, 'tcx>(
cx: &CodegenCx<'ll, 'tcx>, cx: &CodegenCx<'ll, 'tcx>,
struct_type: Ty<'tcx>, struct_type: Ty<'tcx>,
unique_type_id: UniqueTypeId, unique_type_id: UniqueTypeId,
span: Span,
) -> RecursiveTypeDescription<'ll, 'tcx> { ) -> RecursiveTypeDescription<'ll, 'tcx> {
let struct_name = compute_debuginfo_type_name(cx.tcx, struct_type, false); let struct_name = compute_debuginfo_type_name(cx.tcx, struct_type, false);
@ -1348,7 +1308,7 @@ fn prepare_struct_metadata<'ll, 'tcx>(
unique_type_id, unique_type_id,
struct_metadata_stub, struct_metadata_stub,
struct_metadata_stub, struct_metadata_stub,
StructMDF(StructMemberDescriptionFactory { ty: struct_type, variant, span }), StructMDF(StructMemberDescriptionFactory { ty: struct_type, variant }),
) )
} }
@ -1385,7 +1345,6 @@ fn closure_saved_names_of_captured_variables(tcx: TyCtxt<'_>, def_id: DefId) ->
struct TupleMemberDescriptionFactory<'tcx> { struct TupleMemberDescriptionFactory<'tcx> {
ty: Ty<'tcx>, ty: Ty<'tcx>,
component_types: Vec<Ty<'tcx>>, component_types: Vec<Ty<'tcx>>,
span: Span,
} }
impl<'tcx> TupleMemberDescriptionFactory<'tcx> { impl<'tcx> TupleMemberDescriptionFactory<'tcx> {
@ -1412,7 +1371,7 @@ impl<'tcx> TupleMemberDescriptionFactory<'tcx> {
}; };
MemberDescription { MemberDescription {
name, name,
type_metadata: type_metadata(cx, component_type, self.span), type_metadata: type_metadata(cx, component_type),
offset: layout.fields.offset(i), offset: layout.fields.offset(i),
size, size,
align, align,
@ -1430,7 +1389,6 @@ fn prepare_tuple_metadata<'ll, 'tcx>(
tuple_type: Ty<'tcx>, tuple_type: Ty<'tcx>,
component_types: &[Ty<'tcx>], component_types: &[Ty<'tcx>],
unique_type_id: UniqueTypeId, unique_type_id: UniqueTypeId,
span: Span,
containing_scope: Option<&'ll DIScope>, containing_scope: Option<&'ll DIScope>,
) -> RecursiveTypeDescription<'ll, 'tcx> { ) -> RecursiveTypeDescription<'ll, 'tcx> {
let tuple_name = compute_debuginfo_type_name(cx.tcx, tuple_type, false); let tuple_name = compute_debuginfo_type_name(cx.tcx, tuple_type, false);
@ -1453,7 +1411,6 @@ fn prepare_tuple_metadata<'ll, 'tcx>(
TupleMDF(TupleMemberDescriptionFactory { TupleMDF(TupleMemberDescriptionFactory {
ty: tuple_type, ty: tuple_type,
component_types: component_types.to_vec(), component_types: component_types.to_vec(),
span,
}), }),
) )
} }
@ -1465,7 +1422,6 @@ fn prepare_tuple_metadata<'ll, 'tcx>(
struct UnionMemberDescriptionFactory<'tcx> { struct UnionMemberDescriptionFactory<'tcx> {
layout: TyAndLayout<'tcx>, layout: TyAndLayout<'tcx>,
variant: &'tcx ty::VariantDef, variant: &'tcx ty::VariantDef,
span: Span,
} }
impl<'tcx> UnionMemberDescriptionFactory<'tcx> { impl<'tcx> UnionMemberDescriptionFactory<'tcx> {
@ -1481,7 +1437,7 @@ impl<'tcx> UnionMemberDescriptionFactory<'tcx> {
let field = self.layout.field(cx, i); let field = self.layout.field(cx, i);
MemberDescription { MemberDescription {
name: f.name.to_string(), name: f.name.to_string(),
type_metadata: type_metadata(cx, field.ty, self.span), type_metadata: type_metadata(cx, field.ty),
offset: Size::ZERO, offset: Size::ZERO,
size: field.size, size: field.size,
align: field.align.abi, align: field.align.abi,
@ -1498,7 +1454,6 @@ fn prepare_union_metadata<'ll, 'tcx>(
cx: &CodegenCx<'ll, 'tcx>, cx: &CodegenCx<'ll, 'tcx>,
union_type: Ty<'tcx>, union_type: Ty<'tcx>,
unique_type_id: UniqueTypeId, unique_type_id: UniqueTypeId,
span: Span,
) -> RecursiveTypeDescription<'ll, 'tcx> { ) -> RecursiveTypeDescription<'ll, 'tcx> {
let union_name = compute_debuginfo_type_name(cx.tcx, union_type, false); let union_name = compute_debuginfo_type_name(cx.tcx, union_type, false);
@ -1518,7 +1473,7 @@ fn prepare_union_metadata<'ll, 'tcx>(
unique_type_id, unique_type_id,
union_metadata_stub, union_metadata_stub,
union_metadata_stub, union_metadata_stub,
UnionMDF(UnionMemberDescriptionFactory { layout: cx.layout_of(union_type), variant, span }), UnionMDF(UnionMemberDescriptionFactory { layout: cx.layout_of(union_type), variant }),
) )
} }
@ -1573,7 +1528,6 @@ struct EnumMemberDescriptionFactory<'ll, 'tcx> {
layout: TyAndLayout<'tcx>, layout: TyAndLayout<'tcx>,
tag_type_metadata: Option<&'ll DIType>, tag_type_metadata: Option<&'ll DIType>,
common_members: Vec<Option<&'ll DIType>>, common_members: Vec<Option<&'ll DIType>>,
span: Span,
} }
impl<'ll, 'tcx> EnumMemberDescriptionFactory<'ll, 'tcx> { impl<'ll, 'tcx> EnumMemberDescriptionFactory<'ll, 'tcx> {
@ -1605,7 +1559,7 @@ impl<'ll, 'tcx> EnumMemberDescriptionFactory<'ll, 'tcx> {
// msvc, then we need to use a different, fallback encoding of the debuginfo. // msvc, then we need to use a different, fallback encoding of the debuginfo.
let fallback = cpp_like_debuginfo(cx.tcx); let fallback = cpp_like_debuginfo(cx.tcx);
// This will always find the metadata in the type map. // This will always find the metadata in the type map.
let self_metadata = type_metadata(cx, self.enum_type, self.span); let self_metadata = type_metadata(cx, self.enum_type);
match self.layout.variants { match self.layout.variants {
Variants::Single { index } => { Variants::Single { index } => {
@ -1617,7 +1571,7 @@ impl<'ll, 'tcx> EnumMemberDescriptionFactory<'ll, 'tcx> {
let variant_info = variant_info_for(index); let variant_info = variant_info_for(index);
let (variant_type_metadata, member_description_factory) = let (variant_type_metadata, member_description_factory) =
describe_enum_variant(cx, self.layout, variant_info, self_metadata, self.span); describe_enum_variant(cx, self.layout, variant_info, self_metadata);
let member_descriptions = member_description_factory.create_member_descriptions(cx); let member_descriptions = member_description_factory.create_member_descriptions(cx);
@ -1682,13 +1636,8 @@ impl<'ll, 'tcx> EnumMemberDescriptionFactory<'ll, 'tcx> {
.map(|(i, _)| { .map(|(i, _)| {
let variant = self.layout.for_variant(cx, i); let variant = self.layout.for_variant(cx, i);
let variant_info = variant_info_for(i); let variant_info = variant_info_for(i);
let (variant_type_metadata, member_desc_factory) = describe_enum_variant( let (variant_type_metadata, member_desc_factory) =
cx, describe_enum_variant(cx, variant, variant_info, self_metadata);
variant,
variant_info,
self_metadata,
self.span,
);
let member_descriptions = let member_descriptions =
member_desc_factory.create_member_descriptions(cx); member_desc_factory.create_member_descriptions(cx);
@ -1807,7 +1756,7 @@ impl<'ll, 'tcx> EnumMemberDescriptionFactory<'ll, 'tcx> {
tag.value.size(cx).bits(), tag.value.size(cx).bits(),
tag.value.align(cx).abi.bits() as u32, tag.value.align(cx).abi.bits() as u32,
create_DIArray(DIB(cx), &tags), create_DIArray(DIB(cx), &tags),
type_metadata(cx, discr_enum_ty, self.span), type_metadata(cx, discr_enum_ty),
true, true,
) )
}; };
@ -1818,7 +1767,6 @@ impl<'ll, 'tcx> EnumMemberDescriptionFactory<'ll, 'tcx> {
dataful_variant_layout, dataful_variant_layout,
variant_info, variant_info,
self_metadata, self_metadata,
self.span,
); );
let member_descriptions = member_desc_factory.create_member_descriptions(cx); let member_descriptions = member_desc_factory.create_member_descriptions(cx);
@ -1864,13 +1812,7 @@ impl<'ll, 'tcx> EnumMemberDescriptionFactory<'ll, 'tcx> {
let variant = self.layout.for_variant(cx, i); let variant = self.layout.for_variant(cx, i);
let variant_info = variant_info_for(i); let variant_info = variant_info_for(i);
let (variant_type_metadata, member_desc_factory) = let (variant_type_metadata, member_desc_factory) =
describe_enum_variant( describe_enum_variant(cx, variant, variant_info, self_metadata);
cx,
variant,
variant_info,
self_metadata,
self.span,
);
let member_descriptions = let member_descriptions =
member_desc_factory.create_member_descriptions(cx); member_desc_factory.create_member_descriptions(cx);
@ -1908,7 +1850,6 @@ struct VariantMemberDescriptionFactory<'tcx> {
/// Cloned from the `layout::Struct` describing the variant. /// Cloned from the `layout::Struct` describing the variant.
offsets: Vec<Size>, offsets: Vec<Size>,
args: Vec<(String, Ty<'tcx>)>, args: Vec<(String, Ty<'tcx>)>,
span: Span,
} }
impl<'tcx> VariantMemberDescriptionFactory<'tcx> { impl<'tcx> VariantMemberDescriptionFactory<'tcx> {
@ -1923,7 +1864,7 @@ impl<'tcx> VariantMemberDescriptionFactory<'tcx> {
let (size, align) = cx.size_and_align_of(ty); let (size, align) = cx.size_and_align_of(ty);
MemberDescription { MemberDescription {
name: name.to_string(), name: name.to_string(),
type_metadata: type_metadata(cx, ty, self.span), type_metadata: type_metadata(cx, ty),
offset: self.offsets[i], offset: self.offsets[i],
size, size,
align, align,
@ -2011,7 +1952,6 @@ fn describe_enum_variant<'ll, 'tcx>(
layout: layout::TyAndLayout<'tcx>, layout: layout::TyAndLayout<'tcx>,
variant: VariantInfo<'_, 'tcx>, variant: VariantInfo<'_, 'tcx>,
containing_scope: &'ll DIScope, containing_scope: &'ll DIScope,
span: Span,
) -> (&'ll DICompositeType, MemberDescriptionFactory<'ll, 'tcx>) { ) -> (&'ll DICompositeType, MemberDescriptionFactory<'ll, 'tcx>) {
let metadata_stub = variant.map_struct_name(|variant_name| { let metadata_stub = variant.map_struct_name(|variant_name| {
let unique_type_id = debug_context(cx) let unique_type_id = debug_context(cx)
@ -2033,8 +1973,7 @@ fn describe_enum_variant<'ll, 'tcx>(
.map(|i| (variant.field_name(i), layout.field(cx, i).ty)) .map(|i| (variant.field_name(i), layout.field(cx, i).ty))
.collect(); .collect();
let member_description_factory = let member_description_factory = VariantMDF(VariantMemberDescriptionFactory { offsets, args });
VariantMDF(VariantMemberDescriptionFactory { offsets, args, span });
(metadata_stub, member_description_factory) (metadata_stub, member_description_factory)
} }
@ -2044,7 +1983,6 @@ fn prepare_enum_metadata<'ll, 'tcx>(
enum_type: Ty<'tcx>, enum_type: Ty<'tcx>,
enum_def_id: DefId, enum_def_id: DefId,
unique_type_id: UniqueTypeId, unique_type_id: UniqueTypeId,
span: Span,
outer_field_tys: Vec<Ty<'tcx>>, outer_field_tys: Vec<Ty<'tcx>>,
) -> RecursiveTypeDescription<'ll, 'tcx> { ) -> RecursiveTypeDescription<'ll, 'tcx> {
let tcx = cx.tcx; let tcx = cx.tcx;
@ -2109,8 +2047,7 @@ fn prepare_enum_metadata<'ll, 'tcx>(
Some(discriminant_type_metadata) => discriminant_type_metadata, Some(discriminant_type_metadata) => discriminant_type_metadata,
None => { None => {
let (discriminant_size, discriminant_align) = (discr.size(cx), discr.align(cx)); let (discriminant_size, discriminant_align) = (discr.size(cx), discr.align(cx));
let discriminant_base_type_metadata = let discriminant_base_type_metadata = type_metadata(cx, discr.to_ty(tcx));
type_metadata(cx, discr.to_ty(tcx), rustc_span::DUMMY_SP);
let item_name; let item_name;
let discriminant_name = match enum_type.kind() { let discriminant_name = match enum_type.kind() {
@ -2202,7 +2139,6 @@ fn prepare_enum_metadata<'ll, 'tcx>(
layout, layout,
tag_type_metadata: discriminant_type_metadata, tag_type_metadata: discriminant_type_metadata,
common_members: vec![], common_members: vec![],
span,
}), }),
); );
} }
@ -2272,11 +2208,8 @@ fn prepare_enum_metadata<'ll, 'tcx>(
let outer_fields = match layout.variants { let outer_fields = match layout.variants {
Variants::Single { .. } => vec![], Variants::Single { .. } => vec![],
Variants::Multiple { .. } => { Variants::Multiple { .. } => {
let tuple_mdf = TupleMemberDescriptionFactory { let tuple_mdf =
ty: enum_type, TupleMemberDescriptionFactory { ty: enum_type, component_types: outer_field_tys };
component_types: outer_field_tys,
span,
};
tuple_mdf tuple_mdf
.create_member_descriptions(cx) .create_member_descriptions(cx)
.into_iter() .into_iter()
@ -2352,7 +2285,6 @@ fn prepare_enum_metadata<'ll, 'tcx>(
layout, layout,
tag_type_metadata: None, tag_type_metadata: None,
common_members: outer_fields, common_members: outer_fields,
span,
}), }),
) )
} }
@ -2368,11 +2300,6 @@ fn composite_type_metadata<'ll, 'tcx>(
composite_type_unique_id: UniqueTypeId, composite_type_unique_id: UniqueTypeId,
member_descriptions: Vec<MemberDescription<'ll>>, member_descriptions: Vec<MemberDescription<'ll>>,
containing_scope: Option<&'ll DIScope>, containing_scope: Option<&'ll DIScope>,
// Ignore source location information as long as it
// can't be reconstructed for non-local crates.
_file_metadata: &'ll DIFile,
_definition_span: Span,
) -> &'ll DICompositeType { ) -> &'ll DICompositeType {
// Create the (empty) struct metadata node ... // Create the (empty) struct metadata node ...
let composite_type_metadata = create_struct_stub( let composite_type_metadata = create_struct_stub(
@ -2450,8 +2377,7 @@ fn compute_type_parameters<'ll, 'tcx>(cx: &CodegenCx<'ll, 'tcx>, ty: Ty<'tcx>) -
if let GenericArgKind::Type(ty) = kind.unpack() { if let GenericArgKind::Type(ty) = kind.unpack() {
let actual_type = let actual_type =
cx.tcx.normalize_erasing_regions(ParamEnv::reveal_all(), ty); cx.tcx.normalize_erasing_regions(ParamEnv::reveal_all(), ty);
let actual_type_metadata = let actual_type_metadata = type_metadata(cx, actual_type);
type_metadata(cx, actual_type, rustc_span::DUMMY_SP);
let name = name.as_str(); let name = name.as_str();
Some(unsafe { Some(unsafe {
Some(llvm::LLVMRustDIBuilderCreateTemplateTypeParameter( Some(llvm::LLVMRustDIBuilderCreateTemplateTypeParameter(
@ -2593,7 +2519,7 @@ pub fn create_global_var_metadata<'ll>(cx: &CodegenCx<'ll, '_>, def_id: DefId, g
let is_local_to_unit = is_node_local_to_unit(cx, def_id); let is_local_to_unit = is_node_local_to_unit(cx, def_id);
let variable_type = Instance::mono(cx.tcx, def_id).ty(cx.tcx, ty::ParamEnv::reveal_all()); let variable_type = Instance::mono(cx.tcx, def_id).ty(cx.tcx, ty::ParamEnv::reveal_all());
let type_metadata = type_metadata(cx, variable_type, span); let type_metadata = type_metadata(cx, variable_type);
let var_name = tcx.item_name(def_id); let var_name = tcx.item_name(def_id);
let var_name = var_name.as_str(); let var_name = var_name.as_str();
let linkage_name = mangled_name_of_instance(cx, Instance::mono(tcx, def_id)).name; let linkage_name = mangled_name_of_instance(cx, Instance::mono(tcx, def_id)).name;
@ -2648,7 +2574,7 @@ fn vtable_type_metadata<'ll, 'tcx>(
// things simple instead of adding some ad-hoc disambiguation scheme. // things simple instead of adding some ad-hoc disambiguation scheme.
let vtable_type = tcx.mk_array(tcx.mk_imm_ptr(tcx.types.unit), vtable_entries.len() as u64); let vtable_type = tcx.mk_array(tcx.mk_imm_ptr(tcx.types.unit), vtable_entries.len() as u64);
type_metadata(cx, vtable_type, rustc_span::DUMMY_SP) type_metadata(cx, vtable_type)
} }
/// Creates debug information for the given vtable, which is for the /// Creates debug information for the given vtable, which is for the

19
compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
View File

@ -390,7 +390,7 @@ impl<'ll, 'tcx> DebugInfoMethods<'tcx> for CodegenCx<'ll, 'tcx> {
signature.push(if fn_abi.ret.is_ignore() { signature.push(if fn_abi.ret.is_ignore() {
None None
} else { } else {
Some(type_metadata(cx, fn_abi.ret.layout.ty, rustc_span::DUMMY_SP)) Some(type_metadata(cx, fn_abi.ret.layout.ty))
}); });
// Arguments types // Arguments types
@ -415,15 +415,11 @@ impl<'ll, 'tcx> DebugInfoMethods<'tcx> for CodegenCx<'ll, 'tcx> {
} }
_ => t, _ => t,
}; };
Some(type_metadata(cx, t, rustc_span::DUMMY_SP)) Some(type_metadata(cx, t))
})); }));
} else { } else {
signature.extend( signature
fn_abi .extend(fn_abi.args.iter().map(|arg| Some(type_metadata(cx, arg.layout.ty))));
.args
.iter()
.map(|arg| Some(type_metadata(cx, arg.layout.ty, rustc_span::DUMMY_SP))),
);
} }
create_DIArray(DIB(cx), &signature[..]) create_DIArray(DIB(cx), &signature[..])
@ -453,8 +449,7 @@ impl<'ll, 'tcx> DebugInfoMethods<'tcx> for CodegenCx<'ll, 'tcx> {
if let GenericArgKind::Type(ty) = kind.unpack() { if let GenericArgKind::Type(ty) = kind.unpack() {
let actual_type = let actual_type =
cx.tcx.normalize_erasing_regions(ParamEnv::reveal_all(), ty); cx.tcx.normalize_erasing_regions(ParamEnv::reveal_all(), ty);
let actual_type_metadata = let actual_type_metadata = type_metadata(cx, actual_type);
type_metadata(cx, actual_type, rustc_span::DUMMY_SP);
let name = name.as_str(); let name = name.as_str();
Some(unsafe { Some(unsafe {
Some(llvm::LLVMRustDIBuilderCreateTemplateTypeParameter( Some(llvm::LLVMRustDIBuilderCreateTemplateTypeParameter(
@ -509,7 +504,7 @@ impl<'ll, 'tcx> DebugInfoMethods<'tcx> for CodegenCx<'ll, 'tcx> {
if cx.sess().opts.debuginfo == DebugInfo::Full if cx.sess().opts.debuginfo == DebugInfo::Full
&& !impl_self_ty.needs_subst() && !impl_self_ty.needs_subst()
{ {
Some(type_metadata(cx, impl_self_ty, rustc_span::DUMMY_SP)) Some(type_metadata(cx, impl_self_ty))
} else { } else {
Some(namespace::item_namespace(cx, def.did)) Some(namespace::item_namespace(cx, def.did))
} }
@ -584,7 +579,7 @@ impl<'ll, 'tcx> DebugInfoMethods<'tcx> for CodegenCx<'ll, 'tcx> {
let loc = self.lookup_debug_loc(span.lo()); let loc = self.lookup_debug_loc(span.lo());
let file_metadata = file_metadata(self, &loc.file); let file_metadata = file_metadata(self, &loc.file);
let type_metadata = type_metadata(self, variable_type, span); let type_metadata = type_metadata(self, variable_type);
let (argument_index, dwarf_tag) = match variable_kind { let (argument_index, dwarf_tag) = match variable_kind {
ArgumentVariable(index) => (index as c_uint, DW_TAG_arg_variable), ArgumentVariable(index) => (index as c_uint, DW_TAG_arg_variable),