return bx;
}
- let start = dest.project_index(&bx, bx.cx().c_usize(0)).llval;
+ let start = dest.project_index(&bx, bx.cx().const_usize(0)).llval;
if let OperandValue::Immediate(v) = cg_elem.val {
- let align = bx.cx().c_i32(dest.align.abi() as i32);
- let size = bx.cx().c_usize(dest.layout.size.bytes());
+ let align = bx.cx().const_i32(dest.align.abi() as i32);
+ let size = bx.cx().const_usize(dest.layout.size.bytes());
// Use llvm.memset.p0i8.* to initialize all zero arrays
if bx.cx().is_const_integral(v) && bx.cx().const_to_uint(v) == 0 {
- let fill = bx.cx().c_u8(0);
+ let fill = bx.cx().const_u8(0);
base::call_memset(&bx, start, fill, size, align, false);
return bx;
}
}
}
- let count = bx.cx().c_usize(count);
+ let count = bx.cx().const_usize(count);
let end = dest.project_index(&bx, count).llval;
let header_bx = bx.build_sibling_block("repeat_loop_header");
cg_elem.val.store(&body_bx,
PlaceRef::new_sized(current, cg_elem.layout, dest.align));
- let next = body_bx.inbounds_gep(current, &[bx.cx().c_usize(1)]);
+ let next = body_bx.inbounds_gep(current, &[bx.cx().const_usize(1)]);
body_bx.br(header_bx.llbb());
header_bx.add_incoming_to_phi(current, next, body_bx.llbb());
assert!(cast.is_llvm_immediate());
let ll_t_out = cast.immediate_llvm_type(bx.cx());
if operand.layout.abi.is_uninhabited() {
- let val = OperandValue::Immediate(bx.cx().c_undef(ll_t_out));
+ let val = OperandValue::Immediate(bx.cx().const_undef(ll_t_out));
return (bx, OperandRef {
val,
layout: cast,
let discr_val = def
.discriminant_for_variant(bx.cx().tcx, index)
.val;
- let discr = bx.cx().c_uint_big(ll_t_out, discr_val);
+ let discr = bx.cx().const_uint_big(ll_t_out, discr_val);
return (bx, OperandRef {
val: OperandValue::Immediate(discr),
layout: cast,
base::call_assume(&bx, bx.icmp(
IntPredicate::IntULE,
llval,
- bx.cx().c_uint_big(ll_t_in, *scalar.valid_range.end())
+ bx.cx().const_uint_big(ll_t_in, *scalar.valid_range.end())
));
}
}
mir::Rvalue::NullaryOp(mir::NullOp::SizeOf, ty) => {
assert!(bx.cx().type_is_sized(ty));
- let val = bx.cx().c_usize(bx.cx().size_of(ty).bytes());
+ let val = bx.cx().const_usize(bx.cx().size_of(ty).bytes());
let tcx = bx.tcx();
(bx, OperandRef {
val: OperandValue::Immediate(val),
mir::Rvalue::NullaryOp(mir::NullOp::Box, content_ty) => {
let content_ty: Ty<'tcx> = self.monomorphize(&content_ty);
let (size, align) = bx.cx().size_and_align_of(content_ty);
- let llsize = bx.cx().c_usize(size.bytes());
- let llalign = bx.cx().c_usize(align.abi());
+ let llsize = bx.cx().const_usize(size.bytes());
+ let llalign = bx.cx().const_usize(align.abi());
let box_layout = bx.cx().layout_of(bx.tcx().mk_box(content_ty));
let llty_ptr = box_layout.llvm_type(bx.cx());
if let LocalRef::Operand(Some(op)) = self.locals[index] {
if let ty::Array(_, n) = op.layout.ty.sty {
let n = n.unwrap_usize(bx.cx().tcx);
- return bx.cx().c_usize(n);
+ return bx.cx().const_usize(n);
}
}
}
mir::BinOp::Shr => common::build_unchecked_rshift(bx, input_ty, lhs, rhs),
mir::BinOp::Ne | mir::BinOp::Lt | mir::BinOp::Gt |
mir::BinOp::Eq | mir::BinOp::Le | mir::BinOp::Ge => if is_unit {
- bx.cx().c_bool(match op {
+ bx.cx().const_bool(match op {
mir::BinOp::Ne | mir::BinOp::Lt | mir::BinOp::Gt => false,
mir::BinOp::Eq | mir::BinOp::Le | mir::BinOp::Ge => true,
_ => unreachable!()
// while the current crate doesn't use overflow checks.
if !bx.cx().check_overflow {
let val = self.codegen_scalar_binop(bx, op, lhs, rhs, input_ty);
- return OperandValue::Pair(val, bx.cx().c_bool(false));
+ return OperandValue::Pair(val, bx.cx().const_bool(false));
}
let (val, of) = match op {
let invert_mask = common::shift_mask_val(&bx, lhs_llty, rhs_llty, true);
let outer_bits = bx.and(rhs, invert_mask);
- let of = bx.icmp(IntPredicate::IntNE, outer_bits, bx.cx().c_null(rhs_llty));
+ let of = bx.icmp(IntPredicate::IntNE, outer_bits, bx.cx().const_null(rhs_llty));
let val = self.codegen_scalar_binop(bx, op, lhs, rhs, input_ty);
(val, of)
use rustc_apfloat::Float;
const MAX_F32_PLUS_HALF_ULP: u128 = ((1 << (Single::PRECISION + 1)) - 1)
<< (Single::MAX_EXP - Single::PRECISION as i16);
- let max = bx.cx().c_uint_big(int_ty, MAX_F32_PLUS_HALF_ULP);
+ let max = bx.cx().const_uint_big(int_ty, MAX_F32_PLUS_HALF_ULP);
let overflow = bx.icmp(IntPredicate::IntUGE, x, max);
- let infinity_bits = bx.cx().c_u32(ieee::Single::INFINITY.to_bits() as u32);
+ let infinity_bits = bx.cx().const_u32(ieee::Single::INFINITY.to_bits() as u32);
let infinity = consts::bitcast(infinity_bits, float_ty);
bx.select(overflow, infinity, bx.uitofp(x, float_ty))
} else {
let float_bits_to_llval = |bits| {
let bits_llval = match bx.cx().float_width(float_ty) {
- 32 => bx.cx().c_u32(bits as u32),
- 64 => bx.cx().c_u64(bits as u64),
+ 32 => bx.cx().const_u32(bits as u32),
+ 64 => bx.cx().const_u64(bits as u64),
n => bug!("unsupported float width {}", n),
};
consts::bitcast(bits_llval, float_ty)
// performed is ultimately up to the backend, but at least x86 does perform them.
let less_or_nan = bx.fcmp(RealPredicate::RealULT, x, f_min);
let greater = bx.fcmp(RealPredicate::RealOGT, x, f_max);
- let int_max = bx.cx().c_uint_big(int_ty, int_max(signed, int_ty));
- let int_min = bx.cx().c_uint_big(int_ty, int_min(signed, int_ty) as u128);
+ let int_max = bx.cx().const_uint_big(int_ty, int_max(signed, int_ty));
+ let int_min = bx.cx().const_uint_big(int_ty, int_min(signed, int_ty) as u128);
let s0 = bx.select(less_or_nan, int_min, fptosui_result);
let s1 = bx.select(greater, int_max, s0);
// Therefore we only need to execute this step for signed integer types.
if signed {
// LLVM has no isNaN predicate, so we use (x == x) instead
- bx.select(bx.fcmp(RealPredicate::RealOEQ, x, x), s1, bx.cx().c_uint(int_ty, 0))
+ bx.select(bx.fcmp(RealPredicate::RealOEQ, x, x), s1, bx.cx().const_uint(int_ty, 0))
} else {
s1
}
projects / rust.git / blobdiff