Generalized base::coerce_unsized_into

denismerigoux · denismerigoux · commit 8b9ff39ee06f · 2018-10-23T15:40:01.000+02:00
diff --git a/src/librustc_codegen_llvm/asm.rs b/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()));
         }
diff --git a/src/librustc_codegen_llvm/base.rs b/src/librustc_codegen_llvm/base.rs
@@ -66,7 +66,7 @@ use monomorphize::partitioning::{self, PartitioningStrategy, CodegenUnit, Codege
 use rustc_codegen_utils::symbol_names_test;
 use time_graph;
 use mono_item::{MonoItem, BaseMonoItemExt, MonoItemExt};
-use type_of::LayoutLlvmExt;
+
 use rustc::util::nodemap::{FxHashMap, DefIdSet};
 use CrateInfo;
 use rustc_data_structures::small_c_str::SmallCStr;
@@ -274,22 +274,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)
diff --git a/src/librustc_codegen_llvm/builder.rs b/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;
@@ -533,6 +536,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" {
diff --git a/src/librustc_codegen_llvm/glue.rs b/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()))
         }
diff --git a/src/librustc_codegen_llvm/interfaces/backend.rs b/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;
 }
diff --git a/src/librustc_codegen_llvm/interfaces/builder.rs b/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);
diff --git a/src/librustc_codegen_llvm/interfaces/mod.rs b/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 {}
diff --git a/src/librustc_codegen_llvm/interfaces/type_.rs b/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> {}
diff --git a/src/librustc_codegen_llvm/intrinsic.rs b/src/librustc_codegen_llvm/intrinsic.rs
@@ -149,7 +149,7 @@ impl IntrinsicCallMethods<'a, 'll, 'tcx> for Builder<'a, 'll, 'tcx, &'ll Value>
                 let tp_ty = substs.type_at(0);
                 if let OperandValue::Pair(_, meta) = args[0].val {
                     let (llsize, _) =
-                        glue::size_and_align_of_dst(&self, tp_ty, Some(meta));
+                        glue::size_and_align_of_dst(self, tp_ty, Some(meta));
                     llsize
                 } else {
                     cx.const_usize(cx.size_of(tp_ty).bytes())
@@ -163,7 +163,7 @@ impl IntrinsicCallMethods<'a, 'll, 'tcx> for Builder<'a, 'll, 'tcx, &'ll Value>
                 let tp_ty = substs.type_at(0);
                 if let OperandValue::Pair(_, meta) = args[0].val {
                     let (_, llalign) =
-                        glue::size_and_align_of_dst(&self, tp_ty, Some(meta));
+                        glue::size_and_align_of_dst(self, tp_ty, Some(meta));
                     llalign
                 } else {
                     cx.const_usize(cx.align_of(tp_ty).abi())
@@ -341,9 +341,9 @@ impl IntrinsicCallMethods<'a, 'll, 'tcx> for Builder<'a, 'll, 'tcx, &'ll Value>
                                     cx.type_bool()
                                 );
 
-                                let dest = result.project_field(&self, 0);
+                                let dest = result.project_field(self, 0);
                                 &self.store(val, dest.llval, dest.align);
-                                let dest = result.project_field(&self, 1);
+                                let dest = result.project_field(self, 1);
                                 &self.store(overflow, dest.llval, dest.align);
 
                                 return;
@@ -481,9 +481,9 @@ impl IntrinsicCallMethods<'a, 'll, 'tcx> for Builder<'a, 'll, 'tcx, &'ll Value>
                                 &self.cx().type_bool()
                             );
 
-                            let dest = result.project_field(&self, 0);
+                            let dest = result.project_field(self, 0);
                             &self.store(val, dest.llval, dest.align);
-                            let dest = result.project_field(&self, 1);
+                            let dest = result.project_field(self, 1);
                             &self.store(success, dest.llval, dest.align);
                             return;
                         } else {
@@ -639,7 +639,7 @@ impl IntrinsicCallMethods<'a, 'll, 'tcx> for Builder<'a, 'll, 'tcx, &'ll Value>
                             };
                             let arg = PlaceRef::new_sized(ptr, arg.layout, align);
                             (0..contents.len()).map(|i| {
-                                arg.project_field(bx, i).load(bx).immediate()
+                                bx.load_ref(&arg.project_field(bx, i)).immediate()
                             }).collect()
                         }
                         intrinsics::Type::Pointer(_, Some(ref llvm_elem), _) => {
@@ -690,7 +690,7 @@ impl IntrinsicCallMethods<'a, 'll, 'tcx> for Builder<'a, 'll, 'tcx, &'ll Value>
                         assert!(!flatten);
 
                         for i in 0..elems.len() {
-                            let dest = result.project_field(&self, i);
+                            let dest = result.project_field(self, i);
                             let val = &self.extract_value(val, i as u64);
                             &self.store(val, dest.llval, dest.align);
                         }
@@ -707,7 +707,7 @@ impl IntrinsicCallMethods<'a, 'll, 'tcx> for Builder<'a, 'll, 'tcx, &'ll Value>
                 &self.store(llval, ptr, result.align);
             } else {
                 OperandRef::from_immediate_or_packed_pair(&self, llval, result.layout)
-                    .val.store(&self, result);
+                    .val.store(self, result);
             }
         }
     }
diff --git a/src/librustc_codegen_llvm/meth.rs b/src/librustc_codegen_llvm/meth.rs
@@ -52,11 +52,11 @@ impl<'a, 'tcx> VirtualIndex {
         ptr
     }
 
