---

yaml
---
r: 138455
b: refs/heads/try2
c: 4a85389
h: refs/heads/master
i:
  138453: 6aeb685
  138451: 66b5b76
  138447: 779a5aa
v: v3

Author: bstrie

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 2f12e26d06ac106c54b293f0125d2c9319ac4191
+refs/heads/try2: 4a853894fab6b9a4b60c1b3260b446a3473577fa
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/libcore/cleanup.rs

@@ -111,102 +111,45 @@ struct Task {
  * This runs at task death to free all boxes.
  */
 
-struct AnnihilateStats {
-    n_total_boxes: uint,
-    n_unique_boxes: uint,
-    n_bytes_freed: uint
-}
-
-unsafe fn each_live_alloc(f: fn(box: *mut BoxRepr, uniq: bool) -> bool) {
-    use managed;
-
-    let task: *Task = transmute(rustrt::rust_get_task());
-    let box = (*task).boxed_region.live_allocs;
-    let mut box: *mut BoxRepr = transmute(copy box);
-    while box != mut_null() {
-        let next = transmute(copy (*box).header.next);
-        let uniq =
-            (*box).header.ref_count == managed::raw::RC_MANAGED_UNIQUE;
-
-        if ! f(box, uniq) {
-            break
-        }
-
-        box = next
-    }
-}
-
-#[cfg(unix)]
-fn debug_mem() -> bool {
-    use os;
-    use libc;
-    do os::as_c_charp("RUST_DEBUG_MEM") |p| {
-        unsafe { libc::getenv(p) != null() }
-    }
-}
-
-#[cfg(windows)]
-fn debug_mem() -> bool {
-    false
-}
-
 /// Destroys all managed memory (i.e. @ boxes) held by the current task.
 #[cfg(notest)]
 #[lang="annihilate"]
 pub unsafe fn annihilate() {
     use rt::rt_free;
     use io::WriterUtil;
-    use io;
-    use libc;
-    use sys;
-    use managed;
 
-    let mut stats = AnnihilateStats {
-        n_total_boxes: 0,
-        n_unique_boxes: 0,
-        n_bytes_freed: 0
-    };
+    let task: *Task = transmute(rustrt::rust_get_task());
 
     // Pass 1: Make all boxes immortal.
-    for each_live_alloc |box, uniq| {
-        stats.n_total_boxes += 1;
-        if uniq {
-            stats.n_unique_boxes += 1;
-        } else {
-            (*box).header.ref_count = managed::raw::RC_IMMORTAL;
-        }
+    let box = (*task).boxed_region.live_allocs;
+    let mut box: *mut BoxRepr = transmute(copy box);
+    while box != mut_null() {
+        debug!("making box immortal: %x", box as uint);
+        (*box).header.ref_count = 0x77777777;
+        box = transmute(copy (*box).header.next);
     }
 
     // Pass 2: Drop all boxes.
-    for each_live_alloc |box, uniq| {
-        if !uniq {
-            let tydesc: *TypeDesc = transmute(copy (*box).header.type_desc);
-            let drop_glue: DropGlue = transmute(((*tydesc).drop_glue, 0));
-            drop_glue(to_unsafe_ptr(&tydesc), transmute(&(*box).data));
-        }
-    }
+    let box = (*task).boxed_region.live_allocs;
+    let mut box: *mut BoxRepr = transmute(copy box);
+    while box != mut_null() {
+        debug!("calling drop glue for box: %x", box as uint);
+        let tydesc: *TypeDesc = transmute(copy (*box).header.type_desc);
+        let drop_glue: DropGlue = transmute(((*tydesc).drop_glue, 0));
+        drop_glue(to_unsafe_ptr(&tydesc), transmute(&(*box).data));
 
-    // Pass 3: Free all boxes.
-    for each_live_alloc |box, uniq| {
-        if !uniq {
-            stats.n_bytes_freed +=
-                (*((*box).header.type_desc)).size
-                + sys::size_of::<BoxRepr>();
-            rt_free(transmute(box));
-        }
+        box = transmute(copy (*box).header.next);
     }
 
-    if debug_mem() {
-        // We do logging here w/o allocation.
-        let dbg = libc::STDERR_FILENO as io::fd_t;
-        dbg.write_str("annihilator stats:");
-        dbg.write_str("\n  total_boxes: ");
-        dbg.write_uint(stats.n_total_boxes);
-        dbg.write_str("\n  unique_boxes: ");
-        dbg.write_uint(stats.n_unique_boxes);
-        dbg.write_str("\n  bytes_freed: ");
-        dbg.write_uint(stats.n_bytes_freed);
-        dbg.write_str("\n");
+    // Pass 3: Free all boxes.
+    loop {
+        let box = (*task).boxed_region.live_allocs;
+        if box == null() { break; }
+        let mut box: *mut BoxRepr = transmute(copy box);
+        assert (*box).header.prev == null();
+
+        debug!("freeing box: %x", box as uint);
+        rt_free(transmute(box));
     }
 }
 

branches/try2/src/libcore/managed.rs

@@ -16,13 +16,7 @@ use managed::raw::BoxRepr;
 use prelude::*;
 use ptr;
 
-
 pub mod raw {
-
-    pub const RC_EXCHANGE_UNIQUE : uint = (-1) as uint;
-    pub const RC_MANAGED_UNIQUE : uint = (-2) as uint;
-    pub const RC_IMMORTAL : uint = 0x77777777;
-
     use intrinsic::TyDesc;
 
     pub struct BoxHeaderRepr {

branches/try2/src/libcore/vec.rs

@@ -1,4 +1,4 @@
-// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
+// 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.
 //
@@ -31,14 +31,9 @@ use vec;
 
 #[abi = "cdecl"]
 pub extern mod rustrt {
-    // These names are terrible. reserve_shared applies
-    // to ~[] and reserve_shared_actual applies to @[].
     unsafe fn vec_reserve_shared(++t: *sys::TypeDesc,
                                  ++v: **raw::VecRepr,
                                  ++n: libc::size_t);
-    unsafe fn vec_reserve_shared_actual(++t: *sys::TypeDesc,
-                                        ++v: **raw::VecRepr,
-                                        ++n: libc::size_t);
 }
 
 /// Returns true if a vector contains no elements
@@ -64,17 +59,11 @@ pub pure fn same_length<T, U>(xs: &[const T], ys: &[const U]) -> bool {
  */
 pub fn reserve<T>(v: &mut ~[T], n: uint) {
     // Only make the (slow) call into the runtime if we have to
-    use managed;
     if capacity(v) < n {
         unsafe {
             let ptr: **raw::VecRepr = cast::transmute(v);
-            let td = sys::get_type_desc::<T>();
-            if ((**ptr).box_header.ref_count ==
-                managed::raw::RC_MANAGED_UNIQUE) {
-                rustrt::vec_reserve_shared_actual(td, ptr, n as size_t);
-            } else {
-                rustrt::vec_reserve_shared(td, ptr, n as size_t);
-            }
+            rustrt::vec_reserve_shared(sys::get_type_desc::<T>(),
+                                       ptr, n as size_t);
         }
     }
 }

branches/try2/src/librustc/driver/session.rs

@@ -165,49 +165,49 @@ pub struct Session_ {
 pub type Session = @Session_;
 
 pub impl Session {
-    fn span_fatal(sp: span, msg: ~str) -> ! {
+    fn span_fatal(&self, sp: span, msg: ~str) -> ! {
         self.span_diagnostic.span_fatal(sp, msg)
     }
-    fn fatal(msg: ~str) -> ! {
+    fn fatal(&self, msg: ~str) -> ! {
         self.span_diagnostic.handler().fatal(msg)
     }
-    fn span_err(sp: span, msg: ~str) {
+    fn span_err(&self, sp: span, msg: ~str) {
         self.span_diagnostic.span_err(sp, msg)
     }
-    fn err(msg: ~str) {
+    fn err(&self, msg: ~str) {
         self.span_diagnostic.handler().err(msg)
     }
-    fn has_errors() -> bool {
+    fn has_errors(&self) -> bool {
         self.span_diagnostic.handler().has_errors()
     }
-    fn abort_if_errors() {
+    fn abort_if_errors(&self) {
         self.span_diagnostic.handler().abort_if_errors()
     }
-    fn span_warn(sp: span, msg: ~str) {
+    fn span_warn(&self, sp: span, msg: ~str) {
         self.span_diagnostic.span_warn(sp, msg)
     }
-    fn warn(msg: ~str) {
+    fn warn(&self, msg: ~str) {
         self.span_diagnostic.handler().warn(msg)
     }
-    fn span_note(sp: span, msg: ~str) {
+    fn span_note(&self, sp: span, msg: ~str) {
         self.span_diagnostic.span_note(sp, msg)
     }
-    fn note(msg: ~str) {
+    fn note(&self, msg: ~str) {
         self.span_diagnostic.handler().note(msg)
     }
-    fn span_bug(sp: span, msg: ~str) -> ! {
+    fn span_bug(&self, sp: span, msg: ~str) -> ! {
         self.span_diagnostic.span_bug(sp, msg)
     }
-    fn bug(msg: ~str) -> ! {
+    fn bug(&self, msg: ~str) -> ! {
         self.span_diagnostic.handler().bug(msg)
     }
-    fn span_unimpl(sp: span, msg: ~str) -> ! {
+    fn span_unimpl(&self, sp: span, msg: ~str) -> ! {
         self.span_diagnostic.span_unimpl(sp, msg)
     }
-    fn unimpl(msg: ~str) -> ! {
+    fn unimpl(&self, msg: ~str) -> ! {
         self.span_diagnostic.handler().unimpl(msg)
     }
-    fn span_lint_level(level: lint::level, sp: span, +msg: ~str) {
+    fn span_lint_level(&self, level: lint::level, sp: span, +msg: ~str) {
         match level {
           lint::allow => { },
           lint::warn => self.span_warn(sp, msg),
@@ -216,7 +216,7 @@ pub impl Session {
           }
         }
     }
-    fn span_lint(lint_mode: lint::lint,
+    fn span_lint(&self, lint_mode: lint::lint,
                  expr_id: ast::node_id,
                  item_id: ast::node_id,
                  span: span,
@@ -225,45 +225,55 @@ pub impl Session {
             self.lint_settings, lint_mode, expr_id, item_id);
         self.span_lint_level(level, span, msg);
     }
-    fn next_node_id() -> ast::node_id {
+    fn next_node_id(&self) -> ast::node_id {
         return syntax::parse::next_node_id(self.parse_sess);
     }
-    fn diagnostic() -> diagnostic::span_handler {
+    fn diagnostic(&self) -> diagnostic::span_handler {
         self.span_diagnostic
     }
-    fn debugging_opt(opt: uint) -> bool {
+    fn debugging_opt(&self, opt: uint) -> bool {
         (self.opts.debugging_opts & opt) != 0u
     }
     // This exists to help with refactoring to eliminate impossible
     // cases later on
-    fn impossible_case(sp: span, msg: &str) -> ! {
+    fn impossible_case(&self, sp: span, msg: &str) -> ! {
         self.span_bug(sp, fmt!("Impossible case reached: %s", msg));
     }
-    fn verbose() -> bool { self.debugging_opt(verbose) }
-    fn time_passes() -> bool { self.debugging_opt(time_passes) }
-    fn count_llvm_insns() -> bool { self.debugging_opt(count_llvm_insns) }
-    fn count_type_sizes() -> bool { self.debugging_opt(count_type_sizes) }
-    fn time_llvm_passes() -> bool { self.debugging_opt(time_llvm_passes) }
-    fn trans_stats() -> bool { self.debugging_opt(trans_stats) }
-    fn meta_stats() -> bool { self.debugging_opt(meta_stats) }
-    fn no_asm_comments() -> bool { self.debugging_opt(no_asm_comments) }
-    fn no_verify() -> bool { self.debugging_opt(no_verify) }
-    fn trace() -> bool { self.debugging_opt(trace) }
-    fn coherence() -> bool { self.debugging_opt(coherence) }
-    fn borrowck_stats() -> bool { self.debugging_opt(borrowck_stats) }
-    fn borrowck_note_pure() -> bool { self.debugging_opt(borrowck_note_pure) }
-    fn borrowck_note_loan() -> bool { self.debugging_opt(borrowck_note_loan) }
-    fn no_monomorphic_collapse() -> bool {
+    fn verbose(&self) -> bool { self.debugging_opt(verbose) }
+    fn time_passes(&self) -> bool { self.debugging_opt(time_passes) }
+    fn count_llvm_insns(&self) -> bool {
+        self.debugging_opt(count_llvm_insns)
+    }
+    fn count_type_sizes(&self) -> bool {
+        self.debugging_opt(count_type_sizes)
+    }
+    fn time_llvm_passes(&self) -> bool {
+        self.debugging_opt(time_llvm_passes)
+    }
+    fn trans_stats(&self) -> bool { self.debugging_opt(trans_stats) }
+    fn meta_stats(&self) -> bool { self.debugging_opt(meta_stats) }
+    fn no_asm_comments(&self) -> bool { self.debugging_opt(no_asm_comments) }
+    fn no_verify(&self) -> bool { self.debugging_opt(no_verify) }
+    fn trace(&self) -> bool { self.debugging_opt(trace) }
+    fn coherence(&self) -> bool { self.debugging_opt(coherence) }
+    fn borrowck_stats(&self) -> bool { self.debugging_opt(borrowck_stats) }
+    fn borrowck_note_pure(&self) -> bool {
+        self.debugging_opt(borrowck_note_pure)
+    }
+    fn borrowck_note_loan(&self) -> bool {
+        self.debugging_opt(borrowck_note_loan)
+    }
+    fn no_monomorphic_collapse(&self) -> bool {
         self.debugging_opt(no_monomorphic_collapse)
     }
 
-    fn str_of(id: ast::ident) -> @~str {
+    fn str_of(&self, id: ast::ident) -> @~str {
         self.parse_sess.interner.get(id)
     }
-    fn ident_of(+st: ~str) -> ast::ident {
+    fn ident_of(&self, +st: ~str) -> ast::ident {
         self.parse_sess.interner.intern(@st)
     }
-    fn intr() -> @syntax::parse::token::ident_interner {
+    fn intr(&self) -> @syntax::parse::token::ident_interner {
         self.parse_sess.interner
     }
 }

branches/try2/src/librustc/metadata/filesearch.rs

@@ -29,10 +29,10 @@ pub fn pick_file(file: Path, path: &Path) -> Option<Path> {
 }
 
 pub trait FileSearch {
-    fn sysroot() -> Path;
-    fn lib_search_paths() -> ~[Path];
-    fn get_target_lib_path() -> Path;
-    fn get_target_lib_file_path(file: &Path) -> Path;
+    fn sysroot(&self) -> Path;
+    fn lib_search_paths(&self) -> ~[Path];
+    fn get_target_lib_path(&self) -> Path;
+    fn get_target_lib_file_path(&self, file: &Path) -> Path;
 }
 
 pub fn mk_filesearch(maybe_sysroot: Option<Path>,
@@ -44,8 +44,8 @@ pub fn mk_filesearch(maybe_sysroot: Option<Path>,
         target_triple: ~str
     }
     impl FileSearch for FileSearchImpl {
-        fn sysroot() -> Path { /*bad*/copy self.sysroot }
-        fn lib_search_paths() -> ~[Path] {
+        fn sysroot(&self) -> Path { /*bad*/copy self.sysroot }
+        fn lib_search_paths(&self) -> ~[Path] {
             let mut paths = /*bad*/copy self.addl_lib_search_paths;
 
             paths.push(
@@ -61,10 +61,10 @@ pub fn mk_filesearch(maybe_sysroot: Option<Path>,
             }
             paths
         }
-        fn get_target_lib_path() -> Path {
+        fn get_target_lib_path(&self) -> Path {
             make_target_lib_path(&self.sysroot, self.target_triple)
         }
-        fn get_target_lib_file_path(file: &Path) -> Path {
+        fn get_target_lib_file_path(&self, file: &Path) -> Path {
             self.get_target_lib_path().push_rel(file)
         }
     }