---

yaml
---
r: 42995
b: refs/heads/try
c: e91040c
h: refs/heads/master
i:
  42993: ae21d8f
  42991: 1003ff5
v: v3

Author: brson

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 19dfec2aaf746535de1521f68421f9980dbf25de
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 2f46b763da2c098913884f101b6d71d69af41b49
-refs/heads/try: 739e5ba369cfe19da10d7adf1bcfcd14b80f52bb
+refs/heads/try: e91040c704aa9ab46fb1c7a10e293fd5f6bfe079
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: a810c03263670238bccd64cabb12a23a46e3a278

branches/try/mk/tests.mk

@@ -746,9 +746,6 @@ $(3)/test/$$(FT_DRIVER)-$(2).out: \
 	--logfile tmp/$$(FT_DRIVER)-$(2).log
 
 check-fast-T-$(2)-H-$(3):     			\
-	check-stage2-T-$(2)-H-$(3)-rustc	\
-	check-stage2-T-$(2)-H-$(3)-core		\
-	check-stage2-T-$(2)-H-$(3)-std		\
 	$(3)/test/$$(FT_DRIVER)-$(2).out
 
 endef

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

@@ -137,7 +137,7 @@ pub fn log_fn_time(ccx: @crate_ctxt, +name: ~str, start: time::Timespec,
     ccx.stats.fn_times.push({ident: name, time: elapsed});
 }
 
