8000 Rollup of 10 pull requests by matthiaskrgr · Pull Request #105525 · rust-lang/rust · GitHub
[go: up one dir, main page]
Skip to content

Rollup of 10 pull requests #105525

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 29 commits into from
Dec 10, 2022
Merged

Rollup of 10 pull requests #105525

Changes from 1 commit
Commits
Show all changes
29 commits
Select commit Hold shift + click to select a range
9678cec
std: rewrite SGX thread parker
joboet Jun 22, 2022
633d46d
std: reimplement SGX thread joining to use `Parker`
joboet Jun 22, 2022
a40d300
std: clarify semantics of SGX parker
joboet Sep 5, 2022
ac67262
Set `download-ci-llvm = "if-available"` by default when `channel = "d…
jyn514 Nov 17, 2022
7700595
Implement masking in FileType comparison on Unix
krtab Nov 25, 2022
6259028
Add test for regression for FileType equality
krtab Nov 30, 2022
4198d29
Implement masking in FileType hashing on Unix
krtab Dec 6, 2022
b45b948
Compute generator sizes with -Zprint_type_sizes
compiler-errors Nov 5, 2022
b0dcadf
Move closure/generator type info methods to TyCtxt
compiler-errors Dec 7, 2022
57b7226
Properly print generator interior type sizes
compiler-errors Dec 7, 2022
7d23e29
Pull out logic into distinct functions
compiler-errors Dec 7, 2022
ecf8127
Fix Async Generator ABI
Swatinem Nov 29, 2022
65698ae
Add LLVM KCFI support to the Rust compiler
rcvalle Nov 22, 2022
e1741ba
Add documentation for LLVM KCFI support
rcvalle Dec 1, 2022
24cd863
Replace hand-made masking by call to masked() method in FileType
krtab Dec 9, 2022
84a4635
Don't warn about unused parens when they are used by yeet expr
WaffleLapkin Dec 9, 2022
b9da55a
Introduce `Span::is_visible`
estebank Dec 9, 2022
ac90c9b
Update cargo
weihanglo Dec 10, 2022
f069e71
Correct wrong note for short circuiting operators
est31 Dec 10, 2022
ae8794c
Rollup merge of #98391 - joboet:sgx_parker, r=m-ou-se
matthiaskrgr Dec 10, 2022
0f5d3ba
Rollup merge of #104019 - compiler-errors:print-generator-sizes, r=we…
matthiaskrgr Dec 10, 2022
1ce18d2
Rollup merge of #104512 - jyn514:download-ci-llvm-default, r=Mark-Sim…
matthiaskrgr Dec 10, 2022
eb1159c
Rollup merge of #104901 - krtab:filetype_compare, r=the8472
matthiaskrgr Dec 10, 2022
020d7af
Rollup merge of #105082 - Swatinem:async-abi, r=compiler-errors
matthiaskrgr Dec 10, 2022
947fe7e
Rollup merge of #105109 - rcvalle:rust-kcfi, r=bjorn3
matthiaskrgr Dec 10, 2022
9e87dd9
Rollup merge of #105505 - WaffleLapkin:yeet_unused_parens_lint, r=fee…
matthiaskrgr Dec 10, 2022
cf84006
Rollup merge of #105514 - estebank:is_visible, r=oli-obk
matthiaskrgr Dec 10, 2022
6d7e3df
Rollup merge of #105516 - weihanglo:update-cargo, r=weihanglo
matthiaskrgr Dec 10, 2022
f6c2add
Rollup merge of #105522 - est31:remove_or_and_note, r=scottmcm
matthiaskrgr Dec 10, 2022
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Prev Previous commit
Next Next commit
Pull out logic into distinct functions
  • Loading branch information
@compiler-errors
compiler-errors committed Dec 8, 2022
commit 7d23e29f9fb61985aca0227acbabb62f95208c01
349 changes: 165 additions & 184 deletions compiler/rustc_ty_utils/src/layout.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,3 +1,4 @@
use hir::def_id::DefId;
use rustc_hir as hir;
use rustc_index::bit_set::BitSet;
use rustc_index::vec::{Idx, IndexVec};
Expand All @@ -6,7 +7,7 @@ use rustc_middle::ty::layout::{
IntegerExt, LayoutCx, LayoutError, LayoutOf, TyAndLayout, MAX_SIMD_LANES,
};
use rustc_middle::ty::{
self, subst::SubstsRef, EarlyBinder, ReprOptions, Ty, TyCtxt, TypeVisitable,
self, subst::SubstsRef, AdtDef, EarlyBinder, ReprOptions, Ty, TyCtxt, TypeVisitable,
};
use rustc_session::{DataTypeKind, FieldInfo, SizeKind, VariantInfo};
use rustc_span::symbol::Symbol;
Expand Down Expand Up @@ -815,206 +816,186 @@ fn record_layout_for_printing_outlined<'tcx>(
};

match *layout.ty.kind() {
ty::Adt(ref adt_def, _) => {
ty::Adt(adt_def, _) => {
debug!("print-type-size t: `{:?}` process adt", layout.ty);
let adt_kind = adt_def.adt_kind();
let adt_packed = adt_def.repr().pack.is_some();

let build_variant_info =
|n: Option<Symbol>, flds: &[Symbol], layout: TyAndLayout<'tcx>| {
let mut min_size = Size::ZERO;
let field_info: Vec<_> = flds
.iter()
.enumerate()
.map(|(i, &name)| {
let field_layout = layout.field(cx, i);
let offset = layout.fields.offset(i);
min_size = min_size.max(offset + field_layout.size);
FieldInfo {
name,
offset: offset.bytes(),
size: field_layout.size.bytes(),
align: field_layout.align.abi.bytes(),
}
})
.collect();

VariantInfo {
name: n,
kind: if layout.is_unsized() { SizeKind::Min } else { SizeKind::Exact },
align: layout.align.abi.bytes(),
size: if min_size.bytes() == 0 {
layout.size.bytes()
} else {
min_size.bytes()
},
fields: field_info,
}
};

match layout.variants {
Variants::Single { index } => {
if !adt_def.variants().is_empty() && layout.fields != FieldsShape::Primitive {
debug!(
"print-type-size `{:#?}` variant {}",
layout,
adt_def.variant(index).name
);
let variant_def = &adt_def.variant(index);
let fields: Vec<_> = variant_def.fields.iter().map(|f| f.name).collect();
record(
adt_kind.into(),
adt_packed,
None,
vec![build_variant_info(Some(variant_def.name), &fields, layout)],
);
} else {
// (This case arises for *empty* enums; so give it
// zero variants.)
record(adt_kind.into(), adt_packed, None, vec![]);
}
}

