1 // Copyright 2016 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
11 use session::{self, DataTypeKind};
12 use ty::{self, Ty, TyCtxt, TypeFoldable, ReprOptions};
14 use syntax::ast::{self, IntTy, UintTy};
16 use syntax_pos::DUMMY_SP;
24 use ich::StableHashingContext;
25 use rustc_data_structures::stable_hasher::{HashStable, StableHasher,
28 pub use rustc_target::abi::*;
30 pub trait IntegerExt {
31 fn to_ty<'a, 'tcx>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, signed: bool) -> Ty<'tcx>;
32 fn from_attr<C: HasDataLayout>(cx: C, ity: attr::IntType) -> Integer;
33 fn repr_discr<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
41 impl IntegerExt for Integer {
42 fn to_ty<'a, 'tcx>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, signed: bool) -> Ty<'tcx> {
43 match (*self, signed) {
44 (I8, false) => tcx.types.u8,
45 (I16, false) => tcx.types.u16,
46 (I32, false) => tcx.types.u32,
47 (I64, false) => tcx.types.u64,
48 (I128, false) => tcx.types.u128,
49 (I8, true) => tcx.types.i8,
50 (I16, true) => tcx.types.i16,
51 (I32, true) => tcx.types.i32,
52 (I64, true) => tcx.types.i64,
53 (I128, true) => tcx.types.i128,
57 /// Get the Integer type from an attr::IntType.
58 fn from_attr<C: HasDataLayout>(cx: C, ity: attr::IntType) -> Integer {
59 let dl = cx.data_layout();
62 attr::SignedInt(IntTy::I8) | attr::UnsignedInt(UintTy::U8) => I8,
63 attr::SignedInt(IntTy::I16) | attr::UnsignedInt(UintTy::U16) => I16,
64 attr::SignedInt(IntTy::I32) | attr::UnsignedInt(UintTy::U32) => I32,
65 attr::SignedInt(IntTy::I64) | attr::UnsignedInt(UintTy::U64) => I64,
66 attr::SignedInt(IntTy::I128) | attr::UnsignedInt(UintTy::U128) => I128,
67 attr::SignedInt(IntTy::Isize) | attr::UnsignedInt(UintTy::Usize) => {
68 dl.ptr_sized_integer()
73 /// Find the appropriate Integer type and signedness for the given
74 /// signed discriminant range and #[repr] attribute.
75 /// N.B.: u128 values above i128::MAX will be treated as signed, but
76 /// that shouldn't affect anything, other than maybe debuginfo.
77 fn repr_discr<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
83 // Theoretically, negative values could be larger in unsigned representation
84 // than the unsigned representation of the signed minimum. However, if there
85 // are any negative values, the only valid unsigned representation is u128
86 // which can fit all i128 values, so the result remains unaffected.
87 let unsigned_fit = Integer::fit_unsigned(cmp::max(min as u128, max as u128));
88 let signed_fit = cmp::max(Integer::fit_signed(min), Integer::fit_signed(max));
90 let mut min_from_extern = None;
93 if let Some(ity) = repr.int {
94 let discr = Integer::from_attr(tcx, ity);
95 let fit = if ity.is_signed() { signed_fit } else { unsigned_fit };
97 bug!("Integer::repr_discr: `#[repr]` hint too small for \
98 discriminant range of enum `{}", ty)
100 return (discr, ity.is_signed());
104 match &tcx.sess.target.target.arch[..] {
105 // WARNING: the ARM EABI has two variants; the one corresponding
106 // to `at_least == I32` appears to be used on Linux and NetBSD,
107 // but some systems may use the variant corresponding to no
108 // lower bound. However, we don't run on those yet...?
109 "arm" => min_from_extern = Some(I32),
110 _ => min_from_extern = Some(I32),
114 let at_least = min_from_extern.unwrap_or(min_default);
116 // If there are no negative values, we can use the unsigned fit.
118 (cmp::max(unsigned_fit, at_least), false)
120 (cmp::max(signed_fit, at_least), true)
125 pub trait PrimitiveExt {
126 fn to_ty<'a, 'tcx>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Ty<'tcx>;
129 impl PrimitiveExt for Primitive {
130 fn to_ty<'a, 'tcx>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Ty<'tcx> {
132 Int(i, signed) => i.to_ty(tcx, signed),
133 Float(FloatTy::F32) => tcx.types.f32,
134 Float(FloatTy::F64) => tcx.types.f64,
135 Pointer => tcx.mk_mut_ptr(tcx.mk_nil()),
140 /// The first half of a fat pointer.
142 /// - For a trait object, this is the address of the box.
143 /// - For a slice, this is the base address.
144 pub const FAT_PTR_ADDR: usize = 0;
146 /// The second half of a fat pointer.
148 /// - For a trait object, this is the address of the vtable.
149 /// - For a slice, this is the length.
150 pub const FAT_PTR_EXTRA: usize = 1;
152 #[derive(Copy, Clone, Debug, RustcEncodable, RustcDecodable)]
153 pub enum LayoutError<'tcx> {
155 SizeOverflow(Ty<'tcx>)
158 impl<'tcx> fmt::Display for LayoutError<'tcx> {
159 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
161 LayoutError::Unknown(ty) => {
162 write!(f, "the type `{:?}` has an unknown layout", ty)
164 LayoutError::SizeOverflow(ty) => {
165 write!(f, "the type `{:?}` is too big for the current architecture", ty)
171 fn layout_raw<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
172 query: ty::ParamEnvAnd<'tcx, Ty<'tcx>>)
173 -> Result<&'tcx LayoutDetails, LayoutError<'tcx>>
175 ty::tls::with_related_context(tcx, move |icx| {
176 let rec_limit = *tcx.sess.recursion_limit.get();
177 let (param_env, ty) = query.into_parts();
179 if icx.layout_depth > rec_limit {
181 &format!("overflow representing the type `{}`", ty));
184 // Update the ImplicitCtxt to increase the layout_depth
185 let icx = ty::tls::ImplicitCtxt {
186 layout_depth: icx.layout_depth + 1,
190 ty::tls::enter_context(&icx, |_| {
191 let cx = LayoutCx { tcx, param_env };
192 cx.layout_raw_uncached(ty)
197 pub fn provide(providers: &mut ty::query::Providers) {
198 *providers = ty::query::Providers {
204 #[derive(Copy, Clone)]
205 pub struct LayoutCx<'tcx, C> {
207 pub param_env: ty::ParamEnv<'tcx>
210 impl<'a, 'tcx> LayoutCx<'tcx, TyCtxt<'a, 'tcx, 'tcx>> {
211 fn layout_raw_uncached(self, ty: Ty<'tcx>)
212 -> Result<&'tcx LayoutDetails, LayoutError<'tcx>> {
214 let param_env = self.param_env;
215 let dl = self.data_layout();
216 let scalar_unit = |value: Primitive| {
217 let bits = value.size(dl).bits();
218 assert!(bits <= 128);
221 valid_range: 0..=(!0 >> (128 - bits))
224 let scalar = |value: Primitive| {
225 tcx.intern_layout(LayoutDetails::scalar(self, scalar_unit(value)))
227 let scalar_pair = |a: Scalar, b: Scalar| {
228 let align = a.value.align(dl).max(b.value.align(dl)).max(dl.aggregate_align);
229 let b_offset = a.value.size(dl).abi_align(b.value.align(dl));
230 let size = (b_offset + b.value.size(dl)).abi_align(align);
232 variants: Variants::Single { index: 0 },
233 fields: FieldPlacement::Arbitrary {
234 offsets: vec![Size::ZERO, b_offset],
235 memory_index: vec![0, 1]
237 abi: Abi::ScalarPair(a, b),
243 #[derive(Copy, Clone, Debug)]
245 /// A tuple, closure, or univariant which cannot be coerced to unsized.
247 /// A univariant, the last field of which may be coerced to unsized.
249 /// A univariant, but with a prefix of an arbitrary size & alignment (e.g. enum tag).
250 Prefixed(Size, Align),
252 let univariant_uninterned = |fields: &[TyLayout], repr: &ReprOptions, kind| {
253 let packed = repr.packed();
254 if packed && repr.align > 0 {
255 bug!("struct cannot be packed and aligned");
259 let pack = repr.pack as u64;
260 Align::from_bytes(pack, pack).unwrap()
263 let mut align = if packed {
269 let mut sized = true;
270 let mut offsets = vec![Size::ZERO; fields.len()];
271 let mut inverse_memory_index: Vec<u32> = (0..fields.len() as u32).collect();
273 let mut optimize = !repr.inhibit_struct_field_reordering_opt();
274 if let StructKind::Prefixed(_, align) = kind {
275 optimize &= align.abi() == 1;
279 let end = if let StructKind::MaybeUnsized = kind {
284 let optimizing = &mut inverse_memory_index[..end];
285 let field_align = |f: &TyLayout| {
286 if packed { f.align.min(pack).abi() } else { f.align.abi() }
289 StructKind::AlwaysSized |
290 StructKind::MaybeUnsized => {
291 optimizing.sort_by_key(|&x| {
292 // Place ZSTs first to avoid "interesting offsets",
293 // especially with only one or two non-ZST fields.
294 let f = &fields[x as usize];
295 (!f.is_zst(), cmp::Reverse(field_align(f)))
298 StructKind::Prefixed(..) => {
299 optimizing.sort_by_key(|&x| field_align(&fields[x as usize]));
304 // inverse_memory_index holds field indices by increasing memory offset.
305 // That is, if field 5 has offset 0, the first element of inverse_memory_index is 5.
306 // We now write field offsets to the corresponding offset slot;
307 // field 5 with offset 0 puts 0 in offsets[5].
308 // At the bottom of this function, we use inverse_memory_index to produce memory_index.
310 let mut offset = Size::ZERO;
312 if let StructKind::Prefixed(prefix_size, prefix_align) = kind {
314 let prefix_align = prefix_align.min(pack);
315 align = align.max(prefix_align);
317 align = align.max(prefix_align);
319 offset = prefix_size.abi_align(prefix_align);
322 for &i in &inverse_memory_index {
323 let field = fields[i as usize];
325 bug!("univariant: field #{} of `{}` comes after unsized field",
329 if field.is_unsized() {
333 // Invariant: offset < dl.obj_size_bound() <= 1<<61
335 let field_pack = field.align.min(pack);
336 offset = offset.abi_align(field_pack);
337 align = align.max(field_pack);
340 offset = offset.abi_align(field.align);
341 align = align.max(field.align);
344 debug!("univariant offset: {:?} field: {:#?}", offset, field);
345 offsets[i as usize] = offset;
347 offset = offset.checked_add(field.size, dl)
348 .ok_or(LayoutError::SizeOverflow(ty))?;
352 let repr_align = repr.align as u64;
353 align = align.max(Align::from_bytes(repr_align, repr_align).unwrap());
354 debug!("univariant repr_align: {:?}", repr_align);
357 debug!("univariant min_size: {:?}", offset);
358 let min_size = offset;
360 // As stated above, inverse_memory_index holds field indices by increasing offset.
361 // This makes it an already-sorted view of the offsets vec.
362 // To invert it, consider:
363 // If field 5 has offset 0, offsets[0] is 5, and memory_index[5] should be 0.
364 // Field 5 would be the first element, so memory_index is i:
365 // Note: if we didn't optimize, it's already right.
367 let mut memory_index;
369 memory_index = vec![0; inverse_memory_index.len()];
371 for i in 0..inverse_memory_index.len() {
372 memory_index[inverse_memory_index[i] as usize] = i as u32;
375 memory_index = inverse_memory_index;
378 let size = min_size.abi_align(align);
379 let mut abi = Abi::Aggregate { sized };
381 // Unpack newtype ABIs and find scalar pairs.
382 if sized && size.bytes() > 0 {
383 // All other fields must be ZSTs, and we need them to all start at 0.
384 let mut zst_offsets =
385 offsets.iter().enumerate().filter(|&(i, _)| fields[i].is_zst());
386 if zst_offsets.all(|(_, o)| o.bytes() == 0) {
387 let mut non_zst_fields =
388 fields.iter().enumerate().filter(|&(_, f)| !f.is_zst());
390 match (non_zst_fields.next(), non_zst_fields.next(), non_zst_fields.next()) {
391 // We have exactly one non-ZST field.
392 (Some((i, field)), None, None) => {
393 // Field fills the struct and it has a scalar or scalar pair ABI.
394 if offsets[i].bytes() == 0 &&
395 align.abi() == field.align.abi() &&
398 // For plain scalars, or vectors of them, we can't unpack
399 // newtypes for `#[repr(C)]`, as that affects C ABIs.
400 Abi::Scalar(_) | Abi::Vector { .. } if optimize => {
401 abi = field.abi.clone();
403 // But scalar pairs are Rust-specific and get
404 // treated as aggregates by C ABIs anyway.
405 Abi::ScalarPair(..) => {
406 abi = field.abi.clone();
413 // Two non-ZST fields, and they're both scalars.
414 (Some((i, &TyLayout {
415 details: &LayoutDetails { abi: Abi::Scalar(ref a), .. }, ..
416 })), Some((j, &TyLayout {
417 details: &LayoutDetails { abi: Abi::Scalar(ref b), .. }, ..
419 // Order by the memory placement, not source order.
420 let ((i, a), (j, b)) = if offsets[i] < offsets[j] {
425 let pair = scalar_pair(a.clone(), b.clone());
426 let pair_offsets = match pair.fields {
427 FieldPlacement::Arbitrary {
431 assert_eq!(memory_index, &[0, 1]);
436 if offsets[i] == pair_offsets[0] &&
437 offsets[j] == pair_offsets[1] &&
438 align == pair.align &&
440 // We can use `ScalarPair` only when it matches our
441 // already computed layout (including `#[repr(C)]`).
451 if sized && fields.iter().any(|f| f.abi == Abi::Uninhabited) {
452 abi = Abi::Uninhabited;
456 variants: Variants::Single { index: 0 },
457 fields: FieldPlacement::Arbitrary {
466 let univariant = |fields: &[TyLayout], repr: &ReprOptions, kind| {
467 Ok(tcx.intern_layout(univariant_uninterned(fields, repr, kind)?))
469 assert!(!ty.has_infer_types());
474 tcx.intern_layout(LayoutDetails::scalar(self, Scalar {
475 value: Int(I8, false),
480 tcx.intern_layout(LayoutDetails::scalar(self, Scalar {
481 value: Int(I32, false),
482 valid_range: 0..=0x10FFFF
486 scalar(Int(Integer::from_attr(dl, attr::SignedInt(ity)), true))
489 scalar(Int(Integer::from_attr(dl, attr::UnsignedInt(ity)), false))
491 ty::TyFloat(fty) => scalar(Float(fty)),
493 let mut ptr = scalar_unit(Pointer);
494 ptr.valid_range = 1..=*ptr.valid_range.end();
495 tcx.intern_layout(LayoutDetails::scalar(self, ptr))
500 tcx.intern_layout(LayoutDetails {
501 variants: Variants::Single { index: 0 },
502 fields: FieldPlacement::Union(0),
503 abi: Abi::Uninhabited,
509 // Potentially-fat pointers.
510 ty::TyRef(_, pointee, _) |
511 ty::TyRawPtr(ty::TypeAndMut { ty: pointee, .. }) => {
512 let mut data_ptr = scalar_unit(Pointer);
513 if !ty.is_unsafe_ptr() {
514 data_ptr.valid_range = 1..=*data_ptr.valid_range.end();
517 let pointee = tcx.normalize_erasing_regions(param_env, pointee);
518 if pointee.is_sized(tcx.at(DUMMY_SP), param_env) {
519 return Ok(tcx.intern_layout(LayoutDetails::scalar(self, data_ptr)));
522 let unsized_part = tcx.struct_tail(pointee);
523 let metadata = match unsized_part.sty {
524 ty::TyForeign(..) => {
525 return Ok(tcx.intern_layout(LayoutDetails::scalar(self, data_ptr)));
527 ty::TySlice(_) | ty::TyStr => {
528 scalar_unit(Int(dl.ptr_sized_integer(), false))
530 ty::TyDynamic(..) => {
531 let mut vtable = scalar_unit(Pointer);
532 vtable.valid_range = 1..=*vtable.valid_range.end();
535 _ => return Err(LayoutError::Unknown(unsized_part))
538 // Effectively a (ptr, meta) tuple.
539 tcx.intern_layout(scalar_pair(data_ptr, metadata))
542 // Arrays and slices.
543 ty::TyArray(element, mut count) => {
544 if count.has_projections() {
545 count = tcx.normalize_erasing_regions(param_env, count);
546 if count.has_projections() {
547 return Err(LayoutError::Unknown(ty));
551 let element = self.layout_of(element)?;
552 let count = count.unwrap_usize(tcx);
553 let size = element.size.checked_mul(count, dl)
554 .ok_or(LayoutError::SizeOverflow(ty))?;
556 tcx.intern_layout(LayoutDetails {
557 variants: Variants::Single { index: 0 },
558 fields: FieldPlacement::Array {
559 stride: element.size,
562 abi: Abi::Aggregate { sized: true },
563 align: element.align,
567 ty::TySlice(element) => {
568 let element = self.layout_of(element)?;
569 tcx.intern_layout(LayoutDetails {
570 variants: Variants::Single { index: 0 },
571 fields: FieldPlacement::Array {
572 stride: element.size,
575 abi: Abi::Aggregate { sized: false },
576 align: element.align,
581 tcx.intern_layout(LayoutDetails {
582 variants: Variants::Single { index: 0 },
583 fields: FieldPlacement::Array {
584 stride: Size::from_bytes(1),
587 abi: Abi::Aggregate { sized: false },
595 univariant(&[], &ReprOptions::default(), StructKind::AlwaysSized)?
597 ty::TyDynamic(..) | ty::TyForeign(..) => {
598 let mut unit = univariant_uninterned(&[], &ReprOptions::default(),
599 StructKind::AlwaysSized)?;
601 Abi::Aggregate { ref mut sized } => *sized = false,
604 tcx.intern_layout(unit)
607 // Tuples, generators and closures.
608 ty::TyGenerator(def_id, ref substs, _) => {
609 let tys = substs.field_tys(def_id, tcx);
610 univariant(&tys.map(|ty| self.layout_of(ty)).collect::<Result<Vec<_>, _>>()?,
611 &ReprOptions::default(),
612 StructKind::AlwaysSized)?
615 ty::TyClosure(def_id, ref substs) => {
616 let tys = substs.upvar_tys(def_id, tcx);
617 univariant(&tys.map(|ty| self.layout_of(ty)).collect::<Result<Vec<_>, _>>()?,
618 &ReprOptions::default(),
619 StructKind::AlwaysSized)?
622 ty::TyTuple(tys) => {
623 let kind = if tys.len() == 0 {
624 StructKind::AlwaysSized
626 StructKind::MaybeUnsized
629 univariant(&tys.iter().map(|ty| self.layout_of(ty)).collect::<Result<Vec<_>, _>>()?,
630 &ReprOptions::default(), kind)?
633 // SIMD vector types.
634 ty::TyAdt(def, ..) if def.repr.simd() => {
635 let element = self.layout_of(ty.simd_type(tcx))?;
636 let count = ty.simd_size(tcx) as u64;
638 let scalar = match element.abi {
639 Abi::Scalar(ref scalar) => scalar.clone(),
641 tcx.sess.fatal(&format!("monomorphising SIMD type `{}` with \
642 a non-machine element type `{}`",
646 let size = element.size.checked_mul(count, dl)
647 .ok_or(LayoutError::SizeOverflow(ty))?;
648 let align = dl.vector_align(size);
649 let size = size.abi_align(align);
651 tcx.intern_layout(LayoutDetails {
652 variants: Variants::Single { index: 0 },
653 fields: FieldPlacement::Array {
654 stride: element.size,
667 ty::TyAdt(def, substs) => {
668 // Cache the field layouts.
669 let variants = def.variants.iter().map(|v| {
670 v.fields.iter().map(|field| {
671 self.layout_of(field.ty(tcx, substs))
672 }).collect::<Result<Vec<_>, _>>()
673 }).collect::<Result<Vec<_>, _>>()?;
676 let packed = def.repr.packed();
677 if packed && def.repr.align > 0 {
678 bug!("Union cannot be packed and aligned");
682 let pack = def.repr.pack as u64;
683 Align::from_bytes(pack, pack).unwrap()
686 let mut align = if packed {
692 if def.repr.align > 0 {
693 let repr_align = def.repr.align as u64;
695 Align::from_bytes(repr_align, repr_align).unwrap());
698 let mut size = Size::ZERO;
699 for field in &variants[0] {
700 assert!(!field.is_unsized());
703 let field_pack = field.align.min(pack);
704 align = align.max(field_pack);
706 align = align.max(field.align);
708 size = cmp::max(size, field.size);
711 return Ok(tcx.intern_layout(LayoutDetails {
712 variants: Variants::Single { index: 0 },
713 fields: FieldPlacement::Union(variants[0].len()),
714 abi: Abi::Aggregate { sized: true },
716 size: size.abi_align(align)
720 // A variant is absent if it's uninhabited and only has ZST fields.
721 // Present uninhabited variants only require space for their fields,
722 // but *not* an encoding of the discriminant (e.g. a tag value).
723 // See issue #49298 for more details on the need to leave space
724 // for non-ZST uninhabited data (mostly partial initialization).
725 let absent = |fields: &[TyLayout]| {
726 let uninhabited = fields.iter().any(|f| f.abi == Abi::Uninhabited);
727 let is_zst = fields.iter().all(|f| f.is_zst());
728 uninhabited && is_zst
730 let (present_first, present_second) = {
731 let mut present_variants = (0..variants.len()).filter(|&v| {
732 !absent(&variants[v])
734 (present_variants.next(), present_variants.next())
736 if present_first.is_none() {
737 // Uninhabited because it has no variants, or only absent ones.
738 return tcx.layout_raw(param_env.and(tcx.types.never));
741 let is_struct = !def.is_enum() ||
742 // Only one variant is present.
743 (present_second.is_none() &&
744 // Representation optimizations are allowed.
745 !def.repr.inhibit_enum_layout_opt());
747 // Struct, or univariant enum equivalent to a struct.
748 // (Typechecking will reject discriminant-sizing attrs.)
750 let v = present_first.unwrap();
751 let kind = if def.is_enum() || variants[v].len() == 0 {
752 StructKind::AlwaysSized
754 let param_env = tcx.param_env(def.did);
755 let last_field = def.variants[v].fields.last().unwrap();
756 let always_sized = tcx.type_of(last_field.did)
757 .is_sized(tcx.at(DUMMY_SP), param_env);
758 if !always_sized { StructKind::MaybeUnsized }
759 else { StructKind::AlwaysSized }
762 let mut st = univariant_uninterned(&variants[v], &def.repr, kind)?;
763 st.variants = Variants::Single { index: v };
764 // Exclude 0 from the range of a newtype ABI NonZero<T>.
765 if Some(def.did) == self.tcx.lang_items().non_zero() {
767 Abi::Scalar(ref mut scalar) |
768 Abi::ScalarPair(ref mut scalar, _) => {
769 if *scalar.valid_range.start() == 0 {
770 scalar.valid_range = 1..=*scalar.valid_range.end();
776 return Ok(tcx.intern_layout(st));
779 // The current code for niche-filling relies on variant indices
780 // instead of actual discriminants, so dataful enums with
781 // explicit discriminants (RFC #2363) would misbehave.
782 let no_explicit_discriminants = def.variants.iter().enumerate()
783 .all(|(i, v)| v.discr == ty::VariantDiscr::Relative(i));
785 // Niche-filling enum optimization.
786 if !def.repr.inhibit_enum_layout_opt() && no_explicit_discriminants {
787 let mut dataful_variant = None;
788 let mut niche_variants = usize::max_value()..=0;
790 // Find one non-ZST variant.
791 'variants: for (v, fields) in variants.iter().enumerate() {
797 if dataful_variant.is_none() {
798 dataful_variant = Some(v);
801 dataful_variant = None;
806 niche_variants = *niche_variants.start().min(&v)..=v;
809 if niche_variants.start() > niche_variants.end() {
810 dataful_variant = None;
813 if let Some(i) = dataful_variant {
814 let count = (niche_variants.end() - niche_variants.start() + 1) as u128;
815 for (field_index, &field) in variants[i].iter().enumerate() {
816 let niche = match self.find_niche(field)? {
817 Some(niche) => niche,
820 let (niche_start, niche_scalar) = match niche.reserve(self, count) {
825 let mut align = dl.aggregate_align;
826 let st = variants.iter().enumerate().map(|(j, v)| {
827 let mut st = univariant_uninterned(v,
828 &def.repr, StructKind::AlwaysSized)?;
829 st.variants = Variants::Single { index: j };
831 align = align.max(st.align);
834 }).collect::<Result<Vec<_>, _>>()?;
836 let offset = st[i].fields.offset(field_index) + niche.offset;
837 let size = st[i].size;
839 let mut abi = match st[i].abi {
840 Abi::Scalar(_) => Abi::Scalar(niche_scalar.clone()),
841 Abi::ScalarPair(ref first, ref second) => {
842 // We need to use scalar_unit to reset the
843 // valid range to the maximal one for that
844 // primitive, because only the niche is
845 // guaranteed to be initialised, not the
847 if offset.bytes() == 0 {
849 niche_scalar.clone(),
850 scalar_unit(second.value),
854 scalar_unit(first.value),
855 niche_scalar.clone(),
859 _ => Abi::Aggregate { sized: true },
862 if st.iter().all(|v| v.abi == Abi::Uninhabited) {
863 abi = Abi::Uninhabited;
866 return Ok(tcx.intern_layout(LayoutDetails {
867 variants: Variants::NicheFilling {
874 fields: FieldPlacement::Arbitrary {
875 offsets: vec![offset],
876 memory_index: vec![0]
886 let (mut min, mut max) = (i128::max_value(), i128::min_value());
887 let discr_type = def.repr.discr_type();
888 let bits = Integer::from_attr(tcx, discr_type).size().bits();
889 for (i, discr) in def.discriminants(tcx).enumerate() {
890 if variants[i].iter().any(|f| f.abi == Abi::Uninhabited) {
893 let mut x = discr.val as i128;
894 if discr_type.is_signed() {
895 // sign extend the raw representation to be an i128
896 x = (x << (128 - bits)) >> (128 - bits);
898 if x < min { min = x; }
899 if x > max { max = x; }
901 // We might have no inhabited variants, so pretend there's at least one.
902 if (min, max) == (i128::max_value(), i128::min_value()) {
906 assert!(min <= max, "discriminant range is {}...{}", min, max);
907 let (min_ity, signed) = Integer::repr_discr(tcx, ty, &def.repr, min, max);
909 let mut align = dl.aggregate_align;
910 let mut size = Size::ZERO;
912 // We're interested in the smallest alignment, so start large.
913 let mut start_align = Align::from_bytes(256, 256).unwrap();
914 assert_eq!(Integer::for_abi_align(dl, start_align), None);
916 // repr(C) on an enum tells us to make a (tag, union) layout,
917 // so we need to grow the prefix alignment to be at least
918 // the alignment of the union. (This value is used both for
919 // determining the alignment of the overall enum, and the
920 // determining the alignment of the payload after the tag.)
921 let mut prefix_align = min_ity.align(dl);
923 for fields in &variants {
924 for field in fields {
925 prefix_align = prefix_align.max(field.align);
930 // Create the set of structs that represent each variant.
931 let mut layout_variants = variants.iter().enumerate().map(|(i, field_layouts)| {
932 let mut st = univariant_uninterned(&field_layouts,
933 &def.repr, StructKind::Prefixed(min_ity.size(), prefix_align))?;
934 st.variants = Variants::Single { index: i };
935 // Find the first field we can't move later
936 // to make room for a larger discriminant.
937 for field in st.fields.index_by_increasing_offset().map(|j| field_layouts[j]) {
938 if !field.is_zst() || field.align.abi() != 1 {
939 start_align = start_align.min(field.align);
943 size = cmp::max(size, st.size);
944 align = align.max(st.align);
946 }).collect::<Result<Vec<_>, _>>()?;
948 // Align the maximum variant size to the largest alignment.
949 size = size.abi_align(align);
951 if size.bytes() >= dl.obj_size_bound() {
952 return Err(LayoutError::SizeOverflow(ty));
955 let typeck_ity = Integer::from_attr(dl, def.repr.discr_type());
956 if typeck_ity < min_ity {
957 // It is a bug if Layout decided on a greater discriminant size than typeck for
958 // some reason at this point (based on values discriminant can take on). Mostly
959 // because this discriminant will be loaded, and then stored into variable of
960 // type calculated by typeck. Consider such case (a bug): typeck decided on
961 // byte-sized discriminant, but layout thinks we need a 16-bit to store all
962 // discriminant values. That would be a bug, because then, in codegen, in order
963 // to store this 16-bit discriminant into 8-bit sized temporary some of the
964 // space necessary to represent would have to be discarded (or layout is wrong
965 // on thinking it needs 16 bits)
966 bug!("layout decided on a larger discriminant type ({:?}) than typeck ({:?})",
967 min_ity, typeck_ity);
968 // However, it is fine to make discr type however large (as an optimisation)
969 // after this point – we’ll just truncate the value we load in codegen.
972 // Check to see if we should use a different type for the
973 // discriminant. We can safely use a type with the same size
974 // as the alignment of the first field of each variant.
975 // We increase the size of the discriminant to avoid LLVM copying
976 // padding when it doesn't need to. This normally causes unaligned
977 // load/stores and excessive memcpy/memset operations. By using a
978 // bigger integer size, LLVM can be sure about its contents and
979 // won't be so conservative.
981 // Use the initial field alignment
982 let mut ity = if def.repr.c() || def.repr.int.is_some() {
985 Integer::for_abi_align(dl, start_align).unwrap_or(min_ity)
988 // If the alignment is not larger than the chosen discriminant size,
989 // don't use the alignment as the final size.
993 // Patch up the variants' first few fields.
994 let old_ity_size = min_ity.size();
995 let new_ity_size = ity.size();
996 for variant in &mut layout_variants {
997 match variant.fields {
998 FieldPlacement::Arbitrary { ref mut offsets, .. } => {
1000 if *i <= old_ity_size {
1001 assert_eq!(*i, old_ity_size);
1005 // We might be making the struct larger.
1006 if variant.size <= old_ity_size {
1007 variant.size = new_ity_size;
1015 let tag_mask = !0u128 >> (128 - ity.size().bits());
1017 value: Int(ity, signed),
1018 valid_range: (min as u128 & tag_mask)..=(max as u128 & tag_mask),
1020 let mut abi = Abi::Aggregate { sized: true };
1021 if tag.value.size(dl) == size {
1022 abi = Abi::Scalar(tag.clone());
1023 } else if !tag.is_bool() {
1024 // HACK(nox): Blindly using ScalarPair for all tagged enums
1025 // where applicable leads to Option<u8> being handled as {i1, i8},
1026 // which later confuses SROA and some loop optimisations,
1027 // ultimately leading to the repeat-trusted-len test
1028 // failing. We make the trade-off of using ScalarPair only
1029 // for types where the tag isn't a boolean.
1030 let mut common_prim = None;
1031 for (field_layouts, layout_variant) in variants.iter().zip(&layout_variants) {
1032 let offsets = match layout_variant.fields {
1033 FieldPlacement::Arbitrary { ref offsets, .. } => offsets,
1036 let mut fields = field_layouts
1039 .filter(|p| !p.0.is_zst());
1040 let (field, offset) = match (fields.next(), fields.next()) {
1041 (None, None) => continue,
1042 (Some(pair), None) => pair,
1048 let prim = match field.details.abi {
1049 Abi::Scalar(ref scalar) => scalar.value,
1055 if let Some(pair) = common_prim {
1056 // This is pretty conservative. We could go fancier
1057 // by conflating things like i32 and u32, or even
1058 // realising that (u8, u8) could just cohabit with
1060 if pair != (prim, offset) {
1065 common_prim = Some((prim, offset));
1068 if let Some((prim, offset)) = common_prim {
1069 let pair = scalar_pair(tag.clone(), scalar_unit(prim));
1070 let pair_offsets = match pair.fields {
1071 FieldPlacement::Arbitrary {
1075 assert_eq!(memory_index, &[0, 1]);
1080 if pair_offsets[0] == Size::ZERO &&
1081 pair_offsets[1] == *offset &&
1082 align == pair.align &&
1084 // We can use `ScalarPair` only when it matches our
1085 // already computed layout (including `#[repr(C)]`).
1091 if layout_variants.iter().all(|v| v.abi == Abi::Uninhabited) {
1092 abi = Abi::Uninhabited;
1095 tcx.intern_layout(LayoutDetails {
1096 variants: Variants::Tagged {
1098 variants: layout_variants,
1100 fields: FieldPlacement::Arbitrary {
1101 offsets: vec![Size::ZERO],
1102 memory_index: vec![0]
1110 // Types with no meaningful known layout.
1111 ty::TyProjection(_) | ty::TyAnon(..) => {
1112 let normalized = tcx.normalize_erasing_regions(param_env, ty);
1113 if ty == normalized {
1114 return Err(LayoutError::Unknown(ty));
1116 tcx.layout_raw(param_env.and(normalized))?
1119 return Err(LayoutError::Unknown(ty));
1121 ty::TyGeneratorWitness(..) | ty::TyInfer(_) | ty::TyError => {
1122 bug!("LayoutDetails::compute: unexpected type `{}`", ty)
1127 /// This is invoked by the `layout_raw` query to record the final
1128 /// layout of each type.
1130 fn record_layout_for_printing(self, layout: TyLayout<'tcx>) {
1131 // If we are running with `-Zprint-type-sizes`, record layouts for
1132 // dumping later. Ignore layouts that are done with non-empty
1133 // environments or non-monomorphic layouts, as the user only wants
1134 // to see the stuff resulting from the final codegen session.
1136 !self.tcx.sess.opts.debugging_opts.print_type_sizes ||
1137 layout.ty.has_param_types() ||
1138 layout.ty.has_self_ty() ||
1139 !self.param_env.caller_bounds.is_empty()
1144 self.record_layout_for_printing_outlined(layout)
1147 fn record_layout_for_printing_outlined(self, layout: TyLayout<'tcx>) {
1148 // (delay format until we actually need it)
1149 let record = |kind, packed, opt_discr_size, variants| {
1150 let type_desc = format!("{:?}", layout.ty);
1151 self.tcx.sess.code_stats.borrow_mut().record_type_size(kind,
1160 let adt_def = match layout.ty.sty {
1161 ty::TyAdt(ref adt_def, _) => {
1162 debug!("print-type-size t: `{:?}` process adt", layout.ty);
1166 ty::TyClosure(..) => {
1167 debug!("print-type-size t: `{:?}` record closure", layout.ty);
1168 record(DataTypeKind::Closure, false, None, vec![]);
1173 debug!("print-type-size t: `{:?}` skip non-nominal", layout.ty);
1178 let adt_kind = adt_def.adt_kind();
1179 let adt_packed = adt_def.repr.packed();
1181 let build_variant_info = |n: Option<ast::Name>,
1183 layout: TyLayout<'tcx>| {
1184 let mut min_size = Size::ZERO;
1185 let field_info: Vec<_> = flds.iter().enumerate().map(|(i, &name)| {
1186 match layout.field(self, i) {
1188 bug!("no layout found for field {}: `{:?}`", name, err);
1190 Ok(field_layout) => {
1191 let offset = layout.fields.offset(i);
1192 let field_end = offset + field_layout.size;
1193 if min_size < field_end {
1194 min_size = field_end;
1196 session::FieldInfo {
1197 name: name.to_string(),
1198 offset: offset.bytes(),
1199 size: field_layout.size.bytes(),
1200 align: field_layout.align.abi(),
1206 session::VariantInfo {
1207 name: n.map(|n|n.to_string()),
1208 kind: if layout.is_unsized() {
1209 session::SizeKind::Min
1211 session::SizeKind::Exact
1213 align: layout.align.abi(),
1214 size: if min_size.bytes() == 0 {
1223 match layout.variants {
1224 Variants::Single { index } => {
1225 debug!("print-type-size `{:#?}` variant {}",
1226 layout, adt_def.variants[index].name);
1227 if !adt_def.variants.is_empty() {
1228 let variant_def = &adt_def.variants[index];
1229 let fields: Vec<_> =
1230 variant_def.fields.iter().map(|f| f.ident.name).collect();
1231 record(adt_kind.into(),
1234 vec![build_variant_info(Some(variant_def.name),
1238 // (This case arises for *empty* enums; so give it
1240 record(adt_kind.into(), adt_packed, None, vec![]);
1244 Variants::NicheFilling { .. } |
1245 Variants::Tagged { .. } => {
1246 debug!("print-type-size `{:#?}` adt general variants def {}",
1247 layout.ty, adt_def.variants.len());
1248 let variant_infos: Vec<_> =
1249 adt_def.variants.iter().enumerate().map(|(i, variant_def)| {
1250 let fields: Vec<_> =
1251 variant_def.fields.iter().map(|f| f.ident.name).collect();
1252 build_variant_info(Some(variant_def.name),
1254 layout.for_variant(self, i))
1257 record(adt_kind.into(), adt_packed, match layout.variants {
1258 Variants::Tagged { ref tag, .. } => Some(tag.value.size(self)),
1266 /// Type size "skeleton", i.e. the only information determining a type's size.
1267 /// While this is conservative, (aside from constant sizes, only pointers,
1268 /// newtypes thereof and null pointer optimized enums are allowed), it is
1269 /// enough to statically check common usecases of transmute.
1270 #[derive(Copy, Clone, Debug)]
1271 pub enum SizeSkeleton<'tcx> {
1272 /// Any statically computable Layout.
1275 /// A potentially-fat pointer.
1277 /// If true, this pointer is never null.
1279 /// The type which determines the unsized metadata, if any,
1280 /// of this pointer. Either a type parameter or a projection
1281 /// depending on one, with regions erased.
1286 impl<'a, 'tcx> SizeSkeleton<'tcx> {
1287 pub fn compute(ty: Ty<'tcx>,
1288 tcx: TyCtxt<'a, 'tcx, 'tcx>,
1289 param_env: ty::ParamEnv<'tcx>)
1290 -> Result<SizeSkeleton<'tcx>, LayoutError<'tcx>> {
1291 assert!(!ty.has_infer_types());
1293 // First try computing a static layout.
1294 let err = match tcx.layout_of(param_env.and(ty)) {
1296 return Ok(SizeSkeleton::Known(layout.size));
1302 ty::TyRef(_, pointee, _) |
1303 ty::TyRawPtr(ty::TypeAndMut { ty: pointee, .. }) => {
1304 let non_zero = !ty.is_unsafe_ptr();
1305 let tail = tcx.struct_tail(pointee);
1307 ty::TyParam(_) | ty::TyProjection(_) => {
1308 assert!(tail.has_param_types() || tail.has_self_ty());
1309 Ok(SizeSkeleton::Pointer {
1311 tail: tcx.erase_regions(&tail)
1315 bug!("SizeSkeleton::compute({}): layout errored ({}), yet \
1316 tail `{}` is not a type parameter or a projection",
1322 ty::TyAdt(def, substs) => {
1323 // Only newtypes and enums w/ nullable pointer optimization.
1324 if def.is_union() || def.variants.is_empty() || def.variants.len() > 2 {
1328 // Get a zero-sized variant or a pointer newtype.
1329 let zero_or_ptr_variant = |i: usize| {
1330 let fields = def.variants[i].fields.iter().map(|field| {
1331 SizeSkeleton::compute(field.ty(tcx, substs), tcx, param_env)
1334 for field in fields {
1337 SizeSkeleton::Known(size) => {
1338 if size.bytes() > 0 {
1342 SizeSkeleton::Pointer {..} => {
1353 let v0 = zero_or_ptr_variant(0)?;
1355 if def.variants.len() == 1 {
1356 if let Some(SizeSkeleton::Pointer { non_zero, tail }) = v0 {
1357 return Ok(SizeSkeleton::Pointer {
1358 non_zero: non_zero ||
1359 Some(def.did) == tcx.lang_items().non_zero(),
1367 let v1 = zero_or_ptr_variant(1)?;
1368 // Nullable pointer enum optimization.
1370 (Some(SizeSkeleton::Pointer { non_zero: true, tail }), None) |
1371 (None, Some(SizeSkeleton::Pointer { non_zero: true, tail })) => {
1372 Ok(SizeSkeleton::Pointer {
1381 ty::TyProjection(_) | ty::TyAnon(..) => {
1382 let normalized = tcx.normalize_erasing_regions(param_env, ty);
1383 if ty == normalized {
1386 SizeSkeleton::compute(normalized, tcx, param_env)
1394 pub fn same_size(self, other: SizeSkeleton) -> bool {
1395 match (self, other) {
1396 (SizeSkeleton::Known(a), SizeSkeleton::Known(b)) => a == b,
1397 (SizeSkeleton::Pointer { tail: a, .. },
1398 SizeSkeleton::Pointer { tail: b, .. }) => a == b,
1404 pub trait HasTyCtxt<'tcx>: HasDataLayout {
1405 fn tcx<'a>(&'a self) -> TyCtxt<'a, 'tcx, 'tcx>;
1408 impl<'a, 'gcx, 'tcx> HasDataLayout for TyCtxt<'a, 'gcx, 'tcx> {
1409 fn data_layout(&self) -> &TargetDataLayout {
1414 impl<'a, 'gcx, 'tcx> HasTyCtxt<'gcx> for TyCtxt<'a, 'gcx, 'tcx> {
1415 fn tcx<'b>(&'b self) -> TyCtxt<'b, 'gcx, 'gcx> {
1420 impl<'tcx, T: HasDataLayout> HasDataLayout for LayoutCx<'tcx, T> {
1421 fn data_layout(&self) -> &TargetDataLayout {
1422 self.tcx.data_layout()
1426 impl<'gcx, 'tcx, T: HasTyCtxt<'gcx>> HasTyCtxt<'gcx> for LayoutCx<'tcx, T> {
1427 fn tcx<'b>(&'b self) -> TyCtxt<'b, 'gcx, 'gcx> {
1432 pub trait MaybeResult<T> {
1433 fn from_ok(x: T) -> Self;
1434 fn map_same<F: FnOnce(T) -> T>(self, f: F) -> Self;
1437 impl<T> MaybeResult<T> for T {
1438 fn from_ok(x: T) -> Self {
1441 fn map_same<F: FnOnce(T) -> T>(self, f: F) -> Self {
1446 impl<T, E> MaybeResult<T> for Result<T, E> {
1447 fn from_ok(x: T) -> Self {
1450 fn map_same<F: FnOnce(T) -> T>(self, f: F) -> Self {
1455 pub type TyLayout<'tcx> = ::rustc_target::abi::TyLayout<'tcx, Ty<'tcx>>;
1457 impl<'a, 'tcx> LayoutOf for LayoutCx<'tcx, TyCtxt<'a, 'tcx, 'tcx>> {
1459 type TyLayout = Result<TyLayout<'tcx>, LayoutError<'tcx>>;
1461 /// Computes the layout of a type. Note that this implicitly
1462 /// executes in "reveal all" mode.
1463 fn layout_of(self, ty: Ty<'tcx>) -> Self::TyLayout {
1464 let param_env = self.param_env.with_reveal_all();
1465 let ty = self.tcx.normalize_erasing_regions(param_env, ty);
1466 let details = self.tcx.layout_raw(param_env.and(ty))?;
1467 let layout = TyLayout {
1472 // NB: This recording is normally disabled; when enabled, it
1473 // can however trigger recursive invocations of `layout_of`.
1474 // Therefore, we execute it *after* the main query has
1475 // completed, to avoid problems around recursive structures
1476 // and the like. (Admittedly, I wasn't able to reproduce a problem
1477 // here, but it seems like the right thing to do. -nmatsakis)
1478 self.record_layout_for_printing(layout);
1484 impl<'a, 'tcx> LayoutOf for LayoutCx<'tcx, ty::query::TyCtxtAt<'a, 'tcx, 'tcx>> {
1486 type TyLayout = Result<TyLayout<'tcx>, LayoutError<'tcx>>;
1488 /// Computes the layout of a type. Note that this implicitly
1489 /// executes in "reveal all" mode.
1490 fn layout_of(self, ty: Ty<'tcx>) -> Self::TyLayout {
1491 let param_env = self.param_env.with_reveal_all();
1492 let ty = self.tcx.normalize_erasing_regions(param_env, ty);
1493 let details = self.tcx.layout_raw(param_env.and(ty))?;
1494 let layout = TyLayout {
1499 // NB: This recording is normally disabled; when enabled, it
1500 // can however trigger recursive invocations of `layout_of`.
1501 // Therefore, we execute it *after* the main query has
1502 // completed, to avoid problems around recursive structures
1503 // and the like. (Admittedly, I wasn't able to reproduce a problem
1504 // here, but it seems like the right thing to do. -nmatsakis)
1507 param_env: self.param_env
1509 cx.record_layout_for_printing(layout);
1515 // Helper (inherent) `layout_of` methods to avoid pushing `LayoutCx` to users.
1516 impl TyCtxt<'a, 'tcx, '_> {
1517 /// Computes the layout of a type. Note that this implicitly
1518 /// executes in "reveal all" mode.
1520 pub fn layout_of(self, param_env_and_ty: ty::ParamEnvAnd<'tcx, Ty<'tcx>>)
1521 -> Result<TyLayout<'tcx>, LayoutError<'tcx>> {
1523 tcx: self.global_tcx(),
1524 param_env: param_env_and_ty.param_env
1526 cx.layout_of(param_env_and_ty.value)
1530 impl ty::query::TyCtxtAt<'a, 'tcx, '_> {
1531 /// Computes the layout of a type. Note that this implicitly
1532 /// executes in "reveal all" mode.
1534 pub fn layout_of(self, param_env_and_ty: ty::ParamEnvAnd<'tcx, Ty<'tcx>>)
1535 -> Result<TyLayout<'tcx>, LayoutError<'tcx>> {
1537 tcx: self.global_tcx().at(self.span),
1538 param_env: param_env_and_ty.param_env
1540 cx.layout_of(param_env_and_ty.value)
1544 impl<'a, 'tcx, C> TyLayoutMethods<'tcx, C> for Ty<'tcx>
1545 where C: LayoutOf<Ty = Ty<'tcx>> + HasTyCtxt<'tcx>,
1546 C::TyLayout: MaybeResult<TyLayout<'tcx>>
1548 fn for_variant(this: TyLayout<'tcx>, cx: C, variant_index: usize) -> TyLayout<'tcx> {
1549 let details = match this.variants {
1550 Variants::Single { index } if index == variant_index => this.details,
1552 Variants::Single { index } => {
1553 // Deny calling for_variant more than once for non-Single enums.
1554 cx.layout_of(this.ty).map_same(|layout| {
1555 assert_eq!(layout.variants, Variants::Single { index });
1559 let fields = match this.ty.sty {
1560 ty::TyAdt(def, _) => def.variants[variant_index].fields.len(),
1564 tcx.intern_layout(LayoutDetails {
1565 variants: Variants::Single { index: variant_index },
1566 fields: FieldPlacement::Union(fields),
1567 abi: Abi::Uninhabited,
1568 align: tcx.data_layout.i8_align,
1573 Variants::NicheFilling { ref variants, .. } |
1574 Variants::Tagged { ref variants, .. } => {
1575 &variants[variant_index]
1579 assert_eq!(details.variants, Variants::Single { index: variant_index });
1587 fn field(this: TyLayout<'tcx>, cx: C, i: usize) -> C::TyLayout {
1589 cx.layout_of(match this.ty.sty {
1598 ty::TyGeneratorWitness(..) |
1600 ty::TyDynamic(..) => {
1601 bug!("TyLayout::field_type({:?}): not applicable", this)
1604 // Potentially-fat pointers.
1605 ty::TyRef(_, pointee, _) |
1606 ty::TyRawPtr(ty::TypeAndMut { ty: pointee, .. }) => {
1609 // Reuse the fat *T type as its own thin pointer data field.
1610 // This provides information about e.g. DST struct pointees
1611 // (which may have no non-DST form), and will work as long
1612 // as the `Abi` or `FieldPlacement` is checked by users.
1614 let nil = tcx.mk_nil();
1615 let ptr_ty = if this.ty.is_unsafe_ptr() {
1618 tcx.mk_mut_ref(tcx.types.re_static, nil)
1620 return cx.layout_of(ptr_ty).map_same(|mut ptr_layout| {
1621 ptr_layout.ty = this.ty;
1626 match tcx.struct_tail(pointee).sty {
1628 ty::TyStr => tcx.types.usize,
1629 ty::TyDynamic(..) => {
1630 // FIXME(eddyb) use an usize/fn() array with
1631 // the correct number of vtables slots.
1632 tcx.mk_imm_ref(tcx.types.re_static, tcx.mk_nil())
1634 _ => bug!("TyLayout::field_type({:?}): not applicable", this)
1638 // Arrays and slices.
1639 ty::TyArray(element, _) |
1640 ty::TySlice(element) => element,
1641 ty::TyStr => tcx.types.u8,
1643 // Tuples, generators and closures.
1644 ty::TyClosure(def_id, ref substs) => {
1645 substs.upvar_tys(def_id, tcx).nth(i).unwrap()
1648 ty::TyGenerator(def_id, ref substs, _) => {
1649 substs.field_tys(def_id, tcx).nth(i).unwrap()
1652 ty::TyTuple(tys) => tys[i],
1654 // SIMD vector types.
1655 ty::TyAdt(def, ..) if def.repr.simd() => {
1656 this.ty.simd_type(tcx)
1660 ty::TyAdt(def, substs) => {
1661 match this.variants {
1662 Variants::Single { index } => {
1663 def.variants[index].fields[i].ty(tcx, substs)
1666 // Discriminant field for enums (where applicable).
1667 Variants::Tagged { tag: ref discr, .. } |
1668 Variants::NicheFilling { niche: ref discr, .. } => {
1670 let layout = LayoutDetails::scalar(tcx, discr.clone());
1671 return MaybeResult::from_ok(TyLayout {
1672 details: tcx.intern_layout(layout),
1673 ty: discr.value.to_ty(tcx)
1679 ty::TyProjection(_) | ty::TyAnon(..) | ty::TyParam(_) |
1680 ty::TyInfer(_) | ty::TyError => {
1681 bug!("TyLayout::field_type: unexpected type `{}`", this.ty)
1694 fn reserve<'a, 'tcx>(
1696 cx: LayoutCx<'tcx, TyCtxt<'a, 'tcx, 'tcx>>,
1698 ) -> Option<(u128, Scalar)> {
1699 if count > self.available {
1702 let Scalar { value, valid_range: ref v } = self.scalar;
1703 let bits = value.size(cx).bits();
1704 assert!(bits <= 128);
1705 let max_value = !0u128 >> (128 - bits);
1706 let start = v.end().wrapping_add(1) & max_value;
1707 let end = v.end().wrapping_add(count) & max_value;
1708 Some((start, Scalar { value, valid_range: *v.start()..=end }))
1712 impl<'a, 'tcx> LayoutCx<'tcx, TyCtxt<'a, 'tcx, 'tcx>> {
1713 /// Find the offset of a niche leaf field, starting from
1714 /// the given type and recursing through aggregates.
1715 // FIXME(eddyb) traverse already optimized enums.
1716 fn find_niche(self, layout: TyLayout<'tcx>) -> Result<Option<Niche>, LayoutError<'tcx>> {
1717 let scalar_niche = |scalar: &Scalar, offset| {
1718 let Scalar { value, valid_range: ref v } = *scalar;
1720 let bits = value.size(self).bits();
1721 assert!(bits <= 128);
1722 let max_value = !0u128 >> (128 - bits);
1724 // Find out how many values are outside the valid range.
1725 let available = if v.start() <= v.end() {
1726 v.start() + (max_value - v.end())
1728 v.start() - v.end() - 1
1731 // Give up if there is no niche value available.
1736 Some(Niche { offset, scalar: scalar.clone(), available })
1739 // Locals variables which live across yields are stored
1740 // in the generator type as fields. These may be uninitialized
1741 // so we don't look for niches there.
1742 if let ty::TyGenerator(..) = layout.ty.sty {
1747 Abi::Scalar(ref scalar) => {
1748 return Ok(scalar_niche(scalar, Size::ZERO));
1750 Abi::ScalarPair(ref a, ref b) => {
1751 // HACK(nox): We iter on `b` and then `a` because `max_by_key`
1752 // returns the last maximum.
1753 let niche = iter::once((b, a.value.size(self).abi_align(b.value.align(self))))
1754 .chain(iter::once((a, Size::ZERO)))
1755 .filter_map(|(scalar, offset)| scalar_niche(scalar, offset))
1756 .max_by_key(|niche| niche.available);
1759 Abi::Vector { ref element, .. } => {
1760 return Ok(scalar_niche(element, Size::ZERO));
1765 // Perhaps one of the fields is non-zero, let's recurse and find out.
1766 if let FieldPlacement::Union(_) = layout.fields {
1767 // Only Rust enums have safe-to-inspect fields
1768 // (a discriminant), other unions are unsafe.
1769 if let Variants::Single { .. } = layout.variants {
1773 if let FieldPlacement::Array { .. } = layout.fields {
1774 if layout.fields.count() > 0 {
1775 return self.find_niche(layout.field(self, 0)?);
1780 let mut niche = None;
1781 let mut available = 0;
1782 for i in 0..layout.fields.count() {
1783 if let Some(mut c) = self.find_niche(layout.field(self, i)?)? {
1784 if c.available > available {
1785 available = c.available;
1786 c.offset += layout.fields.offset(i);
1795 impl<'a> HashStable<StableHashingContext<'a>> for Variants {
1796 fn hash_stable<W: StableHasherResult>(&self,
1797 hcx: &mut StableHashingContext<'a>,
1798 hasher: &mut StableHasher<W>) {
1799 use ty::layout::Variants::*;
1800 mem::discriminant(self).hash_stable(hcx, hasher);
1803 Single { index } => {
1804 index.hash_stable(hcx, hasher);
1810 tag.hash_stable(hcx, hasher);
1811 variants.hash_stable(hcx, hasher);
1820 dataful_variant.hash_stable(hcx, hasher);
1821 niche_variants.start().hash_stable(hcx, hasher);
1822 niche_variants.end().hash_stable(hcx, hasher);
1823 niche.hash_stable(hcx, hasher);
1824 niche_start.hash_stable(hcx, hasher);
1825 variants.hash_stable(hcx, hasher);
1831 impl<'a> HashStable<StableHashingContext<'a>> for FieldPlacement {
1832 fn hash_stable<W: StableHasherResult>(&self,
1833 hcx: &mut StableHashingContext<'a>,
1834 hasher: &mut StableHasher<W>) {
1835 use ty::layout::FieldPlacement::*;
1836 mem::discriminant(self).hash_stable(hcx, hasher);
1840 count.hash_stable(hcx, hasher);
1842 Array { count, stride } => {
1843 count.hash_stable(hcx, hasher);
1844 stride.hash_stable(hcx, hasher);
1846 Arbitrary { ref offsets, ref memory_index } => {
1847 offsets.hash_stable(hcx, hasher);
1848 memory_index.hash_stable(hcx, hasher);
1854 impl<'a> HashStable<StableHashingContext<'a>> for Abi {
1855 fn hash_stable<W: StableHasherResult>(&self,
1856 hcx: &mut StableHashingContext<'a>,
1857 hasher: &mut StableHasher<W>) {
1858 use ty::layout::Abi::*;
1859 mem::discriminant(self).hash_stable(hcx, hasher);
1863 Scalar(ref value) => {
1864 value.hash_stable(hcx, hasher);
1866 ScalarPair(ref a, ref b) => {
1867 a.hash_stable(hcx, hasher);
1868 b.hash_stable(hcx, hasher);
1870 Vector { ref element, count } => {
1871 element.hash_stable(hcx, hasher);
1872 count.hash_stable(hcx, hasher);
1874 Aggregate { sized } => {
1875 sized.hash_stable(hcx, hasher);
1881 impl<'a> HashStable<StableHashingContext<'a>> for Scalar {
1882 fn hash_stable<W: StableHasherResult>(&self,
1883 hcx: &mut StableHashingContext<'a>,
1884 hasher: &mut StableHasher<W>) {
1885 let Scalar { value, ref valid_range } = *self;
1886 value.hash_stable(hcx, hasher);
1887 valid_range.start().hash_stable(hcx, hasher);
1888 valid_range.end().hash_stable(hcx, hasher);
1892 impl_stable_hash_for!(struct ::ty::layout::LayoutDetails {
1900 impl_stable_hash_for!(enum ::ty::layout::Integer {
1908 impl_stable_hash_for!(enum ::ty::layout::Primitive {
1909 Int(integer, signed),
1914 impl<'gcx> HashStable<StableHashingContext<'gcx>> for Align {
1915 fn hash_stable<W: StableHasherResult>(&self,
1916 hcx: &mut StableHashingContext<'gcx>,
1917 hasher: &mut StableHasher<W>) {
1918 self.abi().hash_stable(hcx, hasher);
1919 self.pref().hash_stable(hcx, hasher);
1923 impl<'gcx> HashStable<StableHashingContext<'gcx>> for Size {
1924 fn hash_stable<W: StableHasherResult>(&self,
1925 hcx: &mut StableHashingContext<'gcx>,
1926 hasher: &mut StableHasher<W>) {
1927 self.bytes().hash_stable(hcx, hasher);
1931 impl<'a, 'gcx> HashStable<StableHashingContext<'a>> for LayoutError<'gcx>
1933 fn hash_stable<W: StableHasherResult>(&self,
1934 hcx: &mut StableHashingContext<'a>,
1935 hasher: &mut StableHasher<W>) {
1936 use ty::layout::LayoutError::*;
1937 mem::discriminant(self).hash_stable(hcx, hasher);
1941 SizeOverflow(t) => t.hash_stable(hcx, hasher)