Add RDRAND feature

Author: Jethro Beekman

Cargo.toml

@@ -22,6 +22,7 @@ default = ["std"]
 std = ["libc"]
 box = [] # enable use of Box on not(std), requires alloc crate and feature
 vec = [] # enable use of Vec on not(std), requires collections crate and feature
+rdrand = []
 
 [dev-dependencies]
 log = "0.3.0"

src/lib.rs

@@ -244,6 +244,7 @@
 #![cfg_attr(not(feature="std"),no_std)]
 #![cfg_attr(all(feature="box",not(feature="std")),feature(alloc))]
 #![cfg_attr(all(feature="vec",not(feature="std")),feature(collections))]
+#![cfg_attr(feature="rdrand",feature(asm))]
 
 #[cfg(test)] #[macro_use] extern crate log;
 
@@ -252,16 +253,16 @@
 #[cfg(all(feature="box",not(feature="std")))] extern crate alloc;
 #[cfg(all(feature="vec",not(feature="std")))] extern crate collections;
 
-#[cfg(feature="std")] use core::cell::RefCell;
+#[cfg(all(feature="std",not(feature="rdrand")))] use core::cell::RefCell;
 use core::marker;
 use core::mem;
 #[cfg(feature="std")] use std::io;
-#[cfg(feature="std")] use std::rc::Rc;
+#[cfg(all(feature="std",not(feature="rdrand")))] use std::rc::Rc;
 use core::num::Wrapping as w;
 #[cfg(all(feature="box",not(feature="std")))] use alloc::boxed::Box;
 #[cfg(all(feature="vec",not(feature="std")))] use collections::vec::Vec;
 
-#[cfg(feature="std")] pub use os::OsRng;
+#[cfg(any(feature="std",feature="rdrand"))] pub use os::OsRng;
 
 pub use isaac::{IsaacRng, Isaac64Rng};
 pub use chacha::ChaChaRng;
@@ -279,7 +280,7 @@ pub mod isaac;
 pub mod chacha;
 pub mod reseeding;
 mod rand_impls;
-#[cfg(feature="std")] pub mod os;
+#[cfg(any(feature="std",feature="rdrand"))] pub mod os;
 #[cfg(any(feature="std",feature="core_io"))] pub mod read;
 
 #[allow(bad_style)]
