auto merge of #5724 : JensNockert/rust/remove-intrinsics, r=brson

I am not convinced that this is a great idea, but I wanted to throw this out here since I noticed it was possible to save a few hundred lines of code with no reduction in functionality.

The main ideas of this commit is to remove most of the special implementation for llvm-intrinsics in src/librustc/middle/trans/base.rs and friends, and instead declare them as semi-standard functions instead with a combination of attributes instead.

In the end, this means that the compiler doesn't need to know about every intrinsic and we only need to provide definitions for the ones we use in the core/std library and users can provide the rest if they need them.

Author: bors

src/libcore/num/f32.rs

@@ -16,7 +16,7 @@ use num::NumCast;
 use num::strconv;
 use num;
 use option::Option;
-use unstable::intrinsics::floorf32;
+use unstable::intrinsics;
 use from_str;
 use to_str;
 
@@ -93,7 +93,6 @@ delegate!(fn ldexp_radix(n: c_float, i: c_int) -> c_float =
     cmath::c_float_utils::ldexp_radix)
 delegate!(fn sin(n: c_float) -> c_float = cmath::c_float_utils::sin)
 delegate!(fn sinh(n: c_float) -> c_float = cmath::c_float_utils::sinh)
-delegate!(fn sqrt(n: c_float) -> c_float = cmath::c_float_utils::sqrt)
 delegate!(fn tan(n: c_float) -> c_float = cmath::c_float_utils::tan)
 delegate!(fn tanh(n: c_float) -> c_float = cmath::c_float_utils::tanh)
 delegate!(fn tgamma(n: c_float) -> c_float = cmath::c_float_utils::tgamma)
@@ -146,7 +145,10 @@ pub fn gt(x: f32, y: f32) -> bool { return x > y; }
 
 /// Returns `x` rounded down
 #[inline(always)]
-pub fn floor(x: f32) -> f32 { unsafe { floorf32(x) } }
+pub fn floor(x: f32) -> f32 { unsafe { intrinsics::llvm::floorf32(x) } }
+
+#[inline(always)]
+pub fn sqrt(x: f32) -> f32 { unsafe { intrinsics::llvm::sqrtf32(x) } }
 
 // FIXME (#1999): replace the predicates below with llvm intrinsics or
 // calls to the libmath macros in the rust runtime for performance.

src/libcore/num/f64.rs

@@ -16,7 +16,7 @@ use num::NumCast;
 use num::strconv;
 use num;
 use option::Option;
-use unstable::intrinsics::floorf64;
+use unstable::intrinsics;
 use to_str;
 use from_str;
 
@@ -94,7 +94,6 @@ delegate!(fn ldexp_radix(n: c_double, i: c_int) -> c_double =
     cmath::c_double_utils::ldexp_radix)
 delegate!(fn sin(n: c_double) -> c_double = cmath::c_double_utils::sin)
 delegate!(fn sinh(n: c_double) -> c_double = cmath::c_double_utils::sinh)
-delegate!(fn sqrt(n: c_double) -> c_double = cmath::c_double_utils::sqrt)
 delegate!(fn tan(n: c_double) -> c_double = cmath::c_double_utils::tan)
 delegate!(fn tanh(n: c_double) -> c_double = cmath::c_double_utils::tanh)
 delegate!(fn tgamma(n: c_double) -> c_double = cmath::c_double_utils::tgamma)
