| //! Computing the size and alignment of a value. |
| |
| use rustc_abi::WrappingRange; |
| use rustc_hir::LangItem; |
| use rustc_middle::bug; |
| use rustc_middle::ty::print::{with_no_trimmed_paths, with_no_visible_paths}; |
| use rustc_middle::ty::{self, Ty}; |
| use rustc_span::DUMMY_SP; |
| use tracing::{debug, trace}; |
| |
| use crate::common::IntPredicate; |
| use crate::traits::*; |
| use crate::{common, meth}; |
| |
| pub fn size_and_align_of_dst<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>( |
| bx: &mut Bx, |
| t: Ty<'tcx>, |
| info: Option<Bx::Value>, |
| ) -> (Bx::Value, Bx::Value) { |
| let layout = bx.layout_of(t); |
| trace!("size_and_align_of_dst(ty={}, info={:?}): layout: {:?}", t, info, layout); |
| if layout.is_sized() { |
| let size = bx.const_usize(layout.size.bytes()); |
| let align = bx.const_usize(layout.align.bytes()); |
| return (size, align); |
| } |
| match t.kind() { |
| ty::Dynamic(..) => { |
| // Load size/align from vtable. |
| let vtable = info.unwrap(); |
| let size = meth::VirtualIndex::from_index(ty::COMMON_VTABLE_ENTRIES_SIZE) |
| .get_usize(bx, vtable, t); |
| let align = meth::VirtualIndex::from_index(ty::COMMON_VTABLE_ENTRIES_ALIGN) |
| .get_usize(bx, vtable, t); |
| |
| // Size is always <= isize::MAX. |
| let size_bound = bx.data_layout().ptr_sized_integer().signed_max() as u128; |
| bx.range_metadata(size, WrappingRange { start: 0, end: size_bound }); |
| // Alignment is always nonzero. |
| bx.range_metadata(align, WrappingRange { start: 1, end: !0 }); |
| |
| (size, align) |
| } |
| ty::Slice(_) | ty::Str => { |
| let unit = layout.field(bx, 0); |
| // The info in this case is the length of the str, so the size is that |
| // times the unit size. |
| ( |
| // All slice sizes must fit into `isize`, so this multiplication cannot |
| // wrap -- neither signed nor unsigned. |
| bx.unchecked_sumul(info.unwrap(), bx.const_usize(unit.size.bytes())), |
| bx.const_usize(unit.align.bytes()), |
| ) |
| } |
| ty::Foreign(_) => { |
| // `extern` type. We cannot compute the size, so panic. |
| let msg_str = with_no_visible_paths!({ |
| with_no_trimmed_paths!({ |
| format!("attempted to compute the size or alignment of extern type `{t}`") |
| }) |
| }); |
| let msg = bx.const_str(&msg_str); |
| |
| // Obtain the panic entry point. |
| let (fn_abi, llfn, _instance) = |
| common::build_langcall(bx, DUMMY_SP, LangItem::PanicNounwind); |
| |
| // Generate the call. Cannot use `do_call` since we don't have a MIR terminator so we |
| // can't create a `TerminationCodegenHelper`. (But we are in good company, this code is |
| // duplicated plenty of times.) |
| let fn_ty = bx.fn_decl_backend_type(fn_abi); |
| |
| bx.call( |
| fn_ty, |
| /* fn_attrs */ None, |
| Some(fn_abi), |
| llfn, |
| &[msg.0, msg.1], |
| None, |
| None, |
| ); |
| |
| // This function does not return so we can now return whatever we want. |
| let size = bx.const_usize(layout.size.bytes()); |
| let align = bx.const_usize(layout.align.bytes()); |
| (size, align) |
| } |
| ty::Adt(..) | ty::Tuple(..) => { |
| // First get the size of all statically known fields. |
| // Don't use size_of because it also rounds up to alignment, which we |
| // want to avoid, as the unsized field's alignment could be smaller. |
| assert!(!t.is_simd()); |
| debug!("DST {} layout: {:?}", t, layout); |
| |
| let i = layout.fields.count() - 1; |
| let unsized_offset_unadjusted = layout.fields.offset(i).bytes(); |
| let sized_align = layout.align.bytes(); |
| debug!( |
| "DST {} offset of dyn field: {}, statically sized align: {}", |
| t, unsized_offset_unadjusted, sized_align |
| ); |
| let unsized_offset_unadjusted = bx.const_usize(unsized_offset_unadjusted); |
| let sized_align = bx.const_usize(sized_align); |
| |
| // Recurse to get the size of the dynamically sized field (must be |
| // the last field). |
| let field_ty = layout.field(bx, i).ty; |
| let (unsized_size, mut unsized_align) = size_and_align_of_dst(bx, field_ty, info); |
| |
| // # First compute the dynamic alignment |
| |
| // For packed types, we need to cap the alignment. |
| if let ty::Adt(def, _) = t.kind() |
| && let Some(packed) = def.repr().pack |
| { |
| if packed.bytes() == 1 { |
| // We know this will be capped to 1. |
| unsized_align = bx.const_usize(1); |
| } else { |
| // We have to dynamically compute `min(unsized_align, packed)`. |
| let packed = bx.const_usize(packed.bytes()); |
| let cmp = bx.icmp(IntPredicate::IntULT, unsized_align, packed); |
| unsized_align = bx.select(cmp, unsized_align, packed); |
| } |
| } |
| |
| // Choose max of two known alignments (combined value must |
| // be aligned according to more restrictive of the two). |
| let full_align = match ( |
| bx.const_to_opt_u128(sized_align, false), |
| bx.const_to_opt_u128(unsized_align, false), |
| ) { |
| (Some(sized_align), Some(unsized_align)) => { |
| // If both alignments are constant, (the sized_align should always be), then |
| // pick the correct alignment statically. |
| bx.const_usize(std::cmp::max(sized_align, unsized_align) as u64) |
| } |
| _ => { |
| let cmp = bx.icmp(IntPredicate::IntUGT, sized_align, unsized_align); |
| bx.select(cmp, sized_align, unsized_align) |
| } |
| }; |
| |
| // # Then compute the dynamic size |
| |
| // The full formula for the size would be: |
| // let unsized_offset_adjusted = unsized_offset_unadjusted.align_to(unsized_align); |
| // let full_size = (unsized_offset_adjusted + unsized_size).align_to(full_align); |
| // However, `unsized_size` is a multiple of `unsized_align`. Therefore, we can |
| // equivalently do the `align_to(unsized_align)` *after* adding `unsized_size`: |
| // |
| // let full_size = |
| // (unsized_offset_unadjusted + unsized_size) |
| // .align_to(unsized_align) |
| // .align_to(full_align); |
| // |
| // Furthermore, `align >= unsized_align`, and therefore we only need to do: |
| // let full_size = (unsized_offset_unadjusted + unsized_size).align_to(full_align); |
| |
| let full_size = bx.add(unsized_offset_unadjusted, unsized_size); |
| |
| // Issue #27023: must add any necessary padding to `size` |
| // (to make it a multiple of `align`) before returning it. |
| // |
| // Namely, the returned size should be, in C notation: |
| // |
| // `size + ((size & (align-1)) ? align : 0)` |
| // |
| // emulated via the semi-standard fast bit trick: |
| // |
| // `(size + (align-1)) & -align` |
| let one = bx.const_usize(1); |
| let addend = bx.sub(full_align, one); |
| let add = bx.add(full_size, addend); |
| let neg = bx.neg(full_align); |
| let full_size = bx.and(add, neg); |
| |
| (full_size, full_align) |
| } |
| _ => bug!("size_and_align_of_dst: {t} not supported"), |
| } |
| } |
