///////////////////////////////////////////////////////////////////////////////
/// `TypeId` represents a globally unique identifier for a type
-#[cfg(stage0)]
-pub struct TypeId {
- priv t: *intrinsics::TyDesc,
-}
-
-/// `TypeId` represents a globally unique identifier for a type
-#[cfg(not(stage0))]
pub struct TypeId {
priv t: u64,
}
impl TypeId {
/// Returns the `TypeId` of the type this generic function has been instantiated with
#[inline]
- #[cfg(stage0)]
- pub fn of<T: 'static>() -> TypeId {
- TypeId{ t: unsafe { intrinsics::get_tydesc::<T>() } }
- }
-
- /// Returns the `TypeId` of the type this generic function has been instantiated with
- #[inline]
- #[cfg(not(stage0))]
pub fn of<T: 'static>() -> TypeId {
TypeId{ t: unsafe { intrinsics::type_id::<T>() } }
}
* and destination may overlap.
*/
#[inline]
-#[cfg(target_word_size = "32", stage0)]
-pub unsafe fn copy_memory<T,P:RawPtr<T>>(dst: *mut T, src: P, count: uint) {
- intrinsics::memmove32(dst,
- cast::transmute_immut_unsafe(src),
- count as u32);
-}
-
-/**
- * Copies data from one location to another.
- *
- * Copies `count` elements (not bytes) from `src` to `dst`. The source
- * and destination may overlap.
- */
-#[inline]
-#[cfg(target_word_size = "64", stage0)]
-pub unsafe fn copy_memory<T,P:RawPtr<T>>(dst: *mut T, src: P, count: uint) {
- intrinsics::memmove64(dst,
- cast::transmute_immut_unsafe(src),
- count as u64);
-}
-
-/**
- * Copies data from one location to another.
- *
- * Copies `count` elements (not bytes) from `src` to `dst`. The source
- * and destination may overlap.
- */
-#[inline]
-#[cfg(not(stage0))]
pub unsafe fn copy_memory<T,P:RawPtr<T>>(dst: *mut T, src: P, count: uint) {
intrinsics::copy_memory(dst, cast::transmute_immut_unsafe(src), count)
}
* and destination may *not* overlap.
*/
#[inline]
-#[cfg(target_word_size = "32", stage0)]
-pub unsafe fn copy_nonoverlapping_memory<T,P:RawPtr<T>>(dst: *mut T,
- src: P,
- count: uint) {
- intrinsics::memcpy32(dst,
- cast::transmute_immut_unsafe(src),
- count as u32);
-}
-
-/**
- * Copies data from one location to another.
- *
- * Copies `count` elements (not bytes) from `src` to `dst`. The source
- * and destination may *not* overlap.
- */
-#[inline]
-#[cfg(target_word_size = "64", stage0)]
-pub unsafe fn copy_nonoverlapping_memory<T,P:RawPtr<T>>(dst: *mut T,
- src: P,
- count: uint) {
- intrinsics::memcpy64(dst,
- cast::transmute_immut_unsafe(src),
- count as u64);
-}
-
-/**
- * Copies data from one location to another.
- *
- * Copies `count` elements (not bytes) from `src` to `dst`. The source
- * and destination may *not* overlap.
- */
-#[inline]
-#[cfg(not(stage0))]
pub unsafe fn copy_nonoverlapping_memory<T,P:RawPtr<T>>(dst: *mut T,
src: P,
count: uint) {
* bytes of memory starting at `dst` to `c`.
*/
#[inline]
-#[cfg(target_word_size = "32", stage0)]
-pub unsafe fn set_memory<T>(dst: *mut T, c: u8, count: uint) {
- intrinsics::memset32(dst, c, count as u32);
-}
-
-/**
- * Invokes memset on the specified pointer, setting `count * size_of::<T>()`
- * bytes of memory starting at `dst` to `c`.
- */
-#[inline]
-#[cfg(target_word_size = "64", stage0)]
-pub unsafe fn set_memory<T>(dst: *mut T, c: u8, count: uint) {
- intrinsics::memset64(dst, c, count as u64);
-}
-
-/**
- * Invokes memset on the specified pointer, setting `count * size_of::<T>()`
- * bytes of memory starting at `dst` to `c`.
- */
-#[inline]
-#[cfg(not(stage0))]
pub unsafe fn set_memory<T>(dst: *mut T, c: u8, count: uint) {
intrinsics::set_memory(dst, c, count)
}
true
}
- #[cfg(stage0)]
- fn visit_fn_output(&mut self, retstyle: uint, inner: *TyDesc) -> bool {
- if ! self.inner.visit_fn_output(retstyle, inner) { return false; }
- true
- }
-
- #[cfg(not(stage0))]
fn visit_fn_output(&mut self, retstyle: uint, variadic: bool, inner: *TyDesc) -> bool {
if ! self.inner.visit_fn_output(retstyle, variadic, inner) { return false; }
true
true
}
- #[cfg(stage0)]
- fn visit_fn_output(&mut self, _retstyle: uint, inner: *TyDesc) -> bool {
- self.writer.write(")".as_bytes());
- let name = unsafe { (*inner).name };
- if name != "()" {
- self.writer.write(" -> ".as_bytes());
- self.writer.write(name.as_bytes());
- }
- true
- }
-
- #[cfg(not(stage0))]
fn visit_fn_output(&mut self, _retstyle: uint, variadic: bool, inner: *TyDesc) -> bool {
if variadic {
self.writer.write(", ...".as_bytes());
fn visit_enter_fn(&mut self, purity: uint, proto: uint,
n_inputs: uint, retstyle: uint) -> bool;
fn visit_fn_input(&mut self, i: uint, mode: uint, inner: *TyDesc) -> bool;
- #[cfg(stage0)]
- fn visit_fn_output(&mut self, retstyle: uint, inner: *TyDesc) -> bool;
- #[cfg(not(stage0))]
fn visit_fn_output(&mut self, retstyle: uint, variadic: bool, inner: *TyDesc) -> bool;
fn visit_leave_fn(&mut self, purity: uint, proto: uint,
n_inputs: uint, retstyle: uint) -> bool;
/// Gets an identifier which is globally unique to the specified type. This
/// function will return the same value for a type regardless of whichever
/// crate it is invoked in.
- #[cfg(not(stage0))]
pub fn type_id<T: 'static>() -> u64;
/// Create a value initialized to zero.
pub fn needs_drop<T>() -> bool;
/// Returns `true` if a type is managed (will be allocated on the local heap)
- #[cfg(stage0)]
- pub fn contains_managed<T>() -> bool;
-
- /// Returns `true` if a type is managed (will be allocated on the local heap)
- #[cfg(not(stage0))]
pub fn owns_managed<T>() -> bool;
pub fn visit_tydesc(td: *TyDesc, tv: &mut TyVisitor);
/// integer, since the conversion would throw away aliasing information.
pub fn offset<T>(dst: *T, offset: int) -> *T;
- /// Equivalent to the `llvm.memcpy.p0i8.0i8.i32` intrinsic, with a size of
- /// `count` * `size_of::<T>()` and an alignment of `min_align_of::<T>()`
- #[cfg(stage0)]
- pub fn memcpy32<T>(dst: *mut T, src: *T, count: u32);
- /// Equivalent to the `llvm.memcpy.p0i8.0i8.i64` intrinsic, with a size of
- /// `count` * `size_of::<T>()` and an alignment of `min_align_of::<T>()`
- #[cfg(stage0)]
- pub fn memcpy64<T>(dst: *mut T, src: *T, count: u64);
-
- /// Equivalent to the `llvm.memmove.p0i8.0i8.i32` intrinsic, with a size of
- /// `count` * `size_of::<T>()` and an alignment of `min_align_of::<T>()`
- #[cfg(stage0)]
- pub fn memmove32<T>(dst: *mut T, src: *T, count: u32);
- /// Equivalent to the `llvm.memmove.p0i8.0i8.i64` intrinsic, with a size of
- /// `count` * `size_of::<T>()` and an alignment of `min_align_of::<T>()`
- #[cfg(stage0)]
- pub fn memmove64<T>(dst: *mut T, src: *T, count: u64);
-
- /// Equivalent to the `llvm.memset.p0i8.i32` intrinsic, with a size of
- /// `count` * `size_of::<T>()` and an alignment of `min_align_of::<T>()`
- #[cfg(stage0)]
- pub fn memset32<T>(dst: *mut T, val: u8, count: u32);
- /// Equivalent to the `llvm.memset.p0i8.i64` intrinsic, with a size of
- /// `count` * `size_of::<T>()` and an alignment of `min_align_of::<T>()`
- #[cfg(stage0)]
- pub fn memset64<T>(dst: *mut T, val: u8, count: u64);
-
- #[cfg(not(stage0))]
+ /// Equivalent to the appropriate `llvm.memcpy.p0i8.0i8.*` intrinsic, with
+ /// a size of `count` * `size_of::<T>()` and an alignment of
+ /// `min_align_of::<T>()`
pub fn copy_nonoverlapping_memory<T>(dst: *mut T, src: *T, count: uint);
- #[cfg(not(stage0))]
+ /// Equivalent to the appropriate `llvm.memmove.p0i8.0i8.*` intrinsic, with
+ /// a size of `count` * `size_of::<T>()` and an alignment of
+ /// `min_align_of::<T>()`
pub fn copy_memory<T>(dst: *mut T, src: *T, count: uint);
- #[cfg(not(stage0))]
+ /// Equivalent to the appropriate `llvm.memset.p0i8.*` intrinsic, with a
+ /// size of `count` * `size_of::<T>()` and an alignment of
+ /// `min_align_of::<T>()`
pub fn set_memory<T>(dst: *mut T, val: u8, count: uint);
pub fn sqrtf32(x: f32) -> f32;
use uint;
use unstable::finally::Finally;
use unstable::intrinsics;
-use unstable::intrinsics::{get_tydesc};
+use unstable::intrinsics::{get_tydesc, owns_managed};
use unstable::raw::{Box, Repr, Slice, Vec};
use vec;
use util;
-#[cfg(not(stage0))]
-use unstable::intrinsics::owns_managed;
-
-#[cfg(stage0)]
-unsafe fn owns_managed<T>() -> bool {
- intrinsics::contains_managed::<T>()
-}
-
/**
* Creates and initializes an owned vector.
*
use unstable::intrinsics;
use vec::{with_capacity, ImmutableVector, MutableVector};
use unstable::raw::{Box, Vec, Slice};
-
- #[cfg(not(stage0))]
use unstable::intrinsics::owns_managed;
- #[cfg(stage0)]
- use vec::owns_managed;
-
/**
* Sets the length of a vector
*
+S 2013-11-06 fdc830d
+ freebsd-x86_64 ef38f3acf8d05eda3c9f21e75c2bbd2f90a614a3
+ linux-i386 6ad20f6722c15a71fe7654d187dc431e26c1da6f
+ linux-x86_64 699b4bef2eff078ae6cfaac093c580b322dc769c
+ macos-i386 8c9d906116359bc665d8ad04ce117b9f5a8a9ae2
+ macos-x86_64 1954f546017639f7ff4cc584120ba41c29c790d2
+ winnt-i386 ce528f85f1470b3183c1e310452103c0c7f89751
+
S 2013-11-01 8ea2123
freebsd-x86_64 bc7dea1ca297cfb4bd6d8a32185c6a4fddca3e6b
linux-i386 4b33599d160d757f6021ff05d0213fba3097dde2
projects / rust.git / commitdiff