fix from to/from f32/f64 changes

Author: RalfJung

src/fn_call.rs

@@ -758,7 +758,7 @@ pub trait EvalContextExt<'a, 'mir, 'tcx: 'a + 'mir>: crate::MiriEvalContextExt<'
                 this.machine.last_error = err;
             }
             "GetLastError" => {
-                this.write_scalar(Scalar::from_uint(this.machine.last_error, Size::from_bits(32)), dest)?;
+                this.write_scalar(Scalar::from_u32(this.machine.last_error), dest)?;
             }
 
             "AddVectoredExceptionHandler" => {
@@ -854,7 +854,7 @@ pub trait EvalContextExt<'a, 'mir, 'tcx: 'a + 'mir>: crate::MiriEvalContextExt<'
                 };
                 // If there was no error, write back how much was written.
                 if let Some(n) = written {
-                    this.write_scalar(Scalar::from_uint(n, Size::from_bits(32)), written_place.into())?;
+                    this.write_scalar(Scalar::from_u32(n), written_place.into())?;
                 }
                 // Return whether this was a success.
                 this.write_scalar(

src/intrinsic.rs

@@ -186,7 +186,8 @@ pub trait EvalContextExt<'a, 'mir, 'tcx: 'a+'mir>: crate::MiriEvalContextExt<'a,
 
             "sinf32" | "fabsf32" | "cosf32" | "sqrtf32" | "expf32" | "exp2f32" | "logf32" |
             "log10f32" | "log2f32" | "floorf32" | "ceilf32" | "truncf32" => {
-                let f = this.read_scalar(args[0])?.to_f32()?;
+                // FIXME: Using host floats.
+                let f = f32::from_bits(this.read_scalar(args[0])?.to_u32()?);
                 let f = match intrinsic_name.get() {
                     "sinf32" => f.sin(),
                     "fabsf32" => f.abs(),
@@ -202,12 +203,13 @@ pub trait EvalContextExt<'a, 'mir, 'tcx: 'a+'mir>: crate::MiriEvalContextExt<'a,
                     "truncf32" => f.trunc(),
                     _ => bug!(),
                 };
-                this.write_scalar(Scalar::from_f32(f), dest)?;
+                this.write_scalar(Scalar::from_u32(f.to_bits()), dest)?;
             }
 
             "sinf64" | "fabsf64" | "cosf64" | "sqrtf64" | "expf64" | "exp2f64" | "logf64" |
             "log10f64" | "log2f64" | "floorf64" | "ceilf64" | "truncf64" => {
-                let f = this.read_scalar(args[0])?.to_f64()?;
+                // FIXME: Using host floats.
+                let f = f64::from_bits(this.read_scalar(args[0])?.to_u64()?);
                 let f = match intrinsic_name.get() {
                     "sinf64" => f.sin(),
                     "fabsf64" => f.abs(),
@@ -223,7 +225,7 @@ pub trait EvalContextExt<'a, 'mir, 'tcx: 'a+'mir>: crate::MiriEvalContextExt<'a,
                     "truncf64" => f.trunc(),
                     _ => bug!(),
                 };
-                this.write_scalar(Scalar::from_f64(f), dest)?;
+                this.write_scalar(Scalar::from_u64(f.to_bits()), dest)?;
             }
 
             "fadd_fast" | "fsub_fast" | "fmul_fast" | "fdiv_fast" | "frem_fast" => {
@@ -320,19 +322,21 @@ pub trait EvalContextExt<'a, 'mir, 'tcx: 'a+'mir>: crate::MiriEvalContextExt<'a,
             }
 
             "powf32" => {
-                let f = this.read_scalar(args[0])?.to_f32()?;
-                let f2 = this.read_scalar(args[1])?.to_f32()?;
+                // FIXME: Using host floats.
+                let f = f32::from_bits(this.read_scalar(args[0])?.to_u32()?);
+                let f2 = f32::from_bits(this.read_scalar(args[1])?.to_u32()?);
                 this.write_scalar(
-                    Scalar::from_f32(f.powf(f2)),
+                    Scalar::from_u32(f.powf(f2).to_bits()),
                     dest,
                 )?;
             }
 
             "powf64" => {
-                let f = this.read_scalar(args[0])?.to_f64()?;
-                let f2 = this.read_scalar(args[1])?.to_f64()?;
+                // FIXME: Using host floats.
+                let f = f64::from_bits(this.read_scalar(args[0])?.to_u64()?);
+                let f2 = f64::from_bits(this.read_scalar(args[1])?.to_u64()?);
                 this.write_scalar(
-                    Scalar::from_f64(f.powf(f2)),
+                    Scalar::from_u64(f.powf(f2).to_bits()),
                     dest,
                 )?;
             }
@@ -341,8 +345,9 @@ pub trait EvalContextExt<'a, 'mir, 'tcx: 'a+'mir>: crate::MiriEvalContextExt<'a,
                 let a = this.read_scalar(args[0])?.to_f32()?;
                 let b = this.read_scalar(args[1])?.to_f32()?;
                 let c = this.read_scalar(args[2])?.to_f32()?;
+                let res = (a*b).value + c;
                 this.write_scalar(
-                    Scalar::from_f32(a * b + c),
+                    Scalar::from_f32(res.value),
                     dest,
                 )?;
             }
@@ -351,26 +356,29 @@ pub trait EvalContextExt<'a, 'mir, 'tcx: 'a+'mir>: crate::MiriEvalContextExt<'a,
                 let a = this.read_scalar(args[0])?.to_f64()?;
                 let b = this.read_scalar(args[1])?.to_f64()?;
                 let c = this.read_scalar(args[2])?.to_f64()?;
+                let res = (a*b).value + c;
                 this.write_scalar(
-                    Scalar::from_f64(a * b + c),
+                    Scalar::from_f64(res.value),
                     dest,
                 )?;
             }
 
             "powif32" => {
-                let f = this.read_scalar(args[0])?.to_f32()?;
+                // FIXME: Using host floats.
+                let f = f32::from_bits(this.read_scalar(args[0])?.to_u32()?);
                 let i = this.read_scalar(args[1])?.to_i32()?;
                 this.write_scalar(
-                    Scalar::from_f32(f.powi(i)),
+                    Scalar::from_u32(f.powi(i).to_bits()),
                     dest,
                 )?;
             }
 
             "powif64" => {
-                let f = this.read_scalar(args[0])?.to_f64()?;
+                // FIXME: Using host floats.
+                let f = f64::from_bits(this.read_scalar(args[0])?.to_u64()?);
                 let i = this.read_scalar(args[1])?.to_i32()?;
                 this.write_scalar(
-                    Scalar::from_f64(f.powi(i)),
+                    Scalar::from_u64(f.powi(i).to_bits()),
                     dest,
                 )?;
             }