3 // Code relating to drop glue.
5 use crate::common::IntPredicate;
8 use rustc_middle::ty::{self, Ty};
9 use rustc_target::abi::WrappingRange;
11 pub fn size_and_align_of_dst<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
14 info: Option<Bx::Value>,
15 ) -> (Bx::Value, Bx::Value) {
16 let layout = bx.layout_of(t);
17 debug!("size_and_align_of_dst(ty={}, info={:?}): layout: {:?}", t, info, layout);
18 if !layout.is_unsized() {
19 let size = bx.const_usize(layout.size.bytes());
20 let align = bx.const_usize(layout.align.abi.bytes());
25 // Load size/align from vtable.
26 let vtable = info.unwrap();
27 let size = meth::VirtualIndex::from_index(ty::COMMON_VTABLE_ENTRIES_SIZE)
28 .get_usize(bx, vtable);
29 let align = meth::VirtualIndex::from_index(ty::COMMON_VTABLE_ENTRIES_ALIGN)
30 .get_usize(bx, vtable);
32 // Alignment is always nonzero.
33 bx.range_metadata(align, WrappingRange { start: 1, end: !0 });
37 ty::Slice(_) | ty::Str => {
38 let unit = layout.field(bx, 0);
39 // The info in this case is the length of the str, so the size is that
40 // times the unit size.
42 // All slice sizes must fit into `isize`, so this multiplication cannot (signed) wrap.
43 // NOTE: ideally, we want the effects of both `unchecked_smul` and `unchecked_umul`
44 // (resulting in `mul nsw nuw` in LLVM IR), since we know that the multiplication
45 // cannot signed wrap, and that both operands are non-negative. But at the time of writing,
46 // `BuilderMethods` can't do this, and it doesn't seem to enable any further optimizations.
47 bx.unchecked_smul(info.unwrap(), bx.const_usize(unit.size.bytes())),
48 bx.const_usize(unit.align.abi.bytes()),
52 // First get the size of all statically known fields.
53 // Don't use size_of because it also rounds up to alignment, which we
54 // want to avoid, as the unsized field's alignment could be smaller.
55 assert!(!t.is_simd());
56 debug!("DST {} layout: {:?}", t, layout);
58 let i = layout.fields.count() - 1;
59 let sized_size = layout.fields.offset(i).bytes();
60 let sized_align = layout.align.abi.bytes();
61 debug!("DST {} statically sized prefix size: {} align: {}", t, sized_size, sized_align);
62 let sized_size = bx.const_usize(sized_size);
63 let sized_align = bx.const_usize(sized_align);
65 // Recurse to get the size of the dynamically sized field (must be
67 let field_ty = layout.field(bx, i).ty;
68 let (unsized_size, mut unsized_align) = size_and_align_of_dst(bx, field_ty, info);
70 // FIXME (#26403, #27023): We should be adding padding
71 // to `sized_size` (to accommodate the `unsized_align`
72 // required of the unsized field that follows) before
73 // summing it with `sized_size`. (Note that since #26403
74 // is unfixed, we do not yet add the necessary padding
75 // here. But this is where the add would go.)
77 // Return the sum of sizes and max of aligns.
78 let size = bx.add(sized_size, unsized_size);
80 // Packed types ignore the alignment of their fields.
81 if let ty::Adt(def, _) = t.kind() {
82 if def.repr().packed() {
83 unsized_align = sized_align;
87 // Choose max of two known alignments (combined value must
88 // be aligned according to more restrictive of the two).
90 bx.const_to_opt_u128(sized_align, false),
91 bx.const_to_opt_u128(unsized_align, false),
93 (Some(sized_align), Some(unsized_align)) => {
94 // If both alignments are constant, (the sized_align should always be), then
95 // pick the correct alignment statically.
96 bx.const_usize(std::cmp::max(sized_align, unsized_align) as u64)
99 let cmp = bx.icmp(IntPredicate::IntUGT, sized_align, unsized_align);
100 bx.select(cmp, sized_align, unsized_align)
104 // Issue #27023: must add any necessary padding to `size`
105 // (to make it a multiple of `align`) before returning it.
107 // Namely, the returned size should be, in C notation:
109 // `size + ((size & (align-1)) ? align : 0)`
111 // emulated via the semi-standard fast bit trick:
113 // `(size + (align-1)) & -align`
114 let one = bx.const_usize(1);
115 let addend = bx.sub(align, one);
116 let add = bx.add(size, addend);
117 let neg = bx.neg(align);
118 let size = bx.and(add, neg);