From 4d10bdc5b9fecee38abcad78a86e552a961b1a0a Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Sat, 15 Feb 2014 23:49:08 -0800 Subject: std: Move intrinsics to std::intrinsics. Issue #1457 --- src/libstd/any.rs | 4 +- src/libstd/cast.rs | 2 +- src/libstd/intrinsics.rs | 459 ++++++++++++++++++++++++++++++++++++++ src/libstd/lib.rs | 3 +- src/libstd/local_data.rs | 2 +- src/libstd/mem.rs | 4 +- src/libstd/num/f32.rs | 2 +- src/libstd/num/f64.rs | 2 +- src/libstd/num/i16.rs | 2 +- src/libstd/num/i32.rs | 2 +- src/libstd/num/i64.rs | 2 +- src/libstd/num/i8.rs | 2 +- src/libstd/num/int.rs | 2 +- src/libstd/num/u16.rs | 2 +- src/libstd/num/u32.rs | 2 +- src/libstd/num/u64.rs | 2 +- src/libstd/num/u8.rs | 2 +- src/libstd/num/uint.rs | 2 +- src/libstd/ptr.rs | 2 +- src/libstd/reflect.rs | 2 +- src/libstd/repr.rs | 2 +- src/libstd/rt/global_heap.rs | 2 +- src/libstd/rt/unwind.rs | 2 +- src/libstd/rt/util.rs | 2 +- src/libstd/sync/atomics.rs | 2 +- src/libstd/unstable/intrinsics.rs | 457 ------------------------------------- src/libstd/unstable/mod.rs | 1 - src/libstd/unstable/stack.rs | 2 +- 28 files changed, 487 insertions(+), 485 deletions(-) create mode 100644 src/libstd/intrinsics.rs delete mode 100644 src/libstd/unstable/intrinsics.rs (limited to 'src/libstd') diff --git a/src/libstd/any.rs b/src/libstd/any.rs index 3f14db14882..06ae20d60bc 100644 --- a/src/libstd/any.rs +++ b/src/libstd/any.rs @@ -25,8 +25,8 @@ use fmt; use option::{Option, Some, None}; use result::{Result, Ok, Err}; use to_str::ToStr; -use unstable::intrinsics::TypeId; -use unstable::intrinsics; +use intrinsics::TypeId; +use intrinsics; /// A type with no inhabitants pub enum Void { } diff --git a/src/libstd/cast.rs b/src/libstd/cast.rs index ffdd70a6c14..c2db0c78205 100644 --- a/src/libstd/cast.rs +++ b/src/libstd/cast.rs @@ -11,7 +11,7 @@ //! Unsafe casting functions use mem; -use unstable::intrinsics; +use intrinsics; use ptr::copy_nonoverlapping_memory; /// Casts the value at `src` to U. The two types must have the same length. diff --git a/src/libstd/intrinsics.rs b/src/libstd/intrinsics.rs new file mode 100644 index 00000000000..b386335a428 --- /dev/null +++ b/src/libstd/intrinsics.rs @@ -0,0 +1,459 @@ +// Copyright 2013 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +/*! rustc compiler intrinsics. + +The corresponding definitions are in librustc/middle/trans/foreign.rs. + +# Volatiles + +The volatile intrinsics provide operations intended to act on I/O +memory, which are guaranteed to not be reordered by the compiler +across other volatile intrinsics. See the LLVM documentation on +[[volatile]]. + +[volatile]: http://llvm.org/docs/LangRef.html#volatile-memory-accesses + +# Atomics + +The atomic intrinsics provide common atomic operations on machine +words, with multiple possible memory orderings. They obey the same +semantics as C++11. See the LLVM documentation on [[atomics]]. + +[atomics]: http://llvm.org/docs/Atomics.html + +A quick refresher on memory ordering: + +* Acquire - a barrier for acquiring a lock. Subsequent reads and writes + take place after the barrier. +* Release - a barrier for releasing a lock. Preceding reads and writes + take place before the barrier. +* Sequentially consistent - sequentially consistent operations are + guaranteed to happen in order. This is the standard mode for working + with atomic types and is equivalent to Java's `volatile`. + +*/ + +#[allow(missing_doc)]; + +// This is needed to prevent duplicate lang item definitions. +#[cfg(test)] +pub use realstd::intrinsics::{TyDesc, Opaque, TyVisitor, TypeId}; + +pub type GlueFn = extern "Rust" fn(*i8); + +#[lang="ty_desc"] +#[cfg(not(test))] +pub struct TyDesc { + // sizeof(T) + size: uint, + + // alignof(T) + align: uint, + + // Called when a value of type `T` is no longer needed + drop_glue: GlueFn, + + // Called by reflection visitor to visit a value of type `T` + visit_glue: GlueFn, + + // Name corresponding to the type + name: &'static str +} + +#[lang="opaque"] +#[cfg(not(test))] +pub enum Opaque { } + +pub type Disr = u64; + +#[lang="ty_visitor"] +#[cfg(not(test))] +pub trait TyVisitor { + fn visit_bot(&mut self) -> bool; + fn visit_nil(&mut self) -> bool; + fn visit_bool(&mut self) -> bool; + + fn visit_int(&mut self) -> bool; + fn visit_i8(&mut self) -> bool; + fn visit_i16(&mut self) -> bool; + fn visit_i32(&mut self) -> bool; + fn visit_i64(&mut self) -> bool; + + fn visit_uint(&mut self) -> bool; + fn visit_u8(&mut self) -> bool; + fn visit_u16(&mut self) -> bool; + fn visit_u32(&mut self) -> bool; + fn visit_u64(&mut self) -> bool; + + fn visit_f32(&mut self) -> bool; + fn visit_f64(&mut self) -> bool; + + fn visit_char(&mut self) -> bool; + + fn visit_estr_box(&mut self) -> bool; + fn visit_estr_uniq(&mut self) -> bool; + fn visit_estr_slice(&mut self) -> bool; + fn visit_estr_fixed(&mut self, n: uint, sz: uint, align: uint) -> bool; + + fn visit_box(&mut self, mtbl: uint, inner: *TyDesc) -> bool; + fn visit_uniq(&mut self, mtbl: uint, inner: *TyDesc) -> bool; + fn visit_ptr(&mut self, mtbl: uint, inner: *TyDesc) -> bool; + fn visit_rptr(&mut self, mtbl: uint, inner: *TyDesc) -> bool; + + fn visit_vec(&mut self, mtbl: uint, inner: *TyDesc) -> bool; + fn visit_unboxed_vec(&mut self, mtbl: uint, inner: *TyDesc) -> bool; + fn visit_evec_box(&mut self, mtbl: uint, inner: *TyDesc) -> bool; + fn visit_evec_uniq(&mut self, mtbl: uint, inner: *TyDesc) -> bool; + fn visit_evec_slice(&mut self, mtbl: uint, inner: *TyDesc) -> bool; + fn visit_evec_fixed(&mut self, n: uint, sz: uint, align: uint, + mtbl: uint, inner: *TyDesc) -> bool; + + fn visit_enter_rec(&mut self, n_fields: uint, + sz: uint, align: uint) -> bool; + fn visit_rec_field(&mut self, i: uint, name: &str, + mtbl: uint, inner: *TyDesc) -> bool; + fn visit_leave_rec(&mut self, n_fields: uint, + sz: uint, align: uint) -> bool; + + fn visit_enter_class(&mut self, name: &str, named_fields: bool, n_fields: uint, + sz: uint, align: uint) -> bool; + fn visit_class_field(&mut self, i: uint, name: &str, named: bool, + mtbl: uint, inner: *TyDesc) -> bool; + fn visit_leave_class(&mut self, name: &str, named_fields: bool, n_fields: uint, + sz: uint, align: uint) -> bool; + + fn visit_enter_tup(&mut self, n_fields: uint, + sz: uint, align: uint) -> bool; + fn visit_tup_field(&mut self, i: uint, inner: *TyDesc) -> bool; + fn visit_leave_tup(&mut self, n_fields: uint, + sz: uint, align: uint) -> bool; + + fn visit_enter_enum(&mut self, n_variants: uint, + get_disr: extern unsafe fn(ptr: *Opaque) -> Disr, + sz: uint, align: uint) -> bool; + fn visit_enter_enum_variant(&mut self, variant: uint, + disr_val: Disr, + n_fields: uint, + name: &str) -> bool; + fn visit_enum_variant_field(&mut self, i: uint, offset: uint, inner: *TyDesc) -> bool; + fn visit_leave_enum_variant(&mut self, variant: uint, + disr_val: Disr, + n_fields: uint, + name: &str) -> bool; + fn visit_leave_enum(&mut self, n_variants: uint, + get_disr: extern unsafe fn(ptr: *Opaque) -> Disr, + sz: uint, align: uint) -> bool; + + 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; + 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; + + fn visit_trait(&mut self, name: &str) -> bool; + fn visit_param(&mut self, i: uint) -> bool; + fn visit_self(&mut self) -> bool; +} + +extern "rust-intrinsic" { + pub fn atomic_cxchg(dst: &mut T, old: T, src: T) -> T; + pub fn atomic_cxchg_acq(dst: &mut T, old: T, src: T) -> T; + pub fn atomic_cxchg_rel(dst: &mut T, old: T, src: T) -> T; + pub fn atomic_cxchg_acqrel(dst: &mut T, old: T, src: T) -> T; + pub fn atomic_cxchg_relaxed(dst: &mut T, old: T, src: T) -> T; + + pub fn atomic_load(src: &T) -> T; + pub fn atomic_load_acq(src: &T) -> T; + pub fn atomic_load_relaxed(src: &T) -> T; + + pub fn atomic_store(dst: &mut T, val: T); + pub fn atomic_store_rel(dst: &mut T, val: T); + pub fn atomic_store_relaxed(dst: &mut T, val: T); + + pub fn atomic_xchg(dst: &mut T, src: T) -> T; + pub fn atomic_xchg_acq(dst: &mut T, src: T) -> T; + pub fn atomic_xchg_rel(dst: &mut T, src: T) -> T; + pub fn atomic_xchg_acqrel(dst: &mut T, src: T) -> T; + pub fn atomic_xchg_relaxed(dst: &mut T, src: T) -> T; + + pub fn atomic_xadd(dst: &mut T, src: T) -> T; + pub fn atomic_xadd_acq(dst: &mut T, src: T) -> T; + pub fn atomic_xadd_rel(dst: &mut T, src: T) -> T; + pub fn atomic_xadd_acqrel(dst: &mut T, src: T) -> T; + pub fn atomic_xadd_relaxed(dst: &mut T, src: T) -> T; + + pub fn atomic_xsub(dst: &mut T, src: T) -> T; + pub fn atomic_xsub_acq(dst: &mut T, src: T) -> T; + pub fn atomic_xsub_rel(dst: &mut T, src: T) -> T; + pub fn atomic_xsub_acqrel(dst: &mut T, src: T) -> T; + pub fn atomic_xsub_relaxed(dst: &mut T, src: T) -> T; + + pub fn atomic_and(dst: &mut T, src: T) -> T; + pub fn atomic_and_acq(dst: &mut T, src: T) -> T; + pub fn atomic_and_rel(dst: &mut T, src: T) -> T; + pub fn atomic_and_acqrel(dst: &mut T, src: T) -> T; + pub fn atomic_and_relaxed(dst: &mut T, src: T) -> T; + + pub fn atomic_nand(dst: &mut T, src: T) -> T; + pub fn atomic_nand_acq(dst: &mut T, src: T) -> T; + pub fn atomic_nand_rel(dst: &mut T, src: T) -> T; + pub fn atomic_nand_acqrel(dst: &mut T, src: T) -> T; + pub fn atomic_nand_relaxed(dst: &mut T, src: T) -> T; + + pub fn atomic_or(dst: &mut T, src: T) -> T; + pub fn atomic_or_acq(dst: &mut T, src: T) -> T; + pub fn atomic_or_rel(dst: &mut T, src: T) -> T; + pub fn atomic_or_acqrel(dst: &mut T, src: T) -> T; + pub fn atomic_or_relaxed(dst: &mut T, src: T) -> T; + + pub fn atomic_xor(dst: &mut T, src: T) -> T; + pub fn atomic_xor_acq(dst: &mut T, src: T) -> T; + pub fn atomic_xor_rel(dst: &mut T, src: T) -> T; + pub fn atomic_xor_acqrel(dst: &mut T, src: T) -> T; + pub fn atomic_xor_relaxed(dst: &mut T, src: T) -> T; + + pub fn atomic_max(dst: &mut T, src: T) -> T; + pub fn atomic_max_acq(dst: &mut T, src: T) -> T; + pub fn atomic_max_rel(dst: &mut T, src: T) -> T; + pub fn atomic_max_acqrel(dst: &mut T, src: T) -> T; + pub fn atomic_max_relaxed(dst: &mut T, src: T) -> T; + + pub fn atomic_min(dst: &mut T, src: T) -> T; + pub fn atomic_min_acq(dst: &mut T, src: T) -> T; + pub fn atomic_min_rel(dst: &mut T, src: T) -> T; + pub fn atomic_min_acqrel(dst: &mut T, src: T) -> T; + pub fn atomic_min_relaxed(dst: &mut T, src: T) -> T; + + pub fn atomic_umin(dst: &mut T, src: T) -> T; + pub fn atomic_umin_acq(dst: &mut T, src: T) -> T; + pub fn atomic_umin_rel(dst: &mut T, src: T) -> T; + pub fn atomic_umin_acqrel(dst: &mut T, src: T) -> T; + pub fn atomic_umin_relaxed(dst: &mut T, src: T) -> T; + + pub fn atomic_umax(dst: &mut T, src: T) -> T; + pub fn atomic_umax_acq(dst: &mut T, src: T) -> T; + pub fn atomic_umax_rel(dst: &mut T, src: T) -> T; + pub fn atomic_umax_acqrel(dst: &mut T, src: T) -> T; + pub fn atomic_umax_relaxed(dst: &mut T, src: T) -> T; + + pub fn atomic_fence(); + pub fn atomic_fence_acq(); + pub fn atomic_fence_rel(); + pub fn atomic_fence_acqrel(); + + /// Abort the execution of the process. + pub fn abort() -> !; + + /// Execute a breakpoint trap, for inspection by a debugger. + pub fn breakpoint(); + + pub fn volatile_load(src: *T) -> T; + pub fn volatile_store(dst: *mut T, val: T); + + + /// The size of a type in bytes. + /// + /// This is the exact number of bytes in memory taken up by a + /// value of the given type. In other words, a memset of this size + /// would *exactly* overwrite a value. When laid out in vectors + /// and structures there may be additional padding between + /// elements. + pub fn size_of() -> uint; + + /// Move a value to an uninitialized memory location. + /// + /// Drop glue is not run on the destination. + pub fn move_val_init(dst: &mut T, src: T); + + pub fn min_align_of() -> uint; + pub fn pref_align_of() -> uint; + + /// Get a static pointer to a type descriptor. + pub fn get_tydesc() -> *TyDesc; + + /// 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. + pub fn type_id() -> TypeId; + + + /// Create a value initialized to zero. + /// + /// `init` is unsafe because it returns a zeroed-out datum, + /// which is unsafe unless T is Pod. + pub fn init() -> T; + + /// Create an uninitialized value. + pub fn uninit() -> T; + + /// Move a value out of scope without running drop glue. + /// + /// `forget` is unsafe because the caller is responsible for + /// ensuring the argument is deallocated already. + pub fn forget(_: T) -> (); + pub fn transmute(e: T) -> U; + + /// Returns `true` if a type requires drop glue. + pub fn needs_drop() -> bool; + + /// Returns `true` if a type is managed (will be allocated on the local heap) + pub fn owns_managed() -> bool; + + pub fn visit_tydesc(td: *TyDesc, tv: &mut TyVisitor); + + /// Calculates the offset from a pointer. The offset *must* be in-bounds of + /// the object, or one-byte-past-the-end. An arithmetic overflow is also + /// undefined behaviour. + /// + /// This is implemented as an intrinsic to avoid converting to and from an + /// integer, since the conversion would throw away aliasing information. + pub fn offset(dst: *T, offset: int) -> *T; + + /// Equivalent to the appropriate `llvm.memcpy.p0i8.0i8.*` intrinsic, with + /// a size of `count` * `size_of::()` and an alignment of + /// `min_align_of::()` + pub fn copy_nonoverlapping_memory(dst: *mut T, src: *T, count: uint); + + /// Equivalent to the appropriate `llvm.memmove.p0i8.0i8.*` intrinsic, with + /// a size of `count` * `size_of::()` and an alignment of + /// `min_align_of::()` + pub fn copy_memory(dst: *mut T, src: *T, count: uint); + + /// Equivalent to the appropriate `llvm.memset.p0i8.*` intrinsic, with a + /// size of `count` * `size_of::()` and an alignment of + /// `min_align_of::()` + pub fn set_memory(dst: *mut T, val: u8, count: uint); + + pub fn sqrtf32(x: f32) -> f32; + pub fn sqrtf64(x: f64) -> f64; + + pub fn powif32(a: f32, x: i32) -> f32; + pub fn powif64(a: f64, x: i32) -> f64; + + pub fn sinf32(x: f32) -> f32; + pub fn sinf64(x: f64) -> f64; + + pub fn cosf32(x: f32) -> f32; + pub fn cosf64(x: f64) -> f64; + + pub fn powf32(a: f32, x: f32) -> f32; + pub fn powf64(a: f64, x: f64) -> f64; + + pub fn expf32(x: f32) -> f32; + pub fn expf64(x: f64) -> f64; + + pub fn exp2f32(x: f32) -> f32; + pub fn exp2f64(x: f64) -> f64; + + pub fn logf32(x: f32) -> f32; + pub fn logf64(x: f64) -> f64; + + pub fn log10f32(x: f32) -> f32; + pub fn log10f64(x: f64) -> f64; + + pub fn log2f32(x: f32) -> f32; + pub fn log2f64(x: f64) -> f64; + + pub fn fmaf32(a: f32, b: f32, c: f32) -> f32; + pub fn fmaf64(a: f64, b: f64, c: f64) -> f64; + + pub fn fabsf32(x: f32) -> f32; + pub fn fabsf64(x: f64) -> f64; + + pub fn copysignf32(x: f32, y: f32) -> f32; + pub fn copysignf64(x: f64, y: f64) -> f64; + + pub fn floorf32(x: f32) -> f32; + pub fn floorf64(x: f64) -> f64; + + pub fn ceilf32(x: f32) -> f32; + pub fn ceilf64(x: f64) -> f64; + + pub fn truncf32(x: f32) -> f32; + pub fn truncf64(x: f64) -> f64; + + pub fn rintf32(x: f32) -> f32; + pub fn rintf64(x: f64) -> f64; + + pub fn nearbyintf32(x: f32) -> f32; + pub fn nearbyintf64(x: f64) -> f64; + + pub fn roundf32(x: f32) -> f32; + pub fn roundf64(x: f64) -> f64; + + 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 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); + pub fn i64_add_with_overflow(x: i64, y: i64) -> (i64, bool); + + pub fn u8_add_with_overflow(x: u8, y: u8) -> (u8, bool); + pub fn u16_add_with_overflow(x: u16, y: u16) -> (u16, bool); + pub fn u32_add_with_overflow(x: u32, y: u32) -> (u32, bool); + pub fn u64_add_with_overflow(x: u64, y: u64) -> (u64, bool); + + pub fn i8_sub_with_overflow(x: i8, y: i8) -> (i8, bool); + pub fn i16_sub_with_overflow(x: i16, y: i16) -> (i16, bool); + pub fn i32_sub_with_overflow(x: i32, y: i32) -> (i32, bool); + pub fn i64_sub_with_overflow(x: i64, y: i64) -> (i64, bool); + + pub fn u8_sub_with_overflow(x: u8, y: u8) -> (u8, bool); + pub fn u16_sub_with_overflow(x: u16, y: u16) -> (u16, bool); + pub fn u32_sub_with_overflow(x: u32, y: u32) -> (u32, bool); + pub fn u64_sub_with_overflow(x: u64, y: u64) -> (u64, bool); + + pub fn i8_mul_with_overflow(x: i8, y: i8) -> (i8, bool); + pub fn i16_mul_with_overflow(x: i16, y: i16) -> (i16, bool); + pub fn i32_mul_with_overflow(x: i32, y: i32) -> (i32, bool); + pub fn i64_mul_with_overflow(x: i64, y: i64) -> (i64, bool); + + pub fn u8_mul_with_overflow(x: u8, y: u8) -> (u8, bool); + pub fn u16_mul_with_overflow(x: u16, y: u16) -> (u16, bool); + pub fn u32_mul_with_overflow(x: u32, y: u32) -> (u32, bool); + pub fn u64_mul_with_overflow(x: u64, y: u64) -> (u64, bool); +} + + +/// `TypeId` represents a globally unique identifier for a type +#[lang="type_id"] // This needs to be kept in lockstep with the code in trans/intrinsic.rs and + // middle/lang_items.rs +#[deriving(Eq, IterBytes)] +#[cfg(not(test))] +pub struct TypeId { + priv t: u64, +} + +#[cfg(not(test))] +impl TypeId { + /// Returns the `TypeId` of the type this generic function has been instantiated with + pub fn of() -> TypeId { + unsafe { type_id::() } + } +} diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs index 6996cba42b4..46958974484 100644 --- a/src/libstd/lib.rs +++ b/src/libstd/lib.rs @@ -196,7 +196,8 @@ pub mod reflect; // Private APIs #[unstable] pub mod unstable; - +#[experimental] +pub mod intrinsics; /* For internal use, not exported */ diff --git a/src/libstd/local_data.rs b/src/libstd/local_data.rs index 043da46ba5e..6b854daabda 100644 --- a/src/libstd/local_data.rs +++ b/src/libstd/local_data.rs @@ -281,7 +281,7 @@ fn get_with ! { - use std::unstable::intrinsics; + use intrinsics; unsafe { intrinsics::abort() } } diff --git a/src/libstd/mem.rs b/src/libstd/mem.rs index 11053f01ded..603f2b80eea 100644 --- a/src/libstd/mem.rs +++ b/src/libstd/mem.rs @@ -17,8 +17,8 @@ use cast; use ptr; -use unstable::intrinsics; -use unstable::intrinsics::{bswap16, bswap32, bswap64}; +use intrinsics; +use intrinsics::{bswap16, bswap32, bswap64}; /// Returns the size of a type in bytes. #[inline] diff --git a/src/libstd/num/f32.rs b/src/libstd/num/f32.rs index da3f2c1636f..7b1fe949199 100644 --- a/src/libstd/num/f32.rs +++ b/src/libstd/num/f32.rs @@ -20,7 +20,7 @@ use num::{FPCategory, FPNaN, FPInfinite , FPZero, FPSubnormal, FPNormal}; use num::{Zero, One, Bounded, strconv}; use num; use to_str; -use unstable::intrinsics; +use intrinsics; macro_rules! delegate( ( diff --git a/src/libstd/num/f64.rs b/src/libstd/num/f64.rs index 24165cbef50..d5a571cdd23 100644 --- a/src/libstd/num/f64.rs +++ b/src/libstd/num/f64.rs @@ -21,7 +21,7 @@ use num::{FPCategory, FPNaN, FPInfinite , FPZero, FPSubnormal, FPNormal}; use num::{Zero, One, Bounded, strconv}; use num; use to_str; -use unstable::intrinsics; +use intrinsics; pub use cmp::{min, max}; diff --git a/src/libstd/num/i16.rs b/src/libstd/num/i16.rs index cbeff5d4aa2..141626ed98a 100644 --- a/src/libstd/num/i16.rs +++ b/src/libstd/num/i16.rs @@ -20,7 +20,7 @@ use num::{CheckedDiv, Zero, One, strconv}; use num::{ToStrRadix, FromStrRadix}; use option::{Option, Some, None}; use str; -use unstable::intrinsics; +use intrinsics; int_module!(i16, 16) diff --git a/src/libstd/num/i32.rs b/src/libstd/num/i32.rs index 9afc1a14545..a43a6e6a288 100644 --- a/src/libstd/num/i32.rs +++ b/src/libstd/num/i32.rs @@ -20,7 +20,7 @@ use num::{CheckedDiv, Zero, One, strconv}; use num::{ToStrRadix, FromStrRadix}; use option::{Option, Some, None}; use str; -use unstable::intrinsics; +use intrinsics; int_module!(i32, 32) diff --git a/src/libstd/num/i64.rs b/src/libstd/num/i64.rs index f1e9f5a4fdc..e8503d808a7 100644 --- a/src/libstd/num/i64.rs +++ b/src/libstd/num/i64.rs @@ -22,7 +22,7 @@ use num::{CheckedDiv, Zero, One, strconv}; use num::{ToStrRadix, FromStrRadix}; use option::{Option, Some, None}; use str; -use unstable::intrinsics; +use intrinsics; int_module!(i64, 64) diff --git a/src/libstd/num/i8.rs b/src/libstd/num/i8.rs index e0e549b731a..9f857ff40ff 100644 --- a/src/libstd/num/i8.rs +++ b/src/libstd/num/i8.rs @@ -20,7 +20,7 @@ use num::{CheckedDiv, Zero, One, strconv}; use num::{ToStrRadix, FromStrRadix}; use option::{Option, Some, None}; use str; -use unstable::intrinsics; +use intrinsics; int_module!(i8, 8) diff --git a/src/libstd/num/int.rs b/src/libstd/num/int.rs index d525639045e..6d1a50b724f 100644 --- a/src/libstd/num/int.rs +++ b/src/libstd/num/int.rs @@ -20,7 +20,7 @@ use num::{CheckedDiv, Zero, One, strconv}; use num::{ToStrRadix, FromStrRadix}; use option::{Option, Some, None}; use str; -use unstable::intrinsics; +use intrinsics; #[cfg(target_word_size = "32")] int_module!(int, 32) #[cfg(target_word_size = "64")] int_module!(int, 64) diff --git a/src/libstd/num/u16.rs b/src/libstd/num/u16.rs index 770db889af5..da0293b3418 100644 --- a/src/libstd/num/u16.rs +++ b/src/libstd/num/u16.rs @@ -21,7 +21,7 @@ use num::{CheckedDiv, Zero, One, strconv}; use num::{ToStrRadix, FromStrRadix}; use option::{Option, Some, None}; use str; -use unstable::intrinsics; +use intrinsics; uint_module!(u16, i16, 16) diff --git a/src/libstd/num/u32.rs b/src/libstd/num/u32.rs index 9e08ffed3b7..b103e18f701 100644 --- a/src/libstd/num/u32.rs +++ b/src/libstd/num/u32.rs @@ -21,7 +21,7 @@ use num::{CheckedDiv, Zero, One, strconv}; use num::{ToStrRadix, FromStrRadix}; use option::{Option, Some, None}; use str; -use unstable::intrinsics; +use intrinsics; uint_module!(u32, i32, 32) diff --git a/src/libstd/num/u64.rs b/src/libstd/num/u64.rs index 17eebed967c..f7956f0128e 100644 --- a/src/libstd/num/u64.rs +++ b/src/libstd/num/u64.rs @@ -23,7 +23,7 @@ use num::{CheckedDiv, Zero, One, strconv}; use num::{ToStrRadix, FromStrRadix}; use option::{Option, Some, None}; use str; -use unstable::intrinsics; +use intrinsics; uint_module!(u64, i64, 64) diff --git a/src/libstd/num/u8.rs b/src/libstd/num/u8.rs index 4aa34b6d880..e6ce9c72e96 100644 --- a/src/libstd/num/u8.rs +++ b/src/libstd/num/u8.rs @@ -21,7 +21,7 @@ use num::{CheckedDiv, Zero, One, strconv}; use num::{ToStrRadix, FromStrRadix}; use option::{Option, Some, None}; use str; -use unstable::intrinsics; +use intrinsics; uint_module!(u8, i8, 8) diff --git a/src/libstd/num/uint.rs b/src/libstd/num/uint.rs index 1811ebc7acc..a8c85787f7e 100644 --- a/src/libstd/num/uint.rs +++ b/src/libstd/num/uint.rs @@ -21,7 +21,7 @@ use num::{CheckedDiv, Zero, One, strconv}; use num::{ToStrRadix, FromStrRadix}; use option::{Option, Some, None}; use str; -use unstable::intrinsics; +use intrinsics; uint_module!(uint, int, ::int::BITS) diff --git a/src/libstd/ptr.rs b/src/libstd/ptr.rs index 193e9ea7052..86264c1ca55 100644 --- a/src/libstd/ptr.rs +++ b/src/libstd/ptr.rs @@ -17,7 +17,7 @@ use cmp::Equiv; use iter::{range, Iterator}; use mem; use option::{Option, Some, None}; -use unstable::intrinsics; +use intrinsics; #[cfg(not(test))] use cmp::{Eq, Ord}; diff --git a/src/libstd/reflect.rs b/src/libstd/reflect.rs index f88da60ae9b..5ee840748e6 100644 --- a/src/libstd/reflect.rs +++ b/src/libstd/reflect.rs @@ -16,7 +16,7 @@ Runtime type reflection #[allow(missing_doc)]; -use unstable::intrinsics::{Disr, Opaque, TyDesc, TyVisitor}; +use intrinsics::{Disr, Opaque, TyDesc, TyVisitor}; use mem; use unstable::raw; diff --git a/src/libstd/repr.rs b/src/libstd/repr.rs index 680ac112300..8e1a0714748 100644 --- a/src/libstd/repr.rs +++ b/src/libstd/repr.rs @@ -29,7 +29,7 @@ use result::{Ok, Err}; use str::StrSlice; use to_str::ToStr; use vec::OwnedVector; -use unstable::intrinsics::{Disr, Opaque, TyDesc, TyVisitor, get_tydesc, visit_tydesc}; +use intrinsics::{Disr, Opaque, TyDesc, TyVisitor, get_tydesc, visit_tydesc}; use unstable::raw; macro_rules! try( ($me:expr, $e:expr) => ( diff --git a/src/libstd/rt/global_heap.rs b/src/libstd/rt/global_heap.rs index 8128bb02148..191d57a58fc 100644 --- a/src/libstd/rt/global_heap.rs +++ b/src/libstd/rt/global_heap.rs @@ -10,7 +10,7 @@ use libc::{c_void, size_t, free, malloc, realloc}; use ptr::{RawPtr, mut_null}; -use unstable::intrinsics::abort; +use intrinsics::abort; use unstable::raw; use mem::size_of; diff --git a/src/libstd/rt/unwind.rs b/src/libstd/rt/unwind.rs index ef8bd94c897..127859b4275 100644 --- a/src/libstd/rt/unwind.rs +++ b/src/libstd/rt/unwind.rs @@ -69,7 +69,7 @@ use rt::local::Local; use rt::task::Task; use str::Str; use task::TaskResult; -use unstable::intrinsics; +use intrinsics; use uw = self::libunwind; diff --git a/src/libstd/rt/util.rs b/src/libstd/rt/util.rs index 69e240f30bc..408f51f2017 100644 --- a/src/libstd/rt/util.rs +++ b/src/libstd/rt/util.rs @@ -143,7 +143,7 @@ memory and partly incapable of presentation to others.", abort(); fn abort() -> ! { - use std::unstable::intrinsics; + use intrinsics; unsafe { intrinsics::abort() } } } diff --git a/src/libstd/sync/atomics.rs b/src/libstd/sync/atomics.rs index 00ce07d747f..b4d465c0397 100644 --- a/src/libstd/sync/atomics.rs +++ b/src/libstd/sync/atomics.rs @@ -21,7 +21,7 @@ #[allow(missing_doc)]; -use unstable::intrinsics; +use intrinsics; use cast; use std::kinds::marker; use option::{Option,Some,None}; diff --git a/src/libstd/unstable/intrinsics.rs b/src/libstd/unstable/intrinsics.rs deleted file mode 100644 index c983d82563c..00000000000 --- a/src/libstd/unstable/intrinsics.rs +++ /dev/null @@ -1,457 +0,0 @@ -// Copyright 2013 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 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -/*! rustc compiler intrinsics. - -The corresponding definitions are in librustc/middle/trans/foreign.rs. - -# Volatiles - -The volatile intrinsics provide operations intended to act on I/O -memory, which are guaranteed to not be reordered by the compiler -across other volatile intrinsics. See the LLVM documentation on -[[volatile]]. - -[volatile]: http://llvm.org/docs/LangRef.html#volatile-memory-accesses - -# Atomics - -The atomic intrinsics provide common atomic operations on machine -words, with multiple possible memory orderings. They obey the same -semantics as C++11. See the LLVM documentation on [[atomics]]. - -[atomics]: http://llvm.org/docs/Atomics.html - -A quick refresher on memory ordering: - -* Acquire - a barrier for acquiring a lock. Subsequent reads and writes - take place after the barrier. -* Release - a barrier for releasing a lock. Preceding reads and writes - take place before the barrier. -* Sequentially consistent - sequentially consistent operations are - guaranteed to happen in order. This is the standard mode for working - with atomic types and is equivalent to Java's `volatile`. - -*/ - -// This is needed to prevent duplicate lang item definitions. -#[cfg(test)] -pub use realstd::unstable::intrinsics::{TyDesc, Opaque, TyVisitor, TypeId}; - -pub type GlueFn = extern "Rust" fn(*i8); - -#[lang="ty_desc"] -#[cfg(not(test))] -pub struct TyDesc { - // sizeof(T) - size: uint, - - // alignof(T) - align: uint, - - // Called when a value of type `T` is no longer needed - drop_glue: GlueFn, - - // Called by reflection visitor to visit a value of type `T` - visit_glue: GlueFn, - - // Name corresponding to the type - name: &'static str -} - -#[lang="opaque"] -#[cfg(not(test))] -pub enum Opaque { } - -pub type Disr = u64; - -#[lang="ty_visitor"] -#[cfg(not(test))] -pub trait TyVisitor { - fn visit_bot(&mut self) -> bool; - fn visit_nil(&mut self) -> bool; - fn visit_bool(&mut self) -> bool; - - fn visit_int(&mut self) -> bool; - fn visit_i8(&mut self) -> bool; - fn visit_i16(&mut self) -> bool; - fn visit_i32(&mut self) -> bool; - fn visit_i64(&mut self) -> bool; - - fn visit_uint(&mut self) -> bool; - fn visit_u8(&mut self) -> bool; - fn visit_u16(&mut self) -> bool; - fn visit_u32(&mut self) -> bool; - fn visit_u64(&mut self) -> bool; - - fn visit_f32(&mut self) -> bool; - fn visit_f64(&mut self) -> bool; - - fn visit_char(&mut self) -> bool; - - fn visit_estr_box(&mut self) -> bool; - fn visit_estr_uniq(&mut self) -> bool; - fn visit_estr_slice(&mut self) -> bool; - fn visit_estr_fixed(&mut self, n: uint, sz: uint, align: uint) -> bool; - - fn visit_box(&mut self, mtbl: uint, inner: *TyDesc) -> bool; - fn visit_uniq(&mut self, mtbl: uint, inner: *TyDesc) -> bool; - fn visit_ptr(&mut self, mtbl: uint, inner: *TyDesc) -> bool; - fn visit_rptr(&mut self, mtbl: uint, inner: *TyDesc) -> bool; - - fn visit_vec(&mut self, mtbl: uint, inner: *TyDesc) -> bool; - fn visit_unboxed_vec(&mut self, mtbl: uint, inner: *TyDesc) -> bool; - fn visit_evec_box(&mut self, mtbl: uint, inner: *TyDesc) -> bool; - fn visit_evec_uniq(&mut self, mtbl: uint, inner: *TyDesc) -> bool; - fn visit_evec_slice(&mut self, mtbl: uint, inner: *TyDesc) -> bool; - fn visit_evec_fixed(&mut self, n: uint, sz: uint, align: uint, - mtbl: uint, inner: *TyDesc) -> bool; - - fn visit_enter_rec(&mut self, n_fields: uint, - sz: uint, align: uint) -> bool; - fn visit_rec_field(&mut self, i: uint, name: &str, - mtbl: uint, inner: *TyDesc) -> bool; - fn visit_leave_rec(&mut self, n_fields: uint, - sz: uint, align: uint) -> bool; - - fn visit_enter_class(&mut self, name: &str, named_fields: bool, n_fields: uint, - sz: uint, align: uint) -> bool; - fn visit_class_field(&mut self, i: uint, name: &str, named: bool, - mtbl: uint, inner: *TyDesc) -> bool; - fn visit_leave_class(&mut self, name: &str, named_fields: bool, n_fields: uint, - sz: uint, align: uint) -> bool; - - fn visit_enter_tup(&mut self, n_fields: uint, - sz: uint, align: uint) -> bool; - fn visit_tup_field(&mut self, i: uint, inner: *TyDesc) -> bool; - fn visit_leave_tup(&mut self, n_fields: uint, - sz: uint, align: uint) -> bool; - - fn visit_enter_enum(&mut self, n_variants: uint, - get_disr: extern unsafe fn(ptr: *Opaque) -> Disr, - sz: uint, align: uint) -> bool; - fn visit_enter_enum_variant(&mut self, variant: uint, - disr_val: Disr, - n_fields: uint, - name: &str) -> bool; - fn visit_enum_variant_field(&mut self, i: uint, offset: uint, inner: *TyDesc) -> bool; - fn visit_leave_enum_variant(&mut self, variant: uint, - disr_val: Disr, - n_fields: uint, - name: &str) -> bool; - fn visit_leave_enum(&mut self, n_variants: uint, - get_disr: extern unsafe fn(ptr: *Opaque) -> Disr, - sz: uint, align: uint) -> bool; - - 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; - 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; - - fn visit_trait(&mut self, name: &str) -> bool; - fn visit_param(&mut self, i: uint) -> bool; - fn visit_self(&mut self) -> bool; -} - -extern "rust-intrinsic" { - pub fn atomic_cxchg(dst: &mut T, old: T, src: T) -> T; - pub fn atomic_cxchg_acq(dst: &mut T, old: T, src: T) -> T; - pub fn atomic_cxchg_rel(dst: &mut T, old: T, src: T) -> T; - pub fn atomic_cxchg_acqrel(dst: &mut T, old: T, src: T) -> T; - pub fn atomic_cxchg_relaxed(dst: &mut T, old: T, src: T) -> T; - - pub fn atomic_load(src: &T) -> T; - pub fn atomic_load_acq(src: &T) -> T; - pub fn atomic_load_relaxed(src: &T) -> T; - - pub fn atomic_store(dst: &mut T, val: T); - pub fn atomic_store_rel(dst: &mut T, val: T); - pub fn atomic_store_relaxed(dst: &mut T, val: T); - - pub fn atomic_xchg(dst: &mut T, src: T) -> T; - pub fn atomic_xchg_acq(dst: &mut T, src: T) -> T; - pub fn atomic_xchg_rel(dst: &mut T, src: T) -> T; - pub fn atomic_xchg_acqrel(dst: &mut T, src: T) -> T; - pub fn atomic_xchg_relaxed(dst: &mut T, src: T) -> T; - - pub fn atomic_xadd(dst: &mut T, src: T) -> T; - pub fn atomic_xadd_acq(dst: &mut T, src: T) -> T; - pub fn atomic_xadd_rel(dst: &mut T, src: T) -> T; - pub fn atomic_xadd_acqrel(dst: &mut T, src: T) -> T; - pub fn atomic_xadd_relaxed(dst: &mut T, src: T) -> T; - - pub fn atomic_xsub(dst: &mut T, src: T) -> T; - pub fn atomic_xsub_acq(dst: &mut T, src: T) -> T; - pub fn atomic_xsub_rel(dst: &mut T, src: T) -> T; - pub fn atomic_xsub_acqrel(dst: &mut T, src: T) -> T; - pub fn atomic_xsub_relaxed(dst: &mut T, src: T) -> T; - - pub fn atomic_and(dst: &mut T, src: T) -> T; - pub fn atomic_and_acq(dst: &mut T, src: T) -> T; - pub fn atomic_and_rel(dst: &mut T, src: T) -> T; - pub fn atomic_and_acqrel(dst: &mut T, src: T) -> T; - pub fn atomic_and_relaxed(dst: &mut T, src: T) -> T; - - pub fn atomic_nand(dst: &mut T, src: T) -> T; - pub fn atomic_nand_acq(dst: &mut T, src: T) -> T; - pub fn atomic_nand_rel(dst: &mut T, src: T) -> T; - pub fn atomic_nand_acqrel(dst: &mut T, src: T) -> T; - pub fn atomic_nand_relaxed(dst: &mut T, src: T) -> T; - - pub fn atomic_or(dst: &mut T, src: T) -> T; - pub fn atomic_or_acq(dst: &mut T, src: T) -> T; - pub fn atomic_or_rel(dst: &mut T, src: T) -> T; - pub fn atomic_or_acqrel(dst: &mut T, src: T) -> T; - pub fn atomic_or_relaxed(dst: &mut T, src: T) -> T; - - pub fn atomic_xor(dst: &mut T, src: T) -> T; - pub fn atomic_xor_acq(dst: &mut T, src: T) -> T; - pub fn atomic_xor_rel(dst: &mut T, src: T) -> T; - pub fn atomic_xor_acqrel(dst: &mut T, src: T) -> T; - pub fn atomic_xor_relaxed(dst: &mut T, src: T) -> T; - - pub fn atomic_max(dst: &mut T, src: T) -> T; - pub fn atomic_max_acq(dst: &mut T, src: T) -> T; - pub fn atomic_max_rel(dst: &mut T, src: T) -> T; - pub fn atomic_max_acqrel(dst: &mut T, src: T) -> T; - pub fn atomic_max_relaxed(dst: &mut T, src: T) -> T; - - pub fn atomic_min(dst: &mut T, src: T) -> T; - pub fn atomic_min_acq(dst: &mut T, src: T) -> T; - pub fn atomic_min_rel(dst: &mut T, src: T) -> T; - pub fn atomic_min_acqrel(dst: &mut T, src: T) -> T; - pub fn atomic_min_relaxed(dst: &mut T, src: T) -> T; - - pub fn atomic_umin(dst: &mut T, src: T) -> T; - pub fn atomic_umin_acq(dst: &mut T, src: T) -> T; - pub fn atomic_umin_rel(dst: &mut T, src: T) -> T; - pub fn atomic_umin_acqrel(dst: &mut T, src: T) -> T; - pub fn atomic_umin_relaxed(dst: &mut T, src: T) -> T; - - pub fn atomic_umax(dst: &mut T, src: T) -> T; - pub fn atomic_umax_acq(dst: &mut T, src: T) -> T; - pub fn atomic_umax_rel(dst: &mut T, src: T) -> T; - pub fn atomic_umax_acqrel(dst: &mut T, src: T) -> T; - pub fn atomic_umax_relaxed(dst: &mut T, src: T) -> T; - - pub fn atomic_fence(); - pub fn atomic_fence_acq(); - pub fn atomic_fence_rel(); - pub fn atomic_fence_acqrel(); - - /// Abort the execution of the process. - pub fn abort() -> !; - - /// Execute a breakpoint trap, for inspection by a debugger. - pub fn breakpoint(); - - pub fn volatile_load(src: *T) -> T; - pub fn volatile_store(dst: *mut T, val: T); - - - /// The size of a type in bytes. - /// - /// This is the exact number of bytes in memory taken up by a - /// value of the given type. In other words, a memset of this size - /// would *exactly* overwrite a value. When laid out in vectors - /// and structures there may be additional padding between - /// elements. - pub fn size_of() -> uint; - - /// Move a value to an uninitialized memory location. - /// - /// Drop glue is not run on the destination. - pub fn move_val_init(dst: &mut T, src: T); - - pub fn min_align_of() -> uint; - pub fn pref_align_of() -> uint; - - /// Get a static pointer to a type descriptor. - pub fn get_tydesc() -> *TyDesc; - - /// 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. - pub fn type_id() -> TypeId; - - - /// Create a value initialized to zero. - /// - /// `init` is unsafe because it returns a zeroed-out datum, - /// which is unsafe unless T is Pod. - pub fn init() -> T; - - /// Create an uninitialized value. - pub fn uninit() -> T; - - /// Move a value out of scope without running drop glue. - /// - /// `forget` is unsafe because the caller is responsible for - /// ensuring the argument is deallocated already. - pub fn forget(_: T) -> (); - pub fn transmute(e: T) -> U; - - /// Returns `true` if a type requires drop glue. - pub fn needs_drop() -> bool; - - /// Returns `true` if a type is managed (will be allocated on the local heap) - pub fn owns_managed() -> bool; - - pub fn visit_tydesc(td: *TyDesc, tv: &mut TyVisitor); - - /// Calculates the offset from a pointer. The offset *must* be in-bounds of - /// the object, or one-byte-past-the-end. An arithmetic overflow is also - /// undefined behaviour. - /// - /// This is implemented as an intrinsic to avoid converting to and from an - /// integer, since the conversion would throw away aliasing information. - pub fn offset(dst: *T, offset: int) -> *T; - - /// Equivalent to the appropriate `llvm.memcpy.p0i8.0i8.*` intrinsic, with - /// a size of `count` * `size_of::()` and an alignment of - /// `min_align_of::()` - pub fn copy_nonoverlapping_memory(dst: *mut T, src: *T, count: uint); - - /// Equivalent to the appropriate `llvm.memmove.p0i8.0i8.*` intrinsic, with - /// a size of `count` * `size_of::()` and an alignment of - /// `min_align_of::()` - pub fn copy_memory(dst: *mut T, src: *T, count: uint); - - /// Equivalent to the appropriate `llvm.memset.p0i8.*` intrinsic, with a - /// size of `count` * `size_of::()` and an alignment of - /// `min_align_of::()` - pub fn set_memory(dst: *mut T, val: u8, count: uint); - - pub fn sqrtf32(x: f32) -> f32; - pub fn sqrtf64(x: f64) -> f64; - - pub fn powif32(a: f32, x: i32) -> f32; - pub fn powif64(a: f64, x: i32) -> f64; - - pub fn sinf32(x: f32) -> f32; - pub fn sinf64(x: f64) -> f64; - - pub fn cosf32(x: f32) -> f32; - pub fn cosf64(x: f64) -> f64; - - pub fn powf32(a: f32, x: f32) -> f32; - pub fn powf64(a: f64, x: f64) -> f64; - - pub fn expf32(x: f32) -> f32; - pub fn expf64(x: f64) -> f64; - - pub fn exp2f32(x: f32) -> f32; - pub fn exp2f64(x: f64) -> f64; - - pub fn logf32(x: f32) -> f32; - pub fn logf64(x: f64) -> f64; - - pub fn log10f32(x: f32) -> f32; - pub fn log10f64(x: f64) -> f64; - - pub fn log2f32(x: f32) -> f32; - pub fn log2f64(x: f64) -> f64; - - pub fn fmaf32(a: f32, b: f32, c: f32) -> f32; - pub fn fmaf64(a: f64, b: f64, c: f64) -> f64; - - pub fn fabsf32(x: f32) -> f32; - pub fn fabsf64(x: f64) -> f64; - - pub fn copysignf32(x: f32, y: f32) -> f32; - pub fn copysignf64(x: f64, y: f64) -> f64; - - pub fn floorf32(x: f32) -> f32; - pub fn floorf64(x: f64) -> f64; - - pub fn ceilf32(x: f32) -> f32; - pub fn ceilf64(x: f64) -> f64; - - pub fn truncf32(x: f32) -> f32; - pub fn truncf64(x: f64) -> f64; - - pub fn rintf32(x: f32) -> f32; - pub fn rintf64(x: f64) -> f64; - - pub fn nearbyintf32(x: f32) -> f32; - pub fn nearbyintf64(x: f64) -> f64; - - pub fn roundf32(x: f32) -> f32; - pub fn roundf64(x: f64) -> f64; - - 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 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); - pub fn i64_add_with_overflow(x: i64, y: i64) -> (i64, bool); - - pub fn u8_add_with_overflow(x: u8, y: u8) -> (u8, bool); - pub fn u16_add_with_overflow(x: u16, y: u16) -> (u16, bool); - pub fn u32_add_with_overflow(x: u32, y: u32) -> (u32, bool); - pub fn u64_add_with_overflow(x: u64, y: u64) -> (u64, bool); - - pub fn i8_sub_with_overflow(x: i8, y: i8) -> (i8, bool); - pub fn i16_sub_with_overflow(x: i16, y: i16) -> (i16, bool); - pub fn i32_sub_with_overflow(x: i32, y: i32) -> (i32, bool); - pub fn i64_sub_with_overflow(x: i64, y: i64) -> (i64, bool); - - pub fn u8_sub_with_overflow(x: u8, y: u8) -> (u8, bool); - pub fn u16_sub_with_overflow(x: u16, y: u16) -> (u16, bool); - pub fn u32_sub_with_overflow(x: u32, y: u32) -> (u32, bool); - pub fn u64_sub_with_overflow(x: u64, y: u64) -> (u64, bool); - - pub fn i8_mul_with_overflow(x: i8, y: i8) -> (i8, bool); - pub fn i16_mul_with_overflow(x: i16, y: i16) -> (i16, bool); - pub fn i32_mul_with_overflow(x: i32, y: i32) -> (i32, bool); - pub fn i64_mul_with_overflow(x: i64, y: i64) -> (i64, bool); - - pub fn u8_mul_with_overflow(x: u8, y: u8) -> (u8, bool); - pub fn u16_mul_with_overflow(x: u16, y: u16) -> (u16, bool); - pub fn u32_mul_with_overflow(x: u32, y: u32) -> (u32, bool); - pub fn u64_mul_with_overflow(x: u64, y: u64) -> (u64, bool); -} - - -/// `TypeId` represents a globally unique identifier for a type -#[lang="type_id"] // This needs to be kept in lockstep with the code in trans/intrinsic.rs and - // middle/lang_items.rs -#[deriving(Eq, IterBytes)] -#[cfg(not(test))] -pub struct TypeId { - priv t: u64, -} - -#[cfg(not(test))] -impl TypeId { - /// Returns the `TypeId` of the type this generic function has been instantiated with - pub fn of() -> TypeId { - unsafe { type_id::() } - } -} diff --git a/src/libstd/unstable/mod.rs b/src/libstd/unstable/mod.rs index 87870ef0331..d3dae938b34 100644 --- a/src/libstd/unstable/mod.rs +++ b/src/libstd/unstable/mod.rs @@ -16,7 +16,6 @@ use libc::uintptr_t; pub mod dynamic_lib; pub mod finally; -pub mod intrinsics; pub mod simd; #[cfg(not(test))] pub mod lang; diff --git a/src/libstd/unstable/stack.rs b/src/libstd/unstable/stack.rs index 90c7888973a..655c209fec8 100644 --- a/src/libstd/unstable/stack.rs +++ b/src/libstd/unstable/stack.rs @@ -40,7 +40,7 @@ pub extern "C" fn rust_stack_exhausted() { use rt::local::Local; use rt::task::Task; use str::Str; - use unstable::intrinsics; + use intrinsics; unsafe { // We're calling this function because the stack just ran out. We need -- cgit 1.4.1-3-g733a5