diff --git a/src/comp/back/abi.rs b/src/comp/back/abi.rs index 2724368bb63..fb974b80452 100644 --- a/src/comp/back/abi.rs +++ b/src/comp/back/abi.rs @@ -78,11 +78,11 @@ const closure_elt_bindings: int = 1; const closure_elt_ty_params: int = 2; -const vec_elt_fill: uint = 0u; +const vec_elt_fill: int = 0; -const vec_elt_alloc: uint = 1u; +const vec_elt_alloc: int = 1; -const vec_elt_elems: uint = 2u; +const vec_elt_elems: int = 2; const worst_case_glue_call_args: int = 7; diff --git a/src/comp/middle/trans.rs b/src/comp/middle/trans.rs index cb1254d4729..9688e351ffe 100644 --- a/src/comp/middle/trans.rs +++ b/src/comp/middle/trans.rs @@ -659,14 +659,6 @@ fn dynamic_align_of(cx: @block_ctxt, t: ty::t) -> result { } } -// Simple wrapper around GEP that takes an array of ints and wraps them -// in C_int() -fn GEPi(cx: @block_ctxt, base: ValueRef, ixs: [int]) -> ValueRef { - let v: [ValueRef] = []; - for i: int in ixs { v += [C_int(bcx_ccx(cx), i)]; } - ret InBoundsGEP(cx, base, v); -} - // Increment a pointer by a given amount and then cast it to be a pointer // to a given type. fn bump_ptr(bcx: @block_ctxt, t: ty::t, base: ValueRef, sz: ValueRef) -> @@ -898,10 +890,8 @@ fn field_of_tydesc(cx: @block_ctxt, t: ty::t, escapes: bool, field: int) -> result { let ti = none::<@tydesc_info>; let tydesc = get_tydesc(cx, t, escapes, tps_normal, ti).result; - let ccx = bcx_ccx(cx); ret rslt(tydesc.bcx, - GEP(tydesc.bcx, tydesc.val, [C_int(ccx, 0), - C_int(ccx, field)])); + GEPi(tydesc.bcx, tydesc.val, [0, field])); } @@ -1230,7 +1220,7 @@ fn make_generic_glue_inner(cx: @local_ctxt, sp: span, t: ty::t, let lltydescs = [mutable]; let p = 0u; while p < ty_param_count { - let llparam = GEP(load_env_bcx, lltyparams, [C_int(ccx, p as int)]); + let llparam = GEPi(load_env_bcx, lltyparams, [p as int]); llparam = Load(load_env_bcx, llparam); std::vec::grow_set(lltydescs, ty_params[p], 0 as ValueRef, llparam); p += 1u; @@ -1354,8 +1344,7 @@ fn make_take_glue(cx: @block_ctxt, v: ValueRef, t: ty::t) { fn incr_refcnt_of_boxed(cx: @block_ctxt, box_ptr: ValueRef) -> @block_ctxt { let ccx = bcx_ccx(cx); let rc_ptr = - GEP(cx, box_ptr, [C_int(ccx, 0), - C_int(ccx, abi::box_rc_field_refcnt)]); + GEPi(cx, box_ptr, [0, abi::box_rc_field_refcnt]); let rc = Load(cx, rc_ptr); rc = Add(cx, rc, C_int(ccx, 1)); Store(cx, rc, rc_ptr); @@ -1369,9 +1358,7 @@ fn make_free_glue(bcx: @block_ctxt, v: ValueRef, t: ty::t) { let bcx = alt ty::struct(bcx_tcx(bcx), t) { ty::ty_box(body_mt) { v = PointerCast(bcx, v, type_of_1(bcx, t)); - let ccx = bcx_ccx(bcx); - let body = GEP(bcx, v, [C_int(ccx, 0), - C_int(ccx, abi::box_rc_field_body)]); + let body = GEPi(bcx, v, [0, abi::box_rc_field_body]); let bcx = drop_ty(bcx, body, body_mt.ty); if !bcx_ccx(bcx).sess.get_opts().do_gc { trans_non_gc_free(bcx, v) @@ -1391,11 +1378,9 @@ fn make_free_glue(bcx: @block_ctxt, v: ValueRef, t: ty::t) { let ccx = bcx_ccx(bcx); let llbox_ty = T_opaque_obj_ptr(ccx); let b = PointerCast(bcx, v, llbox_ty); - let body = GEP(bcx, b, [C_int(ccx, 0), - C_int(ccx, abi::box_rc_field_body)]); + let body = GEPi(bcx, b, [0, abi::box_rc_field_body]); let tydescptr = - GEP(bcx, body, [C_int(ccx, 0), - C_int(ccx, abi::obj_body_elt_tydesc)]); + GEPi(bcx, body, [0, abi::obj_body_elt_tydesc]); let tydesc = Load(bcx, tydescptr); let ti = none; call_tydesc_glue_full(bcx, body, tydesc, @@ -1409,14 +1394,11 @@ fn make_free_glue(bcx: @block_ctxt, v: ValueRef, t: ty::t) { // Then free the body. let ccx = bcx_ccx(bcx); v = PointerCast(bcx, v, T_opaque_closure_ptr(ccx)); - let body = GEP(bcx, v, [C_int(ccx, 0), - C_int(ccx, abi::box_rc_field_body)]); + let body = GEPi(bcx, v, [0, abi::box_rc_field_body]); let bindings = - GEP(bcx, body, [C_int(ccx, 0), - C_int(ccx, abi::closure_elt_bindings)]); + GEPi(bcx, body, [0, abi::closure_elt_bindings]); let tydescptr = - GEP(bcx, body, [C_int(ccx, 0), - C_int(ccx, abi::closure_elt_tydesc)]); + GEPi(bcx, body, [0, abi::closure_elt_tydesc]); let ti = none; call_tydesc_glue_full(bcx, bindings, Load(bcx, tydescptr), abi::tydesc_field_drop_glue, ti); @@ -1440,16 +1422,14 @@ fn make_drop_glue(bcx: @block_ctxt, v0: ValueRef, t: ty::t) { } ty::ty_obj(_) { let box_cell = - GEP(bcx, v0, [C_int(ccx, 0), - C_int(ccx, abi::obj_field_box)]); + GEPi(bcx, v0, [0, abi::obj_field_box]); decr_refcnt_maybe_free(bcx, Load(bcx, box_cell), t) } ty::ty_res(did, inner, tps) { trans_res_drop(bcx, v0, did, inner, tps) } ty::ty_fn(_, _, _, _, _) { - let box_cell = GEP(bcx, v0, [C_int(ccx, 0), - C_int(ccx, abi::fn_field_box)]); + let box_cell = GEPi(bcx, v0, [0, abi::fn_field_box]); decr_refcnt_maybe_free(bcx, Load(bcx, box_cell), t) } _ { @@ -1516,8 +1496,7 @@ fn decr_refcnt_maybe_free(cx: @block_ctxt, box_ptr: ValueRef, t: ty::t) let null_test = IsNull(cx, box_ptr); CondBr(cx, null_test, next_cx.llbb, rc_adj_cx.llbb); let rc_ptr = - GEP(rc_adj_cx, box_ptr, [C_int(ccx, 0), - C_int(ccx, abi::box_rc_field_refcnt)]); + GEPi(rc_adj_cx, box_ptr, [0, abi::box_rc_field_refcnt]); let rc = Load(rc_adj_cx, rc_ptr); rc = Sub(rc_adj_cx, rc, C_int(ccx, 1)); Store(rc_adj_cx, rc, rc_ptr); @@ -1730,8 +1709,8 @@ fn iter_structural_ty(cx: @block_ctxt, av: ValueRef, t: ty::t, let ccx = bcx_ccx(cx); let lltagty = T_opaque_tag_ptr(ccx); let av_tag = PointerCast(cx, av, lltagty); - let lldiscrim_a_ptr = GEP(cx, av_tag, [C_int(ccx, 0), C_int(ccx, 0)]); - let llunion_a_ptr = GEP(cx, av_tag, [C_int(ccx, 0), C_int(ccx, 1)]); + let lldiscrim_a_ptr = GEPi(cx, av_tag, [0, 0]); + let llunion_a_ptr = GEPi(cx, av_tag, [0, 1]); let lldiscrim_a = Load(cx, lldiscrim_a_ptr); // NB: we must hit the discriminant first so that structural @@ -1756,15 +1735,11 @@ fn iter_structural_ty(cx: @block_ctxt, av: ValueRef, t: ty::t, ret next_cx; } ty::ty_fn(_, _, _, _, _) | ty::ty_native_fn(_, _, _) { - let ccx = bcx_ccx(cx); - let box_cell_a = GEP(cx, av, [C_int(ccx, 0), - C_int(ccx, abi::fn_field_box)]); + let box_cell_a = GEPi(cx, av, [0, abi::fn_field_box]); ret iter_boxpp(cx, box_cell_a, f); } ty::ty_obj(_) { - let ccx = bcx_ccx(cx); - let box_cell_a = GEP(cx, av, [C_int(ccx, 0), - C_int(ccx, abi::obj_field_box)]); + let box_cell_a = GEPi(cx, av, [0, abi::obj_field_box]); ret iter_boxpp(cx, box_cell_a, f); } _ { bcx_ccx(cx).sess.unimpl("type in iter_structural_ty"); } @@ -1880,18 +1855,15 @@ fn call_tydesc_glue_full(cx: @block_ctxt, v: ValueRef, tydesc: ValueRef, } } - let ccx = bcx_ccx(cx); let llrawptr = PointerCast(cx, v, T_ptr(T_i8())); let lltydescs = - GEP(cx, tydesc, [C_int(ccx, 0), - C_int(ccx, abi::tydesc_field_first_param)]); + GEPi(cx, tydesc, [0, abi::tydesc_field_first_param]); lltydescs = Load(cx, lltydescs); let llfn; alt static_glue_fn { none. { - let llfnptr = GEP(cx, tydesc, [C_int(ccx, 0), - C_int(ccx, field)]); + let llfnptr = GEPi(cx, tydesc, [0, field]); llfn = Load(cx, llfnptr); } some(sgf) { llfn = sgf; } @@ -1930,18 +1902,15 @@ fn call_cmp_glue(cx: @block_ctxt, lhs: ValueRef, rhs: ValueRef, t: ty::t, let lltydesc = r.val; bcx = r.bcx; lazily_emit_tydesc_glue(bcx, abi::tydesc_field_cmp_glue, ti); - let ccx = bcx_ccx(bcx); let lltydescs = - GEP(bcx, lltydesc, [C_int(ccx, 0), - C_int(ccx, abi::tydesc_field_first_param)]); + GEPi(bcx, lltydesc, [0, abi::tydesc_field_first_param]); lltydescs = Load(bcx, lltydescs); let llfn; alt ti { none. { let llfnptr = - GEP(bcx, lltydesc, [C_int(ccx, 0), - C_int(ccx, abi::tydesc_field_cmp_glue)]); + GEPi(bcx, lltydesc, [0, abi::tydesc_field_cmp_glue]); llfn = Load(bcx, llfnptr); } some(sti) { llfn = option::get(sti.cmp_glue); } @@ -2411,8 +2380,7 @@ fn autoderef(cx: @block_ctxt, v: ValueRef, t: ty::t) -> result_t { while true { alt ty::struct(ccx.tcx, t1) { ty::ty_box(mt) { - let body = GEP(cx, v1, [C_int(ccx, 0), - C_int(ccx, abi::box_rc_field_body)]); + let body = GEPi(cx, v1, [0, abi::box_rc_field_body]); t1 = mt.ty; // Since we're changing levels of box indirection, we may have @@ -2432,7 +2400,7 @@ fn autoderef(cx: @block_ctxt, v: ValueRef, t: ty::t) -> result_t { } ty::ty_res(did, inner, tps) { t1 = ty::substitute_type_params(ccx.tcx, tps, inner); - v1 = GEP(cx, v1, [C_int(ccx, 0), C_int(ccx, 1)]); + v1 = GEPi(cx, v1, [0, 1]); } ty::ty_tag(did, tps) { let variants = ty::tag_variants(ccx.tcx, did); @@ -3031,8 +2999,7 @@ fn trans_var(cx: @block_ctxt, sp: span, def: ast::def, id: ast::node_id) let lltagty = type_of_tag(ccx, sp, tid, tag_ty); let bcx = alloc_result.bcx; let lltagptr = PointerCast(bcx, lltagblob, T_ptr(lltagty)); - let lldiscrimptr = GEP(bcx, lltagptr, [C_int(ccx, 0), - C_int(ccx, 0)]); + let lldiscrimptr = GEPi(bcx, lltagptr, [0, 0]); let d = if std::vec::len(ty::tag_variants(ccx.tcx, tid)) != 1u { let lldiscrim_gv = lookup_discriminant(bcx.fcx.lcx, vid); let lldiscrim = Load(bcx, lldiscrim_gv); @@ -3075,13 +3042,11 @@ fn trans_object_field_inner(bcx: @block_ctxt, o: ValueRef, let mths = alt ty::struct(tcx, o_ty) { ty::ty_obj(ms) { ms } }; let ix = ty::method_idx(ccx.sess, bcx.sp, field, mths); - let vtbl = Load(bcx, GEP(bcx, o, [C_int(ccx, 0), - C_int(ccx, abi::obj_field_vtbl)])); + let vtbl = Load(bcx, GEPi(bcx, o, [0, abi::obj_field_vtbl])); let vtbl_type = T_ptr(T_array(T_ptr(T_nil()), ix + 1u)); vtbl = PointerCast(bcx, vtbl, vtbl_type); - let v = GEP(bcx, vtbl, [C_int(ccx, 0), - C_int(ccx, ix as int)]); + let v = GEPi(bcx, vtbl, [0, ix as int]); let fn_ty: ty::t = ty::method_ty_to_fn_ty(tcx, mths[ix]); let ret_ty = ty::ty_fn_ret(tcx, fn_ty); let ret_ref = ast_util::ret_by_ref(ty::ty_fn_ret_style(tcx, fn_ty)); @@ -3225,13 +3190,10 @@ fn trans_lval(cx: @block_ctxt, e: @ast::expr) -> lval_result { let val = alt ty::struct(ccx.tcx, t) { ty::ty_box(_) { - InBoundsGEP(sub.bcx, sub.val, - [C_int(ccx, 0), - C_int(ccx, abi::box_rc_field_body)]) + GEPi(sub.bcx, sub.val, [0, abi::box_rc_field_body]) } ty::ty_res(_, _, _) { - InBoundsGEP(sub.bcx, sub.val, [C_int(ccx, 0), - C_int(ccx, 1)]) + GEPi(sub.bcx, sub.val, [0, 1]) } ty::ty_tag(_, _) { let ety = ty::expr_ty(ccx.tcx, e); @@ -3453,11 +3415,9 @@ fn trans_bind_thunk(cx: @local_ctxt, sp: span, incoming_fty: ty::t, [0, abi::box_rc_field_body, abi::closure_elt_bindings, 0]); let lltargetenv = - Load(cx, GEP(cx, pair, [C_int(ccx, 0), - C_int(ccx, abi::fn_field_box)])); + Load(cx, GEPi(cx, pair, [0, abi::fn_field_box])); let lltargetfn = Load - (cx, GEP(cx, pair, [C_int(ccx, 0), - C_int(ccx, abi::fn_field_code)])); + (cx, GEPi(cx, pair, [0, abi::fn_field_code])); bcx = cx; (lltargetfn, lltargetenv, 1) } @@ -3803,7 +3763,6 @@ fn trans_call(in_cx: @block_ctxt, f: @ast::expr, // NB: 'f' isn't necessarily a function; it might be an entire self-call // expression because of the hack that allows us to process self-calls // with trans_call. - let ccx = bcx_ccx(in_cx); let tcx = bcx_tcx(in_cx); let fn_expr_ty = ty::expr_ty(tcx, f); @@ -3828,11 +3787,9 @@ fn trans_call(in_cx: @block_ctxt, f: @ast::expr, faddr = load_if_immediate(bcx, faddr, fn_expr_ty); } let pair = faddr; - faddr = GEP(bcx, pair, [C_int(ccx, 0), - C_int(ccx, abi::fn_field_code)]); + faddr = GEPi(bcx, pair, [0, abi::fn_field_code]); faddr = Load(bcx, faddr); - let llclosure = GEP(bcx, pair, [C_int(ccx, 0), - C_int(ccx, abi::fn_field_box)]); + let llclosure = GEPi(bcx, pair, [0, abi::fn_field_box]); llenv = Load(bcx, llclosure); } } @@ -5100,25 +5057,23 @@ fn populate_fn_ctxt_from_llself(fcx: @fn_ctxt, llself: val_self_pair) { let fields_tup_ty = ty::mk_tup(fcx.lcx.ccx.tcx, field_tys); let n_typarams = std::vec::len::(bcx.fcx.lcx.obj_typarams); let llobj_box_ty: TypeRef = T_obj_ptr(ccx, n_typarams); - let box_cell = GEP(bcx, llself.v, [C_int(ccx, 0), - C_int(ccx, abi::obj_field_box)]); + let box_cell = GEPi(bcx, llself.v, [0, abi::obj_field_box]); let box_ptr = Load(bcx, box_cell); box_ptr = PointerCast(bcx, box_ptr, llobj_box_ty); let obj_typarams = - GEP(bcx, box_ptr, - [C_int(ccx, 0), C_int(ccx, abi::box_rc_field_body), - C_int(ccx, abi::obj_body_elt_typarams)]); + GEPi(bcx, box_ptr, [0, abi::box_rc_field_body, + abi::obj_body_elt_typarams]); // The object fields immediately follow the type parameters, so we skip // over them to get the pointer. let obj_fields = - PointerCast(bcx, GEP(bcx, obj_typarams, [C_int(ccx, 1)]), + PointerCast(bcx, GEPi(bcx, obj_typarams, [1]), T_ptr(type_of_or_i8(bcx, fields_tup_ty))); let i: int = 0; for p: ast::ty_param in fcx.lcx.obj_typarams { let lltyparam: ValueRef = - GEP(bcx, obj_typarams, [C_int(ccx, 0), C_int(ccx, i)]); + GEPi(bcx, obj_typarams, [0, i]); lltyparam = Load(bcx, lltyparam); fcx.lltydescs += [lltyparam]; i += 1; @@ -5307,10 +5262,9 @@ fn trans_tag_variant(cx: @local_ctxt, tag_id: ast::node_id, } else { let lltagptr = PointerCast(bcx, fcx.llretptr, T_opaque_tag_ptr(ccx)); - let lldiscrimptr = GEP(bcx, lltagptr, [C_int(ccx, 0), - C_int(ccx, 0)]); + let lldiscrimptr = GEPi(bcx, lltagptr, [0, 0]); Store(bcx, C_int(ccx, index), lldiscrimptr); - GEP(bcx, lltagptr, [C_int(ccx, 0), C_int(ccx, 1)]) + GEPi(bcx, lltagptr, [0, 1]) }; i = 0u; let t_id = ast_util::local_def(tag_id); @@ -5558,11 +5512,9 @@ fn create_real_fn_pair(cx: @block_ctxt, llfnty: TypeRef, llfn: ValueRef, fn fill_fn_pair(bcx: @block_ctxt, pair: ValueRef, llfn: ValueRef, llenvptr: ValueRef) { let ccx = bcx_ccx(bcx); - let code_cell = GEP(bcx, pair, [C_int(ccx, 0), - C_int(ccx, abi::fn_field_code)]); + let code_cell = GEPi(bcx, pair, [0, abi::fn_field_code]); Store(bcx, llfn, code_cell); - let env_cell = GEP(bcx, pair, [C_int(ccx, 0), - C_int(ccx, abi::fn_field_box)]); + let env_cell = GEPi(bcx, pair, [0, abi::fn_field_box]); let llenvblobptr = PointerCast(bcx, llenvptr, T_opaque_closure_ptr(ccx)); Store(bcx, llenvblobptr, env_cell); @@ -5801,7 +5753,7 @@ fn register_native_fn(ccx: @crate_ctxt, sp: span, path: [str], name: str, r = trans_native_call(new_raw_block_ctxt(bcx.fcx, bcx.llbb), ccx.externs, ccx.llmod, name, call_args); - rptr = BitCast(bcx, fcx.llretptr, T_ptr(T_i32())); + rptr = BitCast(bcx, fcx.llretptr, T_ptr(ccx.int_type)); } } // We don't store the return value if it's nil, to avoid stomping on a nil diff --git a/src/comp/middle/trans_alt.rs b/src/comp/middle/trans_alt.rs index 517192d580d..ce9768d88a4 100644 --- a/src/comp/middle/trans_alt.rs +++ b/src/comp/middle/trans_alt.rs @@ -259,7 +259,7 @@ fn extract_variant_args(bcx: @block_ctxt, pat_id: ast::node_id, if size > 0u && vec::len(variants) != 1u { let tagptr = PointerCast(bcx, val, trans_common::T_opaque_tag_ptr(ccx)); - blobptr = GEP(bcx, tagptr, [C_int(ccx, 0), C_int(ccx, 1)]); + blobptr = GEPi(bcx, tagptr, [0, 1]); } let i = 0u; let vdefs_tg = vdefs.tg; @@ -438,10 +438,7 @@ fn compile_submatch(bcx: @block_ctxt, m: match, vals: [ValueRef], f: mk_fail, // Unbox in case of a box field if any_box_pat(m, col) { let box = Load(bcx, val); - let unboxed = - InBoundsGEP(bcx, box, - [C_int(ccx, 0), - C_int(ccx, back::abi::box_rc_field_body)]); + let unboxed = GEPi(bcx, box, [0, back::abi::box_rc_field_body]); compile_submatch(bcx, enter_box(m, col, val), [unboxed] + vals_left, f, exits); ret; @@ -468,8 +465,7 @@ fn compile_submatch(bcx: @block_ctxt, m: match, vals: [ValueRef], f: mk_fail, let tagptr = PointerCast(bcx, val, trans_common::T_opaque_tag_ptr(ccx)); - let discrimptr = GEP(bcx, tagptr, [C_int(ccx, 0), - C_int(ccx, 0)]); + let discrimptr = GEPi(bcx, tagptr, [0, 0]); test_val = Load(bcx, discrimptr); kind = switch; } @@ -738,9 +734,7 @@ fn bind_irrefutable_pat(bcx: @block_ctxt, pat: @ast::pat, val: ValueRef, ast::pat_box(inner) { let box = Load(bcx, val); let unboxed = - InBoundsGEP(bcx, box, - [C_int(ccx, 0), - C_int(ccx, back::abi::box_rc_field_body)]); + GEPi(bcx, box, [0, back::abi::box_rc_field_body]); bcx = bind_irrefutable_pat(bcx, inner, unboxed, true); } ast::pat_uniq(inner) { diff --git a/src/comp/middle/trans_build.rs b/src/comp/middle/trans_build.rs index c2f5fbedaa2..fbc96d5c21d 100644 --- a/src/comp/middle/trans_build.rs +++ b/src/comp/middle/trans_build.rs @@ -4,7 +4,7 @@ import lib::llvm::llvm; import llvm::{ValueRef, TypeRef, BasicBlockRef, BuilderRef, Opcode, ModuleRef}; import trans_common::{block_ctxt, T_ptr, T_nil, T_int, T_i8, T_i1, - val_ty, val_str, bcx_ccx}; + val_ty, val_str, bcx_ccx, C_i32}; fn B(cx: @block_ctxt) -> BuilderRef { let b = *cx.fcx.lcx.ccx.builder; @@ -325,6 +325,14 @@ fn GEP(cx: @block_ctxt, Pointer: ValueRef, Indices: [ValueRef]) -> ValueRef { } } +// Simple wrapper around GEP that takes an array of ints and wraps them +// in C_i32() +fn GEPi(cx: @block_ctxt, base: ValueRef, ixs: [int]) -> ValueRef { + let v: [ValueRef] = []; + for i: int in ixs { v += [C_i32(i as i32)]; } + ret InBoundsGEP(cx, base, v); +} + fn InBoundsGEP(cx: @block_ctxt, Pointer: ValueRef, Indices: [ValueRef]) -> ValueRef { if cx.unreachable { ret llvm::LLVMGetUndef(T_ptr(T_nil())); } diff --git a/src/comp/middle/trans_common.rs b/src/comp/middle/trans_common.rs index 4a85d52e90d..8580f53a624 100644 --- a/src/comp/middle/trans_common.rs +++ b/src/comp/middle/trans_common.rs @@ -770,6 +770,10 @@ fn C_bool(b: bool) -> ValueRef { } else { ret C_integral(T_bool(), 0u, False); } } +fn C_i32(i: i32) -> ValueRef { + ret C_integral(T_i32(), i as uint, True); +} + fn C_int(cx: @crate_ctxt, i: int) -> ValueRef { ret C_integral(cx.int_type, i as uint, True); } diff --git a/src/comp/middle/trans_vec.rs b/src/comp/middle/trans_vec.rs index dbb49b48849..5df7164328c 100644 --- a/src/comp/middle/trans_vec.rs +++ b/src/comp/middle/trans_vec.rs @@ -8,16 +8,16 @@ import trans::{call_memmove, trans_shared_malloc, llsize_of, type_of_or_i8, llderivedtydescs_block_ctxt, lazily_emit_tydesc_glue, get_tydesc, load_inbounds, node_id_type, new_sub_block_ctxt, tps_normal, do_spill_noroot, - GEPi, alloc_ty, dest}; + alloc_ty, dest}; import trans_build::*; import trans_common::*; fn get_fill(bcx: @block_ctxt, vptr: ValueRef) -> ValueRef { - Load(bcx, GEPi(bcx, vptr, [0, abi::vec_elt_fill as int])) + Load(bcx, GEPi(bcx, vptr, [0, abi::vec_elt_fill])) } fn get_dataptr(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, vptr, [0, abi::vec_elt_elems]); PointerCast(bcx, ptr, T_ptr(unit_ty)) } @@ -33,12 +33,8 @@ fn alloc_raw(bcx: @block_ctxt, fill: ValueRef, alloc: ValueRef) -> result { let vecsize = Add(bcx, alloc, llsize_of(ccx, llvecty)); let {bcx: bcx, val: vecptr} = trans_shared_malloc(bcx, T_ptr(llvecty), vecsize); - Store(bcx, fill, - InBoundsGEP(bcx, vecptr, [C_int(ccx, 0), - C_uint(ccx, abi::vec_elt_fill)])); - Store(bcx, alloc, - InBoundsGEP(bcx, vecptr, [C_int(ccx, 0), - C_uint(ccx, abi::vec_elt_alloc)])); + Store(bcx, fill, GEPi(bcx, vecptr, [0, abi::vec_elt_fill])); + Store(bcx, alloc, GEPi(bcx, vecptr, [0, abi::vec_elt_alloc])); ret {bcx: bcx, val: vecptr}; } @@ -80,9 +76,7 @@ fn duplicate(bcx: @block_ctxt, vptr: ValueRef, vec_ty: ty::t) -> result { trans_shared_malloc(bcx, val_ty(vptr), size); let bcx = call_memmove(bcx, newptr, vptr, size).bcx; let unit_ty = ty::sequence_element_type(bcx_tcx(bcx), vec_ty); - Store(bcx, fill, - InBoundsGEP(bcx, newptr, [C_int(ccx, 0), - C_uint(ccx, abi::vec_elt_alloc)])); + Store(bcx, fill, GEPi(bcx, newptr, [0, abi::vec_elt_alloc])); if ty::type_needs_drop(bcx_tcx(bcx), unit_ty) { bcx = iter_vec(bcx, newptr, vec_ty, trans::take_ty); }