codegen_place and related functions can take PlaceRef by value

spastorino · spastorino · commit 39d93b1ef8f3 · 2020-01-28T10:12:53.000-03:00
diff --git a/src/librustc_codegen_ssa/mir/block.rs b/src/librustc_codegen_ssa/mir/block.rs
@@ -264,7 +264,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
             }
 
             PassMode::Direct(_) | PassMode::Pair(..) => {
-                let op = self.codegen_consume(&mut bx, &mir::Place::return_place().as_ref());
+                let op = self.codegen_consume(&mut bx, mir::Place::return_place().as_ref());
                 if let Ref(llval, _, align) = op.val {
                     bx.load(llval, align)
                 } else {
@@ -319,7 +319,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
             return;
         }
 
-        let place = self.codegen_place(&mut bx, &location.as_ref());
+        let place = self.codegen_place(&mut bx, location.as_ref());
         let (args1, args2);
         let mut args = if let Some(llextra) = place.llextra {
             args2 = [place.llval, llextra];
@@ -1111,7 +1111,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
         } else {
             self.codegen_place(
                 bx,
-                &mir::PlaceRef { local: &dest.local, projection: &dest.projection },
+                mir::PlaceRef { local: &dest.local, projection: &dest.projection },
             )
         };
         if fn_ret.is_indirect() {
@@ -1137,7 +1137,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 LocalRef::Place(place) => self.codegen_transmute_into(bx, src, place),
                 LocalRef::UnsizedPlace(_) => bug!("transmute must not involve unsized locals"),
                 LocalRef::Operand(None) => {
-                    let dst_layout = bx.layout_of(self.monomorphized_place_ty(&dst.as_ref()));
+                    let dst_layout = bx.layout_of(self.monomorphized_place_ty(dst.as_ref()));
                     assert!(!dst_layout.ty.has_erasable_regions());
                     let place = PlaceRef::alloca(bx, dst_layout);
                     place.storage_live(bx);
@@ -1151,7 +1151,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 }
             }
         } else {
-            let dst = self.codegen_place(bx, &dst.as_ref());
+            let dst = self.codegen_place(bx, dst.as_ref());
             self.codegen_transmute_into(bx, src, dst);
         }
     }
diff --git a/src/librustc_codegen_ssa/mir/operand.rs b/src/librustc_codegen_ssa/mir/operand.rs
@@ -369,7 +369,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
     fn maybe_codegen_consume_direct(
         &mut self,
         bx: &mut Bx,
-        place_ref: &mir::PlaceRef<'_, 'tcx>,
+        place_ref: mir::PlaceRef<'_, 'tcx>,
     ) -> Option<OperandRef<'tcx, Bx::Value>> {
         debug!("maybe_codegen_consume_direct(place_ref={:?})", place_ref);
 
@@ -413,7 +413,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
     pub fn codegen_consume(
         &mut self,
         bx: &mut Bx,
-        place_ref: &mir::PlaceRef<'_, 'tcx>,
+        place_ref: mir::PlaceRef<'_, 'tcx>,
     ) -> OperandRef<'tcx, Bx::Value> {
         debug!("codegen_consume(place_ref={:?})", place_ref);
 