Variants::Multiple { tag, ref tag_encoding, .. } => {
debug!(
"print-type-size `{:#?}` adt general variants def {}",
layout.ty,
adt_def.variants().len()
);
let variant_infos: Vec<_> = adt_def
.variants()
.iter_enumerated()
.map(|(i, variant_def)| {
let fields: Vec<_> =
variant_def.fields.iter().map(|f| f.name).collect();
build_variant_info(
Some(variant_def.name),
&fields,
layout.for_variant(cx, i),
)
})
.collect();
record(
adt_kind.into(),
adt_packed,
match tag_encoding {
TagEncoding::Direct => Some(tag.size(cx)),
_ => None,
},
variant_infos,
);
}
}
let (variant_infos, opt_discr_size) = variant_info_for_adt(cx, layout, adt_def);
record(adt_kind.into(), adt_packed, opt_discr_size, variant_infos);
}

ty::Generator(def_id, substs, _) => {
debug!("print-type-size t: `{:?}` record generator", layout.ty);
// Generators always have a begin/poisoned/end state with additional suspend points
match layout.variants {
Variants::Multiple { tag, ref tag_encoding, .. } => {
let (generator, state_specific_names) =
cx.tcx.generator_layout_and_saved_local_names(def_id);
let upvar_names = cx.tcx.closure_saved_names_of_captured_variables(def_id);

let mut upvars_size = Size::ZERO;
let upvar_fields: Vec<_> = substs
.as_generator()
.upvar_tys()
.zip(upvar_names)
.enumerate()
.map(|(field_idx, (_, name))| {
let field_layout = layout.field(cx, field_idx);
let offset = layout.fields.offset(field_idx);
upvars_size = upvars_size.max(offset + field_layout.size);
FieldInfo {
name: Symbol::intern(&name),
offset: offset.bytes(),
size: field_layout.size.bytes(),
align: field_layout.align.abi.bytes(),
}
})
.collect();

let variant_infos: Vec<_> = generator
.variant_fields
.iter_enumerated()
.map(|(variant_idx, variant_def)| {
let variant_layout = layout.for_variant(cx, variant_idx);
let mut variant_size = Size::ZERO;
let fields = variant_def
.iter()
.enumerate()
.map(|(field_idx, local)| {
let field_layout = variant_layout.field(cx, field_idx);
let offset = variant_layout.fields.offset(field_idx);
// The struct is as large as the last field's end
variant_size = variant_size.max(offset + field_layout.size);
FieldInfo {
name: state_specific_names
.get(*local)
.copied()
.flatten()
.unwrap_or(Symbol::intern(&format!(
".generator_field{}",
local.as_usize()
))),
offset: offset.bytes(),
size: field_layout.size.bytes(),
align: field_layout.align.abi.bytes(),
}
})
.chain(upvar_fields.iter().copied())
.collect();

// If the variant has no state-specific fields, then it's the size of the upvars.
if variant_size == Size::ZERO {
variant_size = upvars_size;
}
// We need to add the discriminant size back into min_size, since it is subtracted
// later during printing.
variant_size += match tag_encoding {
TagEncoding::Direct => tag.size(cx),
_ => Size::ZERO,
};

VariantInfo {
name: Some(Symbol::intern(&ty::GeneratorSubsts::variant_name(
variant_idx,
))),
kind: SizeKind::Exact,
size: variant_size.bytes(),
align: variant_layout.align.abi.bytes(),
fields,
}
})
.collect();
record(
DataTypeKind::Generator,
false,
match tag_encoding {
TagEncoding::Direct => Some(tag.size(cx)),
_ => None,
},
variant_infos,
);
}
_ => {
// This should never happen, but I would rather not panic.
record(DataTypeKind::Generator, false, None, vec![]);
return;
}
}
let (variant_infos, opt_discr_size) =
variant_info_for_generator(cx, layout, def_id, substs);
record(DataTypeKind::Generator, false, opt_discr_size, variant_infos);
}