@@ -221,7 +220,10 @@ pub fn is_finite(x: f64) -> bool {
 
 /// Returns `x` rounded down
 #[inline(always)]
-pub fn floor(x: f64) -> f64 { unsafe { floorf64(x) } }
+pub fn floor(x: f64) -> f64 { unsafe { intrinsics::llvm::floorf64(x) } }
+
+#[inline(always)]
+pub fn sqrt(x: f64) -> f64 { unsafe { intrinsics::llvm::sqrtf64(x) } }
 
 // FIXME (#1999): add is_normal, is_subnormal, and fpclassify
 

src/libcore/unstable/intrinsics.rs

@@ -63,69 +63,213 @@ pub extern "rust-intrinsic" {
 
     pub fn memmove32(dst: *mut u8, src: *u8, size: u32);
     pub fn memmove64(dst: *mut u8, src: *u8, size: u64);
+}
 
+#[nolink]
+pub extern mod llvm {
+    #[rust_stack]
+    #[inline(always)]
+    #[link_name="llvm.sqrt.f32"]
     pub fn sqrtf32(x: f32) -> f32;
+
+    #[rust_stack]
+    #[inline(always)]
+    #[link_name="llvm.sqrt.f64"]
     pub fn sqrtf64(x: f64) -> f64;
 
+    #[rust_stack]
+    #[inline(always)]
+    #[link_name="llvm.powi.f32"]
     pub fn powif32(a: f32, x: i32) -> f32;
+
+    #[rust_stack]
+    #[inline(always)]
+    #[link_name="llvm.powi.f64"]
     pub fn powif64(a: f64, x: i32) -> f64;
 
+    #[rust_stack]
+    #[inline(always)]
+    #[link_name="llvm.sin.f32"]
     pub fn sinf32(x: f32) -> f32;
+
+    #[rust_stack]
+    #[inline(always)]
+    #[link_name="llvm.sin.f64"]
     pub fn sinf64(x: f64) -> f64;
 
+    #[rust_stack]
+    #[inline(always)]
+    #[link_name="llvm.cos.f32"]
     pub fn cosf32(x: f32) -> f32;
+
+    #[rust_stack]
+    #[inline(always)]
+    #[link_name="llvm.cos.f64"]
     pub fn cosf64(x: f64) -> f64;
 
+    #[rust_stack]
+    #[inline(always)]
+    #[link_name="llvm.pow.f32"]
     pub fn powf32(a: f32, x: f32) -> f32;
+
+    #[rust_stack]
+    #[inline(always)]
+    #[link_name="llvm.pow.f64"]
     pub fn powf64(a: f64, x: f64) -> f64;
 
+    #[rust_stack]
+    #[inline(always)]
+    #[link_name="llvm.exp.f32"]
     pub fn expf32(x: f32) -> f32;
-    pub fn expf64(x: f64) -> f64;
 
-    pub fn exp2f32(x: f32) -> f32;
-    pub fn exp2f64(x: f64) -> f64;
+    #[rust_stack]
+    #[inline(always)]
+    #[link_name="llvm.exp.f64"]
+    pub fn expf64(x: f64) -> f64;
 
+    #[rust_stack]
+    #[inline(always)]
+    #[link_name="llvm.log.f32"]
     pub fn logf32(x: f32) -> f32;
+
+    #[rust_stack]
+    #[inline(always)]
+    #[link_name="llvm.log.f64"]
     pub fn logf64(x: f64) -> f64;
 
+    /* NOTE: Do these intrinsics even exist?
+    pub fn exp2f32(x: f32) -> f32;
+    pub fn exp2f64(x: f64) -> f64;
+
     pub fn log10f32(x: f32) -> f32;
     pub fn log10f64(x: f64) -> f64;
 
     pub fn log2f32(x: f32) -> f32;
     pub fn log2f64(x: f64) -> f64;
+    */
 
+    #[rust_stack]
+    #[inline(always)]
+    #[link_name="llvm.fma.f32"]
     pub fn fmaf32(a: f32, b: f32, c: f32) -> f32;
+
+    #[rust_stack]
+    #[inline(always)]
+    #[link_name="llvm.fma.f64"]
     pub fn fmaf64(a: f64, b: f64, c: f64) -> f64;
 
+    #[rust_stack]
+    #[inline(always)]
+    #[link_name="llvm.fabs.f32"]
     pub fn fabsf32(x: f32) -> f32;
+
+    #[rust_stack]
+    #[inline(always)]
+    #[link_name="llvm.fabs.f64"]
     pub fn fabsf64(x: f64) -> f64;
 
+    #[rust_stack]
+    #[inline(always)]
+    #[link_name="llvm.floor.f32"]
     pub fn floorf32(x: f32) -> f32;
+
+    #[rust_stack]
+    #[inline(always)]
+    #[link_name="llvm.floor.f64"]
     pub fn floorf64(x: f64) -> f64;
 
+    /* NOTE: Needs LLVM 3.3
+    #[rust_stack]
+    #[link_name="llvm.ceil.f32"]
     pub fn ceilf32(x: f32) -> f32;
+
+    #[rust_stack]
+    #[link_name="llvm.ceil.f64"]
     pub fn ceilf64(x: f64) -> f64;
 
+    #[rust_stack]
+    #[link_name="llvm.trunc.f32"]
     pub fn truncf32(x: f32) -> f32;
+
+    #[rust_stack]
+    #[link_name="llvm.trunc.f64"]
     pub fn truncf64(x: f64) -> f64;
+    */
 
+    #[rust_stack]
+    #[inline(always)]
+    #[link_name="llvm.ctpop.i8"]
     pub fn ctpop8(x: i8) -> i8;
+
+    #[rust_stack]
+    #[inline(always)]
+    #[link_name="llvm.ctpop.i16"]
     pub fn ctpop16(x: i16) -> i16;
-    pub fn ctpop32(x: i32) -> i32;
-    pub fn ctpop64(x: i64) -> i64;
 
-    pub fn ctlz8(x: i8) -> i8;
-    pub fn ctlz16(x: i16) -> i16;
-    pub fn ctlz32(x: i32) -> i32;
-    pub fn ctlz64(x: i64) -> i64;
+    #[rust_stack]
+    #[inline(always)]
+    #[link_name="llvm.ctpop.i32"]
+    pub fn ctpop32(x: i32) -> i32;
 
-    pub fn cttz8(x: i8) -> i8;
-    pub fn cttz16(x: i16) -> i16;
-    pub fn cttz32(x: i32) -> i32;
-    pub fn cttz64(x: i64) -> i64;
+    #[rust_stack]
+    #[inline(always)]
+    #[link_name="llvm.ctpop.i64"]
+    pub fn ctpop64(x: i64) -> i64;
 
+    /* NOTE: Needs i1 constants
+    #[rust_stack]
+    #[inline(always)]
+    #[link_name="llvm.ctlz.i8"]
+    pub fn ctlz8(x: i8, is_zero_undef: bool) -> i8;
+
+    #[rust_stack]
+    #[inline(always)]
+    #[link_name="llvm.ctlz.i16"]
+    pub fn ctlz16(x: i16, is_zero_undef: bool) -> i16;
+
+    #[rust_stack]
+    #[inline(always)]
+    #[link_name="llvm.ctlz.i32"]
+    pub fn ctlz32(x: i32, is_zero_undef: bool) -> i32;
+
+    #[rust_stack]
+    #[inline(always)]
+    #[link_name="llvm.ctlz.i64"]
+    pub fn ctlz64(x: i64, is_zero_undef: bool) -> i64;
+
+    #[rust_stack]
+    #[inline(always)]
+    #[link_name="llvm.cttz.i8"]
+    pub fn cttz8(x: i8, is_zero_undef: bool) -> i8;
+
+    #[rust_stack]
+    #[inline(always)]
+    #[link_name="llvm.cttz.i16"]
+    pub fn cttz16(x: i16, is_zero_undef: bool) -> i16;
+
+    #[rust_stack]
+    #[inline(always)]
+    #[link_name="llvm.cttz.i32"]
+    pub fn cttz32(x: i32, is_zero_undef: bool) -> i32;
+
+    #[rust_stack]
+    #[inline(always)]
+    #[link_name="llvm.cttz.i64"]
+    pub fn cttz64(x: i64, is_zero_undef: bool) -> i64;
+    */
+
+    #[rust_stack]
+    #[inline(always)]
+    #[link_name="llvm.bswap.i16"]
     pub fn bswap16(x: i16) -> i16;
+
+    #[rust_stack]
+    #[inline(always)]
+    #[link_name="llvm.bswap.i32"]
     pub fn bswap32(x: i32) -> i32;
+
+    #[rust_stack]
+    #[inline(always)]
+    #[link_name="llvm.bswap.i64"]
     pub fn bswap64(x: i64) -> i64;
 }
-