@@ -444,7 +444,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
 
         match *operand {
             mir::Operand::Copy(ref place) | mir::Operand::Move(ref place) => {
-                self.codegen_consume(bx, &place.as_ref())
+                self.codegen_consume(bx, place.as_ref())
             }
 
             mir::Operand::Constant(ref constant) => {
diff --git a/src/librustc_codegen_ssa/mir/place.rs b/src/librustc_codegen_ssa/mir/place.rs
@@ -408,14 +408,14 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
     pub fn codegen_place(
         &mut self,
         bx: &mut Bx,
-        place_ref: &mir::PlaceRef<'_, 'tcx>,
+        place_ref: mir::PlaceRef<'_, 'tcx>,
     ) -> PlaceRef<'tcx, Bx::Value> {
         debug!("codegen_place(place_ref={:?})", place_ref);
         let cx = self.cx;
         let tcx = self.cx.tcx();
 
         let result = match place_ref {
-            mir::PlaceRef { local, projection: [] } => match self.locals[**local] {
+            mir::PlaceRef { local, projection: [] } => match self.locals[*local] {
                 LocalRef::Place(place) => {
                     return place;
                 }
@@ -428,13 +428,13 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
             },
             mir::PlaceRef { local, projection: [proj_base @ .., mir::ProjectionElem::Deref] } => {
                 // Load the pointer from its location.
-                self.codegen_consume(bx, &mir::PlaceRef { local, projection: proj_base })
+                self.codegen_consume(bx, mir::PlaceRef { local, projection: proj_base })
                     .deref(bx.cx())
             }
             mir::PlaceRef { local, projection: [proj_base @ .., elem] } => {
                 // FIXME turn this recursion into iteration
                 let cg_base =
-                    self.codegen_place(bx, &mir::PlaceRef { local, projection: proj_base });
+                    self.codegen_place(bx, mir::PlaceRef { local, projection: proj_base });
 
                 match elem {
                     mir::ProjectionElem::Deref => bug!(),
@@ -497,7 +497,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
         result
     }
 
-    pub fn monomorphized_place_ty(&self, place_ref: &mir::PlaceRef<'_, 'tcx>) -> Ty<'tcx> {
+    pub fn monomorphized_place_ty(&self, place_ref: mir::PlaceRef<'_, 'tcx>) -> Ty<'tcx> {
         let tcx = self.cx.tcx();
         let place_ty = mir::Place::ty_from(place_ref.local, place_ref.projection, *self.mir, tcx);
         self.monomorphize(&place_ty.ty)
diff --git a/src/librustc_codegen_ssa/mir/rvalue.rs b/src/librustc_codegen_ssa/mir/rvalue.rs
@@ -467,7 +467,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
             mir::Rvalue::Discriminant(ref place) => {
                 let discr_ty = rvalue.ty(*self.mir, bx.tcx());
                 let discr = self
-                    .codegen_place(&mut bx, &place.as_ref())
+                    .codegen_place(&mut bx, place.as_ref())
                     .codegen_get_discr(&mut bx, discr_ty);
                 (
                     bx,
@@ -541,7 +541,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
             }
         }
         // use common size calculation for non zero-sized types
-        let cg_value = self.codegen_place(bx, &place.as_ref());
+        let cg_value = self.codegen_place(bx, place.as_ref());
         cg_value.len(bx.cx())
     }
 
@@ -552,7 +552,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
         place: &mir::Place<'tcx>,
         mk_ptr_ty: impl FnOnce(TyCtxt<'tcx>, Ty<'tcx>) -> Ty<'tcx>,
     ) -> (Bx, OperandRef<'tcx, Bx::Value>) {
-        let cg_place = self.codegen_place(&mut bx, &place.as_ref());
+        let cg_place = self.codegen_place(&mut bx, place.as_ref());
 
         let ty = cg_place.layout.ty;
 
diff --git a/src/librustc_codegen_ssa/mir/statement.rs b/src/librustc_codegen_ssa/mir/statement.rs
@@ -41,12 +41,12 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                         }
                     }
                 } else {
-                    let cg_dest = self.codegen_place(&mut bx, &place.as_ref());
+                    let cg_dest = self.codegen_place(&mut bx, place.as_ref());
                     self.codegen_rvalue(bx, cg_dest, rvalue)
                 }
             }
             mir::StatementKind::SetDiscriminant { box ref place, variant_index } => {
-                self.codegen_place(&mut bx, &place.as_ref())
+                self.codegen_place(&mut bx, place.as_ref())
                     .codegen_set_discr(&mut bx, variant_index);
                 bx
             }
@@ -70,7 +70,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 let outputs = asm
                     .outputs
                     .iter()
