Generalized base::coerce_unsized_into

Author: denismerigoux

src/librustc_codegen_llvm/asm.rs

@@ -37,11 +37,11 @@ pub fn codegen_inline_asm(
     let mut indirect_outputs = vec![];
     for (i, (out, place)) in ia.outputs.iter().zip(&outputs).enumerate() {
         if out.is_rw {
-            inputs.push(place.load(bx).immediate());
+            inputs.push(bx.load_ref(place).immediate());
             ext_constraints.push(i.to_string());
         }
         if out.is_indirect {
-            indirect_outputs.push(place.load(bx).immediate());
+            indirect_outputs.push(bx.load_ref(place).immediate());
         } else {
             output_types.push(place.layout.llvm_type(bx.cx()));
         }

src/librustc_codegen_llvm/base.rs

@@ -275,22 +275,23 @@ pub fn unsize_thin_ptr<'a, 'll: 'a, 'tcx: 'll, Bx: BuilderMethods<'a, 'll, 'tcx>
 
 /// Coerce `src`, which is a reference to a value of type `src_ty`,
 /// to a value of type `dst_ty` and store the result in `dst`
-pub fn coerce_unsized_into(
-    bx: &Builder<'a, 'll, 'tcx, &'ll Value>,
-    src: PlaceRef<'tcx, &'ll Value>,
-    dst: PlaceRef<'tcx, &'ll Value>
-) {
+pub fn coerce_unsized_into<'a, 'll: 'a, 'tcx: 'll, Bx: BuilderMethods<'a, 'll, 'tcx>>(
+    bx: &Bx,
+    src: PlaceRef<'tcx, <Bx::CodegenCx as Backend>::Value>,
+    dst: PlaceRef<'tcx, <Bx::CodegenCx as Backend>::Value>
+) where &'a Bx::CodegenCx: LayoutOf<Ty = Ty<'tcx>, TyLayout = TyLayout<'tcx>> + HasTyCtxt<'tcx>
+{
     let src_ty = src.layout.ty;
     let dst_ty = dst.layout.ty;
     let coerce_ptr = || {
-        let (base, info) = match src.load(bx).val {
+        let (base, info) = match bx.load_ref(&src).val {
             OperandValue::Pair(base, info) => {
                 // fat-ptr to fat-ptr unsize preserves the vtable
                 // i.e. &'a fmt::Debug+Send => &'a fmt::Debug
                 // So we need to pointercast the base to ensure
                 // the types match up.
                 let thin_ptr = dst.layout.field(bx.cx(), abi::FAT_PTR_ADDR);
-                (bx.pointercast(base, thin_ptr.llvm_type(bx.cx())), info)
+                (bx.pointercast(base, bx.cx().backend_type(&thin_ptr)), info)
             }
             OperandValue::Immediate(base) => {
                 unsize_thin_ptr(bx, base, src_ty, dst_ty)

src/librustc_codegen_llvm/builder.rs

@@ -13,15 +13,18 @@ use llvm::{self, False, OperandBundleDef, BasicBlock};
 use common::{self, *};
 use context::CodegenCx;
 use type_::Type;
+use type_of::LayoutLlvmExt;
 use value::Value;
 use libc::{c_uint, c_char};
 use rustc::ty::TyCtxt;
-use rustc::ty::layout::{Align, Size};
+use rustc::ty::layout::{self, Align, Size};
 use rustc::session::{config, Session};
 use rustc_data_structures::small_c_str::SmallCStr;
 use interfaces::*;
 use syntax;
-
+use base;
+use mir::operand::{OperandValue, OperandRef};
+use mir::place::PlaceRef;
 use std::borrow::Cow;
 use std::ops::Range;
 use std::ptr;
@@ -531,6 +534,73 @@ impl BuilderMethods<'a, 'll, 'tcx>
         }
     }
 
+    fn load_ref(
+        &self,
+        ptr: &PlaceRef<'tcx, &'ll Value>
+    ) -> OperandRef<'tcx, &'ll Value> {
+        debug!("PlaceRef::load: {:?}", ptr);
+
+        assert_eq!(ptr.llextra.is_some(), ptr.layout.is_unsized());
+
+        if ptr.layout.is_zst() {
+            return OperandRef::new_zst(self.cx(), ptr.layout);
+        }
+
+        let scalar_load_metadata = |load, scalar: &layout::Scalar| {
+            let vr = scalar.valid_range.clone();
+            match scalar.value {
+                layout::Int(..) => {
+                    let range = scalar.valid_range_exclusive(self.cx());
+                    if range.start != range.end {
+                        &self.range_metadata(load, range);
+                    }
+                }
+                layout::Pointer if vr.start() < vr.end() && !vr.contains(&0) => {
+                    &self.nonnull_metadata(load);
+                }
+                _ => {}
+            }
+        };
+
+        let val = if let Some(llextra) = ptr.llextra {
+            OperandValue::Ref(ptr.llval, Some(llextra), ptr.align)
+        } else if ptr.layout.is_llvm_immediate() {
+            let mut const_llval = None;
+            unsafe {
+                if let Some(global) = llvm::LLVMIsAGlobalVariable(ptr.llval) {
+                    if llvm::LLVMIsGlobalConstant(global) == llvm::True {
+                        const_llval = llvm::LLVMGetInitializer(global);
+                    }
+                }
+            }
+            let llval = const_llval.unwrap_or_else(|| {
+                let load = &self.load(ptr.llval, ptr.align);
+                if let layout::Abi::Scalar(ref scalar) = ptr.layout.abi {
+                    scalar_load_metadata(load, scalar);
+                }
+                load
+            });
+            OperandValue::Immediate(base::to_immediate(self, llval, ptr.layout))
+        } else if let layout::Abi::ScalarPair(ref a, ref b) = ptr.layout.abi {
+            let load = |i, scalar: &layout::Scalar| {
+                let llptr = self.struct_gep(ptr.llval, i as u64);
+                let load = self.load(llptr, ptr.align);
+                scalar_load_metadata(load, scalar);
+                if scalar.is_bool() {
+                    self.trunc(load, self.cx().type_i1())
+                } else {
+                    load
+                }
+            };
+            OperandValue::Pair(load(0, a), load(1, b))
+        } else {
+            OperandValue::Ref(ptr.llval, None, ptr.align)
+        };
+
+        OperandRef { val, layout: ptr.layout }
+    }
+
+
 
     fn range_metadata(&self, load: &'ll Value, range: Range<u128>) {
         if self.sess().target.target.arch == "amdgpu" {

src/librustc_codegen_llvm/glue.rs

@@ -14,23 +14,25 @@
 
 use std;
 
-use builder::Builder;
 use common::*;
 use meth;
-use rustc::ty::layout::LayoutOf;
+use rustc::ty::layout::{LayoutOf, TyLayout, HasTyCtxt};
 use rustc::ty::{self, Ty};
-use value::Value;
 use interfaces::*;
 
-pub fn size_and_align_of_dst(
-    bx: &Builder<'_, 'll, 'tcx, &'ll Value>,
+pub fn size_and_align_of_dst<'a, 'll: 'a, 'tcx: 'll,
+    Bx: BuilderMethods<'a, 'll, 'tcx>
+    >(
+    bx: &Bx,
     t: Ty<'tcx>,
-    info: Option<&'ll Value>
-) -> (&'ll Value, &'ll Value) {
+    info: Option<<Bx::CodegenCx as Backend>::Value>
+) -> (<Bx::CodegenCx as Backend>::Value, <Bx::CodegenCx as Backend>::Value)  where
+    &'a Bx::CodegenCx: LayoutOf<Ty = Ty<'tcx>, TyLayout = TyLayout<'tcx>> + HasTyCtxt<'tcx>
+{
     debug!("calculate size of DST: {}; with lost info: {:?}",
            t, info);
     if bx.cx().type_is_sized(t) {
-        let (size, align) = bx.cx().size_and_align_of(t);
+        let (size, align) = bx.cx().layout_of(t).size_and_align();
         debug!("size_and_align_of_dst t={} info={:?} size: {:?} align: {:?}",
                t, info, size, align);
         let size = bx.cx().const_usize(size.bytes());
@@ -47,7 +49,7 @@ pub fn size_and_align_of_dst(
             let unit = t.sequence_element_type(bx.tcx());
             // The info in this case is the length of the str, so the size is that
             // times the unit size.
-            let (size, align) = bx.cx().size_and_align_of(unit);
+            let (size, align) = bx.cx().layout_of(unit).size_and_align();
             (bx.mul(info.unwrap(), bx.cx().const_usize(size.bytes())),
              bx.cx().const_usize(align.abi()))
         }

src/librustc_codegen_llvm/interfaces/backend.rs

@@ -8,11 +8,11 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::fmt::Debug;
+use super::CodegenObject;
 
 pub trait Backend {
-    type Value : Debug + PartialEq + Copy;
+    type Value : CodegenObject;
     type BasicBlock;
-    type Type : Debug + PartialEq + Copy;
+    type Type : CodegenObject;
     type Context;
 }

src/librustc_codegen_llvm/interfaces/builder.rs

@@ -16,6 +16,8 @@ use rustc::session::Session;
 use builder::MemFlags;
 use super::backend::Backend;
 use super::CodegenMethods;
+use mir::place::PlaceRef;
+use mir::operand::OperandRef;
 
 use std::borrow::Cow;
 use std::ops::Range;
@@ -228,6 +230,10 @@ pub trait BuilderMethods<'a, 'll :'a, 'tcx: 'll> : HasCodegen<'a, 'll, 'tcx> {
         ptr: <Self::CodegenCx as Backend>::Value,
         order: AtomicOrdering, align: Align
     ) -> <Self::CodegenCx as Backend>::Value;
+    fn load_ref(
+        &self,
+        &PlaceRef<'tcx,<Self::CodegenCx as Backend>::Value>
+    ) -> OperandRef<'tcx, <Self::CodegenCx as Backend>::Value>;
 
     fn range_metadata(&self, load: <Self::CodegenCx as Backend>::Value, range: Range<u128>);
     fn nonnull_metadata(&self, load: <Self::CodegenCx as Backend>::Value);

src/librustc_codegen_llvm/interfaces/mod.rs

@@ -26,6 +26,10 @@ pub use self::statics::StaticMethods;
 pub use self::misc::MiscMethods;
 pub use self::debuginfo::DebugInfoMethods;
 
+use std::fmt;
+
 pub trait CodegenMethods<'ll, 'tcx: 'll> :
     Backend + TypeMethods<'ll, 'tcx> + MiscMethods<'tcx> + ConstMethods +
     StaticMethods<'tcx> + DebugInfoMethods<'tcx> {}
+
+pub trait CodegenObject : Copy + PartialEq + fmt::Debug {}

src/librustc_codegen_llvm/interfaces/type_.rs

@@ -85,6 +85,8 @@ pub trait DerivedTypeMethods<'tcx> : Backend {
 
 pub trait LayoutTypeMethods<'tcx> : Backend {
     fn backend_type(&self, ty: &TyLayout<'tcx>) -> Self::Type;
+    fn immediate_backend_type(&self, ty: &TyLayout<'tcx>) -> Self::Type;
+    fn is_backend_immediate(&self, ty: &TyLayout<'tcx>) -> bool;
     fn scalar_pair_element_backend_type<'a>(
         &self,
         ty: &TyLayout<'tcx>,
@@ -93,4 +95,5 @@ pub trait LayoutTypeMethods<'tcx> : Backend {
     ) -> Self::Type;
 }
 
-pub trait TypeMethods<'a, 'tcx: 'a> : BaseTypeMethods<'a, 'tcx> + DerivedTypeMethods<'tcx> + LayoutTypeMethods<'tcx> {}
+pub trait TypeMethods<'a, 'tcx: 'a> :
+    BaseTypeMethods<'a, 'tcx> + DerivedTypeMethods<'tcx> + LayoutTypeMethods<'tcx> {}