From c4a9d8a5e91a08fffb083a10105148380192c5c0 Mon Sep 17 00:00:00 2001 From: Huon Wilson 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(n: u64, size: uint, f: |v: &[u8]| -> T) -> T { assert!(size <= 8u); match size { 1u => f(&[n as u8]), - 2u => f(unsafe { transmute::(to_le16(n as i16)) }), - 4u => f(unsafe { transmute::(to_le32(n as i32)) }), - 8u => f(unsafe { transmute::(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(n: u64, size: uint, f: |v: &[u8]| -> T) -> T { assert!(size <= 8u); match size { 1u => f(&[n as u8]), - 2u => f(unsafe { transmute::(to_be16(n as i16)) }), - 4u => f(unsafe { transmute::(to_be32(n as i32)) }), - 8u => f(unsafe { transmute::(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(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); } }