---

yaml
---
r: 46599
b: refs/heads/auto
c: 4a04a18
h: refs/heads/master
i:
  46597: 6477747
  46595: 9e9bb14
  46591: 98b4d64
v: v3

Author: brson

[refs]

@@ -14,4 +14,4 @@ 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: 2f858de1c39f3fd8bdc77a6517e12a6458c54f03
+refs/heads/auto: 4a04a188e3cf86cdef0e499dc65810009de27808

branches/auto/src/libcore/cleanup.rs

@@ -154,7 +154,7 @@ fn debug_mem() -> bool {
 #[cfg(notest)]
 #[lang="annihilate"]
 pub unsafe fn annihilate() {
-    use rt::local_free;
+    use rt::rt_free;
     use io::WriterUtil;
     use io;
     use libc;
@@ -192,7 +192,7 @@ pub unsafe fn annihilate() {
             stats.n_bytes_freed +=
                 (*((*box).header.type_desc)).size
                 + sys::size_of::<BoxRepr>();
-            local_free(transmute(box));
+            rt_free(transmute(box));
         }
     }
 

branches/auto/src/libcore/comm.rs

@@ -20,8 +20,8 @@ use vec;
 
 use pipes::{recv, try_recv, wait_many, peek, PacketHeader};
 
-// NOTE Making this public exposes some plumbing from pipes. Needs
-// some refactoring
+// FIXME #5160: Making this public exposes some plumbing from
+// pipes. Needs some refactoring
 pub use pipes::Selectable;
 
 /// A trait for things that can send multiple messages.

branches/auto/src/libcore/rt.rs

@@ -36,54 +36,60 @@ pub extern mod rustrt {
     unsafe fn rust_upcall_free(ptr: *c_char);
 }
 
+#[rt(fail_)]
 #[lang="fail_"]
-pub fn fail_(expr: *c_char, file: *c_char, line: size_t) -> ! {
+pub fn rt_fail_(expr: *c_char, file: *c_char, line: size_t) -> ! {
     sys::begin_unwind_(expr, file, line);
 }
 
+#[rt(fail_bounds_check)]
 #[lang="fail_bounds_check"]
-pub unsafe fn fail_bounds_check(file: *c_char, line: size_t,
-                                index: size_t, len: size_t) {
+pub unsafe fn rt_fail_bounds_check(file: *c_char, line: size_t,
+                                   index: size_t, len: size_t) {
     let msg = fmt!("index out of bounds: the len is %d but the index is %d",
                     len as int, index as int);
     do str::as_buf(msg) |p, _len| {
-        fail_(p as *c_char, file, line);
+        rt_fail_(p as *c_char, file, line);
     }
 }
 
-pub unsafe fn fail_borrowed() {
+pub unsafe fn rt_fail_borrowed() {
     let msg = "borrowed";
     do str::as_buf(msg) |msg_p, _| {
         do str::as_buf("???") |file_p, _| {
-            fail_(msg_p as *c_char, file_p as *c_char, 0);
+            rt_fail_(msg_p as *c_char, file_p as *c_char, 0);
         }
     }
 }
 
 // FIXME #4942: Make these signatures agree with exchange_alloc's signatures
+#[rt(exchange_malloc)]
 #[lang="exchange_malloc"]
-pub unsafe fn exchange_malloc(td: *c_char, size: uintptr_t) -> *c_char {
+pub unsafe fn rt_exchange_malloc(td: *c_char, size: uintptr_t) -> *c_char {
     transmute(exchange_alloc::malloc(transmute(td), transmute(size)))
 }
 
 // NB: Calls to free CANNOT be allowed to fail, as throwing an exception from
 // inside a landing pad may corrupt the state of the exception handler. If a
 // problem occurs, call exit instead.
+#[rt(exchange_free)]
 #[lang="exchange_free"]
-pub unsafe fn exchange_free(ptr: *c_char) {
+pub unsafe fn rt_exchange_free(ptr: *c_char) {
     exchange_alloc::free(transmute(ptr))
 }
 
+#[rt(malloc)]
 #[lang="malloc"]
-pub unsafe fn local_malloc(td: *c_char, size: uintptr_t) -> *c_char {
+pub unsafe fn rt_malloc(td: *c_char, size: uintptr_t) -> *c_char {
     return rustrt::rust_upcall_malloc(td, size);
 }
 
 // NB: Calls to free CANNOT be allowed to fail, as throwing an exception from
 // inside a landing pad may corrupt the state of the exception handler. If a
 // problem occurs, call exit instead.
+#[rt(free)]
 #[lang="free"]
-pub unsafe fn local_free(ptr: *c_char) {
+pub unsafe fn rt_free(ptr: *c_char) {
     rustrt::rust_upcall_free(ptr);
 }
 
@@ -106,7 +112,7 @@ pub unsafe fn return_to_mut(a: *u8) {
 pub unsafe fn check_not_borrowed(a: *u8) {
     let a: *mut BoxRepr = transmute(a);
     if ((*a).header.ref_count & FROZEN_BIT) != 0 {
-        fail_borrowed();
+        rt_fail_borrowed();
     }
 }
 

branches/auto/src/librustc/middle/trans/_match.rs

@@ -1054,7 +1054,7 @@ pub fn compare_values(cx: block,
             let scratch_rhs = alloca(cx, val_ty(rhs));
             Store(cx, rhs, scratch_rhs);
             let did = cx.tcx().lang_items.uniq_str_eq_fn();
-            let bcx = callee::trans_lang_call(cx, did,
+            let bcx = callee::trans_rtcall_or_lang_call(cx, did,
                                                         ~[scratch_lhs,
                                                           scratch_rhs],
                                                         expr::SaveIn(
@@ -1069,7 +1069,7 @@ pub fn compare_values(cx: block,
             let scratch_result = scratch_datum(cx, ty::mk_bool(cx.tcx()),
                                                false);
             let did = cx.tcx().lang_items.str_eq_fn();
-            let bcx = callee::trans_lang_call(cx, did,
+            let bcx = callee::trans_rtcall_or_lang_call(cx, did,
                                                         ~[lhs, rhs],
                                                         expr::SaveIn(
                                                          scratch_result.val));

branches/auto/src/librustc/middle/trans/base.rs

@@ -304,7 +304,7 @@ pub fn malloc_raw_dyn(bcx: block,
     // Allocate space:
     let tydesc = PointerCast(bcx, static_ti.tydesc, T_ptr(T_i8()));
     let rval = alloca(bcx, T_ptr(T_i8()));
-    let bcx = callee::trans_lang_call(
+    let bcx = callee::trans_rtcall_or_lang_call(
         bcx,
         langcall,
         ~[tydesc, size],

branches/auto/src/librustc/middle/trans/callee.rs

@@ -332,11 +332,11 @@ pub fn trans_method_call(in_cx: block,
         DontAutorefArg)
 }
 
-pub fn trans_lang_call(bcx: block,
-                       did: ast::def_id,
-                       args: &[ValueRef],
-                       dest: expr::Dest)
-    -> block {
+pub fn trans_rtcall_or_lang_call(bcx: block,
+                                 did: ast::def_id,
+                                 args: &[ValueRef],
+                                 dest: expr::Dest)
+                              -> block {
     let fty = if did.crate == ast::local_crate {
         ty::node_id_to_type(bcx.ccx().tcx, did.node)
     } else {
@@ -349,12 +349,12 @@ pub fn trans_lang_call(bcx: block,
         ArgVals(args), dest, DontAutorefArg);
 }
 
-pub fn trans_lang_call_with_type_params(bcx: block,
-                                        did: ast::def_id,
-                                        args: &[ValueRef],
-                                        type_params: ~[ty::t],
-                                        dest: expr::Dest)
-    -> block {
+pub fn trans_rtcall_or_lang_call_with_type_params(bcx: block,
+                                                  did: ast::def_id,
+                                                  args: &[ValueRef],
+                                                  type_params: ~[ty::t],
+                                                  dest: expr::Dest)
+                                               -> block {
     let fty;
     if did.crate == ast::local_crate {
         fty = ty::node_id_to_type(bcx.tcx(), did.node);

branches/auto/src/librustc/middle/trans/closure.rs

@@ -500,7 +500,7 @@ pub fn make_opaque_cbox_take_glue(
         // Allocate memory, update original ptr, and copy existing data
         let opaque_tydesc = PointerCast(bcx, tydesc, T_ptr(T_i8()));
         let rval = alloca(bcx, T_ptr(T_i8()));
-        let bcx = callee::trans_lang_call(
+        let bcx = callee::trans_rtcall_or_lang_call(
             bcx,
             bcx.tcx().lang_items.exchange_malloc_fn(),
             ~[opaque_tydesc, sz],

branches/auto/src/librustc/middle/trans/common.rs

@@ -442,7 +442,7 @@ pub fn add_clean_frozen_root(bcx: block, val: ValueRef, t: ty::t) {
     do in_scope_cx(bcx) |scope_info| {
         scope_info.cleanups.push(
             clean_temp(val, |bcx| {
-                let bcx = callee::trans_lang_call(
+                let bcx = callee::trans_rtcall_or_lang_call(
                     bcx,
                     bcx.tcx().lang_items.return_to_mut_fn(),
                     ~[

branches/auto/src/librustc/middle/trans/controlflow.rs

@@ -216,7 +216,7 @@ pub fn trans_log(log_ex: @ast::expr,
             // Call the polymorphic log function
             let val = val_datum.to_ref_llval(bcx);
             let did = bcx.tcx().lang_items.log_type_fn();
-            let bcx = callee::trans_lang_call_with_type_params(
+            let bcx = callee::trans_rtcall_or_lang_call_with_type_params(
                 bcx, did, ~[level, val], ~[val_datum.ty], expr::Ignore);
             bcx
         }
@@ -384,7 +384,7 @@ fn trans_fail_value(bcx: block,
     let V_str = PointerCast(bcx, V_fail_str, T_ptr(T_i8()));
     let V_filename = PointerCast(bcx, V_filename, T_ptr(T_i8()));
     let args = ~[V_str, V_filename, C_int(ccx, V_line)];
-    let bcx = callee::trans_lang_call(
+    let bcx = callee::trans_rtcall_or_lang_call(
         bcx, bcx.tcx().lang_items.fail_fn(), args, expr::Ignore);
     Unreachable(bcx);
     return bcx;
@@ -401,7 +401,7 @@ pub fn trans_fail_bounds_check(bcx: block, sp: span,
     let filename = PointerCast(bcx, filename_cstr, T_ptr(T_i8()));
 
     let args = ~[filename, line, index, len];
-    let bcx = callee::trans_lang_call(
+    let bcx = callee::trans_rtcall_or_lang_call(
         bcx, bcx.tcx().lang_items.fail_bounds_check_fn(), args, expr::Ignore);
     Unreachable(bcx);
     return bcx;

branches/auto/src/librustc/middle/trans/datum.rs

@@ -544,7 +544,7 @@ pub impl Datum {
 
         // If we need to freeze the box, do that now.
         if root_info.freezes {
-            callee::trans_lang_call(
+            callee::trans_rtcall_or_lang_call(
                 bcx,
                 bcx.tcx().lang_items.borrow_as_imm_fn(),
                 ~[
@@ -566,7 +566,7 @@ pub impl Datum {
             ByRef => Load(bcx, self.val),
         };
 
-        callee::trans_lang_call(
+        callee::trans_rtcall_or_lang_call(
             bcx,
             bcx.tcx().lang_items.check_not_borrowed_fn(),
             ~[ PointerCast(bcx, llval, T_ptr(T_i8())) ],

branches/auto/src/librustc/middle/trans/glue.rs

@@ -30,7 +30,7 @@ use core::str;
 
 pub fn trans_free(cx: block, v: ValueRef) -> block {
     let _icx = cx.insn_ctxt("trans_free");
-    callee::trans_lang_call(
+    callee::trans_rtcall_or_lang_call(
         cx,
         cx.tcx().lang_items.free_fn(),
         ~[PointerCast(cx, v, T_ptr(T_i8()))],
@@ -39,7 +39,7 @@ pub fn trans_free(cx: block, v: ValueRef) -> block {
 
 pub fn trans_exchange_free(cx: block, v: ValueRef) -> block {
     let _icx = cx.insn_ctxt("trans_exchange_free");
-    callee::trans_lang_call(
+    callee::trans_rtcall_or_lang_call(
         cx,
         cx.tcx().lang_items.exchange_free_fn(),
         ~[PointerCast(cx, v, T_ptr(T_i8()))],

branches/auto/src/librustc/middle/trans/tvec.rs

@@ -306,7 +306,7 @@ pub fn trans_uniq_or_managed_vstore(bcx: block,
                     let llsizeval = C_uint(bcx.ccx(), s.len());
                     let typ = ty::mk_estr(bcx.tcx(), ty::vstore_uniq);
                     let lldestval = datum::scratch_datum(bcx, typ, false);
-                    let bcx = callee::trans_lang_call(
+                    let bcx = callee::trans_rtcall_or_lang_call(
                         bcx,
                         bcx.tcx().lang_items.strdup_uniq_fn(),
                         ~[ llptrval, llsizeval ],

branches/auto/src/rt/rust_builtin.cpp

@@ -124,8 +124,7 @@ vec_reserve_shared_actual(type_desc* ty, rust_vec_box** vp,
 extern "C" CDECL void
 vec_reserve_shared(type_desc* ty, rust_vec_box** vp,
                    size_t n_elts) {
-    rust_task *task = rust_get_current_task();
-    reserve_vec_exact(task, vp, n_elts * ty->size);
+    reserve_vec_exact(vp, n_elts * ty->size);
 }
 
 extern "C" CDECL size_t
@@ -445,9 +444,8 @@ void tm_to_rust_tm(tm* in_tm, rust_tm* out_tm, int32_t gmtoff,
     out_tm->tm_nsec = nsec;
 
     if (zone != NULL) {
-        rust_task *task = rust_get_current_task();
         size_t size = strlen(zone);
-        reserve_vec_exact(task, &out_tm->tm_zone, size + 1);
+        reserve_vec_exact(&out_tm->tm_zone, size + 1);
         memcpy(out_tm->tm_zone->body.data, zone, size);
         out_tm->tm_zone->body.fill = size + 1;
         out_tm->tm_zone->body.data[size] = '\0';

branches/auto/src/rt/rust_upcall.cpp

@@ -118,7 +118,12 @@ extern "C" CDECL void
 upcall_fail(char const *expr,
             char const *file,
             size_t line) {
-    rust_task *task = rust_get_current_task();
+    rust_task *task = rust_try_get_current_task();
+    if (task == NULL) {
+        // FIXME #5161: Need to think about what to do here
+        printf("failure outside of a task");
+        abort();
+    }
     s_fail_args args = {task,expr,file,line};
     UPCALL_SWITCH_STACK(task, &args, upcall_s_fail);
 }

branches/auto/src/rt/rust_util.h

@@ -67,11 +67,12 @@ inline void reserve_vec_exact_shared(rust_task* task, rust_vec_box** vpp,
     }
 }
 
-inline void reserve_vec_exact(rust_task* task, rust_vec_box** vpp,
+inline void reserve_vec_exact(rust_vec_box** vpp,
                               size_t size) {
     if (size > (*vpp)->body.alloc) {
-        *vpp = (rust_vec_box*)task->kernel
-            ->realloc(*vpp, size + sizeof(rust_vec_box));
+        rust_exchange_alloc exchange_alloc;
+        *vpp = (rust_vec_box*)exchange_alloc
+            .realloc(*vpp, size + sizeof(rust_vec_box));
         (*vpp)->body.alloc = size;
     }
 }