Use implicit deref instead of BuilderMethods::cx() at more places

bjorn3 · bjorn3 · commit 17ef2495fce5 · 2019-03-01T13:23:41.000+01:00
diff --git a/src/librustc_codegen_llvm/builder.rs b/src/librustc_codegen_llvm/builder.rs
@@ -1472,6 +1472,7 @@ impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
 
 impl StaticBuilderMethods<'tcx> for Builder<'a, 'll, 'tcx> {
     fn get_static(&self, def_id: DefId) -> &'ll Value {
+        // Forward to the `get_static` method of `CodegenCx`
         self.cx().get_static(def_id)
     }
 }
diff --git a/src/librustc_codegen_ssa/base.rs b/src/librustc_codegen_ssa/base.rs
@@ -21,7 +21,7 @@ use rustc::middle::lang_items::StartFnLangItem;
 use rustc::middle::weak_lang_items;
 use rustc::mir::mono::{Stats, CodegenUnitNameBuilder};
 use rustc::ty::{self, Ty, TyCtxt};
-use rustc::ty::layout::{self, Align, TyLayout, LayoutOf, VariantIdx, HasTyCtxt};
+use rustc::ty::layout::{self, Align, TyLayout, VariantIdx, HasTyCtxt};
 use rustc::ty::query::Providers;
 use rustc::middle::cstore::{self, LinkagePreference};
 use rustc::util::common::{time, print_time_passes_entry};
@@ -162,16 +162,16 @@ pub fn compare_simd_types<'a, 'tcx: 'a, Bx: BuilderMethods<'a, 'tcx>>(
 /// The `old_info` argument is a bit funny. It is intended for use
 /// in an upcast, where the new vtable for an object will be derived
 /// from the old one.
