if
ty.is_scalar() ||
ty.is_unique() ||
- ty.is_region_ptr() ||
+ (ty.is_region_ptr() && !common::type_is_fat_ptr(bcx.tcx(), ty)) ||
ty.is_simd()
{
// These sorts of types are immediates that we can store
// for newtypes, but we currently force some types
// (e.g. structs) into an alloca unconditionally, just so
// that we don't have to deal with having two pathways
- // (gep vs getvalue etc).
+ // (gep vs extractvalue etc).
analyzer.mark_as_lvalue(index);
}
}
/// - nor should it appear in an lvalue path like `tmp.a`
/// - the operand must be defined by an rvalue that can generate immediate
/// values
+ ///
+ /// Avoiding allocs can also be important for certain intrinsics,
+ /// notably `expect`.
temps: Vec<TempRef<'tcx>>,
/// The arguments to the function; as args are lvalues, these are
use trans::common::{self, Block, Result};
use trans::debuginfo::DebugLoc;
use trans::declare;
+use trans::expr;
use trans::machine;
use trans::type_::Type;
use trans::type_of;
mir::Rvalue::Aggregate(_, ref operands) => {
for (i, operand) in operands.iter().enumerate() {
+ // Note: perhaps this should be StructGep, but
+ // note that in some cases the values here will
+ // not be structs but arrays.
let lldest_i = build::GEPi(bcx, lldest, &[0, i]);
self.trans_operand_into(bcx, lldest_i, operand);
}
let llbase1 = build::GEPi(bcx, llbase, &[from_start]);
let adj = common::C_uint(ccx, from_start + from_end);
let lllen1 = build::Sub(bcx, lllen, adj, DebugLoc::None);
- build::Store(bcx, llbase1, build::GEPi(bcx, lldest, &[0, abi::FAT_PTR_ADDR]));
- build::Store(bcx, lllen1, build::GEPi(bcx, lldest, &[0, abi::FAT_PTR_EXTRA]));
+ let lladdrdest = expr::get_dataptr(bcx, lldest);
+ build::Store(bcx, llbase1, lladdrdest);
+ let llmetadest = expr::get_meta(bcx, lldest);
+ build::Store(bcx, lllen1, llmetadest);
bcx
}