From ccde510c95887a2a94e2ad194a7c166dd0c9bc63 Mon Sep 17 00:00:00 2001 From: Eduard-Mihai Burtescu Date: Thu, 7 Nov 2019 16:54:25 +0200 Subject: [PATCH] rustc_target: inline abi::FloatTy into abi::Primitive. --- src/librustc/ich/impls_syntax.rs | 1 - src/librustc/ty/layout.rs | 17 ++++++++-------- .../debuginfo/metadata.rs | 4 ++-- src/librustc_codegen_llvm/intrinsic.rs | 6 +++--- src/librustc_codegen_llvm/type_of.rs | 6 +++--- src/librustc_target/abi/call/mips64.rs | 6 +++--- src/librustc_target/abi/call/mod.rs | 2 +- src/librustc_target/abi/call/x86_64.rs | 2 +- src/librustc_target/abi/mod.rs | 20 +++++++------------ 9 files changed, 29 insertions(+), 35 deletions(-) diff --git a/src/librustc/ich/impls_syntax.rs b/src/librustc/ich/impls_syntax.rs index 2201c4b0980b3..ff0ddb9ec0e6f 100644 --- a/src/librustc/ich/impls_syntax.rs +++ b/src/librustc/ich/impls_syntax.rs @@ -162,7 +162,6 @@ impl_stable_hash_for_spanned!(::syntax::ast::LitKind); impl_stable_hash_for!(enum ::syntax::ast::IntTy { Isize, I8, I16, I32, I64, I128 }); impl_stable_hash_for!(enum ::syntax::ast::UintTy { Usize, U8, U16, U32, U64, U128 }); impl_stable_hash_for!(enum ::syntax::ast::FloatTy { F32, F64 }); -impl_stable_hash_for!(enum ::rustc_target::abi::FloatTy { F32, F64 }); impl_stable_hash_for!(enum ::syntax::ast::Unsafety { Unsafe, Normal }); impl_stable_hash_for!(enum ::syntax::ast::Constness { Const, NotConst }); impl_stable_hash_for!(enum ::syntax::ast::Defaultness { Default, Final }); diff --git a/src/librustc/ty/layout.rs b/src/librustc/ty/layout.rs index 60aab6b6aa924..4bf500555f14b 100644 --- a/src/librustc/ty/layout.rs +++ b/src/librustc/ty/layout.rs @@ -132,8 +132,8 @@ impl PrimitiveExt for Primitive { fn to_ty<'tcx>(&self, tcx: TyCtxt<'tcx>) -> Ty<'tcx> { match *self { Int(i, signed) => i.to_ty(tcx, signed), - Float(FloatTy::F32) => tcx.types.f32, - Float(FloatTy::F64) => tcx.types.f64, + F32 => tcx.types.f32, + F64 => tcx.types.f64, Pointer => tcx.mk_mut_ptr(tcx.mk_unit()), } } @@ -144,7 +144,7 @@ impl PrimitiveExt for Primitive { match *self { Int(i, signed) => i.to_ty(tcx, signed), Pointer => tcx.types.usize, - Float(..) => bug!("floats do not have an int type"), + F32 | F64 => bug!("floats do not have an int type"), } } } @@ -538,10 +538,10 @@ impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> { ty::Uint(ity) => { scalar(Int(Integer::from_attr(dl, attr::UnsignedInt(ity)), false)) } - ty::Float(fty) => scalar(Float(match fty { - ast::FloatTy::F32 => FloatTy::F32, - ast::FloatTy::F64 => FloatTy::F64, - })), + ty::Float(fty) => scalar(match fty { + ast::FloatTy::F32 => F32, + ast::FloatTy::F64 => F64, + }), ty::FnPtr(_) => { let mut ptr = scalar_unit(Pointer); ptr.valid_range = 1..=*ptr.valid_range.end(); @@ -2457,7 +2457,8 @@ impl_stable_hash_for!(enum crate::ty::layout::Integer { impl_stable_hash_for!(enum crate::ty::layout::Primitive { Int(integer, signed), - Float(fty), + F32, + F64, Pointer }); diff --git a/src/librustc_codegen_llvm/debuginfo/metadata.rs b/src/librustc_codegen_llvm/debuginfo/metadata.rs index 5f18bb1700c14..f1bf451113152 100644 --- a/src/librustc_codegen_llvm/debuginfo/metadata.rs +++ b/src/librustc_codegen_llvm/debuginfo/metadata.rs @@ -1904,8 +1904,8 @@ fn prepare_enum_metadata( let discr_type = match discr.value { layout::Int(t, _) => t, - layout::Float(layout::FloatTy::F32) => Integer::I32, - layout::Float(layout::FloatTy::F64) => Integer::I64, + layout::F32 => Integer::I32, + layout::F64 => Integer::I64, layout::Pointer => cx.data_layout().ptr_sized_integer(), }.to_ty(cx.tcx, false); diff --git a/src/librustc_codegen_llvm/intrinsic.rs b/src/librustc_codegen_llvm/intrinsic.rs index a4c3b42f51e9e..6935e09054d0b 100644 --- a/src/librustc_codegen_llvm/intrinsic.rs +++ b/src/librustc_codegen_llvm/intrinsic.rs @@ -18,7 +18,7 @@ use rustc::ty::layout::{self, LayoutOf, HasTyCtxt, Primitive}; use rustc::mir::interpret::GlobalId; use rustc_codegen_ssa::common::{IntPredicate, TypeKind}; use rustc::hir; -use rustc_target::abi::{FloatTy, HasDataLayout}; +use rustc_target::abi::HasDataLayout; use syntax::ast; use rustc_codegen_ssa::common::span_invalid_monomorphization_error; @@ -163,12 +163,12 @@ impl IntrinsicCallMethods<'tcx> for Builder<'a, 'll, 'tcx> { emit_va_arg(self, args[0], ret_ty) } } - Primitive::Float(FloatTy::F64) | + Primitive::F64 | Primitive::Pointer => { emit_va_arg(self, args[0], ret_ty) } // `va_arg` should never be used with the return type f32. - Primitive::Float(FloatTy::F32) => { + Primitive::F32 => { bug!("the va_arg intrinsic does not work with `f32`") } } diff --git a/src/librustc_codegen_llvm/type_of.rs b/src/librustc_codegen_llvm/type_of.rs index dc68872ede11c..c21e62e7562e3 100644 --- a/src/librustc_codegen_llvm/type_of.rs +++ b/src/librustc_codegen_llvm/type_of.rs @@ -3,7 +3,7 @@ use crate::common::*; use crate::type_::Type; use rustc::ty::{self, Ty, TypeFoldable}; use rustc::ty::layout::{self, Align, LayoutOf, FnAbiExt, PointeeInfo, Size, TyLayout}; -use rustc_target::abi::{FloatTy, TyLayoutMethods}; +use rustc_target::abi::TyLayoutMethods; use rustc::ty::print::obsolete::DefPathBasedNames; use rustc_codegen_ssa::traits::*; @@ -300,8 +300,8 @@ impl<'tcx> LayoutLlvmExt<'tcx> for TyLayout<'tcx> { scalar: &layout::Scalar, offset: Size) -> &'a Type { match scalar.value { layout::Int(i, _) => cx.type_from_integer( i), - layout::Float(FloatTy::F32) => cx.type_f32(), - layout::Float(FloatTy::F64) => cx.type_f64(), + layout::F32 => cx.type_f32(), + layout::F64 => cx.type_f64(), layout::Pointer => { // If we know the alignment, pick something better than i8. let pointee = if let Some(pointee) = self.pointee_info_at(cx, offset) { diff --git a/src/librustc_target/abi/call/mips64.rs b/src/librustc_target/abi/call/mips64.rs index db34d36621290..18b121f9c5bef 100644 --- a/src/librustc_target/abi/call/mips64.rs +++ b/src/librustc_target/abi/call/mips64.rs @@ -23,8 +23,8 @@ fn float_reg<'a, Ty, C>(cx: &C, ret: &ArgAbi<'a, Ty>, i: usize) -> Option { match ret.layout.field(cx, i).abi { abi::Abi::Scalar(ref scalar) => match scalar.value { - abi::Float(abi::FloatTy::F32) => Some(Reg::f32()), - abi::Float(abi::FloatTy::F64) => Some(Reg::f64()), + abi::F32 => Some(Reg::f32()), + abi::F64 => Some(Reg::f64()), _ => None }, _ => None @@ -107,7 +107,7 @@ fn classify_arg<'a, Ty, C>(cx: &C, arg: &mut ArgAbi<'a, Ty>) // We only care about aligned doubles if let abi::Abi::Scalar(ref scalar) = field.abi { - if let abi::Float(abi::FloatTy::F64) = scalar.value { + if let abi::F64 = scalar.value { if offset.is_aligned(dl.f64_align.abi) { // Insert enough integers to cover [last_offset, offset) assert!(last_offset.is_aligned(dl.f64_align.abi)); diff --git a/src/librustc_target/abi/call/mod.rs b/src/librustc_target/abi/call/mod.rs index 396b962003803..6029b00aa31bd 100644 --- a/src/librustc_target/abi/call/mod.rs +++ b/src/librustc_target/abi/call/mod.rs @@ -287,7 +287,7 @@ impl<'a, Ty> TyLayout<'a, Ty> { let kind = match scalar.value { abi::Int(..) | abi::Pointer => RegKind::Integer, - abi::Float(_) => RegKind::Float, + abi::F32 | abi::F64 => RegKind::Float, }; HomogeneousAggregate::Homogeneous(Reg { kind, diff --git a/src/librustc_target/abi/call/x86_64.rs b/src/librustc_target/abi/call/x86_64.rs index 96fd077ec00b4..452ca024e61b4 100644 --- a/src/librustc_target/abi/call/x86_64.rs +++ b/src/librustc_target/abi/call/x86_64.rs @@ -45,7 +45,7 @@ fn classify_arg<'a, Ty, C>(cx: &C, arg: &ArgAbi<'a, Ty>) match scalar.value { abi::Int(..) | abi::Pointer => Class::Int, - abi::Float(_) => Class::Sse + abi::F32 | abi::F64 => Class::Sse } } diff --git a/src/librustc_target/abi/mod.rs b/src/librustc_target/abi/mod.rs index e58caed0c99dd..a19bb6807f1a1 100644 --- a/src/librustc_target/abi/mod.rs +++ b/src/librustc_target/abi/mod.rs @@ -532,13 +532,6 @@ impl Integer { } } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Copy, - PartialOrd, Ord, Debug)] -pub enum FloatTy { - F32, - F64, -} - /// Fundamental unit of memory access and layout. #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)] pub enum Primitive { @@ -550,7 +543,8 @@ 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), - Float(FloatTy), + F32, + F64, Pointer } @@ -560,8 +554,8 @@ impl Primitive { match self { Int(i, _) => i.size(), - Float(FloatTy::F32) => Size::from_bits(32), - Float(FloatTy::F64) => Size::from_bits(64), + F32 => Size::from_bits(32), + F64 => Size::from_bits(64), Pointer => dl.pointer_size } } @@ -571,15 +565,15 @@ impl Primitive { match self { Int(i, _) => i.align(dl), - Float(FloatTy::F32) => dl.f32_align, - Float(FloatTy::F64) => dl.f64_align, + F32 => dl.f32_align, + F64 => dl.f64_align, Pointer => dl.pointer_align } } pub fn is_float(self) -> bool { match self { - Float(_) => true, + F32 | F64 => true, _ => false } }