-pub fn decl_fn(llmod: ModuleRef, name: &str, cc: lib::llvm::CallConv,
+pub fn decl_fn(llmod: ModuleRef, name: ~str, cc: lib::llvm::CallConv,
                llty: TypeRef) -> ValueRef {
     let llfn: ValueRef = str::as_c_str(name, |buf| {
         unsafe {
@@ -150,7 +150,7 @@ pub fn decl_fn(llmod: ModuleRef, name: &str, cc: lib::llvm::CallConv,
     return llfn;
 }
 
-pub fn decl_cdecl_fn(llmod: ModuleRef, name: &str, llty: TypeRef)
+pub fn decl_cdecl_fn(llmod: ModuleRef, +name: ~str, llty: TypeRef)
                   -> ValueRef {
     return decl_fn(llmod, name, lib::llvm::CCallConv, llty);
 }
@@ -164,19 +164,20 @@ pub fn decl_internal_cdecl_fn(llmod: ModuleRef, +name: ~str, llty: TypeRef) ->
     return llfn;
 }
 
-pub fn get_extern_fn(externs: ExternMap,
+pub fn get_extern_fn(externs: HashMap<~str, ValueRef>,
                      llmod: ModuleRef,
-                     name: @str,
+                     +name: ~str,
                      cc: lib::llvm::CallConv,
                      ty: TypeRef) -> ValueRef {
     if externs.contains_key_ref(&name) { return externs.get(&name); }
-    let f = decl_fn(llmod, name, cc, ty);
+    // XXX: Bad copy.
+    let f = decl_fn(llmod, copy name, cc, ty);
     externs.insert(name, f);
     return f;
 }
 
-pub fn get_extern_const(externs: ExternMap, llmod: ModuleRef,
-                        name: @str, ty: TypeRef) -> ValueRef {
+pub fn get_extern_const(externs: HashMap<~str, ValueRef>, llmod: ModuleRef,
+                        +name: ~str, ty: TypeRef) -> ValueRef {
     unsafe {
         if externs.contains_key_ref(&name) { return externs.get(&name); }
         let c = str::as_c_str(name, |buf| {
@@ -188,9 +189,9 @@ pub fn get_extern_const(externs: ExternMap, llmod: ModuleRef,
 }
 
     fn get_simple_extern_fn(cx: block,
-                            externs: ExternMap,
+                            externs: HashMap<~str, ValueRef>,
                             llmod: ModuleRef,
-                            name: @str,
+                            +name: ~str,
                             n_args: int) -> ValueRef {
     let _icx = cx.insn_ctxt("get_simple_extern_fn");
     let ccx = cx.fcx.ccx;
@@ -200,8 +201,8 @@ pub fn get_extern_const(externs: ExternMap, llmod: ModuleRef,
     return get_extern_fn(externs, llmod, name, lib::llvm::CCallConv, t);
 }
 
-pub fn trans_foreign_call(cx: block, externs: ExternMap,
-                          llmod: ModuleRef, name: @str, args: ~[ValueRef]) ->
+pub fn trans_foreign_call(cx: block, externs: HashMap<~str, ValueRef>,
+                          llmod: ModuleRef, +name: ~str, args: ~[ValueRef]) ->
    ValueRef {
     let _icx = cx.insn_ctxt("trans_foreign_call");
     let n = args.len() as int;
@@ -473,7 +474,6 @@ pub fn get_res_dtor(ccx: @crate_ctxt, did: ast::def_id,
         let class_ty = ty::subst_tps(tcx, substs, None,
                           ty::lookup_item_type(tcx, parent_id).ty);
         let llty = type_of_dtor(ccx, class_ty);
-        let name = name.to_managed(); // :-(
         get_extern_fn(ccx.externs, ccx.llmod, name, lib::llvm::CCallConv,
                       llty)
     }
@@ -766,7 +766,7 @@ pub fn null_env_ptr(bcx: block) -> ValueRef {
 
 pub fn trans_external_path(ccx: @crate_ctxt, did: ast::def_id, t: ty::t)
     -> ValueRef {
-    let name = csearch::get_symbol(ccx.sess.cstore, did).to_managed(); // Sad
+    let name = csearch::get_symbol(ccx.sess.cstore, did);
     match ty::get(t).sty {
       ty::ty_fn(_) => {
         let llty = type_of_fn_from_ty(ccx, t);

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

@@ -152,15 +152,13 @@ pub fn BuilderRef_res(B: BuilderRef) -> BuilderRef_res {
     }
 }
 
-type ExternMap = HashMap<@str, ValueRef>;
-
 // Crate context.  Every crate we compile has one of these.
 pub struct crate_ctxt {
      sess: session::Session,
      llmod: ModuleRef,
      td: target_data,
      tn: type_names,
-     externs: ExternMap,
+     externs: HashMap<~str, ValueRef>,
      intrinsics: HashMap<~str, ValueRef>,
      item_vals: HashMap<ast::node_id, ValueRef>,
      exp_map2: resolve::ExportMap2,

branches/try/src/rt/rust_sched_loop.h

@@ -135,6 +135,7 @@ struct rust_sched_loop
     void place_task_in_tls(rust_task *task);
 
     static rust_task *get_task_tls();
+    static rust_task *try_get_task_tls();
 
     // Called by each task when they are ready to be destroyed
     void release_task(rust_task *task);
@@ -154,7 +155,7 @@ rust_sched_loop::get_log() {
     return _log;
 }
 
-inline rust_task* rust_sched_loop::get_task_tls()
+inline rust_task* rust_sched_loop::try_get_task_tls()
 {
     if (!tls_initialized)
         return NULL;
@@ -165,6 +166,12 @@ inline rust_task* rust_sched_loop::get_task_tls()
     rust_task *task = reinterpret_cast<rust_task *>
         (pthread_getspecific(task_key));
 #endif
+    return task;
+}
+
+inline rust_task* rust_sched_loop::get_task_tls()
+{
+    rust_task *task = try_get_task_tls();
     assert(task && "Couldn't get the task from TLS!");
     return task;
 }

branches/try/src/rt/rust_task.h

@@ -619,14 +619,14 @@ rust_task::record_stack_limit() {
     record_sp_limit(stk->data + LIMIT_OFFSET + RED_ZONE_SIZE);
 }
 
-inline rust_task* rust_get_current_task() {
+inline rust_task* rust_try_get_current_task() {
     uintptr_t sp_limit = get_sp_limit();
 
     // FIXME (#1226) - Because of a hack in upcall_call_shim_on_c_stack this
     // value is sometimes inconveniently set to 0, so we can't use this
     // method of retreiving the task pointer and need to fall back to TLS.
     if (sp_limit == 0)
-        return rust_sched_loop::get_task_tls();
+        return rust_sched_loop::try_get_task_tls();
 
     // The stack pointer boundary is stored in a quickly-accessible location
     // in the TCB. From that we can calculate the address of the stack segment
@@ -642,6 +642,12 @@ inline rust_task* rust_get_current_task() {
     return stk->task;
 }
 
+inline rust_task* rust_get_current_task() {
+    rust_task* task = rust_try_get_current_task();
+    assert(task != NULL && "no current task");
+    return task;
+}
+
 //
 // Local Variables:
 // mode: C++

branches/try/src/rt/rust_upcall.cpp

@@ -45,6 +45,8 @@ call_upcall_on_c_stack(rust_task *task, void *args, void *fn_ptr) {
     task->call_on_c_stack(args, fn_ptr);
 }
 
+typedef void (*CDECL stack_switch_shim)(void*);
+
 /**********************************************************************
  * Switches to the C-stack and invokes |fn_ptr|, passing |args| as argument.
  * This is used by the C compiler to call foreign functions and by other
@@ -54,13 +56,20 @@ call_upcall_on_c_stack(rust_task *task, void *args, void *fn_ptr) {
  */
 extern "C" CDECL void
 upcall_call_shim_on_c_stack(void *args, void *fn_ptr) {
-    rust_task *task = rust_get_current_task();
-
-    try {
-        task->call_on_c_stack(args, fn_ptr);
-    } catch (...) {
-        // Logging here is not reliable
-        assert(false && "Foreign code threw an exception");
+    rust_task *task = rust_try_get_current_task();
+
+    if (task) {
+        // We're running in task context, do a stack switch
+        try {
+            task->call_on_c_stack(args, fn_ptr);
+        } catch (...) {
+            // Logging here is not reliable
+            assert(false && "Foreign code threw an exception");
+        }
+    } else {
+        // There's no task. Call the function and hope for the best
+        stack_switch_shim f = (stack_switch_shim)fn_ptr;
+        f(args);
     }
 }
 
@@ -70,15 +79,22 @@ upcall_call_shim_on_c_stack(void *args, void *fn_ptr) {
  */
 extern "C" CDECL void
 upcall_call_shim_on_rust_stack(void *args, void *fn_ptr) {
-    rust_task *task = rust_get_current_task();
-
-    try {
-        task->call_on_rust_stack(args, fn_ptr);
-    } catch (...) {
-        // We can't count on being able to unwind through arbitrary
-        // code. Our best option is to just fail hard.
-        // Logging here is not reliable
-        assert(false && "Rust task failed after reentering the Rust stack");
+    rust_task *task = rust_try_get_current_task();
+
+    if (task) {
+        try {
+            task->call_on_rust_stack(args, fn_ptr);
+        } catch (...) {
+            // We can't count on being able to unwind through arbitrary
+            // code. Our best option is to just fail hard.
+            // Logging here is not reliable
+            assert(false
+                   && "Rust task failed after reentering the Rust stack");
+        }
+    } else {
+        // There's no task. Call the function and hope for the best
+        stack_switch_shim f = (stack_switch_shim)fn_ptr;
+        f(args);
     }
 }
 

branches/try/src/test/run-pass/foreign-call-no-runtime.rs

@@ -0,0 +1,24 @@
+use core::private::run_in_bare_thread;
+
+extern {
+    pub fn rust_dbg_call(cb: *u8,
+                         data: libc::uintptr_t) -> libc::uintptr_t;
+}
+
+pub fn main() {
+    unsafe {
+        do run_in_bare_thread() {
+            unsafe {
+                let i = &100;
+                rust_dbg_call(callback, cast::transmute(i));
+            }
+        }
+    }
+}
+
+extern fn callback(data: libc::uintptr_t) {
+    unsafe {
+        let data: *int = cast::transmute(data);
+        assert *data == 100;
+    }
+}