diff options
46 files changed, 288 insertions, 269 deletions
diff --git a/doc/po/ja/rust.md.po b/doc/po/ja/rust.md.po index b21ddfe3e65..0313a3379b7 100644 --- a/doc/po/ja/rust.md.po +++ b/doc/po/ja/rust.md.po @@ -1842,7 +1842,7 @@ msgid "" "The type parameters can also be explicitly supplied in a trailing [path]" "(#paths) component after the function name. This might be necessary if there " "is not sufficient context to determine the type parameters. For example, " -"`sys::size_of::<u32>() == 4`." +"`mem::size_of::<u32>() == 4`." msgstr "" #. type: Plain text diff --git a/doc/po/ja/tutorial-ffi.md.po b/doc/po/ja/tutorial-ffi.md.po index a9bd3842558..ff28357cabf 100644 --- a/doc/po/ja/tutorial-ffi.md.po +++ b/doc/po/ja/tutorial-ffi.md.po @@ -327,7 +327,7 @@ msgid "" "impl<T: Send> Unique<T> {\n" " pub fn new(value: T) -> Unique<T> {\n" " unsafe {\n" -" let ptr = malloc(std::sys::size_of::<T>() as size_t) as *mut T;\n" +" let ptr = malloc(std::mem::size_of::<T>() as size_t) as *mut T;\n" " assert!(!ptr::is_null(ptr));\n" " // `*ptr` is uninitialized, and `*ptr = value` would attempt to destroy it\n" " intrinsics::move_val_init(&mut *ptr, value);\n" diff --git a/doc/po/rust.md.pot b/doc/po/rust.md.pot index 942fd953ec0..31056378a48 100644 --- a/doc/po/rust.md.pot +++ b/doc/po/rust.md.pot @@ -1842,7 +1842,7 @@ msgid "" "The type parameters can also be explicitly supplied in a trailing [path]" "(#paths) component after the function name. This might be necessary if there " "is not sufficient context to determine the type parameters. For example, " -"`sys::size_of::<u32>() == 4`." +"`mem::size_of::<u32>() == 4`." msgstr "" #. type: Plain text diff --git a/doc/po/tutorial-ffi.md.pot b/doc/po/tutorial-ffi.md.pot index 62bbd921cb8..c3116dea872 100644 --- a/doc/po/tutorial-ffi.md.pot +++ b/doc/po/tutorial-ffi.md.pot @@ -327,7 +327,7 @@ msgid "" "impl<T: Send> Unique<T> {\n" " pub fn new(value: T) -> Unique<T> {\n" " unsafe {\n" -" let ptr = malloc(std::sys::size_of::<T>() as size_t) as *mut T;\n" +" let ptr = malloc(std::mem::size_of::<T>() as size_t) as *mut T;\n" " assert!(!ptr::is_null(ptr));\n" " // `*ptr` is uninitialized, and `*ptr = value` would attempt to destroy it\n" " intrinsics::move_val_init(&mut *ptr, value);\n" diff --git a/doc/rust.md b/doc/rust.md index f40a3e3a114..621bf927e39 100644 --- a/doc/rust.md +++ b/doc/rust.md @@ -975,7 +975,7 @@ with `int`, and require the closure parameter to have type The type parameters can also be explicitly supplied in a trailing [path](#paths) component after the function name. This might be necessary if there is not sufficient context to determine the type parameters. For -example, `sys::size_of::<u32>() == 4`. +example, `mem::size_of::<u32>() == 4`. Since a parameter type is opaque to the generic function, the set of operations that can be performed on it is limited. Values of parameter diff --git a/doc/tutorial-ffi.md b/doc/tutorial-ffi.md index 38aea02f040..57dc926dfa9 100644 --- a/doc/tutorial-ffi.md +++ b/doc/tutorial-ffi.md @@ -300,7 +300,7 @@ impl<T: Send> Unique<T> { #[inline(never)]; unsafe { - let ptr = malloc(std::sys::size_of::<T>() as size_t) as *mut T; + let ptr = malloc(std::mem::size_of::<T>() as size_t) as *mut T; assert!(!ptr::is_null(ptr)); // `*ptr` is uninitialized, and `*ptr = value` would attempt to destroy it intrinsics::move_val_init(&mut *ptr, value); diff --git a/src/libextra/arena.rs b/src/libextra/arena.rs index 520faad1afa..6c4e86d958e 100644 --- a/src/libextra/arena.rs +++ b/src/libextra/arena.rs @@ -42,7 +42,7 @@ use std::cast::{transmute, transmute_mut, transmute_mut_region}; use std::cast; use std::num; use std::ptr; -use std::sys; +use std::mem; use std::uint; use std::vec; use std::unstable::intrinsics; @@ -123,7 +123,7 @@ unsafe fn destroy_chunk(chunk: &Chunk) { let (tydesc, is_done) = un_bitpack_tydesc_ptr(*tydesc_data); let (size, align) = ((*tydesc).size, (*tydesc).align); - let after_tydesc = idx + sys::size_of::<*TyDesc>(); + let after_tydesc = idx + mem::size_of::<*TyDesc>(); let start = round_up_to(after_tydesc, align); @@ -134,7 +134,7 @@ unsafe fn destroy_chunk(chunk: &Chunk) { } // Find where the next tydesc lives - idx = round_up_to(start + size, sys::pref_align_of::<*TyDesc>()); + idx = round_up_to(start + size, mem::pref_align_of::<*TyDesc>()); } } @@ -220,7 +220,7 @@ impl Arena { let head = transmute_mut_region(&mut self.head); tydesc_start = head.fill; - after_tydesc = head.fill + sys::size_of::<*TyDesc>(); + after_tydesc = head.fill + mem::size_of::<*TyDesc>(); start = round_up_to(after_tydesc, align); end = start + n_bytes; } @@ -230,7 +230,7 @@ impl Arena { } let head = transmute_mut_region(&mut self.head); - head.fill = round_up_to(end, sys::pref_align_of::<*TyDesc>()); + head.fill = round_up_to(end, mem::pref_align_of::<*TyDesc>()); //debug2!("idx = {}, size = {}, align = {}, fill = {}", // start, n_bytes, align, head.fill); diff --git a/src/libstd/at_vec.rs b/src/libstd/at_vec.rs index f6669893170..8607710edc3 100644 --- a/src/libstd/at_vec.rs +++ b/src/libstd/at_vec.rs @@ -14,7 +14,7 @@ use clone::Clone; use container::Container; use iter::Iterator; use option::{Option, Some, None}; -use sys; +use mem; use unstable::raw::Repr; use vec::{ImmutableVector, OwnedVector}; @@ -26,7 +26,7 @@ use vec::{ImmutableVector, OwnedVector}; pub fn capacity<T>(v: @[T]) -> uint { unsafe { let box = v.repr(); - (*box).data.alloc / sys::size_of::<T>() + (*box).data.alloc / mem::size_of::<T>() } } @@ -160,7 +160,7 @@ pub mod raw { use cast::{transmute, transmute_copy}; use libc; use ptr; - use sys; + use mem; use uint; use unstable::intrinsics::{move_val_init, TyDesc}; use unstable::intrinsics; @@ -176,7 +176,7 @@ pub mod raw { #[inline] pub unsafe fn set_len<T>(v: &mut @[T], new_len: uint) { let repr: *mut Box<Vec<T>> = cast::transmute_copy(v); - (*repr).data.fill = new_len * sys::size_of::<T>(); + (*repr).data.fill = new_len * mem::size_of::<T>(); } /** @@ -199,7 +199,7 @@ pub mod raw { unsafe fn push_fast<T>(v: &mut @[T], initval: T) { let repr: *mut Box<Vec<T>> = cast::transmute_copy(v); let amt = v.len(); - (*repr).data.fill += sys::size_of::<T>(); + (*repr).data.fill += mem::size_of::<T>(); let p = ptr::offset(&(*repr).data.data as *T, amt as int) as *mut T; move_val_init(&mut(*p), initval); } @@ -236,7 +236,7 @@ pub mod raw { unsafe { if n > (**ptr).data.alloc / (*ty).size { let alloc = n * (*ty).size; - let total_size = alloc + sys::size_of::<Vec<()>>(); + let total_size = alloc + mem::size_of::<Vec<()>>(); if alloc / (*ty).size != n || total_size < alloc { fail2!("vector size is too large: {}", n); } diff --git a/src/libstd/cast.rs b/src/libstd/cast.rs index e028bbeac68..a4f2ee0d09c 100644 --- a/src/libstd/cast.rs +++ b/src/libstd/cast.rs @@ -11,7 +11,7 @@ //! Unsafe casting functions use ptr::RawPtr; -use sys; +use mem; use unstable::intrinsics; /// Casts the value at `src` to U. The two types must have the same length. @@ -21,7 +21,7 @@ pub unsafe fn transmute_copy<T, U>(src: &T) -> U { let mut dest: U = intrinsics::uninit(); let dest_ptr: *mut u8 = transmute(&mut dest); let src_ptr: *u8 = transmute(src); - intrinsics::memcpy32(dest_ptr, src_ptr, sys::size_of::<U>() as u32); + intrinsics::memcpy32(dest_ptr, src_ptr, mem::size_of::<U>() as u32); dest } @@ -32,7 +32,7 @@ pub unsafe fn transmute_copy<T, U>(src: &T) -> U { let mut dest: U = intrinsics::uninit(); let dest_ptr: *mut u8 = transmute(&mut dest); let src_ptr: *u8 = transmute(src); - intrinsics::memcpy64(dest_ptr, src_ptr, sys::size_of::<U>() as u64); + intrinsics::memcpy64(dest_ptr, src_ptr, mem::size_of::<U>() as u64); dest } diff --git a/src/libstd/cleanup.rs b/src/libstd/cleanup.rs index 38925621f12..a8c4d9fdca3 100644 --- a/src/libstd/cleanup.rs +++ b/src/libstd/cleanup.rs @@ -68,7 +68,7 @@ fn debug_mem() -> bool { /// Destroys all managed memory (i.e. @ boxes) held by the current task. pub unsafe fn annihilate() { use rt::local_heap::local_free; - use sys; + use mem; use managed; let mut stats = AnnihilateStats { @@ -115,7 +115,7 @@ pub unsafe fn annihilate() { if !uniq { stats.n_bytes_freed += (*((*box).type_desc)).size - + sys::size_of::<raw::Box<()>>(); + + mem::size_of::<raw::Box<()>>(); local_free(box as *i8); } true diff --git a/src/libstd/mem.rs b/src/libstd/mem.rs new file mode 100644 index 00000000000..311bf5f6bc8 --- /dev/null +++ b/src/libstd/mem.rs @@ -0,0 +1,158 @@ +// Copyright 2012 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +//! Functions relating to memory layout + +use unstable::intrinsics; + +/// Returns the size of a type +#[inline] +pub fn size_of<T>() -> uint { + unsafe { intrinsics::size_of::<T>() } +} + +/// Returns the size of the type that `_val` points to +#[inline] +pub fn size_of_val<T>(_val: &T) -> uint { + size_of::<T>() +} + +/** + * Returns the size of a type, or 1 if the actual size is zero. + * + * Useful for building structures containing variable-length arrays. + */ +#[inline] +pub fn nonzero_size_of<T>() -> uint { + let s = size_of::<T>(); + if s == 0 { 1 } else { s } +} + +/// Returns the size of the type of the value that `_val` points to +#[inline] +pub fn nonzero_size_of_val<T>(_val: &T) -> uint { + nonzero_size_of::<T>() +} + + +/** + * Returns the ABI-required minimum alignment of a type + * + * This is the alignment used for struct fields. It may be smaller + * than the preferred alignment. + */ +#[inline] +pub fn min_align_of<T>() -> uint { + unsafe { intrinsics::min_align_of::<T>() } +} + +/// Returns the ABI-required minimum alignment of the type of the value that +/// `_val` points to +#[inline] +pub fn min_align_of_val<T>(_val: &T) -> uint { + min_align_of::<T>() +} + +/// Returns the preferred alignment of a type +#[inline] +pub fn pref_align_of<T>() -> uint { + unsafe { intrinsics::pref_align_of::<T>() } +} + +/// Returns the preferred alignment of the type of the value that +/// `_val` points to +#[inline] +pub fn pref_align_of_val<T>(_val: &T) -> uint { + pref_align_of::<T>() +} + +#[cfg(test)] +mod tests { + use cast; + use mem::*; + + #[test] + fn size_of_basic() { + assert_eq!(size_of::<u8>(), 1u); + assert_eq!(size_of::<u16>(), 2u); + assert_eq!(size_of::<u32>(), 4u); + assert_eq!(size_of::<u64>(), 8u); + } + + #[test] + #[cfg(target_arch = "x86")] + #[cfg(target_arch = "arm")] + #[cfg(target_arch = "mips")] + fn size_of_32() { + assert_eq!(size_of::<uint>(), 4u); + assert_eq!(size_of::<*uint>(), 4u); + } + + #[test] + #[cfg(target_arch = "x86_64")] + fn size_of_64() { + assert_eq!(size_of::<uint>(), 8u); + assert_eq!(size_of::<*uint>(), 8u); + } + + #[test] + fn size_of_val_basic() { + assert_eq!(size_of_val(&1u8), 1); + assert_eq!(size_of_val(&1u16), 2); + assert_eq!(size_of_val(&1u32), 4); + assert_eq!(size_of_val(&1u64), 8); + } + + #[test] + fn nonzero_size_of_basic() { + type Z = [i8, ..0]; + assert_eq!(size_of::<Z>(), 0u); + assert_eq!(nonzero_size_of::<Z>(), 1u); + assert_eq!(nonzero_size_of::<uint>(), size_of::<uint>()); + } + + #[test] + fn nonzero_size_of_val_basic() { + let z = [0u8, ..0]; + assert_eq!(size_of_val(&z), 0u); + assert_eq!(nonzero_size_of_val(&z), 1u); + assert_eq!(nonzero_size_of_val(&1u), size_of_val(&1u)); + } + + #[test] + fn align_of_basic() { + assert_eq!(pref_align_of::<u8>(), 1u); + assert_eq!(pref_align_of::<u16>(), 2u); + assert_eq!(pref_align_of::<u32>(), 4u); + } + + #[test] + #[cfg(target_arch = "x86")] + #[cfg(target_arch = "arm")] + #[cfg(target_arch = "mips")] + fn align_of_32() { + assert_eq!(pref_align_of::<uint>(), 4u); + assert_eq!(pref_align_of::<*uint>(), 4u); + } + + #[test] + #[cfg(target_arch = "x86_64")] + fn align_of_64() { + assert_eq!(pref_align_of::<uint>(), 8u); + assert_eq!(pref_align_of::<*uint>(), 8u); + } + + #[test] + fn align_of_val_basic() { + assert_eq!(pref_align_of_val(&1u8), 1u); + assert_eq!(pref_align_of_val(&1u16), 2u); + assert_eq!(pref_align_of_val(&1u32), 4u); + } +} diff --git a/src/libstd/num/f32.rs b/src/libstd/num/f32.rs index 2b4a636e1ad..e99dcd6b2eb 100644 --- a/src/libstd/num/f32.rs +++ b/src/libstd/num/f32.rs @@ -928,7 +928,7 @@ mod tests { use num::*; use num; - use sys; + use mem; #[test] fn test_num() { @@ -1198,8 +1198,8 @@ mod tests { #[test] fn test_primitive() { let none: Option<f32> = None; - assert_eq!(Primitive::bits(none), sys::size_of::<f32>() * 8); - assert_eq!(Primitive::bytes(none), sys::size_of::<f32>()); + assert_eq!(Primitive::bits(none), mem::size_of::<f32>() * 8); + assert_eq!(Primitive::bytes(none), mem::size_of::<f32>()); } #[test] diff --git a/src/libstd/num/f64.rs b/src/libstd/num/f64.rs index d4442e5b34f..f367de376d4 100644 --- a/src/libstd/num/f64.rs +++ b/src/libstd/num/f64.rs @@ -976,7 +976,7 @@ mod tests { use num::*; use num; - use sys; + use mem; #[test] fn test_num() { @@ -1249,8 +1249,8 @@ mod tests { #[test] fn test_primitive() { let none: Option<f64> = None; - assert_eq!(Primitive::bits(none), sys::size_of::<f64>() * 8); - assert_eq!(Primitive::bytes(none), sys::size_of::<f64>()); + assert_eq!(Primitive::bits(none), mem::size_of::<f64>() * 8); + assert_eq!(Primitive::bytes(none), mem::size_of::<f64>()); } #[test] diff --git a/src/libstd/num/int_macros.rs b/src/libstd/num/int_macros.rs index 7fae567809b..694e5e7f6bf 100644 --- a/src/libstd/num/int_macros.rs +++ b/src/libstd/num/int_macros.rs @@ -456,7 +456,7 @@ mod tests { use int; use i32; use num; - use sys; + use mem; #[test] fn test_num() { @@ -653,8 +653,8 @@ mod tests { #[test] fn test_primitive() { let none: Option<$T> = None; - assert_eq!(Primitive::bits(none), sys::size_of::<$T>() * 8); - assert_eq!(Primitive::bytes(none), sys::size_of::<$T>()); + assert_eq!(Primitive::bits(none), mem::size_of::<$T>() * 8); + assert_eq!(Primitive::bytes(none), mem::size_of::<$T>()); } #[test] diff --git a/src/libstd/num/uint.rs b/src/libstd/num/uint.rs index 38a4df270fc..2ecbb79407e 100644 --- a/src/libstd/num/uint.rs +++ b/src/libstd/num/uint.rs @@ -14,7 +14,7 @@ use num; use num::{CheckedAdd, CheckedSub, CheckedMul}; use option::{Option, Some, None}; use unstable::intrinsics; -use sys; +use mem; pub use self::generated::*; @@ -97,7 +97,7 @@ impl num::Times for uint { /// Returns the smallest power of 2 greater than or equal to `n` #[inline] pub fn next_power_of_two(n: uint) -> uint { - let halfbits: uint = sys::size_of::<uint>() * 4u; + let halfbits: uint = mem::size_of::<uint>() * 4u; let mut tmp: uint = n - 1u; let mut shift: uint = 1u; while shift <= halfbits { tmp |= tmp >> shift; shift <<= 1u; } @@ -107,7 +107,7 @@ pub fn next_power_of_two(n: uint) -> uint { /// Returns the smallest power of 2 greater than or equal to `n` #[inline] pub fn next_power_of_two_opt(n: uint) -> Option<uint> { - let halfbits: uint = sys::size_of::<uint>() * 4u; + let halfbits: uint = mem::size_of::<uint>() * 4u; let mut tmp: uint = n - 1u; let mut shift: uint = 1u; while shift <= halfbits { tmp |= tmp >> shift; shift <<= 1u; } diff --git a/src/libstd/num/uint_macros.rs b/src/libstd/num/uint_macros.rs index f52feced67c..2974b402d4a 100644 --- a/src/libstd/num/uint_macros.rs +++ b/src/libstd/num/uint_macros.rs @@ -337,7 +337,7 @@ mod tests { use super::*; use num; - use sys; + use mem; use u16; #[test] @@ -431,8 +431,8 @@ mod tests { #[test] fn test_primitive() { let none: Option<$T> = None; - assert_eq!(Primitive::bits(none), sys::size_of::<$T>() * 8); - assert_eq!(Primitive::bytes(none), sys::size_of::<$T>()); + assert_eq!(Primitive::bits(none), mem::size_of::<$T>() * 8); + assert_eq!(Primitive::bytes(none), mem::size_of::<$T>()); } #[test] diff --git a/src/libstd/rand/mod.rs b/src/libstd/rand/mod.rs index 1e76effd0d2..954db42c89b 100644 --- a/src/libstd/rand/mod.rs +++ b/src/libstd/rand/mod.rs @@ -52,7 +52,7 @@ fn main () { ``` */ -use sys::size_of; +use mem::size_of; use unstable::raw::Slice; use cast; use container::Container; @@ -952,7 +952,7 @@ mod test { mod bench { use extra::test::BenchHarness; use rand::*; - use sys::size_of; + use mem::size_of; #[bench] fn rand_xorshift(bh: &mut BenchHarness) { diff --git a/src/libstd/reflect.rs b/src/libstd/reflect.rs index 292330de7b5..1cd76727716 100644 --- a/src/libstd/reflect.rs +++ b/src/libstd/reflect.rs @@ -18,7 +18,7 @@ Runtime type reflection use unstable::intrinsics::{Opaque, TyDesc, TyVisitor}; use libc::c_void; -use sys; +use mem; use unstable::raw; /** @@ -64,12 +64,12 @@ impl<V:TyVisitor + MovePtr> MovePtrAdaptor<V> { #[inline] pub fn align_to<T>(&mut self) { - self.align(sys::min_align_of::<T>()); + self.align(mem::min_align_of::<T>()); } #[inline] pub fn bump_past<T>(&mut self) { - self.bump(sys::size_of::<T>()); + self.bump(mem::size_of::<T>()); } } diff --git a/src/libstd/rt/context.rs b/src/libstd/rt/context.rs index 853cc08a0ba..222f9a44b17 100644 --- a/src/libstd/rt/context.rs +++ b/src/libstd/rt/context.rs @@ -233,6 +233,6 @@ fn align_down(sp: *mut uint) -> *mut uint { // ptr::mut_offset is positive ints only #[inline] pub fn mut_offset<T>(ptr: *mut T, count: int) -> *mut T { - use std::sys::size_of; + use mem::size_of; (ptr as int + count * (size_of::<T>() as int)) as *mut T } diff --git a/src/libstd/rt/global_heap.rs b/src/libstd/rt/global_heap.rs index 7d3f5f91774..446efbd9047 100644 --- a/src/libstd/rt/global_heap.rs +++ b/src/libstd/rt/global_heap.rs @@ -11,7 +11,7 @@ use libc::{c_void, c_char, size_t, uintptr_t, free, malloc, realloc}; use unstable::intrinsics::TyDesc; use unstable::raw; -use sys::size_of; +use mem::size_of; extern { #[rust_stack] diff --git a/src/libstd/rt/io/native/process.rs b/src/libstd/rt/io/native/process.rs index d338192c664..57367beacd8 100644 --- a/src/libstd/rt/io/native/process.rs +++ b/src/libstd/rt/io/native/process.rs @@ -271,12 +271,12 @@ fn spawn_process_os(prog: &str, args: &[~str], }; use libc::funcs::extra::msvcrt::get_osfhandle; - use sys; + use mem; unsafe { let mut si = zeroed_startupinfo(); - si.cb = sys::size_of::<STARTUPINFO>() as DWORD; + si.cb = mem::size_of::<STARTUPINFO>() as DWORD; si.dwFlags = STARTF_USESTDHANDLES; let cur_proc = GetCurrentProcess(); diff --git a/src/libstd/rt/sched.rs b/src/libstd/rt/sched.rs index 0a4622bc65e..7724f58153e 100644 --- a/src/libstd/rt/sched.rs +++ b/src/libstd/rt/sched.rs @@ -857,7 +857,7 @@ fn new_sched_rng() -> XorShiftRng { #[fixed_stack_segment] #[inline(never)] fn new_sched_rng() -> XorShiftRng { use libc; - use sys; + use mem; use c_str::ToCStr; use vec::MutableVector; use iter::Iterator; @@ -871,7 +871,7 @@ fn new_sched_rng() -> XorShiftRng { } let mut seeds = [0u32, .. 4]; - let size = sys::size_of_val(&seeds); + let size = mem::size_of_val(&seeds); loop { let nbytes = do seeds.as_mut_buf |buf, _| { unsafe { diff --git a/src/libstd/rt/test.rs b/src/libstd/rt/test.rs index 1178bfdaa80..9f4e6558ac5 100644 --- a/src/libstd/rt/test.rs +++ b/src/libstd/rt/test.rs @@ -103,7 +103,7 @@ mod darwin_fd_limit { // The strategy here is to fetch the current resource limits, read the kern.maxfilesperproc // sysctl value, and bump the soft resource limit for maxfiles up to the sysctl value. use ptr::{to_unsafe_ptr, to_mut_unsafe_ptr, mut_null}; - use sys::size_of_val; + use mem::size_of_val; use os::last_os_error; // Fetch the kern.maxfilesperproc value diff --git a/src/libstd/std.rs b/src/libstd/std.rs index 73cb6a5645d..c446fe3d94f 100644 --- a/src/libstd/std.rs +++ b/src/libstd/std.rs @@ -189,6 +189,7 @@ pub mod condition; pub mod logging; pub mod util; pub mod routine; +pub mod mem; /* Unsupported interfaces */ diff --git a/src/libstd/sys.rs b/src/libstd/sys.rs index 10c3fed1d54..0299ca0b49a 100644 --- a/src/libstd/sys.rs +++ b/src/libstd/sys.rs @@ -19,68 +19,6 @@ use libc; use repr; use rt::task; use str; -use unstable::intrinsics; - -/// Returns the size of a type -#[inline] -pub fn size_of<T>() -> uint { - unsafe { intrinsics::size_of::<T>() } -} - -/// Returns the size of the type that `_val` points to -#[inline] -pub fn size_of_val<T>(_val: &T) -> uint { - size_of::<T>() -} - -/** - * Returns the size of a type, or 1 if the actual size is zero. - * - * Useful for building structures containing variable-length arrays. - */ -#[inline] -pub fn nonzero_size_of<T>() -> uint { - let s = size_of::<T>(); - if s == 0 { 1 } else { s } -} - -/// Returns the size of the type of the value that `_val` points to -#[inline] -pub fn nonzero_size_of_val<T>(_val: &T) -> uint { - nonzero_size_of::<T>() -} - - -/** - * Returns the ABI-required minimum alignment of a type - * - * This is the alignment used for struct fields. It may be smaller - * than the preferred alignment. - */ -#[inline] -pub fn min_align_of<T>() -> uint { - unsafe { intrinsics::min_align_of::<T>() } -} - -/// Returns the ABI-required minimum alignment of the type of the value that -/// `_val` points to -#[inline] -pub fn min_align_of_val<T>(_val: &T) -> uint { - min_align_of::<T>() -} - -/// Returns the preferred alignment of a type -#[inline] -pub fn pref_align_of<T>() -> uint { - unsafe { intrinsics::pref_align_of::<T>() } -} - -/// Returns the preferred alignment of the type of the value that -/// `_val` points to -#[inline] -pub fn pref_align_of_val<T>(_val: &T) -> uint { - pref_align_of::<T>() -} /// Returns the refcount of a shared box (as just before calling this) #[inline] @@ -132,84 +70,6 @@ mod tests { use sys::*; #[test] - fn size_of_basic() { - assert_eq!(size_of::<u8>(), 1u); - assert_eq!(size_of::<u16>(), 2u); - assert_eq!(size_of::<u32>(), 4u); - assert_eq!(size_of::<u64>(), 8u); - } - - #[test] - #[cfg(target_arch = "x86")] - #[cfg(target_arch = "arm")] - #[cfg(target_arch = "mips")] - fn size_of_32() { - assert_eq!(size_of::<uint>(), 4u); - assert_eq!(size_of::<*uint>(), 4u); - } - - #[test] - #[cfg(target_arch = "x86_64")] - fn size_of_64() { - assert_eq!(size_of::<uint>(), 8u); - assert_eq!(size_of::<*uint>(), 8u); - } - - #[test] - fn size_of_val_basic() { - assert_eq!(size_of_val(&1u8), 1); - assert_eq!(size_of_val(&1u16), 2); - assert_eq!(size_of_val(&1u32), 4); - assert_eq!(size_of_val(&1u64), 8); - } - - #[test] - fn nonzero_size_of_basic() { - type Z = [i8, ..0]; - assert_eq!(size_of::<Z>(), 0u); - assert_eq!(nonzero_size_of::<Z>(), 1u); - assert_eq!(nonzero_size_of::<uint>(), size_of::<uint>()); - } - - #[test] - fn nonzero_size_of_val_basic() { - let z = [0u8, ..0]; - assert_eq!(size_of_val(&z), 0u); - assert_eq!(nonzero_size_of_val(&z), 1u); - assert_eq!(nonzero_size_of_val(&1u), size_of_val(&1u)); - } - - #[test] - fn align_of_basic() { - assert_eq!(pref_align_of::<u8>(), 1u); - assert_eq!(pref_align_of::<u16>(), 2u); - assert_eq!(pref_align_of::<u32>(), 4u); - } - - #[test] - #[cfg(target_arch = "x86")] - #[cfg(target_arch = "arm")] - #[cfg(target_arch = "mips")] - fn align_of_32() { - assert_eq!(pref_align_of::<uint>(), 4u); - assert_eq!(pref_align_of::<*uint>(), 4u); - } - - #[test] - #[cfg(target_arch = "x86_64")] - fn align_of_64() { - assert_eq!(pref_align_of::<uint>(), 8u); - assert_eq!(pref_align_of::<*uint>(), 8u); - } - - #[test] - fn align_of_val_basic() { - assert_eq!(pref_align_of_val(&1u8), 1u); - assert_eq!(pref_align_of_val(&1u16), 2u); - assert_eq!(pref_align_of_val(&1u32), 4u); - } - - #[test] fn synthesize_closure() { use unstable::raw::Closure; unsafe { diff --git a/src/libstd/unstable/sync.rs b/src/libstd/unstable/sync.rs index f3945d8f3c9..0b28497e640 100644 --- a/src/libstd/unstable/sync.rs +++ b/src/libstd/unstable/sync.rs @@ -425,7 +425,7 @@ mod tests { use super::{Exclusive, UnsafeArc, atomically}; use task; use util; - use sys::size_of; + use mem::size_of; //#[unsafe_no_drop_flag] FIXME: #9758 #[ignore] diff --git a/src/libstd/util.rs b/src/libstd/util.rs index 44cfdb86057..3e44a30e47b 100644 --- a/src/libstd/util.rs +++ b/src/libstd/util.rs @@ -93,7 +93,7 @@ mod tests { use ops::Drop; use option::{None, Some}; use either::{Either, Left, Right}; - use sys::size_of; + use mem::size_of; #[test] fn identity_crisis() { diff --git a/src/libstd/vec.rs b/src/libstd/vec.rs index 60c569e75d0..d298507aa8c 100644 --- a/src/libstd/vec.rs +++ b/src/libstd/vec.rs @@ -116,8 +116,8 @@ use ptr; use ptr::RawPtr; use rt::global_heap::malloc_raw; use rt::global_heap::realloc_raw; -use sys; -use sys::size_of; +use mem; +use mem::size_of; use uint; use unstable::finally::Finally; use unstable::intrinsics; @@ -185,8 +185,8 @@ pub fn with_capacity<T>(capacity: uint) -> ~[T] { vec.reserve(capacity); vec } else { - let alloc = capacity * sys::nonzero_size_of::<T>(); - let ptr = malloc_raw(alloc + sys::size_of::<Vec<()>>()) as *mut Vec<()>; + let alloc = capacity * mem::nonzero_size_of::<T>(); + let ptr = malloc_raw(alloc + mem::size_of::<Vec<()>>()) as *mut Vec<()>; (*ptr).alloc = alloc; (*ptr).fill = 0; cast::transmute(ptr) @@ -1002,7 +1002,7 @@ impl<'self,T> ImmutableVector<'self, T> for &'self [T] { fn iter(self) -> VecIterator<'self, T> { unsafe { let p = vec::raw::to_ptr(self); - if sys::size_of::<T>() == 0 { + if mem::size_of::<T>() == 0 { VecIterator{ptr: p, end: (p as uint + self.len()) as *T, lifetime: None} @@ -1406,9 +1406,9 @@ impl<T> OwnedVector<T> for ~[T] { ::at_vec::raw::reserve_raw(td, ptr, n); } else { let ptr: *mut *mut Vec<()> = cast::transmute(self); - let alloc = n * sys::nonzero_size_of::<T>(); - let size = alloc + sys::size_of::<Vec<()>>(); - if alloc / sys::nonzero_size_of::<T>() != n || size < alloc { + let alloc = n * mem::nonzero_size_of::<T>(); + let size = alloc + mem::size_of::<Vec<()>>(); + if alloc / mem::nonzero_size_of::<T>() != n || size < alloc { fail2!("vector size is too large: {}", n); } *ptr = realloc_raw(*ptr as *mut c_void, size) @@ -1439,10 +1439,10 @@ impl<T> OwnedVector<T> for ~[T] { unsafe { if contains_managed::<T>() { let repr: **Box<Vec<()>> = cast::transmute(self); - (**repr).data.alloc / sys::nonzero_size_of::<T>() + (**repr).data.alloc / mem::nonzero_size_of::<T>() } else { let repr: **Vec<()> = cast::transmute(self); - (**repr).alloc / sys::nonzero_size_of::<T>() + (**repr).alloc / mem::nonzero_size_of::<T>() } } } @@ -1451,7 +1451,7 @@ impl<T> OwnedVector<T> for ~[T] { unsafe { let ptr: *mut *mut Vec<()> = cast::transmute(self); let alloc = (**ptr).fill; - let size = alloc + sys::size_of::<Vec<()>>(); + let size = alloc + mem::size_of::<Vec<()>>(); *ptr = realloc_raw(*ptr as *mut c_void, size) as *mut Vec<()>; (**ptr).alloc = alloc; } @@ -1485,14 +1485,14 @@ impl<T> OwnedVector<T> for ~[T] { if contains_managed::<T>() { let repr: **mut Box<Vec<u8>> = cast::transmute(this); let fill = (**repr).data.fill; - (**repr).data.fill += sys::nonzero_size_of::<T>(); + (**repr).data.fill += mem::nonzero_size_of::<T>(); let p = to_unsafe_ptr(&((**repr).data.data)); let p = ptr::offset(p, fill as int) as *mut T; intrinsics::move_val_init(&mut(*p), t); } else { let repr: **mut Vec<u8> = cast::transmute(this); let fill = (**repr).fill; - (**repr).fill += sys::nonzero_size_of::<T>(); + (**repr).fill += mem::nonzero_size_of::<T>(); let p = to_unsafe_ptr(&((**repr).data)); let p = ptr::offset(p, fill as int) as *mut T; intrinsics::move_val_init(&mut(*p), t); @@ -1957,7 +1957,7 @@ impl<'self,T> MutableVector<'self, T> for &'self mut [T] { fn mut_iter(self) -> VecMutIterator<'self, T> { unsafe { let p = vec::raw::to_mut_ptr(self); - if sys::size_of::<T>() == 0 { + if mem::size_of::<T>() == 0 { VecMutIterator{ptr: p, end: (p as uint + self.len()) as *mut T, lifetime: None} @@ -2054,7 +2054,7 @@ pub mod raw { use clone::Clone; use option::Some; use ptr; - use sys; + use mem; use unstable::intrinsics; use vec::{with_capacity, ImmutableVector, MutableVector}; use unstable::intrinsics::contains_managed; @@ -2071,10 +2071,10 @@ pub mod raw { pub unsafe fn set_len<T>(v: &mut ~[T], new_len: uint) { if contains_managed::<T>() { let repr: **mut Box<Vec<()>> = cast::transmute(v); - (**repr).data.fill = new_len * sys::nonzero_size_of::<T>(); + (**repr).data.fill = new_len * mem::nonzero_size_of::<T>(); } else { let repr: **mut Vec<()> = cast::transmute(v); - (**repr).fill = new_len * sys::nonzero_size_of::<T>(); + (**repr).fill = new_len * mem::nonzero_size_of::<T>(); } } @@ -2323,7 +2323,7 @@ macro_rules! iterator { None } else { let old = self.ptr; - self.ptr = if sys::size_of::<T>() == 0 { + self.ptr = if mem::size_of::<T>() == 0 { // purposefully don't use 'ptr.offset' because for // vectors with 0-size elements this would return the // same pointer. @@ -2340,7 +2340,7 @@ macro_rules! iterator { #[inline] fn size_hint(&self) -> (uint, Option<uint>) { let diff = (self.end as uint) - (self.ptr as uint); - let exact = diff / sys::nonzero_size_of::<T>(); + let exact = diff / mem::nonzero_size_of::<T>(); (exact, Some(exact)) } } @@ -2357,7 +2357,7 @@ macro_rules! double_ended_iterator { if self.end == self.ptr { None } else { - self.end = if sys::size_of::<T>() == 0 { + self.end = if mem::size_of::<T>() == 0 { // See above for why 'ptr.offset' isn't used cast::transmute(self.end as uint - 1) } else { @@ -2497,7 +2497,7 @@ impl<A> Extendable<A> for ~[A] { #[cfg(test)] mod tests { use option::{None, Option, Some}; - use sys; + use mem; use vec::*; use cmp::*; use prelude::*; @@ -2597,7 +2597,7 @@ mod tests { let v0 : &[Z] = &[]; let v1 : &[Z] = &[[]]; let v2 : &[Z] = &[[], []]; - assert_eq!(sys::size_of::<Z>(), 0); + assert_eq!(mem::size_of::<Z>(), 0); assert_eq!(v0.len(), 0); assert_eq!(v1.len(), 1); assert_eq!(v2.len(), 2); diff --git a/src/test/run-fail/bounds-check-no-overflow.rs b/src/test/run-fail/bounds-check-no-overflow.rs index 679f060a55d..faced3531f5 100644 --- a/src/test/run-fail/bounds-check-no-overflow.rs +++ b/src/test/run-fail/bounds-check-no-overflow.rs @@ -11,7 +11,7 @@ // error-pattern:index out of bounds: the len is 3 but the index is use std::uint::max_value; -use std::sys::size_of; +use std::mem::size_of; fn main() { let xs = [1, 2, 3]; diff --git a/src/test/run-fail/bug-2470-bounds-check-overflow.rs b/src/test/run-fail/bug-2470-bounds-check-overflow.rs index 083ea5b8f19..17b4c83788c 100644 --- a/src/test/run-fail/bug-2470-bounds-check-overflow.rs +++ b/src/test/run-fail/bug-2470-bounds-check-overflow.rs @@ -10,7 +10,7 @@ // error-pattern:index out of bounds -use std::sys; +use std::mem; fn main() { @@ -23,12 +23,12 @@ fn main() { let x = ~[1u,2u,3u]; do x.as_imm_buf |p, _len| { let base = p as uint; - let idx = base / sys::size_of::<uint>(); + let idx = base / mem::size_of::<uint>(); error2!("ov1 base = 0x{:x}", base); error2!("ov1 idx = 0x{:x}", idx); - error2!("ov1 sizeof::<uint>() = 0x{:x}", sys::size_of::<uint>()); + error2!("ov1 sizeof::<uint>() = 0x{:x}", mem::size_of::<uint>()); error2!("ov1 idx * sizeof::<uint>() = 0x{:x}", - idx * sys::size_of::<uint>()); + idx * mem::size_of::<uint>()); // This should fail. error2!("ov1 0x{:x}", x[idx]); diff --git a/src/test/run-pass/attr-no-drop-flag-size.rs b/src/test/run-pass/attr-no-drop-flag-size.rs index bbc6501bc77..48768a1c6fd 100644 --- a/src/test/run-pass/attr-no-drop-flag-size.rs +++ b/src/test/run-pass/attr-no-drop-flag-size.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::sys::size_of; +use std::mem::size_of; #[unsafe_no_drop_flag] struct Test<T> { diff --git a/src/test/run-pass/enum-alignment.rs b/src/test/run-pass/enum-alignment.rs index a36aaaf936d..4c60cfb7328 100644 --- a/src/test/run-pass/enum-alignment.rs +++ b/src/test/run-pass/enum-alignment.rs @@ -10,7 +10,7 @@ use std::cast; use std::ptr; -use std::sys; +use std::mem; fn addr_of<T>(ptr: &T) -> uint { let ptr = ptr::to_unsafe_ptr(ptr); @@ -20,7 +20,7 @@ fn addr_of<T>(ptr: &T) -> uint { fn is_aligned<T>(ptr: &T) -> bool { unsafe { let addr: uint = cast::transmute(ptr); - (addr % sys::min_align_of::<T>()) == 0 + (addr % mem::min_align_of::<T>()) == 0 } } diff --git a/src/test/run-pass/enum-discrim-width-stuff.rs b/src/test/run-pass/enum-discrim-width-stuff.rs index 71f0b0f9475..65f93b1c3c2 100644 --- a/src/test/run-pass/enum-discrim-width-stuff.rs +++ b/src/test/run-pass/enum-discrim-width-stuff.rs @@ -8,12 +8,12 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::sys; +use std::mem; pub fn main() { enum E { V = 0x1717171717171717 } static C: E = V; - let expected: u64 = if sys::size_of::<uint>() < 8 { + let expected: u64 = if mem::size_of::<uint>() < 8 { 0x17171717 } else { 0x1717171717171717 diff --git a/src/test/run-pass/fn-bare-size.rs b/src/test/run-pass/fn-bare-size.rs index 144cc7c1e28..cdde98331e2 100644 --- a/src/test/run-pass/fn-bare-size.rs +++ b/src/test/run-pass/fn-bare-size.rs @@ -8,9 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::sys; +use std::mem; pub fn main() { // Bare functions should just be a pointer - assert_eq!(sys::size_of::<extern "Rust" fn()>(), sys::size_of::<int>()); + assert_eq!(mem::size_of::<extern "Rust" fn()>(), mem::size_of::<int>()); } diff --git a/src/test/run-pass/issue-2895.rs b/src/test/run-pass/issue-2895.rs index f325756d368..1e1db393780 100644 --- a/src/test/run-pass/issue-2895.rs +++ b/src/test/run-pass/issue-2895.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::sys; +use std::mem; struct Cat { x: int @@ -24,13 +24,13 @@ impl Drop for Kitty { #[cfg(target_arch = "x86_64")] pub fn main() { - assert_eq!(sys::size_of::<Cat>(), 8 as uint); - assert_eq!(sys::size_of::<Kitty>(), 16 as uint); + assert_eq!(mem::size_of::<Cat>(), 8 as uint); + assert_eq!(mem::size_of::<Kitty>(), 16 as uint); } #[cfg(target_arch = "x86")] #[cfg(target_arch = "arm")] pub fn main() { - assert_eq!(sys::size_of::<Cat>(), 4 as uint); - assert_eq!(sys::size_of::<Kitty>(), 8 as uint); + assert_eq!(mem::size_of::<Cat>(), 4 as uint); + assert_eq!(mem::size_of::<Kitty>(), 8 as uint); } diff --git a/src/test/run-pass/nullable-pointer-size.rs b/src/test/run-pass/nullable-pointer-size.rs index 15cd508b655..228b91a4532 100644 --- a/src/test/run-pass/nullable-pointer-size.rs +++ b/src/test/run-pass/nullable-pointer-size.rs @@ -10,7 +10,7 @@ #[feature(macro_rules)]; -use std::sys; +use std::mem; enum E<T> { Thing(int, T), Nothing((), ((), ()), [i8, ..0]) } struct S<T>(int, T); @@ -19,13 +19,13 @@ struct S<T>(int, T); macro_rules! check_option { ($T:ty) => { - assert_eq!(sys::size_of::<Option<$T>>(), sys::size_of::<$T>()); + assert_eq!(mem::size_of::<Option<$T>>(), mem::size_of::<$T>()); } } macro_rules! check_fancy { ($T:ty) => { - assert_eq!(sys::size_of::<E<$T>>(), sys::size_of::<S<$T>>()); + assert_eq!(mem::size_of::<E<$T>>(), mem::size_of::<S<$T>>()); } } diff --git a/src/test/run-pass/packed-struct-generic-size.rs b/src/test/run-pass/packed-struct-generic-size.rs index 798acc646be..1d3d8cf736f 100644 --- a/src/test/run-pass/packed-struct-generic-size.rs +++ b/src/test/run-pass/packed-struct-generic-size.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::sys; +use std::mem; #[packed] struct S<T, S> { @@ -18,10 +18,10 @@ struct S<T, S> { } pub fn main() { - assert_eq!(sys::size_of::<S<u8, u8>>(), 3); + assert_eq!(mem::size_of::<S<u8, u8>>(), 3); - assert_eq!(sys::size_of::<S<u64, u16>>(), 11); + assert_eq!(mem::size_of::<S<u64, u16>>(), 11); - assert_eq!(sys::size_of::<S<~str, @mut [int]>>(), - 1 + sys::size_of::<~str>() + sys::size_of::<@mut [int]>()); + assert_eq!(mem::size_of::<S<~str, @mut [int]>>(), + 1 + mem::size_of::<~str>() + mem::size_of::<@mut [int]>()); } diff --git a/src/test/run-pass/packed-struct-size-xc.rs b/src/test/run-pass/packed-struct-size-xc.rs index 19f6046c7d6..5b4426d314b 100644 --- a/src/test/run-pass/packed-struct-size-xc.rs +++ b/src/test/run-pass/packed-struct-size-xc.rs @@ -3,8 +3,8 @@ extern mod packed; -use std::sys; +use std::mem; fn main() { - assert_eq!(sys::size_of::<packed::S>(), 5); + assert_eq!(mem::size_of::<packed::S>(), 5); } diff --git a/src/test/run-pass/packed-struct-size.rs b/src/test/run-pass/packed-struct-size.rs index b94b4db5f60..cc4cb99e2f6 100644 --- a/src/test/run-pass/packed-struct-size.rs +++ b/src/test/run-pass/packed-struct-size.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::sys; +use std::mem; #[packed] struct S4 { @@ -57,9 +57,9 @@ static TEST_S3_Foo: S3_Foo = S3_Foo { a: 1, b: 2, c: Baz }; pub fn main() { - assert_eq!(sys::size_of::<S4>(), 4); - assert_eq!(sys::size_of::<S5>(), 5); - assert_eq!(sys::size_of::<S13_str>(), 13 + sys::size_of::<~str>()); - assert_eq!(sys::size_of::<S3_Foo>(), 3 + sys::size_of::<Foo>()); - assert_eq!(sys::size_of::<S7_Option>(), 7 + sys::size_of::<Option<@mut f64>>()); + assert_eq!(mem::size_of::<S4>(), 4); + assert_eq!(mem::size_of::<S5>(), 5); + assert_eq!(mem::size_of::<S13_str>(), 13 + mem::size_of::<~str>()); + assert_eq!(mem::size_of::<S3_Foo>(), 3 + mem::size_of::<Foo>()); + assert_eq!(mem::size_of::<S7_Option>(), 7 + mem::size_of::<Option<@mut f64>>()); } diff --git a/src/test/run-pass/packed-struct-vec.rs b/src/test/run-pass/packed-struct-vec.rs index 6cf519a387f..6007cc251c9 100644 --- a/src/test/run-pass/packed-struct-vec.rs +++ b/src/test/run-pass/packed-struct-vec.rs @@ -10,7 +10,7 @@ // xfail-android: FIXME(#9116) Bus error -use std::sys; +use std::mem; #[packed] #[deriving(Eq)] @@ -22,7 +22,7 @@ struct Foo { pub fn main() { let foos = [Foo { bar: 1, baz: 2 }, .. 10]; - assert_eq!(sys::size_of::<[Foo, .. 10]>(), 90); + assert_eq!(mem::size_of::<[Foo, .. 10]>(), 90); for i in range(0u, 10) { assert_eq!(foos[i], Foo { bar: 1, baz: 2}); diff --git a/src/test/run-pass/packed-tuple-struct-size.rs b/src/test/run-pass/packed-tuple-struct-size.rs index dd38a6b7d12..76362ffeaaf 100644 --- a/src/test/run-pass/packed-tuple-struct-size.rs +++ b/src/test/run-pass/packed-tuple-struct-size.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::sys; +use std::mem; #[packed] struct S4(u8,[u8, .. 3]); @@ -31,16 +31,16 @@ struct S3_Foo(u8, u16, Foo); struct S7_Option(f32, u8, u16, Option<@mut f64>); pub fn main() { - assert_eq!(sys::size_of::<S4>(), 4); + assert_eq!(mem::size_of::<S4>(), 4); - assert_eq!(sys::size_of::<S5>(), 5); + assert_eq!(mem::size_of::<S5>(), 5); - assert_eq!(sys::size_of::<S13_str>(), - 13 + sys::size_of::<~str>()); + assert_eq!(mem::size_of::<S13_str>(), + 13 + mem::size_of::<~str>()); - assert_eq!(sys::size_of::<S3_Foo>(), - 3 + sys::size_of::<Foo>()); + assert_eq!(mem::size_of::<S3_Foo>(), + 3 + mem::size_of::<Foo>()); - assert_eq!(sys::size_of::<S7_Option>(), - 7 + sys::size_of::<Option<@mut f64>>()); + assert_eq!(mem::size_of::<S7_Option>(), + 7 + mem::size_of::<Option<@mut f64>>()); } diff --git a/src/test/run-pass/rec-align-u32.rs b/src/test/run-pass/rec-align-u32.rs index 804e6902002..43304b66176 100644 --- a/src/test/run-pass/rec-align-u32.rs +++ b/src/test/run-pass/rec-align-u32.rs @@ -12,7 +12,7 @@ // Issue #2303 -use std::sys; +use std::mem; mod rusti { extern "rust-intrinsic" { @@ -55,7 +55,7 @@ pub fn main() { let y = format!("{:?}", x); info2!("align inner = {:?}", rusti::min_align_of::<Inner>()); - info2!("size outer = {:?}", sys::size_of::<Outer>()); + info2!("size outer = {:?}", mem::size_of::<Outer>()); info2!("y = {}", y); // per clang/gcc the alignment of `inner` is 4 on x86. @@ -63,7 +63,7 @@ pub fn main() { // per clang/gcc the size of `outer` should be 12 // because `inner`s alignment was 4. - assert_eq!(sys::size_of::<Outer>(), m::size()); + assert_eq!(mem::size_of::<Outer>(), m::size()); assert_eq!(y, ~"Outer{c8: 22u8, t: Inner{c64: 44u32}}"); } diff --git a/src/test/run-pass/rec-align-u64.rs b/src/test/run-pass/rec-align-u64.rs index 6ec2b63cfff..5adb8cf9510 100644 --- a/src/test/run-pass/rec-align-u64.rs +++ b/src/test/run-pass/rec-align-u64.rs @@ -12,7 +12,7 @@ // Issue #2303 -use std::sys; +use std::mem; mod rusti { extern "rust-intrinsic" { @@ -77,7 +77,7 @@ pub fn main() { let y = format!("{:?}", x); info2!("align inner = {}", rusti::min_align_of::<Inner>()); - info2!("size outer = {}", sys::size_of::<Outer>()); + info2!("size outer = {}", mem::size_of::<Outer>()); info2!("y = {}", y); // per clang/gcc the alignment of `Inner` is 4 on x86. @@ -85,7 +85,7 @@ pub fn main() { // per clang/gcc the size of `Outer` should be 12 // because `Inner`s alignment was 4. - assert_eq!(sys::size_of::<Outer>(), m::m::size()); + assert_eq!(mem::size_of::<Outer>(), m::m::size()); assert_eq!(y, ~"Outer{c8: 22u8, t: Inner{c64: 44u64}}"); } diff --git a/src/test/run-pass/reflect-visit-data.rs b/src/test/run-pass/reflect-visit-data.rs index 85cc8b224f6..5a2243b1940 100644 --- a/src/test/run-pass/reflect-visit-data.rs +++ b/src/test/run-pass/reflect-visit-data.rs @@ -12,7 +12,7 @@ use std::libc::c_void; use std::ptr; -use std::sys; +use std::mem; use std::unstable::intrinsics::{TyDesc, get_tydesc, visit_tydesc, TyVisitor, Opaque}; use std::unstable::raw::Vec; @@ -49,12 +49,12 @@ impl<V:TyVisitor + movable_ptr> ptr_visit_adaptor<V> { #[inline(always)] pub fn align_to<T>(&mut self) { - self.align(sys::min_align_of::<T>()); + self.align(mem::min_align_of::<T>()); } #[inline(always)] pub fn bump_past<T>(&mut self) { - self.bump(sys::size_of::<T>()); + self.bump(mem::size_of::<T>()); } } diff --git a/src/test/run-pass/regions-mock-trans.rs b/src/test/run-pass/regions-mock-trans.rs index 201584d48a5..e66a34b47bc 100644 --- a/src/test/run-pass/regions-mock-trans.rs +++ b/src/test/run-pass/regions-mock-trans.rs @@ -10,7 +10,7 @@ use std::cast; use std::libc; -use std::sys; +use std::mem; struct arena(()); @@ -30,7 +30,7 @@ struct Ccx { #[fixed_stack_segment] #[inline(never)] fn alloc<'a>(_bcx : &'a arena) -> &'a Bcx<'a> { unsafe { - cast::transmute(libc::malloc(sys::size_of::<Bcx<'blk>>() + cast::transmute(libc::malloc(mem::size_of::<Bcx<'blk>>() as libc::size_t)) } } diff --git a/src/test/run-pass/type-sizes.rs b/src/test/run-pass/type-sizes.rs index 5695254cdbf..2cdff23050d 100644 --- a/src/test/run-pass/type-sizes.rs +++ b/src/test/run-pass/type-sizes.rs @@ -9,7 +9,7 @@ // except according to those terms. extern mod std; -use std::sys::size_of; +use std::mem::size_of; struct t {a: u8, b: i8} struct u {a: u8, b: i8, c: u8} |