rustc_target: inline abi::FloatTy into abi::Primitive.

eddyb · eddyb · commit ccde510c9588 · 2019-11-07T16:54:25.000+02:00
diff --git 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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -23,8 +23,8 @@ fn float_reg<'a, Ty, C>(cx: &C, ret: &ArgAbi<'a, Ty>, i: usize) -> Option<Reg>
 {
     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
@@ -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
@@ -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
@@ -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
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ use rustc::ty::layout::{self, LayoutOf, HasTyCtxt, Primitive};`
`18`	`18`	`use rustc::mir::interpret::GlobalId;`
`19`	`19`	`use rustc_codegen_ssa::common::{IntPredicate, TypeKind};`
`20`	`20`	`use rustc::hir;`
`21`		`-use rustc_target::abi::{FloatTy, HasDataLayout};`
	`21`	`+use rustc_target::abi::HasDataLayout;`
`22`	`22`	`use syntax::ast;`
`23`	`23`
`24`	`24`	`use rustc_codegen_ssa::common::span_invalid_monomorphization_error;`
`@@ -163,12 +163,12 @@ impl IntrinsicCallMethods<'tcx> for Builder<'a, 'll, 'tcx> {`
`163`	`163`	`emit_va_arg(self, args[0], ret_ty)`
`164`	`164`	`}`
`165`	`165`	`}`
`166`		`- Primitive::Float(FloatTy::F64) \|`
	`166`	`+ Primitive::F64 \|`
`167`	`167`	`Primitive::Pointer => {`
`168`	`168`	`emit_va_arg(self, args[0], ret_ty)`
`169`	`169`	`}`
`170`	`170`	// `va_arg` should never be used with the return type f32.
`171`		`- Primitive::Float(FloatTy::F32) => {`
	`171`	`+ Primitive::F32 => {`
`172`	`172`	bug!("the va_arg intrinsic does not work with `f32`")
`173`	`173`	`}`
`174`	`174`	`}`
Original file line number	Diff line number	Diff line change
`@@ -45,7 +45,7 @@ fn classify_arg<'a, Ty, C>(cx: &C, arg: &ArgAbi<'a, Ty>)`
`45`	`45`	`match scalar.value {`
`46`	`46`	`abi::Int(..) \|`
`47`	`47`	`abi::Pointer => Class::Int,`
`48`		`- abi::Float(_) => Class::Sse`
	`48`	`+ abi::F32 \| abi::F64 => Class::Sse`
`49`	`49`	`}`
`50`	`50`	`}`
`51`	`51`
Original file line number	Diff line number	Diff line change
`@@ -532,13 +532,6 @@ impl Integer {`
`532`	`532`	`}`
`533`	`533`	`}`
`534`	`534`
`535`		`-#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Copy,`
`536`		`- PartialOrd, Ord, Debug)]`
`537`		`-pub enum FloatTy {`
`538`		`- F32,`
`539`		`- F64,`
`540`		`-}`
`541`		`-`
`542`	`535`	`/// Fundamental unit of memory access and layout.`
`543`	`536`	`#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]`
`544`	`537`	`pub enum Primitive {`
`@@ -550,7 +543,8 @@ pub enum Primitive {`
`550`	`543`	`/// a negative integer passed by zero-extension will appear positive in`
`551`	`544`	`/// the callee, and most operations on it will produce the wrong values.`
`552`	`545`	`Int(Integer, bool),`
`553`		`- Float(FloatTy),`
	`546`	`+ F32,`
	`547`	`+ F64,`
`554`	`548`	`Pointer`
`555`	`549`	`}`
`556`	`550`
`@@ -560,8 +554,8 @@ impl Primitive {`
`560`	`554`
`561`	`555`	`match self {`
`562`	`556`	`Int(i, _) => i.size(),`
`563`		`- Float(FloatTy::F32) => Size::from_bits(32),`
`564`		`- Float(FloatTy::F64) => Size::from_bits(64),`
	`557`	`+ F32 => Size::from_bits(32),`
	`558`	`+ F64 => Size::from_bits(64),`
`565`	`559`	`Pointer => dl.pointer_size`
`566`	`560`	`}`
`567`	`561`	`}`
`@@ -571,15 +565,15 @@ impl Primitive {`
`571`	`565`
`572`	`566`	`match self {`
`573`	`567`	`Int(i, _) => i.align(dl),`
`574`		`- Float(FloatTy::F32) => dl.f32_align,`
`575`		`- Float(FloatTy::F64) => dl.f64_align,`
	`568`	`+ F32 => dl.f32_align,`
	`569`	`+ F64 => dl.f64_align,`
`576`	`570`	`Pointer => dl.pointer_align`
`577`	`571`	`}`
`578`	`572`	`}`
`579`	`573`
`580`	`574`	`pub fn is_float(self) -> bool {`
`581`	`575`	`match self {`
`582`		`- Float(_) => true,`
	`576`	`+ F32 \| F64 => true,`
`583`	`577`	`_ => false`
`584`	`578`	`}`
`585`	`579`	`}`