Auto merge of rust-lang#124972 - matthiaskrgr:rollup-3fablim, r=matth…

…iaskrgr

Rollup of 5 pull requests

Successful merges:

 - rust-lang#124615 (coverage: Further simplify extraction of mapping info from MIR)
 - rust-lang#124778 (Fix parse error message for meta items)
 - rust-lang#124797 (Refactor float `Primitive`s to a separate `Float` type)
 - rust-lang#124888 (Migrate `run-make/rustdoc-output-path` to rmake)
 - rust-lang#124957 (Make `Ty::builtin_deref` just return a `Ty`)

r? `@ghost`
`@rustbot` modify labels: rollup

compiler/rustc_abi/src/lib.rs

@@ -926,6 +926,41 @@ impl Integer {
  }
 }
 
+/// Floating-point types.
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
+#[cfg_attr(feature = "nightly", derive(HashStable_Generic))]
+pub enum Float {
+ F16,
+ F32,
+ F64,
+ F128,
+}
+
+impl Float {
+ pub fn size(self) -> Size {
+ use Float::*;
+
+ match self {
+ F16 => Size::from_bits(16),
+ F32 => Size::from_bits(32),
+ F64 => Size::from_bits(64),
+ F128 => Size::from_bits(128),
+ }
+ }
+
+ pub fn align<C: HasDataLayout>(self, cx: &C) -> AbiAndPrefAlign {
+ use Float::*;
+ let dl = cx.data_layout();
+
+ match self {
+ F16 => dl.f16_align,
+ F32 => dl.f32_align,
+ F64 => dl.f64_align,
+ F128 => dl.f128_align,
+ }
+ }
+}
+
 /// Fundamental unit of memory access and layout.
 #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
 #[cfg_attr(feature = "nightly", derive(HashStable_Generic))]
@@ -938,10 +973,7 @@ pub enum Primitive {
  /// a negative integer passed by zero-extension will appear positive in
  /// the callee, and most operations on it will produce the wrong values.
  Int(Integer, bool),
- F16,
- F32,
- F64,
- F128,
+ Float(Float),
  Pointer(AddressSpace),
 }
 
