X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fcommon.rs;h=19127c7612d8f5ad36d2600bd9daf91b48f393c9;hb=88c058b6147b9db15b03035baaab62c8e4d28ee4;hp=3178ada9ec3e20b501bd8c90703e6fab39efe5fb;hpb=afae271d5d3719eeb92c18bc004bb6d1965a5f3f;p=rust.git diff --git a/src/common.rs b/src/common.rs index 3178ada9ec3..19127c7612d 100644 --- a/src/common.rs +++ b/src/common.rs @@ -1,7 +1,5 @@ -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, @@ -10,12 +8,12 @@ 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; @@ -26,63 +24,26 @@ pub fn const_bytes(&self, bytes: &[u8]) -> RValue<'gcc> { 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::(), 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::(); + 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 { @@ -115,42 +76,25 @@ fn const_undef(&self, typ: Type<'gcc>) -> RValue<'gcc> { } 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 = 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) } @@ -175,17 +119,19 @@ fn const_usize(&self, i: u64) -> RValue<'gcc> { 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)) @@ -195,36 +141,23 @@ fn const_struct(&self, values: &[RValue<'gcc>], packed: bool) -> RValue<'gcc> { 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::>().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 { - // 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 { - // 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) => { @@ -234,7 +167,7 @@ fn scalar_to_backend(&self, cv: Scalar, layout: &abi::Scalar, ty: Type<'gcc>) -> 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); @@ -244,11 +177,8 @@ fn scalar_to_backend(&self, cv: Scalar, layout: &abi::Scalar, ty: Type<'gcc>) -> } 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(); @@ -256,14 +186,14 @@ fn scalar_to_backend(&self, cv: Scalar, layout: &abi::Scalar, ty: Type<'gcc>) -> 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 }, @@ -272,39 +202,38 @@ fn scalar_to_backend(&self, cv: Scalar, layout: &abi::Scalar, ty: Type<'gcc>) -> }, 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); @@ -322,6 +251,7 @@ pub trait SignType<'gcc, 'tcx> { 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> { @@ -353,6 +283,27 @@ fn to_signed(&self, cx: &CodegenCx<'gcc, 'tcx>) -> 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> { @@ -431,11 +382,11 @@ fn is_u64(&self, cx: &CodegenCx<'gcc, 'tcx>) -> bool { } 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 {