2011-08-22 13:48:00 -05:00
|
|
|
import syntax::ast;
|
2012-01-30 23:00:57 -06:00
|
|
|
import driver::session::session;
|
2012-02-01 04:04:56 -06:00
|
|
|
import lib::llvm::{ValueRef, TypeRef};
|
2011-08-22 13:48:00 -05:00
|
|
|
import back::abi;
|
2012-01-27 06:17:06 -06:00
|
|
|
import base::{call_memmove, trans_shared_malloc, type_of_or_i8,
|
2012-01-19 12:21:42 -06:00
|
|
|
INIT, copy_val, load_if_immediate, get_tydesc,
|
2012-02-17 06:17:40 -06:00
|
|
|
sub_block, do_spill_noroot,
|
2011-11-10 10:41:42 -06:00
|
|
|
dest};
|
2012-01-19 12:21:42 -06:00
|
|
|
import shape::{llsize_of, size_of};
|
2012-01-27 06:17:06 -06:00
|
|
|
import build::*;
|
|
|
|
import common::*;
|
2011-08-22 13:48:00 -05:00
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn get_fill(bcx: block, vptr: ValueRef) -> ValueRef {
|
2011-10-26 00:23:28 -05:00
|
|
|
Load(bcx, GEPi(bcx, vptr, [0, abi::vec_elt_fill]))
|
2011-08-25 03:18:02 -05:00
|
|
|
}
|
2012-02-17 06:17:40 -06:00
|
|
|
fn get_dataptr(bcx: block, vptr: ValueRef, unit_ty: TypeRef)
|
2011-09-27 13:21:44 -05:00
|
|
|
-> ValueRef {
|
2011-10-26 00:23:28 -05:00
|
|
|
let ptr = GEPi(bcx, vptr, [0, abi::vec_elt_elems]);
|
2011-08-25 03:18:02 -05:00
|
|
|
PointerCast(bcx, ptr, T_ptr(unit_ty))
|
|
|
|
}
|
2011-08-22 13:48:00 -05:00
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn pointer_add(bcx: block, ptr: ValueRef, bytes: ValueRef) -> ValueRef {
|
2011-08-25 03:18:02 -05:00
|
|
|
let old_ty = val_ty(ptr);
|
|
|
|
let bptr = PointerCast(bcx, ptr, T_ptr(T_i8()));
|
|
|
|
ret PointerCast(bcx, InBoundsGEP(bcx, bptr, [bytes]), old_ty);
|
|
|
|
}
|
2011-08-22 13:48:00 -05:00
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn alloc_raw(bcx: block, fill: ValueRef, alloc: ValueRef) -> result {
|
2011-10-14 22:38:24 -05:00
|
|
|
let ccx = bcx_ccx(bcx);
|
|
|
|
let llvecty = ccx.opaque_vec_type;
|
|
|
|
let vecsize = Add(bcx, alloc, llsize_of(ccx, llvecty));
|
2011-09-02 17:34:58 -05:00
|
|
|
let {bcx: bcx, val: vecptr} =
|
2011-08-29 15:30:18 -05:00
|
|
|
trans_shared_malloc(bcx, T_ptr(llvecty), vecsize);
|
2011-10-26 00:23:28 -05:00
|
|
|
Store(bcx, fill, GEPi(bcx, vecptr, [0, abi::vec_elt_fill]));
|
|
|
|
Store(bcx, alloc, GEPi(bcx, vecptr, [0, abi::vec_elt_alloc]));
|
2011-08-29 15:30:18 -05:00
|
|
|
ret {bcx: bcx, val: vecptr};
|
|
|
|
}
|
|
|
|
|
2011-09-02 17:34:58 -05:00
|
|
|
type alloc_result =
|
2012-02-17 06:17:40 -06:00
|
|
|
{bcx: block,
|
2011-09-02 17:34:58 -05:00
|
|
|
val: ValueRef,
|
|
|
|
unit_ty: ty::t,
|
|
|
|
llunitsz: ValueRef,
|
|
|
|
llunitty: TypeRef};
|
2011-08-22 13:48:00 -05:00
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn alloc(bcx: block, vec_ty: ty::t, elts: uint) -> alloc_result {
|
2011-10-14 22:38:24 -05:00
|
|
|
let ccx = bcx_ccx(bcx);
|
2011-08-25 03:18:02 -05:00
|
|
|
let unit_ty = ty::sequence_element_type(bcx_tcx(bcx), vec_ty);
|
2012-02-07 04:25:04 -06:00
|
|
|
let llunitty = type_of_or_i8(ccx, unit_ty);
|
2011-10-14 22:38:24 -05:00
|
|
|
let llvecty = T_vec(ccx, llunitty);
|
2011-09-02 17:34:58 -05:00
|
|
|
let {bcx: bcx, val: unit_sz} = size_of(bcx, unit_ty);
|
2011-08-25 03:18:02 -05:00
|
|
|
|
2011-10-14 22:38:24 -05:00
|
|
|
let fill = Mul(bcx, C_uint(ccx, elts), unit_sz);
|
|
|
|
let alloc = if elts < 4u {
|
|
|
|
Mul(bcx, C_int(ccx, 4), unit_sz)
|
|
|
|
} else {
|
|
|
|
fill
|
|
|
|
};
|
2011-09-02 17:34:58 -05:00
|
|
|
let {bcx: bcx, val: vptr} = alloc_raw(bcx, fill, alloc);
|
2011-08-29 15:30:18 -05:00
|
|
|
let vptr = PointerCast(bcx, vptr, T_ptr(llvecty));
|
2011-09-07 14:10:37 -05:00
|
|
|
|
2011-09-02 17:34:58 -05:00
|
|
|
ret {bcx: bcx,
|
2011-09-27 13:21:44 -05:00
|
|
|
val: vptr,
|
2011-09-02 17:34:58 -05:00
|
|
|
unit_ty: unit_ty,
|
|
|
|
llunitsz: unit_sz,
|
|
|
|
llunitty: llunitty};
|
2011-08-25 03:18:02 -05:00
|
|
|
}
|
2011-08-29 15:30:18 -05:00
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn duplicate(bcx: block, vptr: ValueRef, vec_ty: ty::t) -> result {
|
2011-10-14 22:38:24 -05:00
|
|
|
let ccx = bcx_ccx(bcx);
|
2011-10-10 06:32:50 -05:00
|
|
|
let fill = get_fill(bcx, vptr);
|
2011-10-14 22:38:24 -05:00
|
|
|
let size = Add(bcx, fill, llsize_of(ccx, ccx.opaque_vec_type));
|
2011-09-02 17:34:58 -05:00
|
|
|
let {bcx: bcx, val: newptr} =
|
|
|
|
trans_shared_malloc(bcx, val_ty(vptr), size);
|
2011-08-25 03:18:02 -05:00
|
|
|
let bcx = call_memmove(bcx, newptr, vptr, size).bcx;
|
2011-10-10 06:32:50 -05:00
|
|
|
let unit_ty = ty::sequence_element_type(bcx_tcx(bcx), vec_ty);
|
2011-10-26 00:23:28 -05:00
|
|
|
Store(bcx, fill, GEPi(bcx, newptr, [0, abi::vec_elt_alloc]));
|
2011-10-10 06:32:50 -05:00
|
|
|
if ty::type_needs_drop(bcx_tcx(bcx), unit_ty) {
|
2012-01-27 06:17:06 -06:00
|
|
|
bcx = iter_vec(bcx, newptr, vec_ty, base::take_ty);
|
2011-10-10 06:32:50 -05:00
|
|
|
}
|
|
|
|
ret rslt(bcx, newptr);
|
2011-08-25 03:18:02 -05:00
|
|
|
}
|
2012-02-17 06:17:40 -06:00
|
|
|
fn make_free_glue(bcx: block, vptr: ValueRef, vec_ty: ty::t) ->
|
|
|
|
block {
|
|
|
|
let tcx = bcx_tcx(bcx), unit_ty = ty::sequence_element_type(tcx, vec_ty);
|
|
|
|
base::with_cond(bcx, IsNotNull(bcx, vptr)) {|bcx|
|
|
|
|
let bcx = if ty::type_needs_drop(tcx, unit_ty) {
|
|
|
|
iter_vec(bcx, vptr, vec_ty, base::drop_ty)
|
|
|
|
} else { bcx };
|
|
|
|
base::trans_shared_free(bcx, vptr)
|
2011-08-22 13:48:00 -05:00
|
|
|
}
|
2011-08-22 15:30:53 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn trans_vec(bcx: block, args: [@ast::expr], id: ast::node_id,
|
|
|
|
dest: dest) -> block {
|
2011-11-03 04:57:54 -05:00
|
|
|
let ccx = bcx_ccx(bcx), bcx = bcx;
|
2012-01-27 06:17:06 -06:00
|
|
|
if dest == base::ignore {
|
2011-09-27 03:50:18 -05:00
|
|
|
for arg in args {
|
2012-01-27 06:17:06 -06:00
|
|
|
bcx = base::trans_expr(bcx, arg, base::ignore);
|
2011-09-27 03:50:18 -05:00
|
|
|
}
|
|
|
|
ret bcx;
|
|
|
|
}
|
2012-02-02 05:37:17 -06:00
|
|
|
let vec_ty = node_id_type(bcx, id);
|
2011-09-02 17:34:58 -05:00
|
|
|
let {bcx: bcx,
|
2011-09-27 13:21:44 -05:00
|
|
|
val: vptr,
|
2011-09-02 17:34:58 -05:00
|
|
|
llunitsz: llunitsz,
|
|
|
|
unit_ty: unit_ty,
|
|
|
|
llunitty: llunitty} =
|
2012-02-14 02:10:47 -06:00
|
|
|
alloc(bcx, vec_ty, args.len());
|
2011-08-22 15:30:53 -05:00
|
|
|
|
2011-09-27 06:19:55 -05:00
|
|
|
add_clean_free(bcx, vptr, true);
|
2011-08-22 15:30:53 -05:00
|
|
|
// Store the individual elements.
|
2011-10-10 06:32:50 -05:00
|
|
|
let dataptr = get_dataptr(bcx, vptr, llunitty);
|
2011-09-27 06:19:55 -05:00
|
|
|
let i = 0u, temp_cleanups = [vptr];
|
2011-08-25 03:18:02 -05:00
|
|
|
for e in args {
|
2011-09-27 03:50:18 -05:00
|
|
|
let lleltptr = if ty::type_has_dynamic_size(bcx_tcx(bcx), unit_ty) {
|
2011-10-14 22:38:24 -05:00
|
|
|
InBoundsGEP(bcx, dataptr, [Mul(bcx, C_uint(ccx, i), llunitsz)])
|
|
|
|
} else { InBoundsGEP(bcx, dataptr, [C_uint(ccx, i)]) };
|
2012-01-27 06:17:06 -06:00
|
|
|
bcx = base::trans_expr_save_in(bcx, e, lleltptr);
|
2011-09-27 03:50:18 -05:00
|
|
|
add_clean_temp_mem(bcx, lleltptr, unit_ty);
|
|
|
|
temp_cleanups += [lleltptr];
|
2011-08-22 13:48:00 -05:00
|
|
|
i += 1u;
|
|
|
|
}
|
2012-01-05 13:46:38 -06:00
|
|
|
for cln in temp_cleanups { revoke_clean(bcx, cln); }
|
2012-01-27 06:17:06 -06:00
|
|
|
ret base::store_in_dest(bcx, vptr, dest);
|
2011-08-22 13:48:00 -05:00
|
|
|
}
|
2011-09-27 13:21:44 -05:00
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn trans_str(bcx: block, s: str, dest: dest) -> block {
|
2012-02-12 02:14:05 -06:00
|
|
|
let veclen = str::len_bytes(s) + 1u; // +1 for \0
|
2011-09-27 13:21:44 -05:00
|
|
|
let {bcx: bcx, val: sptr, _} =
|
|
|
|
alloc(bcx, ty::mk_str(bcx_tcx(bcx)), veclen);
|
2011-08-22 13:48:00 -05:00
|
|
|
|
2011-10-14 22:38:24 -05:00
|
|
|
let ccx = bcx_ccx(bcx);
|
|
|
|
let llcstr = C_cstr(ccx, s);
|
2011-09-02 17:34:58 -05:00
|
|
|
let bcx =
|
2011-10-10 06:32:50 -05:00
|
|
|
call_memmove(bcx, get_dataptr(bcx, sptr, T_i8()), llcstr,
|
2011-10-14 22:38:24 -05:00
|
|
|
C_uint(ccx, veclen)).bcx;
|
2012-01-27 06:17:06 -06:00
|
|
|
ret base::store_in_dest(bcx, sptr, dest);
|
2011-08-22 13:48:00 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn trans_append(cx: block, vec_ty: ty::t, lhsptr: ValueRef,
|
|
|
|
rhs: ValueRef) -> block {
|
2011-08-22 13:48:00 -05:00
|
|
|
// Cast to opaque interior vector types if necessary.
|
2011-10-14 22:38:24 -05:00
|
|
|
let ccx = bcx_ccx(cx);
|
2011-08-25 03:18:02 -05:00
|
|
|
let unit_ty = ty::sequence_element_type(bcx_tcx(cx), vec_ty);
|
|
|
|
let dynamic = ty::type_has_dynamic_size(bcx_tcx(cx), unit_ty);
|
2012-01-29 20:33:08 -06:00
|
|
|
let (lhsptr, rhs) =
|
|
|
|
if !dynamic {
|
|
|
|
(lhsptr, rhs)
|
|
|
|
} else {
|
|
|
|
(PointerCast(cx, lhsptr, T_ptr(T_ptr(ccx.opaque_vec_type))),
|
|
|
|
PointerCast(cx, rhs, T_ptr(ccx.opaque_vec_type)))
|
|
|
|
};
|
2012-02-03 08:15:28 -06:00
|
|
|
let strings = alt ty::get(vec_ty).struct {
|
2012-01-19 00:37:22 -06:00
|
|
|
ty::ty_str { true }
|
2011-10-10 06:32:50 -05:00
|
|
|
ty::ty_vec(_) { false }
|
2012-01-30 23:00:57 -06:00
|
|
|
_ {
|
|
|
|
// precondition?
|
|
|
|
bcx_tcx(cx).sess.bug("Bad argument type in trans_append");
|
|
|
|
}
|
2011-10-10 06:32:50 -05:00
|
|
|
};
|
2011-08-22 19:35:38 -05:00
|
|
|
|
2011-09-02 17:34:58 -05:00
|
|
|
let {bcx: bcx, val: unit_sz} = size_of(cx, unit_ty);
|
2012-02-07 04:25:04 -06:00
|
|
|
let llunitty = type_of_or_i8(ccx, unit_ty);
|
2011-08-22 13:48:00 -05:00
|
|
|
|
2011-08-25 03:18:02 -05:00
|
|
|
let lhs = Load(bcx, lhsptr);
|
2012-02-01 04:04:56 -06:00
|
|
|
let self_append = ICmp(bcx, lib::llvm::IntEQ, lhs, rhs);
|
2011-10-10 06:32:50 -05:00
|
|
|
let lfill = get_fill(bcx, lhs);
|
|
|
|
let rfill = get_fill(bcx, rhs);
|
2011-08-25 03:18:02 -05:00
|
|
|
let new_fill = Add(bcx, lfill, rfill);
|
2011-10-14 22:38:24 -05:00
|
|
|
if strings { new_fill = Sub(bcx, new_fill, C_int(ccx, 1)); }
|
|
|
|
let opaque_lhs = PointerCast(bcx, lhsptr,
|
|
|
|
T_ptr(T_ptr(ccx.opaque_vec_type)));
|
2011-09-02 09:09:41 -05:00
|
|
|
Call(bcx, bcx_ccx(cx).upcalls.vec_grow,
|
2011-10-20 04:42:40 -05:00
|
|
|
[opaque_lhs, new_fill]);
|
2011-08-25 03:18:02 -05:00
|
|
|
// Was overwritten if we resized
|
2011-10-10 06:32:50 -05:00
|
|
|
let lhs = Load(bcx, lhsptr);
|
|
|
|
rhs = Select(bcx, self_append, lhs, rhs);
|
2011-08-25 03:18:02 -05:00
|
|
|
|
2011-10-10 06:32:50 -05:00
|
|
|
let lhs_data = get_dataptr(bcx, lhs, llunitty);
|
2011-08-25 03:18:02 -05:00
|
|
|
let lhs_off = lfill;
|
2011-10-14 22:38:24 -05:00
|
|
|
if strings { lhs_off = Sub(bcx, lhs_off, C_int(ccx, 1)); }
|
2011-08-25 03:18:02 -05:00
|
|
|
let write_ptr = pointer_add(bcx, lhs_data, lhs_off);
|
2011-09-02 17:12:27 -05:00
|
|
|
let write_ptr_ptr = do_spill_noroot(bcx, write_ptr);
|
2011-10-10 06:32:50 -05:00
|
|
|
let bcx = iter_vec_raw(bcx, rhs, vec_ty, rfill,
|
2011-09-02 17:34:58 -05:00
|
|
|
// We have to increment by the dynamically-computed size.
|
2011-09-12 04:27:30 -05:00
|
|
|
{|bcx, addr, _ty|
|
2011-09-02 17:34:58 -05:00
|
|
|
let write_ptr = Load(bcx, write_ptr_ptr);
|
|
|
|
let bcx =
|
|
|
|
copy_val(bcx, INIT, write_ptr,
|
|
|
|
load_if_immediate(bcx, addr, unit_ty),
|
|
|
|
unit_ty);
|
2012-01-29 20:33:08 -06:00
|
|
|
let incr = if dynamic {
|
|
|
|
unit_sz
|
|
|
|
} else {
|
|
|
|
C_int(ccx, 1)
|
|
|
|
};
|
2011-09-09 07:20:15 -05:00
|
|
|
Store(bcx, InBoundsGEP(bcx, write_ptr, [incr]),
|
|
|
|
write_ptr_ptr);
|
2011-09-02 17:34:58 -05:00
|
|
|
ret bcx;
|
|
|
|
});
|
2011-09-27 01:03:06 -05:00
|
|
|
ret bcx;
|
2011-08-22 13:48:00 -05:00
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn trans_append_literal(bcx: block, vptrptr: ValueRef, vec_ty: ty::t,
|
|
|
|
vals: [@ast::expr]) -> block {
|
2011-10-14 22:38:24 -05:00
|
|
|
let ccx = bcx_ccx(bcx);
|
2011-08-24 06:53:34 -05:00
|
|
|
let elt_ty = ty::sequence_element_type(bcx_tcx(bcx), vec_ty);
|
|
|
|
let ti = none;
|
2012-02-17 08:45:38 -06:00
|
|
|
let {bcx: bcx, val: td} = get_tydesc(bcx, elt_ty, false, ti);
|
2012-02-07 04:25:04 -06:00
|
|
|
base::lazily_emit_tydesc_glue(ccx, abi::tydesc_field_take_glue, ti);
|
2011-10-14 22:38:24 -05:00
|
|
|
let opaque_v = PointerCast(bcx, vptrptr,
|
|
|
|
T_ptr(T_ptr(ccx.opaque_vec_type)));
|
2011-08-24 06:53:34 -05:00
|
|
|
for val in vals {
|
2012-01-27 06:17:06 -06:00
|
|
|
let {bcx: e_bcx, val: elt} = base::trans_temp_expr(bcx, val);
|
2011-08-24 06:53:34 -05:00
|
|
|
bcx = e_bcx;
|
2012-01-27 06:17:06 -06:00
|
|
|
let r = base::spill_if_immediate(bcx, elt, elt_ty);
|
2011-09-02 17:34:58 -05:00
|
|
|
let spilled = r.val;
|
|
|
|
bcx = r.bcx;
|
2011-09-02 09:09:41 -05:00
|
|
|
Call(bcx, bcx_ccx(bcx).upcalls.vec_push,
|
2011-10-20 04:42:40 -05:00
|
|
|
[opaque_v, td, PointerCast(bcx, spilled, T_ptr(T_i8()))]);
|
2011-08-24 06:53:34 -05:00
|
|
|
}
|
|
|
|
ret bcx;
|
|
|
|
}
|
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn trans_add(bcx: block, vec_ty: ty::t, lhs: ValueRef,
|
|
|
|
rhs: ValueRef, dest: dest) -> block {
|
2011-10-14 22:38:24 -05:00
|
|
|
let ccx = bcx_ccx(bcx);
|
2012-02-03 08:15:28 -06:00
|
|
|
let strings = alt ty::get(vec_ty).struct {
|
2012-01-19 00:37:22 -06:00
|
|
|
ty::ty_str { true }
|
2012-01-30 23:00:57 -06:00
|
|
|
_ { false }
|
2011-09-27 03:50:18 -05:00
|
|
|
};
|
2011-08-29 15:30:18 -05:00
|
|
|
let unit_ty = ty::sequence_element_type(bcx_tcx(bcx), vec_ty);
|
2012-02-07 04:25:04 -06:00
|
|
|
let llunitty = type_of_or_i8(ccx, unit_ty);
|
2011-09-02 17:34:58 -05:00
|
|
|
let {bcx: bcx, val: llunitsz} = size_of(bcx, unit_ty);
|
2011-08-29 15:30:18 -05:00
|
|
|
|
2011-10-10 06:32:50 -05:00
|
|
|
let lhs_fill = get_fill(bcx, lhs);
|
2011-10-14 22:38:24 -05:00
|
|
|
if strings { lhs_fill = Sub(bcx, lhs_fill, C_int(ccx, 1)); }
|
2011-10-10 06:32:50 -05:00
|
|
|
let rhs_fill = get_fill(bcx, rhs);
|
2011-08-25 03:18:02 -05:00
|
|
|
let new_fill = Add(bcx, lhs_fill, rhs_fill);
|
2011-09-07 14:10:37 -05:00
|
|
|
let {bcx: bcx, val: new_vec_ptr} = alloc_raw(bcx, new_fill, new_fill);
|
2011-10-14 22:38:24 -05:00
|
|
|
new_vec_ptr = PointerCast(bcx, new_vec_ptr, T_ptr(T_vec(ccx, llunitty)));
|
2011-08-25 03:18:02 -05:00
|
|
|
|
2011-09-27 13:21:44 -05:00
|
|
|
let write_ptr_ptr = do_spill_noroot
|
2011-10-10 06:32:50 -05:00
|
|
|
(bcx, get_dataptr(bcx, new_vec_ptr, llunitty));
|
2012-02-17 06:17:40 -06:00
|
|
|
let copy_fn = fn@(bcx: block, addr: ValueRef,
|
|
|
|
_ty: ty::t) -> block {
|
2012-01-11 11:58:05 -06:00
|
|
|
let ccx = bcx_ccx(bcx);
|
|
|
|
let write_ptr = Load(bcx, write_ptr_ptr);
|
|
|
|
let bcx = copy_val(bcx, INIT, write_ptr,
|
|
|
|
load_if_immediate(bcx, addr, unit_ty), unit_ty);
|
|
|
|
let incr =
|
2012-01-29 20:33:08 -06:00
|
|
|
if ty::type_has_dynamic_size(bcx_tcx(bcx), unit_ty) {
|
|
|
|
llunitsz
|
|
|
|
} else {
|
|
|
|
C_int(ccx, 1)
|
|
|
|
};
|
2012-01-11 11:58:05 -06:00
|
|
|
Store(bcx, InBoundsGEP(bcx, write_ptr, [incr]),
|
|
|
|
write_ptr_ptr);
|
|
|
|
ret bcx;
|
|
|
|
};
|
2011-08-22 18:39:18 -05:00
|
|
|
|
2011-10-10 06:32:50 -05:00
|
|
|
let bcx = iter_vec_raw(bcx, lhs, vec_ty, lhs_fill, copy_fn);
|
|
|
|
bcx = iter_vec_raw(bcx, rhs, vec_ty, rhs_fill, copy_fn);
|
2012-01-27 06:17:06 -06:00
|
|
|
ret base::store_in_dest(bcx, new_vec_ptr, dest);
|
2011-08-29 09:14:24 -05:00
|
|
|
}
|
2011-08-22 13:48:00 -05:00
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
type val_and_ty_fn = fn@(block, ValueRef, ty::t) -> result;
|
2011-08-22 13:48:00 -05:00
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
type iter_vec_block = fn(block, ValueRef, ty::t) -> block;
|
2011-08-22 13:48:00 -05:00
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn iter_vec_raw(bcx: block, vptr: ValueRef, vec_ty: ty::t,
|
|
|
|
fill: ValueRef, f: iter_vec_block) -> block {
|
2011-10-14 22:38:24 -05:00
|
|
|
let ccx = bcx_ccx(bcx);
|
2011-08-25 03:18:02 -05:00
|
|
|
let unit_ty = ty::sequence_element_type(bcx_tcx(bcx), vec_ty);
|
2012-02-07 04:25:04 -06:00
|
|
|
let llunitty = type_of_or_i8(ccx, unit_ty);
|
2011-09-02 17:34:58 -05:00
|
|
|
let {bcx: bcx, val: unit_sz} = size_of(bcx, unit_ty);
|
2011-11-03 04:57:54 -05:00
|
|
|
let vptr = PointerCast(bcx, vptr, T_ptr(T_vec(ccx, llunitty)));
|
2011-10-10 06:32:50 -05:00
|
|
|
let data_ptr = get_dataptr(bcx, vptr, llunitty);
|
2011-08-25 03:18:02 -05:00
|
|
|
|
|
|
|
// Calculate the last pointer address we want to handle.
|
|
|
|
// TODO: Optimize this when the size of the unit type is statically
|
|
|
|
// known to not use pointer casts, which tend to confuse LLVM.
|
|
|
|
let data_end_ptr = pointer_add(bcx, data_ptr, fill);
|
|
|
|
|
|
|
|
// Now perform the iteration.
|
2012-02-17 06:17:40 -06:00
|
|
|
let header_cx = sub_block(bcx, "iter_vec_loop_header");
|
2011-08-25 03:18:02 -05:00
|
|
|
Br(bcx, header_cx.llbb);
|
2011-09-09 07:20:15 -05:00
|
|
|
let data_ptr = Phi(header_cx, val_ty(data_ptr), [data_ptr], [bcx.llbb]);
|
2011-09-02 17:34:58 -05:00
|
|
|
let not_yet_at_end =
|
2012-02-01 04:04:56 -06:00
|
|
|
ICmp(header_cx, lib::llvm::IntULT, data_ptr, data_end_ptr);
|
2012-02-17 06:17:40 -06:00
|
|
|
let body_cx = sub_block(header_cx, "iter_vec_loop_body");
|
|
|
|
let next_cx = sub_block(header_cx, "iter_vec_next");
|
2011-08-25 03:18:02 -05:00
|
|
|
CondBr(header_cx, not_yet_at_end, body_cx.llbb, next_cx.llbb);
|
2011-08-30 06:50:58 -05:00
|
|
|
body_cx = f(body_cx, data_ptr, unit_ty);
|
2011-09-02 17:34:58 -05:00
|
|
|
let increment =
|
|
|
|
if ty::type_has_dynamic_size(bcx_tcx(bcx), unit_ty) {
|
|
|
|
unit_sz
|
2011-10-14 22:38:24 -05:00
|
|
|
} else { C_int(ccx, 1) };
|
2011-09-23 16:20:19 -05:00
|
|
|
AddIncomingToPhi(data_ptr, InBoundsGEP(body_cx, data_ptr, [increment]),
|
|
|
|
body_cx.llbb);
|
2011-08-25 03:18:02 -05:00
|
|
|
Br(body_cx, header_cx.llbb);
|
2011-08-30 06:50:58 -05:00
|
|
|
ret next_cx;
|
2011-08-22 13:48:00 -05:00
|
|
|
}
|
2011-08-25 03:18:02 -05:00
|
|
|
|
2012-02-17 06:17:40 -06:00
|
|
|
fn iter_vec(bcx: block, vptr: ValueRef, vec_ty: ty::t,
|
|
|
|
f: iter_vec_block) -> block {
|
2011-10-14 22:38:24 -05:00
|
|
|
let ccx = bcx_ccx(bcx);
|
2011-11-03 04:57:54 -05:00
|
|
|
let vptr = PointerCast(bcx, vptr, T_ptr(ccx.opaque_vec_type));
|
2011-10-10 06:32:50 -05:00
|
|
|
ret iter_vec_raw(bcx, vptr, vec_ty, get_fill(bcx, vptr), f);
|
2011-08-29 09:14:24 -05:00
|
|
|
}
|
|
|
|
|
2011-08-24 06:53:34 -05:00
|
|
|
//
|
|
|
|
// Local Variables:
|
|
|
|
// mode: rust
|
|
|
|
// fill-column: 78;
|
|
|
|
// indent-tabs-mode: nil
|
|
|
|
// c-basic-offset: 4
|
|
|
|
// buffer-file-coding-system: utf-8-unix
|
|
|
|
// End:
|
|
|
|
//
|