adjust the check! macro to accept AAPCS intrinsics

Jorge Aparicio · Jorge Aparicio · commit 47b45d1d62ab · 2017-02-07T23:07:51.000-05:00
diff --git a/src/float/add.rs b/src/float/add.rs
@@ -203,14 +203,14 @@ mod tests {
     use qc::{F32, F64};
 
     check! {
-        fn __addsf3(f: extern fn(f32, f32) -> f32,
+        fn __addsf3(f: extern "C" fn(f32, f32) -> f32,
                     a: F32,
                     b: F32)
                     -> Option<F32> {
             Some(F32(f(a.0, b.0)))
         }
 
-        fn __adddf3(f: extern fn(f64, f64) -> f64,
+        fn __adddf3(f: extern "C" fn(f64, f64) -> f64,
                     a: F64,
                     b: F64) -> Option<F64> {
             Some(F64(f(a.0, b.0)))
diff --git a/src/float/pow.rs b/src/float/pow.rs
@@ -34,13 +34,13 @@ mod tests {
     use qc::{I32, F32, F64};
 
     check! {
-        fn __powisf2(f: extern fn(f32, i32) -> f32, 
+        fn __powisf2(f: extern "C" fn(f32, i32) -> f32,
                      a: F32,
                      b: I32) -> Option<F32> {
             Some(F32(f(a.0, b.0)))
         }
 
-        fn __powidf2(f: extern fn(f64, i32) -> f64, 
+        fn __powidf2(f: extern "C" fn(f64, i32) -> f64,
                      a: F64,
                      b: I32) -> Option<F64> {
             Some(F64(f(a.0, b.0)))
diff --git a/src/int/mul.rs b/src/int/mul.rs
@@ -99,12 +99,12 @@ mod tests {
     use qc::{I32, I64, U64};
 
     check! {
-        fn __muldi3(f: extern fn(u64, u64) -> u64, a: U64, b: U64)
+        fn __muldi3(f: extern "C" fn(u64, u64) -> u64, a: U64, b: U64)
                     -> Option<u64> {
             Some(f(a.0, b.0))
         }
 
-        fn __mulosi4(f: extern fn(i32, i32, &mut i32) -> i32,
+        fn __mulosi4(f: extern "C" fn(i32, i32, &mut i32) -> i32,
                      a: I32,
                      b: I32) -> Option<(i32, i32)> {
             let (a, b) = (a.0, b.0);
@@ -116,7 +116,7 @@ mod tests {
             Some((r, overflow))
         }
 
-        fn __mulodi4(f: extern fn(i64, i64, &mut i32) -> i64,
+        fn __mulodi4(f: extern "C" fn(i64, i64, &mut i32) -> i64,
                      a: I64,
                      b: I64) -> Option<(i64, i32)> {
             let (a, b) = (a.0, b.0);
@@ -139,11 +139,11 @@ mod tests_i128 {
     use qc::I128;
 
     check! {
-        fn __multi3(f: extern fn(i128, i128) -> i128, a: I128, b: I128)
+        fn __multi3(f: extern "C" fn(i128, i128) -> i128, a: I128, b: I128)
                     -> Option<i128> {
             Some(f(a.0, b.0))
         }
-        fn __muloti4(f: extern fn(i128, i128, &mut i32) -> i128,
+        fn __muloti4(f: extern "C" fn(i128, i128, &mut i32) -> i128,
                      a: I128,
                      b: I128) -> Option<(i128, i32)> {
             let (a, b) = (a.0, b.0);
diff --git a/src/int/sdiv.rs b/src/int/sdiv.rs
@@ -99,7 +99,7 @@ mod tests {
     use qc::{U32, U64};
 
     check! {
-        fn __divdi3(f: extern fn(i64, i64) -> i64, n: U64, d: U64) -> Option<i64> {
+        fn __divdi3(f: extern "C" fn(i64, i64) -> i64, n: U64, d: U64) -> Option<i64> {
             let (n, d) = (n.0 as i64, d.0 as i64);
             if d == 0 {
                 None
@@ -108,7 +108,7 @@ mod tests {
             }
         }
 
-        fn __moddi3(f: extern fn(i64, i64) -> i64, n: U64, d: U64) -> Option<i64> {
+        fn __moddi3(f: extern "C" fn(i64, i64) -> i64, n: U64, d: U64) -> Option<i64> {
             let (n, d) = (n.0 as i64, d.0 as i64);
             if d == 0 {
                 None
@@ -117,7 +117,8 @@ mod tests {
             }
         }
 
-        fn __divmoddi4(f: extern fn(i64, i64, &mut i64) -> i64,
+        #[cfg(target_arch = "arm")]
+        fn __divmoddi4(f: extern "aapcs" fn(i64, i64, &mut i64) -> i64,
                        n: U64,
                        d: U64) -> Option<(i64, i64)> {
             let (n, d) = (n.0 as i64, d.0 as i64);
@@ -130,7 +131,21 @@ mod tests {
             }
         }
 
-        fn __divsi3(f: extern fn(i32, i32) -> i32,
+        #[cfg(not(target_arch = "arm"))]
+        fn __divmoddi4(f: extern "C" fn(i64, i64, &mut i64) -> i64,
+                       n: U64,
+                       d: U64) -> Option<(i64, i64)> {
+            let (n, d) = (n.0 as i64, d.0 as i64);
+            if d == 0 {
+                None
+            } else {
+                let mut r = 0;
+                let q = f(n, d, &mut r);
+                Some((q, r))
+            }
+        }
+
+        fn __divsi3(f: extern "C" fn(i32, i32) -> i32,
                     n: U32,
                     d: U32) -> Option<i32> {
             let (n, d) = (n.0 as i32, d.0 as i32);
@@ -141,7 +156,7 @@ mod tests {
             }
         }
 
-        fn __modsi3(f: extern fn(i32, i32) -> i32,
+        fn __modsi3(f: extern "C" fn(i32, i32) -> i32,
                     n: U32,
                     d: U32) -> Option<i32> {
             let (n, d) = (n.0 as i32, d.0 as i32);
@@ -152,7 +167,7 @@ mod tests {
             }
         }
 
-        fn __divmodsi4(f: extern fn(i32, i32, &mut i32) -> i32,
+        fn __divmodsi4(f: extern "C" fn(i32, i32, &mut i32) -> i32,
                        n: U32,
                        d: U32) -> Option<(i32, i32)> {
             let (n, d) = (n.0 as i32, d.0 as i32);
@@ -176,7 +191,7 @@ mod tests_i128 {
     use qc::U128;
     check! {
 
-        fn __divti3(f: extern fn(i128, i128) -> i128, n: U128, d: U128) -> Option<i128> {
+        fn __divti3(f: extern "C" fn(i128, i128) -> i128, n: U128, d: U128) -> Option<i128> {
             let (n, d) = (n.0 as i128, d.0 as i128);
             if d == 0 {
                 None
@@ -185,7 +200,7 @@ mod tests_i128 {
             }
         }
 
-        fn __modti3(f: extern fn(i128, i128) -> i128, n: U128, d: U128) -> Option<i128> {
+        fn __modti3(f: extern "C" fn(i128, i128) -> i128, n: U128, d: U128) -> Option<i128> {
             let (n, d) = (n.0 as i128, d.0 as i128);
             if d == 0 {
                 None
diff --git a/src/int/shift.rs b/src/int/shift.rs
@@ -79,7 +79,7 @@ mod tests {
 
     // NOTE We purposefully stick to `u32` for `b` here because we want "small" values (b < 64)
     check! {
-        fn __ashldi3(f: extern fn(u64, u32) -> u64, a: U64, b: u32) -> Option<u64> {
+        fn __ashldi3(f: extern "C" fn(u64, u32) -> u64, a: U64, b: u32) -> Option<u64> {
             let a = a.0;
             if b >= 64 {
                 None
@@ -88,7 +88,7 @@ mod tests {
             }
         }
 
-        fn __ashrdi3(f: extern fn(i64, u32) -> i64, a: I64, b: u32) -> Option<i64> {
+        fn __ashrdi3(f: extern "C" fn(i64, u32) -> i64, a: I64, b: u32) -> Option<i64> {
             let a = a.0;
             if b >= 64 {
                 None
@@ -97,7 +97,7 @@ mod tests {
             }
         }
 
-        fn __lshrdi3(f: extern fn(u64, u32) -> u64, a: U64, b: u32) -> Option<u64> {
+        fn __lshrdi3(f: extern "C" fn(u64, u32) -> u64, a: U64, b: u32) -> Option<u64> {
             let a = a.0;
             if b >= 64 {
                 None
@@ -118,7 +118,7 @@ mod tests_i128 {
 
     // NOTE We purposefully stick to `u32` for `b` here because we want "small" values (b < 64)
     check! {
-        fn __ashlti3(f: extern fn(u128, u32) -> u128, a: U128, b: u32) -> Option<u128> {
+        fn __ashlti3(f: extern "C" fn(u128, u32) -> u128, a: U128, b: u32) -> Option<u128> {
             let a = a.0;
             if b >= 64 {
                 None
@@ -127,7 +127,7 @@ mod tests_i128 {
             }
         }
 
-        fn __ashrti3(f: extern fn(i128, u32) -> i128, a: I128, b: u32) -> Option<i128> {
+        fn __ashrti3(f: extern "C" fn(i128, u32) -> i128, a: I128, b: u32) -> Option<i128> {
             let a = a.0;
             if b >= 64 {
                 None
@@ -136,7 +136,7 @@ mod tests_i128 {
             }
         }
 
-        fn __lshrti3(f: extern fn(u128, u32) -> u128, a: U128, b: u32) -> Option<u128> {
+        fn __lshrti3(f: extern "C" fn(u128, u32) -> u128, a: U128, b: u32) -> Option<u128> {
             let a = a.0;
             if b >= 128 {
                 None
diff --git a/src/int/udiv.rs b/src/int/udiv.rs
@@ -318,7 +318,7 @@ mod tests {
     use qc::{U32, U64};
 
     check! {
-        fn __udivdi3(f: extern fn(u64, u64) -> u64, n: U64, d: U64) -> Option<u64> {
+        fn __udivdi3(f: extern "C" fn(u64, u64) -> u64, n: U64, d: U64) -> Option<u64> {
             let (n, d) = (n.0, d.0);
             if d == 0 {
                 None
@@ -327,7 +327,7 @@ mod tests {
             }
         }
 
-        fn __umoddi3(f: extern fn(u64, u64) -> u64, n: U64, d: U64) -> Option<u64> {
+        fn __umoddi3(f: extern "C" fn(u64, u64) -> u64, n: U64, d: U64) -> Option<u64> {
             let (n, d) = (n.0, d.0);
             if d == 0 {
                 None
@@ -336,7 +336,7 @@ mod tests {
             }
         }
 
-        fn __udivmoddi4(f: extern fn(u64, u64, Option<&mut u64>) -> u64,
+        fn __udivmoddi4(f: extern "C" fn(u64, u64, Option<&mut u64>) -> u64,
                         n: U64,
                         d: U64) -> Option<(u64, u64)> {
             let (n, d) = (n.0, d.0);
@@ -349,7 +349,7 @@ mod tests {
             }
         }
 
-        fn __udivsi3(f: extern fn(u32, u32) -> u32, n: U32, d: U32) -> Option<u32> {
+        fn __udivsi3(f: extern "C" fn(u32, u32) -> u32, n: U32, d: U32) -> Option<u32> {
             let (n, d) = (n.0, d.0);
             if d == 0 {
                 None
@@ -358,7 +358,7 @@ mod tests {
             }
         }
 
-        fn __umodsi3(f: extern fn(u32, u32) -> u32, n: U32, d: U32) -> Option<u32> {
+        fn __umodsi3(f: extern "C" fn(u32, u32) -> u32, n: U32, d: U32) -> Option<u32> {
             let (n, d) = (n.0, d.0);
             if d == 0 {
                 None
@@ -367,7 +367,7 @@ mod tests {
             }
         }
 
-        fn __udivmodsi4(f: extern fn(u32, u32, Option<&mut u32>) -> u32,
+        fn __udivmodsi4(f: extern "C" fn(u32, u32, Option<&mut u32>) -> u32,
                         n: U32,
                         d: U32) -> Option<(u32, u32)> {
             let (n, d) = (n.0, d.0);
@@ -391,7 +391,7 @@ mod tests_i128 {
     use qc::U128;
 
     check! {
-        fn __udivti3(f: extern fn(u128, u128) -> u128,
+        fn __udivti3(f: extern "C" fn(u128, u128) -> u128,
                      n: U128,
                      d: U128) -> Option<u128> {
             let (n, d) = (n.0, d.0);
@@ -402,7 +402,7 @@ mod tests_i128 {
             }
         }
 
-        fn __umodti3(f: extern fn(u128, u128) -> u128,
+        fn __umodti3(f: extern "C" fn(u128, u128) -> u128,
                      n: U128,
                      d: U128) -> Option<u128> {
             let (n, d) = (n.0, d.0);
@@ -413,7 +413,7 @@ mod tests_i128 {
             }
         }
 
-        fn __udivmodti4(f: extern fn(u128, u128, Option<&mut u128>) -> u128,
+        fn __udivmodti4(f: extern "C" fn(u128, u128, Option<&mut u128>) -> u128,
                         n: U128,
                         d: U128) -> Option<u128> {
             let (n, d) = (n.0, d.0);
diff --git a/src/qc.rs b/src/qc.rs
@@ -240,15 +240,17 @@ arbitrary_float!(F64: f64);
 // fails.
 macro_rules! check {
     ($(
-        fn $name:ident($f:ident: extern fn($($farg:ty),*) -> $fret:ty,
+        $(#[$cfg:meta])*
+        fn $name:ident($f:ident: extern $abi:tt fn($($farg:ty),*) -> $fret:ty,
                        $($arg:ident: $t:ty),*)
                        -> Option<$ret:ty>
         {
             $($code:tt)*
         }
     )*) => (
         $(
-            fn $name($f: extern fn($($farg),*) -> $fret,
+            $(#[$cfg])*
+            fn $name($f: extern $abi fn($($farg),*) -> $fret,
                      $($arg: $t),*) -> Option<$ret> {
                 $($code)*
             }
@@ -260,6 +262,7 @@ macro_rules! check {
             use quickcheck::TestResult;
 
             $(
+                $(#[$cfg])*
                 #[test]
                 fn $name() {
                     fn my_check($($arg:$t),*) -> TestResult {

Original file line number	Diff line number	Diff line change
`@@ -79,7 +79,7 @@ mod tests {`
`79`	`79`
`80`	`80`	// NOTE We purposefully stick to `u32` for `b` here because we want "small" values (b < 64)
`81`	`81`	`check! {`
`82`		`- fn __ashldi3(f: extern fn(u64, u32) -> u64, a: U64, b: u32) -> Option<u64> {`
	`82`	`+ fn __ashldi3(f: extern "C" fn(u64, u32) -> u64, a: U64, b: u32) -> Option<u64> {`
`83`	`83`	`let a = a.0;`
`84`	`84`	`if b >= 64 {`
`85`	`85`	`None`
`@@ -88,7 +88,7 @@ mod tests {`
`88`	`88`	`}`
`89`	`89`	`}`
`90`	`90`
`91`		`- fn __ashrdi3(f: extern fn(i64, u32) -> i64, a: I64, b: u32) -> Option<i64> {`
	`91`	`+ fn __ashrdi3(f: extern "C" fn(i64, u32) -> i64, a: I64, b: u32) -> Option<i64> {`
`92`	`92`	`let a = a.0;`
`93`	`93`	`if b >= 64 {`
`94`	`94`	`None`
`@@ -97,7 +97,7 @@ mod tests {`
`97`	`97`	`}`
`98`	`98`	`}`
`99`	`99`
`100`		`- fn __lshrdi3(f: extern fn(u64, u32) -> u64, a: U64, b: u32) -> Option<u64> {`
	`100`	`+ fn __lshrdi3(f: extern "C" fn(u64, u32) -> u64, a: U64, b: u32) -> Option<u64> {`
`101`	`101`	`let a = a.0;`
`102`	`102`	`if b >= 64 {`
`103`	`103`	`None`
`@@ -118,7 +118,7 @@ mod tests_i128 {`
`118`	`118`
`119`	`119`	// NOTE We purposefully stick to `u32` for `b` here because we want "small" values (b < 64)
`120`	`120`	`check! {`
`121`		`- fn __ashlti3(f: extern fn(u128, u32) -> u128, a: U128, b: u32) -> Option<u128> {`
	`121`	`+ fn __ashlti3(f: extern "C" fn(u128, u32) -> u128, a: U128, b: u32) -> Option<u128> {`
`122`	`122`	`let a = a.0;`
`123`	`123`	`if b >= 64 {`
`124`	`124`	`None`
`@@ -127,7 +127,7 @@ mod tests_i128 {`
`127`	`127`	`}`
`128`	`128`	`}`
`129`	`129`
`130`		`- fn __ashrti3(f: extern fn(i128, u32) -> i128, a: I128, b: u32) -> Option<i128> {`
	`130`	`+ fn __ashrti3(f: extern "C" fn(i128, u32) -> i128, a: I128, b: u32) -> Option<i128> {`
`131`	`131`	`let a = a.0;`
`132`	`132`	`if b >= 64 {`
`133`	`133`	`None`
`@@ -136,7 +136,7 @@ mod tests_i128 {`
`136`	`136`	`}`
`137`	`137`	`}`
`138`	`138`
`139`		`- fn __lshrti3(f: extern fn(u128, u32) -> u128, a: U128, b: u32) -> Option<u128> {`
	`139`	`+ fn __lshrti3(f: extern "C" fn(u128, u32) -> u128, a: U128, b: u32) -> Option<u128> {`
`140`	`140`	`let a = a.0;`
`141`	`141`	`if b >= 128 {`
`142`	`142`	`None`
Original file line number	Diff line number	Diff line change
`@@ -318,7 +318,7 @@ mod tests {`
`318`	`318`	`use qc::{U32, U64};`
`319`	`319`
`320`	`320`	`check! {`
`321`		`- fn __udivdi3(f: extern fn(u64, u64) -> u64, n: U64, d: U64) -> Option<u64> {`
	`321`	`+ fn __udivdi3(f: extern "C" fn(u64, u64) -> u64, n: U64, d: U64) -> Option<u64> {`
`322`	`322`	`let (n, d) = (n.0, d.0);`
`323`	`323`	`if d == 0 {`
`324`	`324`	`None`
`@@ -327,7 +327,7 @@ mod tests {`
`327`	`327`	`}`
`328`	`328`	`}`
`329`	`329`
`330`		`- fn __umoddi3(f: extern fn(u64, u64) -> u64, n: U64, d: U64) -> Option<u64> {`
	`330`	`+ fn __umoddi3(f: extern "C" fn(u64, u64) -> u64, n: U64, d: U64) -> Option<u64> {`
`331`	`331`	`let (n, d) = (n.0, d.0);`
`332`	`332`	`if d == 0 {`
`333`	`333`	`None`
`@@ -336,7 +336,7 @@ mod tests {`
`336`	`336`	`}`
`337`	`337`	`}`
`338`	`338`
`339`		`- fn __udivmoddi4(f: extern fn(u64, u64, Option<&mut u64>) -> u64,`
	`339`	`+ fn __udivmoddi4(f: extern "C" fn(u64, u64, Option<&mut u64>) -> u64,`
`340`	`340`	`n: U64,`
`341`	`341`	`d: U64) -> Option<(u64, u64)> {`
`342`	`342`	`let (n, d) = (n.0, d.0);`
`@@ -349,7 +349,7 @@ mod tests {`
`349`	`349`	`}`
`350`	`350`	`}`
`351`	`351`
`352`		`- fn __udivsi3(f: extern fn(u32, u32) -> u32, n: U32, d: U32) -> Option<u32> {`
	`352`	`+ fn __udivsi3(f: extern "C" fn(u32, u32) -> u32, n: U32, d: U32) -> Option<u32> {`
`353`	`353`	`let (n, d) = (n.0, d.0);`
`354`	`354`	`if d == 0 {`
`355`	`355`	`None`
`@@ -358,7 +358,7 @@ mod tests {`
`358`	`358`	`}`
`359`	`359`	`}`
`360`	`360`
`361`		`- fn __umodsi3(f: extern fn(u32, u32) -> u32, n: U32, d: U32) -> Option<u32> {`
	`361`	`+ fn __umodsi3(f: extern "C" fn(u32, u32) -> u32, n: U32, d: U32) -> Option<u32> {`
`362`	`362`	`let (n, d) = (n.0, d.0);`
`363`	`363`	`if d == 0 {`
`364`	`364`	`None`
`@@ -367,7 +367,7 @@ mod tests {`
`367`	`367`	`}`
`368`	`368`	`}`
`369`	`369`
`370`		`- fn __udivmodsi4(f: extern fn(u32, u32, Option<&mut u32>) -> u32,`
	`370`	`+ fn __udivmodsi4(f: extern "C" fn(u32, u32, Option<&mut u32>) -> u32,`
`371`	`371`	`n: U32,`
`372`	`372`	`d: U32) -> Option<(u32, u32)> {`
`373`	`373`	`let (n, d) = (n.0, d.0);`
`@@ -391,7 +391,7 @@ mod tests_i128 {`
`391`	`391`	`use qc::U128;`
`392`	`392`
`393`	`393`	`check! {`
`394`		`- fn __udivti3(f: extern fn(u128, u128) -> u128,`
	`394`	`+ fn __udivti3(f: extern "C" fn(u128, u128) -> u128,`
`395`	`395`	`n: U128,`
`396`	`396`	`d: U128) -> Option<u128> {`
`397`	`397`	`let (n, d) = (n.0, d.0);`
`@@ -402,7 +402,7 @@ mod tests_i128 {`
`402`	`402`	`}`
`403`	`403`	`}`
`404`	`404`
`405`		`- fn __umodti3(f: extern fn(u128, u128) -> u128,`
	`405`	`+ fn __umodti3(f: extern "C" fn(u128, u128) -> u128,`
`406`	`406`	`n: U128,`
`407`	`407`	`d: U128) -> Option<u128> {`
`408`	`408`	`let (n, d) = (n.0, d.0);`
`@@ -413,7 +413,7 @@ mod tests_i128 {`
`413`	`413`	`}`
`414`	`414`	`}`
`415`	`415`
`416`		`- fn __udivmodti4(f: extern fn(u128, u128, Option<&mut u128>) -> u128,`
	`416`	`+ fn __udivmodti4(f: extern "C" fn(u128, u128, Option<&mut u128>) -> u128,`
`417`	`417`	`n: U128,`
`418`	`418`	`d: U128) -> Option<u128> {`
`419`	`419`	`let (n, d) = (n.0, d.0);`