From c4a9d8a5e91a08fffb083a10105148380192c5c0 Mon Sep 17 00:00:00 2001
From: Huon Wilson <dbau.pp+github@gmail.com>
Date: Mon, 14 Apr 2014 20:04:14 +1000
Subject: [PATCH] Use the unsigned integer types for bitwise intrinsics.
Exposing ctpop, ctlz, cttz and bswap as taking signed i8/i16/... is just
exposing the internal LLVM names pointlessly (LLVM doesn't have "signed
integers" or "unsigned integers", it just has sized integer types
with (un)signed *operations*).
These operations are semantically working with raw bytes, which the
unsigned types model better.
---
src/libnative/io/net.rs | 4 +-
src/librustc/middle/typeck/check/mod.rs | 30 ++--
src/librustc/util/sha2.rs | 10 +-
src/librustuv/net.rs | 4 +-
src/libserialize/ebml.rs | 4 +-
src/libstd/intrinsics.rs | 60 +++++---
src/libstd/io/extensions.rs | 14 +-
src/libstd/mem.rs | 96 ++++++------
src/libstd/num/i16.rs | 6 +-
src/libstd/num/i32.rs | 6 +-
src/libstd/num/i64.rs | 6 +-
src/libstd/num/i8.rs | 6 +-
src/libuuid/lib.rs | 12 +-
src/test/bench/sudoku.rs | 6 +-
src/test/run-pass/intrinsics-integer.rs | 193 ++++++++++++------------
15 files changed, 238 insertions(+), 219 deletions(-)
diff --git a/src/libnative/io/net.rs b/src/libnative/io/net.rs
index cef6a247a00af..2e64b82a84a31 100644
--- a/src/libnative/io/net.rs
+++ b/src/libnative/io/net.rs
@@ -26,10 +26,10 @@ use super::{IoResult, retry, keep_going};
#[cfg(unix)] pub type sock_t = super::file::fd_t;
pub fn htons(u: u16) -> u16 {
- mem::to_be16(u as i16) as u16
+ mem::to_be16(u)
}
pub fn ntohs(u: u16) -> u16 {
- mem::from_be16(u as i16) as u16
+ mem::from_be16(u)
}
enum InAddr {
diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs
index fee510b82b7a2..cff8c149bb6ef 100644
--- a/src/librustc/middle/typeck/check/mod.rs
+++ b/src/librustc/middle/typeck/check/mod.rs
@@ -4143,21 +4143,21 @@ pub fn check_intrinsic_type(ccx: &CrateCtxt, it: &ast::ForeignItem) {
"nearbyintf64" => (0, vec!( ty::mk_f64() ), ty::mk_f64()),
"roundf32" => (0, vec!( ty::mk_f32() ), ty::mk_f32()),
"roundf64" => (0, vec!( ty::mk_f64() ), ty::mk_f64()),
- "ctpop8" => (0, vec!( ty::mk_i8() ), ty::mk_i8()),
- "ctpop16" => (0, vec!( ty::mk_i16() ), ty::mk_i16()),
- "ctpop32" => (0, vec!( ty::mk_i32() ), ty::mk_i32()),
- "ctpop64" => (0, vec!( ty::mk_i64() ), ty::mk_i64()),
- "ctlz8" => (0, vec!( ty::mk_i8() ), ty::mk_i8()),
- "ctlz16" => (0, vec!( ty::mk_i16() ), ty::mk_i16()),
- "ctlz32" => (0, vec!( ty::mk_i32() ), ty::mk_i32()),
- "ctlz64" => (0, vec!( ty::mk_i64() ), ty::mk_i64()),
- "cttz8" => (0, vec!( ty::mk_i8() ), ty::mk_i8()),
- "cttz16" => (0, vec!( ty::mk_i16() ), ty::mk_i16()),
- "cttz32" => (0, vec!( ty::mk_i32() ), ty::mk_i32()),
- "cttz64" => (0, vec!( ty::mk_i64() ), ty::mk_i64()),
- "bswap16" => (0, vec!( ty::mk_i16() ), ty::mk_i16()),
- "bswap32" => (0, vec!( ty::mk_i32() ), ty::mk_i32()),
- "bswap64" => (0, vec!( ty::mk_i64() ), ty::mk_i64()),
+ "ctpop8" => (0, vec!( ty::mk_u8() ), ty::mk_u8()),
+ "ctpop16" => (0, vec!( ty::mk_u16() ), ty::mk_u16()),
+ "ctpop32" => (0, vec!( ty::mk_u32() ), ty::mk_u32()),
+ "ctpop64" => (0, vec!( ty::mk_u64() ), ty::mk_u64()),
+ "ctlz8" => (0, vec!( ty::mk_u8() ), ty::mk_u8()),
+ "ctlz16" => (0, vec!( ty::mk_u16() ), ty::mk_u16()),
+ "ctlz32" => (0, vec!( ty::mk_u32() ), ty::mk_u32()),
+ "ctlz64" => (0, vec!( ty::mk_u64() ), ty::mk_u64()),
+ "cttz8" => (0, vec!( ty::mk_u8() ), ty::mk_u8()),
+ "cttz16" => (0, vec!( ty::mk_u16() ), ty::mk_u16()),
+ "cttz32" => (0, vec!( ty::mk_u32() ), ty::mk_u32()),
+ "cttz64" => (0, vec!( ty::mk_u64() ), ty::mk_u64()),
+ "bswap16" => (0, vec!( ty::mk_u16() ), ty::mk_u16()),
+ "bswap32" => (0, vec!( ty::mk_u32() ), ty::mk_u32()),
+ "bswap64" => (0, vec!( ty::mk_u64() ), ty::mk_u64()),
"volatile_load" =>
(1, vec!( ty::mk_imm_ptr(tcx, param(ccx, 0)) ), param(ccx, 0)),
diff --git a/src/librustc/util/sha2.rs b/src/librustc/util/sha2.rs
index 17ea4d6b0b475..4571e6328cf24 100644
--- a/src/librustc/util/sha2.rs
+++ b/src/librustc/util/sha2.rs
@@ -20,23 +20,21 @@ use serialize::hex::ToHex;
/// Write a u32 into a vector, which must be 4 bytes long. The value is written in big-endian
/// format.
fn write_u32_be(dst: &mut[u8], input: u32) {
- use std::cast::transmute;
use std::mem::to_be32;
assert!(dst.len() == 4);
unsafe {
- let x: *mut i32 = transmute(dst.unsafe_mut_ref(0));
- *x = to_be32(input as i32);
+ let x = dst.unsafe_mut_ref(0) as *mut _ as *mut u32;
+ *x = to_be32(input);
}
}
/// Read a vector of bytes into a vector of u32s. The values are read in big-endian format.
fn read_u32v_be(dst: &mut[u32], input: &[u8]) {
- use std::cast::transmute;
use std::mem::to_be32;
assert!(dst.len() * 4 == input.len());
unsafe {
- let mut x: *mut i32 = transmute(dst.unsafe_mut_ref(0));
- let mut y: *i32 = transmute(input.unsafe_ref(0));
+ let mut x = dst.unsafe_mut_ref(0) as *mut _ as *mut u32;
+ let mut y = input.unsafe_ref(0) as *_ as *u32;
for _ in range(0, dst.len()) {
*x = to_be32(*y);
x = x.offset(1);
diff --git a/src/librustuv/net.rs b/src/librustuv/net.rs
index b893f5f693fa7..280cd4bd592ee 100644
--- a/src/librustuv/net.rs
+++ b/src/librustuv/net.rs
@@ -32,8 +32,8 @@ use uvll;
/// Generic functions related to dealing with sockaddr things
////////////////////////////////////////////////////////////////////////////////
-pub fn htons(u: u16) -> u16 { mem::to_be16(u as i16) as u16 }
-pub fn ntohs(u: u16) -> u16 { mem::from_be16(u as i16) as u16 }
+pub fn htons(u: u16) -> u16 { mem::to_be16(u) }
+pub fn ntohs(u: u16) -> u16 { mem::from_be16(u) }
pub fn sockaddr_to_addr(storage: &libc::sockaddr_storage,
len: uint) -> ip::SocketAddr {
diff --git a/src/libserialize/ebml.rs b/src/libserialize/ebml.rs
index 9b2df307b9947..0efa93011fc66 100644
--- a/src/libserialize/ebml.rs
+++ b/src/libserialize/ebml.rs
@@ -179,8 +179,8 @@ pub mod reader {
];
unsafe {
- let ptr = data.as_ptr().offset(start as int) as *i32;
- let val = from_be32(*ptr) as u32;
+ let ptr = data.as_ptr().offset(start as int) as *u32;
+ let val = from_be32(*ptr);
let i = (val >> 28u) as uint;
let (shift, mask) = SHIFT_MASK_TABLE[i];
diff --git a/src/libstd/intrinsics.rs b/src/libstd/intrinsics.rs
index 896ebcd6fb596..175c7fe57b319 100644
--- a/src/libstd/intrinsics.rs
+++ b/src/libstd/intrinsics.rs
@@ -394,26 +394,50 @@ extern "rust-intrinsic" {
pub fn roundf32(x: f32) -> f32;
pub fn roundf64(x: f64) -> f64;
+}
+#[cfg(not(stage0))]
+extern "rust-intrinsic" {
+ pub fn ctpop8(x: u8) -> u8;
+ pub fn ctpop16(x: u16) -> u16;
+ pub fn ctpop32(x: u32) -> u32;
+ pub fn ctpop64(x: u64) -> u64;
+
+ pub fn ctlz8(x: u8) -> u8;
+ pub fn ctlz16(x: u16) -> u16;
+ pub fn ctlz32(x: u32) -> u32;
+ pub fn ctlz64(x: u64) -> u64;
+
+ pub fn cttz8(x: u8) -> u8;
+ pub fn cttz16(x: u16) -> u16;
+ pub fn cttz32(x: u32) -> u32;
+ pub fn cttz64(x: u64) -> u64;
+
+ pub fn bswap16(x: u16) -> u16;
+ pub fn bswap32(x: u32) -> u32;
+ pub fn bswap64(x: u64) -> u64;
+}
- pub fn ctpop8(x: i8) -> i8;
- 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;
-
- pub fn cttz8(x: i8) -> i8;
- pub fn cttz16(x: i16) -> i16;
- pub fn cttz32(x: i32) -> i32;
- pub fn cttz64(x: i64) -> i64;
-
- pub fn bswap16(x: i16) -> i16;
- pub fn bswap32(x: i32) -> i32;
- pub fn bswap64(x: i64) -> i64;
+// NOTE: remove this after a snap, and merge the extern block above
+macro_rules! stage0_hack {
+ ($( $u_ty:ty, $i_ty:ty => $($name:ident),*);*) => {
+ $(
+ $(
+ #[cfg(stage0)]
+ pub unsafe fn $name(x: $u_ty) -> $u_ty {
+ extern "rust-intrinsic" { fn $name(x: $i_ty) -> $i_ty; }
+ $name(x as $i_ty) as $u_ty
+ }
+ )*)*
+ }
+}
+stage0_hack! {
+ u8, i8 => ctpop8, ctlz8, cttz8;
+ u16, i16 => ctpop16, ctlz16, cttz16, bswap16;
+ u32, i32 => ctpop32, ctlz32, cttz32, bswap32;
+ u64, i64 => ctpop64, ctlz64, cttz64, bswap64
+}
+extern "rust-intrinsic" {
pub fn i8_add_with_overflow(x: i8, y: i8) -> (i8, bool);
pub fn i16_add_with_overflow(x: i16, y: i16) -> (i16, bool);
pub fn i32_add_with_overflow(x: i32, y: i32) -> (i32, bool);
diff --git a/src/libstd/io/extensions.rs b/src/libstd/io/extensions.rs
index b2202a1305749..d8022b1e26c6d 100644
--- a/src/libstd/io/extensions.rs
+++ b/src/libstd/io/extensions.rs
@@ -83,9 +83,9 @@ pub fn u64_to_le_bytes<T>(n: u64, size: uint, f: |v: &[u8]| -> T) -> T {
assert!(size <= 8u);
match size {
1u => f(&[n as u8]),
- 2u => f(unsafe { transmute::<i16, [u8, ..2]>(to_le16(n as i16)) }),
- 4u => f(unsafe { transmute::<i32, [u8, ..4]>(to_le32(n as i32)) }),
- 8u => f(unsafe { transmute::<i64, [u8, ..8]>(to_le64(n as i64)) }),
+ 2u => f(unsafe { transmute::<_, [u8, ..2]>(to_le16(n as u16)) }),
+ 4u => f(unsafe { transmute::<_, [u8, ..4]>(to_le32(n as u32)) }),
+ 8u => f(unsafe { transmute::<_, [u8, ..8]>(to_le64(n)) }),
_ => {
let mut bytes = vec!();
@@ -123,9 +123,9 @@ pub fn u64_to_be_bytes<T>(n: u64, size: uint, f: |v: &[u8]| -> T) -> T {
assert!(size <= 8u);
match size {
1u => f(&[n as u8]),
- 2u => f(unsafe { transmute::<i16, [u8, ..2]>(to_be16(n as i16)) }),
- 4u => f(unsafe { transmute::<i32, [u8, ..4]>(to_be32(n as i32)) }),
- 8u => f(unsafe { transmute::<i64, [u8, ..8]>(to_be64(n as i64)) }),
+ 2u => f(unsafe { transmute::<_, [u8, ..2]>(to_be16(n as u16)) }),
+ 4u => f(unsafe { transmute::<_, [u8, ..4]>(to_be32(n as u32)) }),
+ 8u => f(unsafe { transmute::<_, [u8, ..8]>(to_be64(n)) }),
_ => {
let mut bytes = vec!();
let mut i = size;
@@ -166,7 +166,7 @@ pub fn u64_from_be_bytes(data: &[u8], start: uint, size: uint) -> u64 {
let ptr = data.as_ptr().offset(start as int);
let out = buf.as_mut_ptr();
copy_nonoverlapping_memory(out.offset((8 - size) as int), ptr, size);
- from_be64(*(out as *i64)) as u64
+ from_be64(*(out as *u64))
}
}
diff --git a/src/libstd/mem.rs b/src/libstd/mem.rs
index deefb3fe2ed0a..282cfe517823b 100644
--- a/src/libstd/mem.rs
+++ b/src/libstd/mem.rs
@@ -99,128 +99,128 @@ pub unsafe fn move_val_init<T>(dst: &mut T, src: T) {
intrinsics::move_val_init(dst, src)
}
-/// Convert an i16 to little endian from the target's endianness.
+/// Convert an u16 to little endian from the target's endianness.
///
/// On little endian, this is a no-op. On big endian, the bytes are swapped.
-#[cfg(target_endian = "little")] #[inline] pub fn to_le16(x: i16) -> i16 { x }
+#[cfg(target_endian = "little")] #[inline] pub fn to_le16(x: u16) -> u16 { x }
-/// Convert an i16 to little endian from the target's endianness.
+/// Convert an u16 to little endian from the target's endianness.
///
/// On little endian, this is a no-op. On big endian, the bytes are swapped.
-#[cfg(target_endian = "big")] #[inline] pub fn to_le16(x: i16) -> i16 { unsafe { bswap16(x) } }
+#[cfg(target_endian = "big")] #[inline] pub fn to_le16(x: u16) -> u16 { unsafe { bswap16(x) } }
-/// Convert an i32 to little endian from the target's endianness.
+/// Convert an u32 to little endian from the target's endianness.
///
/// On little endian, this is a no-op. On big endian, the bytes are swapped.
-#[cfg(target_endian = "little")] #[inline] pub fn to_le32(x: i32) -> i32 { x }
+#[cfg(target_endian = "little")] #[inline] pub fn to_le32(x: u32) -> u32 { x }
-/// Convert an i32 to little endian from the target's endianness.
+/// Convert an u32 to little endian from the target's endianness.
///
/// On little endian, this is a no-op. On big endian, the bytes are swapped.
-#[cfg(target_endian = "big")] #[inline] pub fn to_le32(x: i32) -> i32 { unsafe { bswap32(x) } }
+#[cfg(target_endian = "big")] #[inline] pub fn to_le32(x: u32) -> u32 { unsafe { bswap32(x) } }
-/// Convert an i64 to little endian from the target's endianness.
+/// Convert an u64 to little endian from the target's endianness.
///
/// On little endian, this is a no-op. On big endian, the bytes are swapped.
-#[cfg(target_endian = "little")] #[inline] pub fn to_le64(x: i64) -> i64 { x }
+#[cfg(target_endian = "little")] #[inline] pub fn to_le64(x: u64) -> u64 { x }
-/// Convert an i64 to little endian from the target's endianness.
+/// Convert an u64 to little endian from the target's endianness.
///
/// On little endian, this is a no-op. On big endian, the bytes are swapped.
-#[cfg(target_endian = "big")] #[inline] pub fn to_le64(x: i64) -> i64 { unsafe { bswap64(x) } }
+#[cfg(target_endian = "big")] #[inline] pub fn to_le64(x: u64) -> u64 { unsafe { bswap64(x) } }
-/// Convert an i16 to big endian from the target's endianness.
+/// Convert an u16 to big endian from the target's endianness.
///
/// On big endian, this is a no-op. On little endian, the bytes are swapped.
-#[cfg(target_endian = "little")] #[inline] pub fn to_be16(x: i16) -> i16 { unsafe { bswap16(x) } }
+#[cfg(target_endian = "little")] #[inline] pub fn to_be16(x: u16) -> u16 { unsafe { bswap16(x) } }
-/// Convert an i16 to big endian from the target's endianness.
+/// Convert an u16 to big endian from the target's endianness.
///
/// On big endian, this is a no-op. On little endian, the bytes are swapped.
-#[cfg(target_endian = "big")] #[inline] pub fn to_be16(x: i16) -> i16 { x }
+#[cfg(target_endian = "big")] #[inline] pub fn to_be16(x: u16) -> u16 { x }
-/// Convert an i32 to big endian from the target's endianness.
+/// Convert an u32 to big endian from the target's endianness.
///
/// On big endian, this is a no-op. On little endian, the bytes are swapped.
-#[cfg(target_endian = "little")] #[inline] pub fn to_be32(x: i32) -> i32 { unsafe { bswap32(x) } }
+#[cfg(target_endian = "little")] #[inline] pub fn to_be32(x: u32) -> u32 { unsafe { bswap32(x) } }
-/// Convert an i32 to big endian from the target's endianness.
+/// Convert an u32 to big endian from the target's endianness.
///
/// On big endian, this is a no-op. On little endian, the bytes are swapped.
-#[cfg(target_endian = "big")] #[inline] pub fn to_be32(x: i32) -> i32 { x }
+#[cfg(target_endian = "big")] #[inline] pub fn to_be32(x: u32) -> u32 { x }
-/// Convert an i64 to big endian from the target's endianness.
+/// Convert an u64 to big endian from the target's endianness.
///
/// On big endian, this is a no-op. On little endian, the bytes are swapped.
-#[cfg(target_endian = "little")] #[inline] pub fn to_be64(x: i64) -> i64 { unsafe { bswap64(x) } }
+#[cfg(target_endian = "little")] #[inline] pub fn to_be64(x: u64) -> u64 { unsafe { bswap64(x) } }
-/// Convert an i64 to big endian from the target's endianness.
+/// Convert an u64 to big endian from the target's endianness.
///
/// On big endian, this is a no-op. On little endian, the bytes are swapped.
-#[cfg(target_endian = "big")] #[inline] pub fn to_be64(x: i64) -> i64 { x }
+#[cfg(target_endian = "big")] #[inline] pub fn to_be64(x: u64) -> u64 { x }
-/// Convert an i16 from little endian to the target's endianness.
+/// Convert an u16 from little endian to the target's endianness.
///
/// On little endian, this is a no-op. On big endian, the bytes are swapped.
-#[cfg(target_endian = "little")] #[inline] pub fn from_le16(x: i16) -> i16 { x }
+#[cfg(target_endian = "little")] #[inline] pub fn from_le16(x: u16) -> u16 { x }
-/// Convert an i16 from little endian to the target's endianness.
+/// Convert an u16 from little endian to the target's endianness.
///
/// On little endian, this is a no-op. On big endian, the bytes are swapped.
-#[cfg(target_endian = "big")] #[inline] pub fn from_le16(x: i16) -> i16 { unsafe { bswap16(x) } }
+#[cfg(target_endian = "big")] #[inline] pub fn from_le16(x: u16) -> u16 { unsafe { bswap16(x) } }
-/// Convert an i32 from little endian to the target's endianness.
+/// Convert an u32 from little endian to the target's endianness.
///
/// On little endian, this is a no-op. On big endian, the bytes are swapped.
-#[cfg(target_endian = "little")] #[inline] pub fn from_le32(x: i32) -> i32 { x }
+#[cfg(target_endian = "little")] #[inline] pub fn from_le32(x: u32) -> u32 { x }
-/// Convert an i32 from little endian to the target's endianness.
+/// Convert an u32 from little endian to the target's endianness.
///
/// On little endian, this is a no-op. On big endian, the bytes are swapped.
-#[cfg(target_endian = "big")] #[inline] pub fn from_le32(x: i32) -> i32 { unsafe { bswap32(x) } }
+#[cfg(target_endian = "big")] #[inline] pub fn from_le32(x: u32) -> u32 { unsafe { bswap32(x) } }
-/// Convert an i64 from little endian to the target's endianness.
+/// Convert an u64 from little endian to the target's endianness.
///
/// On little endian, this is a no-op. On big endian, the bytes are swapped.
-#[cfg(target_endian = "little")] #[inline] pub fn from_le64(x: i64) -> i64 { x }
+#[cfg(target_endian = "little")] #[inline] pub fn from_le64(x: u64) -> u64 { x }
-/// Convert an i64 from little endian to the target's endianness.
+/// Convert an u64 from little endian to the target's endianness.
///
/// On little endian, this is a no-op. On big endian, the bytes are swapped.
-#[cfg(target_endian = "big")] #[inline] pub fn from_le64(x: i64) -> i64 { unsafe { bswap64(x) } }
+#[cfg(target_endian = "big")] #[inline] pub fn from_le64(x: u64) -> u64 { unsafe { bswap64(x) } }
-/// Convert an i16 from big endian to the target's endianness.
+/// Convert an u16 from big endian to the target's endianness.
///
/// On big endian, this is a no-op. On little endian, the bytes are swapped.
-#[cfg(target_endian = "little")] #[inline] pub fn from_be16(x: i16) -> i16 { unsafe { bswap16(x) } }
+#[cfg(target_endian = "little")] #[inline] pub fn from_be16(x: u16) -> u16 { unsafe { bswap16(x) } }
-/// Convert an i16 from big endian to the target's endianness.
+/// Convert an u16 from big endian to the target's endianness.
///
/// On big endian, this is a no-op. On little endian, the bytes are swapped.
-#[cfg(target_endian = "big")] #[inline] pub fn from_be16(x: i16) -> i16 { x }
+#[cfg(target_endian = "big")] #[inline] pub fn from_be16(x: u16) -> u16 { x }
-/// Convert an i32 from big endian to the target's endianness.
+/// Convert an u32 from big endian to the target's endianness.
///
/// On big endian, this is a no-op. On little endian, the bytes are swapped.
-#[cfg(target_endian = "little")] #[inline] pub fn from_be32(x: i32) -> i32 { unsafe { bswap32(x) } }
+#[cfg(target_endian = "little")] #[inline] pub fn from_be32(x: u32) -> u32 { unsafe { bswap32(x) } }
-/// Convert an i32 from big endian to the target's endianness.
+/// Convert an u32 from big endian to the target's endianness.
///
/// On big endian, this is a no-op. On little endian, the bytes are swapped.
-#[cfg(target_endian = "big")] #[inline] pub fn from_be32(x: i32) -> i32 { x }
+#[cfg(target_endian = "big")] #[inline] pub fn from_be32(x: u32) -> u32 { x }
-/// Convert an i64 from big endian to the target's endianness.
+/// Convert an u64 from big endian to the target's endianness.
///
/// On big endian, this is a no-op. On little endian, the bytes are swapped.
-#[cfg(target_endian = "little")] #[inline] pub fn from_be64(x: i64) -> i64 { unsafe { bswap64(x) } }
+#[cfg(target_endian = "little")] #[inline] pub fn from_be64(x: u64) -> u64 { unsafe { bswap64(x) } }
-/// Convert an i64 from big endian to the target's endianness.
+/// Convert an u64 from big endian to the target's endianness.
///
/// On big endian, this is a no-op. On little endian, the bytes are swapped.
-#[cfg(target_endian = "big")] #[inline] pub fn from_be64(x: i64) -> i64 { x }
+#[cfg(target_endian = "big")] #[inline] pub fn from_be64(x: u64) -> u64 { x }
/**
diff --git a/src/libstd/num/i16.rs b/src/libstd/num/i16.rs
index 42710a8b459d0..79827421f9222 100644
--- a/src/libstd/num/i16.rs
+++ b/src/libstd/num/i16.rs
@@ -28,17 +28,17 @@ int_module!(i16, 16)
impl Bitwise for i16 {
/// Returns the number of ones in the binary representation of the number.
#[inline]
- fn count_ones(&self) -> i16 { unsafe { intrinsics::ctpop16(*self) } }
+ fn count_ones(&self) -> i16 { unsafe { intrinsics::ctpop16(*self as u16) as i16 } }
/// Returns the number of leading zeros in the in the binary representation
/// of the number.
#[inline]
- fn leading_zeros(&self) -> i16 { unsafe { intrinsics::ctlz16(*self) } }
+ fn leading_zeros(&self) -> i16 { unsafe { intrinsics::ctlz16(*self as u16) as i16 } }
/// Returns the number of trailing zeros in the in the binary representation
/// of the number.
#[inline]
- fn trailing_zeros(&self) -> i16 { unsafe { intrinsics::cttz16(*self) } }
+ fn trailing_zeros(&self) -> i16 { unsafe { intrinsics::cttz16(*self as u16) as i16 } }
}
impl CheckedAdd for i16 {
diff --git a/src/libstd/num/i32.rs b/src/libstd/num/i32.rs
index 69d4b0639f732..97f03299b8765 100644
--- a/src/libstd/num/i32.rs
+++ b/src/libstd/num/i32.rs
@@ -28,17 +28,17 @@ int_module!(i32, 32)
impl Bitwise for i32 {
/// Returns the number of ones in the binary representation of the number.
#[inline]
- fn count_ones(&self) -> i32 { unsafe { intrinsics::ctpop32(*self) } }
+ fn count_ones(&self) -> i32 { unsafe { intrinsics::ctpop32(*self as u32) as i32 } }
/// Returns the number of leading zeros in the in the binary representation
/// of the number.
#[inline]
- fn leading_zeros(&self) -> i32 { unsafe { intrinsics::ctlz32(*self) } }
+ fn leading_zeros(&self) -> i32 { unsafe { intrinsics::ctlz32(*self as u32) as i32 } }
/// Returns the number of trailing zeros in the in the binary representation
/// of the number.
#[inline]
- fn trailing_zeros(&self) -> i32 { unsafe { intrinsics::cttz32(*self) } }
+ fn trailing_zeros(&self) -> i32 { unsafe { intrinsics::cttz32(*self as u32) as i32 } }
}
impl CheckedAdd for i32 {
diff --git a/src/libstd/num/i64.rs b/src/libstd/num/i64.rs
index 1f7066c25db3b..00823aa22c28e 100644
--- a/src/libstd/num/i64.rs
+++ b/src/libstd/num/i64.rs
@@ -30,16 +30,16 @@ int_module!(i64, 64)
impl Bitwise for i64 {
/// Returns the number of ones in the binary representation of the number.
#[inline]
- fn count_ones(&self) -> i64 { unsafe { intrinsics::ctpop64(*self) } }
+ fn count_ones(&self) -> i64 { unsafe { intrinsics::ctpop64(*self as u64) as i64 } }
/// Returns the number of leading zeros in the in the binary representation
/// of the number.
#[inline]
- fn leading_zeros(&self) -> i64 { unsafe { intrinsics::ctlz64(*self) } }
+ fn leading_zeros(&self) -> i64 { unsafe { intrinsics::ctlz64(*self as u64) as i64 } }
/// Counts the number of trailing zeros.
#[inline]
- fn trailing_zeros(&self) -> i64 { unsafe { intrinsics::cttz64(*self) } }
+ fn trailing_zeros(&self) -> i64 { unsafe { intrinsics::cttz64(*self as u64) as i64 } }
}
impl CheckedAdd for i64 {
diff --git a/src/libstd/num/i8.rs b/src/libstd/num/i8.rs
index 061ffddf2312e..2d349fa7f4f1d 100644
--- a/src/libstd/num/i8.rs
+++ b/src/libstd/num/i8.rs
@@ -28,17 +28,17 @@ int_module!(i8, 8)
impl Bitwise for i8 {
/// Returns the number of ones in the binary representation of the number.
#[inline]
- fn count_ones(&self) -> i8 { unsafe { intrinsics::ctpop8(*self) } }
+ fn count_ones(&self) -> i8 { unsafe { intrinsics::ctpop8(*self as u8) as i8 } }
/// Returns the number of leading zeros in the in the binary representation
/// of the number.
#[inline]
- fn leading_zeros(&self) -> i8 { unsafe { intrinsics::ctlz8(*self) } }
+ fn leading_zeros(&self) -> i8 { unsafe { intrinsics::ctlz8(*self as u8) as i8 } }
/// Returns the number of trailing zeros in the in the binary representation
/// of the number.
#[inline]
- fn trailing_zeros(&self) -> i8 { unsafe { intrinsics::cttz8(*self) } }
+ fn trailing_zeros(&self) -> i8 { unsafe { intrinsics::cttz8(*self as u8) as i8 } }
}
impl CheckedAdd for i8 {
diff --git a/src/libuuid/lib.rs b/src/libuuid/lib.rs
index 2ac6780af4c1b..559edd587fd7e 100644
--- a/src/libuuid/lib.rs
+++ b/src/libuuid/lib.rs
@@ -220,9 +220,9 @@ impl Uuid {
data4: [0, ..8]
};
- fields.data1 = to_be32(d1 as i32) as u32;
- fields.data2 = to_be16(d2 as i16) as u16;
- fields.data3 = to_be16(d3 as i16) as u16;
+ fields.data1 = to_be32(d1);
+ fields.data2 = to_be16(d2);
+ fields.data3 = to_be16(d3);
slice::bytes::copy_memory(fields.data4, d4);
unsafe {
@@ -343,9 +343,9 @@ impl Uuid {
unsafe {
uf = transmute_copy(&self.bytes);
}
- uf.data1 = to_be32(uf.data1 as i32) as u32;
- uf.data2 = to_be16(uf.data2 as i16) as u16;
- uf.data3 = to_be16(uf.data3 as i16) as u16;
+ uf.data1 = to_be32(uf.data1);
+ uf.data2 = to_be16(uf.data2);
+ uf.data3 = to_be16(uf.data3);
let s = format!("{:08x}-{:04x}-{:04x}-{:02x}{:02x}-\
{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}",
uf.data1,
diff --git a/src/test/bench/sudoku.rs b/src/test/bench/sudoku.rs
index 80fea6d49321d..f5724fc1324d5 100644
--- a/src/test/bench/sudoku.rs
+++ b/src/test/bench/sudoku.rs
@@ -16,7 +16,7 @@ use std::io;
use std::io::stdio::StdReader;
use std::io::BufferedReader;
use std::os;
-use std::intrinsics::cttz16;
+use std::num::Bitwise;
// Computes a single solution to a given 9x9 sudoku
//
@@ -187,9 +187,7 @@ impl Colors {
if (0u16 == val) {
return 0u8;
} else {
- unsafe {
- return cttz16(val as i16) as u8;
- }
+ return val.trailing_zeros() as u8
}
}
diff --git a/src/test/run-pass/intrinsics-integer.rs b/src/test/run-pass/intrinsics-integer.rs
index 164d16fe50397..e31b941f956eb 100644
--- a/src/test/run-pass/intrinsics-integer.rs
+++ b/src/test/run-pass/intrinsics-integer.rs
@@ -1,4 +1,3 @@
-
// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
@@ -13,24 +12,24 @@
mod rusti {
extern "rust-intrinsic" {
- pub fn ctpop8(x: i8) -> i8;
- 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;
-
- pub fn cttz8(x: i8) -> i8;
- pub fn cttz16(x: i16) -> i16;
- pub fn cttz32(x: i32) -> i32;
- pub fn cttz64(x: i64) -> i64;
-
- pub fn bswap16(x: i16) -> i16;
- pub fn bswap32(x: i32) -> i32;
- pub fn bswap64(x: i64) -> i64;
+ pub fn ctpop8(x: u8) -> u8;
+ pub fn ctpop16(x: u16) -> u16;
+ pub fn ctpop32(x: u32) -> u32;
+ pub fn ctpop64(x: u64) -> u64;
+
+ pub fn ctlz8(x: u8) -> u8;
+ pub fn ctlz16(x: u16) -> u16;
+ pub fn ctlz32(x: u32) -> u32;
+ pub fn ctlz64(x: u64) -> u64;
+
+ pub fn cttz8(x: u8) -> u8;
+ pub fn cttz16(x: u16) -> u16;
+ pub fn cttz32(x: u32) -> u32;
+ pub fn cttz64(x: u64) -> u64;
+
+ pub fn bswap16(x: u16) -> u16;
+ pub fn bswap32(x: u32) -> u32;
+ pub fn bswap64(x: u64) -> u64;
}
}
@@ -38,83 +37,83 @@ pub fn main() {
unsafe {
use rusti::*;
- assert_eq!(ctpop8(0i8), 0i8);
- assert_eq!(ctpop16(0i16), 0i16);
- assert_eq!(ctpop32(0i32), 0i32);
- assert_eq!(ctpop64(0i64), 0i64);
-
- assert_eq!(ctpop8(1i8), 1i8);
- assert_eq!(ctpop16(1i16), 1i16);
- assert_eq!(ctpop32(1i32), 1i32);
- assert_eq!(ctpop64(1i64), 1i64);
-
- assert_eq!(ctpop8(10i8), 2i8);
- assert_eq!(ctpop16(10i16), 2i16);
- assert_eq!(ctpop32(10i32), 2i32);
- assert_eq!(ctpop64(10i64), 2i64);
-
- assert_eq!(ctpop8(100i8), 3i8);
- assert_eq!(ctpop16(100i16), 3i16);
- assert_eq!(ctpop32(100i32), 3i32);
- assert_eq!(ctpop64(100i64), 3i64);
-
- assert_eq!(ctpop8(-1i8), 8i8);
- assert_eq!(ctpop16(-1i16), 16i16);
- assert_eq!(ctpop32(-1i32), 32i32);
- assert_eq!(ctpop64(-1i64), 64i64);
-
- assert_eq!(ctlz8(0i8), 8i8);
- assert_eq!(ctlz16(0i16), 16i16);
- assert_eq!(ctlz32(0i32), 32i32);
- assert_eq!(ctlz64(0i64), 64i64);
-
- assert_eq!(ctlz8(1i8), 7i8);
- assert_eq!(ctlz16(1i16), 15i16);
- assert_eq!(ctlz32(1i32), 31i32);
- assert_eq!(ctlz64(1i64), 63i64);
-
- assert_eq!(ctlz8(10i8), 4i8);
- assert_eq!(ctlz16(10i16), 12i16);
- assert_eq!(ctlz32(10i32), 28i32);
- assert_eq!(ctlz64(10i64), 60i64);
-
- assert_eq!(ctlz8(100i8), 1i8);
- assert_eq!(ctlz16(100i16), 9i16);
- assert_eq!(ctlz32(100i32), 25i32);
- assert_eq!(ctlz64(100i64), 57i64);
-
- assert_eq!(cttz8(-1i8), 0i8);
- assert_eq!(cttz16(-1i16), 0i16);
- assert_eq!(cttz32(-1i32), 0i32);
- assert_eq!(cttz64(-1i64), 0i64);
-
- assert_eq!(cttz8(0i8), 8i8);
- assert_eq!(cttz16(0i16), 16i16);
- assert_eq!(cttz32(0i32), 32i32);
- assert_eq!(cttz64(0i64), 64i64);
-
- assert_eq!(cttz8(1i8), 0i8);
- assert_eq!(cttz16(1i16), 0i16);
- assert_eq!(cttz32(1i32), 0i32);
- assert_eq!(cttz64(1i64), 0i64);
-
- assert_eq!(cttz8(10i8), 1i8);
- assert_eq!(cttz16(10i16), 1i16);
- assert_eq!(cttz32(10i32), 1i32);
- assert_eq!(cttz64(10i64), 1i64);
-
- assert_eq!(cttz8(100i8), 2i8);
- assert_eq!(cttz16(100i16), 2i16);
- assert_eq!(cttz32(100i32), 2i32);
- assert_eq!(cttz64(100i64), 2i64);
-
- assert_eq!(cttz8(-1i8), 0i8);
- assert_eq!(cttz16(-1i16), 0i16);
- assert_eq!(cttz32(-1i32), 0i32);
- assert_eq!(cttz64(-1i64), 0i64);
-
- assert_eq!(bswap16(0x0A0Bi16), 0x0B0Ai16);
- assert_eq!(bswap32(0x0ABBCC0Di32), 0x0DCCBB0Ai32);
- assert_eq!(bswap64(0x0122334455667708i64), 0x0877665544332201i64);
+ assert_eq!(ctpop8(0u8), 0u8);
+ assert_eq!(ctpop16(0u16), 0u16);
+ assert_eq!(ctpop32(0u32), 0u32);
+ assert_eq!(ctpop64(0u64), 0u64);
+
+ assert_eq!(ctpop8(1u8), 1u8);
+ assert_eq!(ctpop16(1u16), 1u16);
+ assert_eq!(ctpop32(1u32), 1u32);
+ assert_eq!(ctpop64(1u64), 1u64);
+
+ assert_eq!(ctpop8(10u8), 2u8);
+ assert_eq!(ctpop16(10u16), 2u16);
+ assert_eq!(ctpop32(10u32), 2u32);
+ assert_eq!(ctpop64(10u64), 2u64);
+
+ assert_eq!(ctpop8(100u8), 3u8);
+ assert_eq!(ctpop16(100u16), 3u16);
+ assert_eq!(ctpop32(100u32), 3u32);
+ assert_eq!(ctpop64(100u64), 3u64);
+
+ assert_eq!(ctpop8(-1u8), 8u8);
+ assert_eq!(ctpop16(-1u16), 16u16);
+ assert_eq!(ctpop32(-1u32), 32u32);
+ assert_eq!(ctpop64(-1u64), 64u64);
+
+ assert_eq!(ctlz8(0u8), 8u8);
+ assert_eq!(ctlz16(0u16), 16u16);
+ assert_eq!(ctlz32(0u32), 32u32);
+ assert_eq!(ctlz64(0u64), 64u64);
+
+ assert_eq!(ctlz8(1u8), 7u8);
+ assert_eq!(ctlz16(1u16), 15u16);
+ assert_eq!(ctlz32(1u32), 31u32);
+ assert_eq!(ctlz64(1u64), 63u64);
+
+ assert_eq!(ctlz8(10u8), 4u8);
+ assert_eq!(ctlz16(10u16), 12u16);
+ assert_eq!(ctlz32(10u32), 28u32);
+ assert_eq!(ctlz64(10u64), 60u64);
+
+ assert_eq!(ctlz8(100u8), 1u8);
+ assert_eq!(ctlz16(100u16), 9u16);
+ assert_eq!(ctlz32(100u32), 25u32);
+ assert_eq!(ctlz64(100u64), 57u64);
+
+ assert_eq!(cttz8(-1u8), 0u8);
+ assert_eq!(cttz16(-1u16), 0u16);
+ assert_eq!(cttz32(-1u32), 0u32);
+ assert_eq!(cttz64(-1u64), 0u64);
+
+ assert_eq!(cttz8(0u8), 8u8);
+ assert_eq!(cttz16(0u16), 16u16);
+ assert_eq!(cttz32(0u32), 32u32);
+ assert_eq!(cttz64(0u64), 64u64);
+
+ assert_eq!(cttz8(1u8), 0u8);
+ assert_eq!(cttz16(1u16), 0u16);
+ assert_eq!(cttz32(1u32), 0u32);
+ assert_eq!(cttz64(1u64), 0u64);
+
+ assert_eq!(cttz8(10u8), 1u8);
+ assert_eq!(cttz16(10u16), 1u16);
+ assert_eq!(cttz32(10u32), 1u32);
+ assert_eq!(cttz64(10u64), 1u64);
+
+ assert_eq!(cttz8(100u8), 2u8);
+ assert_eq!(cttz16(100u16), 2u16);
+ assert_eq!(cttz32(100u32), 2u32);
+ assert_eq!(cttz64(100u64), 2u64);
+
+ assert_eq!(cttz8(-1u8), 0u8);
+ assert_eq!(cttz16(-1u16), 0u16);
+ assert_eq!(cttz32(-1u32), 0u32);
+ assert_eq!(cttz64(-1u64), 0u64);
+
+ assert_eq!(bswap16(0x0A0Bu16), 0x0B0Au16);
+ assert_eq!(bswap32(0x0ABBCC0Du32), 0x0DCCBB0Au32);
+ assert_eq!(bswap64(0x0122334455667708u64), 0x0877665544332201u64);
}
}