Support Yield in ops.

Author: cjgillot

compiler/rustc_mir_transform/src/cost_checker.rs

@@ -107,6 +107,7 @@ impl<'tcx> Visitor<'tcx> for CostChecker<'_, 'tcx> {
                     }
                 }
             }
+            TerminatorKind::Yield { .. } => self.penalty += CALL_PENALTY,
             TerminatorKind::Call { func, unwind, .. } => {
                 self.penalty += if let Some((def_id, ..)) = func.const_fn_def()
                     && self.tcx.intrinsic(def_id).is_some()
@@ -163,12 +164,11 @@ impl<'tcx> Visitor<'tcx> for CostChecker<'_, 'tcx> {
             TerminatorKind::Unreachable => {
                 self.bonus += INSTR_COST;
             }
-            TerminatorKind::Goto { .. } | TerminatorKind::Return => {}
+            TerminatorKind::Goto { .. }
+            | TerminatorKind::Return
+            | TerminatorKind::CoroutineDrop => {}
             TerminatorKind::UnwindTerminate(..) => {}
-            kind @ (TerminatorKind::FalseUnwind { .. }
-            | TerminatorKind::FalseEdge { .. }
-            | TerminatorKind::Yield { .. }
-            | TerminatorKind::CoroutineDrop) => {
+            kind @ (TerminatorKind::FalseUnwind { .. } | TerminatorKind::FalseEdge { .. }) => {
                 bug!("{kind:?} should not be in runtime MIR");
             }
         }

compiler/rustc_mir_transform/src/dataflow_const_prop.rs

@@ -239,9 +239,8 @@ impl<'a, 'tcx> ConstAnalysis<'a, 'tcx> {
             TerminatorKind::Drop { place, .. } => {
                 state.flood_with(place.as_ref(), &self.map, FlatSet::<Scalar>::BOTTOM);
             }
-            TerminatorKind::Yield { .. } => {
-                // They would have an effect, but are not allowed in this phase.
-                bug!("encountered disallowed terminator");
+            TerminatorKind::Yield { resume_arg, .. } => {
+                state.flood_with(resume_arg.as_ref(), &self.map, FlatSet::<Scalar>::BOTTOM);
             }
             TerminatorKind::SwitchInt { discr, targets } => {
                 return self.handle_switch_int(discr, targets, state);

compiler/rustc_mir_transform/src/gvn.rs

@@ -2062,14 +2062,18 @@ impl<'tcx> MutVisitor<'tcx> for VnState<'_, '_, 'tcx> {
     }
 
     fn visit_terminator(&mut self, terminator: &mut Terminator<'tcx>, location: Location) {
-        if let Terminator { kind: TerminatorKind::Call { destination, .. }, .. } = terminator {
-            if let Some(local) = destination.as_local()
-                && self.ssa.is_ssa(local)
-            {
-                let ty = self.local_decls[local].ty;
-                let opaque = self.new_opaque(ty);
-                self.assign(local, opaque);
-            }
+        let destination = match terminator.kind {
+            TerminatorKind::Call { destination, .. } => Some(destination),
+            TerminatorKind::Yield { resume_arg, .. } => Some(resume_arg),
+            _ => None,
+        };
+        if let Some(destination) = destination
+            && let Some(local) = destination.as_local()
+            && self.ssa.is_ssa(local)
+        {
+            let ty = self.local_decls[local].ty;
+            let opaque = self.new_opaque(ty);
+            self.assign(local, opaque);
         }
         self.super_terminator(terminator, location);
     }

compiler/rustc_mir_transform/src/jump_threading.rs

@@ -650,9 +650,9 @@ impl<'a, 'tcx> TOFinder<'a, 'tcx> {
         let term = self.body.basic_blocks[bb].terminator();
         let place_to_flood = match term.kind {
             // Disallowed during optimizations.
-            TerminatorKind::FalseEdge { .. }
-            | TerminatorKind::FalseUnwind { .. }
-            | TerminatorKind::Yield { .. } => bug!("{term:?} invalid"),
+            TerminatorKind::FalseEdge { .. } | TerminatorKind::FalseUnwind { .. } => {
+                bug!("{term:?} invalid")
+            }
             // Cannot reason about inline asm.
             TerminatorKind::InlineAsm { .. } => {
                 state.active.clear();
@@ -673,6 +673,7 @@ impl<'a, 'tcx> TOFinder<'a, 'tcx> {
             | TerminatorKind::Goto { .. } => None,
             // Flood the overwritten place, and progress through.
             TerminatorKind::Drop { place: destination, .. }
+            | TerminatorKind::Yield { resume_arg: destination, .. }
             | TerminatorKind::Call { destination, .. } => Some(destination),
             TerminatorKind::TailCall { .. } => Some(RETURN_PLACE.into()),
         };