-                    .map(|output| self.codegen_place(&mut bx, &output.as_ref()))
+                    .map(|output| self.codegen_place(&mut bx, output.as_ref()))
                     .collect();
 
                 let input_vals = asm.inputs.iter().fold(

Original file line number	Diff line number	Diff line change
`@@ -264,7 +264,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {`
`264`	`264`	`}`
`265`	`265`
`266`	`266`	`PassMode::Direct(_) \| PassMode::Pair(..) => {`
`267`		`- let op = self.codegen_consume(&mut bx, &mir::Place::return_place().as_ref());`
	`267`	`+ let op = self.codegen_consume(&mut bx, mir::Place::return_place().as_ref());`
`268`	`268`	`if let Ref(llval, _, align) = op.val {`
`269`	`269`	`bx.load(llval, align)`
`270`	`270`	`} else {`
`@@ -319,7 +319,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {`
`319`	`319`	`return;`
`320`	`320`	`}`
`321`	`321`
`322`		`- let place = self.codegen_place(&mut bx, &location.as_ref());`
	`322`	`+ let place = self.codegen_place(&mut bx, location.as_ref());`
`323`	`323`	`let (args1, args2);`
`324`	`324`	`let mut args = if let Some(llextra) = place.llextra {`
`325`	`325`	`args2 = [place.llval, llextra];`
`@@ -1111,7 +1111,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {`
`1111`	`1111`	`} else {`
`1112`	`1112`	`self.codegen_place(`
`1113`	`1113`	`bx,`
`1114`		`- &mir::PlaceRef { local: &dest.local, projection: &dest.projection },`
	`1114`	`+ mir::PlaceRef { local: &dest.local, projection: &dest.projection },`
`1115`	`1115`	`)`
`1116`	`1116`	`};`
`1117`	`1117`	`if fn_ret.is_indirect() {`
`@@ -1137,7 +1137,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {`
`1137`	`1137`	`LocalRef::Place(place) => self.codegen_transmute_into(bx, src, place),`
`1138`	`1138`	`LocalRef::UnsizedPlace(_) => bug!("transmute must not involve unsized locals"),`
`1139`	`1139`	`LocalRef::Operand(None) => {`
`1140`		`- let dst_layout = bx.layout_of(self.monomorphized_place_ty(&dst.as_ref()));`
	`1140`	`+ let dst_layout = bx.layout_of(self.monomorphized_place_ty(dst.as_ref()));`
`1141`	`1141`	`assert!(!dst_layout.ty.has_erasable_regions());`
`1142`	`1142`	`let place = PlaceRef::alloca(bx, dst_layout);`
`1143`	`1143`	`place.storage_live(bx);`
`@@ -1151,7 +1151,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {`
`1151`	`1151`	`}`
`1152`	`1152`	`}`
`1153`	`1153`	`} else {`
`1154`		`- let dst = self.codegen_place(bx, &dst.as_ref());`
	`1154`	`+ let dst = self.codegen_place(bx, dst.as_ref());`
`1155`	`1155`	`self.codegen_transmute_into(bx, src, dst);`
`1156`	`1156`	`}`
`1157`	`1157`	`}`
Original file line number	Diff line number	Diff line change
`@@ -467,7 +467,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {`
`467`	`467`	`mir::Rvalue::Discriminant(ref place) => {`
`468`	`468`	`let discr_ty = rvalue.ty(*self.mir, bx.tcx());`
`469`	`469`	`let discr = self`
`470`		`- .codegen_place(&mut bx, &place.as_ref())`
	`470`	`+ .codegen_place(&mut bx, place.as_ref())`
`471`	`471`	`.codegen_get_discr(&mut bx, discr_ty);`
`472`	`472`	`(`
`473`	`473`	`bx,`
`@@ -541,7 +541,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {`
`541`	`541`	`}`
`542`	`542`	`}`
`543`	`543`	`// use common size calculation for non zero-sized types`
`544`		`- let cg_value = self.codegen_place(bx, &place.as_ref());`
	`544`	`+ let cg_value = self.codegen_place(bx, place.as_ref());`
`545`	`545`	`cg_value.len(bx.cx())`
`546`	`546`	`}`
`547`	`547`
`@@ -552,7 +552,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {`
`552`	`552`	`place: &mir::Place<'tcx>,`
`553`	`553`	`mk_ptr_ty: impl FnOnce(TyCtxt<'tcx>, Ty<'tcx>) -> Ty<'tcx>,`
`554`	`554`	`) -> (Bx, OperandRef<'tcx, Bx::Value>) {`
`555`		`- let cg_place = self.codegen_place(&mut bx, &place.as_ref());`
	`555`	`+ let cg_place = self.codegen_place(&mut bx, place.as_ref());`
`556`	`556`
`557`	`557`	`let ty = cg_place.layout.ty;`
`558`	`558`
Original file line number	Diff line number	Diff line change
`@@ -41,12 +41,12 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {`
`41`	`41`	`}`
`42`	`42`	`}`
`43`	`43`	`} else {`
`44`		`- let cg_dest = self.codegen_place(&mut bx, &place.as_ref());`
	`44`	`+ let cg_dest = self.codegen_place(&mut bx, place.as_ref());`
`45`	`45`	`self.codegen_rvalue(bx, cg_dest, rvalue)`
`46`	`46`	`}`
`47`	`47`	`}`
`48`	`48`	`mir::StatementKind::SetDiscriminant { box ref place, variant_index } => {`
`49`		`- self.codegen_place(&mut bx, &place.as_ref())`
	`49`	`+ self.codegen_place(&mut bx, place.as_ref())`
`50`	`50`	`.codegen_set_discr(&mut bx, variant_index);`
`51`	`51`	`bx`
`52`	`52`	`}`
`@@ -70,7 +70,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {`
`70`	`70`	`let outputs = asm`
`71`	`71`	`.outputs`
`72`	`72`	`.iter()`
`73`		`- .map(\|output\| self.codegen_place(&mut bx, &output.as_ref()))`
	`73`	`+ .map(\|output\| self.codegen_place(&mut bx, output.as_ref()))`
`74`	`74`	`.collect();`
`75`	`75`
`76`	`76`	`let input_vals = asm.inputs.iter().fold(`