---

yaml
---
r: 5578
b: refs/heads/master
c: e50580a
h: refs/heads/master
v: v3

Author: brson

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 1097463d96fb549464ba37a3d2dbaa6a837d18eb
+refs/heads/master: e50580aa669efc91e5d374e4357bd48dd594169d

trunk/src/comp/middle/trans.rs

@@ -2208,7 +2208,7 @@ fn trans_unary(bcx: @block_ctxt, op: ast::unop, e: @ast::expr,
             let llety = T_ptr(type_of(ccx, e_sp, e_ty));
             body = PointerCast(bcx, body, llety);
         }
-        bcx = trans_expr_save_in(bcx, e, body, INIT);
+        bcx = trans_expr_save_in(bcx, e, body);
         revoke_clean(bcx, box);
         ret store_in_dest(bcx, box, dest);
       }
@@ -4033,15 +4033,15 @@ fn trans_tup(bcx: @block_ctxt, elts: [@ast::expr], id: ast::node_id,
       }
       save_in(pos) { (pos, none) }
       overwrite(pos, _) {
-        let scratch = alloca(bcx, llvm::LLVMGetElementType(val_ty(pos)));
+        let scratch = alloca(bcx, val_ty(pos));
         (scratch, some(pos))
       }
     };
     let temp_cleanups = [], i = 0;
     for e in elts {
         let dst = GEP_tup_like_1(bcx, t, addr, [0, i]);
         let e_ty = ty::expr_ty(bcx_tcx(bcx), e);
-        bcx = trans_expr_save_in(dst.bcx, e, dst.val, INIT);
+        bcx = trans_expr_save_in(dst.bcx, e, dst.val);
         add_clean_temp_mem(bcx, dst.val, e_ty);
         temp_cleanups += [dst.val];
         i += 1;
@@ -4072,7 +4072,7 @@ fn trans_rec(bcx: @block_ctxt, fields: [ast::field],
       // The expressions that populate the fields might still use the old
       // record, so we build the new on in a scratch area
       overwrite(pos, _) {
-        let scratch = alloca(bcx, llvm::LLVMGetElementType(val_ty(pos)));
+        let scratch = alloca(bcx, val_ty(pos));
         (scratch, some(pos))
       }
     };
@@ -4096,7 +4096,7 @@ fn trans_rec(bcx: @block_ctxt, fields: [ast::field],
         fn test(n: str, f: ast::field) -> bool { str::eq(f.node.ident, n) }
         alt vec::find(bind test(tf.ident, _), fields) {
           some(f) {
-            bcx = trans_expr_save_in(bcx, f.node.expr, dst.val, INIT);
+            bcx = trans_expr_save_in(bcx, f.node.expr, dst.val);
           }
           none. {
             let base = GEP_tup_like_1(bcx, t, base_val, [0, i]);
@@ -4198,17 +4198,20 @@ fn trans_expr(cx: @block_ctxt, e: @ast::expr) -> result {
     }
 }
 
-fn trans_expr_save_in(bcx: @block_ctxt, e: @ast::expr, dest: ValueRef,
-                      kind: copy_action) -> @block_ctxt {
+// FIXME add support for INIT/DROP_EXISTING
+fn trans_expr_save_in(bcx: @block_ctxt, e: @ast::expr, dest: ValueRef)
+    -> @block_ctxt {
     let tcx = bcx_tcx(bcx), t = ty::expr_ty(tcx, e);
-    let dst = if ty::type_is_bot(tcx, t) || ty::type_is_nil(tcx, t) {
-        ignore
-    } else if kind == INIT {
-        save_in(dest)
+    if ty::type_is_bot(tcx, t) || ty::type_is_nil(tcx, t) {
+        ret trans_expr_dps(bcx, e, ignore);
+    } else if type_is_immediate(bcx_ccx(bcx), t) {
+        let cell = empty_dest_cell();
+        bcx = trans_expr_dps(bcx, e, by_val(cell));
+        Store(bcx, *cell, dest);
+        ret bcx;
     } else {
-        overwrite(dest, t)
-    };
-    ret trans_expr_dps(bcx, e, dst);
+        ret trans_expr_dps(bcx, e, save_in(dest));
+    }
 }
 
 fn trans_expr_by_ref(bcx: @block_ctxt, e: @ast::expr) -> result {
@@ -4335,9 +4338,13 @@ fn trans_expr_dps(bcx: @block_ctxt, e: @ast::expr, dest: dest)
       }
       ast::expr_assign(dst, src) {
         assert dest == ignore;
-        let {bcx, val: lhs_addr, is_mem} = trans_lval(bcx, dst);
-        assert is_mem;
-        ret trans_expr_save_in(bcx, src, lhs_addr, DROP_EXISTING);
+        let lhs_res = trans_lval(bcx, dst);
+        assert (lhs_res.is_mem);
+        let rhs = trans_lval(lhs_res.bcx, src);
+        let t = ty::expr_ty(bcx_tcx(bcx), src);
+        // FIXME: calculate copy init-ness in typestate.
+        ret move_val_if_temp(rhs.bcx, DROP_EXISTING, lhs_res.val,
+                             rhs, t);
       }
       ast::expr_swap(dst, src) {
         assert dest == ignore;
@@ -4643,7 +4650,7 @@ fn trans_ret(bcx: @block_ctxt, e: option::t<@ast::expr>) -> @block_ctxt {
             Store(cx, val, bcx.fcx.llretptr);
             bcx = cx;
         } else {
-            bcx = trans_expr_save_in(bcx, x, bcx.fcx.llretptr, INIT);
+            bcx = trans_expr_save_in(bcx, x, bcx.fcx.llretptr);
         }
       }
       _ {}
@@ -4687,9 +4694,13 @@ fn init_local(bcx: @block_ctxt, local: @ast::local) -> @block_ctxt {
       some(init) {
         alt init.op {
           ast::init_assign. {
-            bcx = trans_expr_save_in(bcx, init.expr, llptr, INIT);
+            // Use the type of the RHS because if it's _|_, the LHS
+            // type might be something else, but we don't want to copy
+            // the value.
+            ty = node_id_type(bcx_ccx(bcx), init.expr.id);
+            let sub = trans_lval(bcx, init.expr);
+            bcx = move_val_if_temp(sub.bcx, INIT, llptr, sub, ty);
           }
-          // FIXME[DPS] do a save_in when expr isn't lval
           ast::init_move. {
             let sub = trans_lval(bcx, init.expr);
             bcx = move_val(sub.bcx, INIT, llptr, sub, ty);

trunk/src/comp/middle/trans_uniq.rs

@@ -30,7 +30,7 @@ fn trans_uniq(bcx: @block_ctxt, contents: @ast::expr,
     check type_is_unique_box(bcx, uniq_ty);
     let {bcx, val: llptr} = alloc_uniq(bcx, uniq_ty);
     add_clean_free(bcx, llptr, true);
-    bcx = trans::trans_expr_save_in(bcx, contents, llptr, INIT);
+    bcx = trans::trans_expr_save_in(bcx, contents, llptr);
     revoke_clean(bcx, llptr);
     ret trans::store_in_dest(bcx, llptr, dest);
 }

trunk/src/comp/middle/trans_vec.rs

@@ -20,11 +20,7 @@ fn get_alloc(bcx: @block_ctxt, vptrptr: ValueRef) -> ValueRef {
 }
 fn get_dataptr(bcx: @block_ctxt, vptrptr: ValueRef, unit_ty: TypeRef) ->
    ValueRef {
-    ret get_dataptr_simple(bcx, Load(bcx, vptrptr), unit_ty);
-}
-fn get_dataptr_simple(bcx: @block_ctxt, vptr: ValueRef, unit_ty: TypeRef)
-    -> ValueRef {
-    let ptr = GEPi(bcx, vptr, [0, abi::vec_elt_elems as int]);
+    let ptr = GEPi(bcx, Load(bcx, vptrptr), [0, abi::vec_elt_elems as int]);
     PointerCast(bcx, ptr, T_ptr(unit_ty))
 }
 
@@ -53,7 +49,8 @@ type alloc_result =
      llunitsz: ValueRef,
      llunitty: TypeRef};
 
-fn alloc(bcx: @block_ctxt, vec_ty: ty::t, elts: uint) -> alloc_result {
+fn alloc(bcx: @block_ctxt, vec_ty: ty::t, elts: uint, dest: dest)
+    -> alloc_result {
     let unit_ty = ty::sequence_element_type(bcx_tcx(bcx), vec_ty);
     let llunitty = type_of_or_i8(bcx, unit_ty);
     let llvecty = T_vec(llunitty);
@@ -64,8 +61,11 @@ fn alloc(bcx: @block_ctxt, vec_ty: ty::t, elts: uint) -> alloc_result {
     let {bcx: bcx, val: vptr} = alloc_raw(bcx, fill, alloc);
     let vptr = PointerCast(bcx, vptr, T_ptr(llvecty));
 
+    let vptrptr = alt dest { trans::save_in(a) { a } };
+    Store(bcx, vptr, vptrptr);
+//    add_clean_temp(bcx, vptrptr, vec_ty);
     ret {bcx: bcx,
-         val: vptr,
+         val: vptrptr,
          unit_ty: unit_ty,
          llunitsz: unit_sz,
          llunitty: llunitty};
@@ -110,15 +110,16 @@ fn trans_vec(bcx: @block_ctxt, args: [@ast::expr], id: ast::node_id,
     }
     let vec_ty = node_id_type(bcx_ccx(bcx), id);
     let {bcx: bcx,
-         val: vptr,
+         val: vptrptr,
          llunitsz: llunitsz,
          unit_ty: unit_ty,
          llunitty: llunitty} =
-        alloc(bcx, vec_ty, vec::len(args));
+        alloc(bcx, vec_ty, vec::len(args), dest);
 
+    let vptr = Load(bcx, vptrptr);
     add_clean_free(bcx, vptr, true);
     // Store the individual elements.
-    let dataptr = get_dataptr_simple(bcx, vptr, llunitty);
+    let dataptr = get_dataptr(bcx, vptrptr, llunitty);
     let i = 0u, temp_cleanups = [vptr];
     for e in args {
         let lv = trans_lval(bcx, e);
@@ -132,28 +133,17 @@ fn trans_vec(bcx: @block_ctxt, args: [@ast::expr], id: ast::node_id,
         i += 1u;
     }
     for clean in temp_cleanups { revoke_clean(bcx, clean); }
-    let vptrptr = alt dest {
-      trans::save_in(a) { a }
-      trans::overwrite(a, t) { bcx = trans::drop_ty(bcx, a, t); a }
-    };
-    Store(bcx, vptr, vptrptr);
     ret bcx;
 }
-
 fn trans_str(bcx: @block_ctxt, s: str, dest: dest) -> @block_ctxt {
     let veclen = std::str::byte_len(s) + 1u; // +1 for \0
-    let {bcx: bcx, val: sptr, _} =
-        alloc(bcx, ty::mk_str(bcx_tcx(bcx)), veclen);
+    let {bcx: bcx, val: sptrptr, _} =
+        alloc(bcx, ty::mk_str(bcx_tcx(bcx)), veclen, dest);
 
     let llcstr = C_cstr(bcx_ccx(bcx), s);
     let bcx =
-        call_memmove(bcx, get_dataptr_simple(bcx, sptr, T_i8()), llcstr,
+        call_memmove(bcx, get_dataptr(bcx, sptrptr, T_i8()), llcstr,
                      C_uint(veclen)).bcx;
-    let sptrptr = alt dest {
-      trans::save_in(a) { a }
-      trans::overwrite(a, t) { bcx = trans::drop_ty(bcx, a, t); a }
-    };
-    Store(bcx, sptr, sptrptr);
     ret bcx;
 }
 
@@ -247,9 +237,11 @@ fn trans_add(bcx: @block_ctxt, vec_ty: ty::t, lhsptr: ValueRef,
     let new_fill = Add(bcx, lhs_fill, rhs_fill);
     let {bcx: bcx, val: new_vec_ptr} = alloc_raw(bcx, new_fill, new_fill);
     new_vec_ptr = PointerCast(bcx, new_vec_ptr, T_ptr(T_vec(llunitty)));
+    let new_vec_ptr_ptr = alt dest { trans::save_in(a) { a } };
+    Store(bcx, new_vec_ptr, new_vec_ptr_ptr);
 
-    let write_ptr_ptr = do_spill_noroot
-        (bcx, get_dataptr_simple(bcx, new_vec_ptr, llunitty));
+    let write_ptr_ptr =
+        do_spill_noroot(bcx, get_dataptr(bcx, new_vec_ptr_ptr, llunitty));
     let copy_fn =
         bind fn (bcx: @block_ctxt, addr: ValueRef, _ty: ty::t,
                  write_ptr_ptr: ValueRef, unit_ty: ty::t, llunitsz: ValueRef)
@@ -267,15 +259,7 @@ fn trans_add(bcx: @block_ctxt, vec_ty: ty::t, lhsptr: ValueRef,
              }(_, _, _, write_ptr_ptr, unit_ty, llunitsz);
 
     let bcx = iter_vec_raw(bcx, lhsptr, vec_ty, lhs_fill, copy_fn);
-    bcx = iter_vec_raw(bcx, rhsptr, vec_ty, rhs_fill, copy_fn);
-    alt dest {
-      trans::save_in(a) { Store(bcx, new_vec_ptr, a); }
-      trans::overwrite(a, t) {
-        bcx = trans::drop_ty(bcx, a, t);
-        Store(bcx, new_vec_ptr, a);
-      }
-    }
-    ret bcx;
+    ret iter_vec_raw(bcx, rhsptr, vec_ty, rhs_fill, copy_fn);
 }
 
 type val_and_ty_fn = fn(@block_ctxt, ValueRef, ty::t) -> result;