@@ -2112,6 +2112,7 @@ fn move_val(cx: @block_ctxt, action: copy_action, dst: ValueRef,
2112
2112
ty_to_str ( tcx, t) ) ;
2113
2113
}
2114
2114
2115
+ // FIXME[DPS] rename to store_temp_expr
2115
2116
fn move_val_if_temp ( cx : @block_ctxt , action : copy_action , dst : ValueRef ,
2116
2117
src : lval_result , t : ty:: t ) -> @block_ctxt {
2117
2118
// Lvals in memory are not temporaries. Copy them.
@@ -2213,7 +2214,7 @@ fn trans_unary(bcx: @block_ctxt, op: ast::unop, e: @ast::expr,
2213
2214
let llety = T_ptr ( type_of ( ccx, e_sp, e_ty) ) ;
2214
2215
body = PointerCast ( bcx, body, llety) ;
2215
2216
}
2216
- bcx = trans_expr_save_in ( bcx, e, body, INIT ) ;
2217
+ bcx = trans_expr_save_in ( bcx, e, body) ;
2217
2218
revoke_clean ( bcx, box) ;
2218
2219
ret store_in_dest ( bcx, box, dest) ;
2219
2220
}
@@ -2255,8 +2256,7 @@ fn trans_expr_fn(bcx: @block_ctxt, f: ast::_fn, sp: span,
2255
2256
trans_closure ( sub_cx, sp, f, llfn, none, [ ] , id, { |_fcx|} ) ;
2256
2257
}
2257
2258
} ;
2258
- let { bcx, val: addr } = get_dest_addr ( bcx, dest) ;
2259
- fill_fn_pair ( bcx, addr, llfn, env) ;
2259
+ fill_fn_pair ( bcx, get_dest_addr ( dest) , llfn, env) ;
2260
2260
ret bcx;
2261
2261
}
2262
2262
@@ -2357,19 +2357,18 @@ fn trans_assign_op(bcx: @block_ctxt, op: ast::binop, dst: @ast::expr,
2357
2357
}
2358
2358
_ { }
2359
2359
}
2360
- let rhs_res = trans_expr ( lhs_res. bcx , src) ;
2360
+ let { bcx , val : rhs_val } = trans_expr ( lhs_res. bcx , src) ;
2361
2361
if ty:: type_is_sequence ( tcx, t) {
2362
2362
alt op {
2363
2363
ast : : add. {
2364
- ret tvec:: trans_append ( rhs_res. bcx , t, lhs_res. val ,
2365
- rhs_res. val ) ;
2364
+ ret tvec:: trans_append ( bcx, t, lhs_res. val , rhs_val) ;
2366
2365
}
2367
2366
_ { }
2368
2367
}
2369
2368
}
2370
- let lhs_val = load_if_immediate ( rhs_res . bcx , lhs_res . val , t ) ;
2371
- ret trans_eager_binop ( rhs_res . bcx , op, lhs_val , t, rhs_res . val , t,
2372
- overwrite ( lhs_res. val , t ) ) ;
2369
+
2370
+ ret trans_eager_binop( bcx, op, Load ( bcx , lhs_res . val ) , t, rhs_val , t,
2371
+ save_in ( lhs_res. val ) ) ;
2373
2372
}
2374
2373
2375
2374
fn autoderef ( cx : @block_ctxt , v : ValueRef , t : ty:: t ) -> result_t {
@@ -2485,7 +2484,6 @@ tag dest {
2485
2484
by_val( @mutable ValueRef ) ;
2486
2485
by_ref ( @mutable ValueRef ) ;
2487
2486
save_in ( ValueRef ) ;
2488
- overwrite ( ValueRef , ty:: t) ;
2489
2487
ignore;
2490
2488
}
2491
2489
@@ -2538,19 +2536,12 @@ fn store_in_dest(bcx: @block_ctxt, val: ValueRef, dest: dest) -> @block_ctxt {
2538
2536
ignore. { }
2539
2537
by_val ( cell) { * cell = val; }
2540
2538
save_in ( addr) { Store ( bcx, val, addr) ; }
2541
- overwrite ( addr, tp) {
2542
- bcx = drop_ty ( bcx, addr, tp) ;
2543
- Store ( bcx, val, addr) ;
2544
- }
2545
2539
}
2546
2540
ret bcx;
2547
2541
}
2548
2542
2549
- fn get_dest_addr ( bcx : @block_ctxt , dest : dest ) -> result {
2550
- alt dest {
2551
- save_in( a) { rslt ( bcx, a) }
2552
- overwrite ( a, t) { rslt ( drop_ty ( bcx, a, t) , a) }
2553
- }
2543
+ fn get_dest_addr ( dest : dest ) -> ValueRef {
2544
+ alt dest { save_in( a) { a } }
2554
2545
}
2555
2546
2556
2547
// Wrapper through which legacy non-DPS code can use DPS functions
@@ -2733,7 +2724,7 @@ fn build_environment(bcx: @block_ctxt, lltydescs: [ValueRef],
2733
2724
bcx = bound. bcx ;
2734
2725
alt bv {
2735
2726
env_expr( e) {
2736
- bcx = trans_expr_save_in ( bcx, e, bound. val , INIT ) ;
2727
+ bcx = trans_expr_save_in ( bcx, e, bound. val ) ;
2737
2728
add_clean_temp_mem ( bcx, bound. val , bound_tys[ i] ) ;
2738
2729
temp_cleanups += [ bound. val ] ;
2739
2730
}
@@ -3698,8 +3689,7 @@ fn trans_bind_1(cx: @block_ctxt, outgoing_fty: ty::t,
3698
3689
let lv = lval_maybe_callee_to_lval ( f_res, pair_ty) ;
3699
3690
bcx = lv. bcx ;
3700
3691
// FIXME[DPS] factor this out
3701
- let { bcx, val: addr } = get_dest_addr ( bcx, dest) ;
3702
- ret memmove_ty( bcx, addr, lv. val , pair_ty) ;
3692
+ ret memmove_ty( bcx, get_dest_addr ( dest) , lv. val , pair_ty) ;
3703
3693
}
3704
3694
let closure = alt f_res. env {
3705
3695
null_env. { none }
@@ -3736,8 +3726,7 @@ fn trans_bind_1(cx: @block_ctxt, outgoing_fty: ty::t,
3736
3726
closure. ptrty , ty_param_count, target_res) ;
3737
3727
3738
3728
// Fill the function pair
3739
- let { bcx, val: addr } = get_dest_addr ( bcx, dest) ;
3740
- fill_fn_pair ( bcx, addr, llthunk. val , closure. ptr ) ;
3729
+ fill_fn_pair ( bcx, get_dest_addr ( dest) , llthunk. val , closure. ptr ) ;
3741
3730
ret bcx;
3742
3731
}
3743
3732
@@ -3845,7 +3834,7 @@ fn trans_args(cx: @block_ctxt, outer_cx: @block_ctxt, llenv: ValueRef,
3845
3834
} else { alloca ( cx, llretty) }
3846
3835
}
3847
3836
save_in ( dst) { dst }
3848
- overwrite ( _ , _ ) | by_val ( _) { alloca ( cx, llretty) }
3837
+ by_val ( _) { alloca ( cx, llretty) }
3849
3838
by_ref ( _) { dest_ref = true ; alloca ( cx, T_ptr ( llretty) ) }
3850
3839
} ;
3851
3840
// FIXME[DSP] does this always hold?
@@ -3970,10 +3959,6 @@ fn trans_call(in_cx: @block_ctxt, f: @ast::expr,
3970
3959
}
3971
3960
}
3972
3961
save_in ( _) { } // Already saved by callee
3973
- overwrite ( a, t) {
3974
- bcx = drop_ty ( bcx, a, t) ;
3975
- bcx = memmove_ty ( bcx, a, llretslot, ret_ty) ;
3976
- }
3977
3962
by_ref ( cell) | by_val ( cell) {
3978
3963
* cell = Load ( bcx, llretslot) ;
3979
3964
}
@@ -4181,55 +4166,38 @@ fn trans_landing_pad(bcx: @block_ctxt,
4181
4166
fn trans_tup ( bcx : @block_ctxt , elts : [ @ast:: expr ] , id : ast:: node_id ,
4182
4167
dest : dest ) -> @block_ctxt {
4183
4168
let t = node_id_type ( bcx. fcx . lcx . ccx , id) ;
4184
- let ( addr, overwrite ) = alt dest {
4169
+ let addr = alt dest {
4185
4170
ignore. {
4186
4171
for ex in elts { bcx = trans_expr_dps ( bcx, ex, ignore) ; }
4187
4172
ret bcx;
4188
4173
}
4189
- save_in ( pos) { ( pos, none) }
4190
- overwrite ( pos, _) {
4191
- let scratch = alloca ( bcx, llvm:: LLVMGetElementType ( val_ty ( pos) ) ) ;
4192
- ( scratch, some ( pos) )
4193
- }
4174
+ save_in ( pos) { pos }
4194
4175
} ;
4195
4176
let temp_cleanups = [ ] , i = 0 ;
4196
4177
for e in elts {
4197
4178
let dst = GEP_tup_like_1 ( bcx, t, addr, [ 0 , i] ) ;
4198
4179
let e_ty = ty:: expr_ty ( bcx_tcx ( bcx) , e) ;
4199
- bcx = trans_expr_save_in ( dst. bcx , e, dst. val , INIT ) ;
4180
+ bcx = trans_expr_save_in ( dst. bcx , e, dst. val ) ;
4200
4181
add_clean_temp_mem ( bcx, dst. val , e_ty) ;
4201
4182
temp_cleanups += [ dst. val ] ;
4202
4183
i += 1 ;
4203
4184
}
4204
4185
for cleanup in temp_cleanups { revoke_clean ( bcx, cleanup) ; }
4205
- alt overwrite {
4206
- some( pos) {
4207
- bcx = drop_ty ( bcx, pos, t) ;
4208
- bcx = memmove_ty ( bcx, pos, addr, t) ;
4209
- }
4210
- none. { }
4211
- }
4212
4186
ret bcx;
4213
4187
}
4214
4188
4215
4189
fn trans_rec ( bcx : @block_ctxt , fields : [ ast:: field ] ,
4216
4190
base : option:: t < @ast:: expr > , id : ast:: node_id ,
4217
4191
dest : dest ) -> @block_ctxt {
4218
4192
let t = node_id_type ( bcx_ccx ( bcx) , id) ;
4219
- let ( addr, overwrite ) = alt dest {
4193
+ let addr = alt dest {
4220
4194
ignore. {
4221
4195
for fld in fields {
4222
4196
bcx = trans_expr_dps ( bcx, fld. node . expr , ignore) ;
4223
4197
}
4224
4198
ret bcx;
4225
4199
}
4226
- save_in ( pos) { ( pos, none) }
4227
- // The expressions that populate the fields might still use the old
4228
- // record, so we build the new on in a scratch area
4229
- overwrite ( pos, _) {
4230
- let scratch = alloca ( bcx, llvm:: LLVMGetElementType ( val_ty ( pos) ) ) ;
4231
- ( scratch, some ( pos) )
4232
- }
4200
+ save_in ( pos) { pos }
4233
4201
} ;
4234
4202
4235
4203
let base_val = alt base {
@@ -4248,7 +4216,7 @@ fn trans_rec(bcx: @block_ctxt, fields: [ast::field],
4248
4216
bcx = dst. bcx ;
4249
4217
alt vec:: find ( { |f| str:: eq ( f. node . ident , tf. ident ) } , fields) {
4250
4218
some ( f) {
4251
- bcx = trans_expr_save_in ( bcx, f. node . expr , dst. val , INIT ) ;
4219
+ bcx = trans_expr_save_in ( bcx, f. node . expr , dst. val ) ;
4252
4220
}
4253
4221
none. {
4254
4222
let base = GEP_tup_like_1 ( bcx, t, base_val, [ 0 , i] ) ;
@@ -4263,13 +4231,6 @@ fn trans_rec(bcx: @block_ctxt, fields: [ast::field],
4263
4231
// Now revoke the cleanups as we pass responsibility for the data
4264
4232
// structure on to the caller
4265
4233
for cleanup in temp_cleanups { revoke_clean ( bcx, cleanup) ; }
4266
- alt overwrite {
4267
- some( pos) {
4268
- bcx = drop_ty ( bcx, pos, t) ;
4269
- bcx = memmove_ty ( bcx, pos, addr, t) ;
4270
- }
4271
- none. { }
4272
- }
4273
4234
ret bcx;
4274
4235
}
4275
4236
@@ -4288,19 +4249,37 @@ fn trans_expr(cx: @block_ctxt, e: @ast::expr) -> result {
4288
4249
}
4289
4250
}
4290
4251
4291
- fn trans_expr_save_in ( bcx : @block_ctxt , e : @ast:: expr , dest : ValueRef ,
4292
- kind : copy_action ) -> @block_ctxt {
4252
+ fn trans_expr_save_in ( bcx : @block_ctxt , e : @ast:: expr , dest : ValueRef )
4253
+ -> @block_ctxt {
4293
4254
let tcx = bcx_tcx ( bcx) , t = ty:: expr_ty ( tcx, e) ;
4294
4255
let dst = if ty:: type_is_bot ( tcx, t) || ty:: type_is_nil ( tcx, t) {
4295
4256
ignore
4296
- } else if kind == INIT {
4297
- save_in ( dest)
4298
- } else {
4299
- overwrite ( dest, t)
4300
- } ;
4257
+ } else { save_in ( dest) } ;
4301
4258
ret trans_expr_dps ( bcx, e, dst) ;
4302
4259
}
4303
4260
4261
+ fn trans_temp_expr ( bcx : @block_ctxt , e : @ast:: expr ) -> lval_result {
4262
+ if expr_is_lval ( bcx_tcx ( bcx) , e) {
4263
+ ret trans_lval ( bcx, e) ;
4264
+ } else {
4265
+ let tcx = bcx_tcx ( bcx) ;
4266
+ let ty = ty:: expr_ty ( tcx, e) ;
4267
+ if ty:: type_is_nil ( tcx, ty) || ty:: type_is_bot ( tcx, ty) {
4268
+ bcx = trans_expr_dps ( bcx, e, ignore) ;
4269
+ ret { bcx : bcx, val : C_nil ( ) , is_mem : false } ;
4270
+ } else if type_is_immediate ( bcx_ccx ( bcx) , ty) {
4271
+ let cell = empty_dest_cell ( ) ;
4272
+ bcx = trans_expr_dps ( bcx, e, by_val ( cell) ) ;
4273
+ ret { bcx : bcx, val : * cell, is_mem : false } ;
4274
+ } else {
4275
+ let { bcx, val: scratch } = alloc_ty ( bcx, ty) ;
4276
+ bcx = trans_expr_dps ( bcx, e, save_in ( scratch) ) ;
4277
+ ret { bcx : bcx, val : scratch, is_mem : false } ;
4278
+ }
4279
+ }
4280
+ }
4281
+
4282
+ // FIXME[DPS] supersede by trans_temp_expr, get rid of by_ref dests
4304
4283
fn trans_expr_by_ref ( bcx : @block_ctxt , e : @ast:: expr ) -> result {
4305
4284
let cell = empty_dest_cell ( ) ;
4306
4285
bcx = trans_expr_dps ( bcx, e, by_ref ( cell) ) ;
@@ -4444,22 +4423,20 @@ fn trans_expr_dps(bcx: @block_ctxt, e: @ast::expr, dest: dest)
4444
4423
}
4445
4424
ast:: expr_assign ( dst, src) {
4446
4425
assert dest == ignore;
4447
- let { bcx, val: lhs_addr , is_mem} = trans_lval ( bcx, dst) ;
4426
+ let src_r = trans_temp_expr ( bcx, src) ;
4427
+ let { bcx, val: addr , is_mem } = trans_lval ( src_r. bcx , dst) ;
4448
4428
assert is_mem;
4449
- ret trans_expr_save_in ( bcx, src, lhs_addr, DROP_EXISTING ) ;
4429
+ ret move_val_if_temp ( bcx, DROP_EXISTING , addr, src_r,
4430
+ ty:: expr_ty ( bcx_tcx ( bcx) , src) ) ;
4450
4431
}
4451
4432
ast:: expr_move ( dst, src) {
4433
+ // FIXME: calculate copy init-ness in typestate.
4452
4434
assert dest == ignore;
4453
- let { bcx, val: addr , is_mem } = trans_lval ( bcx, dst) ;
4435
+ let src_r = trans_temp_expr ( bcx, src) ;
4436
+ let { bcx, val: addr , is_mem } = trans_lval ( src_r. bcx , dst) ;
4454
4437
assert is_mem;
4455
- // FIXME: calculate copy init-ness in typestate.
4456
- if expr_is_lval ( tcx, src) {
4457
- ret trans_expr_save_in ( bcx, src, addr, DROP_EXISTING ) ;
4458
- } else {
4459
- let srclv = trans_lval ( bcx, src) ;
4460
- let t = ty:: expr_ty ( tcx, src) ;
4461
- ret move_val( srclv. bcx , DROP_EXISTING , addr, srclv, t) ;
4462
- }
4438
+ ret move_val( bcx, DROP_EXISTING , addr, src_r,
4439
+ ty:: expr_ty ( bcx_tcx ( bcx) , src) ) ;
4463
4440
}
4464
4441
ast:: expr_swap ( dst, src) {
4465
4442
assert dest == ignore;
@@ -4506,9 +4483,6 @@ fn lval_to_dps(bcx: @block_ctxt, e: @ast::expr, dest: dest) -> @block_ctxt {
4506
4483
* cell = val;
4507
4484
}
4508
4485
save_in ( loc) { bcx = move_val_if_temp ( bcx, INIT , loc, lv, ty) ; }
4509
- overwrite ( loc, _) {
4510
- bcx = move_val_if_temp ( bcx, DROP_EXISTING , loc, lv, ty) ;
4511
- }
4512
4486
ignore. { }
4513
4487
}
4514
4488
ret bcx;
@@ -4760,7 +4734,7 @@ fn trans_ret(bcx: @block_ctxt, e: option::t<@ast::expr>) -> @block_ctxt {
4760
4734
Store ( cx, val, bcx. fcx . llretptr ) ;
4761
4735
bcx = cx;
4762
4736
} else {
4763
- bcx = trans_expr_save_in ( bcx, x, bcx. fcx . llretptr , INIT ) ;
4737
+ bcx = trans_expr_save_in ( bcx, x, bcx. fcx . llretptr ) ;
4764
4738
}
4765
4739
}
4766
4740
_ { }
@@ -4798,7 +4772,7 @@ fn init_local(bcx: @block_ctxt, local: @ast::local) -> @block_ctxt {
4798
4772
some ( init) {
4799
4773
if init. op == ast:: init_assign ||
4800
4774
!expr_is_lval ( bcx_tcx ( bcx) , init. expr ) {
4801
- bcx = trans_expr_save_in ( bcx, init. expr , llptr, INIT ) ;
4775
+ bcx = trans_expr_save_in ( bcx, init. expr , llptr) ;
4802
4776
} else { // This is a move from an lval, must perform an actual move
4803
4777
let sub = trans_lval ( bcx, init. expr ) ;
4804
4778
bcx = move_val ( sub. bcx , INIT , llptr, sub, ty) ;
0 commit comments