Re-enable float tests

Author: antoyo

example/mini_core_hello_world.rs

@@ -275,11 +275,8 @@ fn main() {
     &mut (|| Some(0 as *const ())) as &mut dyn FnMut() -> Option<*const ()>;
 
     let f = 1000.0;
-    // FIXME(antoyo): doesn't work on m68k.
-    #[cfg(target_arch="x86_64")]
     assert_eq!(f as u8, 255);
     let f2 = -1000.0;
-    #[cfg(target_arch="x86_64")]
     assert_eq!(f2 as i8, -128);
     assert_eq!(f2 as u8, 0);
 

example/std_example.rs

@@ -46,8 +46,6 @@ fn main() {
     println!("{}", 2.3f32.max(1.0));
     println!("{}", 2.3f32.powi(2));
     println!("{}", 2.3f32.log2());
-    // FIXME(antoyo): doesn't work on m68k.
-    #[cfg(target_arch="x86_64")]
     assert_eq!(2.3f32.copysign(-1.0), -2.3f32);
     println!("{}", 2.3f32.powf(2.0));
 
@@ -80,22 +78,15 @@ fn main() {
     // Check that all u/i128 <-> float casts work correctly.
     let houndred_u128 = 100u128;
     let houndred_i128 = 100i128;
-    #[cfg(target_arch="x86_64")]
     let houndred_f32 = 100.0f32;
-    #[cfg(target_arch="x86_64")]
     let houndred_f64 = 100.0f64;
     assert_eq!(houndred_u128 as f32, 100.0);
     assert_eq!(houndred_u128 as f64, 100.0);
-    // FIXME(antoyo): doesn't work on m68k.
-    #[cfg(target_arch="x86_64")]
     assert_eq!(houndred_f32 as u128, 100);
-    #[cfg(target_arch="x86_64")]
     assert_eq!(houndred_f64 as u128, 100);
     assert_eq!(houndred_i128 as f32, 100.0);
     assert_eq!(houndred_i128 as f64, 100.0);
-    #[cfg(target_arch="x86_64")]
     assert_eq!(houndred_f32 as i128, 100);
-    #[cfg(target_arch="x86_64")]
     assert_eq!(houndred_f64 as i128, 100);
 
     let _a = 1u32 << 2u8;

src/context.rs

@@ -180,6 +180,7 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
 
         let tls_model = to_gcc_tls_mode(tcx.sess.tls_model());
 
+        // TODO(antoyo): set alignment on those types as well.
         let float_type = context.new_type::<f32>();
         let double_type = context.new_type::<f64>();
 

src/type_.rs

@@ -119,11 +119,11 @@ impl<'gcc, 'tcx> BaseTypeMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
     }
 
     fn type_f32(&self) -> Type<'gcc> {
-        self.context.new_type::<f32>()
+        self.float_type
     }
 
     fn type_f64(&self) -> Type<'gcc> {
-        self.context.new_type::<f64>()
+        self.double_type
     }
 
     fn type_func(&self, params: &[Type<'gcc>], return_type: Type<'gcc>) -> Type<'gcc> {