---

yaml
---
r: 56464
b: refs/heads/auto
c: 35f33c1
h: refs/heads/master
v: v3

Author: brendanzab

[refs]

@@ -14,6 +14,6 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 32df8ed877e6ec73eb787798384e114182caf08c
+refs/heads/auto: 35f33c17f7d242bce031a9e648e6c3f31dd59ef6
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c

branches/auto/src/libcore/num/int-template/int.rs

@@ -27,12 +27,6 @@ mod inst {
         #[inline(always)]
         fn bits() -> uint { 64 }
 
-        // fallback if we don't have access to the current word size
-        #[cfg(not(target_word_size = "32"),
-              not(target_word_size = "64"))]
-        #[inline(always)]
-        fn bits() -> uint { ::sys::size_of::<int>() * 8 }
-
         #[inline(always)]
         fn bytes() -> uint { Primitive::bits::<int>() / 8 }
     }
@@ -69,41 +63,6 @@ mod inst {
         fn trailing_zeros(&self) -> int { (*self as i32).trailing_zeros() as int }
     }
 
-    // fallback if we don't have access to the current word size
-    #[cfg(not(target_word_size = "32"),
-          not(target_word_size = "64"))]
-    impl BitCount for int {
-        /// Counts the number of bits set.
-        #[inline(always)]
-        fn population_count(&self) -> int {
-            match ::sys::size_of::<int>() {
-                8 => (*self as i64).population_count() as int,
-                4 => (*self as i32).population_count() as int,
-                s => fail!(fmt!("unsupported word size: %?", s)),
-            }
-        }
-
-        /// Counts the number of leading zeros.
-        #[inline(always)]
-        fn leading_zeros(&self) -> int {
-            match ::sys::size_of::<int>() {
-                8 => (*self as i64).leading_zeros() as int,
-                4 => (*self as i32).leading_zeros() as int,
-                s => fail!(fmt!("unsupported word size: %?", s)),
-            }
-        }
-
-        /// Counts the number of trailing zeros.
-        #[inline(always)]
-        fn trailing_zeros(&self) -> int {
-            match ::sys::size_of::<int>() {
-                8 => (*self as i64).trailing_zeros() as int,
-                4 => (*self as i32).trailing_zeros() as int,
-                s => fail!(fmt!("unsupported word size: %?", s)),
-            }
-        }
-    }
-
     /// Returns `base` raised to the power of `exponent`
     pub fn pow(base: int, exponent: uint) -> int {
         if exponent == 0u {

branches/auto/src/libcore/num/uint-template/uint.rs

@@ -41,12 +41,6 @@ pub mod inst {
         #[inline(always)]
         fn bits() -> uint { 64 }
 
-        // fallback if we don't have access to the current word size
-        #[cfg(not(target_word_size = "32"),
-              not(target_word_size = "64"))]
-        #[inline(always)]
-        fn bits() -> uint { sys::size_of::<uint>() * 8 }
-
         #[inline(always)]
         fn bytes() -> uint { Primitive::bits::<uint>() / 8 }
     }
@@ -83,41 +77,6 @@ pub mod inst {
         fn trailing_zeros(&self) -> uint { (*self as i32).trailing_zeros() as uint }
     }
 
-    // fallback if we don't have access to the current word size
-    #[cfg(not(target_word_size = "32"),
-          not(target_word_size = "64"))]
-    impl BitCount for uint {
-        /// Counts the number of bits set.
-        #[inline(always)]
-        fn population_count(&self) -> uint {
-            match sys::size_of::<uint>() {
-                8 => (*self as i64).population_count() as uint,
-                4 => (*self as i32).population_count() as uint,
-                s => fail!(fmt!("unsupported word size: %?", s)),
-            }
-        }
-
-        /// Counts the number of leading zeros.
-        #[inline(always)]
-        fn leading_zeros(&self) -> uint {
-            match sys::size_of::<uint>() {
-                8 => (*self as i64).leading_zeros() as uint,
-                4 => (*self as i32).leading_zeros() as uint,
-                s => fail!(fmt!("unsupported word size: %?", s)),
-            }
-        }
-
-        /// Counts the number of trailing zeros.
-        #[inline(always)]
-        fn trailing_zeros(&self) -> uint {
-            match sys::size_of::<uint>() {
-                8 => (*self as i64).trailing_zeros() as uint,
-                4 => (*self as i32).trailing_zeros() as uint,
-                s => fail!(fmt!("unsupported word size: %?", s)),
-            }
-        }
-    }
-
     ///
     /// Divide two numbers, return the result, rounded up.
     ///