Auto merge of #27981 - dotdash:gepi, r=brson
This commit is contained in:
commit
5c630a61c6
11 changed files with 52 additions and 57 deletions
|
@ -188,7 +188,6 @@ pub use self::TransBindingMode::*;
|
|||
use self::Opt::*;
|
||||
use self::FailureHandler::*;
|
||||
|
||||
use back::abi;
|
||||
use llvm::{ValueRef, BasicBlockRef};
|
||||
use middle::check_match::StaticInliner;
|
||||
use middle::check_match;
|
||||
|
@ -731,9 +730,8 @@ fn bind_subslice_pat(bcx: Block,
|
|||
let slice_ty = bcx.tcx().mk_imm_ref(bcx.tcx().mk_region(ty::ReStatic),
|
||||
bcx.tcx().mk_slice(unit_ty));
|
||||
let scratch = rvalue_scratch_datum(bcx, slice_ty, "");
|
||||
Store(bcx, slice_begin,
|
||||
GEPi(bcx, scratch.val, &[0, abi::FAT_PTR_ADDR]));
|
||||
Store(bcx, slice_len, GEPi(bcx, scratch.val, &[0, abi::FAT_PTR_EXTRA]));
|
||||
Store(bcx, slice_begin, expr::get_dataptr(bcx, scratch.val));
|
||||
Store(bcx, slice_len, expr::get_meta(bcx, scratch.val));
|
||||
scratch.val
|
||||
}
|
||||
|
||||
|
@ -887,9 +885,9 @@ fn compare_values<'blk, 'tcx>(cx: Block<'blk, 'tcx>,
|
|||
&format!("comparison of `{}`", rhs_t),
|
||||
StrEqFnLangItem);
|
||||
let lhs_data = Load(cx, expr::get_dataptr(cx, lhs));
|
||||
let lhs_len = Load(cx, expr::get_len(cx, lhs));
|
||||
let lhs_len = Load(cx, expr::get_meta(cx, lhs));
|
||||
let rhs_data = Load(cx, expr::get_dataptr(cx, rhs));
|
||||
let rhs_len = Load(cx, expr::get_len(cx, rhs));
|
||||
let rhs_len = Load(cx, expr::get_meta(cx, rhs));
|
||||
callee::trans_lang_call(cx, did, &[lhs_data, lhs_len, rhs_data, rhs_len], None, debug_loc)
|
||||
}
|
||||
|
||||
|
@ -910,15 +908,15 @@ fn compare_values<'blk, 'tcx>(cx: Block<'blk, 'tcx>,
|
|||
let ty_str_slice = cx.tcx().mk_static_str();
|
||||
|
||||
let rhs_str = alloc_ty(cx, ty_str_slice, "rhs_str");
|
||||
Store(cx, GEPi(cx, rhs, &[0, 0]), expr::get_dataptr(cx, rhs_str));
|
||||
Store(cx, C_uint(cx.ccx(), pat_len), expr::get_len(cx, rhs_str));
|
||||
Store(cx, expr::get_dataptr(cx, rhs), expr::get_dataptr(cx, rhs_str));
|
||||
Store(cx, C_uint(cx.ccx(), pat_len), expr::get_meta(cx, rhs_str));
|
||||
|
||||
let lhs_str;
|
||||
if val_ty(lhs) == val_ty(rhs) {
|
||||
// Both the discriminant and the pattern are thin pointers
|
||||
lhs_str = alloc_ty(cx, ty_str_slice, "lhs_str");
|
||||
Store(cx, GEPi(cx, lhs, &[0, 0]), expr::get_dataptr(cx, lhs_str));
|
||||
Store(cx, C_uint(cx.ccx(), pat_len), expr::get_len(cx, lhs_str));
|
||||
Store(cx, expr::get_dataptr(cx, lhs), expr::get_dataptr(cx, lhs_str));
|
||||
Store(cx, C_uint(cx.ccx(), pat_len), expr::get_meta(cx, lhs_str));
|
||||
}
|
||||
else {
|
||||
// The discriminant is a fat pointer
|
||||
|
@ -1197,9 +1195,9 @@ fn compile_submatch_continue<'a, 'p, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
|
|||
let llty = type_of::type_of(bcx.ccx(), unsized_ty);
|
||||
let scratch = alloca_no_lifetime(bcx, llty, "__struct_field_fat_ptr");
|
||||
let data = adt::trans_field_ptr(bcx, &*repr, struct_val, 0, arg_count);
|
||||
let len = Load(bcx, expr::get_len(bcx, val.val));
|
||||
let len = Load(bcx, expr::get_meta(bcx, val.val));
|
||||
Store(bcx, data, expr::get_dataptr(bcx, scratch));
|
||||
Store(bcx, len, expr::get_len(bcx, scratch));
|
||||
Store(bcx, len, expr::get_meta(bcx, scratch));
|
||||
field_vals.push(scratch);
|
||||
}
|
||||
_ => {}
|
||||
|
|
|
@ -892,7 +892,7 @@ pub fn trans_get_discr<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, r: &Repr<'tcx>,
|
|||
let val = match *r {
|
||||
CEnum(ity, min, max) => load_discr(bcx, ity, scrutinee, min, max),
|
||||
General(ity, ref cases, _) => {
|
||||
let ptr = GEPi(bcx, scrutinee, &[0, 0]);
|
||||
let ptr = StructGEP(bcx, scrutinee, 0);
|
||||
load_discr(bcx, ity, ptr, 0, (cases.len() - 1) as Disr)
|
||||
}
|
||||
Univariant(..) => C_u8(bcx.ccx(), 0),
|
||||
|
@ -986,13 +986,13 @@ pub fn trans_set_discr<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, r: &Repr<'tcx>,
|
|||
Store(bcx, C_u8(bcx.ccx(), DTOR_NEEDED), ptr);
|
||||
}
|
||||
Store(bcx, C_integral(ll_inttype(bcx.ccx(), ity), discr as u64, true),
|
||||
GEPi(bcx, val, &[0, 0]));
|
||||
StructGEP(bcx, val, 0));
|
||||
}
|
||||
Univariant(ref st, dtor) => {
|
||||
assert_eq!(discr, 0);
|
||||
if dtor_active(dtor) {
|
||||
Store(bcx, C_u8(bcx.ccx(), DTOR_NEEDED),
|
||||
GEPi(bcx, val, &[0, st.fields.len() - 1]));
|
||||
StructGEP(bcx, val, st.fields.len() - 1));
|
||||
}
|
||||
}
|
||||
RawNullablePointer { nndiscr, nnty, ..} => {
|
||||
|
@ -1091,7 +1091,7 @@ pub fn struct_field_ptr<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, st: &Struct<'tcx>, v
|
|||
val
|
||||
};
|
||||
|
||||
GEPi(bcx, val, &[0, ix])
|
||||
StructGEP(bcx, val, ix)
|
||||
}
|
||||
|
||||
pub fn fold_variants<'blk, 'tcx, F>(bcx: Block<'blk, 'tcx>,
|
||||
|
@ -1162,7 +1162,7 @@ pub fn trans_drop_flag_ptr<'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
|
|||
let ptr_ty = bcx.tcx().mk_imm_ptr(tcx.dtor_type());
|
||||
match *r {
|
||||
Univariant(ref st, dtor) if dtor_active(dtor) => {
|
||||
let flag_ptr = GEPi(bcx, val, &[0, st.fields.len() - 1]);
|
||||
let flag_ptr = StructGEP(bcx, val, st.fields.len() - 1);
|
||||
datum::immediate_rvalue_bcx(bcx, flag_ptr, ptr_ty).to_expr_datumblock()
|
||||
}
|
||||
General(_, _, dtor) if dtor_active(dtor) => {
|
||||
|
|
|
@ -403,8 +403,8 @@ pub fn iter_structural_ty<'blk, 'tcx, F>(cx: Block<'blk, 'tcx>,
|
|||
let (data_ptr, info) = if common::type_is_sized(cx.tcx(), t) {
|
||||
(av, None)
|
||||
} else {
|
||||
let data = GEPi(cx, av, &[0, abi::FAT_PTR_ADDR]);
|
||||
let info = GEPi(cx, av, &[0, abi::FAT_PTR_EXTRA]);
|
||||
let data = expr::get_dataptr(cx, av);
|
||||
let info = expr::get_meta(cx, av);
|
||||
(Load(cx, data), Some(Load(cx, info)))
|
||||
};
|
||||
|
||||
|
@ -420,8 +420,8 @@ pub fn iter_structural_ty<'blk, 'tcx, F>(cx: Block<'blk, 'tcx>,
|
|||
llfld_a
|
||||
} else {
|
||||
let scratch = datum::rvalue_scratch_datum(cx, field_ty, "__fat_ptr_iter");
|
||||
Store(cx, llfld_a, GEPi(cx, scratch.val, &[0, abi::FAT_PTR_ADDR]));
|
||||
Store(cx, info.unwrap(), GEPi(cx, scratch.val, &[0, abi::FAT_PTR_EXTRA]));
|
||||
Store(cx, llfld_a, expr::get_dataptr(cx, scratch.val));
|
||||
Store(cx, info.unwrap(), expr::get_meta(cx, scratch.val));
|
||||
scratch.val
|
||||
};
|
||||
cx = f(cx, val, field_ty);
|
||||
|
@ -835,7 +835,7 @@ pub fn store_ty<'blk, 'tcx>(cx: Block<'blk, 'tcx>, v: ValueRef, dst: ValueRef, t
|
|||
|
||||
if common::type_is_fat_ptr(cx.tcx(), t) {
|
||||
Store(cx, ExtractValue(cx, v, abi::FAT_PTR_ADDR), expr::get_dataptr(cx, dst));
|
||||
Store(cx, ExtractValue(cx, v, abi::FAT_PTR_EXTRA), expr::get_len(cx, dst));
|
||||
Store(cx, ExtractValue(cx, v, abi::FAT_PTR_EXTRA), expr::get_meta(cx, dst));
|
||||
} else {
|
||||
let store = Store(cx, from_arg_ty(cx, v, t), to_arg_ty_ptr(cx, dst, t));
|
||||
unsafe {
|
||||
|
@ -1402,7 +1402,7 @@ pub fn create_datums_for_fn_args<'a, 'tcx>(mut bcx: Block<'a, 'tcx>,
|
|||
arg_scope_id, (data, extra),
|
||||
|(data, extra), bcx, dst| {
|
||||
Store(bcx, data, expr::get_dataptr(bcx, dst));
|
||||
Store(bcx, extra, expr::get_len(bcx, dst));
|
||||
Store(bcx, extra, expr::get_meta(bcx, dst));
|
||||
bcx
|
||||
}))
|
||||
} else {
|
||||
|
@ -1428,12 +1428,12 @@ pub fn create_datums_for_fn_args<'a, 'tcx>(mut bcx: Block<'a, 'tcx>,
|
|||
llval| {
|
||||
for (j, &tupled_arg_ty) in
|
||||
tupled_arg_tys.iter().enumerate() {
|
||||
let lldest = GEPi(bcx, llval, &[0, j]);
|
||||
let lldest = StructGEP(bcx, llval, j);
|
||||
if common::type_is_fat_ptr(bcx.tcx(), tupled_arg_ty) {
|
||||
let data = get_param(bcx.fcx.llfn, idx);
|
||||
let extra = get_param(bcx.fcx.llfn, idx + 1);
|
||||
Store(bcx, data, expr::get_dataptr(bcx, lldest));
|
||||
Store(bcx, extra, expr::get_len(bcx, lldest));
|
||||
Store(bcx, extra, expr::get_meta(bcx, lldest));
|
||||
idx += 2;
|
||||
} else {
|
||||
let datum = datum::Datum::new(
|
||||
|
@ -1835,7 +1835,7 @@ fn trans_enum_variant_or_tuple_like_struct<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx
|
|||
i);
|
||||
if common::type_is_fat_ptr(bcx.tcx(), arg_ty) {
|
||||
Store(bcx, get_param(fcx.llfn, llarg_idx), expr::get_dataptr(bcx, lldestptr));
|
||||
Store(bcx, get_param(fcx.llfn, llarg_idx + 1), expr::get_len(bcx, lldestptr));
|
||||
Store(bcx, get_param(fcx.llfn, llarg_idx + 1), expr::get_meta(bcx, lldestptr));
|
||||
llarg_idx += 2;
|
||||
} else {
|
||||
let arg = get_param(fcx.llfn, llarg_idx);
|
||||
|
|
|
@ -1129,7 +1129,7 @@ pub fn trans_arg_datum<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
|
|||
|
||||
if common::type_is_fat_ptr(bcx.tcx(), formal_arg_ty) {
|
||||
llargs.push(Load(bcx, expr::get_dataptr(bcx, val)));
|
||||
llargs.push(Load(bcx, expr::get_len(bcx, val)));
|
||||
llargs.push(Load(bcx, expr::get_meta(bcx, val)));
|
||||
} else {
|
||||
llargs.push(val);
|
||||
}
|
||||
|
|
|
@ -70,7 +70,7 @@ fn load_closure_environment<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
|
|||
let upvar_id = ty::UpvarId { var_id: freevar.def.local_node_id(),
|
||||
closure_expr_id: closure_id.node };
|
||||
let upvar_capture = bcx.tcx().upvar_capture(upvar_id).unwrap();
|
||||
let mut upvar_ptr = GEPi(bcx, llenv, &[0, i]);
|
||||
let mut upvar_ptr = StructGEP(bcx, llenv, i);
|
||||
let captured_by_ref = match upvar_capture {
|
||||
ty::UpvarCapture::ByValue => false,
|
||||
ty::UpvarCapture::ByRef(..) => {
|
||||
|
|
|
@ -282,17 +282,17 @@ pub fn trans<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
|
|||
return DatumBlock::new(bcx, datum);
|
||||
}
|
||||
|
||||
pub fn get_len(bcx: Block, fat_ptr: ValueRef) -> ValueRef {
|
||||
GEPi(bcx, fat_ptr, &[0, abi::FAT_PTR_EXTRA])
|
||||
pub fn get_meta(bcx: Block, fat_ptr: ValueRef) -> ValueRef {
|
||||
StructGEP(bcx, fat_ptr, abi::FAT_PTR_EXTRA)
|
||||
}
|
||||
|
||||
pub fn get_dataptr(bcx: Block, fat_ptr: ValueRef) -> ValueRef {
|
||||
GEPi(bcx, fat_ptr, &[0, abi::FAT_PTR_ADDR])
|
||||
StructGEP(bcx, fat_ptr, abi::FAT_PTR_ADDR)
|
||||
}
|
||||
|
||||
pub fn copy_fat_ptr(bcx: Block, src_ptr: ValueRef, dst_ptr: ValueRef) {
|
||||
Store(bcx, Load(bcx, get_dataptr(bcx, src_ptr)), get_dataptr(bcx, dst_ptr));
|
||||
Store(bcx, Load(bcx, get_len(bcx, src_ptr)), get_len(bcx, dst_ptr));
|
||||
Store(bcx, Load(bcx, get_meta(bcx, src_ptr)), get_meta(bcx, dst_ptr));
|
||||
}
|
||||
|
||||
/// Retrieve the information we are losing (making dynamic) in an unsizing
|
||||
|
@ -454,7 +454,7 @@ fn coerce_unsized<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
|
|||
// load out the original data pointer so we can repackage
|
||||
// it.
|
||||
(Load(bcx, get_dataptr(bcx, source.val)),
|
||||
Some(Load(bcx, get_len(bcx, source.val))))
|
||||
Some(Load(bcx, get_meta(bcx, source.val))))
|
||||
} else {
|
||||
let val = if source.kind.is_by_ref() {
|
||||
load_ty(bcx, source.val, source.ty)
|
||||
|
@ -473,7 +473,7 @@ fn coerce_unsized<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
|
|||
let base = PointerCast(bcx, base, ptr_ty);
|
||||
|
||||
Store(bcx, base, get_dataptr(bcx, target.val));
|
||||
Store(bcx, info, get_len(bcx, target.val));
|
||||
Store(bcx, info, get_meta(bcx, target.val));
|
||||
}
|
||||
|
||||
// This can be extended to enums and tuples in the future.
|
||||
|
@ -729,8 +729,8 @@ fn trans_field<'blk, 'tcx, F>(bcx: Block<'blk, 'tcx>,
|
|||
} else {
|
||||
let scratch = rvalue_scratch_datum(bcx, d.ty, "");
|
||||
Store(bcx, d.val, get_dataptr(bcx, scratch.val));
|
||||
let info = Load(bcx, get_len(bcx, base_datum.val));
|
||||
Store(bcx, info, get_len(bcx, scratch.val));
|
||||
let info = Load(bcx, get_meta(bcx, base_datum.val));
|
||||
Store(bcx, info, get_meta(bcx, scratch.val));
|
||||
|
||||
// Always generate an lvalue datum, because this pointer doesn't own
|
||||
// the data and cleanup is scheduled elsewhere.
|
||||
|
|
|
@ -302,7 +302,7 @@ pub fn trans_native_call<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
|
|||
"__arg");
|
||||
if type_is_fat_ptr(ccx.tcx(), passed_arg_tys[i]) {
|
||||
Store(bcx, llargs_rust[i + offset], expr::get_dataptr(bcx, scratch));
|
||||
Store(bcx, llargs_rust[i + offset + 1], expr::get_len(bcx, scratch));
|
||||
Store(bcx, llargs_rust[i + offset + 1], expr::get_meta(bcx, scratch));
|
||||
offset += 1;
|
||||
} else {
|
||||
base::store_ty(bcx, llarg_rust, scratch, passed_arg_tys[i]);
|
||||
|
@ -821,10 +821,10 @@ pub fn trans_rust_fn_with_foreign_abi<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
|
|||
i, ccx.tn().val_to_string(llrust_arg));
|
||||
if type_is_fat_ptr(ccx.tcx(), rust_ty) {
|
||||
let next_llrust_ty = rust_param_tys.next().expect("Not enough parameter types!");
|
||||
llrust_args.push(builder.load(builder.bitcast(builder.gepi(
|
||||
llrust_arg, &[0, abi::FAT_PTR_ADDR]), llrust_ty.ptr_to())));
|
||||
llrust_args.push(builder.load(builder.bitcast(builder.gepi(
|
||||
llrust_arg, &[0, abi::FAT_PTR_EXTRA]), next_llrust_ty.ptr_to())));
|
||||
llrust_args.push(builder.load(builder.bitcast(builder.struct_gep(
|
||||
llrust_arg, abi::FAT_PTR_ADDR), llrust_ty.ptr_to())));
|
||||
llrust_args.push(builder.load(builder.bitcast(builder.struct_gep(
|
||||
llrust_arg, abi::FAT_PTR_EXTRA), next_llrust_ty.ptr_to())));
|
||||
} else {
|
||||
llrust_args.push(llrust_arg);
|
||||
}
|
||||
|
|
|
@ -13,7 +13,6 @@
|
|||
// Code relating to drop glue.
|
||||
|
||||
|
||||
use back::abi;
|
||||
use back::link::*;
|
||||
use llvm;
|
||||
use llvm::{ValueRef, get_param};
|
||||
|
@ -390,7 +389,7 @@ fn trans_struct_drop<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
|
|||
let (_, bcx) = if type_is_sized(bcx.tcx(), t) {
|
||||
invoke(bcx, dtor_addr, &[v0], dtor_ty, DebugLoc::None)
|
||||
} else {
|
||||
let args = [Load(bcx, expr::get_dataptr(bcx, v0)), Load(bcx, expr::get_len(bcx, v0))];
|
||||
let args = [Load(bcx, expr::get_dataptr(bcx, v0)), Load(bcx, expr::get_meta(bcx, v0))];
|
||||
invoke(bcx, dtor_addr, &args, dtor_ty, DebugLoc::None)
|
||||
};
|
||||
|
||||
|
@ -525,14 +524,14 @@ fn make_drop_glue<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, v0: ValueRef, g: DropGlueK
|
|||
// a safe-guard, assert TyBox not used with TyContents.
|
||||
assert!(!skip_dtor);
|
||||
if !type_is_sized(bcx.tcx(), content_ty) {
|
||||
let llval = GEPi(bcx, v0, &[0, abi::FAT_PTR_ADDR]);
|
||||
let llval = expr::get_dataptr(bcx, v0);
|
||||
let llbox = Load(bcx, llval);
|
||||
let llbox_as_usize = PtrToInt(bcx, llbox, Type::int(bcx.ccx()));
|
||||
let drop_flag_not_dropped_already =
|
||||
ICmp(bcx, llvm::IntNE, llbox_as_usize, dropped_pattern, DebugLoc::None);
|
||||
with_cond(bcx, drop_flag_not_dropped_already, |bcx| {
|
||||
let bcx = drop_ty(bcx, v0, content_ty, DebugLoc::None);
|
||||
let info = GEPi(bcx, v0, &[0, abi::FAT_PTR_EXTRA]);
|
||||
let info = expr::get_meta(bcx, v0);
|
||||
let info = Load(bcx, info);
|
||||
let (llsize, llalign) = size_and_align_of_dst(bcx, content_ty, info);
|
||||
|
||||
|
@ -591,8 +590,8 @@ fn make_drop_glue<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, v0: ValueRef, g: DropGlueK
|
|||
// versus without calling Drop::drop. Assert caller is
|
||||
// okay with always calling the Drop impl, if any.
|
||||
assert!(!skip_dtor);
|
||||
let data_ptr = GEPi(bcx, v0, &[0, abi::FAT_PTR_ADDR]);
|
||||
let vtable_ptr = Load(bcx, GEPi(bcx, v0, &[0, abi::FAT_PTR_EXTRA]));
|
||||
let data_ptr = expr::get_dataptr(bcx, v0);
|
||||
let vtable_ptr = Load(bcx, expr::get_meta(bcx, v0));
|
||||
let dtor = Load(bcx, vtable_ptr);
|
||||
Call(bcx,
|
||||
dtor,
|
||||
|
|
|
@ -449,7 +449,7 @@ pub fn trans_intrinsic_call<'a, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
|
|||
} else {
|
||||
let scratch = rvalue_scratch_datum(bcx, tp_ty, "tmp");
|
||||
Store(bcx, llargs[0], expr::get_dataptr(bcx, scratch.val));
|
||||
Store(bcx, llargs[1], expr::get_len(bcx, scratch.val));
|
||||
Store(bcx, llargs[1], expr::get_meta(bcx, scratch.val));
|
||||
fcx.schedule_lifetime_end(cleanup::CustomScope(cleanup_scope), scratch.val);
|
||||
scratch.val
|
||||
};
|
||||
|
|
|
@ -9,7 +9,6 @@
|
|||
// except according to those terms.
|
||||
|
||||
use arena::TypedArena;
|
||||
use back::abi;
|
||||
use back::link;
|
||||
use llvm::{ValueRef, get_params};
|
||||
use middle::def_id::DefId;
|
||||
|
@ -446,8 +445,8 @@ fn trans_trait_callee<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
|
|||
self_datum.val
|
||||
};
|
||||
|
||||
let llself = Load(bcx, GEPi(bcx, llval, &[0, abi::FAT_PTR_ADDR]));
|
||||
let llvtable = Load(bcx, GEPi(bcx, llval, &[0, abi::FAT_PTR_EXTRA]));
|
||||
let llself = Load(bcx, expr::get_dataptr(bcx, llval));
|
||||
let llvtable = Load(bcx, expr::get_meta(bcx, llval));
|
||||
trans_trait_callee_from_llval(bcx, opaque_fn_ty, vtable_index, llself, llvtable)
|
||||
}
|
||||
|
||||
|
|
|
@ -10,7 +10,6 @@
|
|||
|
||||
#![allow(non_camel_case_types)]
|
||||
|
||||
use back::abi;
|
||||
use llvm;
|
||||
use llvm::ValueRef;
|
||||
use trans::base::*;
|
||||
|
@ -67,7 +66,7 @@ pub fn trans_fixed_vstore<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
|
|||
SaveIn(lldest) => {
|
||||
// lldest will have type *[T x N], but we want the type *T,
|
||||
// so use GEP to convert:
|
||||
let lldest = GEPi(bcx, lldest, &[0, 0]);
|
||||
let lldest = StructGEP(bcx, lldest, 0);
|
||||
write_content(bcx, &vt, expr, expr, SaveIn(lldest))
|
||||
}
|
||||
};
|
||||
|
@ -123,7 +122,7 @@ pub fn trans_slice_vec<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
|
|||
// llfixed has type *[T x N], but we want the type *T,
|
||||
// so use GEP to convert
|
||||
bcx = write_content(bcx, &vt, slice_expr, content_expr,
|
||||
SaveIn(GEPi(bcx, llfixed, &[0, 0])));
|
||||
SaveIn(StructGEP(bcx, llfixed, 0)));
|
||||
};
|
||||
|
||||
immediate_rvalue_bcx(bcx, llfixed, vec_ty).to_expr_datumblock()
|
||||
|
@ -147,8 +146,8 @@ pub fn trans_lit_str<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
|
|||
let llbytes = C_uint(bcx.ccx(), bytes);
|
||||
let llcstr = C_cstr(bcx.ccx(), str_lit, false);
|
||||
let llcstr = consts::ptrcast(llcstr, Type::i8p(bcx.ccx()));
|
||||
Store(bcx, llcstr, GEPi(bcx, lldest, &[0, abi::FAT_PTR_ADDR]));
|
||||
Store(bcx, llbytes, GEPi(bcx, lldest, &[0, abi::FAT_PTR_EXTRA]));
|
||||
Store(bcx, llcstr, expr::get_dataptr(bcx, lldest));
|
||||
Store(bcx, llbytes, expr::get_meta(bcx, lldest));
|
||||
bcx
|
||||
}
|
||||
}
|
||||
|
@ -310,7 +309,7 @@ pub fn get_base_and_len<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
|
|||
ty::TyArray(_, n) => get_fixed_base_and_len(bcx, llval, n),
|
||||
ty::TySlice(_) | ty::TyStr => {
|
||||
let base = Load(bcx, expr::get_dataptr(bcx, llval));
|
||||
let len = Load(bcx, expr::get_len(bcx, llval));
|
||||
let len = Load(bcx, expr::get_meta(bcx, llval));
|
||||
(base, len)
|
||||
}
|
||||
|
||||
|
|
Loading…
Reference in a new issue