ty::Closure(..) => {
debug!("print-type-size t: `{:?}` record closure", layout.ty);
record(DataTypeKind::Closure, false, None, vec![]);
return;
}

_ => {
debug!("print-type-size t: `{:?}` skip non-nominal", layout.ty);
return;
}
};
}

fn variant_info_for_adt<'tcx>(
cx: &LayoutCx<'tcx, TyCtxt<'tcx>>,
layout: TyAndLayout<'tcx>,
adt_def: AdtDef<'tcx>,
) -> (Vec<VariantInfo>, Option<Size>) {
let build_variant_info = |n: Option<Symbol>, flds: &[Symbol], layout: TyAndLayout<'tcx>| {
let mut min_size = Size::ZERO;
let field_info: Vec<_> = flds
8000 .iter()
.enumerate()
.map(|(i, &name)| {
let field_layout = layout.field(cx, i);
let offset = layout.fields.offset(i);
min_size = min_size.max(offset + field_layout.size);
FieldInfo {
name,
offset: offset.bytes(),
size: field_layout.size.bytes(),
align: field_layout.align.abi.bytes(),
}
})
.collect();

VariantInfo {
name: n,
kind: if layout.is_unsized() { SizeKind::Min } else { SizeKind::Exact },
align: layout.align.abi.bytes(),
size: if min_size.bytes() == 0 { layout.size.bytes() } else { min_size.bytes() },
fields: field_info,
}
};

