---

yaml
---
r: 42997
b: refs/heads/try
c: b34f871
h: refs/heads/master
i:
  42995: e54d43b
v: v3

Author: pcwalton

[refs]

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

branches/try/mk/rt.mk

@@ -63,7 +63,6 @@ RUNTIME_CXXS_$(1) := \
               rt/rust_log.cpp \
               rt/rust_gc_metadata.cpp \
               rt/rust_util.cpp \
-              rt/rust_exchange_alloc.cpp \
               rt/isaac/randport.cpp \
               rt/miniz.cpp \
               rt/rust_kernel.cpp \

branches/try/mk/tests.mk

@@ -746,6 +746,9 @@ $(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/libcore/private.rs

@@ -35,8 +35,6 @@ pub mod global;
 pub mod finally;
 #[path = "private/weak_task.rs"]
 pub mod weak_task;
-#[path = "private/exchange_alloc.rs"]
-pub mod exchange_alloc;
 
 extern mod rustrt {
     pub unsafe fn rust_create_little_lock() -> rust_little_lock;
@@ -93,17 +91,6 @@ fn test_run_in_bare_thread() {
     }
 }
 
-#[test]
-fn test_run_in_bare_thread_exchange() {
-    unsafe {
-        // Does the exchange heap work without the runtime?
-        let i = ~100;
-        do run_in_bare_thread {
-            assert i == ~100;
-        }
-    }
-}
-
 fn compare_and_swap(address: &mut int, oldval: int, newval: int) -> bool {
     unsafe {
         let old = rusti::atomic_cxchg(address, oldval, newval);

branches/try/src/libcore/private/exchange_alloc.rs

@@ -18,8 +18,6 @@ use libc::{c_char, c_uchar, c_void, size_t, uintptr_t};
 use managed::raw::BoxRepr;
 use str;
 use sys;
-use private::exchange_alloc;
-use cast::transmute;
 
 use gc::{cleanup_stack_for_failure, gc, Word};
 
@@ -32,6 +30,13 @@ pub const FROZEN_BIT: uint = 0x80000000;
 pub const FROZEN_BIT: uint = 0x8000000000000000;
 
 pub extern mod rustrt {
+    #[rust_stack]
+    unsafe fn rust_upcall_exchange_malloc(td: *c_char, size: uintptr_t)
+                                       -> *c_char;
+
+    #[rust_stack]
+    unsafe fn rust_upcall_exchange_free(ptr: *c_char);
+
     #[rust_stack]
     unsafe fn rust_upcall_malloc(td: *c_char, size: uintptr_t) -> *c_char;
 
@@ -65,11 +70,10 @@ pub unsafe fn rt_fail_borrowed() {
     }
 }
 
-// XXX: Make these signatures agree with exchange_alloc's signatures
 #[rt(exchange_malloc)]
 #[lang="exchange_malloc"]
 pub unsafe fn rt_exchange_malloc(td: *c_char, size: uintptr_t) -> *c_char {
-    transmute(exchange_alloc::malloc(transmute(td), transmute(size)))
+    return rustrt::rust_upcall_exchange_malloc(td, size);
 }
 
 // NB: Calls to free CANNOT be allowed to fail, as throwing an exception from
@@ -78,7 +82,7 @@ pub unsafe fn rt_exchange_malloc(td: *c_char, size: uintptr_t) -> *c_char {
 #[rt(exchange_free)]
 #[lang="exchange_free"]
 pub unsafe fn rt_exchange_free(ptr: *c_char) {
-    exchange_alloc::free(transmute(ptr))
+    rustrt::rust_upcall_exchange_free(ptr);
 }
 
 #[rt(malloc)]

branches/try/src/libcore/rt.rs

@@ -1028,6 +1028,8 @@ pub fn pick_col(m: &[@Match]) -> uint {
 pub enum branch_kind { no_branch, single, switch, compare, compare_vec_len, }
 
 // Compiles a comparison between two things.
+//
+// NB: This must produce an i1, not a Rust bool (i8).
 pub fn compare_values(cx: block,
                       lhs: ValueRef,
                       rhs: ValueRef,
@@ -1053,7 +1055,11 @@ pub fn compare_values(cx: block,
                                                           scratch_rhs],
                                                         expr::SaveIn(
                                                          scratch_result.val));
-            return scratch_result.to_result(bcx);
+            let result = scratch_result.to_result(bcx);
+            Result {
+                bcx: result.bcx,
+                val: bool_to_i1(result.bcx, result.val)
+            }
         }
         ty::ty_estr(_) => {
             let scratch_result = scratch_datum(cx, ty::mk_bool(cx.tcx()),
@@ -1063,7 +1069,11 @@ pub fn compare_values(cx: block,
                                                         ~[lhs, rhs],
                                                         expr::SaveIn(
                                                          scratch_result.val));
-            return scratch_result.to_result(bcx);
+            let result = scratch_result.to_result(bcx);
+            Result {
+                bcx: result.bcx,
+                val: bool_to_i1(result.bcx, result.val)
+            }
         }
         _ => {
             cx.tcx().sess.bug(~"only scalars and strings supported in \
@@ -1176,6 +1186,7 @@ pub fn compile_guard(bcx: block,
             expr::trans_to_datum(bcx, guard_expr).to_result()
         }
     });
+    let val = bool_to_i1(bcx, val);
 
     // Revoke the temp cleanups now that the guard successfully executed.
     for temp_cleanups.each |llval| {

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

@@ -494,8 +494,13 @@ pub fn maybe_name_value(cx: @crate_ctxt, v: ValueRef, s: ~str) {
 // Used only for creating scalar comparison glue.
 pub enum scalar_type { nil_type, signed_int, unsigned_int, floating_point, }
 
-pub fn compare_scalar_types(cx: block, lhs: ValueRef, rhs: ValueRef,
-                            t: ty::t, op: ast::binop) -> Result {
+// NB: This produces an i1, not a Rust bool (i8).
+pub fn compare_scalar_types(cx: block,
+                            lhs: ValueRef,
+                            rhs: ValueRef,
+                            t: ty::t,
+                            op: ast::binop)
+                         -> Result {
     let f = |a| compare_scalar_values(cx, lhs, rhs, a, op);
 
     match ty::get(t).sty {
@@ -521,8 +526,12 @@ pub fn compare_scalar_types(cx: block, lhs: ValueRef, rhs: ValueRef,
 
 
 // A helper function to do the actual comparison of scalar values.
-pub fn compare_scalar_values(cx: block, lhs: ValueRef, rhs: ValueRef,
-                             nt: scalar_type, op: ast::binop) -> ValueRef {
+pub fn compare_scalar_values(cx: block,
+                             lhs: ValueRef,
+                             rhs: ValueRef,
+                             nt: scalar_type,
+                             op: ast::binop)
+                          -> ValueRef {
     let _icx = cx.insn_ctxt("compare_scalar_values");
     fn die(cx: block) -> ! {
         cx.tcx().sess.bug(~"compare_scalar_values: must be a\
@@ -533,8 +542,8 @@ pub fn compare_scalar_values(cx: block, lhs: ValueRef, rhs: ValueRef,
         // We don't need to do actual comparisons for nil.
         // () == () holds but () < () does not.
         match op {
-          ast::eq | ast::le | ast::ge => return C_bool(true),
-          ast::ne | ast::lt | ast::gt => return C_bool(false),
+          ast::eq | ast::le | ast::ge => return C_i1(true),
+          ast::ne | ast::lt | ast::gt => return C_i1(false),
           // refinements would be nice
           _ => die(cx)
         }
@@ -1442,7 +1451,7 @@ pub fn call_memcpy(cx: block, dst: ValueRef, src: ValueRef,
     let dst_ptr = PointerCast(cx, dst, T_ptr(T_i8()));
     let size = IntCast(cx, n_bytes, ccx.int_type);
     let align = C_i32(1i32);
-    let volatile = C_bool(false);
+    let volatile = C_i1(false);
     Call(cx, memcpy, ~[dst_ptr, src_ptr, size, align, volatile]);
 }
 
@@ -1489,7 +1498,7 @@ pub fn memzero(cx: block, llptr: ValueRef, llty: TypeRef) {
     let llzeroval = C_u8(0);
     let size = IntCast(cx, machine::llsize_of(ccx, llty), ccx.int_type);
     let align = C_i32(1i32);
-    let volatile = C_bool(false);
+    let volatile = C_i1(false);
     Call(cx, llintrinsicfn, ~[llptr, llzeroval, size, align, volatile]);
 }
 

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

@@ -438,7 +438,9 @@ pub fn trans_call_inner(
             let flag = alloca(bcx, T_bool());
             Store(bcx, C_bool(false), flag);
             Some(flag)
-        } else { None };
+        } else {
+            None
+        };
 
         let (llfn, llenv) = unsafe {
             match callee.data {
@@ -506,7 +508,8 @@ pub fn trans_call_inner(
         if ty::type_is_bot(ret_ty) {
             Unreachable(bcx);
         } else if ret_in_loop {
-            bcx = do with_cond(bcx, Load(bcx, ret_flag.get())) |bcx| {
+            let ret_flag_result = bool_to_i1(bcx, Load(bcx, ret_flag.get()));
+            bcx = do with_cond(bcx, ret_flag_result) |bcx| {
                 do option::iter(&copy bcx.fcx.loop_ret) |lret| {
                     Store(bcx, C_bool(true), lret.flagptr);
                     Store(bcx, C_bool(false), bcx.fcx.llretptr);

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

@@ -759,7 +759,7 @@ pub fn T_f32() -> TypeRef { unsafe { return llvm::LLVMFloatType(); } }
 
 pub fn T_f64() -> TypeRef { unsafe { return llvm::LLVMDoubleType(); } }
 
-pub fn T_bool() -> TypeRef { return T_i1(); }
+pub fn T_bool() -> TypeRef { return T_i8(); }
 
 pub fn T_int(targ_cfg: @session::config) -> TypeRef {
     return match targ_cfg.arch {
@@ -1109,6 +1109,10 @@ pub fn C_bool(b: bool) -> ValueRef {
     C_integral(T_bool(), if b { 1u64 } else { 0u64 }, False)
 }
 
+pub fn C_i1(b: bool) -> ValueRef {
+    return C_integral(T_i1(), if b { 1 } else { 0 }, False);
+}
+
 pub fn C_i32(i: i32) -> ValueRef {
     return C_integral(T_i32(), i as u64, True);
 }
@@ -1435,6 +1439,11 @@ pub fn struct_dtor() -> [uint * 2] {
     [0, 1]
 }
 
+// Casts a Rust bool value to an i1.
+pub fn bool_to_i1(bcx: block, llval: ValueRef) -> ValueRef {
+    build::ICmp(bcx, lib::llvm::IntNE, llval, C_bool(false))
+}
+
 //
 // Local Variables:
 // mode: rust

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

@@ -62,6 +62,8 @@ pub fn trans_if(bcx: block,
 
     let then_bcx_in = scope_block(bcx, thn.info(), ~"then");
     let else_bcx_in = scope_block(bcx, els.info(), ~"else");
+
+    let cond_val = bool_to_i1(bcx, cond_val);
     CondBr(bcx, cond_val, then_bcx_in.llbb, else_bcx_in.llbb);
 
     debug!("then_bcx_in=%s, else_bcx_in=%s",
@@ -139,6 +141,7 @@ pub fn trans_while(bcx: block, cond: @ast::expr, body: ast::blk) -> block {
     // compile the condition
     let Result {bcx: cond_bcx_out, val: cond_val} =
         expr::trans_to_datum(cond_bcx_in, cond).to_result();
+    let cond_val = bool_to_i1(cond_bcx_out, cond_val);
     let cond_bcx_out =
         trans_block_cleanups(cond_bcx_out, block_cleanups(cond_bcx_in));
     CondBr(cond_bcx_out, cond_val, body_bcx_in.llbb, next_bcx.llbb);
@@ -324,6 +327,7 @@ pub fn trans_check_expr(bcx: block,
             expr::trans_to_datum(bcx, pred_expr).to_result()
         }
     };
+    let val = bool_to_i1(bcx, val);
     do with_cond(bcx, Not(bcx, val)) |bcx| {
         trans_fail(bcx, Some(pred_expr.span), /*bad*/copy expr_str)
     }

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

@@ -77,7 +77,7 @@ fn lli64(val: int) -> ValueRef {
     C_i64(val as i64)
 }
 fn lli1(bval: bool) -> ValueRef {
-    C_bool(bval)
+    C_i1(bval)
 }
 fn llmdnode(elems: ~[ValueRef]) -> ValueRef {
     unsafe {