Initial implementation of powi

Author: mattico

README.md

@@ -159,8 +159,8 @@ porting that particular intrinsic.
 - [x] mulodi4.c
 - [x] mulosi4.c
 - [ ] mulsf3.c
-- [ ] powidf2.c
-- [ ] powisf2.c
+- [x] powidf2.c
+- [x] powisf2.c
 - [ ] subdf3.c
 - [ ] subsf3.c
 - [ ] truncdfhf2.c

compiler-rt/compiler-rt-cdylib/build.rs

@@ -58,6 +58,8 @@ fn main() {
         "udivmodsi4.c",
         "adddf3.c",
         "addsf3.c",
+        "powidf2.c",
+        "powisf2.c",
     ]);
 
     for src in sources.files.iter() {

compiler-rt/compiler-rt-cdylib/src/lib.rs

@@ -22,6 +22,8 @@ extern {
     fn __umodsi3();
     fn __addsf3();
     fn __adddf3();
+    fn __powisf2();
+    fn __powidf2();
 }
 
 macro_rules! declare {
@@ -53,6 +55,8 @@ declare!(___umoddi3, __umoddi3);
 declare!(___umodsi3, __umodsi3);
 declare!(___addsf3, __addsf3);
 declare!(___adddf3, __adddf3);
+declare!(___powisf2, __powisf2);
+declare!(___powidf2, __powidf2);
 
 #[lang = "eh_personality"]
 fn eh_personality() {}

src/float/add.rs

@@ -190,40 +190,18 @@ mod tests {
     use float::Float;
     use qc::{F32, F64};
 
-    // NOTE The tests below have special handing for NaN values.
-    // Because NaN != NaN, the floating-point representations must be used
-    // Because there are many diffferent values of NaN, and the implementation
-    // doesn't care about calculating the 'correct' one, if both values are NaN
-    // the values are considered equivalent.
-
-    struct FRepr<F>(F);
-
-    impl<F: Float> PartialEq for FRepr<F> {
-        fn eq(&self, other: &FRepr<F>) -> bool {
-            // NOTE(cfg) for some reason, on hard float targets, our implementation doesn't
-            // match the output of its gcc_s counterpart. Until we investigate further, we'll
-            // just avoid testing against gcc_s on those targets. Do note that our
-            // implementation matches the output of the FPU instruction on *hard* float targets
-            // and matches its gcc_s counterpart on *soft* float targets.
-            if cfg!(gnueabihf) {
-                return true
-            }
-            self.0.eq_repr(other.0)
-        }
-    }
-
     check! {
         fn __addsf3(f: extern fn(f32, f32) -> f32,
                     a: F32,
                     b: F32)
-                    -> Option<FRepr<f32> > {
-            Some(FRepr(f(a.0, b.0)))
+                    -> Option<F32> {
+            Some(F32(f(a.0, b.0)))
         }
 
         fn __adddf3(f: extern fn(f64, f64) -> f64,
                     a: F64,
-                    b: F64) -> Option<FRepr<f64> > {
-            Some(FRepr(f(a.0, b.0)))
+                    b: F64) -> Option<F64> {
+            Some(F64(f(a.0, b.0)))
         }
     }
 }

src/float/mod.rs

@@ -1,6 +1,7 @@
 use core::mem;
 
 pub mod add;
+pub mod pow;
 
 /// Trait for some basic operations on floats
 pub trait Float: Sized + Copy {

src/float/pow.rs

@@ -0,0 +1,48 @@
+
+macro_rules! pow {
+    ($intrinsic:ident: $fty:ty, $ity:ty) => {
+        /// Returns `a` raised to the power `b`
+        #[cfg_attr(not(test), no_mangle)]
+        pub extern "C" fn $intrinsic(a: $fty, b: $ity) -> $fty {
+            let (mut a, mut b) = (a, b);
+            let recip = b < 0;
+            let mut r: $fty = 1.0;
+            loop {
+                if (b & 1) != 0 {
+                    r *= a;
+                }
+                b /= 2;
+                if b == 0 {
+                    break;
+                }
+                a *= a;
+            }
+
+            if recip {
+                1.0 / r
+            } else {
+                r
+            }
+        }
+    }
+}
+
+pow!(__powisf2: f32, i32);
+pow!(__powidf2: f64, i32);
+
+#[cfg(test)]
+mod tests {
+    use qc::{I32, F32, F64};
+
+    check! {
+        fn __powisf2(f: extern fn(f32, i32) -> f32, a: F32, b: I32) -> Option<F32> {
+            let (a, b) = (a.0, b.0);
+            Some(F32(f(a, b)))
+        }
+
+        fn __powidf2(f: extern fn(f64, i32) -> f64, a: F64, b: I32) -> Option<F64> {
+            let (a, b) = (a.0, b.0);
+            Some(F64(f(a, b)))
+        }
+    }
+}

src/qc.rs

@@ -190,6 +190,20 @@ macro_rules! arbitrary_float {
                 fmt::Debug::fmt(&self.0, f)
             }
         }
+
+        impl PartialEq for $TY  {
+            fn eq(&self, other: &Self) -> bool {
+                // NOTE(cfg) for some reason, on hard float targets, our implementation doesn't
+                // match the output of its gcc_s counterpart. Until we investigate further, we'll
+                // just avoid testing against gcc_s on those targets. Do note that our
+                // implementation matches the output of the FPU instruction on *hard* float targets
+                // and matches its gcc_s counterpart on *soft* float targets.
+                if cfg!(gnueabihf) {
+                    return true
+                }
+                self.0.eq_repr(other.0)
+            }
+        }
     }
 }