@@ -822,7 +823,7 @@ impl StdRng {
     ///
     /// Reading the randomness from the OS may fail, and any error is
     /// propagated via the `io::Result` return value.
-    #[cfg(feature="std")]
+    #[cfg(any(feature="std",feature="rdrand"))]
     pub fn new() -> io::Result<StdRng> {
         OsRng::new().map(|mut r| StdRng { rng: r.gen() })
     }
@@ -861,7 +862,7 @@ impl<'a> SeedableRng<&'a [usize]> for StdRng {
 ///
 /// This will read randomness from the operating system to seed the
 /// generator.
-#[cfg(feature="std")]
+#[cfg(any(feature="std",feature="rdrand"))]
 pub fn weak_rng() -> XorShiftRng {
     match OsRng::new() {
         Ok(mut r) => r.gen(),
@@ -870,10 +871,10 @@ pub fn weak_rng() -> XorShiftRng {
 }
 
 /// Controls how the thread-local RNG is reseeded.
-#[cfg(feature="std")]
+#[cfg(all(feature="std",not(feature="rdrand")))]
 struct ThreadRngReseeder;
 
-#[cfg(feature="std")]
+#[cfg(all(feature="std",not(feature="rdrand")))]
 impl reseeding::Reseeder<StdRng> for ThreadRngReseeder {
     fn reseed(&mut self, rng: &mut StdRng) {
         *rng = match StdRng::new() {
@@ -882,14 +883,14 @@ impl reseeding::Reseeder<StdRng> for ThreadRngReseeder {
         }
     }
 }
-#[cfg(feature="std")]
+#[cfg(all(feature="std",not(feature="rdrand")))]
 const THREAD_RNG_RESEED_THRESHOLD: u64 = 32_768;
-#[cfg(feature="std")]
+#[cfg(all(feature="std",not(feature="rdrand")))]
 type ThreadRngInner = reseeding::ReseedingRng<StdRng, ThreadRngReseeder>;
 
 /// The thread-local RNG.
+#[cfg(all(feature="std",not(feature="rdrand")))]
 #[derive(Clone)]
-#[cfg(feature="std")]
 pub struct ThreadRng {
     rng: Rc<RefCell<ThreadRngInner>>,
 }
@@ -905,7 +906,7 @@ pub struct ThreadRng {
 /// if the operating system random number generator is rigged to give
 /// the same sequence always. If absolute consistency is required,
 /// explicitly select an RNG, e.g. `IsaacRng` or `Isaac64Rng`.
-#[cfg(feature="std")]
+#[cfg(all(feature="std",not(feature="rdrand")))]
 pub fn thread_rng() -> ThreadRng {
     // used to make space in TLS for a random number generator
     thread_local!(static THREAD_RNG_KEY: Rc<RefCell<ThreadRngInner>> = {
@@ -922,7 +923,7 @@ pub fn thread_rng() -> ThreadRng {
     ThreadRng { rng: THREAD_RNG_KEY.with(|t| t.clone()) }
 }
 
-#[cfg(feature="std")]
+#[cfg(all(feature="std",not(feature="rdrand")))]
 impl Rng for ThreadRng {
     fn next_u32(&mut self) -> u32 {
         self.rng.borrow_mut().next_u32()
@@ -938,6 +939,14 @@ impl Rng for ThreadRng {
     }
 }
 
+#[cfg(feature="rdrand")]
+pub use os::OsRng as ThreadRng;
+
+#[cfg(feature="rdrand")]
+pub fn thread_rng() -> ThreadRng {
+    OsRng::new().unwrap()
+}
+
 /// Generates a random value using the thread-local random number generator.
 ///
 /// `random()` can generate various types of random things, and so may require
@@ -980,7 +989,7 @@ impl Rng for ThreadRng {
 ///     *x = rng.gen();
 /// }
 /// ```
-#[cfg(feature="std")]
+#[cfg(any(feature="std",feature="rdrand"))]
 #[inline]
 pub fn random<T: Rand>() -> T {
     thread_rng().gen()

src/os.rs

@@ -11,7 +11,8 @@
 //! Interfaces to the operating system provided random number
 //! generators.
 
-use std::io;
+#[cfg(not(feature="std"))] use io;
+#[cfg(feature="std")] use std::io;
 use Rng;
 
 /// A random number generator that retrieves randomness straight from
@@ -41,7 +42,7 @@ impl Rng for OsRng {
 }
 
 #[cfg(all(unix, not(target_os = "ios"),
-          not(target_os = "nacl")))]
+          not(target_os = "nacl"), not(feature = "rdrand")))]
 mod imp {
     extern crate libc;
 
@@ -198,7 +199,7 @@ mod imp {
     }
 }
 
-#[cfg(target_os = "ios")]
+#[cfg(all(target_os = "ios", not(feature = "rdrand")))]
 mod imp {
     extern crate libc;
 
@@ -248,7 +249,7 @@ mod imp {
     }
 }
 
-#[cfg(windows)]
+#[cfg(all(windows, not(feature = "rdrand")))]
 mod imp {
     use std::io;
     use std::mem;
@@ -339,7 +340,7 @@ mod imp {
     }
 }
 
-#[cfg(target_os = "nacl")]
+#[cfg(all(target_os = "nacl", not(feature = "rdrand")))]
 mod imp {
     extern crate libc;
 
@@ -417,6 +418,36 @@ mod imp {
 }
 
 
+#[cfg(feature = "rdrand")]
+mod imp {
+    #[cfg(not(feature="std"))] use io;
+    #[cfg(feature="std")] use std::io;
+
+    use Rng;
+
+    pub struct OsRng;
+
+    impl OsRng {
+        pub fn new() -> io::Result<OsRng> {
+            Ok(OsRng)
+        }
+    }
+
+    impl Rng for OsRng {
+        fn next_u32(&mut self) -> u32 {
+            let ret;
+            unsafe{asm!("rdrand $0":"=r"(ret):::"volatile")};
+            ret
+        }
+        #[cfg(target_arch="x86_64")]
+        fn next_u64(&mut self) -> u64 {
+            let ret;
+            unsafe{asm!("rdrand $0":"=r"(ret):::"volatile")};
+            ret
+        }
+    }
+}
+
 #[cfg(test)]
 mod test {
     use std::sync::mpsc::channel;