Skip to content

Commit e8a2673

Browse files
VeykrilVeykril
committed
Add VariantIdx back
1 parent f14b7c9 commit e8a2673

File tree

3 files changed

+87
-61
lines changed

3 files changed

+87
-61
lines changed

‎compiler/rustc_abi/src/layout.rs‎

Lines changed: 55 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -8,15 +8,19 @@ use tracing::debug;
88
use crate::{
99
Abi, AbiAndPrefAlign, Align, FieldsShape, IndexSlice, IndexVec, Integer, LayoutS, Niche,
1010
NonZeroUsize, Primitive, ReprOptions, Scalar, Size, StructKind, TagEncoding, TargetDataLayout,
11-
VariantIdx, Variants, WrappingRange, FIRST_VARIANT,
11+
Variants, WrappingRange,
1212
};
1313
pub trait LayoutCalculator {
1414
type TargetDataLayoutRef: Borrow<TargetDataLayout>;
1515

1616
fn delay_bug(&self, txt: String);
1717
fn current_data_layout(&self) -> Self::TargetDataLayoutRef;
1818

19-
fn scalar_pair<FieldIdx: Idx>(&self, a: Scalar, b: Scalar) -> LayoutS<FieldIdx> {
19+
fn scalar_pair<FieldIdx: Idx, VariantIdx: Idx>(
20+
&self,
21+
a: Scalar,
22+
b: Scalar,
23+
) -> LayoutS<FieldIdx, VariantIdx> {
2024
let dl = self.current_data_layout();
2125
let dl = dl.borrow();
2226
let b_align = b.align(dl);
@@ -32,7 +36,7 @@ pub trait LayoutCalculator {
3236
.max_by_key(|niche| niche.available(dl));
3337

3438
LayoutS {
35-
variants: Variants::Single { index: FIRST_VARIANT },
39+
variants: Variants::Single { index: VariantIdx::new(0) },
3640
fields: FieldsShape::Arbitrary {
3741
offsets: [Size::ZERO, b_offset].into(),
3842
memory_index: [0, 1].into(),
@@ -46,13 +50,18 @@ pub trait LayoutCalculator {
4650
}
4751
}
4852

49-
fn univariant<'a, FieldIdx: Idx, F: Deref<Target = &'a LayoutS<FieldIdx>> + fmt::Debug>(
53+
fn univariant<
54+
'a,
55+
FieldIdx: Idx,
56+
VariantIdx: Idx,
57+
F: Deref<Target = &'a LayoutS<FieldIdx, VariantIdx>> + fmt::Debug,
58+
>(
5059
&self,
5160
dl: &TargetDataLayout,
5261
fields: &IndexSlice<FieldIdx, F>,
5362
repr: &ReprOptions,
5463
kind: StructKind,
55-
) -> Option<LayoutS<FieldIdx>> {
64+
) -> Option<LayoutS<FieldIdx, VariantIdx>> {
5665
let layout = univariant(self, dl, fields, repr, kind, NicheBias::Start);
5766
// Enums prefer niches close to the beginning or the end of the variants so that other
5867
// (smaller) data-carrying variants can be packed into the space after/before the niche.
@@ -115,11 +124,13 @@ pub trait LayoutCalculator {
115124
layout
116125
}
117126

118-
fn layout_of_never_type<FieldIdx: Idx>(&self) -> LayoutS<FieldIdx> {
127+
fn layout_of_never_type<FieldIdx: Idx, VariantIdx: Idx>(
128+
&self,
129+
) -> LayoutS<FieldIdx, VariantIdx> {
119130
let dl = self.current_data_layout();
120131
let dl = dl.borrow();
121132
LayoutS {
122-
variants: Variants::Single { index: FIRST_VARIANT },
133+
variants: Variants::Single { index: VariantIdx::new(0) },
123134
fields: FieldsShape::Primitive,
124135
abi: Abi::Uninhabited,
125136
largest_niche: None,
@@ -133,7 +144,8 @@ pub trait LayoutCalculator {
133144
fn layout_of_struct_or_enum<
134145
'a,
135146
FieldIdx: Idx,
136-
F: Deref<Target = &'a LayoutS<FieldIdx>> + fmt::Debug,
147+
VariantIdx: Idx,
148+
F: Deref<Target = &'a LayoutS<FieldIdx, VariantIdx>> + fmt::Debug,
137149
>(
138150
&self,
139151
repr: &ReprOptions,
@@ -145,7 +157,7 @@ pub trait LayoutCalculator {
145157
discriminants: impl Iterator<Item = (VariantIdx, i128)>,
146158
dont_niche_optimize_enum: bool,
147159
always_sized: bool,
148-
) -> Option<LayoutS<FieldIdx>> {
160+
) -> Option<LayoutS<FieldIdx, VariantIdx>> {
149161
let dl = self.current_data_layout();
150162
let dl = dl.borrow();
151163

@@ -181,7 +193,7 @@ pub trait LayoutCalculator {
181193
}
182194
// If it's a struct, still compute a layout so that we can still compute the
183195
// field offsets.
184-
None => FIRST_VARIANT,
196+
None => VariantIdx::new(0),
185197
};
186198

187199
let is_struct = !is_enum ||
@@ -284,12 +296,12 @@ pub trait LayoutCalculator {
284296
// variant layouts, so we can't store them in the
285297
// overall LayoutS. Store the overall LayoutS
286298
// and the variant LayoutSs here until then.
287-
struct TmpLayout<FieldIdx: Idx> {
288-
layout: LayoutS<FieldIdx>,
289-
variants: IndexVec<VariantIdx, LayoutS<FieldIdx>>,
299+
struct TmpLayout<FieldIdx: Idx, VariantIdx: Idx> {
300+
layout: LayoutS<FieldIdx, VariantIdx>,
301+
variants: IndexVec<VariantIdx, LayoutS<FieldIdx, VariantIdx>>,
290302
}
291303

292-
let calculate_niche_filling_layout = || -> Option<TmpLayout<FieldIdx>> {
304+
let calculate_niche_filling_layout = || -> Option<TmpLayout<FieldIdx, VariantIdx>> {
293305
if dont_niche_optimize_enum {
294306
return None;
295307
}
@@ -327,7 +339,8 @@ pub trait LayoutCalculator {
327339
let niche_variants = all_indices.clone().find(|v| needs_disc(*v)).unwrap()
328340
..=all_indices.rev().find(|v| needs_disc(*v)).unwrap();
329341

330-
let count = niche_variants.size_hint().1.unwrap() as u128;
342+
let count =
343+
niche_variants.end().index() as u128 - niche_variants.start().index() as u128;
331344

332345
// Find the field with the largest niche
333346
let (field_index, niche, (niche_start, niche_scalar)) = variants[largest_variant_index]
@@ -660,7 +673,7 @@ pub trait LayoutCalculator {
660673
// Common prim might be uninit.
661674
Scalar::Union { value: prim }
662675
};
663-
let pair = self.scalar_pair(tag, prim_scalar);
676+
let pair = self.scalar_pair::<FieldIdx, VariantIdx>(tag, prim_scalar);
664677
let pair_offsets = match pair.fields {
665678
FieldsShape::Arbitrary { ref offsets, ref memory_index } => {
666679
assert_eq!(memory_index.raw, [0, 1]);
@@ -726,7 +739,7 @@ pub trait LayoutCalculator {
726739
// pick the layout with the larger niche; otherwise,
727740
// pick tagged as it has simpler codegen.
728741
use cmp::Ordering::*;
729-
let niche_size = |tmp_l: &TmpLayout<FieldIdx>| {
742+
let niche_size = |tmp_l: &TmpLayout<FieldIdx, VariantIdx>| {
730743
tmp_l.layout.largest_niche.map_or(0, |n| n.available(dl))
731744
};
732745
match (tl.layout.size.cmp(&nl.layout.size), niche_size(&tl).cmp(&niche_size(&nl))) {
@@ -748,11 +761,16 @@ pub trait LayoutCalculator {
748761
Some(best_layout.layout)
749762
}
750763

751-
fn layout_of_union<'a, FieldIdx: Idx, F: Deref<Target = &'a LayoutS<FieldIdx>> + fmt::Debug>(
764+
fn layout_of_union<
765+
'a,
766+
FieldIdx: Idx,
767+
VariantIdx: Idx,
768+
F: Deref<Target = &'a LayoutS<FieldIdx, VariantIdx>> + fmt::Debug,
769+
>(
752770
&self,
753771
repr: &ReprOptions,
754772
variants: &IndexSlice<VariantIdx, IndexVec<FieldIdx, F>>,
755-
) -> Option<LayoutS<FieldIdx>> {
773+
) -> Option<LayoutS<FieldIdx, VariantIdx>> {
756774
let dl = self.current_data_layout();
757775
let dl = dl.borrow();
758776
let mut align = if repr.pack.is_some() { dl.i8_align } else { dl.aggregate_align };
@@ -769,7 +787,7 @@ pub trait LayoutCalculator {
769787
};
770788

771789
let mut size = Size::ZERO;
772-
let only_variant = &variants[FIRST_VARIANT];
790+
let only_variant = &variants[VariantIdx::new(0)];
773791
for field in only_variant {
774792
if field.is_unsized() {
775793
self.delay_bug("unsized field in union".to_string());
@@ -836,7 +854,7 @@ pub trait LayoutCalculator {
836854
};
837855

838856
Some(LayoutS {
839-
variants: Variants::Single { index: FIRST_VARIANT },
857+
variants: Variants::Single { index: VariantIdx::new(0) },
840858
fields: FieldsShape::Union(NonZeroUsize::new(only_variant.len())?),
841859
abi,
842860
largest_niche: None,
@@ -854,14 +872,19 @@ enum NicheBias {
854872
End,
855873
}
856874

857-
fn univariant<'a, FieldIdx: Idx, F: Deref<Target = &'a LayoutS<FieldIdx>> + fmt::Debug>(
875+
fn univariant<
876+
'a,
877+
FieldIdx: Idx,
878+
VariantIdx: Idx,
879+
F: Deref<Target = &'a LayoutS<FieldIdx, VariantIdx>> + fmt::Debug,
880+
>(
858881
this: &(impl LayoutCalculator + ?Sized),
859882
dl: &TargetDataLayout,
860883
fields: &IndexSlice<FieldIdx, F>,
861884
repr: &ReprOptions,
862885
kind: StructKind,
863886
niche_bias: NicheBias,
864-
) -> Option<LayoutS<FieldIdx>> {
887+
) -> Option<LayoutS<FieldIdx, VariantIdx>> {
865888
let pack = repr.pack;
866889
let mut align = if pack.is_some() { dl.i8_align } else { dl.aggregate_align };
867890
let mut max_repr_align = repr.align;
@@ -1120,7 +1143,7 @@ fn univariant<'a, FieldIdx: Idx, F: Deref<Target = &'a LayoutS<FieldIdx>> + fmt:
11201143
} else {
11211144
((j, b), (i, a))
11221145
};
1123-
let pair = this.scalar_pair(a, b);
1146+
let pair = this.scalar_pair::<FieldIdx, VariantIdx>(a, b);
11241147
let pair_offsets = match pair.fields {
11251148
FieldsShape::Arbitrary { ref offsets, ref memory_index } => {
11261149
assert_eq!(memory_index.raw, [0, 1]);
@@ -1162,7 +1185,7 @@ fn univariant<'a, FieldIdx: Idx, F: Deref<Target = &'a LayoutS<FieldIdx>> + fmt:
11621185
};
11631186

11641187
Some(LayoutS {
1165-
variants: Variants::Single { index: FIRST_VARIANT },
1188+
variants: Variants::Single { index: VariantIdx::new(0) },
11661189
fields: FieldsShape::Arbitrary { offsets, memory_index },
11671190
abi,
11681191
largest_niche,
@@ -1173,8 +1196,13 @@ fn univariant<'a, FieldIdx: Idx, F: Deref<Target = &'a LayoutS<FieldIdx>> + fmt:
11731196
})
11741197
}
11751198

1176-
fn format_field_niches<'a, FieldIdx: Idx, F: Deref<Target = &'a LayoutS<FieldIdx>> + fmt::Debug>(
1177-
layout: &LayoutS<FieldIdx>,
1199+
fn format_field_niches<
1200+
'a,
1201+
FieldIdx: Idx,
1202+
VariantIdx: Idx,
1203+
F: Deref<Target = &'a LayoutS<FieldIdx, VariantIdx>> + fmt::Debug,
1204+
>(
1205+
layout: &LayoutS<FieldIdx, VariantIdx>,
11781206
fields: &IndexSlice<FieldIdx, F>,
11791207
dl: &TargetDataLayout,
11801208
) -> String {

‎compiler/rustc_abi/src/lib.rs‎

Lines changed: 11 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -11,7 +11,6 @@ use std::ops::{Add, AddAssign, Mul, RangeInclusive, Sub};
1111
use std::str::FromStr;
1212

1313
use bitflags::bitflags;
14-
use rustc_data_structures::intern::Interned;
1514
use rustc_data_structures::stable_hasher::Hash64;
1615
#[cfg(feature = "nightly")]
1716
use rustc_data_structures::stable_hasher::StableOrd;
@@ -1360,7 +1359,7 @@ impl Abi {
13601359

13611360
#[derive(PartialEq, Eq, Hash, Clone, Debug)]
13621361
#[cfg_attr(feature = "nightly", derive(HashStable_Generic))]
1363-
pub enum Variants<FieldIdx: Idx> {
1362+
pub enum Variants<FieldIdx: Idx, VariantIdx: Idx> {
13641363
/// Single enum variants, structs/tuples, unions, and all non-ADTs.
13651364
Single { index: VariantIdx },
13661365

@@ -1372,15 +1371,15 @@ pub enum Variants<FieldIdx: Idx> {
13721371
/// For enums, the tag is the sole field of the layout.
13731372
Multiple {
13741373
tag: Scalar,
1375-
tag_encoding: TagEncoding,
1374+
tag_encoding: TagEncoding<VariantIdx>,
13761375
tag_field: usize,
1377-
variants: IndexVec<VariantIdx, LayoutS<FieldIdx>>,
1376+
variants: IndexVec<VariantIdx, LayoutS<FieldIdx, VariantIdx>>,
13781377
},
13791378
}
13801379

13811380
#[derive(PartialEq, Eq, Hash, Clone, Debug)]
13821381
#[cfg_attr(feature = "nightly", derive(HashStable_Generic))]
1383-
pub enum TagEncoding {
1382+
pub enum TagEncoding<VariantIdx: Idx> {
13841383
/// The tag directly stores the discriminant, but possibly with a smaller layout
13851384
/// (so converting the tag to the discriminant can require sign extension).
13861385
Direct,
@@ -1488,27 +1487,9 @@ impl Niche {
14881487
}
14891488
}
14901489

1491-
rustc_index::newtype_index! {
1492-
/// The *source-order* index of a variant in a type.
1493-
///
1494-
/// For enums, these are always `0..variant_count`, regardless of any
1495-
/// custom discriminants that may have been defined, and including any
1496-
/// variants that may end up uninhabited due to field types. (Some of the
1497-
/// variants may not be present in a monomorphized ABI [`Variants`], but
1498-
/// those skipped variants are always counted when determining the *index*.)
1499-
///
1500-
/// `struct`s, `tuples`, and `unions`s are considered to have a single variant
1501-
/// with variant index zero, aka [`FIRST_VARIANT`].
1502-
#[derive(HashStable_Generic)]
1503-
pub struct VariantIdx {
1504-
/// Equivalent to `VariantIdx(0)`.
1505-
const FIRST_VARIANT = 0;
1506-
}
1507-
}
1508-
15091490
#[derive(PartialEq, Eq, Hash, Clone)]
15101491
#[cfg_attr(feature = "nightly", derive(HashStable_Generic))]
1511-
pub struct LayoutS<FieldIdx: Idx> {
1492+
pub struct LayoutS<FieldIdx: Idx, VariantIdx: Idx> {
15121493
/// Says where the fields are located within the layout.
15131494
pub fields: FieldsShape<FieldIdx>,
15141495

@@ -1519,7 +1500,7 @@ pub struct LayoutS<FieldIdx: Idx> {
15191500
///
15201501
/// To access all fields of this layout, both `fields` and the fields of the active variant
15211502
/// must be taken into account.
1522-
pub variants: Variants<FieldIdx>,
1503+
pub variants: Variants<FieldIdx, VariantIdx>,
15231504

15241505
/// The `abi` defines how this data is passed between functions, and it defines
15251506
/// value restrictions via `valid_range`.
@@ -1548,13 +1529,13 @@ pub struct LayoutS<FieldIdx: Idx> {
15481529
pub unadjusted_abi_align: Align,
15491530
}
15501531

1551-
impl<FieldIdx: Idx> LayoutS<FieldIdx> {
1532+
impl<FieldIdx: Idx, VariantIdx: Idx> LayoutS<FieldIdx, VariantIdx> {
15521533
pub fn scalar<C: HasDataLayout>(cx: &C, scalar: Scalar) -> Self {
15531534
let largest_niche = Niche::from_scalar(cx, Size::ZERO, scalar);
15541535
let size = scalar.size(cx);
15551536
let align = scalar.align(cx);
15561537
LayoutS {
1557-
variants: Variants::Single { index: FIRST_VARIANT },
1538+
variants: Variants::Single { index: VariantIdx::new(0) },
15581539
fields: FieldsShape::Primitive,
15591540
abi: Abi::Scalar(scalar),
15601541
largest_niche,
@@ -1566,10 +1547,10 @@ impl<FieldIdx: Idx> LayoutS<FieldIdx> {
15661547
}
15671548
}
15681549

1569-
impl<FieldIdx: Idx> fmt::Debug for LayoutS<FieldIdx>
1550+
impl<FieldIdx: Idx, VariantIdx: Idx> fmt::Debug for LayoutS<FieldIdx, VariantIdx>
15701551
where
15711552
FieldsShape<FieldIdx>: fmt::Debug,
1572-
Variants<FieldIdx>: fmt::Debug,
1553+
Variants<FieldIdx, VariantIdx>: fmt::Debug,
15731554
{
15741555
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
15751556
// This is how `Layout` used to print before it become
@@ -1617,7 +1598,7 @@ pub struct PointeeInfo {
16171598
pub safe: Option<PointerKind>,
16181599
}
16191600

1620-
impl<FieldIdx: Idx> LayoutS<FieldIdx> {
1601+
impl<FieldIdx: Idx, VariantIdx: Idx> LayoutS<FieldIdx, VariantIdx> {
16211602
/// Returns `true` if the layout corresponds to an unsized type.
16221603
#[inline]
16231604
pub fn is_unsized(&self) -> bool {

‎compiler/rustc_target/src/abi/mod.rs‎

Lines changed: 21 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -45,9 +45,26 @@ rustc_index::newtype_index! {
4545
pub struct FieldIdx {}
4646
}
4747

48+
rustc_index::newtype_index! {
49+
/// The *source-order* index of a variant in a type.
50+
///
51+
/// For enums, these are always `0..variant_count`, regardless of any
52+
/// custom discriminants that may have been defined, and including any
53+
/// variants that may end up uninhabited due to field types. (Some of the
54+
/// variants may not be present in a monomorphized ABI [`Variants`], but
55+
/// those skipped variants are always counted when determining the *index*.)
56+
///
57+
/// `struct`s, `tuples`, and `unions`s are considered to have a single variant
58+
/// with variant index zero, aka [`FIRST_VARIANT`].
59+
#[derive(HashStable_Generic)]
60+
pub struct VariantIdx {
61+
/// Equivalent to `VariantIdx(0)`.
62+
const FIRST_VARIANT = 0;
63+
}
64+
}
4865
#[derive(Copy, Clone, PartialEq, Eq, Hash, HashStable_Generic)]
4966
#[rustc_pass_by_value]
50-
pub struct Layout<'a>(pub Interned<'a, LayoutS<FieldIdx>>);
67+
pub struct Layout<'a>(pub Interned<'a, LayoutS<FieldIdx, VariantIdx>>);
5168

5269
impl<'a> fmt::Debug for Layout<'a> {
5370
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -61,7 +78,7 @@ impl<'a> Layout<'a> {
6178
&self.0.0.fields
6279
}
6380

64-
pub fn variants(self) -> &'a Variants<FieldIdx> {
81+
pub fn variants(self) -> &'a Variants<FieldIdx, VariantIdx> {
6582
&self.0.0.variants
6683
}
6784

@@ -124,8 +141,8 @@ impl<'a, Ty: fmt::Display> fmt::Debug for TyAndLayout<'a, Ty> {
124141
}
125142

126143
impl<'a, Ty> Deref for TyAndLayout<'a, Ty> {
127-
type Target = &'a LayoutS<FieldIdx>;
128-
fn deref(&self) -> &&'a LayoutS<FieldIdx> {
144+
type Target = &'a LayoutS<FieldIdx, VariantIdx>;
145+
fn deref(&self) -> &&'a LayoutS<FieldIdx, VariantIdx> {
129146
&self.layout.0.0
130147
}
131148
}

0 commit comments

Comments
 (0)