731 lines
33 KiB
Rust
731 lines
33 KiB
Rust
|
//! Module to handle integer operations.
|
||
|
|
//! This module exists because some integer types are not supported on some gcc platforms, e.g.
|
||
|
|
//! 128-bit integers on 32-bit platforms and thus require to be handled manually.
|
||
|
|
|
||
|
|
use std::convert::TryFrom;
|
||
|
|
|
||
|
|
use gccjit::{ComparisonOp, FunctionType, RValue, ToRValue, Type, UnaryOp, BinaryOp};
|
||
|
|
use rustc_codegen_ssa::common::{IntPredicate, TypeKind};
|
||
|
|
use rustc_codegen_ssa::traits::{BackendTypes, BaseTypeMethods, BuilderMethods, OverflowOp};
|
||
|
|
use rustc_middle::ty::Ty;
|
||
|
|
|
||
|
|
use crate::builder::ToGccComp;
|
||
|
|
use crate::{builder::Builder, common::{SignType, TypeReflection}, context::CodegenCx};
|
||
|
|
|
||
|
|
impl<'a, 'gcc, 'tcx> Builder<'a, 'gcc, 'tcx> {
|
||
|
|
pub fn gcc_urem(&self, a: RValue<'gcc>, b: RValue<'gcc>) -> RValue<'gcc> {
|
||
|
|
// 128-bit unsigned %: __umodti3
|
||
|
|
self.multiplicative_operation(BinaryOp::Modulo, "mod", false, a, b)
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn gcc_srem(&self, a: RValue<'gcc>, b: RValue<'gcc>) -> RValue<'gcc> {
|
||
|
|
// 128-bit signed %: __modti3
|
||
|
|
self.multiplicative_operation(BinaryOp::Modulo, "mod", true, a, b)
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn gcc_not(&self, a: RValue<'gcc>) -> RValue<'gcc> {
|
||
|
|
let typ = a.get_type();
|
||
|
|
if self.is_native_int_type_or_bool(typ) {
|
||
|
|
let operation =
|
||
|
|
if typ.is_bool() {
|
||
|
|
UnaryOp::LogicalNegate
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
UnaryOp::BitwiseNegate
|
||
|
|
};
|
||
|
|
self.cx.context.new_unary_op(None, operation, typ, a)
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
// TODO(antoyo): use __negdi2 and __negti2 instead?
|
||
|
|
let element_type = typ.dyncast_array().expect("element type");
|
||
|
|
let values = [
|
||
|
|
self.cx.context.new_unary_op(None, UnaryOp::BitwiseNegate, element_type, self.low(a)),
|
||
|
|
self.cx.context.new_unary_op(None, UnaryOp::BitwiseNegate, element_type, self.high(a)),
|
||
|
|
];
|
||
|
|
self.cx.context.new_array_constructor(None, typ, &values)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn gcc_neg(&self, a: RValue<'gcc>) -> RValue<'gcc> {
|
||
|
|
let a_type = a.get_type();
|
||
|
|
if self.is_native_int_type(a_type) {
|
||
|
|
self.cx.context.new_unary_op(None, UnaryOp::Minus, a.get_type(), a)
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
let param_a = self.context.new_parameter(None, a_type, "a");
|
||
|
|
let func = self.context.new_function(None, FunctionType::Extern, a_type, &[param_a], "__negti2", false);
|
||
|
|
self.context.new_call(None, func, &[a])
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn gcc_and(&self, a: RValue<'gcc>, b: RValue<'gcc>) -> RValue<'gcc> {
|
||
|
|
self.cx.bitwise_operation(BinaryOp::BitwiseAnd, a, b)
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn gcc_lshr(&mut self, a: RValue<'gcc>, b: RValue<'gcc>) -> RValue<'gcc> {
|
||
|
|
let a_type = a.get_type();
|
||
|
|
let b_type = b.get_type();
|
||
|
|
let a_native = self.is_native_int_type(a_type);
|
||
|
|
let b_native = self.is_native_int_type(b_type);
|
||
|
|
if a_native && b_native {
|
||
|
|
// FIXME(antoyo): remove the casts when libgccjit can shift an unsigned number by a signed number.
|
||
|
|
// TODO(antoyo): cast to unsigned to do a logical shift if that does not work.
|
||
|
|
if a_type.is_signed(self) != b_type.is_signed(self) {
|
||
|
|
let b = self.context.new_cast(None, b, a_type);
|
||
|
|
a >> b
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
a >> b
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if a_native && !b_native {
|
||
|
|
self.gcc_lshr(a, self.gcc_int_cast(b, a_type))
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
// NOTE: we cannot use the lshr builtin because it's calling hi() (to get the most
|
||
|
|
// significant half of the number) which uses lshr.
|
||
|
|
|
||
|
|
let native_int_type = a_type.dyncast_array().expect("get element type");
|
||
|
|
|
||
|
|
let func = self.current_func();
|
||
|
|
let then_block = func.new_block("then");
|
||
|
|
let else_block = func.new_block("else");
|
||
|
|
let after_block = func.new_block("after");
|
||
|
|
let b0_block = func.new_block("b0");
|
||
|
|
let actual_else_block = func.new_block("actual_else");
|
||
|
|
|
||
|
|
let result = func.new_local(None, a_type, "shiftResult");
|
||
|
|
|
||
|
|
let sixty_four = self.gcc_int(native_int_type, 64);
|
||
|
|
let sixty_three = self.gcc_int(native_int_type, 63);
|
||
|
|
let zero = self.gcc_zero(native_int_type);
|
||
|
|
let b = self.gcc_int_cast(b, native_int_type);
|
||
|
|
let condition = self.gcc_icmp(IntPredicate::IntNE, self.gcc_and(b, sixty_four), zero);
|
||
|
|
self.llbb().end_with_conditional(None, condition, then_block, else_block);
|
||
|
|
|
||
|
|
// TODO(antoyo): take endianness into account.
|
||
|
|
let shift_value = self.gcc_sub(b, sixty_four);
|
||
|
|
let high = self.high(a);
|
||
|
|
let sign =
|
||
|
|
if a_type.is_signed(self) {
|
||
|
|
high >> sixty_three
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
zero
|
||
|
|
};
|
||
|
|
let values = [
|
||
|
|
high >> shift_value,
|
||
|
|
sign,
|
||
|
|
];
|
||
|
|
let array_value = self.context.new_array_constructor(None, a_type, &values);
|
||
|
|
then_block.add_assignment(None, result, array_value);
|
||
|
|
then_block.end_with_jump(None, after_block);
|
||
|
|
|
||
|
|
let condition = self.gcc_icmp(IntPredicate::IntEQ, b, zero);
|
||
|
|
else_block.end_with_conditional(None, condition, b0_block, actual_else_block);
|
||
|
|
|
||
|
|
b0_block.add_assignment(None, result, a);
|
||
|
|
b0_block.end_with_jump(None, after_block);
|
||
|
|
|
||
|
|
let shift_value = self.gcc_sub(sixty_four, b);
|
||
|
|
// NOTE: cast low to its unsigned type in order to perform a logical right shift.
|
||
|
|
let unsigned_type = native_int_type.to_unsigned(&self.cx);
|
||
|
|
let casted_low = self.context.new_cast(None, self.low(a), unsigned_type);
|
||
|
|
let shifted_low = casted_low >> self.context.new_cast(None, b, unsigned_type);
|
||
|
|
let shifted_low = self.context.new_cast(None, shifted_low, native_int_type);
|
||
|
|
let values = [
|
||
|
|
(high << shift_value) | shifted_low,
|
||
|
|
high >> b,
|
||
|
|
];
|
||
|
|
let array_value = self.context.new_array_constructor(None, a_type, &values);
|
||
|
|
actual_else_block.add_assignment(None, result, array_value);
|
||
|
|
actual_else_block.end_with_jump(None, after_block);
|
||
|
|
|
||
|
|
// NOTE: since jumps were added in a place rustc does not expect, the current block in the
|
||
|
|
// state need to be updated.
|
||
|
|
self.switch_to_block(after_block);
|
||
|
|
|
||
|
|
result.to_rvalue()
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
fn additive_operation(&self, operation: BinaryOp, a: RValue<'gcc>, mut b: RValue<'gcc>) -> RValue<'gcc> {
|
||
|
|
let a_type = a.get_type();
|
||
|
|
let b_type = b.get_type();
|
||
|
|
if self.is_native_int_type_or_bool(a_type) && self.is_native_int_type_or_bool(b_type) {
|
||
|
|
if a.get_type() != b.get_type() {
|
||
|
|
b = self.context.new_cast(None, b, a.get_type());
|
||
|
|
}
|
||
|
|
self.context.new_binary_op(None, operation, a_type, a, b)
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
let signed = a_type.is_compatible_with(self.i128_type);
|
||
|
|
let func_name =
|
||
|
|
match (operation, signed) {
|
||
|
|
(BinaryOp::Plus, true) => "__rust_i128_add",
|
||
|
|
(BinaryOp::Plus, false) => "__rust_u128_add",
|
||
|
|
(BinaryOp::Minus, true) => "__rust_i128_sub",
|
||
|
|
(BinaryOp::Minus, false) => "__rust_u128_sub",
|
||
|
|
_ => unreachable!("unexpected additive operation {:?}", operation),
|
||
|
|
};
|
||
|
|
let param_a = self.context.new_parameter(None, a_type, "a");
|
||
|
|
let param_b = self.context.new_parameter(None, b_type, "b");
|
||
|
|
let func = self.context.new_function(None, FunctionType::Extern, a_type, &[param_a, param_b], func_name, false);
|
||
|
|
self.context.new_call(None, func, &[a, b])
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn gcc_add(&self, a: RValue<'gcc>, b: RValue<'gcc>) -> RValue<'gcc> {
|
||
|
|
self.additive_operation(BinaryOp::Plus, a, b)
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn gcc_mul(&self, a: RValue<'gcc>, b: RValue<'gcc>) -> RValue<'gcc> {
|
||
|
|
self.multiplicative_operation(BinaryOp::Mult, "mul", true, a, b)
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn gcc_sub(&self, a: RValue<'gcc>, b: RValue<'gcc>) -> RValue<'gcc> {
|
||
|
|
self.additive_operation(BinaryOp::Minus, a, b)
|
||
|
|
}
|
||
|
|
|
||
|
|
fn multiplicative_operation(&self, operation: BinaryOp, operation_name: &str, signed: bool, a: RValue<'gcc>, b: RValue<'gcc>) -> RValue<'gcc> {
|
||
|
|
let a_type = a.get_type();
|
||
|
|
let b_type = b.get_type();
|
||
|
|
if self.is_native_int_type_or_bool(a_type) && self.is_native_int_type_or_bool(b_type) {
|
||
|
|
self.context.new_binary_op(None, operation, a_type, a, b)
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
let sign =
|
||
|
|
if signed {
|
||
|
|
""
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
"u"
|
||
|
|
};
|
||
|
|
let func_name = format!("__{}{}ti3", sign, operation_name);
|
||
|
|
let param_a = self.context.new_parameter(None, a_type, "a");
|
||
|
|
let param_b = self.context.new_parameter(None, b_type, "b");
|
||
|
|
let func = self.context.new_function(None, FunctionType::Extern, a_type, &[param_a, param_b], func_name, false);
|
||
|
|
self.context.new_call(None, func, &[a, b])
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn gcc_sdiv(&self, a: RValue<'gcc>, b: RValue<'gcc>) -> RValue<'gcc> {
|
||
|
|
// TODO(antoyo): check if the types are signed?
|
||
|
|
// 128-bit, signed: __divti3
|
||
|
|
// TODO(antoyo): convert the arguments to signed?
|
||
|
|
self.multiplicative_operation(BinaryOp::Divide, "div", true, a, b)
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn gcc_udiv(&self, a: RValue<'gcc>, b: RValue<'gcc>) -> RValue<'gcc> {
|
||
|
|
// 128-bit, unsigned: __udivti3
|
||
|
|
self.multiplicative_operation(BinaryOp::Divide, "div", false, a, b)
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn gcc_checked_binop(&self, oop: OverflowOp, typ: Ty<'_>, lhs: <Self as BackendTypes>::Value, rhs: <Self as BackendTypes>::Value) -> (<Self as BackendTypes>::Value, <Self as BackendTypes>::Value) {
|
||
|
|
use rustc_middle::ty::{Int, IntTy::*, Uint, UintTy::*};
|
||
|
|
|
||
|
|
let new_kind =
|
||
|
|
match typ.kind() {
|
||
|
|
Int(t @ Isize) => Int(t.normalize(self.tcx.sess.target.pointer_width)),
|
||
|
|
Uint(t @ Usize) => Uint(t.normalize(self.tcx.sess.target.pointer_width)),
|
||
|
|
t @ (Uint(_) | Int(_)) => t.clone(),
|
||
|
|
_ => panic!("tried to get overflow intrinsic for op applied to non-int type"),
|
||
|
|
};
|
||
|
|
|
||
|
|
// TODO(antoyo): remove duplication with intrinsic?
|
||
|
|
let name =
|
||
|
|
if self.is_native_int_type(lhs.get_type()) {
|
||
|
|
match oop {
|
||
|
|
OverflowOp::Add =>
|
||
|
|
match new_kind {
|
||
|
|
Int(I8) => "__builtin_add_overflow",
|
||
|
|
Int(I16) => "__builtin_add_overflow",
|
||
|
|
Int(I32) => "__builtin_sadd_overflow",
|
||
|
|
Int(I64) => "__builtin_saddll_overflow",
|
||
|
|
Int(I128) => "__builtin_add_overflow",
|
||
|
|
|
||
|
|
Uint(U8) => "__builtin_add_overflow",
|
||
|
|
Uint(U16) => "__builtin_add_overflow",
|
||
|
|
Uint(U32) => "__builtin_uadd_overflow",
|
||
|
|
Uint(U64) => "__builtin_uaddll_overflow",
|
||
|
|
Uint(U128) => "__builtin_add_overflow",
|
||
|
|
|
||
|
|
_ => unreachable!(),
|
||
|
|
},
|
||
|
|
OverflowOp::Sub =>
|
||
|
|
match new_kind {
|
||
|
|
Int(I8) => "__builtin_sub_overflow",
|
||
|
|
Int(I16) => "__builtin_sub_overflow",
|
||
|
|
Int(I32) => "__builtin_ssub_overflow",
|
||
|
|
Int(I64) => "__builtin_ssubll_overflow",
|
||
|
|
Int(I128) => "__builtin_sub_overflow",
|
||
|
|
|
||
|
|
Uint(U8) => "__builtin_sub_overflow",
|
||
|
|
Uint(U16) => "__builtin_sub_overflow",
|
||
|
|
Uint(U32) => "__builtin_usub_overflow",
|
||
|
|
Uint(U64) => "__builtin_usubll_overflow",
|
||
|
|
Uint(U128) => "__builtin_sub_overflow",
|
||
|
|
|
||
|
|
_ => unreachable!(),
|
||
|
|
},
|
||
|
|
OverflowOp::Mul =>
|
||
|
|
match new_kind {
|
||
|
|
Int(I8) => "__builtin_mul_overflow",
|
||
|
|
Int(I16) => "__builtin_mul_overflow",
|
||
|
|
Int(I32) => "__builtin_smul_overflow",
|
||
|
|
Int(I64) => "__builtin_smulll_overflow",
|
||
|
|
Int(I128) => "__builtin_mul_overflow",
|
||
|
|
|
||
|
|
Uint(U8) => "__builtin_mul_overflow",
|
||
|
|
Uint(U16) => "__builtin_mul_overflow",
|
||
|
|
Uint(U32) => "__builtin_umul_overflow",
|
||
|
|
Uint(U64) => "__builtin_umulll_overflow",
|
||
|
|
Uint(U128) => "__builtin_mul_overflow",
|
||
|
|
|
||
|
|
_ => unreachable!(),
|
||
|
|
},
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
match new_kind {
|
||
|
|
Int(I128) | Uint(U128) => {
|
||
|
|
let func_name =
|
||
|
|
match oop {
|
||
|
|
OverflowOp::Add =>
|
||
|
|
match new_kind {
|
||
|
|
Int(I128) => "__rust_i128_addo",
|
||
|
|
Uint(U128) => "__rust_u128_addo",
|
||
|
|
_ => unreachable!(),
|
||
|
|
},
|
||
|
|
OverflowOp::Sub =>
|
||
|
|
match new_kind {
|
||
|
|
Int(I128) => "__rust_i128_subo",
|
||
|
|
Uint(U128) => "__rust_u128_subo",
|
||
|
|
_ => unreachable!(),
|
||
|
|
},
|
||
|
|
OverflowOp::Mul =>
|
||
|
|
match new_kind {
|
||
|
|
Int(I128) => "__rust_i128_mulo", // TODO(antoyo): use __muloti4d instead?
|
||
|
|
Uint(U128) => "__rust_u128_mulo",
|
||
|
|
_ => unreachable!(),
|
||
|
|
},
|
||
|
|
};
|
||
|
|
let a_type = lhs.get_type();
|
||
|
|
let b_type = rhs.get_type();
|
||
|
|
let param_a = self.context.new_parameter(None, a_type, "a");
|
||
|
|
let param_b = self.context.new_parameter(None, b_type, "b");
|
||
|
|
let result_field = self.context.new_field(None, a_type, "result");
|
||
|
|
let overflow_field = self.context.new_field(None, self.bool_type, "overflow");
|
||
|
|
let return_type = self.context.new_struct_type(None, "result_overflow", &[result_field, overflow_field]);
|
||
|
|
let func = self.context.new_function(None, FunctionType::Extern, return_type.as_type(), &[param_a, param_b], func_name, false);
|
||
|
|
let result = self.context.new_call(None, func, &[lhs, rhs]);
|
||
|
|
let overflow = result.access_field(None, overflow_field);
|
||
|
|
let int_result = result.access_field(None, result_field);
|
||
|
|
return (int_result, overflow);
|
||
|
|
},
|
||
|
|
_ => {
|
||
|
|
match oop {
|
||
|
|
OverflowOp::Mul =>
|
||
|
|
match new_kind {
|
||
|
|
Int(I32) => "__mulosi4",
|
||
|
|
Int(I64) => "__mulodi4",
|
||
|
|
_ => unreachable!(),
|
||
|
|
},
|
||
|
|
_ => unimplemented!("overflow operation for {:?}", new_kind),
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
let intrinsic = self.context.get_builtin_function(&name);
|
||
|
|
let res = self.current_func()
|
||
|
|
// TODO(antoyo): is it correct to use rhs type instead of the parameter typ?
|
||
|
|
.new_local(None, rhs.get_type(), "binopResult")
|
||
|
|
.get_address(None);
|
||
|
|
let overflow = self.overflow_call(intrinsic, &[lhs, rhs, res], None);
|
||
|
|
(res.dereference(None).to_rvalue(), overflow)
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn gcc_icmp(&self, op: IntPredicate, mut lhs: RValue<'gcc>, mut rhs: RValue<'gcc>) -> RValue<'gcc> {
|
||
|
|
let a_type = lhs.get_type();
|
||
|
|
let b_type = rhs.get_type();
|
||
|
|
if self.is_non_native_int_type(a_type) || self.is_non_native_int_type(b_type) {
|
||
|
|
let signed = a_type.is_compatible_with(self.i128_type);
|
||
|
|
let sign =
|
||
|
|
if signed {
|
||
|
|
""
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
"u"
|
||
|
|
};
|
||
|
|
let func_name = format!("__{}cmpti2", sign);
|
||
|
|
let param_a = self.context.new_parameter(None, a_type, "a");
|
||
|
|
let param_b = self.context.new_parameter(None, b_type, "b");
|
||
|
|
let func = self.context.new_function(None, FunctionType::Extern, self.int_type, &[param_a, param_b], func_name, false);
|
||
|
|
let cmp = self.context.new_call(None, func, &[lhs, rhs]);
|
||
|
|
let (op, limit) =
|
||
|
|
match op {
|
||
|
|
IntPredicate::IntEQ => {
|
||
|
|
return self.context.new_comparison(None, ComparisonOp::Equals, cmp, self.context.new_rvalue_one(self.int_type));
|
||
|
|
},
|
||
|
|
IntPredicate::IntNE => {
|
||
|
|
return self.context.new_comparison(None, ComparisonOp::NotEquals, cmp, self.context.new_rvalue_one(self.int_type));
|
||
|
|
},
|
||
|
|
IntPredicate::IntUGT => (ComparisonOp::Equals, 2),
|
||
|
|
IntPredicate::IntUGE => (ComparisonOp::GreaterThanEquals, 1),
|
||
|
|
IntPredicate::IntULT => (ComparisonOp::Equals, 0),
|
||
|
|
IntPredicate::IntULE => (ComparisonOp::LessThanEquals, 1),
|
||
|
|
IntPredicate::IntSGT => (ComparisonOp::Equals, 2),
|
||
|
|
IntPredicate::IntSGE => (ComparisonOp::GreaterThanEquals, 1),
|
||
|
|
IntPredicate::IntSLT => (ComparisonOp::Equals, 0),
|
||
|
|
IntPredicate::IntSLE => (ComparisonOp::LessThanEquals, 1),
|
||
|
|
};
|
||
|
|
self.context.new_comparison(None, op, cmp, self.context.new_rvalue_from_int(self.int_type, limit))
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
let left_type = lhs.get_type();
|
||
|
|
let right_type = rhs.get_type();
|
||
|
|
if left_type != right_type {
|
||
|
|
// NOTE: because libgccjit cannot compare function pointers.
|
||
|
|
if left_type.dyncast_function_ptr_type().is_some() && right_type.dyncast_function_ptr_type().is_some() {
|
||
|
|
lhs = self.context.new_cast(None, lhs, self.usize_type.make_pointer());
|
||
|
|
rhs = self.context.new_cast(None, rhs, self.usize_type.make_pointer());
|
||
|
|
}
|
||
|
|
// NOTE: hack because we try to cast a vector type to the same vector type.
|
||
|
|
else if format!("{:?}", left_type) != format!("{:?}", right_type) {
|
||
|
|
rhs = self.context.new_cast(None, rhs, left_type);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
self.context.new_comparison(None, op.to_gcc_comparison(), lhs, rhs)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn gcc_xor(&self, a: RValue<'gcc>, b: RValue<'gcc>) -> RValue<'gcc> {
|
||
|
|
let a_type = a.get_type();
|
||
|
|
let b_type = b.get_type();
|
||
|
|
if self.is_native_int_type_or_bool(a_type) && self.is_native_int_type_or_bool(b_type) {
|
||
|
|
a ^ b
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
let values = [
|
||
|
|
self.low(a) ^ self.low(b),
|
||
|
|
self.high(a) ^ self.high(b),
|
||
|
|
];
|
||
|
|
self.context.new_array_constructor(None, a_type, &values)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn gcc_shl(&mut self, a: RValue<'gcc>, b: RValue<'gcc>) -> RValue<'gcc> {
|
||
|
|
let a_type = a.get_type();
|
||
|
|
let b_type = b.get_type();
|
||
|
|
let a_native = self.is_native_int_type(a_type);
|
||
|
|
let b_native = self.is_native_int_type(b_type);
|
||
|
|
if a_native && b_native {
|
||
|
|
// FIXME(antoyo): remove the casts when libgccjit can shift an unsigned number by an unsigned number.
|
||
|
|
if a_type.is_unsigned(self) && b_type.is_signed(self) {
|
||
|
|
let a = self.context.new_cast(None, a, b_type);
|
||
|
|
let result = a << b;
|
||
|
|
self.context.new_cast(None, result, a_type)
|
||
|
|
}
|
||
|
|
else if a_type.is_signed(self) && b_type.is_unsigned(self) {
|
||
|
|
let b = self.context.new_cast(None, b, a_type);
|
||
|
|
a << b
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
a << b
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if a_native && !b_native {
|
||
|
|
self.gcc_shl(a, self.gcc_int_cast(b, a_type))
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
// NOTE: we cannot use the ashl builtin because it's calling widen_hi() which uses ashl.
|
||
|
|
let native_int_type = a_type.dyncast_array().expect("get element type");
|
||
|
|
|
||
|
|
let func = self.current_func();
|
||
|
|
let then_block = func.new_block("then");
|
||
|
|
let else_block = func.new_block("else");
|
||
|
|
let after_block = func.new_block("after");
|
||
|
|
let b0_block = func.new_block("b0");
|
||
|
|
let actual_else_block = func.new_block("actual_else");
|
||
|
|
|
||
|
|
let result = func.new_local(None, a_type, "shiftResult");
|
||
|
|
|
||
|
|
let b = self.gcc_int_cast(b, native_int_type);
|
||
|
|
let sixty_four = self.gcc_int(native_int_type, 64);
|
||
|
|
let zero = self.gcc_zero(native_int_type);
|
||
|
|
let condition = self.gcc_icmp(IntPredicate::IntNE, self.gcc_and(b, sixty_four), zero);
|
||
|
|
self.llbb().end_with_conditional(None, condition, then_block, else_block);
|
||
|
|
|
||
|
|
// TODO(antoyo): take endianness into account.
|
||
|
|
let values = [
|
||
|
|
zero,
|
||
|
|
self.low(a) << (b - sixty_four),
|
||
|
|
];
|
||
|
|
let array_value = self.context.new_array_constructor(None, a_type, &values);
|
||
|
|
then_block.add_assignment(None, result, array_value);
|
||
|
|
then_block.end_with_jump(None, after_block);
|
||
|
|
|
||
|
|
let condition = self.gcc_icmp(IntPredicate::IntEQ, b, zero);
|
||
|
|
else_block.end_with_conditional(None, condition, b0_block, actual_else_block);
|
||
|
|
|
||
|
|
b0_block.add_assignment(None, result, a);
|
||
|
|
b0_block.end_with_jump(None, after_block);
|
||
|
|
|
||
|
|
// NOTE: cast low to its unsigned type in order to perform a logical right shift.
|
||
|
|
let unsigned_type = native_int_type.to_unsigned(&self.cx);
|
||
|
|
let casted_low = self.context.new_cast(None, self.low(a), unsigned_type);
|
||
|
|
let shift_value = self.context.new_cast(None, sixty_four - b, unsigned_type);
|
||
|
|
let high_low = self.context.new_cast(None, casted_low >> shift_value, native_int_type);
|
||
|
|
let values = [
|
||
|
|
self.low(a) << b,
|
||
|
|
(self.high(a) << b) | high_low,
|
||
|
|
];
|
||
|
|
|
||
|
|
let array_value = self.context.new_array_constructor(None, a_type, &values);
|
||
|
|
actual_else_block.add_assignment(None, result, array_value);
|
||
|
|
actual_else_block.end_with_jump(None, after_block);
|
||
|
|
|
||
|
|
// NOTE: since jumps were added in a place rustc does not expect, the current block in the
|
||
|
|
// state need to be updated.
|
||
|
|
self.switch_to_block(after_block);
|
||
|
|
|
||
|
|
result.to_rvalue()
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn gcc_bswap(&mut self, mut arg: RValue<'gcc>, width: u64) -> RValue<'gcc> {
|
||
|
|
let arg_type = arg.get_type();
|
||
|
|
if !self.is_native_int_type(arg_type) {
|
||
|
|
let native_int_type = arg_type.dyncast_array().expect("get element type");
|
||
|
|
let lsb = self.context.new_array_access(None, arg, self.context.new_rvalue_from_int(self.int_type, 0)).to_rvalue();
|
||
|
|
let swapped_lsb = self.gcc_bswap(lsb, width / 2);
|
||
|
|
let swapped_lsb = self.context.new_cast(None, swapped_lsb, native_int_type);
|
||
|
|
let msb = self.context.new_array_access(None, arg, self.context.new_rvalue_from_int(self.int_type, 1)).to_rvalue();
|
||
|
|
let swapped_msb = self.gcc_bswap(msb, width / 2);
|
||
|
|
let swapped_msb = self.context.new_cast(None, swapped_msb, native_int_type);
|
||
|
|
|
||
|
|
// NOTE: we also need to swap the two elements here, in addition to swapping inside
|
||
|
|
// the elements themselves like done above.
|
||
|
|
return self.context.new_array_constructor(None, arg_type, &[swapped_msb, swapped_lsb]);
|
||
|
|
}
|
||
|
|
|
||
|
|
// TODO(antoyo): check if it's faster to use string literals and a
|
||
|
|
// match instead of format!.
|
||
|
|
let bswap = self.cx.context.get_builtin_function(&format!("__builtin_bswap{}", width));
|
||
|
|
// FIXME(antoyo): this cast should not be necessary. Remove
|
||
|
|
// when having proper sized integer types.
|
||
|
|
let param_type = bswap.get_param(0).to_rvalue().get_type();
|
||
|
|
if param_type != arg_type {
|
||
|
|
arg = self.bitcast(arg, param_type);
|
||
|
|
}
|
||
|
|
self.cx.context.new_call(None, bswap, &[arg])
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
|
||
|
|
pub fn gcc_int(&self, typ: Type<'gcc>, int: i64) -> RValue<'gcc> {
|
||
|
|
if self.is_native_int_type_or_bool(typ) {
|
||
|
|
self.context.new_rvalue_from_long(typ, i64::try_from(int).expect("i64::try_from"))
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
// NOTE: set the sign in high.
|
||
|
|
self.from_low_high(typ, int, -(int.is_negative() as i64))
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn gcc_uint(&self, typ: Type<'gcc>, int: u64) -> RValue<'gcc> {
|
||
|
|
if self.is_native_int_type_or_bool(typ) {
|
||
|
|
self.context.new_rvalue_from_long(typ, u64::try_from(int).expect("u64::try_from") as i64)
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
self.from_low_high(typ, int as i64, 0)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn gcc_uint_big(&self, typ: Type<'gcc>, num: u128) -> RValue<'gcc> {
|
||
|
|
let low = num as u64;
|
||
|
|
let high = (num >> 64) as u64;
|
||
|
|
if num >> 64 != 0 {
|
||
|
|
// FIXME(antoyo): use a new function new_rvalue_from_unsigned_long()?
|
||
|
|
if self.is_native_int_type(typ) {
|
||
|
|
let low = self.context.new_rvalue_from_long(self.u64_type, low as i64);
|
||
|
|
let high = self.context.new_rvalue_from_long(typ, high as i64);
|
||
|
|
|
||
|
|
let sixty_four = self.context.new_rvalue_from_long(typ, 64);
|
||
|
|
let shift = high << sixty_four;
|
||
|
|
shift | self.context.new_cast(None, low, typ)
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
self.from_low_high(typ, low as i64, high as i64)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if typ.is_i128(self) {
|
||
|
|
let num = self.context.new_rvalue_from_long(self.u64_type, num as u64 as i64);
|
||
|
|
self.gcc_int_cast(num, typ)
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
self.gcc_uint(typ, num as u64)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn gcc_zero(&self, typ: Type<'gcc>) -> RValue<'gcc> {
|
||
|
|
if self.is_native_int_type_or_bool(typ) {
|
||
|
|
self.context.new_rvalue_zero(typ)
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
self.from_low_high(typ, 0, 0)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn gcc_int_width(&self, typ: Type<'gcc>) -> u64 {
|
||
|
|
if self.is_native_int_type_or_bool(typ) {
|
||
|
|
typ.get_size() as u64 * 8
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
// NOTE: the only unsupported types are u128 and i128.
|
||
|
|
128
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
fn bitwise_operation(&self, operation: BinaryOp, a: RValue<'gcc>, mut b: RValue<'gcc>) -> RValue<'gcc> {
|
||
|
|
let a_type = a.get_type();
|
||
|
|
let b_type = b.get_type();
|
||
|
|
let a_native = self.is_native_int_type_or_bool(a_type);
|
||
|
|
let b_native = self.is_native_int_type_or_bool(b_type);
|
||
|
|
if a_native && b_native {
|
||
|
|
if a_type != b_type {
|
||
|
|
b = self.context.new_cast(None, b, a_type);
|
||
|
|
}
|
||
|
|
self.context.new_binary_op(None, operation, a_type, a, b)
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
assert!(!a_native && !b_native, "both types should either be native or non-native for or operation");
|
||
|
|
let native_int_type = a_type.dyncast_array().expect("get element type");
|
||
|
|
let values = [
|
||
|
|
self.context.new_binary_op(None, operation, native_int_type, self.low(a), self.low(b)),
|
||
|
|
self.context.new_binary_op(None, operation, native_int_type, self.high(a), self.high(b)),
|
||
|
|
];
|
||
|
|
self.context.new_array_constructor(None, a_type, &values)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn gcc_or(&self, a: RValue<'gcc>, b: RValue<'gcc>) -> RValue<'gcc> {
|
||
|
|
self.bitwise_operation(BinaryOp::BitwiseOr, a, b)
|
||
|
|
}
|
||
|
|
|
||
|
|
// TODO(antoyo): can we use https://github.com/rust-lang/compiler-builtins/blob/master/src/int/mod.rs#L379 instead?
|
||
|
|
pub fn gcc_int_cast(&self, value: RValue<'gcc>, dest_typ: Type<'gcc>) -> RValue<'gcc> {
|
||
|
|
let value_type = value.get_type();
|
||
|
|
if self.is_native_int_type_or_bool(dest_typ) && self.is_native_int_type_or_bool(value_type) {
|
||
|
|
self.context.new_cast(None, value, dest_typ)
|
||
|
|
}
|
||
|
|
else if self.is_native_int_type_or_bool(dest_typ) {
|
||
|
|
self.context.new_cast(None, self.low(value), dest_typ)
|
||
|
|
}
|
||
|
|
else if self.is_native_int_type_or_bool(value_type) {
|
||
|
|
let dest_element_type = dest_typ.dyncast_array().expect("get element type");
|
||
|
|
|
||
|
|
// NOTE: set the sign of the value.
|
||
|
|
let zero = self.context.new_rvalue_zero(value_type);
|
||
|
|
let is_negative = self.context.new_comparison(None, ComparisonOp::LessThan, value, zero);
|
||
|
|
let is_negative = self.gcc_int_cast(is_negative, dest_element_type);
|
||
|
|
let values = [
|
||
|
|
self.context.new_cast(None, value, dest_element_type),
|
||
|
|
self.context.new_unary_op(None, UnaryOp::Minus, dest_element_type, is_negative),
|
||
|
|
];
|
||
|
|
self.context.new_array_constructor(None, dest_typ, &values)
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
// Since u128 and i128 are the only types that can be unsupported, we know the type of
|
||
|
|
// value and the destination type have the same size, so a bitcast is fine.
|
||
|
|
self.context.new_bitcast(None, value, dest_typ)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
fn int_to_float_cast(&self, signed: bool, value: RValue<'gcc>, dest_typ: Type<'gcc>) -> RValue<'gcc> {
|
||
|
|
let value_type = value.get_type();
|
||
|
|
if self.is_native_int_type_or_bool(value_type) {
|
||
|
|
return self.context.new_cast(None, value, dest_typ);
|
||
|
|
}
|
||
|
|
|
||
|
|
let name_suffix =
|
||
|
|
match self.type_kind(dest_typ) {
|
||
|
|
TypeKind::Float => "tisf",
|
||
|
|
TypeKind::Double => "tidf",
|
||
|
|
kind => panic!("cannot cast a non-native integer to type {:?}", kind),
|
||
|
|
};
|
||
|
|
let sign =
|
||
|
|
if signed {
|
||
|
|
""
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
"un"
|
||
|
|
};
|
||
|
|
let func_name = format!("__float{}{}", sign, name_suffix);
|
||
|
|
let param = self.context.new_parameter(None, value_type, "n");
|
||
|
|
let func = self.context.new_function(None, FunctionType::Extern, dest_typ, &[param], func_name, false);
|
||
|
|
self.context.new_call(None, func, &[value])
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn gcc_int_to_float_cast(&self, value: RValue<'gcc>, dest_typ: Type<'gcc>) -> RValue<'gcc> {
|
||
|
|
self.int_to_float_cast(true, value, dest_typ)
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn gcc_uint_to_float_cast(&self, value: RValue<'gcc>, dest_typ: Type<'gcc>) -> RValue<'gcc> {
|
||
|
|
self.int_to_float_cast(false, value, dest_typ)
|
||
|
|
}
|
||
|
|
|
||
|
|
fn float_to_int_cast(&self, signed: bool, value: RValue<'gcc>, dest_typ: Type<'gcc>) -> RValue<'gcc> {
|
||
|
|
let value_type = value.get_type();
|
||
|
|
if self.is_native_int_type_or_bool(dest_typ) {
|
||
|
|
return self.context.new_cast(None, value, dest_typ);
|
||
|
|
}
|
||
|
|
|
||
|
|
let name_suffix =
|
||
|
|
match self.type_kind(value_type) {
|
||
|
|
TypeKind::Float => "sfti",
|
||
|
|
TypeKind::Double => "dfti",
|
||
|
|
kind => panic!("cannot cast a {:?} to non-native integer", kind),
|
||
|
|
};
|
||
|
|
let sign =
|
||
|
|
if signed {
|
||
|
|
""
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
"uns"
|
||
|
|
};
|
||
|
|
let func_name = format!("__fix{}{}", sign, name_suffix);
|
||
|
|
let param = self.context.new_parameter(None, value_type, "n");
|
||
|
|
let func = self.context.new_function(None, FunctionType::Extern, dest_typ, &[param], func_name, false);
|
||
|
|
self.context.new_call(None, func, &[value])
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn gcc_float_to_int_cast(&self, value: RValue<'gcc>, dest_typ: Type<'gcc>) -> RValue<'gcc> {
|
||
|
|
self.float_to_int_cast(true, value, dest_typ)
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn gcc_float_to_uint_cast(&self, value: RValue<'gcc>, dest_typ: Type<'gcc>) -> RValue<'gcc> {
|
||
|
|
self.float_to_int_cast(false, value, dest_typ)
|
||
|
|
}
|
||
|
|
|
||
|
|
fn high(&self, value: RValue<'gcc>) -> RValue<'gcc> {
|
||
|
|
self.context.new_array_access(None, value, self.context.new_rvalue_from_int(self.int_type, 1))
|
||
|
|
.to_rvalue()
|
||
|
|
}
|
||
|
|
|
||
|
|
fn low(&self, value: RValue<'gcc>) -> RValue<'gcc> {
|
||
|
|
self.context.new_array_access(None, value, self.context.new_rvalue_from_int(self.int_type, 0))
|
||
|
|
.to_rvalue()
|
||
|
|
}
|
||
|
|
|
||
|
|
fn from_low_high(&self, typ: Type<'gcc>, low: i64, high: i64) -> RValue<'gcc> {
|
||
|
|
let native_int_type = typ.dyncast_array().expect("get element type");
|
||
|
|
let values = [
|
||
|
|
self.context.new_rvalue_from_long(native_int_type, low),
|
||
|
|
self.context.new_rvalue_from_long(native_int_type, high),
|
||
|
|
];
|
||
|
|
self.context.new_array_constructor(None, typ, &values)
|
||
|
|
}
|
||
|
|
}
|