From ed67cdb73c9cf3a1cba768b3122aa03564b43ccc Mon Sep 17 00:00:00 2001 From: Daniel Micay Date: Mon, 22 Jul 2013 00:06:29 -0400 Subject: [PATCH 1/2] new snapshot --- src/libextra/arc.rs | 1 - src/libextra/arena.rs | 26 +-- src/libextra/dbg.rs | 6 - src/libextra/rc.rs | 2 - src/libextra/rl.rs | 3 - src/librustc/back/link.rs | 8 - src/librustc/middle/trans/base.rs | 3 - src/librustc/middle/trans/context.rs | 3 - src/librustc/middle/trans/debuginfo.rs | 139 ------------- src/libstd/cell.rs | 1 - src/libstd/cleanup.rs | 15 +- src/libstd/condition.rs | 61 ------ src/libstd/gc.rs | 15 +- src/libstd/kinds.rs | 20 -- src/libstd/local_data.rs | 47 +---- src/libstd/os.rs | 3 - src/libstd/rand.rs | 3 - src/libstd/reflect.rs | 13 -- src/libstd/repr.rs | 29 --- src/libstd/rt/global_heap.rs | 22 +-- src/libstd/str.rs | 13 -- src/libstd/task/local_data_priv_stage0.rs | 229 ---------------------- src/libstd/task/mod.rs | 4 - src/libstd/task/spawn.rs | 5 - src/libstd/unstable/intrinsics.rs | 9 - src/libstd/util.rs | 13 +- src/libstd/vec.rs | 117 ----------- src/libsyntax/ast_util.rs | 3 - src/libsyntax/diagnostic.rs | 3 - src/libsyntax/parse/token.rs | 3 - src/rt/rust_task.cpp | 3 - src/rt/rust_type.h | 3 - src/snapshots.txt | 8 + 33 files changed, 22 insertions(+), 811 deletions(-) delete mode 100644 src/libstd/task/local_data_priv_stage0.rs diff --git a/src/libextra/arc.rs b/src/libextra/arc.rs index 404d5bfde5876..7a8d6950120f5 100644 --- a/src/libextra/arc.rs +++ b/src/libextra/arc.rs @@ -305,7 +305,6 @@ struct RWARCInner { priv lock: RWlock, priv failed: bool, priv data: T } * * Unlike mutex_arcs, rw_arcs are safe, because they cannot be nested. */ -#[mutable] // XXX remove after snap #[no_freeze] struct RWARC { priv x: UnsafeAtomicRcBox>, diff --git a/src/libextra/arena.rs b/src/libextra/arena.rs index 4ada3bcb6b591..3c10c3545bf45 100644 --- a/src/libextra/arena.rs +++ b/src/libextra/arena.rs @@ -46,15 +46,7 @@ use std::sys; use std::uint; use std::vec; use std::unstable::intrinsics; -use std::unstable::intrinsics::{TyDesc}; - -#[cfg(not(stage0))] -use std::unstable::intrinsics::{get_tydesc}; - -#[cfg(stage0)] -unsafe fn get_tydesc() -> *TyDesc { - intrinsics::get_tydesc::() as *TyDesc -} +use std::unstable::intrinsics::{TyDesc, get_tydesc}; // The way arena uses arrays is really deeply awful. The arrays are // allocated, and have capacities reserved, but the fill for the array @@ -65,7 +57,6 @@ struct Chunk { is_pod: bool, } -#[mutable] // XXX remove after snap #[no_freeze] pub struct Arena { // The head is separated out from the list as a unbenchmarked @@ -117,19 +108,6 @@ fn round_up_to(base: uint, align: uint) -> uint { (base + (align - 1)) & !(align - 1) } -#[inline] -#[cfg(not(stage0))] -unsafe fn call_drop_glue(tydesc: *TyDesc, data: *i8) { - // This function should be inlined when stage0 is gone - ((*tydesc).drop_glue)(data); -} - -#[inline] -#[cfg(stage0)] -unsafe fn call_drop_glue(tydesc: *TyDesc, data: *i8) { - ((*tydesc).drop_glue)(0 as **TyDesc, data); -} - // Walk down a chunk, running the destructors for any objects stored // in it. unsafe fn destroy_chunk(chunk: &Chunk) { @@ -149,7 +127,7 @@ unsafe fn destroy_chunk(chunk: &Chunk) { //debug!("freeing object: idx = %u, size = %u, align = %u, done = %b", // start, size, align, is_done); if is_done { - call_drop_glue(tydesc, ptr::offset(buf, start) as *i8); + ((*tydesc).drop_glue)(ptr::offset(buf, start) as *i8); } // Find where the next tydesc lives diff --git a/src/libextra/dbg.rs b/src/libextra/dbg.rs index 51b01a158ffd5..2c25ee9da78f6 100644 --- a/src/libextra/dbg.rs +++ b/src/libextra/dbg.rs @@ -13,15 +13,9 @@ #[allow(missing_doc)]; use std::cast::transmute; -#[cfg(stage0)] -use intrinsic::{get_tydesc}; -#[cfg(not(stage0))] use std::unstable::intrinsics::{get_tydesc}; pub mod rustrt { - #[cfg(stage0)] - use intrinsic::{TyDesc}; - #[cfg(not(stage0))] use std::unstable::intrinsics::{TyDesc}; #[abi = "cdecl"] diff --git a/src/libextra/rc.rs b/src/libextra/rc.rs index 7cc8bca891077..8d6b146e14264 100644 --- a/src/libextra/rc.rs +++ b/src/libextra/rc.rs @@ -166,9 +166,7 @@ struct RcMutBox { } /// Mutable reference counted pointer type -#[non_owned] #[no_send] -#[mutable] // XXX remove after snap #[no_freeze] #[unsafe_no_drop_flag] pub struct RcMut { diff --git a/src/libextra/rl.rs b/src/libextra/rl.rs index e962eaa9677d4..8d291377b1eb9 100644 --- a/src/libextra/rl.rs +++ b/src/libextra/rl.rs @@ -68,10 +68,7 @@ pub unsafe fn read(prompt: &str) -> Option<~str> { pub type CompletionCb = @fn(~str, @fn(~str)); -#[cfg(not(stage0))] static complete_key: local_data::Key<@CompletionCb> = &local_data::Key; -#[cfg(stage0)] -fn complete_key(_: @CompletionCb) {} /// Bind to the main completion callback pub unsafe fn complete(cb: CompletionCb) { diff --git a/src/librustc/back/link.rs b/src/librustc/back/link.rs index 6bccf7268bb48..bb0280ab0650a 100644 --- a/src/librustc/back/link.rs +++ b/src/librustc/back/link.rs @@ -106,7 +106,6 @@ pub mod jit { use metadata::cstore; use std::cast; - #[cfg(not(stage0))] use std::local_data; use std::unstable::intrinsics; @@ -204,22 +203,15 @@ pub mod jit { // The stage1 compiler won't work, but that doesn't really matter. TLS // changed only very recently to allow storage of owned values. - #[cfg(not(stage0))] static engine_key: local_data::Key<~Engine> = &local_data::Key; - #[cfg(not(stage0))] fn set_engine(engine: ~Engine) { local_data::set(engine_key, engine) } - #[cfg(stage0)] - fn set_engine(_: ~Engine) {} - #[cfg(not(stage0))] pub fn consume_engine() -> Option<~Engine> { local_data::pop(engine_key) } - #[cfg(stage0)] - pub fn consume_engine() -> Option<~Engine> { None } } pub mod write { diff --git a/src/librustc/middle/trans/base.rs b/src/librustc/middle/trans/base.rs index 45a44e7a8a7ef..da92e76e1997f 100644 --- a/src/librustc/middle/trans/base.rs +++ b/src/librustc/middle/trans/base.rs @@ -90,10 +90,7 @@ use syntax::abi::{X86, X86_64, Arm, Mips}; pub use middle::trans::context::task_llcx; -#[cfg(not(stage0))] static task_local_insn_key: local_data::Key<@~[&'static str]> = &local_data::Key; -#[cfg(stage0)] -fn task_local_insn_key(_: @~[&'static str]) {} pub fn with_insn_ctxt(blk: &fn(&[&'static str])) { let opt = local_data::get(task_local_insn_key, |k| k.map(|&k| *k)); diff --git a/src/librustc/middle/trans/context.rs b/src/librustc/middle/trans/context.rs index ffebb87d5cf04..2a071bb00f418 100644 --- a/src/librustc/middle/trans/context.rs +++ b/src/librustc/middle/trans/context.rs @@ -236,9 +236,6 @@ impl Drop for CrateContext { } } -#[cfg(stage0)] -fn task_local_llcx_key(_v: @ContextRef) {} -#[cfg(not(stage0))] static task_local_llcx_key: local_data::Key<@ContextRef> = &local_data::Key; pub fn task_llcx() -> ContextRef { diff --git a/src/librustc/middle/trans/debuginfo.rs b/src/librustc/middle/trans/debuginfo.rs index 0e75e4e85c2f2..220e5b887cb03 100644 --- a/src/librustc/middle/trans/debuginfo.rs +++ b/src/librustc/middle/trans/debuginfo.rs @@ -607,9 +607,6 @@ fn tuple_metadata(cx: &mut CrateContext, span); } -// The stage0 snapshot does not yet support the fixes from PR #7557, so there are two versions of -// following function for now -#[cfg(not(stage0))] fn enum_metadata(cx: &mut CrateContext, enum_type: ty::t, enum_def_id: ast::def_id, @@ -772,142 +769,6 @@ fn enum_metadata(cx: &mut CrateContext, } } -#[cfg(stage0)] -fn enum_metadata(cx: &mut CrateContext, - enum_type: ty::t, - enum_def_id: ast::def_id, - substs: &ty::substs, - span: span) - -> DIType { - - let enum_name = ty_to_str(cx.tcx, enum_type); - - // For empty enums there is an early exit. Just describe it as an empty struct with the - // appropriate type name - if ty::type_is_empty(cx.tcx, enum_type) { - return composite_type_metadata(cx, Type::nil(), enum_name, &[], &[], &[], span); - } - - // Prepare some data (llvm type, size, align, ...) about the discriminant. This data will be - // needed in all of the following cases. - let discriminant_llvm_type = Type::enum_discrim(cx); - let (discriminant_size, discriminant_align) = size_and_align_of(cx, discriminant_llvm_type); - - assert!(Type::enum_discrim(cx) == cx.int_type); - let discriminant_type_metadata = type_metadata(cx, ty::mk_int(), span); - - let variants: &[@ty::VariantInfo] = *ty::enum_variants(cx.tcx, enum_def_id); - - let enumerators_metadata: ~[DIDescriptor] = variants - .iter() - .transform(|v| { - let name: &str = cx.sess.str_of(v.name); - let discriminant_value = v.disr_val as c_ulonglong; - - do name.as_c_str |name| { - unsafe { - llvm::LLVMDIBuilderCreateEnumerator( - DIB(cx), - name, - discriminant_value) - } - } - }) - .collect(); - - let loc = span_start(cx, span); - let file_metadata = file_metadata(cx, loc.file.name); - - let discriminant_type_metadata = do enum_name.as_c_str |enum_name| { - unsafe { - llvm::LLVMDIBuilderCreateEnumerationType( - DIB(cx), - file_metadata, - enum_name, - file_metadata, - loc.line as c_uint, - bytes_to_bits(discriminant_size), - bytes_to_bits(discriminant_align), - create_DIArray(DIB(cx), enumerators_metadata), - discriminant_type_metadata) - } - }; - - if ty::type_is_c_like_enum(cx.tcx, enum_type) { - return discriminant_type_metadata; - } - - let is_univariant = variants.len() == 1; - - let variants_metadata = do variants.map |&vi| { - - let raw_types: &[ty::t] = vi.args; - let arg_types = do raw_types.map |&raw_type| { ty::subst(cx.tcx, substs, raw_type) }; - - let mut arg_llvm_types = do arg_types.map |&ty| { type_of::type_of(cx, ty) }; - let mut arg_names = match vi.arg_names { - Some(ref names) => do names.map |ident| { cx.sess.str_of(*ident).to_owned() }, - None => do arg_types.map |_| { ~"" } - }; - - let mut arg_metadata = do arg_types.map |&ty| { type_metadata(cx, ty, span) }; - - if !is_univariant { - arg_llvm_types.insert(0, discriminant_llvm_type); - arg_names.insert(0, ~""); - arg_metadata.insert(0, discriminant_type_metadata); - } - - let variant_llvm_type = Type::struct_(arg_llvm_types, false); - let (variant_type_size, variant_type_align) = size_and_align_of(cx, variant_llvm_type); - - let variant_type_metadata = composite_type_metadata( - cx, - variant_llvm_type, - &"", - arg_llvm_types, - arg_names, - arg_metadata, - span); - - do "".as_c_str |name| { - unsafe { - llvm::LLVMDIBuilderCreateMemberType( - DIB(cx), - file_metadata, - name, - file_metadata, - loc.line as c_uint, - bytes_to_bits(variant_type_size), - bytes_to_bits(variant_type_align), - bytes_to_bits(0), - 0, - variant_type_metadata) - } - } - }; - - let enum_llvm_type = type_of::type_of(cx, enum_type); - let (enum_type_size, enum_type_align) = size_and_align_of(cx, enum_llvm_type); - - return do enum_name.as_c_str |enum_name| { - unsafe { - llvm::LLVMDIBuilderCreateUnionType( - DIB(cx), - file_metadata, - enum_name, - file_metadata, - loc.line as c_uint, - bytes_to_bits(enum_type_size), - bytes_to_bits(enum_type_align), - 0, // Flags - create_DIArray(DIB(cx), variants_metadata), - 0) // RuntimeLang - } - }; -} - - /// Creates debug information for a composite type, that is, anything that results in a LLVM struct. /// /// Examples of Rust types to use this are: structs, tuples, boxes, vecs, and enums. diff --git a/src/libstd/cell.rs b/src/libstd/cell.rs index 695ed0749dde0..5a0c781fe9a87 100644 --- a/src/libstd/cell.rs +++ b/src/libstd/cell.rs @@ -21,7 +21,6 @@ A dynamic, mutable location. Similar to a mutable option type, but friendlier. */ -#[mutable] // XXX remove after snap #[no_freeze] #[deriving(Clone, DeepClone, Eq)] #[allow(missing_doc)] diff --git a/src/libstd/cleanup.rs b/src/libstd/cleanup.rs index bb011a8cd3270..2ea10b09c8ec1 100644 --- a/src/libstd/cleanup.rs +++ b/src/libstd/cleanup.rs @@ -73,19 +73,6 @@ fn debug_mem() -> bool { false } -#[inline] -#[cfg(not(stage0))] -unsafe fn call_drop_glue(tydesc: *TyDesc, data: *i8) { - // This function should be inlined when stage0 is gone - ((*tydesc).drop_glue)(data); -} - -#[inline] -#[cfg(stage0)] -unsafe fn call_drop_glue(tydesc: *TyDesc, data: *i8) { - ((*tydesc).drop_glue)(0 as **TyDesc, data); -} - /// Destroys all managed memory (i.e. @ boxes) held by the current task. pub unsafe fn annihilate() { use rt::local_heap::local_free; @@ -128,7 +115,7 @@ pub unsafe fn annihilate() { if !uniq { let tydesc: *TyDesc = transmute((*box).header.type_desc); let data = transmute(&(*box).data); - call_drop_glue(tydesc, data); + ((*tydesc).drop_glue)(data); } } diff --git a/src/libstd/condition.rs b/src/libstd/condition.rs index 100751370174f..1f7f96d93c32a 100644 --- a/src/libstd/condition.rs +++ b/src/libstd/condition.rs @@ -23,18 +23,11 @@ pub struct Handler { prev: Option<@Handler>, } -#[cfg(stage0)] -pub struct Condition<'self, T, U> { - name: &'static str, - key: local_data::Key<'self, @Handler> -} -#[cfg(not(stage0))] pub struct Condition { name: &'static str, key: local_data::Key<@Handler> } -#[cfg(not(stage0))] impl Condition { pub fn trap<'a>(&'a self, h: &'a fn(T) -> U) -> Trap<'a, T, U> { unsafe { @@ -73,56 +66,7 @@ impl Condition { } } } -#[cfg(stage0)] -impl<'self, T, U> Condition<'self, T, U> { - pub fn trap<'a>(&'a self, h: &'a fn(T) -> U) -> Trap<'a, T, U> { - unsafe { - let p : *RustClosure = ::cast::transmute(&h); - let prev = local_data::get(::cast::unsafe_copy(&self.key), - |k| k.map(|&x| *x)); - let h = @Handler { handle: *p, prev: prev }; - Trap { cond: self, handler: h } - } - } - - pub fn raise(&self, t: T) -> U { - let msg = fmt!("Unhandled condition: %s: %?", self.name, t); - self.raise_default(t, || fail!(msg.clone())) - } - - pub fn raise_default(&self, t: T, default: &fn() -> U) -> U { - unsafe { - match local_data::pop(::cast::unsafe_copy(&self.key)) { - None => { - debug!("Condition.raise: found no handler"); - default() - } - Some(handler) => { - debug!("Condition.raise: found handler"); - match handler.prev { - None => {} - Some(hp) => { - local_data::set(::cast::unsafe_copy(&self.key), - hp) - } - } - let handle : &fn(T) -> U = - ::cast::transmute(handler.handle); - let u = handle(t); - local_data::set(::cast::unsafe_copy(&self.key), handler); - u - } - } - } - } -} -#[cfg(stage0)] -struct Trap<'self, T, U> { - cond: &'self Condition<'self, T, U>, - handler: @Handler -} -#[cfg(not(stage0))] struct Trap<'self, T, U> { cond: &'self Condition, handler: @Handler @@ -137,11 +81,6 @@ impl<'self, T, U> Trap<'self, T, U> { } } -#[cfg(stage0)] -struct Guard<'self, T, U> { - cond: &'self Condition<'self, T, U> -} -#[cfg(not(stage0))] struct Guard<'self, T, U> { cond: &'self Condition } diff --git a/src/libstd/gc.rs b/src/libstd/gc.rs index 62be923d7707a..911fb5625e588 100644 --- a/src/libstd/gc.rs +++ b/src/libstd/gc.rs @@ -317,19 +317,6 @@ fn expect_sentinel() -> bool { true } #[cfg(nogc)] fn expect_sentinel() -> bool { false } -#[inline] -#[cfg(not(stage0))] -unsafe fn call_drop_glue(tydesc: *TyDesc, data: *i8) { - // This function should be inlined when stage0 is gone - ((*tydesc).drop_glue)(data); -} - -#[inline] -#[cfg(stage0)] -unsafe fn call_drop_glue(tydesc: *TyDesc, data: *i8) { - ((*tydesc).drop_glue)(0 as **TyDesc, data); -} - // Entry point for GC-based cleanup. Walks stack looking for exchange // heap and stack allocations requiring drop, and runs all // destructors. @@ -373,7 +360,7 @@ pub fn cleanup_stack_for_failure() { // FIXME #4420: Destroy this box // FIXME #4330: Destroy this box } else { - call_drop_glue(tydesc, *root as *i8); + ((*tydesc).drop_glue)(*root as *i8); } } } diff --git a/src/libstd/kinds.rs b/src/libstd/kinds.rs index f13eeece2f4a7..6b45ddddf7e93 100644 --- a/src/libstd/kinds.rs +++ b/src/libstd/kinds.rs @@ -29,31 +29,11 @@ The 2 kinds are #[allow(missing_doc)]; -#[cfg(stage0)] -#[lang="copy"] -pub trait Copy { - // Empty. -} - -#[cfg(stage0)] -#[lang="owned"] -pub trait Send { - // empty. -} - -#[cfg(not(stage0))] #[lang="send"] pub trait Send { // empty. } -#[cfg(stage0)] -#[lang="const"] -pub trait Freeze { - // empty. -} - -#[cfg(not(stage0))] #[lang="freeze"] pub trait Freeze { // empty. diff --git a/src/libstd/local_data.rs b/src/libstd/local_data.rs index 2c1a3bb29a09d..537289c8dd6c2 100644 --- a/src/libstd/local_data.rs +++ b/src/libstd/local_data.rs @@ -56,10 +56,7 @@ use task::local_data_priv::*; * sections to ensure that each value of the `Key` type points to a unique * location. */ -#[cfg(not(stage0))] pub type Key = &'static KeyValue; -#[cfg(stage0)] -pub type Key<'self,T> = &'self fn(v: T); pub enum KeyValue { Key } @@ -67,73 +64,37 @@ pub enum KeyValue { Key } * Remove a task-local data value from the table, returning the * reference that was originally created to insert it. */ -#[cfg(stage0)] -pub fn pop(key: Key<@T>) -> Option<@T> { - unsafe { local_pop(Handle::new(), key) } -} -/** - * Remove a task-local data value from the table, returning the - * reference that was originally created to insert it. - */ -#[cfg(not(stage0))] pub fn pop(key: Key) -> Option { unsafe { local_pop(Handle::new(), key) } } + /** * Retrieve a task-local data value. It will also be kept alive in the * table until explicitly removed. */ -#[cfg(stage0)] -pub fn get(key: Key<@T>, f: &fn(Option<&@T>) -> U) -> U { - unsafe { local_get(Handle::new(), key, f) } -} -/** - * Retrieve a task-local data value. It will also be kept alive in the - * table until explicitly removed. - */ -#[cfg(not(stage0))] pub fn get(key: Key, f: &fn(Option<&T>) -> U) -> U { unsafe { local_get(Handle::new(), key, f) } } + /** * Retrieve a mutable borrowed pointer to a task-local data value. */ -#[cfg(not(stage0))] pub fn get_mut(key: Key, f: &fn(Option<&mut T>) -> U) -> U { unsafe { local_get_mut(Handle::new(), key, f) } } + /** * Store a value in task-local data. If this key already has a value, * that value is overwritten (and its destructor is run). */ -#[cfg(stage0)] -pub fn set(key: Key<@T>, data: @T) { - unsafe { local_set(Handle::new(), key, data) } -} -/** - * Store a value in task-local data. If this key already has a value, - * that value is overwritten (and its destructor is run). - */ -#[cfg(not(stage0))] pub fn set(key: Key, data: T) { unsafe { local_set(Handle::new(), key, data) } } + /** * Modify a task-local data value. If the function returns 'None', the * data is removed (and its reference dropped). */ -#[cfg(stage0)] -pub fn modify(key: Key<@T>, f: &fn(Option<@T>) -> Option<@T>) { - match f(pop(key)) { - Some(next) => { set(key, next); } - None => {} - } -} -/** - * Modify a task-local data value. If the function returns 'None', the - * data is removed (and its reference dropped). - */ -#[cfg(not(stage0))] pub fn modify(key: Key, f: &fn(Option) -> Option) { unsafe { match f(pop(::cast::unsafe_copy(&key))) { diff --git a/src/libstd/os.rs b/src/libstd/os.rs index 3b37fb077d66d..bbfa15d69bd94 100644 --- a/src/libstd/os.rs +++ b/src/libstd/os.rs @@ -1237,9 +1237,6 @@ struct OverriddenArgs { val: ~[~str] } -#[cfg(stage0)] -fn overridden_arg_key(_v: @OverriddenArgs) {} -#[cfg(not(stage0))] static overridden_arg_key: local_data::Key<@OverriddenArgs> = &local_data::Key; /// Returns the arguments which this program was started with (normally passed diff --git a/src/libstd/rand.rs b/src/libstd/rand.rs index 5be73bbfc68ae..9af2d8be2970f 100644 --- a/src/libstd/rand.rs +++ b/src/libstd/rand.rs @@ -852,9 +852,6 @@ pub fn seed() -> ~[u8] { } // used to make space in TLS for a random number generator -#[cfg(stage0)] -fn tls_rng_state(_v: @@mut IsaacRng) {} -#[cfg(not(stage0))] static tls_rng_state: local_data::Key<@@mut IsaacRng> = &local_data::Key; /** diff --git a/src/libstd/reflect.rs b/src/libstd/reflect.rs index 63d2492bd338d..d49d54ae68fe6 100644 --- a/src/libstd/reflect.rs +++ b/src/libstd/reflect.rs @@ -16,9 +16,6 @@ Runtime type reflection #[allow(missing_doc)]; -#[cfg(stage0)] -use intrinsic::{Opaque, TyDesc, TyVisitor}; -#[cfg(not(stage0))] use unstable::intrinsics::{Opaque, TyDesc, TyVisitor}; use libc::c_void; use sys; @@ -197,14 +194,6 @@ impl TyVisitor for MovePtrAdaptor { true } - #[cfg(stage0)] - fn visit_str(&self) -> bool { - self.align_to::<~str>(); - if ! self.inner.visit_str() { return false; } - self.bump_past::<~str>(); - true - } - fn visit_estr_box(&self) -> bool { self.align_to::<@str>(); if ! self.inner.visit_estr_box() { return false; } @@ -249,7 +238,6 @@ impl TyVisitor for MovePtrAdaptor { true } - #[cfg(not(stage0))] fn visit_uniq_managed(&self, mtbl: uint, inner: *TyDesc) -> bool { self.align_to::<~u8>(); if ! self.inner.visit_uniq_managed(mtbl, inner) { return false; } @@ -298,7 +286,6 @@ impl TyVisitor for MovePtrAdaptor { true } - #[cfg(not(stage0))] fn visit_evec_uniq_managed(&self, mtbl: uint, inner: *TyDesc) -> bool { self.align_to::<~[@u8]>(); if ! self.inner.visit_evec_uniq_managed(mtbl, inner) { return false; } diff --git a/src/libstd/repr.rs b/src/libstd/repr.rs index 0aeff2b0b778c..07fd82e16160a 100644 --- a/src/libstd/repr.rs +++ b/src/libstd/repr.rs @@ -31,9 +31,6 @@ use to_str::ToStr; use vec::raw::{VecRepr, SliceRepr}; use vec; use vec::{OwnedVector, UnboxedVecRepr}; -#[cfg(stage0)] -use intrinsic::{Opaque, TyDesc, TyVisitor, get_tydesc, visit_tydesc}; -#[cfg(not(stage0))] use unstable::intrinsics::{Opaque, TyDesc, TyVisitor, get_tydesc, visit_tydesc}; #[cfg(test)] use io; @@ -267,10 +264,6 @@ impl TyVisitor for ReprVisitor { } } - // Type no longer exists, vestigial function. - #[cfg(stage0)] - fn visit_str(&self) -> bool { fail!(); } - fn visit_estr_box(&self) -> bool { do self.get::<@str> |s| { self.writer.write_char('@'); @@ -309,7 +302,6 @@ impl TyVisitor for ReprVisitor { } } - #[cfg(not(stage0))] fn visit_uniq_managed(&self, _mtbl: uint, inner: *TyDesc) -> bool { self.writer.write_char('~'); do self.get::<&managed::raw::BoxRepr> |b| { @@ -351,15 +343,6 @@ impl TyVisitor for ReprVisitor { } } - #[cfg(stage0)] - fn visit_evec_uniq(&self, mtbl: uint, inner: *TyDesc) -> bool { - do self.get::<&VecRepr> |b| { - self.writer.write_char('~'); - self.write_unboxed_vec_repr(mtbl, &b.unboxed, inner); - } - } - - #[cfg(not(stage0))] fn visit_evec_uniq(&self, mtbl: uint, inner: *TyDesc) -> bool { do self.get::<&UnboxedVecRepr> |b| { self.writer.write_char('~'); @@ -367,7 +350,6 @@ impl TyVisitor for ReprVisitor { } } - #[cfg(not(stage0))] fn visit_evec_uniq_managed(&self, mtbl: uint, inner: *TyDesc) -> bool { do self.get::<&VecRepr> |b| { self.writer.write_char('~'); @@ -563,7 +545,6 @@ impl TyVisitor for ReprVisitor { fn visit_self(&self) -> bool { true } fn visit_type(&self) -> bool { true } - #[cfg(not(stage0))] fn visit_opaque_box(&self) -> bool { self.writer.write_char('@'); do self.get::<&managed::raw::BoxRepr> |b| { @@ -571,16 +552,6 @@ impl TyVisitor for ReprVisitor { self.visit_ptr_inner(p, b.header.type_desc); } } - #[cfg(stage0)] - fn visit_opaque_box(&self) -> bool { - self.writer.write_char('@'); - do self.get::<&managed::raw::BoxRepr> |b| { - let p = ptr::to_unsafe_ptr(&b.data) as *c_void; - unsafe { - self.visit_ptr_inner(p, transmute(b.header.type_desc)); - } - } - } // Type no longer exists, vestigial function. fn visit_constr(&self, _inner: *TyDesc) -> bool { fail!(); } diff --git a/src/libstd/rt/global_heap.rs b/src/libstd/rt/global_heap.rs index d0b268ace5470..580390c19530e 100644 --- a/src/libstd/rt/global_heap.rs +++ b/src/libstd/rt/global_heap.rs @@ -56,28 +56,8 @@ pub unsafe fn realloc_raw(ptr: *mut c_void, size: uint) -> *mut c_void { p } -// FIXME #4942: Make these signatures agree with exchange_alloc's signatures -#[cfg(stage0, not(test))] -#[lang="exchange_malloc"] -#[inline] -pub unsafe fn exchange_malloc(td: *c_char, size: uintptr_t) -> *c_char { - let td = td as *TyDesc; - let size = size as uint; - - assert!(td.is_not_null()); - - let total_size = get_box_size(size, (*td).align); - let p = malloc_raw(total_size as uint); - - let box: *mut BoxRepr = p as *mut BoxRepr; - (*box).header.ref_count = -1; - (*box).header.type_desc = td; - - box as *c_char -} - /// The allocator for unique pointers without contained managed pointers. -#[cfg(not(stage0), not(test))] +#[cfg(not(test))] #[lang="exchange_malloc"] #[inline] pub unsafe fn exchange_malloc(size: uintptr_t) -> *c_char { diff --git a/src/libstd/str.rs b/src/libstd/str.rs index 97fc56d007db7..125df156ed0b2 100644 --- a/src/libstd/str.rs +++ b/src/libstd/str.rs @@ -1006,19 +1006,6 @@ pub mod raw { /// Sets the length of the string and adds the null terminator #[inline] - #[cfg(stage0)] - pub unsafe fn set_len(v: &mut ~str, new_len: uint) { - let v: **mut vec::raw::VecRepr = cast::transmute(v); - let repr: *mut vec::raw::VecRepr = *v; - (*repr).unboxed.fill = new_len + 1u; - let null = ptr::mut_offset(cast::transmute(&((*repr).unboxed.data)), - new_len); - *null = 0u8; - } - - /// Sets the length of the string and adds the null terminator - #[inline] - #[cfg(not(stage0))] pub unsafe fn set_len(v: &mut ~str, new_len: uint) { let v: **mut vec::UnboxedVecRepr = cast::transmute(v); let repr: *mut vec::UnboxedVecRepr = *v; diff --git a/src/libstd/task/local_data_priv_stage0.rs b/src/libstd/task/local_data_priv_stage0.rs deleted file mode 100644 index fe80ec06c69d0..0000000000000 --- a/src/libstd/task/local_data_priv_stage0.rs +++ /dev/null @@ -1,229 +0,0 @@ -// 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 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -#[allow(missing_doc)]; - -use cast; -use cmp::Eq; -use libc; -use local_data; -use prelude::*; -use sys; -use task::rt; - -use super::rt::rust_task; -use rt::task::{Task, LocalStorage}; - -pub enum Handle { - OldHandle(*rust_task), - NewHandle(*mut LocalStorage) -} - -impl Handle { - pub fn new() -> Handle { - use rt::{context, OldTaskContext}; - use rt::local::Local; - unsafe { - match context() { - OldTaskContext => { - OldHandle(rt::rust_get_task()) - } - _ => { - let task = Local::unsafe_borrow::(); - NewHandle(&mut (*task).storage) - } - } - } - } -} - -pub trait LocalData { } -impl LocalData for @T { } - -impl Eq for @LocalData { - fn eq(&self, other: &@LocalData) -> bool { - unsafe { - let ptr_a: &(uint, uint) = cast::transmute(self); - let ptr_b: &(uint, uint) = cast::transmute(other); - return ptr_a == ptr_b; - } - } - fn ne(&self, other: &@LocalData) -> bool { !(*self).eq(other) } -} - -// If TLS is used heavily in future, this could be made more efficient with a -// proper map. -type TaskLocalElement = (*libc::c_void, *libc::c_void, @LocalData); -// Has to be a pointer at outermost layer; the foreign call returns void *. -type TaskLocalMap = ~[Option]; - -fn cleanup_task_local_map(map_ptr: *libc::c_void) { - unsafe { - assert!(!map_ptr.is_null()); - // Get and keep the single reference that was created at the - // beginning. - let _map: TaskLocalMap = cast::transmute(map_ptr); - // All local_data will be destroyed along with the map. - } -} - -// Gets the map from the runtime. Lazily initialises if not done so already. -unsafe fn get_local_map(handle: Handle) -> &mut TaskLocalMap { - match handle { - OldHandle(task) => get_task_local_map(task), - NewHandle(local_storage) => get_newsched_local_map(local_storage) - } -} - -unsafe fn get_task_local_map(task: *rust_task) -> &mut TaskLocalMap { - - extern fn cleanup_task_local_map_extern_cb(map_ptr: *libc::c_void) { - cleanup_task_local_map(map_ptr); - } - - // Relies on the runtime initialising the pointer to null. - // Note: the map is an owned pointer and is "owned" by TLS. It is moved - // into the tls slot for this task, and then mutable loans are taken from - // this slot to modify the map. - let map_ptr = rt::rust_get_task_local_data(task); - if (*map_ptr).is_null() { - // First time TLS is used, create a new map and set up the necessary - // TLS information for its safe destruction - let map: TaskLocalMap = ~[]; - *map_ptr = cast::transmute(map); - rt::rust_task_local_data_atexit(task, cleanup_task_local_map_extern_cb); - } - return cast::transmute(map_ptr); -} - -unsafe fn get_newsched_local_map(local: *mut LocalStorage) -> &mut TaskLocalMap { - // This is based on the same idea as the oldsched code above. - match &mut *local { - // If the at_exit function is already set, then we just need to take a - // loan out on the TLS map stored inside - &LocalStorage(ref mut map_ptr, Some(_)) => { - assert!(map_ptr.is_not_null()); - return cast::transmute(map_ptr); - } - // If this is the first time we've accessed TLS, perform similar - // actions to the oldsched way of doing things. - &LocalStorage(ref mut map_ptr, ref mut at_exit) => { - assert!(map_ptr.is_null()); - assert!(at_exit.is_none()); - let map: TaskLocalMap = ~[]; - *map_ptr = cast::transmute(map); - *at_exit = Some(cleanup_task_local_map); - return cast::transmute(map_ptr); - } - } -} - -unsafe fn key_to_key_value(key: local_data::Key<@T>) -> *libc::c_void { - let pair: sys::Closure = cast::transmute(key); - return pair.code as *libc::c_void; -} - -// If returning Some(..), returns with @T with the map's reference. Careful! -unsafe fn local_data_lookup( - map: &mut TaskLocalMap, key: local_data::Key<@T>) - -> Option<(uint, *libc::c_void)> { - - let key_value = key_to_key_value(key); - for map.iter().enumerate().advance |(i, entry)| { - match *entry { - Some((k, data, _)) if k == key_value => { return Some((i, data)); } - _ => {} - } - } - return None; -} - -unsafe fn local_get_helper( - handle: Handle, key: local_data::Key<@T>, - do_pop: bool) -> Option<@T> { - - let map = get_local_map(handle); - // Interpreturn our findings from the map - do local_data_lookup(map, key).map |result| { - // A reference count magically appears on 'data' out of thin air. It - // was referenced in the local_data box, though, not here, so before - // overwriting the local_data_box we need to give an extra reference. - // We must also give an extra reference when not removing. - let (index, data_ptr) = *result; - let data: @T = cast::transmute(data_ptr); - cast::bump_box_refcount(data); - if do_pop { - map[index] = None; - } - data - } -} - - -pub unsafe fn local_pop( - handle: Handle, - key: local_data::Key<@T>) -> Option<@T> { - - local_get_helper(handle, key, true) -} - -pub unsafe fn local_get( - handle: Handle, - key: local_data::Key<@T>, - f: &fn(Option<&@T>) -> U) -> U { - - match local_get_helper(handle, key, false) { - Some(ref x) => f(Some(x)), - None => f(None) - } -} - -pub unsafe fn local_set( - handle: Handle, key: local_data::Key<@T>, data: @T) { - - let map = get_local_map(handle); - // Store key+data as *voids. Data is invisibly referenced once; key isn't. - let keyval = key_to_key_value(key); - // We keep the data in two forms: one as an unsafe pointer, so we can get - // it back by casting; another in an existential box, so the reference we - // own on it can be dropped when the box is destroyed. The unsafe pointer - // does not have a reference associated with it, so it may become invalid - // when the box is destroyed. - let data_ptr = *cast::transmute::<&@T, &*libc::c_void>(&data); - let data_box = @data as @LocalData; - // Construct new entry to store in the map. - let new_entry = Some((keyval, data_ptr, data_box)); - // Find a place to put it. - match local_data_lookup(map, key) { - Some((index, _old_data_ptr)) => { - // Key already had a value set, _old_data_ptr, whose reference - // will get dropped when the local_data box is overwritten. - map[index] = new_entry; - } - None => { - // Find an empty slot. If not, grow the vector. - match map.iter().position(|x| x.is_none()) { - Some(empty_index) => { map[empty_index] = new_entry; } - None => { map.push(new_entry); } - } - } - } -} - -pub unsafe fn local_modify( - handle: Handle, key: local_data::Key<@T>, - modify_fn: &fn(Option<@T>) -> Option<@T>) { - - // Could be more efficient by doing the lookup work, but this is easy. - let newdata = modify_fn(local_pop(handle, key)); - if newdata.is_some() { - local_set(handle, key, newdata.unwrap()); - } -} diff --git a/src/libstd/task/mod.rs b/src/libstd/task/mod.rs index f2563b37347a5..1ce8641085bfb 100644 --- a/src/libstd/task/mod.rs +++ b/src/libstd/task/mod.rs @@ -54,10 +54,6 @@ use util; #[cfg(test)] use ptr; #[cfg(test)] use task; -#[cfg(stage0)] -#[path="local_data_priv_stage0.rs"] -mod local_data_priv; -#[cfg(not(stage0))] mod local_data_priv; pub mod rt; pub mod spawn; diff --git a/src/libstd/task/spawn.rs b/src/libstd/task/spawn.rs index 2150c0c5ac28d..a17bb2b163259 100644 --- a/src/libstd/task/spawn.rs +++ b/src/libstd/task/spawn.rs @@ -487,14 +487,9 @@ fn kill_taskgroup(state: TaskGroupInner, me: &TaskHandle, is_main: bool) { // FIXME (#2912): Work around core-vs-coretest function duplication. Can't use // a proper closure because the #[test]s won't understand. Have to fake it. -#[cfg(not(stage0))] fn taskgroup_key() -> local_data::Key<@@mut Taskgroup> { unsafe { cast::transmute(-2) } } -#[cfg(stage0)] -fn taskgroup_key() -> local_data::Key<@@mut Taskgroup> { - unsafe { cast::transmute((-2, 0)) } -} // Transitionary. struct RuntimeGlue; diff --git a/src/libstd/unstable/intrinsics.rs b/src/libstd/unstable/intrinsics.rs index 275a8c94c6902..76958fa333fd3 100644 --- a/src/libstd/unstable/intrinsics.rs +++ b/src/libstd/unstable/intrinsics.rs @@ -36,12 +36,8 @@ A quick refresher on memory ordering: #[cfg(test)] pub use realstd::unstable::intrinsics::{TyDesc, Opaque, TyVisitor}; -#[cfg(not(stage0))] pub type GlueFn = extern "Rust" fn(*i8); -#[cfg(stage0)] -pub type GlueFn = extern "Rust" fn(**TyDesc, *i8); - // NB: this has to be kept in sync with the Rust ABI. #[lang="ty_desc"] #[cfg(not(test))] @@ -284,10 +280,7 @@ extern "rust-intrinsic" { pub fn pref_align_of() -> uint; /// Get a static pointer to a type descriptor. - #[cfg(not(stage0))] pub fn get_tydesc() -> *TyDesc; - #[cfg(stage0)] - pub fn get_tydesc() -> *(); /// Create a value initialized to zero. /// @@ -310,10 +303,8 @@ extern "rust-intrinsic" { pub fn needs_drop() -> bool; /// Returns `true` if a type is managed (will be allocated on the local heap) - #[cfg(not(stage0))] pub fn contains_managed() -> bool; - #[cfg(not(stage0))] pub fn visit_tydesc(td: *TyDesc, tv: @TyVisitor); pub fn frame_address(f: &once fn(*u8)); diff --git a/src/libstd/util.rs b/src/libstd/util.rs index 8e7efeb532a74..5ae45b74dd8ca 100644 --- a/src/libstd/util.rs +++ b/src/libstd/util.rs @@ -175,18 +175,16 @@ mod tests { // verify that `#[unsafe_no_drop_flag]` works as intended on a zero-size struct - // NOTE: uncomment after snapshot, will not parse yet - //static mut did_run: bool = false; + static mut did_run: bool = false; struct Foo { five: int } impl Drop for Foo { fn drop(&self) { assert_eq!(self.five, 5); - // NOTE: uncomment after snapshot, will not parse yet - //unsafe { - //did_run = true; - //} + unsafe { + did_run = true; + } } } @@ -194,7 +192,6 @@ mod tests { let _a = (NonCopyable, Foo { five: 5 }, NonCopyable); } - // NOTE: uncomment after snapshot, will not parse yet - //unsafe { assert_eq!(did_run, true); } + unsafe { assert_eq!(did_run, true); } } } diff --git a/src/libstd/vec.rs b/src/libstd/vec.rs index 877ee65b4d67f..6c9d3c15b9ef2 100644 --- a/src/libstd/vec.rs +++ b/src/libstd/vec.rs @@ -25,16 +25,12 @@ use option::{None, Option, Some}; use ptr::to_unsafe_ptr; use ptr; use ptr::RawPtr; -#[cfg(not(stage0))] use rt::global_heap::malloc_raw; use rt::global_heap::realloc_raw; use sys; use sys::size_of; use uint; use unstable::intrinsics; -#[cfg(stage0)] -use intrinsic::{get_tydesc}; -#[cfg(not(stage0))] use unstable::intrinsics::{get_tydesc, contains_managed}; use vec; use util; @@ -91,15 +87,6 @@ pub fn from_elem(n_elts: uint, t: T) -> ~[T] { } /// Creates a new vector with a capacity of `capacity` -#[cfg(stage0)] -pub fn with_capacity(capacity: uint) -> ~[T] { - let mut vec = ~[]; - vec.reserve(capacity); - vec -} - -/// Creates a new vector with a capacity of `capacity` -#[cfg(not(stage0))] pub fn with_capacity(capacity: uint) -> ~[T] { unsafe { if contains_managed::() { @@ -1136,40 +1123,6 @@ impl OwnedVector for ~[T] { * * * n - The number of elements to reserve space for */ - #[cfg(stage0)] - fn reserve(&mut self, n: uint) { - // Only make the (slow) call into the runtime if we have to - use managed; - if self.capacity() < n { - unsafe { - let ptr: *mut *mut raw::VecRepr = cast::transmute(self); - let td = get_tydesc::(); - if ((**ptr).box_header.ref_count == - managed::raw::RC_MANAGED_UNIQUE) { - // XXX transmute shouldn't be necessary - let td = cast::transmute(td); - ::at_vec::raw::reserve_raw(td, ptr, n); - } else { - let alloc = n * sys::nonzero_size_of::(); - *ptr = realloc_raw(*ptr as *mut c_void, alloc + size_of::()) - as *mut raw::VecRepr; - (**ptr).unboxed.alloc = alloc; - } - } - } - } - - /** - * Reserves capacity for exactly `n` elements in the given vector. - * - * If the capacity for `self` is already equal to or greater than the requested - * capacity, then no action is taken. - * - * # Arguments - * - * * n - The number of elements to reserve space for - */ - #[cfg(not(stage0))] fn reserve(&mut self, n: uint) { // Only make the (slow) call into the runtime if we have to if self.capacity() < n { @@ -1213,17 +1166,6 @@ impl OwnedVector for ~[T] { /// Returns the number of elements the vector can hold without reallocating. #[inline] - #[cfg(stage0)] - fn capacity(&self) -> uint { - unsafe { - let repr: **raw::VecRepr = transmute(self); - (**repr).unboxed.alloc / sys::nonzero_size_of::() - } - } - - /// Returns the number of elements the vector can hold without reallocating. - #[inline] - #[cfg(not(stage0))] fn capacity(&self) -> uint { unsafe { if contains_managed::() { @@ -1238,23 +1180,6 @@ impl OwnedVector for ~[T] { /// Append an element to a vector #[inline] - #[cfg(stage0)] - fn push(&mut self, t: T) { - unsafe { - let repr: **raw::VecRepr = transmute(&mut *self); - let fill = (**repr).unboxed.fill; - if (**repr).unboxed.alloc <= fill { - let new_len = self.len() + 1; - self.reserve_at_least(new_len); - } - - self.push_fast(t); - } - } - - /// Append an element to a vector - #[inline] - #[cfg(not(stage0))] fn push(&mut self, t: T) { unsafe { if contains_managed::() { @@ -1281,19 +1206,6 @@ impl OwnedVector for ~[T] { // This doesn't bother to make sure we have space. #[inline] // really pretty please - #[cfg(stage0)] - unsafe fn push_fast(&mut self, t: T) { - let repr: **mut raw::VecRepr = transmute(self); - let fill = (**repr).unboxed.fill; - (**repr).unboxed.fill += sys::nonzero_size_of::(); - let p = to_unsafe_ptr(&((**repr).unboxed.data)); - let p = ptr::offset(p, fill) as *mut T; - intrinsics::move_val_init(&mut(*p), t); - } - - // This doesn't bother to make sure we have space. - #[inline] // really pretty please - #[cfg(not(stage0))] unsafe fn push_fast(&mut self, t: T) { if contains_managed::() { let repr: **mut raw::VecRepr = transmute(self); @@ -1901,7 +1813,6 @@ pub mod raw { use sys; use unstable::intrinsics; use vec::{UnboxedVecRepr, with_capacity, ImmutableVector, MutableVector}; - #[cfg(not(stage0))] use unstable::intrinsics::contains_managed; /// The internal representation of a (boxed) vector @@ -1927,21 +1838,6 @@ pub mod raw { * the vector is actually the specified size. */ #[inline] - #[cfg(stage0)] - pub unsafe fn set_len(v: &mut ~[T], new_len: uint) { - let repr: **mut VecRepr = transmute(v); - (**repr).unboxed.fill = new_len * sys::nonzero_size_of::(); - } - - /** - * Sets the length of a vector - * - * This will explicitly set the size of the vector, without actually - * modifing its buffers, so it is up to the caller to ensure that - * the vector is actually the specified size. - */ - #[inline] - #[cfg(not(stage0))] pub unsafe fn set_len(v: &mut ~[T], new_len: uint) { if contains_managed::() { let repr: **mut VecRepr = transmute(v); @@ -2286,19 +2182,6 @@ impl Iterator for VecConsumeRevIterator { } } -#[cfg(stage0)] -impl> FromIterator for ~[A] { - pub fn from_iterator(iterator: &mut T) -> ~[A] { - let mut xs = ~[]; - for iterator.advance |x| { - xs.push(x); - } - xs - } -} - - -#[cfg(not(stage0))] impl> FromIterator for ~[A] { pub fn from_iterator(iterator: &mut T) -> ~[A] { let (lower, _) = iterator.size_hint(); diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs index 97e940805bbbc..15ac50b917cc3 100644 --- a/src/libsyntax/ast_util.rs +++ b/src/libsyntax/ast_util.rs @@ -704,10 +704,7 @@ pub fn new_sctable_internal() -> SCTable { // fetch the SCTable from TLS, create one if it doesn't yet exist. pub fn get_sctable() -> @mut SCTable { - #[cfg(not(stage0))] static sctable_key: local_data::Key<@@mut SCTable> = &local_data::Key; - #[cfg(stage0)] - fn sctable_key(_: @@mut SCTable) {} match local_data::get(sctable_key, |k| k.map(|&k| *k)) { None => { let new_table = @@mut new_sctable_internal(); diff --git a/src/libsyntax/diagnostic.rs b/src/libsyntax/diagnostic.rs index 717c5571994ff..8be55ac0dc715 100644 --- a/src/libsyntax/diagnostic.rs +++ b/src/libsyntax/diagnostic.rs @@ -188,10 +188,7 @@ fn diagnosticcolor(lvl: level) -> term::color::Color { } fn print_maybe_styled(msg: &str, color: term::attr::Attr) { - #[cfg(not(stage0))] static tls_terminal: local_data::Key<@Option> = &local_data::Key; - #[cfg(stage0)] - fn tls_terminal(_: @Option) {} let stderr = io::stderr(); diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs index 754b7268a4afd..322424b90fbe1 100644 --- a/src/libsyntax/parse/token.rs +++ b/src/libsyntax/parse/token.rs @@ -484,11 +484,8 @@ fn mk_fresh_ident_interner() -> @ident_interner { // if an interner exists in TLS, return it. Otherwise, prepare a // fresh one. pub fn get_ident_interner() -> @ident_interner { - #[cfg(not(stage0))] static key: local_data::Key<@@::parse::token::ident_interner> = &local_data::Key; - #[cfg(stage0)] - fn key(_: @@::parse::token::ident_interner) {} match local_data::get(key, |k| k.map(|&k| *k)) { Some(interner) => *interner, None => { diff --git a/src/rt/rust_task.cpp b/src/rt/rust_task.cpp index 4d6d2567cd452..a4afb1c0bc535 100644 --- a/src/rt/rust_task.cpp +++ b/src/rt/rust_task.cpp @@ -183,9 +183,6 @@ void task_start_wrapper(spawn_args *a) // free the environment (which should be a unique closure). const type_desc *td = env->td; td->drop_glue(NULL, -#ifdef _RUST_STAGE0 - NULL, -#endif box_body(env)); task->kernel->region()->free(env); } diff --git a/src/rt/rust_type.h b/src/rt/rust_type.h index 30ff5f1fa54e2..60ca5674b0163 100644 --- a/src/rt/rust_type.h +++ b/src/rt/rust_type.h @@ -26,9 +26,6 @@ typedef void (*CDECL spawn_fn)(rust_opaque_box*, void *); struct type_desc; typedef void CDECL (glue_fn)(void *, -#ifdef _RUST_STAGE0 - const type_desc **, -#endif void *); // Corresponds to the boxed data in the @ region. The body follows the diff --git a/src/snapshots.txt b/src/snapshots.txt index 910de5f66b7f6..a3297ef7f1d84 100644 --- a/src/snapshots.txt +++ b/src/snapshots.txt @@ -1,3 +1,11 @@ +S 2013-07-21 e336cbf + macos-i386 d9666dccc1040ebe298a54acb378902a7472ad0f + macos-x86_64 808f68916444e3857ef2aab20f8db9db8f4b0b4a + winnt-i386 f9a5f891fd24e9446acb2a1b5d697461665c4388 + freebsd-x86_64 8e79f6e970bc33ea6a3b9329bc4526d89ca63d47 + linux-i386 054a0229b9cbdadf013868ba01a8277883f83a6d + linux-x86_64 2c53a72e9c9bb547df248a2d4b857d480ce0b910 + S 2013-06-23 f827561 macos-i386 63ffbcf99b6853d7840bdfe01380068518d0e466 macos-x86_64 b34fdf3845f8ef4760817007d8ef820cd32f2e07 From f51e2ad435d7c0b4cb1bdebc5b6db29b65249125 Mon Sep 17 00:00:00 2001 From: Daniel Micay Date: Mon, 22 Jul 2013 01:00:00 -0400 Subject: [PATCH 2/2] temporarily disable 3 rustpkg tests Re-enabling these when the ephemeral failures are fixed is filed as issue #7956. --- src/librustpkg/tests.rs | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/src/librustpkg/tests.rs b/src/librustpkg/tests.rs index 7953d4545a845..4b4a1645a9b4c 100644 --- a/src/librustpkg/tests.rs +++ b/src/librustpkg/tests.rs @@ -475,7 +475,8 @@ fn test_install_invalid() { // Tests above should (maybe) be converted to shell out to rustpkg, too -#[test] #[ignore(cfg(target_arch = "x86"))] +// FIXME: #7956: temporarily disabled +#[ignore(cfg(target_arch = "x86"))] fn test_install_git() { let sysroot = test_sysroot(); debug!("sysroot = %s", sysroot.to_str()); @@ -566,7 +567,8 @@ fn test_package_ids_must_be_relative_path_like() { } -#[test] #[ignore(cfg(target_arch = "x86"))] +// FIXME: #7956: temporarily disabled +#[ignore(cfg(target_arch = "x86"))] fn test_package_version() { let local_path = "mockgithub.com/catamorphism/test_pkg_version"; let repo = init_git_repo(&Path(local_path)); @@ -678,7 +680,7 @@ fn rustpkg_install_url_2() { &temp_dir); } -#[test] +// FIXME: #7956: temporarily disabled fn rustpkg_library_target() { let foo_repo = init_git_repo(&Path("foo")); let package_dir = foo_repo.push("foo");