@@ -952,10 +984,7 @@ impl Primitive {
 
  match self {
  Int(i, _) => i.size(),
- F16 => Size::from_bits(16),
- F32 => Size::from_bits(32),
- F64 => Size::from_bits(64),
- F128 => Size::from_bits(128),
+ Float(f) => f.size(),
  // FIXME(erikdesjardins): ignoring address space is technically wrong, pointers in
  // different address spaces can have different sizes
  // (but TargetDataLayout doesn't currently parse that part of the DL string)
@@ -969,10 +998,7 @@ impl Primitive {
 
  match self {
  Int(i, _) => i.align(dl),
- F16 => dl.f16_align,
- F32 => dl.f32_align,
- F64 => dl.f64_align,
- F128 => dl.f128_align,
+ Float(f) => f.align(dl),
  // FIXME(erikdesjardins): ignoring address space is technically wrong, pointers in
  // different address spaces can have different alignments
  // (but TargetDataLayout doesn't currently parse that part of the DL string)

compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs

@@ -1483,10 +1483,9 @@ fn suggest_ampmut<'tcx>(
  } else {
  // otherwise, suggest that the user annotates the binding; we provide the
  // type of the local.
- let ty_mut = decl_ty.builtin_deref(true).unwrap();
- assert_eq!(ty_mut.mutbl, hir::Mutability::Not);
+ let ty = decl_ty.builtin_deref(true).unwrap();
 
- (false, span, format!("{}mut {}", if decl_ty.is_ref() { "&" } else { "*" }, ty_mut.ty))
+ (false, span, format!("{}mut {}", if decl_ty.is_ref() { "&" } else { "*" }, ty))
  }
 }
 

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -400,7 +400,7 @@ impl<'a, 'b, 'tcx> Visitor<'tcx> for TypeVerifier<'a, 'b, 'tcx> {
  } else if let Some(static_def_id) = constant.check_static_ptr(tcx) {
  let unnormalized_ty = tcx.type_of(static_def_id).instantiate_identity();
  let normalized_ty = self.cx.normalize(unnormalized_ty, locations);
- let literal_ty = constant.const_.ty().builtin_deref(true).unwrap().ty;
+ let literal_ty = constant.const_.ty().builtin_deref(true).unwrap();
 
  if let Err(terr) = self.cx.eq_types(
  literal_ty,
@@ -637,7 +637,7 @@ impl<'a, 'b, 'tcx> TypeVerifier<'a, 'b, 'tcx> {
  match pi {
  ProjectionElem::Deref => {
  let deref_ty = base_ty.builtin_deref(true);
- PlaceTy::from_ty(deref_ty.map(|t| t.ty).unwrap_or_else(|| {
+ PlaceTy::from_ty(deref_ty.unwrap_or_else(|| {
  span_mirbug_and_err!(self, place, "deref of non-pointer {:?}", base_ty)
  }))
  }

compiler/rustc_codegen_cranelift/src/base.rs

@@ -670,11 +670,8 @@ fn codegen_stmt<'tcx>(
  let to_ty = fx.monomorphize(to_ty);
 
  fn is_fat_ptr<'tcx>(fx: &FunctionCx<'_, '_, 'tcx>, ty: Ty<'tcx>) -> bool {
- ty.builtin_deref(true).is_some_and(
- |ty::TypeAndMut { ty: pointee_ty, mutbl: _ }| {
- has_ptr_meta(fx.tcx, pointee_ty)
- },
- )
+ ty.builtin_deref(true)
+ .is_some_and(|pointee_ty| has_ptr_meta(fx.tcx, pointee_ty))
  }
 
  if is_fat_ptr(fx, from_ty) {

compiler/rustc_codegen_cranelift/src/common.rs

@@ -7,7 +7,7 @@ use rustc_middle::ty::layout::{
 use rustc_middle::ty::TypeFoldable;
 use rustc_span::source_map::Spanned;
 use rustc_target::abi::call::FnAbi;
-use rustc_target::abi::{Integer, Primitive};
+use rustc_target::abi::{Float, Integer, Primitive};
 use rustc_target::spec::{HasTargetSpec, Target};
 
 use crate::constant::ConstantCx;
@@ -32,10 +32,12 @@ pub(crate) fn scalar_to_clif_type(tcx: TyCtxt<'_>, scalar: Scalar) -> Type {
  Integer::I64 => types::I64,
  Integer::I128 => types::I128,
  },
- Primitive::F16 => unimplemented!("f16_f128"),
- Primitive::F32 => types::F32,
- Primitive::F64 => types::F64,
- Primitive::F128 => unimplemented!("f16_f128"),
+ Primitive::Float(float) => match float {
+ Float::F16 => unimplemented!("f16_f128"),
+ Float::F32 => types::F32,
+ Float::F64 => types::F64,
+ Float::F128 => unimplemented!("f16_f128"),
+ },
  // FIXME(erikdesjardins): handle non-default addrspace ptr sizes
  Primitive::Pointer(_) => pointer_ty(tcx),
  }

compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs

@@ -586,7 +586,7 @@ fn codegen_regular_intrinsic_call<'tcx>(
  intrinsic_args!(fx, args => (base, offset); intrinsic);
  let offset = offset.load_scalar(fx);
 
- let pointee_ty = base.layout().ty.builtin_deref(true).unwrap().ty;
+ let pointee_ty = base.layout().ty.builtin_deref(true).unwrap();
  let pointee_size = fx.layout_of(pointee_ty).size.bytes();
  let ptr_diff = if pointee_size != 1 {
  fx.bcx.ins().imul_imm(offset, pointee_size as i64)
@@ -610,7 +610,7 @@ fn codegen_regular_intrinsic_call<'tcx>(
  let val = val.load_scalar(fx);
  let count = count.load_scalar(fx);
 
- let pointee_ty = dst.layout().ty.builtin_deref(true).unwrap().ty;
+ let pointee_ty = dst.layout().ty.builtin_deref(true).unwrap();
  let pointee_size = fx.layout_of(pointee_ty).size.bytes();
  let count = if pointee_size != 1 {
  fx.bcx.ins().imul_imm(count, pointee_size as i64)
@@ -715,7 +715,7 @@ fn codegen_regular_intrinsic_call<'tcx>(
 
  // Cranelift treats loads as volatile by default
  // FIXME correctly handle unaligned_volatile_load
- let inner_layout = fx.layout_of(ptr.layout().ty.builtin_deref(true).unwrap().ty);
+ let inner_layout = fx.layout_of(ptr.layout().ty.builtin_deref(true).unwrap());
  let val = CValue::by_ref(Pointer::new(ptr.load_scalar(fx)), inner_layout);
  ret.write_cvalue(fx, val);
  }

compiler/rustc_codegen_cranelift/src/intrinsics/simd.rs

@@ -974,7 +974,7 @@ pub(super) fn codegen_simd_intrinsic_call<'tcx>(
  intrinsic_args!(fx, args => (ptr, offset); intrinsic);
 
  let (lane_count, ptr_lane_ty) = ptr.layout().ty.simd_size_and_type(fx.tcx);
- let pointee_ty = ptr_lane_ty.builtin_deref(true).unwrap().ty;
+ let pointee_ty = ptr_lane_ty.builtin_deref(true).unwrap();
  let pointee_size = fx.layout_of(pointee_ty).size.bytes();
  let (ret_lane_count, ret_lane_ty) = ret.layout().ty.simd_size_and_type(fx.tcx);
  let ret_lane_layout = fx.layout_of(ret_lane_ty);

compiler/rustc_codegen_cranelift/src/lib.rs

@@ -95,7 +95,7 @@ mod prelude {
  pub(crate) use rustc_middle::mir::{self, *};
  pub(crate) use rustc_middle::ty::layout::{LayoutOf, TyAndLayout};
  pub(crate) use rustc_middle::ty::{
- self, FloatTy, Instance, InstanceDef, IntTy, ParamEnv, Ty, TyCtxt, TypeAndMut, UintTy,
+ self, FloatTy, Instance, InstanceDef, IntTy, ParamEnv, Ty, TyCtxt, UintTy,
  };
  pub(crate) use rustc_span::Span;
  pub(crate) use rustc_target::abi::{Abi, FieldIdx, Scalar, Size, VariantIdx, FIRST_VARIANT};

compiler/rustc_codegen_cranelift/src/num.rs

@@ -388,12 +388,8 @@ pub(crate) fn codegen_ptr_binop<'tcx>(
  in_lhs: CValue<'tcx>,
  in_rhs: CValue<'tcx>,
 ) -> CValue<'tcx> {
- let is_thin_ptr = in_lhs
- .layout()
- .ty
- .builtin_deref(true)
- .map(|TypeAndMut { ty, mutbl: _ }| !has_ptr_meta(fx.tcx, ty))
- .unwrap_or(true);
+ let is_thin_ptr =
+ in_lhs.layout().ty.builtin_deref(true).map(|ty| !has_ptr_meta(fx.tcx, ty)).unwrap_or(true);
 
  if is_thin_ptr {
  match bin_op {
@@ -404,7 +400,7 @@ pub(crate) fn codegen_ptr_binop<'tcx>(
  codegen_compare_bin_op(fx, bin_op, false, lhs, rhs)
  }
  BinOp::Offset => {
- let pointee_ty = in_lhs.layout().ty.builtin_deref(true).unwrap().ty;
+ let pointee_ty = in_lhs.layout().ty.builtin_deref(true).unwrap();
  let (base, offset) = (in_lhs, in_rhs.load_scalar(fx));
  let pointee_size = fx.layout_of(pointee_ty).size.bytes();
  let ptr_diff = fx.bcx.ins().imul_imm(offset, pointee_size as i64);

compiler/rustc_codegen_cranelift/src/unsize.rs

@@ -127,7 +127,7 @@ pub(crate) fn coerce_unsized_into<'tcx>(
  let dst_ty = dst.layout().ty;
  let mut coerce_ptr = || {
  let (base, info) =
- if fx.layout_of(src.layout().ty.builtin_deref(true).unwrap().ty).is_unsized() {
+ if fx.layout_of(src.layout().ty.builtin_deref(true).unwrap()).is_unsized() {
  let (old_base, old_info) = src.load_scalar_pair(fx);
  unsize_ptr(fx, old_base, src.layout(), dst.layout(), Some(old_info))
  } else {

compiler/rustc_codegen_cranelift/src/value_and_place.rs

@@ -819,7 +819,7 @@ impl<'tcx> CPlace<'tcx> {
  }
 
  pub(crate) fn place_deref(self, fx: &mut FunctionCx<'_, '_, 'tcx>) -> CPlace<'tcx> {
- let inner_layout = fx.layout_of(self.layout().ty.builtin_deref(true).unwrap().ty);
+ let inner_layout = fx.layout_of(self.layout().ty.builtin_deref(true).unwrap());
  if has_ptr_meta(fx.tcx, inner_layout.ty) {
  let (addr, extra) = self.to_cvalue(fx).load_scalar_pair(fx);
  CPlace::for_ptr_with_extra(Pointer::new(addr), extra, inner_layout)

compiler/rustc_codegen_cranelift/src/vtable.rs

@@ -59,7 +59,7 @@ pub(crate) fn get_ptr_and_method_ref<'tcx>(
 
  if let ty::Ref(_, ty, _) = arg.layout().ty.kind() {
  if ty.is_dyn_star() {
- let inner_layout = fx.layout_of(arg.layout().ty.builtin_deref(true).unwrap().ty);
+ let inner_layout = fx.layout_of(arg.layout().ty.builtin_deref(true).unwrap());
  let dyn_star = CPlace::for_ptr(Pointer::new(arg.load_scalar(fx)), inner_layout);
  let ptr = dyn_star.place_field(fx, FieldIdx::ZERO).to_ptr();
  let vtable =

compiler/rustc_codegen_gcc/src/type_of.rs

@@ -8,8 +8,8 @@ use rustc_middle::ty::print::with_no_trimmed_paths;
 use rustc_middle::ty::{self, Ty, TypeVisitableExt};
 use rustc_target::abi::call::{CastTarget, FnAbi, Reg};
 use rustc_target::abi::{
- self, Abi, Align, FieldsShape, Int, Integer, PointeeInfo, Pointer, Size, TyAbiInterface,
- Variants, F128, F16, F32, F64,
+ self, Abi, Align, FieldsShape, Float, Int, Integer, PointeeInfo, Pointer, Size, TyAbiInterface,
+ Variants,
 };
 
 use crate::abi::{FnAbiGcc, FnAbiGccExt, GccType};
@@ -283,10 +283,7 @@ impl<'tcx> LayoutGccExt<'tcx> for TyAndLayout<'tcx> {
  match scalar.primitive() {
  Int(i, true) => cx.type_from_integer(i),
  Int(i, false) => cx.type_from_unsigned_integer(i),
- F16 => cx.type_f16(),
- F32 => cx.type_f32(),
- F64 => cx.type_f64(),
- F128 => cx.type_f128(),
+ Float(f) => cx.type_from_float(f),
  Pointer(address_space) => {
  // If we know the alignment, pick something better than i8.
  let pointee = if let Some(pointee) = self.pointee_info_at(cx, offset) {

compiler/rustc_codegen_llvm/src/abi.rs

@@ -583,7 +583,7 @@ impl<'ll, 'tcx> FnAbiLlvmExt<'ll, 'tcx> for FnAbi<'tcx, Ty<'tcx>> {
  let element_type_index = unsafe { llvm::LLVMRustGetElementTypeArgIndex(callsite) };
  if element_type_index >= 0 {
  let arg_ty = self.args[element_type_index as usize].layout.ty;
- let pointee_ty = arg_ty.builtin_deref(true).expect("Must be pointer argument").ty;
+ let pointee_ty = arg_ty.builtin_deref(true).expect("Must be pointer argument");
  let element_type_attr = unsafe {
  llvm::LLVMRustCreateElementTypeAttr(bx.llcx, bx.layout_of(pointee_ty).llvm_type(bx))
  };

compiler/rustc_codegen_llvm/src/asm.rs

@@ -904,8 +904,8 @@ fn llvm_asm_scalar_type<'ll>(cx: &CodegenCx<'ll, '_>, scalar: Scalar) -> &'ll Ty
  Primitive::Int(Integer::I16, _) => cx.type_i16(),
  Primitive::Int(Integer::I32, _) => cx.type_i32(),
  Primitive::Int(Integer::I64, _) => cx.type_i64(),
- Primitive::F32 => cx.type_f32(),
- Primitive::F64 => cx.type_f64(),
+ Primitive::Float(Float::F32) => cx.type_f32(),
+ Primitive::Float(Float::F64) => cx.type_f64(),
  // FIXME(erikdesjardins): handle non-default addrspace ptr sizes
  Primitive::Pointer(_) => cx.type_from_integer(dl.ptr_sized_integer()),
  _ => unreachable!(),
@@ -950,7 +950,7 @@ fn llvm_fixup_input<'ll, 'tcx>(
  bx.shuffle_vector(value, bx.const_undef(vec_ty), bx.const_vector(&indices))
  }
  (InlineAsmRegClass::X86(X86InlineAsmRegClass::reg_abcd), Abi::Scalar(s))
- if s.primitive() == Primitive::F64 =>
+ if s.primitive() == Primitive::Float(Float::F64) =>
  {
  bx.bitcast(value, bx.cx.type_i64())
  }
@@ -986,8 +986,8 @@ fn llvm_fixup_input<'ll, 'tcx>(
  match s.primitive() {
  // MIPS only supports register-length arithmetics.
  Primitive::Int(Integer::I8 | Integer::I16, _) => bx.zext(value, bx.cx.type_i32()),
- Primitive::F32 => bx.bitcast(value, bx.cx.type_i32()),
- Primitive::F64 => bx.bitcast(value, bx.cx.type_i64()),
+ Primitive::Float(Float::F32) => bx.bitcast(value, bx.cx.type_i32()),
+ Primitive::Float(Float::F64) => bx.bitcast(value, bx.cx.type_i64()),
  _ => value,
  }
  }
@@ -1027,7 +1027,7 @@ fn llvm_fixup_output<'ll, 'tcx>(
  bx.shuffle_vector(value, bx.const_undef(vec_ty), bx.const_vector(&indices))
  }
  (InlineAsmRegClass::X86(X86InlineAsmRegClass::reg_abcd), Abi::Scalar(s))
- if s.primitive() == Primitive::F64 =>
+ if s.primitive() == Primitive::Float(Float::F64) =>
  {
  bx.bitcast(value, bx.cx.type_f64())
  }
@@ -1064,8 +1064,8 @@ fn llvm_fixup_output<'ll, 'tcx>(
  // MIPS only supports register-length arithmetics.
  Primitive::Int(Integer::I8, _) => bx.trunc(value, bx.cx.type_i8()),
  Primitive::Int(Integer::I16, _) => bx.trunc(value, bx.cx.type_i16()),
- Primitive::F32 => bx.bitcast(value, bx.cx.type_f32()),
- Primitive::F64 => bx.bitcast(value, bx.cx.type_f64()),
+ Primitive::Float(Float::F32) => bx.bitcast(value, bx.cx.type_f32()),
+ Primitive::Float(Float::F64) => bx.bitcast(value, bx.cx.type_f64()),
  _ => value,
  }
  }
@@ -1100,7 +1100,7 @@ fn llvm_fixup_output_type<'ll, 'tcx>(
  cx.type_vector(elem_ty, count * 2)
  }
  (InlineAsmRegClass::X86(X86InlineAsmRegClass::reg_abcd), Abi::Scalar(s))
- if s.primitive() == Primitive::F64 =>
+ if s.primitive() == Primitive::Float(Float::F64) =>
  {
  cx.type_i64()
  }
@@ -1136,8 +1136,8 @@ fn llvm_fixup_output_type<'ll, 'tcx>(
  match s.primitive() {
  // MIPS only supports register-length arithmetics.
  Primitive::Int(Integer::I8 | Integer::I16, _) => cx.type_i32(),
- Primitive::F32 => cx.type_i32(),
- Primitive::F64 => cx.type_i64(),
+ Primitive::Float(Float::F32) => cx.type_i32(),
+ Primitive::Float(Float::F64) => cx.type_i64(),
  _ => layout.llvm_type(cx),
  }
  }

compiler/rustc_codegen_llvm/src/builder.rs

@@ -576,7 +576,7 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
  }
  }
  }
- abi::F16 | abi::F32 | abi::F64 | abi::F128 => {}
+ abi::Float(_) => {}
  }
  }
 

compiler/rustc_codegen_llvm/src/debuginfo/metadata/enums/mod.rs

@@ -122,10 +122,7 @@ fn tag_base_type<'ll, 'tcx>(
  // Niche tags are always normalized to unsized integers of the correct size.
  match tag.primitive() {
  Primitive::Int(t, _) => t,
- Primitive::F16 => Integer::I16,
- Primitive::F32 => Integer::I32,
- Primitive::F64 => Integer::I64,
- Primitive::F128 => Integer::I128,
+ Primitive::Float(f) => Integer::from_size(f.size()).unwrap(),
  // FIXME(erikdesjardins): handle non-default addrspace ptr sizes
  Primitive::Pointer(_) => {
  // If the niche is the NULL value of a reference, then `discr_enum_ty` will be