-pub fn unsized_info<'tcx, Cx: CodegenMethods<'tcx>>(
-    cx: &Cx,
+pub fn unsized_info<'a, 'tcx: 'a, Bx: BuilderMethods<'a, 'tcx>>(
+    bx: &Bx,
     source: Ty<'tcx>,
     target: Ty<'tcx>,
-    old_info: Option<Cx::Value>,
-) -> Cx::Value {
-    let (source, target) = cx.tcx().struct_lockstep_tails(source, target);
+    old_info: Option<Bx::Value>,
+) -> Bx::Value {
+    let (source, target) = bx.tcx().struct_lockstep_tails(source, target);
     match (&source.sty, &target.sty) {
         (&ty::Array(_, len), &ty::Slice(_)) => {
-            cx.const_usize(len.unwrap_usize(cx.tcx()))
+            bx.const_usize(len.unwrap_usize(bx.tcx()))
         }
         (&ty::Dynamic(..), &ty::Dynamic(..)) => {
             // For now, upcasts are limited to changes in marker
@@ -180,10 +180,10 @@ pub fn unsized_info<'tcx, Cx: CodegenMethods<'tcx>>(
             old_info.expect("unsized_info: missing old info for trait upcast")
         }
         (_, &ty::Dynamic(ref data, ..)) => {
-            let vtable_ptr = cx.layout_of(cx.tcx().mk_mut_ptr(target))
-                .field(cx, FAT_PTR_EXTRA);
-            cx.const_ptrcast(meth::get_vtable(cx, source, data.principal()),
-                            cx.backend_type(vtable_ptr))
+            let vtable_ptr = bx.layout_of(bx.tcx().mk_mut_ptr(target))
+                .field(bx, FAT_PTR_EXTRA);
+            bx.const_ptrcast(meth::get_vtable(bx.cx(), source, data.principal()),
+                            bx.backend_type(vtable_ptr))
         }
         _ => bug!("unsized_info: invalid unsizing {:?} -> {:?}",
                   source,
@@ -206,40 +206,40 @@ pub fn unsize_thin_ptr<'a, 'tcx: 'a, Bx: BuilderMethods<'a, 'tcx>>(
          &ty::RawPtr(ty::TypeAndMut { ty: b, .. })) |
         (&ty::RawPtr(ty::TypeAndMut { ty: a, .. }),
          &ty::RawPtr(ty::TypeAndMut { ty: b, .. })) => {
-            assert!(bx.cx().type_is_sized(a));
-            let ptr_ty = bx.cx().type_ptr_to(bx.cx().backend_type(bx.cx().layout_of(b)));
-            (bx.pointercast(src, ptr_ty), unsized_info(bx.cx(), a, b, None))
+            assert!(bx.type_is_sized(a));
+            let ptr_ty = bx.type_ptr_to(bx.backend_type(bx.layout_of(b)));
+            (bx.pointercast(src, ptr_ty), unsized_info(bx, a, b, None))
         }
         (&ty::Adt(def_a, _), &ty::Adt(def_b, _)) if def_a.is_box() && def_b.is_box() => {
             let (a, b) = (src_ty.boxed_ty(), dst_ty.boxed_ty());
-            assert!(bx.cx().type_is_sized(a));
-            let ptr_ty = bx.cx().type_ptr_to(bx.cx().backend_type(bx.cx().layout_of(b)));
-            (bx.pointercast(src, ptr_ty), unsized_info(bx.cx(), a, b, None))
+            assert!(bx.type_is_sized(a));
+            let ptr_ty = bx.type_ptr_to(bx.backend_type(bx.layout_of(b)));
+            (bx.pointercast(src, ptr_ty), unsized_info(bx, a, b, None))
         }
         (&ty::Adt(def_a, _), &ty::Adt(def_b, _)) => {
             assert_eq!(def_a, def_b);
 
-            let src_layout = bx.cx().layout_of(src_ty);
-            let dst_layout = bx.cx().layout_of(dst_ty);
+            let src_layout = bx.layout_of(src_ty);
+            let dst_layout = bx.layout_of(dst_ty);
             let mut result = None;
             for i in 0..src_layout.fields.count() {
-                let src_f = src_layout.field(bx.cx(), i);
+                let src_f = src_layout.field(bx, i);
                 assert_eq!(src_layout.fields.offset(i).bytes(), 0);
                 assert_eq!(dst_layout.fields.offset(i).bytes(), 0);
                 if src_f.is_zst() {
                     continue;
                 }
                 assert_eq!(src_layout.size, src_f.size);
 
-                let dst_f = dst_layout.field(bx.cx(), i);
+                let dst_f = dst_layout.field(bx, i);
                 assert_ne!(src_f.ty, dst_f.ty);
                 assert_eq!(result, None);
                 result = Some(unsize_thin_ptr(bx, src, src_f.ty, dst_f.ty));
             }
             let (lldata, llextra) = result.unwrap();
             // HACK(eddyb) have to bitcast pointers until LLVM removes pointee types.
-            (bx.bitcast(lldata, bx.cx().scalar_pair_element_backend_type(dst_layout, 0, true)),
-             bx.bitcast(llextra, bx.cx().scalar_pair_element_backend_type(dst_layout, 1, true)))
+            (bx.bitcast(lldata, bx.scalar_pair_element_backend_type(dst_layout, 0, true)),
+             bx.bitcast(llextra, bx.scalar_pair_element_backend_type(dst_layout, 1, true)))
         }
         _ => bug!("unsize_thin_ptr: called on bad types"),
     }
@@ -261,8 +261,8 @@ pub fn coerce_unsized_into<'a, 'tcx: 'a, Bx: BuilderMethods<'a, 'tcx>>(
                 // 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(), FAT_PTR_ADDR);
-                (bx.pointercast(base, bx.cx().backend_type(thin_ptr)), info)
+                let thin_ptr = dst.layout.field(bx, FAT_PTR_ADDR);
+                (bx.pointercast(base, bx.backend_type(thin_ptr)), info)
             }
             OperandValue::Immediate(base) => {
                 unsize_thin_ptr(bx, base, src_ty, dst_ty)
@@ -323,16 +323,16 @@ fn cast_shift_rhs<'a, 'tcx: 'a, Bx: BuilderMethods<'a, 'tcx>>(
 ) -> Bx::Value {
     // Shifts may have any size int on the rhs
     if op.is_shift() {
-        let mut rhs_llty = bx.cx().val_ty(rhs);
-        let mut lhs_llty = bx.cx().val_ty(lhs);
-        if bx.cx().type_kind(rhs_llty) == TypeKind::Vector {
-            rhs_llty = bx.cx().element_type(rhs_llty)
+        let mut rhs_llty = bx.val_ty(rhs);
+        let mut lhs_llty = bx.val_ty(lhs);
+        if bx.type_kind(rhs_llty) == TypeKind::Vector {
+            rhs_llty = bx.element_type(rhs_llty)
         }
-        if bx.cx().type_kind(lhs_llty) == TypeKind::Vector {
-            lhs_llty = bx.cx().element_type(lhs_llty)
+        if bx.type_kind(lhs_llty) == TypeKind::Vector {
+            lhs_llty = bx.element_type(lhs_llty)
         }
-        let rhs_sz = bx.cx().int_width(rhs_llty);
-        let lhs_sz = bx.cx().int_width(lhs_llty);
+        let rhs_sz = bx.int_width(rhs_llty);
+        let lhs_sz = bx.int_width(lhs_llty);
         if lhs_sz < rhs_sz {
             bx.trunc(rhs, lhs_llty)
         } else if lhs_sz > rhs_sz {
@@ -360,8 +360,8 @@ pub fn from_immediate<'a, 'tcx: 'a, Bx: BuilderMethods<'a, 'tcx>>(
     bx: &mut Bx,
     val: Bx::Value
 ) -> Bx::Value {
-    if bx.cx().val_ty(val) == bx.cx().type_i1() {
-        bx.zext(val, bx.cx().type_i8())
+    if bx.val_ty(val) == bx.type_i1() {
+        bx.zext(val, bx.type_i8())
     } else {
         val
     }
@@ -384,7 +384,7 @@ pub fn to_immediate_scalar<'a, 'tcx: 'a, Bx: BuilderMethods<'a, 'tcx>>(
     scalar: &layout::Scalar,
 ) -> Bx::Value {
     if scalar.is_bool() {
-        return bx.trunc(val, bx.cx().type_i1());
+        return bx.trunc(val, bx.type_i1());
     }
     val
 }
@@ -403,7 +403,7 @@ pub fn memcpy_ty<'a, 'tcx: 'a, Bx: BuilderMethods<'a, 'tcx>>(
         return;
     }
 
-    bx.memcpy(dst, dst_align, src, src_align, bx.cx().const_usize(size), flags);
+    bx.memcpy(dst, dst_align, src, src_align, bx.const_usize(size), flags);
 }
 
 pub fn codegen_instance<'a, 'tcx: 'a, Bx: BuilderMethods<'a, 'tcx>>(
diff --git a/src/librustc_codegen_ssa/mir/block.rs b/src/librustc_codegen_ssa/mir/block.rs
@@ -1,6 +1,6 @@
 use rustc::middle::lang_items;
 use rustc::ty::{self, Ty, TypeFoldable};
-use rustc::ty::layout::{self, LayoutOf, HasTyCtxt};
+use rustc::ty::layout::{self, HasTyCtxt};
 use rustc::mir;
 use rustc::mir::interpret::EvalErrorKind;
 use rustc_target::abi::call::{ArgType, FnType, PassMode, IgnoreMode};
@@ -1012,13 +1012,12 @@ impl<'a, 'tcx: 'a, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
         &mut self,
         bx: &mut Bx
     ) -> PlaceRef<'tcx, Bx::Value> {
-        let cx = bx.cx();
         if let Some(slot) = self.personality_slot {
             slot
         } else {
-            let layout = cx.layout_of(cx.tcx().intern_tup(&[
-                cx.tcx().mk_mut_ptr(cx.tcx().types.u8),
-                cx.tcx().types.i32
+            let layout = bx.layout_of(bx.tcx().intern_tup(&[
+                bx.tcx().mk_mut_ptr(bx.tcx().types.u8),
+                bx.tcx().types.i32
             ]));
             let slot = PlaceRef::alloca(bx, layout, "personalityslot");
             self.personality_slot = Some(slot);
diff --git a/src/librustc_codegen_ssa/mir/operand.rs b/src/librustc_codegen_ssa/mir/operand.rs
@@ -1,7 +1,7 @@
 use rustc::mir::interpret::{ConstValue, ErrorHandled};
 use rustc::mir;
 use rustc::ty;
-use rustc::ty::layout::{self, Align, LayoutOf, TyLayout};
+use rustc::ty::layout::{self, Align, TyLayout};
 
 use crate::base;
 use crate::MemFlags;
@@ -148,11 +148,11 @@ impl<'a, 'tcx: 'a, V: CodegenObject> OperandRef<'tcx, V> {
         bx: &mut Bx
     ) -> V {
         if let OperandValue::Pair(a, b) = self.val {
-            let llty = bx.cx().backend_type(self.layout);
+            let llty = bx.backend_type(self.layout);
             debug!("Operand::immediate_or_packed_pair: packing {:?} into {:?}",
                    self, llty);
             // Reconstruct the immediate aggregate.
-            let mut llpair = bx.cx().const_undef(llty);
+            let mut llpair = bx.const_undef(llty);
             let imm_a = base::from_immediate(bx, a);
             let imm_b = base::from_immediate(bx, b);
             llpair = bx.insert_value(llpair, imm_a, 0);
@@ -190,7 +190,7 @@ impl<'a, 'tcx: 'a, V: CodegenObject> OperandRef<'tcx, V> {
         bx: &mut Bx,
         i: usize
     ) -> Self {
-        let field = self.layout.field(bx.cx(), i);
+        let field = self.layout.field(bx, i);
         let offset = self.layout.fields.offset(i);
 
         let mut val = match (self.val, &self.layout.abi) {
@@ -209,20 +209,20 @@ impl<'a, 'tcx: 'a, V: CodegenObject> OperandRef<'tcx, V> {
             // Extract a scalar component from a pair.
             (OperandValue::Pair(a_llval, b_llval), &layout::Abi::ScalarPair(ref a, ref b)) => {
                 if offset.bytes() == 0 {
-                    assert_eq!(field.size, a.value.size(bx.cx()));
+                    assert_eq!(field.size, a.value.size(bx));
                     OperandValue::Immediate(a_llval)
                 } else {
-                    assert_eq!(offset, a.value.size(bx.cx())
-                        .align_to(b.value.align(bx.cx()).abi));
-                    assert_eq!(field.size, b.value.size(bx.cx()));
+                    assert_eq!(offset, a.value.size(bx)
+                        .align_to(b.value.align(bx).abi));
+                    assert_eq!(field.size, b.value.size(bx));
                     OperandValue::Immediate(b_llval)
                 }
             }
 
             // `#[repr(simd)]` types are also immediate.
             (OperandValue::Immediate(llval), &layout::Abi::Vector { .. }) => {
                 OperandValue::Immediate(
-                    bx.extract_element(llval, bx.cx().const_usize(i as u64)))
+                    bx.extract_element(llval, bx.const_usize(i as u64)))
             }
 
             _ => bug!("OperandRef::extract_field({:?}): not applicable", self)
@@ -231,7 +231,7 @@ impl<'a, 'tcx: 'a, V: CodegenObject> OperandRef<'tcx, V> {
         // HACK(eddyb) have to bitcast pointers until LLVM removes pointee types.
         // Bools in union fields needs to be truncated.
         let to_immediate_or_cast = |bx: &mut Bx, val, ty| {
-            if ty == bx.cx().type_i1() {
+            if ty == bx.type_i1() {
                 bx.trunc(val, ty)
             } else {
                 bx.bitcast(val, ty)
@@ -240,12 +240,12 @@ impl<'a, 'tcx: 'a, V: CodegenObject> OperandRef<'tcx, V> {
 
         match val {
             OperandValue::Immediate(ref mut llval) => {
-                *llval = to_immediate_or_cast(bx, *llval, bx.cx().immediate_backend_type(field));
+                *llval = to_immediate_or_cast(bx, *llval, bx.immediate_backend_type(field));
             }
             OperandValue::Pair(ref mut a, ref mut b) => {
-                *a = to_immediate_or_cast(bx, *a, bx.cx()
+                *a = to_immediate_or_cast(bx, *a, bx
                     .scalar_pair_element_backend_type(field, 0, true));
-                *b = to_immediate_or_cast(bx, *b, bx.cx()
+                *b = to_immediate_or_cast(bx, *b, bx
                     .scalar_pair_element_backend_type(field, 1, true));
             }
             OperandValue::Ref(..) => bug!()
@@ -359,7 +359,7 @@ impl<'a, 'tcx: 'a, V: CodegenObject> OperandValue<V> {
 
         // Allocate an appropriate region on the stack, and copy the value into it
         let (llsize, _) = glue::size_and_align_of_dst(bx, unsized_ty, Some(llextra));
-        let lldst = bx.array_alloca(bx.cx().type_i8(), llsize, "unsized_tmp", max_align);
+        let lldst = bx.array_alloca(bx.type_i8(), llsize, "unsized_tmp", max_align);
         bx.memcpy(lldst, max_align, llptr, min_align, llsize, flags);
 
         // Store the allocated region and the extra to the indirect place.
@@ -404,7 +404,7 @@ impl<'a, 'tcx: 'a, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                         // ZSTs don't require any actual memory access.
                         // FIXME(eddyb) deduplicate this with the identical
                         // checks in `codegen_consume` and `extract_field`.
-                        let elem = o.layout.field(bx.cx(), 0);
+                        let elem = o.layout.field(bx, 0);
                         if elem.is_zst() {
                             return Some(OperandRef::new_zst(bx, elem));
                         }
@@ -425,7 +425,7 @@ impl<'a, 'tcx: 'a, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
         debug!("codegen_consume(place={:?})", place);
 
         let ty = self.monomorphized_place_ty(place);
-        let layout = bx.cx().layout_of(ty);
+        let layout = bx.layout_of(ty);
 
         // ZSTs don't require any actual memory access.
         if layout.is_zst() {
@@ -471,9 +471,9 @@ impl<'a, 'tcx: 'a, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                         // the above error (or silence it under some conditions) will not cause UB
                         bx.abort();
                         // We've errored, so we don't have to produce working code.
-                        let layout = bx.cx().layout_of(ty);
+                        let layout = bx.layout_of(ty);
                         bx.load_operand(PlaceRef::new_sized(
-                            bx.cx().const_undef(bx.cx().type_ptr_to(bx.cx().backend_type(layout))),
+                            bx.const_undef(bx.type_ptr_to(bx.backend_type(layout))),
                             layout,
                             layout.align.abi,
                         ))
diff --git a/src/librustc_codegen_ssa/mir/place.rs b/src/librustc_codegen_ssa/mir/place.rs
diff --git a/src/librustc_codegen_ssa/mir/rvalue.rs b/src/librustc_codegen_ssa/mir/rvalue.rs

Original file line number	Diff line number	Diff line change
`@@ -1472,6 +1472,7 @@ impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {`
`1472`	`1472`
`1473`	`1473`	`impl StaticBuilderMethods<'tcx> for Builder<'a, 'll, 'tcx> {`
`1474`	`1474`	`fn get_static(&self, def_id: DefId) -> &'ll Value {`
	`1475`	+ // Forward to the `get_static` method of `CodegenCx`
`1475`	`1476`	`self.cx().get_static(def_id)`
`1476`	`1477`	`}`
`1477`	`1478`	`}`