match layout.variants {
Variants::Single { index } => {
if !adt_def.variants().is_empty() && layout.fields != FieldsShape::Primitive {
debug!("print-type-size `{:#?}` variant {}", layout, adt_def.variant(index).name);
let variant_def = &adt_def.variant(index);
let fields: Vec<_> = variant_def.fields.iter().map(|f| f.name).collect();
(vec![build_variant_info(Some(variant_def.name), &fields, layout)], None)
} else {
(vec![], None)
}
}

Variants::Multiple { tag, ref tag_encoding, .. } => {
debug!(
"print-type-size `{:#?}` adt general variants def {}",
layout.ty,
adt_def.variants().len()
);
let variant_infos: Vec<_> = adt_def
.variants()
.iter_enumerated()
.map(|(i, variant_def)| {
let fields: Vec<_> = variant_def.fields.iter().map(|f| f.name).collect();
build_variant_info(Some(variant_def.name), &fields, layout.for_variant(cx, i))
})
.collect();

(
variant_infos,
match tag_encoding {
TagEncoding::Direct => Some(tag.size(cx)),
_ => None,
},
)
}
}
}

fn variant_info_for_generator<'tcx>(
cx: &LayoutCx<'tcx, TyCtxt<'tcx>>,
layout: TyAndLayout<'tcx>,
def_id: DefId,
substs: ty::SubstsRef<'tcx>,
) -> (Vec<VariantInfo>, Option<Size>) {
let Variants::Multiple { tag, ref tag_encoding, .. } = layout.variants else {
return (vec![], None);
};

let (generator, state_specific_names) = cx.tcx.generator_layout_and_saved_local_names(def_id);
let upvar_names = cx.tcx.closure_saved_names_of_captured_variables(def_id);

let mut upvars_size = Size::ZERO;
let upvar_fields: Vec<_> = substs
.as_generator()
.upvar_tys()
.zip(upvar_names)
.enumerate()
.map(|(field_idx, (_, name))| {
let field_layout = layout.field(cx, field_idx);
let offset = layout.fields.offset(field_idx);
upvars_size = upvars_size.max(offset + field_layout.size);
FieldInfo {
name: Symbol::intern(&name),
offset: offset.bytes(),
size: field_layout.size.bytes(),
align: field_layout.align.abi.bytes(),
}
})
.collect();

let variant_infos: Vec<_> = generator
.variant_fields
.iter_enumerated()
.map(|(variant_idx, variant_def)| {
let variant_layout = layout.for_variant(cx, variant_idx);
let mut variant_size = Size::ZERO;
let fields = variant_def
.iter()
.enumerate()
.map(|(field_idx, local)| {
let field_layout = variant_layout.field(cx, field_idx);
let offset = variant_layout.fields.offset(field_idx);
// The struct is as large as the last field's end
variant_size = variant_size.max(offset + field_layout.size);
FieldInfo {
name: state_specific_names.get(*local).copied().flatten().unwrap_or(
Symbol::intern(&format!(".generator_field{}", local.as_usize())),
),
offset: offset.bytes(),
size: field_layout.size.bytes(),
align: field_layout.align.abi.bytes(),
}
})
.chain(upvar_fields.iter().copied())
.collect();

// If the variant has no state-specific fields, then it's the size of the upvars.
if variant_size == Size::ZERO {
variant_size = upvars_size;
}
// We need to add the discriminant size back into min_size, since it is subtracted
// later during printing.
variant_size += match tag_encoding {
TagEncoding::Direct => tag.size(cx),
_ => Size::ZERO,
};

VariantInfo {
name: Some(Symbol::intern(&ty::GeneratorSubsts::variant_name(variant_idx))),
kind: SizeKind::Exact,
size: variant_size.bytes(),
align: variant_layout.align.abi.bytes(),
fields,
}
})
.collect();
(
variant_infos,
match tag_encoding {
TagEncoding::Direct => Some(tag.size(cx)),
_ => None,
},
)
}
0