| use rustc_middle::mir::{self, NonDivergingIntrinsic, StmtDebugInfo}; |
| use rustc_middle::span_bug; |
| use tracing::instrument; |
| |
| use super::{FunctionCx, LocalRef}; |
| use crate::traits::*; |
| |
| impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> { |
| #[instrument(level = "debug", skip(self, bx))] |
| pub(crate) fn codegen_statement(&mut self, bx: &mut Bx, statement: &mir::Statement<'tcx>) { |
| self.codegen_stmt_debuginfos(bx, &statement.debuginfos); |
| self.set_debug_loc(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(bx, cg_dest, rvalue), |
| LocalRef::UnsizedPlace(cg_indirect_dest) => { |
| let ty = cg_indirect_dest.layout.ty; |
| span_bug!( |
| statement.source_info.span, |
| "cannot reallocate from `UnsizedPlace({ty})` \ |
| into `{rvalue:?}`; dynamic alloca is not supported", |
| ); |
| } |
| LocalRef::PendingOperand => { |
| let operand = self.codegen_rvalue_operand(bx, rvalue); |
| self.overwrite_local(index, LocalRef::Operand(operand)); |
| self.debug_introduce_local(bx, index); |
| } |
| LocalRef::Operand(op) => { |
| if !op.layout.is_zst() { |
| span_bug!( |
| statement.source_info.span, |
| "operand {:?} already assigned", |
| rvalue |
| ); |
| } |
| |
| // 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(bx, rvalue); |
| } |
| } |
| } else { |
| let cg_dest = self.codegen_place(bx, place.as_ref()); |
| self.codegen_rvalue(bx, cg_dest, rvalue); |
| } |
| } |
| mir::StatementKind::SetDiscriminant { box ref place, variant_index } => { |
| self.codegen_place(bx, place.as_ref()).codegen_set_discr(bx, variant_index); |
| } |
| mir::StatementKind::StorageLive(local) => { |
| if let LocalRef::Place(cg_place) = self.locals[local] { |
| cg_place.storage_live(bx); |
| } else if let LocalRef::UnsizedPlace(cg_indirect_place) = self.locals[local] { |
| cg_indirect_place.storage_live(bx); |
| } |
| } |
| mir::StatementKind::StorageDead(local) => { |
| if let LocalRef::Place(cg_place) = self.locals[local] { |
| cg_place.storage_dead(bx); |
| } else if let LocalRef::UnsizedPlace(cg_indirect_place) = self.locals[local] { |
| cg_indirect_place.storage_dead(bx); |
| } |
| } |
| mir::StatementKind::Coverage(ref kind) => { |
| self.codegen_coverage(bx, kind, statement.source_info.scope); |
| } |
| mir::StatementKind::Intrinsic(box NonDivergingIntrinsic::Assume(ref op)) => { |
| let op_val = self.codegen_operand(bx, op); |
| bx.assume(op_val.immediate()); |
| } |
| mir::StatementKind::Intrinsic(box NonDivergingIntrinsic::CopyNonOverlapping( |
| mir::CopyNonOverlapping { ref count, ref src, ref dst }, |
| )) => { |
| let dst_val = self.codegen_operand(bx, dst); |
| let src_val = self.codegen_operand(bx, src); |
| let count = self.codegen_operand(bx, count).immediate(); |
| let pointee_layout = dst_val |
| .layout |
| .pointee_info_at(bx, rustc_abi::Size::ZERO) |
| .expect("Expected pointer"); |
| let bytes = bx.mul(count, bx.const_usize(pointee_layout.size.bytes())); |
| |
| let align = pointee_layout.align; |
| let dst = dst_val.immediate(); |
| let src = src_val.immediate(); |
| bx.memcpy(dst, align, src, align, bytes, crate::MemFlags::empty(), None); |
| } |
| mir::StatementKind::FakeRead(..) |
| | mir::StatementKind::Retag { .. } |
| | mir::StatementKind::AscribeUserType(..) |
| | mir::StatementKind::ConstEvalCounter |
| | mir::StatementKind::PlaceMention(..) |
| | mir::StatementKind::BackwardIncompatibleDropHint { .. } |
| | mir::StatementKind::Nop => {} |
| } |
| } |
| |
| pub(crate) fn codegen_stmt_debuginfo(&mut self, bx: &mut Bx, debuginfo: &StmtDebugInfo<'tcx>) { |
| match debuginfo { |
| StmtDebugInfo::AssignRef(dest, place) => { |
| let local_ref = match self.locals[place.local] { |
| // For an rvalue like `&(_1.1)`, when `BackendRepr` is `BackendRepr::Memory`, we allocate a block of memory to this place. |
| // The place is an indirect pointer, we can refer to it directly. |
| LocalRef::Place(place_ref) => Some((place_ref, place.projection.as_slice())), |
| // For an rvalue like `&((*_1).1)`, we are calculating the address of `_1.1`. |
| // The deref projection is no-op here. |
| LocalRef::Operand(operand_ref) if place.is_indirect_first_projection() => { |
| Some((operand_ref.deref(bx.cx()), &place.projection[1..])) |
| } |
| // For an rvalue like `&1`, when `BackendRepr` is `BackendRepr::Scalar`, |
| // we cannot get the address. |
| // N.B. `non_ssa_locals` returns that this is an SSA local. |
| LocalRef::Operand(_) => None, |
| LocalRef::UnsizedPlace(_) | LocalRef::PendingOperand => None, |
| } |
| .filter(|(_, projection)| { |
| // Drop unsupported projections. |
| projection.iter().all(|p| p.can_use_in_debuginfo()) |
| }); |
| if let Some((base, projection)) = local_ref { |
| self.debug_new_val_to_local(bx, *dest, base, projection); |
| } else { |
| // If the address cannot be calculated, use poison to indicate that the value has been optimized out. |
| self.debug_poison_to_local(bx, *dest); |
| } |
| } |
| StmtDebugInfo::InvalidAssign(local) => { |
| self.debug_poison_to_local(bx, *local); |
| } |
| } |
| } |
| |
| pub(crate) fn codegen_stmt_debuginfos( |
| &mut self, |
| bx: &mut Bx, |
| debuginfos: &[StmtDebugInfo<'tcx>], |
| ) { |
| for debuginfo in debuginfos { |
| self.codegen_stmt_debuginfo(bx, debuginfo); |
| } |
| } |
| } |
