use rustc_data_structures::sync::Lrc;
use rustc_data_structures::indexed_vec::Idx;
-use traits::BuilderMethods;
+use traits::{IntPredicate, BuilderMethods};
use llvm::BasicBlock;
use std::any::Any;
pub fn bin_op_to_icmp_predicate(op: hir::BinOpKind,
signed: bool)
- -> llvm::IntPredicate {
+ -> IntPredicate {
match op {
- hir::BinOpKind::Eq => llvm::IntEQ,
- hir::BinOpKind::Ne => llvm::IntNE,
- hir::BinOpKind::Lt => if signed { llvm::IntSLT } else { llvm::IntULT },
- hir::BinOpKind::Le => if signed { llvm::IntSLE } else { llvm::IntULE },
- hir::BinOpKind::Gt => if signed { llvm::IntSGT } else { llvm::IntUGT },
- hir::BinOpKind::Ge => if signed { llvm::IntSGE } else { llvm::IntUGE },
+ hir::BinOpKind::Eq => IntPredicate::IntEQ,
+ hir::BinOpKind::Ne => IntPredicate::IntNE,
+ hir::BinOpKind::Lt => if signed { IntPredicate::IntSLT } else { IntPredicate::IntULT },
+ hir::BinOpKind::Le => if signed { IntPredicate::IntSLE } else { IntPredicate::IntULE },
+ hir::BinOpKind::Gt => if signed { IntPredicate::IntSGT } else { IntPredicate::IntUGT },
+ hir::BinOpKind::Ge => if signed { IntPredicate::IntSGE } else { IntPredicate::IntUGE },
op => {
bug!("comparison_op_to_icmp_predicate: expected comparison operator, \
found {:?}",
// except according to those terms.
use llvm::{AtomicRmwBinOp, AtomicOrdering, SynchronizationScope, AsmDialect};
-use llvm::{IntPredicate, RealPredicate, False, OperandBundleDef};
+use llvm::{RealPredicate, False, OperandBundleDef};
use llvm::{self, BasicBlock};
use common::*;
use type_::Type;
use rustc::ty::layout::{Align, Size};
use rustc::session::{config, Session};
use rustc_data_structures::small_c_str::SmallCStr;
-use traits::BuilderMethods;
+use traits::{self, BuilderMethods};
use std::borrow::Cow;
use std::ops::Range;
}
/* Comparisons */
- fn icmp(&self, op: IntPredicate, lhs: &'ll Value, rhs: &'ll Value) -> &'ll Value {
+ fn icmp(&self, op: traits::IntPredicate, lhs: &'ll Value, rhs: &'ll Value) -> &'ll Value {
self.count_insn("icmp");
+ let op : llvm::IntPredicate = traits::IntPredicateMethods::convert_to_backend_specific(op);
unsafe {
llvm::LLVMBuildICmp(self.llbuilder, op as c_uint, lhs, rhs, noname())
}
src: &'ll Value,
order: AtomicOrdering,
failure_order: AtomicOrdering,
- weak: llvm::Bool,
+ weak: bool,
) -> &'ll Value {
+ let weak = if weak { llvm::True } else { llvm::False };
unsafe {
llvm::LLVMRustBuildAtomicCmpXchg(self.llbuilder, dst, cmp, src,
order, failure_order, weak)
use builder::Builder;
use common::*;
-use llvm;
use meth;
use rustc::ty::layout::LayoutOf;
use rustc::ty::{self, Ty};
use value::Value;
-use traits::BuilderMethods;
+use traits::{IntPredicate,BuilderMethods};
pub fn size_and_align_of_dst(
bx: &Builder<'_, 'll, 'tcx>,
// pick the correct alignment statically.
C_usize(cx, std::cmp::max(sized_align, unsized_align) as u64)
}
- _ => bx.select(bx.icmp(llvm::IntUGT, sized_align, unsized_align),
+ _ => bx.select(bx.icmp(IntPredicate::IntUGT, sized_align, unsized_align),
sized_align,
unsized_align)
};
"cxchg" | "cxchgweak" => {
let ty = substs.type_at(0);
if int_type_width_signed(ty, cx).is_some() {
- let weak = if split[1] == "cxchgweak" { llvm::True } else { llvm::False };
+ let weak = split[1] == "cxchgweak";
let pair = bx.atomic_cmpxchg(
args[0].immediate(),
args[1].immediate(),
use libc::{c_ulonglong, c_void};
use std::marker::PhantomData;
+use traits;
use super::RustString;
IntSLE = 41,
}
+impl traits::IntPredicateMethods for IntPredicate {
+ fn convert_to_backend_specific(intpre: traits::IntPredicate) -> Self {
+ match intpre {
+ traits::IntPredicate::IntEQ => IntPredicate::IntEQ,
+ traits::IntPredicate::IntNE => IntPredicate::IntNE,
+ traits::IntPredicate::IntUGT => IntPredicate::IntUGT,
+ traits::IntPredicate::IntUGE => IntPredicate::IntUGE,
+ traits::IntPredicate::IntULT => IntPredicate::IntULT,
+ traits::IntPredicate::IntULE => IntPredicate::IntULE,
+ traits::IntPredicate::IntSGT => IntPredicate::IntSGT,
+ traits::IntPredicate::IntSGE => IntPredicate::IntSGE,
+ traits::IntPredicate::IntSLT => IntPredicate::IntSLT,
+ traits::IntPredicate::IntSLE => IntPredicate::IntSLE,
+ }
+ }
+}
+
/// LLVMRealPredicate
#[derive(Copy, Clone)]
#[repr(C)]
use type_::Type;
use value::Value;
-use traits::BuilderMethods;
+use traits::{IntPredicate,BuilderMethods};
use syntax::symbol::Symbol;
use syntax_pos::Pos;
} else {
let switch_llty = bx.cx.layout_of(switch_ty).immediate_llvm_type(bx.cx);
let llval = C_uint_big(switch_llty, values[0]);
- let cmp = bx.icmp(llvm::IntEQ, discr.immediate(), llval);
+ let cmp = bx.icmp(IntPredicate::IntEQ, discr.immediate(), llval);
bx.cond_br(cmp, lltrue, llfalse);
}
} else {
use glue;
use mir::constant::const_alloc_to_llvm;
-use traits::BuilderMethods;
+use traits::{IntPredicate,BuilderMethods};
use super::{FunctionCx, LocalRef};
use super::operand::{OperandRef, OperandValue};
} else {
C_uint_big(niche_llty, niche_start)
};
- bx.select(bx.icmp(llvm::IntEQ, lldiscr, niche_llval),
+ bx.select(bx.icmp(IntPredicate::IntEQ, lldiscr, niche_llval),
C_uint(cast_to, niche_variants.start().as_u32() as u64),
C_uint(cast_to, dataful_variant.as_u32() as u64))
} else {
let delta = niche_start.wrapping_sub(niche_variants.start().as_u32() as u128);
let lldiscr = bx.sub(lldiscr, C_uint_big(niche_llty, delta));
let lldiscr_max = C_uint(niche_llty, niche_variants.end().as_u32() as u64);
- bx.select(bx.icmp(llvm::IntULE, lldiscr, lldiscr_max),
+ bx.select(bx.icmp(IntPredicate::IntULE, lldiscr, lldiscr_max),
bx.intcast(lldiscr, cast_to, false),
C_uint(cast_to, dataful_variant.as_u32() as u64))
}
use type_of::LayoutLlvmExt;
use value::Value;
-use traits::BuilderMethods;
+use traits::{IntPredicate,BuilderMethods};
use super::{FunctionCx, LocalRef};
use super::operand::{OperandRef, OperandValue};
bx.br(header_bx.llbb());
let current = header_bx.phi(common::val_ty(start), &[start], &[bx.llbb()]);
- let keep_going = header_bx.icmp(llvm::IntNE, current, end);
+ let keep_going = header_bx.icmp(IntPredicate::IntNE, current, end);
header_bx.cond_br(keep_going, body_bx.llbb(), next_bx.llbb());
cg_elem.val.store(&body_bx,
// convenient place to put the `assume`.
base::call_assume(&bx, bx.icmp(
- llvm::IntULE,
+ IntPredicate::IntULE,
llval,
C_uint_big(ll_t_in, *scalar.valid_range.end())
));
match op {
mir::BinOp::Eq => {
bx.and(
- bx.icmp(llvm::IntEQ, lhs_addr, rhs_addr),
- bx.icmp(llvm::IntEQ, lhs_extra, rhs_extra)
+ bx.icmp(IntPredicate::IntEQ, lhs_addr, rhs_addr),
+ bx.icmp(IntPredicate::IntEQ, lhs_extra, rhs_extra)
)
}
mir::BinOp::Ne => {
bx.or(
- bx.icmp(llvm::IntNE, lhs_addr, rhs_addr),
- bx.icmp(llvm::IntNE, lhs_extra, rhs_extra)
+ bx.icmp(IntPredicate::IntNE, lhs_addr, rhs_addr),
+ bx.icmp(IntPredicate::IntNE, lhs_extra, rhs_extra)
)
}
mir::BinOp::Le | mir::BinOp::Lt |
mir::BinOp::Ge | mir::BinOp::Gt => {
// a OP b ~ a.0 STRICT(OP) b.0 | (a.0 == b.0 && a.1 OP a.1)
let (op, strict_op) = match op {
- mir::BinOp::Lt => (llvm::IntULT, llvm::IntULT),
- mir::BinOp::Le => (llvm::IntULE, llvm::IntULT),
- mir::BinOp::Gt => (llvm::IntUGT, llvm::IntUGT),
- mir::BinOp::Ge => (llvm::IntUGE, llvm::IntUGT),
+ mir::BinOp::Lt => (IntPredicate::IntULT, IntPredicate::IntULT),
+ mir::BinOp::Le => (IntPredicate::IntULE, IntPredicate::IntULT),
+ mir::BinOp::Gt => (IntPredicate::IntUGT, IntPredicate::IntUGT),
+ mir::BinOp::Ge => (IntPredicate::IntUGE, IntPredicate::IntUGT),
_ => bug!(),
};
bx.or(
bx.icmp(strict_op, lhs_addr, rhs_addr),
bx.and(
- bx.icmp(llvm::IntEQ, lhs_addr, rhs_addr),
+ bx.icmp(IntPredicate::IntEQ, lhs_addr, rhs_addr),
bx.icmp(op, lhs_extra, rhs_extra)
)
)
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(llvm::IntNE, outer_bits, C_null(rhs_llty));
+ let of = bx.icmp(IntPredicate::IntNE, outer_bits, C_null(rhs_llty));
let val = self.codegen_scalar_binop(bx, op, lhs, rhs, input_ty);
(val, of)
const MAX_F32_PLUS_HALF_ULP: u128 = ((1 << (Single::PRECISION + 1)) - 1)
<< (Single::MAX_EXP - Single::PRECISION as i16);
let max = C_uint_big(int_ty, MAX_F32_PLUS_HALF_ULP);
- let overflow = bx.icmp(llvm::IntUGE, x, max);
+ let overflow = bx.icmp(IntPredicate::IntUGE, x, max);
let infinity_bits = C_u32(bx.cx, ieee::Single::INFINITY.to_bits() as u32);
let infinity = consts::bitcast(infinity_bits, float_ty);
bx.select(overflow, infinity, bx.uitofp(x, float_ty))
// except according to those terms.
use llvm::{AtomicRmwBinOp, AtomicOrdering, SynchronizationScope, AsmDialect};
-use llvm::{IntPredicate, RealPredicate, OperandBundleDef};
-use llvm;
+use llvm::{RealPredicate, OperandBundleDef};
use common::*;
use type_::Type;
use libc::c_char;
use std::borrow::Cow;
use std::ops::Range;
+pub enum IntPredicate {
+ IntEQ,
+ IntNE,
+ IntUGT,
+ IntUGE,
+ IntULT,
+ IntULE,
+ IntSGT,
+ IntSGE,
+ IntSLT,
+ IntSLE,
+}
+
+pub trait IntPredicateMethods {
+ fn convert_to_backend_specific(intpre : IntPredicate) -> Self;
+}
+
pub trait BuilderMethods<'a, 'll :'a, 'tcx: 'll,
Value : ?Sized,
src: &'ll Value,
order: AtomicOrdering,
failure_order: AtomicOrdering,
- weak: llvm::Bool,
+ weak: bool,
) -> &'ll Value;
fn atomic_rmw(
&self,