diff --git a/src/comp/back/upcall.rs b/src/comp/back/upcall.rs index 0eaef300d80..9d67aea59d9 100644 --- a/src/comp/back/upcall.rs +++ b/src/comp/back/upcall.rs @@ -1,5 +1,6 @@ import std::str; +import driver::session; import middle::trans; import trans::decl_cdecl_fn; import middle::trans_common::{T_f32, T_f64, T_fn, T_bool, T_i1, T_i8, T_i32, @@ -32,7 +33,9 @@ type upcalls = call_c_stack_float: ValueRef, rust_personality: ValueRef}; -fn declare_upcalls(_tn: type_names, tydesc_type: TypeRef, +fn declare_upcalls(targ_cfg: @session::config, + _tn: type_names, + tydesc_type: TypeRef, llmod: ModuleRef) -> @upcalls { fn decl(llmod: ModuleRef, name: str, tys: [TypeRef], rv: TypeRef) -> ValueRef { @@ -44,25 +47,35 @@ fn declare_upcalls(_tn: type_names, tydesc_type: TypeRef, let d = bind decl(llmod, _, _, _); let dv = bind decl(llmod, _, _, T_void()); - ret @{_fail: dv("fail", [T_ptr(T_i8()), T_ptr(T_i8()), T_size_t()]), + let int_t = T_int(targ_cfg); + let size_t = T_size_t(targ_cfg); + let opaque_vec_t = T_opaque_vec(targ_cfg); + + ret @{_fail: dv("fail", [T_ptr(T_i8()), + T_ptr(T_i8()), + size_t]), malloc: - d("malloc", [T_size_t(), T_ptr(tydesc_type)], T_ptr(T_i8())), - free: dv("free", [T_ptr(T_i8()), T_int()]), + d("malloc", [size_t, T_ptr(tydesc_type)], + T_ptr(T_i8())), + free: dv("free", [T_ptr(T_i8()), int_t]), shared_malloc: - d("shared_malloc", [T_size_t(), T_ptr(tydesc_type)], + d("shared_malloc", [size_t, T_ptr(tydesc_type)], T_ptr(T_i8())), shared_free: dv("shared_free", [T_ptr(T_i8())]), - mark: d("mark", [T_ptr(T_i8())], T_int()), + mark: d("mark", [T_ptr(T_i8())], int_t), get_type_desc: d("get_type_desc", - [T_ptr(T_nil()), T_size_t(), T_size_t(), T_size_t(), - T_ptr(T_ptr(tydesc_type)), T_int()], T_ptr(tydesc_type)), + [T_ptr(T_nil()), size_t, + size_t, size_t, + T_ptr(T_ptr(tydesc_type)), int_t], + T_ptr(tydesc_type)), vec_grow: - dv("vec_grow", [T_ptr(T_ptr(T_opaque_vec())), T_int()]), + dv("vec_grow", [T_ptr(T_ptr(opaque_vec_t)), + int_t]), vec_push: dv("vec_push", - [T_ptr(T_ptr(T_opaque_vec())), T_ptr(tydesc_type), - T_ptr(T_i8())]), + [T_ptr(T_ptr(opaque_vec_t)), T_ptr(tydesc_type), + T_ptr(T_i8())]), cmp_type: dv("cmp_type", [T_ptr(T_i1()), T_ptr(tydesc_type), @@ -72,13 +85,13 @@ fn declare_upcalls(_tn: type_names, tydesc_type: TypeRef, dv("log_type", [T_ptr(tydesc_type), T_ptr(T_i8()), T_i32()]), dynastack_mark: d("dynastack_mark", [], T_ptr(T_i8())), dynastack_alloc: - d("dynastack_alloc_2", [T_size_t(), T_ptr(tydesc_type)], + d("dynastack_alloc_2", [size_t, T_ptr(tydesc_type)], T_ptr(T_i8())), dynastack_free: dv("dynastack_free", [T_ptr(T_i8())]), alloc_c_stack: d("alloc_c_stack", [T_size_t()], T_ptr(T_i8())), call_c_stack: d("call_c_stack", [T_ptr(T_fn([], T_int())), T_ptr(T_i8())], - T_int()), + int_t), call_c_stack_i64: d("call_c_stack_i64", [T_ptr(T_fn([], T_int())), T_ptr(T_i8())], T_i64()), diff --git a/src/comp/middle/gc.rs b/src/comp/middle/gc.rs index be5376bc2b6..833864a8e7a 100644 --- a/src/comp/middle/gc.rs +++ b/src/comp/middle/gc.rs @@ -29,6 +29,7 @@ fn add_global(ccx: @crate_ctxt, llval: ValueRef, name: str) -> ValueRef { fn add_gc_root(cx: @block_ctxt, llval: ValueRef, ty: ty::t) -> @block_ctxt { let bcx = cx; + let ccx = bcx_ccx(cx); if !type_is_gc_relevant(bcx_tcx(cx), ty) || ty::type_has_dynamic_size(bcx_tcx(cx), ty) { ret bcx; @@ -61,10 +62,12 @@ fn add_gc_root(cx: @block_ctxt, llval: ValueRef, ty: ty::t) -> @block_ctxt { gc_cx.next_tydesc_num += 1u; let lldestindex = - add_global(bcx_ccx(bcx), C_struct([C_int(0), C_uint(number)]), + add_global(bcx_ccx(bcx), C_struct([C_int(ccx, 0), + C_uint(ccx, number)]), "rust_gc_tydesc_dest_index"); let llsrcindex = - add_global(bcx_ccx(bcx), C_struct([C_int(1), C_uint(number)]), + add_global(bcx_ccx(bcx), C_struct([C_int(ccx, 1), + C_uint(ccx, number)]), "rust_gc_tydesc_src_index"); lldestindex = lll::LLVMConstPointerCast(lldestindex, T_ptr(T_i8())); @@ -85,7 +88,7 @@ fn add_gc_root(cx: @block_ctxt, llval: ValueRef, ty: ty::t) -> @block_ctxt { // Static type descriptor. let llstaticgcmeta = - add_global(bcx_ccx(bcx), C_struct([C_int(2), lltydesc]), + add_global(bcx_ccx(bcx), C_struct([C_int(ccx, 2), lltydesc]), "rust_gc_tydesc_static_gc_meta"); let llstaticgcmetaptr = lll::LLVMConstPointerCast(llstaticgcmeta, T_ptr(T_i8())); diff --git a/src/comp/middle/trans.rs b/src/comp/middle/trans.rs index 138d3a3bbd5..f4009a929e3 100644 --- a/src/comp/middle/trans.rs +++ b/src/comp/middle/trans.rs @@ -161,7 +161,7 @@ fn type_of_inner(cx: @crate_ctxt, sp: span, t: ty::t) ty::ty_vec(mt) { let mt_ty = mt.ty; if ty::type_has_dynamic_size(cx.tcx, mt_ty) { - T_ptr(T_opaque_vec(cx)) + T_ptr(cx.opaque_vec_type) } else { // should be unnecessary check non_ty_var(cx, mt_ty); @@ -359,7 +359,7 @@ fn trans_native_call(cx: @block_ctxt, externs: hashmap, get_simple_extern_fn(cx, externs, llmod, name, n); let call_args: [ValueRef] = []; for a: ValueRef in args { - call_args += [ZExtOrBitCast(cx, a, T_int(bcx_ccx(cx)))]; + call_args += [ZExtOrBitCast(cx, a, bcx_ccx(cx).int_type)]; } ret Call(cx, llnative, call_args); } @@ -2616,7 +2616,7 @@ fn trans_for(cx: @block_ctxt, local: @ast::local, seq: @ast::expr, let next_cx = new_sub_block_ctxt(cx, "next"); let seq_ty = ty::expr_ty(bcx_tcx(cx), seq); let {bcx: bcx, val: seq} = trans_temp_expr(cx, seq); - let seq = PointerCast(bcx, seq, T_ptr(T_opaque_vec(ccx))); + let seq = PointerCast(bcx, seq, T_ptr(ccx.opaque_vec_type)); let fill = tvec::get_fill(bcx, seq); if ty::type_is_str(bcx_tcx(bcx), seq_ty) { fill = Sub(bcx, fill, C_int(ccx, 1)); @@ -6075,7 +6075,7 @@ fn fill_crate_map(ccx: @crate_ctxt, map: ValueRef) { llvm::LLVMSetLinkage(map, lib::llvm::LLVMExternalLinkage as llvm::Linkage); llvm::LLVMSetInitializer(map, - C_struct([p2i(create_module_map(ccx)), + C_struct([p2i(ccx, create_module_map(ccx)), C_array(ccx.int_type, subcrates)])); ret map; >>>>>>> work on making the size of ints depend on the target arch @@ -6129,15 +6129,16 @@ fn trans_crate(sess: session::session, crate: @ast::crate, tcx: ty::ctxt, let _: () = str::as_buf(sess.get_targ_cfg().target_strs.target_triple, {|buf| llvm::LLVMSetTarget(llmod, buf) }); + let targ_cfg = sess.get_targ_cfg(); let td = mk_target_data(sess.get_targ_cfg().target_strs.data_layout); let tn = mk_type_names(); let intrinsics = declare_intrinsics(llmod); - let int_type = T_int(sess.get_targ_cfg().arch); - let float_type = T_float(sess.get_targ_cfg().arch); - let task_type = T_task(sess.get_targ_cfg().arch); + let int_type = T_int(targ_cfg); + let float_type = T_float(targ_cfg); + let task_type = T_task(targ_cfg); let taskptr_type = T_ptr(task_type); tn.associate("taskptr", taskptr_type); - let tydesc_type = T_tydesc(taskptr_type); + let tydesc_type = T_tydesc(targ_cfg, taskptr_type); tn.associate("tydesc", tydesc_type); let hasher = ty::hash_ty; let eqer = ty::eq_ty; @@ -6184,12 +6185,14 @@ fn trans_crate(sess: session::session, crate: @ast::crate, tcx: ty::ctxt, mutable n_real_glues: 0u, fn_times: @mutable []}, upcalls: - upcall::declare_upcalls(tn, tydesc_type, llmod), + upcall::declare_upcalls(targ_cfg, tn, tydesc_type, + llmod), rust_object_type: T_rust_object(), tydesc_type: tydesc_type, int_type: int_type, float_type: float_type, task_type: task_type, + opaque_vec_type: T_opaque_vec(targ_cfg), builder: BuilderRef_res(llvm::LLVMCreateBuilder()), shape_cx: shape::mk_ctxt(llmod), gc_cx: gc::mk_ctxt(), diff --git a/src/comp/middle/trans_alt.rs b/src/comp/middle/trans_alt.rs index 8ac7a6e8a23..517192d580d 100644 --- a/src/comp/middle/trans_alt.rs +++ b/src/comp/middle/trans_alt.rs @@ -44,6 +44,7 @@ tag opt_result { range_result(result, result); } fn trans_opt(bcx: @block_ctxt, o: opt) -> opt_result { + let ccx = bcx_ccx(bcx); alt o { lit(l) { alt l.node { @@ -56,11 +57,11 @@ fn trans_opt(bcx: @block_ctxt, o: opt) -> opt_result { } _ { ret single_result( - rslt(bcx, trans::trans_crate_lit(bcx_ccx(bcx), *l))); + rslt(bcx, trans::trans_crate_lit(ccx, *l))); } } } - var(id, _) { ret single_result(rslt(bcx, C_int(id as int))); } + var(id, _) { ret single_result(rslt(bcx, C_int(ccx, id as int))); } range(l1, l2) { let cell1 = trans::empty_dest_cell(); let cell2 = trans::empty_dest_cell(); @@ -257,8 +258,8 @@ fn extract_variant_args(bcx: @block_ctxt, pat_id: ast::node_id, vec::len(ty::tag_variant_with_id(ccx.tcx, vdefs.tg, vdefs.var).args); if size > 0u && vec::len(variants) != 1u { let tagptr = - PointerCast(bcx, val, trans_common::T_opaque_tag_ptr(ccx.tn)); - blobptr = GEP(bcx, tagptr, [C_int(0), C_int(1)]); + PointerCast(bcx, val, trans_common::T_opaque_tag_ptr(ccx)); + blobptr = GEP(bcx, tagptr, [C_int(ccx, 0), C_int(ccx, 1)]); } let i = 0u; let vdefs_tg = vdefs.tg; @@ -439,7 +440,8 @@ fn compile_submatch(bcx: @block_ctxt, m: match, vals: [ValueRef], f: mk_fail, let box = Load(bcx, val); let unboxed = InBoundsGEP(bcx, box, - [C_int(0), C_int(back::abi::box_rc_field_body)]); + [C_int(ccx, 0), + C_int(ccx, back::abi::box_rc_field_body)]); compile_submatch(bcx, enter_box(m, col, val), [unboxed] + vals_left, f, exits); ret; @@ -465,8 +467,9 @@ fn compile_submatch(bcx: @block_ctxt, m: match, vals: [ValueRef], f: mk_fail, } else { let tagptr = PointerCast(bcx, val, - trans_common::T_opaque_tag_ptr(ccx.tn)); - let discrimptr = GEP(bcx, tagptr, [C_int(0), C_int(0)]); + trans_common::T_opaque_tag_ptr(ccx)); + let discrimptr = GEP(bcx, tagptr, [C_int(ccx, 0), + C_int(ccx, 0)]); test_val = Load(bcx, discrimptr); kind = switch; } @@ -505,7 +508,7 @@ fn compile_submatch(bcx: @block_ctxt, m: match, vals: [ValueRef], f: mk_fail, // holding a corrupted value (when the compiler is optimized). // This can be removed after our next LLVM upgrade. val_ty(sw); - } else { sw = C_int(0); } // Placeholder for when not using a switch + } else { sw = C_int(ccx, 0); } // Placeholder for when not using a switch // Compile subtrees for each option for opt: opt in opts { @@ -736,7 +739,8 @@ fn bind_irrefutable_pat(bcx: @block_ctxt, pat: @ast::pat, val: ValueRef, let box = Load(bcx, val); let unboxed = InBoundsGEP(bcx, box, - [C_int(0), C_int(back::abi::box_rc_field_body)]); + [C_int(ccx, 0), + C_int(ccx, 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_common.rs b/src/comp/middle/trans_common.rs index 0121b848a4c..8e289d756a3 100644 --- a/src/comp/middle/trans_common.rs +++ b/src/comp/middle/trans_common.rs @@ -123,6 +123,7 @@ type crate_ctxt = int_type: TypeRef, float_type: TypeRef, task_type: TypeRef, + opaque_vec_type: TypeRef, builder: BuilderRef_res, shape_cx: shape::ctxt, gc_cx: gc::ctxt, @@ -490,26 +491,26 @@ fn T_f64() -> TypeRef { ret llvm::LLVMDoubleType(); } fn T_bool() -> TypeRef { ret T_i1(); } -fn T_int(arch: session::arch) -> TypeRef { - ret alt arch { - arch_x86 { T_i32() } - arch_x86_64 { T_i64() } - arch_arm { T_i32() } +fn T_int(targ_cfg: @session::config) -> TypeRef { + ret alt targ_cfg.arch { + session::arch_x86. { T_i32() } + session::arch_x86_64. { T_i64() } + session::arch_arm. { T_i32() } }; } -fn T_float(arch: session::arch) -> TypeRef { - ret alt arch { - arch_x86 { T_f64() } - arch_x86_64 { T_f64() } - arch_arm { T_f64() } +fn T_float(targ_cfg: @session::config) -> TypeRef { + ret alt targ_cfg.arch { + session::arch_x86. { T_f64() } + session::arch_x86_64. { T_f64() } + session::arch_arm. { T_f64() } }; } fn T_char() -> TypeRef { ret T_i32(); } -fn T_size_t(cx: @crate_ctxt) -> TypeRef { - ret cx.int_type; +fn T_size_t(targ_cfg: @session::config) -> TypeRef { + ret T_int(targ_cfg); } fn T_fn(inputs: [TypeRef], output: TypeRef) -> TypeRef { @@ -553,7 +554,7 @@ fn T_rust_object() -> TypeRef { ret t; } -fn T_task(arch: session::arch) -> TypeRef { +fn T_task(targ_cfg: @session::config) -> TypeRef { let t = T_named_struct("task"); // Refcount @@ -567,7 +568,7 @@ fn T_task(arch: session::arch) -> TypeRef { // Domain pointer // Crate cache pointer - let t_int = T_int(arch); + let t_int = T_int(targ_cfg); let elems = [t_int, t_int, t_int, t_int, t_int, t_int, t_int, t_int]; @@ -603,7 +604,7 @@ fn T_cmp_glue_fn(cx: @crate_ctxt) -> TypeRef { ret t; } -fn T_tydesc(cx: @crate_ctxt) -> TypeRef { +fn T_tydesc(targ_cfg: @session::config) -> TypeRef { let tydesc = T_named_struct("tydesc"); let tydescpp = T_ptr(T_ptr(tydesc)); let pvoid = T_ptr(T_i8()); @@ -614,29 +615,35 @@ fn T_tydesc(cx: @crate_ctxt) -> TypeRef { T_ptr(T_fn([T_ptr(T_i1()), T_ptr(tydesc), tydescpp, pvoid, pvoid, T_i8()], T_void())); + let int_type = T_int(targ_cfg); let elems = - [tydescpp, cx.int_type, cx.int_type, + [tydescpp, int_type, int_type, glue_fn_ty, glue_fn_ty, glue_fn_ty, T_ptr(T_i8()), glue_fn_ty, glue_fn_ty, glue_fn_ty, cmp_glue_fn_ty, - T_ptr(T_i8()), T_ptr(T_i8()), cx.int_type, cx.int_type]; + T_ptr(T_i8()), T_ptr(T_i8()), int_type, int_type]; set_struct_body(tydesc, elems); ret tydesc; } fn T_array(t: TypeRef, n: uint) -> TypeRef { ret llvm::LLVMArrayType(t, n); } - // Interior vector. // // TODO: Support user-defined vector sizes. -fn T_vec(cx: @crate_ctxt, t: TypeRef) -> TypeRef { - ret T_struct([cx.int_type, // fill - cx.int_type, // alloc +fn T_vec2(targ_cfg: @session::config, t: TypeRef) -> TypeRef { + ret T_struct([T_int(targ_cfg), // fill + T_int(targ_cfg), // alloc T_array(t, 0u)]); // elements } +fn T_vec(ccx: @crate_ctxt, t: TypeRef) -> TypeRef { + ret T_vec2(ccx.sess.get_targ_cfg(), t); +} + // Note that the size of this one is in bytes. -fn T_opaque_vec(cx: @crate_ctxt) -> TypeRef { ret T_vec(cx, T_i8()); } +fn T_opaque_vec(targ_cfg: @session::config) -> TypeRef { + ret T_vec2(targ_cfg, T_i8()); +} fn T_box(cx: @crate_ctxt, t: TypeRef) -> TypeRef { ret T_struct([cx.int_type, t]); diff --git a/src/comp/middle/trans_objects.rs b/src/comp/middle/trans_objects.rs index ea3947a32ed..526f60dd88a 100644 --- a/src/comp/middle/trans_objects.rs +++ b/src/comp/middle/trans_objects.rs @@ -70,8 +70,8 @@ fn trans_obj(cx: @local_ctxt, sp: span, ob: ast::_obj, ctor_id: ast::node_id, // Grab onto the first and second elements of the pair. // abi::obj_field_vtbl and abi::obj_field_box simply specify words 0 and 1 // of 'pair'. - let pair_vtbl = GEP(bcx, pair, [C_int(0), C_int(abi::obj_field_vtbl)]); - let pair_box = GEP(bcx, pair, [C_int(0), C_int(abi::obj_field_box)]); + let pair_vtbl = GEPi(bcx, pair, [0, abi::obj_field_vtbl]); + let pair_box = GEPi(bcx, pair, [0, abi::obj_field_box]); // Make a vtable for this object: a static array of pointers to functions. // It will be located in the read-only memory of the executable we're @@ -375,9 +375,9 @@ fn trans_anon_obj(bcx: @block_ctxt, sp: span, anon_obj: ast::anon_obj, box = PointerCast(bcx, box, llbox_ty); } let pair = trans::get_dest_addr(dest); - let pair_vtbl = GEP(bcx, pair, [C_int(0), C_int(abi::obj_field_vtbl)]); + let pair_vtbl = GEPi(bcx, pair, [0, abi::obj_field_vtbl]); Store(bcx, vtbl, pair_vtbl); - let pair_box = GEP(bcx, pair, [C_int(0), C_int(abi::obj_field_box)]); + let pair_box = GEPi(bcx, pair, [0, abi::obj_field_box]); Store(bcx, box, pair_box); ret bcx; } @@ -627,7 +627,7 @@ fn process_bkwding_mthd(cx: @local_ctxt, sp: span, m: @ty::method, PointerCast(bcx, fcx.llenv, T_ptr(T_struct([cx.ccx.rust_object_type, T_ptr(cx.ccx.rust_object_type)]))); - let llself_obj_ptr = GEP(bcx, llenv, [C_int(0), C_int(1)]); + let llself_obj_ptr = GEPi(bcx, llenv, [0, 1]); llself_obj_ptr = Load(bcx, llself_obj_ptr); // Cast it back to pointer-to-object-type, so LLVM won't complain. @@ -663,12 +663,12 @@ fn process_bkwding_mthd(cx: @local_ctxt, sp: span, m: @ty::method, let vtbl_type = T_ptr(T_array(T_ptr(T_nil()), ix + 1u)); let llouter_obj_vtbl = - GEP(bcx, llself_obj_ptr, [C_int(0), C_int(abi::obj_field_vtbl)]); + GEPi(bcx, llself_obj_ptr, [0, abi::obj_field_vtbl]); llouter_obj_vtbl = Load(bcx, llouter_obj_vtbl); llouter_obj_vtbl = PointerCast(bcx, llouter_obj_vtbl, vtbl_type); let llouter_mthd = - GEP(bcx, llouter_obj_vtbl, [C_int(0), C_int(ix as int)]); + GEPi(bcx, llouter_obj_vtbl, [0, ix as int]); // Set up the outer method to be called. let llouter_mthd_ty = type_of_meth(bcx_ccx(bcx), sp, m, ty_params); @@ -746,16 +746,16 @@ fn process_fwding_mthd(cx: @local_ctxt, sp: span, m: @ty::method, // First, grab the box out of the self_obj. It contains a refcount and a // body. let llself_obj_box = - GEP(bcx, llself_obj_ptr, [C_int(0), C_int(abi::obj_field_box)]); + GEPi(bcx, llself_obj_ptr, [0, abi::obj_field_box]); llself_obj_box = Load(bcx, llself_obj_box); let ccx = bcx_ccx(bcx); - let llbox_ty = T_opaque_obj_ptr(*ccx); + let llbox_ty = T_opaque_obj_ptr(ccx); llself_obj_box = PointerCast(bcx, llself_obj_box, llbox_ty); // Now, reach into the box and grab the body. let llself_obj_body = - GEP(bcx, llself_obj_box, [C_int(0), C_int(abi::box_rc_field_body)]); + GEPi(bcx, llself_obj_box, [0, abi::box_rc_field_body]); // Now, we need to figure out exactly what type the body is supposed to be // cast to. @@ -784,11 +784,11 @@ fn process_fwding_mthd(cx: @local_ctxt, sp: span, m: @ty::method, // method's entry out of the vtable so that the forwarding function can // call it. let llinner_obj_vtbl = - GEP(bcx, llinner_obj.val, [C_int(0), C_int(abi::obj_field_vtbl)]); + GEPi(bcx, llinner_obj.val, [0, abi::obj_field_vtbl]); llinner_obj_vtbl = Load(bcx, llinner_obj_vtbl); let llinner_obj_body = - GEP(bcx, llinner_obj.val, [C_int(0), C_int(abi::obj_field_box)]); + GEPi(bcx, llinner_obj.val, [0, abi::obj_field_box]); llinner_obj_body = Load(bcx, llinner_obj_body); // Get the index of the method we want. @@ -809,7 +809,7 @@ fn process_fwding_mthd(cx: @local_ctxt, sp: span, m: @ty::method, llinner_obj_vtbl = PointerCast(bcx, llinner_obj_vtbl, vtbl_type); let llorig_mthd = - GEP(bcx, llinner_obj_vtbl, [C_int(0), C_int(ix as int)]); + GEPi(bcx, llinner_obj_vtbl, [0, ix as int]); // Set up the original method to be called. let llorig_mthd_ty = type_of_meth(bcx_ccx(bcx), sp, m, ty_params); @@ -920,18 +920,18 @@ fn populate_self_stack(bcx: @block_ctxt, self_stack: ValueRef, inner_obj_body: ValueRef) -> ValueRef { // Drop the outer obj into the second slot. - let self_pair_ptr = GEP(bcx, self_stack, [C_int(0), C_int(1)]); + let self_pair_ptr = GEPi(bcx, self_stack, [0, 1]); Store(bcx, outer_obj, self_pair_ptr); // Drop in the backwarding vtbl. - let wrapper_pair = GEP(bcx, self_stack, [C_int(0), C_int(0)]); - let wrapper_vtbl_ptr = GEP(bcx, wrapper_pair, [C_int(0), C_int(0)]); + let wrapper_pair = GEPi(bcx, self_stack, [0, 0]); + let wrapper_vtbl_ptr = GEPi(bcx, wrapper_pair, [0, 0]); let backwarding_vtbl_cast = PointerCast(bcx, backwarding_vtbl, T_ptr(T_empty_struct())); Store(bcx, backwarding_vtbl_cast, wrapper_vtbl_ptr); // Drop in the inner obj body. - let wrapper_body_ptr = GEP(bcx, wrapper_pair, [C_int(0), C_int(1)]); + let wrapper_body_ptr = GEPi(bcx, wrapper_pair, [0, 1]); Store(bcx, inner_obj_body, wrapper_body_ptr); ret self_stack; diff --git a/src/comp/middle/trans_vec.rs b/src/comp/middle/trans_vec.rs index 124c1096927..dbb49b48849 100644 --- a/src/comp/middle/trans_vec.rs +++ b/src/comp/middle/trans_vec.rs @@ -28,14 +28,17 @@ fn pointer_add(bcx: @block_ctxt, ptr: ValueRef, bytes: ValueRef) -> ValueRef { } fn alloc_raw(bcx: @block_ctxt, fill: ValueRef, alloc: ValueRef) -> result { - let llvecty = T_opaque_vec(); - let vecsize = Add(bcx, alloc, llsize_of(llvecty)); + let ccx = bcx_ccx(bcx); + let llvecty = ccx.opaque_vec_type; + 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(0), C_uint(abi::vec_elt_fill)])); + InBoundsGEP(bcx, vecptr, [C_int(ccx, 0), + C_uint(ccx, abi::vec_elt_fill)])); Store(bcx, alloc, - InBoundsGEP(bcx, vecptr, [C_int(0), C_uint(abi::vec_elt_alloc)])); + InBoundsGEP(bcx, vecptr, [C_int(ccx, 0), + C_uint(ccx, abi::vec_elt_alloc)])); ret {bcx: bcx, val: vecptr}; } @@ -47,13 +50,18 @@ type alloc_result = llunitty: TypeRef}; fn alloc(bcx: @block_ctxt, vec_ty: ty::t, elts: uint) -> alloc_result { + let ccx = bcx_ccx(bcx); 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); + let llvecty = T_vec(ccx, llunitty); let {bcx: bcx, val: unit_sz} = size_of(bcx, unit_ty); - let fill = Mul(bcx, C_uint(elts), unit_sz); - let alloc = if elts < 4u { Mul(bcx, C_int(4), unit_sz) } else { fill }; + 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 + }; let {bcx: bcx, val: vptr} = alloc_raw(bcx, fill, alloc); let vptr = PointerCast(bcx, vptr, T_ptr(llvecty)); @@ -65,14 +73,16 @@ fn alloc(bcx: @block_ctxt, vec_ty: ty::t, elts: uint) -> alloc_result { } fn duplicate(bcx: @block_ctxt, vptr: ValueRef, vec_ty: ty::t) -> result { + let ccx = bcx_ccx(bcx); let fill = get_fill(bcx, vptr); - let size = Add(bcx, fill, llsize_of(T_opaque_vec())); + let size = Add(bcx, fill, llsize_of(ccx, ccx.opaque_vec_type)); let {bcx: bcx, val: newptr} = 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(0), C_uint(abi::vec_elt_alloc)])); + InBoundsGEP(bcx, newptr, [C_int(ccx, 0), + C_uint(ccx, abi::vec_elt_alloc)])); if ty::type_needs_drop(bcx_tcx(bcx), unit_ty) { bcx = iter_vec(bcx, newptr, vec_ty, trans::take_ty); } @@ -95,6 +105,7 @@ fn make_free_glue(bcx: @block_ctxt, vptr: ValueRef, vec_ty: ty::t) -> fn trans_vec(bcx: @block_ctxt, args: [@ast::expr], id: ast::node_id, dest: dest) -> @block_ctxt { + let ccx = bcx_ccx(bcx); if dest == trans::ignore { for arg in args { bcx = trans::trans_expr(bcx, arg, trans::ignore); @@ -115,8 +126,8 @@ fn trans_vec(bcx: @block_ctxt, args: [@ast::expr], id: ast::node_id, let i = 0u, temp_cleanups = [vptr]; for e in args { let lleltptr = if ty::type_has_dynamic_size(bcx_tcx(bcx), unit_ty) { - InBoundsGEP(bcx, dataptr, [Mul(bcx, C_uint(i), llunitsz)]) - } else { InBoundsGEP(bcx, dataptr, [C_uint(i)]) }; + InBoundsGEP(bcx, dataptr, [Mul(bcx, C_uint(ccx, i), llunitsz)]) + } else { InBoundsGEP(bcx, dataptr, [C_uint(ccx, i)]) }; bcx = trans::trans_expr_save_in(bcx, e, lleltptr); add_clean_temp_mem(bcx, lleltptr, unit_ty); temp_cleanups += [lleltptr]; @@ -131,21 +142,23 @@ fn trans_str(bcx: @block_ctxt, s: str, dest: dest) -> @block_ctxt { let {bcx: bcx, val: sptr, _} = alloc(bcx, ty::mk_str(bcx_tcx(bcx)), veclen); - let llcstr = C_cstr(bcx_ccx(bcx), s); + let ccx = bcx_ccx(bcx); + let llcstr = C_cstr(ccx, s); let bcx = call_memmove(bcx, get_dataptr(bcx, sptr, T_i8()), llcstr, - C_uint(veclen)).bcx; + C_uint(ccx, veclen)).bcx; ret trans::store_in_dest(bcx, sptr, dest); } fn trans_append(cx: @block_ctxt, vec_ty: ty::t, lhsptr: ValueRef, rhs: ValueRef) -> @block_ctxt { // Cast to opaque interior vector types if necessary. + let ccx = bcx_ccx(cx); let unit_ty = ty::sequence_element_type(bcx_tcx(cx), vec_ty); let dynamic = ty::type_has_dynamic_size(bcx_tcx(cx), unit_ty); if dynamic { - lhsptr = PointerCast(cx, lhsptr, T_ptr(T_ptr(T_opaque_vec()))); - rhs = PointerCast(cx, rhs, T_ptr(T_opaque_vec())); + lhsptr = PointerCast(cx, lhsptr, T_ptr(T_ptr(ccx.opaque_vec_type))); + rhs = PointerCast(cx, rhs, T_ptr(ccx.opaque_vec_type)); } let strings = alt ty::struct(bcx_tcx(cx), vec_ty) { ty::ty_str. { true } @@ -160,8 +173,9 @@ fn trans_append(cx: @block_ctxt, vec_ty: ty::t, lhsptr: ValueRef, let lfill = get_fill(bcx, lhs); let rfill = get_fill(bcx, rhs); let new_fill = Add(bcx, lfill, rfill); - if strings { new_fill = Sub(bcx, new_fill, C_int(1)); } - let opaque_lhs = PointerCast(bcx, lhsptr, T_ptr(T_ptr(T_opaque_vec()))); + 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))); Call(bcx, bcx_ccx(cx).upcalls.vec_grow, [opaque_lhs, new_fill]); // Was overwritten if we resized @@ -170,7 +184,7 @@ fn trans_append(cx: @block_ctxt, vec_ty: ty::t, lhsptr: ValueRef, let lhs_data = get_dataptr(bcx, lhs, llunitty); let lhs_off = lfill; - if strings { lhs_off = Sub(bcx, lhs_off, C_int(1)); } + if strings { lhs_off = Sub(bcx, lhs_off, C_int(ccx, 1)); } let write_ptr = pointer_add(bcx, lhs_data, lhs_off); let write_ptr_ptr = do_spill_noroot(bcx, write_ptr); let bcx = iter_vec_raw(bcx, rhs, vec_ty, rfill, @@ -181,7 +195,7 @@ fn trans_append(cx: @block_ctxt, vec_ty: ty::t, lhsptr: ValueRef, copy_val(bcx, INIT, write_ptr, load_if_immediate(bcx, addr, unit_ty), unit_ty); - let incr = dynamic ? unit_sz : C_int(1); + let incr = dynamic ? unit_sz : C_int(ccx, 1); Store(bcx, InBoundsGEP(bcx, write_ptr, [incr]), write_ptr_ptr); ret bcx; @@ -191,12 +205,14 @@ fn trans_append(cx: @block_ctxt, vec_ty: ty::t, lhsptr: ValueRef, fn trans_append_literal(bcx: @block_ctxt, vptrptr: ValueRef, vec_ty: ty::t, vals: [@ast::expr]) -> @block_ctxt { + let ccx = bcx_ccx(bcx); let elt_ty = ty::sequence_element_type(bcx_tcx(bcx), vec_ty); let ti = none; let {bcx: bcx, val: td} = get_tydesc(bcx, elt_ty, false, tps_normal, ti).result; trans::lazily_emit_tydesc_glue(bcx, abi::tydesc_field_take_glue, ti); - let opaque_v = PointerCast(bcx, vptrptr, T_ptr(T_ptr(T_opaque_vec()))); + let opaque_v = PointerCast(bcx, vptrptr, + T_ptr(T_ptr(ccx.opaque_vec_type))); for val in vals { let {bcx: e_bcx, val: elt} = trans::trans_temp_expr(bcx, val); bcx = e_bcx; @@ -211,6 +227,7 @@ fn trans_append_literal(bcx: @block_ctxt, vptrptr: ValueRef, vec_ty: ty::t, fn trans_add(bcx: @block_ctxt, vec_ty: ty::t, lhs: ValueRef, rhs: ValueRef, dest: dest) -> @block_ctxt { + let ccx = bcx_ccx(bcx); let strings = alt ty::struct(bcx_tcx(bcx), vec_ty) { ty::ty_str. { true } ty::ty_vec(_) { false } @@ -220,11 +237,11 @@ fn trans_add(bcx: @block_ctxt, vec_ty: ty::t, lhs: ValueRef, let {bcx: bcx, val: llunitsz} = size_of(bcx, unit_ty); let lhs_fill = get_fill(bcx, lhs); - if strings { lhs_fill = Sub(bcx, lhs_fill, C_int(1)); } + if strings { lhs_fill = Sub(bcx, lhs_fill, C_int(ccx, 1)); } let rhs_fill = get_fill(bcx, rhs); 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))); + new_vec_ptr = PointerCast(bcx, new_vec_ptr, T_ptr(T_vec(ccx, llunitty))); let write_ptr_ptr = do_spill_noroot (bcx, get_dataptr(bcx, new_vec_ptr, llunitty)); @@ -232,13 +249,14 @@ fn trans_add(bcx: @block_ctxt, vec_ty: ty::t, lhs: ValueRef, bind fn (bcx: @block_ctxt, addr: ValueRef, _ty: ty::t, write_ptr_ptr: ValueRef, unit_ty: ty::t, llunitsz: ValueRef) -> @block_ctxt { + 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 = ty::type_has_dynamic_size(bcx_tcx(bcx), unit_ty) ? - llunitsz : C_int(1); + llunitsz : C_int(ccx, 1); Store(bcx, InBoundsGEP(bcx, write_ptr, [incr]), write_ptr_ptr); ret bcx; @@ -255,10 +273,11 @@ type iter_vec_block = block(@block_ctxt, ValueRef, ty::t) -> @block_ctxt; fn iter_vec_raw(bcx: @block_ctxt, vptr: ValueRef, vec_ty: ty::t, fill: ValueRef, f: iter_vec_block) -> @block_ctxt { + let ccx = bcx_ccx(bcx); let unit_ty = ty::sequence_element_type(bcx_tcx(bcx), vec_ty); let llunitty = type_of_or_i8(bcx, unit_ty); let {bcx: bcx, val: unit_sz} = size_of(bcx, unit_ty); - vptr = PointerCast(bcx, vptr, T_ptr(T_vec(llunitty))); + vptr = PointerCast(bcx, vptr, T_ptr(T_vec(ccx, llunitty))); let data_ptr = get_dataptr(bcx, vptr, llunitty); // Calculate the last pointer address we want to handle. @@ -279,7 +298,7 @@ fn iter_vec_raw(bcx: @block_ctxt, vptr: ValueRef, vec_ty: ty::t, let increment = if ty::type_has_dynamic_size(bcx_tcx(bcx), unit_ty) { unit_sz - } else { C_int(1) }; + } else { C_int(ccx, 1) }; AddIncomingToPhi(data_ptr, InBoundsGEP(body_cx, data_ptr, [increment]), body_cx.llbb); Br(body_cx, header_cx.llbb); @@ -288,7 +307,8 @@ fn iter_vec_raw(bcx: @block_ctxt, vptr: ValueRef, vec_ty: ty::t, fn iter_vec(bcx: @block_ctxt, vptr: ValueRef, vec_ty: ty::t, f: iter_vec_block) -> @block_ctxt { - vptr = PointerCast(bcx, vptr, T_ptr(T_opaque_vec())); + let ccx = bcx_ccx(bcx); + vptr = PointerCast(bcx, vptr, T_ptr(ccx.opaque_vec_type)); ret iter_vec_raw(bcx, vptr, vec_ty, get_fill(bcx, vptr), f); }