From 66279d12f9cad1d47e4d6ed458dcbb7505b65b55 Mon Sep 17 00:00:00 2001 From: Paul Daniel Faria Date: Mon, 14 Oct 2019 01:38:38 -0400 Subject: [PATCH] Revert back to using FunctionCx's Body --- src/librustc_codegen_ssa/mir/analyze.rs | 2 +- src/librustc_codegen_ssa/mir/block.rs | 153 ++++++++++------------ src/librustc_codegen_ssa/mir/mod.rs | 11 +- src/librustc_codegen_ssa/mir/operand.rs | 10 +- src/librustc_codegen_ssa/mir/place.rs | 13 +- src/librustc_codegen_ssa/mir/rvalue.rs | 53 ++++---- src/librustc_codegen_ssa/mir/statement.rs | 23 ++-- 7 files changed, 118 insertions(+), 147 deletions(-) diff --git a/src/librustc_codegen_ssa/mir/analyze.rs b/src/librustc_codegen_ssa/mir/analyze.rs index 69e26cf3b43..171e3c840fb 100644 --- a/src/librustc_codegen_ssa/mir/analyze.rs +++ b/src/librustc_codegen_ssa/mir/analyze.rs @@ -245,7 +245,7 @@ impl<'mir, 'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> Visitor<'tcx> if let Some(index) = place.as_local() { self.assign(index, location); let decl_span = self.fx.mir.local_decls[index].source_info.span; - if !self.fx.rvalue_creates_operand(rvalue, decl_span, self.fx.mir) { + if !self.fx.rvalue_creates_operand(rvalue, decl_span) { self.not_ssa(index); } } else { diff --git a/src/librustc_codegen_ssa/mir/block.rs b/src/librustc_codegen_ssa/mir/block.rs index ba86576dd32..53bffc794d7 100644 --- a/src/librustc_codegen_ssa/mir/block.rs +++ b/src/librustc_codegen_ssa/mir/block.rs @@ -2,7 +2,7 @@ use rustc_index::vec::Idx; use rustc::middle::lang_items; use rustc::ty::{self, Ty, TypeFoldable, Instance}; use rustc::ty::layout::{self, LayoutOf, HasTyCtxt, FnAbiExt}; -use rustc::mir::{self, Body, PlaceBase, Static, StaticKind}; +use rustc::mir::{self, PlaceBase, Static, StaticKind}; use rustc::mir::interpret::PanicInfo; use rustc_target::abi::call::{ArgAbi, FnAbi, PassMode}; use rustc_target::spec::abi::Abi; @@ -46,7 +46,6 @@ impl<'a, 'tcx> TerminatorCodegenHelper<'a, 'tcx> { fn lltarget<'b, 'c, 'd, Bx: BuilderMethods<'b, 'tcx>>( &self, fx: &'d mut FunctionCx<'b, 'c, 'tcx, Bx>, - mir: &Body<'tcx>, target: mir::BasicBlock ) -> (Bx::BasicBlock, bool) { let span = self.terminator.source_info.span; @@ -57,9 +56,9 @@ impl<'a, 'tcx> TerminatorCodegenHelper<'a, 'tcx> { (Some(f), Some(t_f)) if f == t_f || !base::wants_msvc_seh(fx.cx.tcx().sess) => (lltarget, false), // jump *into* cleanup - need a landing pad if GNU - (None, Some(_)) => (fx.landing_pad_to(target, mir), false), + (None, Some(_)) => (fx.landing_pad_to(target), false), (Some(_), None) => span_bug!(span, "{:?} - jump out of cleanup?", self.terminator), - (Some(_), Some(_)) => (fx.landing_pad_to(target, mir), true), + (Some(_), Some(_)) => (fx.landing_pad_to(target), true), } } @@ -67,10 +66,9 @@ impl<'a, 'tcx> TerminatorCodegenHelper<'a, 'tcx> { fn llblock<'d, 'c, 'b, Bx: BuilderMethods<'b, 'tcx>>( &self, fx: &'d mut FunctionCx<'b, 'c, 'tcx, Bx>, - mir: &Body<'tcx>, target: mir::BasicBlock ) -> Bx::BasicBlock { - let (lltarget, is_cleanupret) = self.lltarget(fx, mir, target); + let (lltarget, is_cleanupret) = self.lltarget(fx, target); if is_cleanupret { // MSVC cross-funclet jump - need a trampoline @@ -88,11 +86,10 @@ impl<'a, 'tcx> TerminatorCodegenHelper<'a, 'tcx> { fn funclet_br<'d, 'c, 'b, Bx: BuilderMethods<'b, 'tcx>>( &self, fx: &'d mut FunctionCx<'b, 'c, 'tcx, Bx>, - mir: &Body<'tcx>, bx: &mut Bx, target: mir::BasicBlock, ) { - let (lltarget, is_cleanupret) = self.lltarget(fx, mir, target); + let (lltarget, is_cleanupret) = self.lltarget(fx, target); if is_cleanupret { // micro-optimization: generate a `ret` rather than a jump // to a trampoline. @@ -107,7 +104,6 @@ impl<'a, 'tcx> TerminatorCodegenHelper<'a, 'tcx> { fn do_call<'d, 'c, 'b, Bx: BuilderMethods<'b, 'tcx>>( &self, fx: &'d mut FunctionCx<'b, 'c, 'tcx, Bx>, - mir: &Body<'tcx>, bx: &mut Bx, fn_abi: FnAbi<'tcx, Ty<'tcx>>, fn_ptr: Bx::Value, @@ -124,19 +120,19 @@ impl<'a, 'tcx> TerminatorCodegenHelper<'a, 'tcx> { let invokeret = bx.invoke(fn_ptr, &llargs, ret_bx, - self.llblock(fx, mir, cleanup), + self.llblock(fx, cleanup), self.funclet(fx)); bx.apply_attrs_callsite(&fn_abi, invokeret); if let Some((ret_dest, target)) = destination { let mut ret_bx = fx.build_block(target); - fx.set_debug_loc(&mut ret_bx, self.terminator.source_info, mir); + fx.set_debug_loc(&mut ret_bx, self.terminator.source_info); fx.store_return(&mut ret_bx, ret_dest, &fn_abi.ret, invokeret); } } else { let llret = bx.call(fn_ptr, &llargs, self.funclet(fx)); bx.apply_attrs_callsite(&fn_abi, llret); - if mir[*self.bb].is_cleanup { + if fx.mir[*self.bb].is_cleanup { // Cleanup is always the cold path. Don't inline // drop glue. Also, when there is a deeply-nested // struct, there are "symmetry" issues that cause @@ -146,7 +142,7 @@ impl<'a, 'tcx> TerminatorCodegenHelper<'a, 'tcx> { if let Some((ret_dest, target)) = destination { fx.store_return(bx, ret_dest, &fn_abi.ret, llret); - self.funclet_br(fx, mir, bx, target); + self.funclet_br(fx, bx, target); } else { bx.unreachable(); } @@ -208,20 +204,19 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { fn codegen_switchint_terminator<'c>( &mut self, helper: TerminatorCodegenHelper<'c, 'tcx>, - mir: &Body<'tcx>, mut bx: Bx, discr: &mir::Operand<'tcx>, switch_ty: Ty<'tcx>, values: &Cow<'tcx, [u128]>, targets: &Vec, ) { - let discr = self.codegen_operand(mir, &mut bx, &discr); + let discr = self.codegen_operand(&mut bx, &discr); if targets.len() == 2 { // If there are two targets, emit br instead of switch - let lltrue = helper.llblock(self, mir, targets[0]); - let llfalse = helper.llblock(self, mir, targets[1]); + let lltrue = helper.llblock(self, targets[0]); + let llfalse = helper.llblock(self, targets[1]); if switch_ty == bx.tcx().types.bool { - helper.maybe_sideeffect(mir, &mut bx, targets.as_slice()); + helper.maybe_sideeffect(self.mir, &mut bx, targets.as_slice()); // Don't generate trivial icmps when switching on bool if let [0] = values[..] { bx.cond_br(discr.immediate(), llfalse, lltrue); @@ -243,15 +238,15 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { let (otherwise, targets) = targets.split_last().unwrap(); bx.switch( discr.immediate(), - helper.llblock(self, mir, *otherwise), + helper.llblock(self, *otherwise), values.iter().zip(targets).map(|(&value, target)| { - (value, helper.llblock(self, mir, *target)) + (value, helper.llblock(self, *target)) }) ); } } - fn codegen_return_terminator(&mut self, mir: &Body<'tcx>, mut bx: Bx) { + fn codegen_return_terminator(&mut self, mut bx: Bx) { // Call `va_end` if this is the definition of a C-variadic function. if self.fn_abi.c_variadic { // The `VaList` "spoofed" argument is just after all the real arguments. @@ -278,7 +273,7 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { PassMode::Direct(_) | PassMode::Pair(..) => { let op = - self.codegen_consume(mir, &mut bx, &mir::Place::return_place().as_ref()); + self.codegen_consume(&mut bx, &mir::Place::return_place().as_ref()); if let Ref(llval, _, align) = op.val { bx.load(llval, align) } else { @@ -324,24 +319,23 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { fn codegen_drop_terminator<'c>( &mut self, helper: TerminatorCodegenHelper<'c, 'tcx>, - mir: &Body<'tcx>, mut bx: Bx, location: &mir::Place<'tcx>, target: mir::BasicBlock, unwind: Option, ) { - let ty = location.ty(mir, bx.tcx()).ty; + let ty = location.ty(self.mir, bx.tcx()).ty; let ty = self.monomorphize(&ty); let drop_fn = Instance::resolve_drop_in_place(bx.tcx(), ty); if let ty::InstanceDef::DropGlue(_, None) = drop_fn.def { // we don't actually need to drop anything. - helper.maybe_sideeffect(mir, &mut bx, &[target]); - helper.funclet_br(self, mir, &mut bx, target); + helper.maybe_sideeffect(self.mir, &mut bx, &[target]); + helper.funclet_br(self, &mut bx, target); return } - let place = self.codegen_place(mir, &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]; @@ -367,7 +361,7 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { FnAbi::of_instance(&bx, drop_fn)) } }; - helper.maybe_sideeffect(mir, &mut bx, &[target]); + helper.maybe_sideeffect(self.mir, &mut bx, &[target]); helper.do_call(self, &mut bx, fn_ty, drop_fn, args, Some((ReturnDest::Nothing, target)), unwind); @@ -376,7 +370,6 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { fn codegen_assert_terminator<'c>( &mut self, helper: TerminatorCodegenHelper<'c, 'tcx>, - mir: &Body<'tcx>, mut bx: Bx, terminator: &mir::Terminator<'tcx>, cond: &mir::Operand<'tcx>, @@ -386,7 +379,7 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { cleanup: Option, ) { let span = terminator.source_info.span; - let cond = self.codegen_operand(mir, &mut bx, cond).immediate(); + let cond = self.codegen_operand(&mut bx, cond).immediate(); let mut const_cond = bx.const_to_opt_u128(cond, false).map(|c| c == 1); // This case can currently arise only from functions marked @@ -404,8 +397,8 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { // Don't codegen the panic block if success if known. if const_cond == Some(expected) { - helper.maybe_sideeffect(mir, &mut bx, &[target]); - helper.funclet_br(self, mir, &mut bx, target); + helper.maybe_sideeffect(self.mir, &mut bx, &[target]); + helper.funclet_br(self, &mut bx, target); return; } @@ -413,9 +406,9 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { let cond = bx.expect(cond, expected); // Create the failure block and the conditional branch to it. - let lltarget = helper.llblock(self, mir, target); + let lltarget = helper.llblock(self, target); let panic_block = self.new_block("panic"); - helper.maybe_sideeffect(mir, &mut bx, &[target]); + helper.maybe_sideeffect(self.mir, &mut bx, &[target]); if expected { bx.cond_br(cond, lltarget, panic_block.llbb()); } else { @@ -424,7 +417,7 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { // After this point, bx is the block for the call to panic. bx = panic_block; - self.set_debug_loc(&mut bx, terminator.source_info, mir); + self.set_debug_loc(&mut bx, terminator.source_info); // Get the location information. let location = self.get_caller_location(&mut bx, span).immediate(); @@ -432,8 +425,8 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { // Put together the arguments to the panic entry point. let (lang_item, args) = match msg { PanicInfo::BoundsCheck { ref len, ref index } => { - let len = self.codegen_operand(mir, &mut bx, len).immediate(); - let index = self.codegen_operand(mir, &mut bx, index).immediate(); + let len = self.codegen_operand(&mut bx, len).immediate(); + let index = self.codegen_operand(&mut bx, index).immediate(); (lang_items::PanicBoundsCheckFnLangItem, vec![location, index, len]) } _ => { @@ -450,13 +443,12 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { let llfn = bx.get_fn_addr(instance); // Codegen the actual panic invoke/call. - helper.do_call(self, mir, &mut bx, fn_abi, llfn, &args, None, cleanup); + helper.do_call(self, &mut bx, fn_abi, llfn, &args, None, cleanup); } fn codegen_call_terminator<'c>( &mut self, helper: TerminatorCodegenHelper<'c, 'tcx>, - mir: &Body<'tcx>, mut bx: Bx, terminator: &mir::Terminator<'tcx>, func: &mir::Operand<'tcx>, @@ -466,7 +458,7 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { ) { let span = terminator.source_info.span; // Create the callee. This is a fn ptr or zero-sized and hence a kind of scalar. - let callee = self.codegen_operand(mir, &mut bx, func); + let callee = self.codegen_operand(&mut bx, func); let (instance, mut llfn) = match callee.layout.ty.kind { ty::FnDef(def_id, substs) => { @@ -500,9 +492,9 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { if intrinsic == Some("transmute") { if let Some(destination_ref) = destination.as_ref() { let &(ref dest, target) = destination_ref; - self.codegen_transmute(mir, &mut bx, &args[0], dest); - helper.maybe_sideeffect(mir, &mut bx, &[target]); - helper.funclet_br(self, mir, &mut bx, target); + self.codegen_transmute(&mut bx, &args[0], dest); + helper.maybe_sideeffect(self.mir, &mut bx, &[target]); + helper.funclet_br(self, &mut bx, target); } else { // If we are trying to transmute to an uninhabited type, // it is likely there is no allotted destination. In fact, @@ -518,7 +510,7 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { let extra_args = &args[sig.inputs().len()..]; let extra_args = extra_args.iter().map(|op_arg| { - let op_ty = op_arg.ty(mir, bx.tcx()); + let op_ty = op_arg.ty(self.mir, bx.tcx()); self.monomorphize(&op_ty) }).collect::>(); @@ -529,8 +521,8 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { Some(ty::InstanceDef::DropGlue(_, None)) => { // Empty drop glue; a no-op. let &(_, target) = destination.as_ref().unwrap(); - helper.maybe_sideeffect(mir, &mut bx, &[target]); - helper.funclet_br(self, mir, &mut bx, target); + helper.maybe_sideeffect(self.mir, &mut bx, &[target]); + helper.funclet_br(self, &mut bx, target); return; } _ => FnAbi::new(&bx, sig, &extra_args) @@ -566,7 +558,6 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { // Codegen the actual panic invoke/call. helper.do_call( self, - mir, &mut bx, fn_abi, llfn, @@ -590,8 +581,7 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { // Prepare the return value destination let ret_dest = if let Some((ref dest, _)) = *destination { let is_intrinsic = intrinsic.is_some(); - self.make_return_dest(&mut bx, dest, &fn_abi.ret, &mut llargs, - is_intrinsic, mir) + self.make_return_dest(&mut bx, dest, &fn_abi.ret, &mut llargs, is_intrinsic) } else { ReturnDest::Nothing }; @@ -680,7 +670,7 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { } } - self.codegen_operand(mir, &mut bx, arg) + self.codegen_operand(&mut bx, arg) }).collect(); @@ -692,8 +682,8 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { } if let Some((_, target)) = *destination { - helper.maybe_sideeffect(mir, &mut bx, &[target]); - helper.funclet_br(self, mir, &mut bx, target); + helper.maybe_sideeffect(self.mir, &mut bx, &[target]); + helper.funclet_br(self, &mut bx, target); } else { bx.unreachable(); } @@ -710,7 +700,7 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { }; 'make_args: for (i, arg) in first_args.iter().enumerate() { - let mut op = self.codegen_operand(mir, &mut bx, arg); + let mut op = self.codegen_operand(&mut bx, arg); if let (0, Some(ty::InstanceDef::Virtual(_, idx))) = (i, def) { if let Pair(..) = op.val { @@ -775,7 +765,7 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { self.codegen_argument(&mut bx, op, &mut llargs, &fn_abi.args[i]); } if let Some(tup) = untuple { - self.codegen_arguments_untupled(mir, &mut bx, tup, &mut llargs, + self.codegen_arguments_untupled(&mut bx, tup, &mut llargs, &fn_abi.args[first_args.len()..]) } @@ -786,7 +776,7 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { }; if let Some((_, target)) = destination.as_ref() { - helper.maybe_sideeffect(mir, &mut bx, &[*target]); + helper.maybe_sideeffect(self.mir, &mut bx, &[*target]); } helper.do_call(self, &mut bx, fn_ty, fn_ptr, &llargs, destination.as_ref().map(|&(_, target)| (ret_dest, target)), @@ -798,18 +788,17 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { pub fn codegen_block( &mut self, bb: mir::BasicBlock, - mir: &Body<'tcx>, ) { let mut bx = self.build_block(bb); - let data = &mir[bb]; + let data = &self.mir[bb]; debug!("codegen_block({:?}={:?})", bb, data); for statement in &data.statements { - bx = self.codegen_statement(mir, bx, statement); + bx = self.codegen_statement(bx, statement); } - self.codegen_terminator(bx, bb, data.terminator(), mir); + self.codegen_terminator(bx, bb, data.terminator()); } fn codegen_terminator( @@ -817,7 +806,6 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { mut bx: Bx, bb: mir::BasicBlock, terminator: &mir::Terminator<'tcx>, - mir: &Body<'tcx> ) { debug!("codegen_terminator: {:?}", terminator); @@ -827,7 +815,7 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { bb: &bb, terminator, funclet_bb }; - self.set_debug_loc(&mut bx, terminator.source_info, mir); + self.set_debug_loc(&mut bx, terminator.source_info); match terminator.kind { mir::TerminatorKind::Resume => { self.codegen_resume_terminator(helper, bx) @@ -839,19 +827,18 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { } mir::TerminatorKind::Goto { target } => { - helper.maybe_sideeffect(mir, &mut bx, &[target]); - helper.funclet_br(self, mir, &mut bx, target); + helper.maybe_sideeffect(self.mir, &mut bx, &[target]); + helper.funclet_br(self, &mut bx, target); } mir::TerminatorKind::SwitchInt { ref discr, switch_ty, ref values, ref targets } => { - self.codegen_switchint_terminator(helper, mir, bx, discr, switch_ty, - values, targets); + self.codegen_switchint_terminator(helper, bx, discr, switch_ty, values, targets); } mir::TerminatorKind::Return => { - self.codegen_return_terminator(mir, bx); + self.codegen_return_terminator(bx); } mir::TerminatorKind::Unreachable => { @@ -859,11 +846,11 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { } mir::TerminatorKind::Drop { ref location, target, unwind } => { - self.codegen_drop_terminator(helper, mir, bx, location, target, unwind); + self.codegen_drop_terminator(helper, bx, location, target, unwind); } mir::TerminatorKind::Assert { ref cond, expected, ref msg, target, cleanup } => { - self.codegen_assert_terminator(helper, mir, bx, terminator, cond, + self.codegen_assert_terminator(helper, bx, terminator, cond, expected, msg, target, cleanup); } @@ -878,7 +865,7 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { cleanup, from_hir_call: _ } => { - self.codegen_call_terminator(helper, mir, bx, terminator, func, + self.codegen_call_terminator(helper, bx, terminator, func, args, destination, cleanup); } mir::TerminatorKind::GeneratorDrop | @@ -983,13 +970,12 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { fn codegen_arguments_untupled( &mut self, - mir: &Body<'tcx>, bx: &mut Bx, operand: &mir::Operand<'tcx>, llargs: &mut Vec, args: &[ArgAbi<'tcx, Ty<'tcx>>] ) { - let tuple = self.codegen_operand(mir, bx, operand); + let tuple = self.codegen_operand(bx, operand); // Handle both by-ref and immediate tuples. if let Ref(llval, None, align) = tuple.val { @@ -1049,14 +1035,13 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { fn landing_pad_to( &mut self, target_bb: mir::BasicBlock, - mir: &Body<'tcx> ) -> Bx::BasicBlock { if let Some(block) = self.landing_pads[target_bb] { return block; } let block = self.blocks[target_bb]; - let landing_pad = self.landing_pad_uncached(block, mir); + let landing_pad = self.landing_pad_uncached(block); self.landing_pads[target_bb] = Some(landing_pad); landing_pad } @@ -1064,10 +1049,9 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { fn landing_pad_uncached( &mut self, target_bb: Bx::BasicBlock, - mir: &Body<'tcx> ) -> Bx::BasicBlock { if base::wants_msvc_seh(self.cx.sess()) { - span_bug!(mir.span, "landing pad was not inserted?") + span_bug!(self.mir.span, "landing pad was not inserted?") } let mut bx = self.new_block("cleanup"); @@ -1120,7 +1104,6 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { dest: &mir::Place<'tcx>, fn_ret: &ArgAbi<'tcx, Ty<'tcx>>, llargs: &mut Vec, is_intrinsic: bool, - mir: &Body<'tcx> ) -> ReturnDest<'tcx, Bx::Value> { // If the return is ignored, we can just return a do-nothing `ReturnDest`. if fn_ret.is_ignore() { @@ -1156,7 +1139,7 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { } } } else { - self.codegen_place(mir, bx, &mir::PlaceRef { + self.codegen_place(bx, &mir::PlaceRef { base: &dest.base, projection: &dest.projection, }) @@ -1169,7 +1152,7 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { // // If someone changes that, please update this code path // to create a temporary. - span_bug!(mir.span, "can't directly store to unaligned value"); + span_bug!(self.mir.span, "can't directly store to unaligned value"); } llargs.push(dest.llval); ReturnDest::Nothing @@ -1180,21 +1163,20 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { fn codegen_transmute( &mut self, - mir: &Body<'tcx>, bx: &mut Bx, src: &mir::Operand<'tcx>, dst: &mir::Place<'tcx> ) { if let Some(index) = dst.as_local() { match self.locals[index] { - LocalRef::Place(place) => self.codegen_transmute_into(mir, bx, src, place), + 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(), mir)); + 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); - self.codegen_transmute_into(mir, bx, src, place); + self.codegen_transmute_into(bx, src, place); let op = bx.load_operand(place); place.storage_dead(bx); self.locals[index] = LocalRef::Operand(Some(op)); @@ -1205,19 +1187,18 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { } } } else { - let dst = self.codegen_place(mir, bx, &dst.as_ref()); - self.codegen_transmute_into(mir, bx, src, dst); + let dst = self.codegen_place(bx, &dst.as_ref()); + self.codegen_transmute_into(bx, src, dst); } } fn codegen_transmute_into( &mut self, - mir: &Body<'tcx>, bx: &mut Bx, src: &mir::Operand<'tcx>, dst: PlaceRef<'tcx, Bx::Value> ) { - let src = self.codegen_operand(mir, bx, src); + let src = self.codegen_operand(bx, src); let llty = bx.backend_type(src.layout); let cast_ptr = bx.pointercast(dst.llval, bx.type_ptr_to(llty)); let align = src.layout.align.abi.min(dst.align); diff --git a/src/librustc_codegen_ssa/mir/mod.rs b/src/librustc_codegen_ssa/mir/mod.rs index 7a3cf699f58..64129f4b5e4 100644 --- a/src/librustc_codegen_ssa/mir/mod.rs +++ b/src/librustc_codegen_ssa/mir/mod.rs @@ -178,7 +178,7 @@ pub fn codegen_mir<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>( // Allocate variable and temp allocas fx.locals = { - let args = arg_local_refs(&mut bx, &fx, &mir, &memory_locals); + let args = arg_local_refs(&mut bx, &fx, &memory_locals); let mut allocate_local = |local| { let decl = &mir.local_decls[local]; @@ -232,7 +232,7 @@ pub fn codegen_mir<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>( // Codegen the body of each block using reverse postorder for (bb, _) in rpo { visited.insert(bb.index()); - fx.codegen_block(bb, &mir); + fx.codegen_block(bb); } // Remove blocks that haven't been visited, or have no @@ -321,16 +321,15 @@ fn create_funclets<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>>( fn arg_local_refs<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>>( bx: &mut Bx, fx: &FunctionCx<'a, 'b, 'tcx, Bx>, - mir: &Body<'tcx>, memory_locals: &BitSet, ) -> Vec> { let mut idx = 0; let mut llarg_idx = fx.fn_abi.ret.is_indirect() as usize; - mir.args_iter().enumerate().map(|(arg_index, local)| { - let arg_decl = &mir.local_decls[local]; + fx.mir.args_iter().enumerate().map(|(arg_index, local)| { + let arg_decl = &fx.mir.local_decls[local]; - if Some(local) == mir.spread_arg { + if Some(local) == fx.mir.spread_arg { // This argument (e.g., the last argument in the "rust-call" ABI) // is a tuple that was spread at the ABI level and now we have // to reconstruct it into a tuple local variable, from multiple diff --git a/src/librustc_codegen_ssa/mir/operand.rs b/src/librustc_codegen_ssa/mir/operand.rs index 9c4bf14c833..947dc2df87d 100644 --- a/src/librustc_codegen_ssa/mir/operand.rs +++ b/src/librustc_codegen_ssa/mir/operand.rs @@ -7,7 +7,7 @@ use crate::glue; use crate::traits::*; use rustc::mir::interpret::{ConstValue, ErrorHandled, Pointer, Scalar}; -use rustc::mir::{self, Body}; +use rustc::mir; use rustc::ty; use rustc::ty::layout::{self, Align, LayoutOf, TyLayout, Size}; @@ -428,13 +428,12 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { pub fn codegen_consume( &mut self, - mir: &Body<'tcx>, bx: &mut Bx, place_ref: &mir::PlaceRef<'_, 'tcx> ) -> OperandRef<'tcx, Bx::Value> { debug!("codegen_consume(place_ref={:?})", place_ref); - let ty = self.monomorphized_place_ty(place_ref, mir); + let ty = self.monomorphized_place_ty(place_ref); let layout = bx.cx().layout_of(ty); // ZSTs don't require any actual memory access. @@ -448,13 +447,12 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { // for most places, to consume them we just load them // out from their home - let place = self.codegen_place(mir, bx, place_ref); + let place = self.codegen_place(bx, place_ref); bx.load_operand(place) } pub fn codegen_operand( &mut self, - mir: &Body<'tcx>, bx: &mut Bx, operand: &mir::Operand<'tcx> ) -> OperandRef<'tcx, Bx::Value> { @@ -463,7 +461,7 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { match *operand { mir::Operand::Copy(ref place) | mir::Operand::Move(ref place) => { - self.codegen_consume(mir, 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 index 50c7fabc225..245998bd87d 100644 --- a/src/librustc_codegen_ssa/mir/place.rs +++ b/src/librustc_codegen_ssa/mir/place.rs @@ -8,7 +8,7 @@ use crate::traits::*; use rustc::ty::{self, Instance, Ty}; use rustc::ty::layout::{self, Align, TyLayout, LayoutOf, VariantIdx, HasTyCtxt}; -use rustc::mir::{self, Body}; +use rustc::mir; use rustc::mir::tcx::PlaceTy; #[derive(Copy, Clone, Debug)] @@ -438,7 +438,6 @@ impl<'a, 'tcx, V: CodegenObject> PlaceRef<'tcx, V> { impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { pub fn codegen_place( &mut self, - mir: &Body<'tcx>, bx: &mut Bx, place_ref: &mir::PlaceRef<'_, 'tcx> ) -> PlaceRef<'tcx, Bx::Value> { @@ -519,7 +518,7 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { projection: [proj_base @ .., mir::ProjectionElem::Deref], } => { // Load the pointer from its location. - self.codegen_consume(mir, bx, &mir::PlaceRef { + self.codegen_consume(bx, &mir::PlaceRef { base, projection: proj_base, }).deref(bx.cx()) @@ -529,7 +528,7 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { projection: [proj_base @ .., elem], } => { // FIXME turn this recursion into iteration - let cg_base = self.codegen_place(mir, bx, &mir::PlaceRef { + let cg_base = self.codegen_place(bx, &mir::PlaceRef { base, projection: proj_base, }); @@ -543,7 +542,7 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { let index = &mir::Operand::Copy( mir::Place::from(*index) ); - let index = self.codegen_operand(mir, bx, index); + let index = self.codegen_operand(bx, index); let llindex = index.immediate(); cg_base.project_index(bx, llindex) } @@ -590,9 +589,9 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { result } - pub fn monomorphized_place_ty(&self, place_ref: &mir::PlaceRef<'_, 'tcx>, mir: &Body<'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.base, place_ref.projection, mir, tcx); + let place_ty = mir::Place::ty_from(place_ref.base, 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 index 8a296b29de7..5180f4376a6 100644 --- a/src/librustc_codegen_ssa/mir/rvalue.rs +++ b/src/librustc_codegen_ssa/mir/rvalue.rs @@ -10,7 +10,7 @@ use crate::traits::*; use rustc::ty::{self, Ty, adjustment::{PointerCast}, Instance}; use rustc::ty::cast::{CastTy, IntTy}; use rustc::ty::layout::{self, LayoutOf, HasTyCtxt}; -use rustc::mir::{self, Body}; +use rustc::mir; use rustc::middle::lang_items::ExchangeMallocFnLangItem; use rustc_apfloat::{ieee, Float, Status, Round}; use syntax::symbol::sym; @@ -21,7 +21,6 @@ use std::{u128, i128}; impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { pub fn codegen_rvalue( &mut self, - mir: &Body<'tcx>, mut bx: Bx, dest: PlaceRef<'tcx, Bx::Value>, rvalue: &mir::Rvalue<'tcx> @@ -31,7 +30,7 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { match *rvalue { mir::Rvalue::Use(ref operand) => { - let cg_operand = self.codegen_operand(mir, &mut bx, operand); + let cg_operand = self.codegen_operand(&mut bx, operand); // FIXME: consider not copying constants through stack. (Fixable by codegen'ing // constants into `OperandValue::Ref`; why don’t we do that yet if we don’t?) cg_operand.val.store(&mut bx, dest); @@ -44,7 +43,7 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { if bx.cx().is_backend_scalar_pair(dest.layout) { // Into-coerce of a thin pointer to a fat pointer -- just // use the operand path. - let (mut bx, temp) = self.codegen_rvalue_operand(mir, bx, rvalue); + let (mut bx, temp) = self.codegen_rvalue_operand(bx, rvalue); temp.val.store(&mut bx, dest); return bx; } @@ -53,7 +52,7 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { // this to be eliminated by MIR building, but // `CoerceUnsized` can be passed by a where-clause, // so the (generic) MIR may not be able to expand it. - let operand = self.codegen_operand(mir, &mut bx, source); + let operand = self.codegen_operand(&mut bx, source); match operand.val { OperandValue::Pair(..) | OperandValue::Immediate(_) => { @@ -82,7 +81,7 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { } mir::Rvalue::Repeat(ref elem, count) => { - let cg_elem = self.codegen_operand(mir, &mut bx, elem); + let cg_elem = self.codegen_operand(&mut bx, elem); // Do not generate the loop for zero-sized elements or empty arrays. if dest.layout.is_zst() { @@ -125,7 +124,7 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { _ => (dest, None) }; for (i, operand) in operands.iter().enumerate() { - let op = self.codegen_operand(mir, &mut bx, operand); + let op = self.codegen_operand(&mut bx, operand); // Do not generate stores and GEPis for zero-sized fields. if !op.layout.is_zst() { let field_index = active_field_index.unwrap_or(i); @@ -137,8 +136,8 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { } _ => { - assert!(self.rvalue_creates_operand(rvalue, DUMMY_SP, mir)); - let (mut bx, temp) = self.codegen_rvalue_operand(mir, bx, rvalue); + assert!(self.rvalue_creates_operand(rvalue, DUMMY_SP)); + let (mut bx, temp) = self.codegen_rvalue_operand(bx, rvalue); temp.val.store(&mut bx, dest); bx } @@ -147,7 +146,6 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { pub fn codegen_rvalue_unsized( &mut self, - mir: &Body<'tcx>, mut bx: Bx, indirect_dest: PlaceRef<'tcx, Bx::Value>, rvalue: &mir::Rvalue<'tcx>, @@ -157,7 +155,7 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { match *rvalue { mir::Rvalue::Use(ref operand) => { - let cg_operand = self.codegen_operand(mir, &mut bx, operand); + let cg_operand = self.codegen_operand(&mut bx, operand); cg_operand.val.store_unsized(&mut bx, indirect_dest); bx } @@ -168,19 +166,18 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { pub fn codegen_rvalue_operand( &mut self, - mir: &Body<'tcx>, mut bx: Bx, rvalue: &mir::Rvalue<'tcx> ) -> (Bx, OperandRef<'tcx, Bx::Value>) { assert!( - self.rvalue_creates_operand(rvalue, DUMMY_SP, mir), + self.rvalue_creates_operand(rvalue, DUMMY_SP), "cannot codegen {:?} to operand", rvalue, ); match *rvalue { mir::Rvalue::Cast(ref kind, ref source, mir_cast_ty) => { - let operand = self.codegen_operand(mir, &mut bx, source); + let operand = self.codegen_operand(&mut bx, source); debug!("cast operand is {:?}", operand); let cast = bx.cx().layout_of(self.monomorphize(&mir_cast_ty)); @@ -373,7 +370,7 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { } mir::Rvalue::Ref(_, bk, ref place) => { - let cg_place = self.codegen_place(mir, &mut bx, &place.as_ref()); + let cg_place = self.codegen_place(&mut bx, &place.as_ref()); let ty = cg_place.layout.ty; @@ -394,7 +391,7 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { } mir::Rvalue::Len(ref place) => { - let size = self.evaluate_array_len(mir, &mut bx, place); + let size = self.evaluate_array_len(&mut bx, place); let operand = OperandRef { val: OperandValue::Immediate(size), layout: bx.cx().layout_of(bx.tcx().types.usize), @@ -403,8 +400,8 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { } mir::Rvalue::BinaryOp(op, ref lhs, ref rhs) => { - let lhs = self.codegen_operand(mir, &mut bx, lhs); - let rhs = self.codegen_operand(mir, &mut bx, rhs); + let lhs = self.codegen_operand(&mut bx, lhs); + let rhs = self.codegen_operand(&mut bx, rhs); let llresult = match (lhs.val, rhs.val) { (OperandValue::Pair(lhs_addr, lhs_extra), OperandValue::Pair(rhs_addr, rhs_extra)) => { @@ -429,8 +426,8 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { (bx, operand) } mir::Rvalue::CheckedBinaryOp(op, ref lhs, ref rhs) => { - let lhs = self.codegen_operand(mir, &mut bx, lhs); - let rhs = self.codegen_operand(mir, &mut bx, rhs); + let lhs = self.codegen_operand(&mut bx, lhs); + let rhs = self.codegen_operand(&mut bx, rhs); let result = self.codegen_scalar_checked_binop(&mut bx, op, lhs.immediate(), rhs.immediate(), lhs.layout.ty); @@ -445,7 +442,7 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { } mir::Rvalue::UnaryOp(op, ref operand) => { - let operand = self.codegen_operand(mir, &mut bx, operand); + let operand = self.codegen_operand(&mut bx, operand); let lloperand = operand.immediate(); let is_float = operand.layout.ty.is_floating_point(); let llval = match op { @@ -463,8 +460,8 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { } mir::Rvalue::Discriminant(ref place) => { - let discr_ty = rvalue.ty(mir, bx.tcx()); - let discr = self.codegen_place(mir, &mut bx, &place.as_ref()) + let discr_ty = rvalue.ty(self.mir, bx.tcx()); + let discr = self.codegen_place(&mut bx, &place.as_ref()) .codegen_get_discr(&mut bx, discr_ty); (bx, OperandRef { val: OperandValue::Immediate(discr), @@ -509,14 +506,14 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { (bx, operand) } mir::Rvalue::Use(ref operand) => { - let operand = self.codegen_operand(mir, &mut bx, operand); + let operand = self.codegen_operand(&mut bx, operand); (bx, operand) } mir::Rvalue::Repeat(..) | mir::Rvalue::Aggregate(..) => { // According to `rvalue_creates_operand`, only ZST // aggregate rvalues are allowed to be operands. - let ty = rvalue.ty(mir, self.cx.tcx()); + let ty = rvalue.ty(self.mir, self.cx.tcx()); let operand = OperandRef::new_zst( &mut bx, self.cx.layout_of(self.monomorphize(&ty)), @@ -528,7 +525,6 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { fn evaluate_array_len( &mut self, - mir: &Body<'tcx>, bx: &mut Bx, place: &mir::Place<'tcx>, ) -> Bx::Value { @@ -543,7 +539,7 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { } } // use common size calculation for non zero-sized types - let cg_value = self.codegen_place(mir, bx, &place.as_ref()); + let cg_value = self.codegen_place(bx, &place.as_ref()); cg_value.len(bx.cx()) } @@ -704,7 +700,6 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { &self, rvalue: &mir::Rvalue<'tcx>, span: Span, - mir: &Body<'tcx> ) -> bool { match *rvalue { mir::Rvalue::Ref(..) | @@ -719,7 +714,7 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { true, mir::Rvalue::Repeat(..) | mir::Rvalue::Aggregate(..) => { - let ty = rvalue.ty(mir, self.cx.tcx()); + let ty = rvalue.ty(self.mir, self.cx.tcx()); let ty = self.monomorphize(&ty); self.cx.spanned_layout_of(ty, span).is_zst() } diff --git a/src/librustc_codegen_ssa/mir/statement.rs b/src/librustc_codegen_ssa/mir/statement.rs index 05c88a316ff..5307108f857 100644 --- a/src/librustc_codegen_ssa/mir/statement.rs +++ b/src/librustc_codegen_ssa/mir/statement.rs @@ -1,4 +1,4 @@ -use rustc::mir::{self, Body}; +use rustc::mir; use crate::traits::BuilderMethods; use super::FunctionCx; @@ -11,25 +11,24 @@ use rustc_error_codes::*; impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { pub fn codegen_statement( &mut self, - mir: &Body<'tcx>, mut bx: Bx, statement: &mir::Statement<'tcx> ) -> Bx { debug!("codegen_statement(statement={:?})", statement); - self.set_debug_loc(&mut bx, statement.source_info, mir); + self.set_debug_loc(&mut bx, statement.source_info); match statement.kind { mir::StatementKind::Assign(box(ref place, ref rvalue)) => { if let Some(index) = place.as_local() { match self.locals[index] { LocalRef::Place(cg_dest) => { - self.codegen_rvalue(mir, bx, cg_dest, rvalue) + self.codegen_rvalue(bx, cg_dest, rvalue) } LocalRef::UnsizedPlace(cg_indirect_dest) => { - self.codegen_rvalue_unsized(mir, bx, cg_indirect_dest, rvalue) + self.codegen_rvalue_unsized(bx, cg_indirect_dest, rvalue) } LocalRef::Operand(None) => { - let (mut bx, operand) = self.codegen_rvalue_operand(mir, bx, rvalue); + let (mut bx, operand) = self.codegen_rvalue_operand(bx, rvalue); self.locals[index] = LocalRef::Operand(Some(operand)); self.debug_introduce_local(&mut bx, index); bx @@ -43,16 +42,16 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { // If the type is zero-sized, it's already been set here, // but we still need to make sure we codegen the operand - self.codegen_rvalue_operand(mir, bx, rvalue).0 + self.codegen_rvalue_operand(bx, rvalue).0 } } } else { - let cg_dest = self.codegen_place(mir, &mut bx, &place.as_ref()); - self.codegen_rvalue(mir, bx, cg_dest, rvalue) + 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(mir, &mut bx, &place.as_ref()) + self.codegen_place(&mut bx, &place.as_ref()) .codegen_set_discr(&mut bx, variant_index); bx } @@ -74,12 +73,12 @@ impl<'a, 'b, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'b, 'tcx, Bx> { } mir::StatementKind::InlineAsm(ref asm) => { let outputs = asm.outputs.iter().map(|output| { - self.codegen_place(mir, &mut bx, &output.as_ref()) + self.codegen_place(&mut bx, &output.as_ref()) }).collect(); let input_vals = asm.inputs.iter() .fold(Vec::with_capacity(asm.inputs.len()), |mut acc, (span, input)| { - let op = self.codegen_operand(mir, &mut bx, input); + let op = self.codegen_operand(&mut bx, input); if let OperandValue::Immediate(_) = op.val { acc.push(op.immediate()); } else {