-    pub fn get_usize(
+    pub fn get_usize<Bx: BuilderMethods<'a, 'll, 'tcx>>(
         self,
-        bx: &Builder<'a, 'll, 'tcx, &'ll Value>,
-        llvtable: &'ll Value
-    ) -> &'ll Value {
+        bx: &Bx,
+        llvtable: <Bx::CodegenCx as Backend>::Value
+    ) -> <Bx::CodegenCx as Backend>::Value {
         // Load the data pointer from the object.
         debug!("get_int({:?}, {:?})", llvtable, self);
 
diff --git a/src/librustc_codegen_llvm/mir/block.rs b/src/librustc_codegen_llvm/mir/block.rs
@@ -165,8 +165,8 @@ impl FunctionCx<'a, 'll, 'tcx, &'ll Value> {
                     bx.cleanup_ret(cleanup_pad, None);
                 } else {
                     let slot = self.get_personality_slot(&bx);
-                    let lp0 = slot.project_field(&bx, 0).load(&bx).immediate();
-                    let lp1 = slot.project_field(&bx, 1).load(&bx).immediate();
+                    let lp0 = &bx.load_ref(&slot.project_field(&bx, 0)).immediate();
+                    let lp1 = &bx.load_ref(&slot.project_field(&bx, 1)).immediate();
                     slot.storage_dead(&bx);
 
                     if !bx.sess().target.target.options.custom_unwind_resume {
@@ -793,7 +793,7 @@ impl FunctionCx<'a, 'll, 'tcx, &'ll Value> {
             let tuple_ptr = PlaceRef::new_sized(llval, tuple.layout, align);
             for i in 0..tuple.layout.fields.count() {
                 let field_ptr = tuple_ptr.project_field(bx, i);
-                self.codegen_argument(bx, field_ptr.load(bx), llargs, &args[i]);
+                self.codegen_argument(bx, bx.load_ref(&field_ptr), llargs, &args[i]);
             }
         } else if let Ref(_, Some(_), _) = tuple.val {
             bug!("closure arguments must be sized")
@@ -952,7 +952,7 @@ impl FunctionCx<'a, 'll, 'tcx, &'ll Value> {
                     let place = PlaceRef::alloca(bx, dst_layout, "transmute_temp");
                     place.storage_live(bx);
                     self.codegen_transmute_into(bx, src, place);
-                    let op = place.load(bx);
+                    let op = bx.load_ref(&place);
                     place.storage_dead(bx);
                     self.locals[index] = LocalRef::Operand(Some(op));
                 }
@@ -990,7 +990,7 @@ impl FunctionCx<'a, 'll, 'tcx, &'ll Value> {
             Nothing => (),
             Store(dst) => ret_ty.store(bx, llval, dst),
             IndirectOperand(tmp, index) => {
-                let op = tmp.load(bx);
+                let op = bx.load_ref(&tmp);
                 tmp.storage_dead(bx);
                 self.locals[index] = LocalRef::Operand(Some(op));
             }
@@ -1000,7 +1000,7 @@ impl FunctionCx<'a, 'll, 'tcx, &'ll Value> {
                     let tmp = PlaceRef::alloca(bx, ret_ty.layout, "tmp_ret");
                     tmp.storage_live(bx);
                     ret_ty.store(bx, llval, tmp);
-                    let op = tmp.load(bx);
+                    let op = bx.load_ref(&tmp);
                     tmp.storage_dead(bx);
                     op
                 } else {
diff --git a/src/librustc_codegen_llvm/mir/mod.rs b/src/librustc_codegen_llvm/mir/mod.rs
@@ -566,7 +566,7 @@ fn arg_local_refs(
             let indirect_operand = OperandValue::Pair(llarg, llextra);
 
             let tmp = PlaceRef::alloca_unsized_indirect(bx, arg.layout, &name);
-            indirect_operand.store(&bx, tmp);
+            indirect_operand.store(bx, tmp);
             tmp
         } else {
             let tmp = PlaceRef::alloca(bx, arg.layout, &name);
diff --git a/src/librustc_codegen_llvm/mir/operand.rs b/src/librustc_codegen_llvm/mir/operand.rs
diff --git a/src/librustc_codegen_llvm/mir/place.rs b/src/librustc_codegen_llvm/mir/place.rs
diff --git a/src/librustc_codegen_llvm/type_.rs b/src/librustc_codegen_llvm/type_.rs
diff --git a/src/librustc_codegen_llvm/value.rs b/src/librustc_codegen_llvm/value.rs

Original file line number	Diff line number	Diff line change
`@@ -37,11 +37,11 @@ pub fn codegen_inline_asm(`
`37`	`37`	`let mut indirect_outputs = vec![];`
`38`	`38`	`for (i, (out, place)) in ia.outputs.iter().zip(&outputs).enumerate() {`
`39`	`39`	`if out.is_rw {`
`40`		`- inputs.push(place.load(bx).immediate());`
	`40`	`+ inputs.push(bx.load_ref(place).immediate());`
`41`	`41`	`ext_constraints.push(i.to_string());`
`42`	`42`	`}`
`43`	`43`	`if out.is_indirect {`
`44`		`- indirect_outputs.push(place.load(bx).immediate());`
	`44`	`+ indirect_outputs.push(bx.load_ref(place).immediate());`
`45`	`45`	`} else {`
`46`	`46`	`output_types.push(place.layout.llvm_type(bx.cx()));`
`47`	`47`	`}`