---

yaml
---
r: 60641
b: refs/heads/auto
c: 18df18c
h: refs/heads/master
i:
  60639: 7fcc9a4
v: v3

Author: pcwalton

[refs]

@@ -14,6 +14,6 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: ee52865c8848657e737e3c2071728b062ec9c8de
+refs/heads/auto: 18df18c817b5e109710c58f512a2cc5ad14fa8b2
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c

branches/auto/src/librustc/metadata/csearch.rs

@@ -54,18 +54,6 @@ pub fn each_lang_item(cstore: @mut cstore::CStore,
 }
 
 /// Iterates over all the paths in the given crate.
-#[cfg(stage0)]
-pub fn each_path(cstore: @mut cstore::CStore,
-                 cnum: ast::crate_num,
-                 f: &fn(&str, decoder::def_like, ast::visibility) -> bool) {
-    let crate_data = cstore::get_crate_data(cstore, cnum);
-    let get_crate_data: decoder::GetCrateDataCb = |cnum| {
-        cstore::get_crate_data(cstore, cnum)
-    };
-    decoder::each_path(cstore.intr, crate_data, get_crate_data, f)
-}
-/// Iterates over all the paths in the given crate.
-#[cfg(not(stage0))]
 pub fn each_path(cstore: @mut cstore::CStore,
                  cnum: ast::crate_num,
                  f: &fn(&str, decoder::def_like, ast::visibility) -> bool)

branches/auto/src/librustc/metadata/decoder.rs

@@ -566,14 +566,6 @@ pub fn _each_path(intr: @ident_interner,
     return broken;
 }
 
-#[cfg(stage0)]
-pub fn each_path(intr: @ident_interner,
-                 cdata: cmd,
-                 get_crate_data: GetCrateDataCb,
-                 f: &fn(&str, def_like, ast::visibility) -> bool) {
-    _each_path(intr, cdata, get_crate_data, f);
-}
-#[cfg(not(stage0))]
 pub fn each_path(intr: @ident_interner,
                  cdata: cmd,
                  get_crate_data: GetCrateDataCb,

branches/auto/src/librustc/middle/borrowck/gather_loans/lifetime.rs

@@ -11,6 +11,8 @@
 //! This module implements the check that the lifetime of a borrow
 //! does not exceed the lifetime of the value being borrowed.
 
+use core::prelude::*;
+
 use middle::borrowck::*;
 use mc = middle::mem_categorization;
 use middle::ty;

branches/auto/src/librustc/middle/borrowck/gather_loans/mod.rs

@@ -16,6 +16,8 @@
 // their associated scopes.  In phase two, checking loans, we will then make
 // sure that all of these loans are honored.
 
+use core::prelude::*;
+
 use middle::borrowck::*;
 use mc = middle::mem_categorization;
 use middle::pat_util;

branches/auto/src/librustc/middle/borrowck/gather_loans/restrictions.rs

@@ -10,6 +10,8 @@
 
 //! Computes the restrictions that result from a borrow.
 
+use core::prelude::*;
+
 use middle::borrowck::*;
 use mc = middle::mem_categorization;
 use middle::ty;

branches/auto/src/librustc/middle/borrowck/mod.rs

@@ -10,6 +10,8 @@
 
 /*! See doc.rs for a thorough explanation of the borrow checker */
 
+use core::prelude::*;
+
 use mc = middle::mem_categorization;
 use middle::ty;
 use middle::typeck;

branches/auto/src/librustc/middle/resolve.rs

@@ -22,6 +22,7 @@ use middle::lint::unused_imports;
 use middle::pat_util::pat_bindings;
 
 use syntax::ast::*;
+use syntax::ast;
 use syntax::ast_util::{def_id_of_def, local_def};
 use syntax::ast_util::{path_to_ident, walk_pat, trait_method_to_ty_method};
 use syntax::ast_util::{Privacy, Public, Private};

branches/auto/src/libcore/rt/comm.rs renamed to branches/auto/src/libstd/rt/comm.rs

@@ -0,0 +1,87 @@
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use sys::{TypeDesc, size_of};
+use libc::{c_void, size_t, uintptr_t};
+use c_malloc = libc::malloc;
+use c_free = libc::free;
+use managed::raw::{BoxHeaderRepr, BoxRepr};
+use cast::transmute;
+use unstable::intrinsics::{atomic_xadd,atomic_xsub};
+use ptr::null;
+use intrinsic::TyDesc;
+
+pub unsafe fn malloc(td: *TypeDesc, size: uint) -> *c_void {
+    assert!(td.is_not_null());
+
+    let total_size = get_box_size(size, (*td).align);
+    let p = c_malloc(total_size as size_t);
+    assert!(p.is_not_null());
+
+    // FIXME #3475: Converting between our two different tydesc types
+    let td: *TyDesc = transmute(td);
+
+    let box: &mut BoxRepr = transmute(p);
+    box.header.ref_count = -1; // Exchange values not ref counted
+    box.header.type_desc = td;
+    box.header.prev = null();
+    box.header.next = null();
+
+    let exchange_count = &mut *exchange_count_ptr();
+    atomic_xadd(exchange_count, 1);
+
+    return transmute(box);
+}
+/**
+Thin wrapper around libc::malloc, none of the box header
+stuff in exchange_alloc::malloc
+*/
+pub unsafe fn malloc_raw(size: uint) -> *c_void {
+    let p = c_malloc(size as size_t);
+    if p.is_null() {
+        fail!("Failure in malloc_raw: result ptr is null");
+    }
+    p
+}
+
+pub unsafe fn free(ptr: *c_void) {
+    let exchange_count = &mut *exchange_count_ptr();
+    atomic_xsub(exchange_count, 1);
+
+    assert!(ptr.is_not_null());
+    c_free(ptr);
+}
+///Thin wrapper around libc::free, as with exchange_alloc::malloc_raw
+pub unsafe fn free_raw(ptr: *c_void) {
+    c_free(ptr);
+}
+
+fn get_box_size(body_size: uint, body_align: uint) -> uint {
+    let header_size = size_of::<BoxHeaderRepr>();
+    // FIXME (#2699): This alignment calculation is suspicious. Is it right?
+    let total_size = align_to(header_size, body_align) + body_size;
+    return total_size;
+}
+
+// Rounds |size| to the nearest |alignment|. Invariant: |alignment| is a power
+// of two.
+fn align_to(size: uint, align: uint) -> uint {
+    assert!(align != 0);
+    (size + align - 1) & !(align - 1)
+}
+
+fn exchange_count_ptr() -> *mut int {
+    // XXX: Need mutable globals
+    unsafe { transmute(&rust_exchange_count) }
+}
+
+extern {
+    static rust_exchange_count: uintptr_t;
+}