-use std::convert::TryFrom;
-use std::convert::TryInto;
-
-use gccjit::{Block, CType, RValue, Type, ToRValue};
+use gccjit::LValue;
+use gccjit::{RValue, Type, ToRValue};
use rustc_codegen_ssa::mir::place::PlaceRef;
use rustc_codegen_ssa::traits::{
BaseTypeMethods,
MiscMethods,
StaticMethods,
};
-use rustc_middle::bug;
use rustc_middle::mir::Mutability;
-use rustc_middle::ty::{layout::TyAndLayout, ScalarInt};
-use rustc_mir::interpret::{Allocation, GlobalAlloc, Scalar};
+use rustc_middle::ty::ScalarInt;
+use rustc_middle::ty::layout::{TyAndLayout, LayoutOf};
+use rustc_middle::mir::interpret::{ConstAllocation, GlobalAlloc, Scalar};
use rustc_span::Symbol;
-use rustc_target::abi::{self, HasDataLayout, LayoutOf, Pointer, Size};
+use rustc_target::abi::{self, HasDataLayout, Pointer, Size};
use crate::consts::const_alloc_to_gcc;
use crate::context::CodegenCx;
bytes_in_context(self, bytes)
}
- fn const_cstr(&self, symbol: Symbol, _null_terminated: bool) -> RValue<'gcc> {
- // TODO: handle null_terminated.
- if let Some(&value) = self.const_cstr_cache.borrow().get(&symbol) {
- return value.to_rvalue();
- }
-
- let global = self.global_string(&*symbol.as_str());
-
- self.const_cstr_cache.borrow_mut().insert(symbol, global.dereference(None));
- global
- }
-
- fn global_string(&self, string: &str) -> RValue<'gcc> {
- // TODO: handle non-null-terminated strings.
+ fn global_string(&self, string: &str) -> LValue<'gcc> {
+ // TODO(antoyo): handle non-null-terminated strings.
let string = self.context.new_string_literal(&*string);
let sym = self.generate_local_symbol_name("str");
- // NOTE: TLS is always off for a string litteral.
- // NOTE: string litterals do not have a link section.
- let global = self.define_global(&sym, self.val_ty(string), false, None)
- .unwrap_or_else(|| bug!("symbol `{}` is already defined", sym));
- self.global_init_block.add_assignment(None, global.dereference(None), string);
- global.to_rvalue()
- //llvm::LLVMRustSetLinkage(global, llvm::Linkage::InternalLinkage);
- }
-
- pub fn inttoptr(&self, block: Block<'gcc>, value: RValue<'gcc>, dest_ty: Type<'gcc>) -> RValue<'gcc> {
- let func = block.get_function();
- let local = func.new_local(None, value.get_type(), "intLocal");
- block.add_assignment(None, local, value);
- let value_address = local.get_address(None);
-
- let ptr = self.context.new_cast(None, value_address, dest_ty.make_pointer());
- ptr.dereference(None).to_rvalue()
- }
-
- pub fn ptrtoint(&self, block: Block<'gcc>, value: RValue<'gcc>, dest_ty: Type<'gcc>) -> RValue<'gcc> {
- // TODO: when libgccjit allow casting from pointer to int, remove this.
- let func = block.get_function();
- let local = func.new_local(None, value.get_type(), "ptrLocal");
- block.add_assignment(None, local, value);
- let ptr_address = local.get_address(None);
-
- let ptr = self.context.new_cast(None, ptr_address, dest_ty.make_pointer());
- ptr.dereference(None).to_rvalue()
+ let global = self.declare_private_global(&sym, self.val_ty(string));
+ global.global_set_initializer_rvalue(string);
+ global
+ // TODO(antoyo): set linkage.
}
-
- /*pub fn const_vector(&self, elements: &[RValue<'gcc>]) -> RValue<'gcc> {
- self.context.new_rvalue_from_vector(None, elements[0].get_type(), elements)
- }*/
}
pub fn bytes_in_context<'gcc, 'tcx>(cx: &CodegenCx<'gcc, 'tcx>, bytes: &[u8]) -> RValue<'gcc> {
let context = &cx.context;
- let typ = context.new_array_type(None, context.new_type::<u8>(), bytes.len() as i32);
- let global = cx.declare_unnamed_global(typ);
- global.global_set_initializer(bytes);
- global.to_rvalue()
+ let byte_type = context.new_type::<u8>();
+ let typ = context.new_array_type(None, byte_type, bytes.len() as i32);
+ let elements: Vec<_> =
+ bytes.iter()
+ .map(|&byte| context.new_rvalue_from_int(byte_type, byte as i32))
+ .collect();
+ context.new_array_constructor(None, typ, &elements)
}
pub fn type_is_pointer<'gcc>(typ: Type<'gcc>) -> bool {
}
fn const_int(&self, typ: Type<'gcc>, int: i64) -> RValue<'gcc> {
- self.context.new_rvalue_from_long(typ, i64::try_from(int).expect("i64::try_from"))
+ self.gcc_int(typ, int)
}
fn const_uint(&self, typ: Type<'gcc>, int: u64) -> RValue<'gcc> {
- self.context.new_rvalue_from_long(typ, u64::try_from(int).expect("u64::try_from") as i64)
+ self.gcc_uint(typ, int)
}
fn const_uint_big(&self, typ: Type<'gcc>, num: u128) -> RValue<'gcc> {
- let num64: Result<i64, _> = num.try_into();
- if let Ok(num) = num64 {
- // FIXME: workaround for a bug where libgccjit is expecting a constant.
- // The operations >> 64 and | low are making the normal case a non-constant.
- return self.context.new_rvalue_from_long(typ, num as i64);
- }
-
- if num >> 64 != 0 {
- // FIXME: use a new function new_rvalue_from_unsigned_long()?
- let low = self.context.new_rvalue_from_long(self.u64_type, num as u64 as i64);
- let high = self.context.new_rvalue_from_long(typ, (num >> 64) as u64 as i64);
-
- let sixty_four = self.context.new_rvalue_from_long(typ, 64);
- (high << sixty_four) | self.context.new_cast(None, low, typ)
- }
- else if typ.is_i128(self) {
- let num = self.context.new_rvalue_from_long(self.u64_type, num as u64 as i64);
- self.context.new_cast(None, num, typ)
- }
- else {
- self.context.new_rvalue_from_long(typ, num as u64 as i64)
- }
+ self.gcc_uint_big(typ, num)
}
fn const_bool(&self, val: bool) -> RValue<'gcc> {
self.const_uint(self.type_i1(), val as u64)
}
+ fn const_i16(&self, i: i16) -> RValue<'gcc> {
+ self.const_int(self.type_i16(), i as i64)
+ }
+
fn const_i32(&self, i: i32) -> RValue<'gcc> {
self.const_int(self.type_i32(), i as i64)
}
fn const_u8(&self, _i: u8) -> RValue<'gcc> {
unimplemented!();
- //self.const_uint(self.type_i8(), i as u64)
}
fn const_real(&self, _t: Type<'gcc>, _val: f64) -> RValue<'gcc> {
unimplemented!();
- //unsafe { llvm::LLVMConstReal(t, val) }
}
fn const_str(&self, s: Symbol) -> (RValue<'gcc>, RValue<'gcc>) {
- let len = s.as_str().len();
- let cs = self.const_ptrcast(self.const_cstr(s, false),
+ let s_str = s.as_str();
+ let str_global = *self.const_str_cache.borrow_mut().entry(s).or_insert_with(|| {
+ self.global_string(s_str)
+ });
+ let len = s_str.len();
+ let cs = self.const_ptrcast(str_global.get_address(None),
self.type_ptr_to(self.layout_of(self.tcx.types.str_).gcc_type(self, true)),
);
(cs, self.const_usize(len as u64))
let fields: Vec<_> = values.iter()
.map(|value| value.get_type())
.collect();
- // TODO: cache the type? It's anonymous, so probably not.
- let name = fields.iter().map(|typ| format!("{:?}", typ)).collect::<Vec<_>>().join("_");
+ // TODO(antoyo): cache the type? It's anonymous, so probably not.
let typ = self.type_struct(&fields, packed);
- let structure = self.global_init_func.new_local(None, typ, &name);
let struct_type = typ.is_struct().expect("struct type");
- for (index, value) in values.iter().enumerate() {
- let field = struct_type.get_field(index as i32);
- let field_lvalue = structure.access_field(None, field);
- self.global_init_block.add_assignment(None, field_lvalue, *value);
- }
- self.lvalue_to_rvalue(structure)
+ self.context.new_struct_constructor(None, struct_type.as_type(), None, values)
}
fn const_to_opt_uint(&self, _v: RValue<'gcc>) -> Option<u64> {
- // TODO
+ // TODO(antoyo)
None
- //try_as_const_integral(v).map(|v| unsafe { llvm::LLVMConstIntGetZExtValue(v) })
}
fn const_to_opt_u128(&self, _v: RValue<'gcc>, _sign_ext: bool) -> Option<u128> {
- // TODO
+ // TODO(antoyo)
None
- /*try_as_const_integral(v).and_then(|v| unsafe {
- let (mut lo, mut hi) = (0u64, 0u64);
- let success = llvm::LLVMRustConstInt128Get(v, sign_ext, &mut hi, &mut lo);
- success.then_some(hi_lo_to_u128(lo, hi))
- })*/
}
- fn scalar_to_backend(&self, cv: Scalar, layout: &abi::Scalar, ty: Type<'gcc>) -> RValue<'gcc> {
+ fn scalar_to_backend(&self, cv: Scalar, layout: abi::Scalar, ty: Type<'gcc>) -> RValue<'gcc> {
let bitsize = if layout.is_bool() { 1 } else { layout.value.size(self).bits() };
match cv {
Scalar::Int(ScalarInt::ZST) => {
Scalar::Int(int) => {
let data = int.assert_bits(layout.value.size(self));
- // FIXME: there's some issues with using the u128 code that follows, so hard-code
+ // FIXME(antoyo): there's some issues with using the u128 code that follows, so hard-code
// the paths for floating-point values.
if ty == self.float_type {
return self.context.new_rvalue_from_double(ty, f32::from_bits(data as u32) as f64);
}
let value = self.const_uint_big(self.type_ix(bitsize), data);
- if layout.value == Pointer {
- self.inttoptr(self.current_block.borrow().expect("block"), value, ty)
- } else {
- self.const_bitcast(value, ty)
- }
+ // TODO(bjorn3): assert size is correct
+ self.const_bitcast(value, ty)
}
Scalar::Ptr(ptr, _size) => {
let (alloc_id, offset) = ptr.into_parts();
match self.tcx.global_alloc(alloc_id) {
GlobalAlloc::Memory(alloc) => {
let init = const_alloc_to_gcc(self, alloc);
+ let alloc = alloc.inner();
let value =
match alloc.mutability {
Mutability::Mut => self.static_addr_of_mut(init, alloc.align, None),
_ => self.static_addr_of(init, alloc.align, None),
};
if !self.sess().fewer_names() {
- // TODO
- //llvm::set_value_name(value, format!("{:?}", ptr.alloc_id).as_bytes());
+ // TODO(antoyo): set value name.
}
value
},
},
GlobalAlloc::Static(def_id) => {
assert!(self.tcx.is_static(def_id));
- self.get_static(def_id)
+ self.get_static(def_id).get_address(None)
},
};
let ptr_type = base_addr.get_type();
let base_addr = self.const_bitcast(base_addr, self.usize_type);
let offset = self.context.new_rvalue_from_long(self.usize_type, offset.bytes() as i64);
let ptr = self.const_bitcast(base_addr + offset, ptr_type);
- let value = ptr.dereference(None);
if layout.value != Pointer {
- self.const_bitcast(value.to_rvalue(), ty)
+ self.const_bitcast(ptr.dereference(None).to_rvalue(), ty)
}
else {
- self.const_bitcast(value.get_address(None), ty)
+ self.const_bitcast(ptr, ty)
}
}
}
}
- fn const_data_from_alloc(&self, alloc: &Allocation) -> Self::Value {
+ fn const_data_from_alloc(&self, alloc: ConstAllocation<'tcx>) -> Self::Value {
const_alloc_to_gcc(self, alloc)
}
- fn from_const_alloc(&self, layout: TyAndLayout<'tcx>, alloc: &Allocation, offset: Size) -> PlaceRef<'tcx, RValue<'gcc>> {
- assert_eq!(alloc.align, layout.align.abi);
+ fn from_const_alloc(&self, layout: TyAndLayout<'tcx>, alloc: ConstAllocation<'tcx>, offset: Size) -> PlaceRef<'tcx, RValue<'gcc>> {
+ assert_eq!(alloc.inner().align, layout.align.abi);
let ty = self.type_ptr_to(layout.gcc_type(self, true));
let value =
if layout.size == Size::ZERO {
- let value = self.const_usize(alloc.align.bytes());
+ let value = self.const_usize(alloc.inner().align.bytes());
self.context.new_cast(None, value, ty)
}
else {
let init = const_alloc_to_gcc(self, alloc);
- let base_addr = self.static_addr_of(init, alloc.align, None);
+ let base_addr = self.static_addr_of(init, alloc.inner().align, None);
let array = self.const_bitcast(base_addr, self.type_i8p());
let value = self.context.new_array_access(None, array, self.const_usize(offset.bytes())).get_address(None);
fn is_signed(&self, cx: &CodegenCx<'gcc, 'tcx>) -> bool;
fn is_unsigned(&self, cx: &CodegenCx<'gcc, 'tcx>) -> bool;
fn to_signed(&self, cx: &CodegenCx<'gcc, 'tcx>) -> Type<'gcc>;
+ fn to_unsigned(&self, cx: &CodegenCx<'gcc, 'tcx>) -> Type<'gcc>;
}
impl<'gcc, 'tcx> SignType<'gcc, 'tcx> for Type<'gcc> {
self.clone()
}
}
+
+ fn to_unsigned(&self, cx: &CodegenCx<'gcc, 'tcx>) -> Type<'gcc> {
+ if self.is_i8(cx) {
+ cx.u8_type
+ }
+ else if self.is_i16(cx) {
+ cx.u16_type
+ }
+ else if self.is_i32(cx) {
+ cx.u32_type
+ }
+ else if self.is_i64(cx) {
+ cx.u64_type
+ }
+ else if self.is_i128(cx) {
+ cx.u128_type
+ }
+ else {
+ self.clone()
+ }
+ }
}
pub trait TypeReflection<'gcc, 'tcx> {
}
fn is_i128(&self, cx: &CodegenCx<'gcc, 'tcx>) -> bool {
- self.unqualified() == cx.context.new_c_type(CType::Int128t)
+ self.unqualified() == cx.i128_type.unqualified()
}
fn is_u128(&self, cx: &CodegenCx<'gcc, 'tcx>) -> bool {
- self.unqualified() == cx.context.new_c_type(CType::UInt128t)
+ self.unqualified() == cx.u128_type.unqualified()
}
fn is_f32(&self, cx: &CodegenCx<'gcc, 'tcx>) -> bool {
projects / rust.git / blobdiff