Auto merge of #111309 - saethlin:InstSimplify, r=scottmcm

Rename InstCombine to InstSimplify

```
╭ ➜ ben@archlinux:~/rust
╰ ➤ rg -i instcombine
src/doc/rustc-dev-guide/src/mir/optimizations.md
134:may have been misapplied. Examples of this are `InstCombine` and `ConstantPropagation`.

src/ci/docker/host-x86_64/disabled/dist-x86_64-haiku/llvm-config.sh
38:                    instcombine instrumentation interpreter ipo irreader lanai \

tests/codegen/slice_as_from_ptr_range.rs
4:// min-llvm-version: 15.0 (because this is a relatively new instcombine)
```

r? `@scottmcm`

compiler/rustc_mir_transform/src/instsimplify.rs

@@ -1,6 +1,6 @@
 //! Performs various peephole optimizations.
 
-use crate::simplify::combine_duplicate_switch_targets;
+use crate::simplify::simplify_duplicate_switch_targets;
 use crate::MirPass;
 use rustc_hir::Mutability;
 use rustc_middle::mir::*;
@@ -10,15 +10,15 @@ use rustc_middle::ty::{self, ParamEnv, SubstsRef, Ty, TyCtxt};
 use rustc_span::symbol::Symbol;
 use rustc_target::abi::FieldIdx;
 
-pub struct InstCombine;
+pub struct InstSimplify;
 
-impl<'tcx> MirPass<'tcx> for InstCombine {
+impl<'tcx> MirPass<'tcx> for InstSimplify {
     fn is_enabled(&self, sess: &rustc_session::Session) -> bool {
         sess.mir_opt_level() > 0
     }
 
     fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
-        let ctx = InstCombineContext {
+        let ctx = InstSimplifyContext {
             tcx,
             local_decls: &body.local_decls,
             param_env: tcx.param_env_reveal_all_normalized(body.source.def_id()),
@@ -27,43 +27,43 @@ impl<'tcx> MirPass<'tcx> for InstCombine {
             for statement in block.statements.iter_mut() {
                 match statement.kind {
                     StatementKind::Assign(box (_place, ref mut rvalue)) => {
-                        ctx.combine_bool_cmp(&statement.source_info, rvalue);
-                        ctx.combine_ref_deref(&statement.source_info, rvalue);
-                        ctx.combine_len(&statement.source_info, rvalue);
-                        ctx.combine_cast(&statement.source_info, rvalue);
+                        ctx.simplify_bool_cmp(&statement.source_info, rvalue);
+                        ctx.simplify_ref_deref(&statement.source_info, rvalue);
+                        ctx.simplify_len(&statement.source_info, rvalue);
+                        ctx.simplify_cast(&statement.source_info, rvalue);
                     }
                     _ => {}
                 }
             }
 
-            ctx.combine_primitive_clone(
+            ctx.simplify_primitive_clone(
                 &mut block.terminator.as_mut().unwrap(),
                 &mut block.statements,
             );
-            ctx.combine_intrinsic_assert(
+            ctx.simplify_intrinsic_assert(
                 &mut block.terminator.as_mut().unwrap(),
                 &mut block.statements,
             );
-            combine_duplicate_switch_targets(block.terminator.as_mut().unwrap());
+            simplify_duplicate_switch_targets(block.terminator.as_mut().unwrap());
         }
     }
 }
 
-struct InstCombineContext<'tcx, 'a> {
+struct InstSimplifyContext<'tcx, 'a> {
     tcx: TyCtxt<'tcx>,
     local_decls: &'a LocalDecls<'tcx>,
     param_env: ParamEnv<'tcx>,
 }
 
-impl<'tcx> InstCombineContext<'tcx, '_> {
-    fn should_combine(&self, source_info: &SourceInfo, rvalue: &Rvalue<'tcx>) -> bool {
+impl<'tcx> InstSimplifyContext<'tcx, '_> {
+    fn should_simplify(&self, source_info: &SourceInfo, rvalue: &Rvalue<'tcx>) -> bool {
         self.tcx.consider_optimizing(|| {
-            format!("InstCombine - Rvalue: {:?} SourceInfo: {:?}", rvalue, source_info)
+            format!("InstSimplify - Rvalue: {:?} SourceInfo: {:?}", rvalue, source_info)
         })
     }
 
     /// Transform boolean comparisons into logical operations.
-    fn combine_bool_cmp(&self, source_info: &SourceInfo, rvalue: &mut Rvalue<'tcx>) {
+    fn simplify_bool_cmp(&self, source_info: &SourceInfo, rvalue: &mut Rvalue<'tcx>) {
         match rvalue {
             Rvalue::BinaryOp(op @ (BinOp::Eq | BinOp::Ne), box (a, b)) => {
                 let new = match (op, self.try_eval_bool(a), self.try_eval_bool(b)) {
@@ -94,7 +94,7 @@ impl<'tcx> InstCombineContext<'tcx, '_> {
                     _ => None,
                 };
 
-                if let Some(new) = new && self.should_combine(source_info, rvalue) {
+                if let Some(new) = new && self.should_simplify(source_info, rvalue) {
                     *rvalue = new;
                 }
             }
@@ -109,14 +109,14 @@ impl<'tcx> InstCombineContext<'tcx, '_> {
     }
 
     /// Transform "&(*a)" ==> "a".
-    fn combine_ref_deref(&self, source_info: &SourceInfo, rvalue: &mut Rvalue<'tcx>) {
+    fn simplify_ref_deref(&self, source_info: &SourceInfo, rvalue: &mut Rvalue<'tcx>) {
         if let Rvalue::Ref(_, _, place) = rvalue {
             if let Some((base, ProjectionElem::Deref)) = place.as_ref().last_projection() {
                 if rvalue.ty(self.local_decls, self.tcx) != base.ty(self.local_decls, self.tcx).ty {
                     return;
                 }
 
-                if !self.should_combine(source_info, rvalue) {
+                if !self.should_simplify(source_info, rvalue) {
                     return;
                 }
 
@@ -129,11 +129,11 @@ impl<'tcx> InstCombineContext<'tcx, '_> {
     }
 
     /// Transform "Len([_; N])" ==> "N".
-    fn combine_len(&self, source_info: &SourceInfo, rvalue: &mut Rvalue<'tcx>) {
+    fn simplify_len(&self, source_info: &SourceInfo, rvalue: &mut Rvalue<'tcx>) {
         if let Rvalue::Len(ref place) = *rvalue {
             let place_ty = place.ty(self.local_decls, self.tcx).ty;
             if let ty::Array(_, len) = *place_ty.kind() {
-                if !self.should_combine(source_info, rvalue) {
+                if !self.should_simplify(source_info, rvalue) {
                     return;
                 }
 
@@ -144,7 +144,7 @@ impl<'tcx> InstCombineContext<'tcx, '_> {
         }
     }
 
-    fn combine_cast(&self, _source_info: &SourceInfo, rvalue: &mut Rvalue<'tcx>) {
+    fn simplify_cast(&self, _source_info: &SourceInfo, rvalue: &mut Rvalue<'tcx>) {
         if let Rvalue::Cast(kind, operand, cast_ty) = rvalue {
             let operand_ty = operand.ty(self.local_decls, self.tcx);
             if operand_ty == *cast_ty {
@@ -196,7 +196,7 @@ impl<'tcx> InstCombineContext<'tcx, '_> {
         }
     }
 
-    fn combine_primitive_clone(
+    fn simplify_primitive_clone(
         &self,
         terminator: &mut Terminator<'tcx>,
         statements: &mut Vec<Statement<'tcx>>,
@@ -239,7 +239,7 @@ impl<'tcx> InstCombineContext<'tcx, '_> {
 
         if !self.tcx.consider_optimizing(|| {
             format!(
-                "InstCombine - Call: {:?} SourceInfo: {:?}",
+                "InstSimplify - Call: {:?} SourceInfo: {:?}",
                 (fn_def_id, fn_substs),
                 terminator.source_info
             )
@@ -262,7 +262,7 @@ impl<'tcx> InstCombineContext<'tcx, '_> {
         terminator.kind = TerminatorKind::Goto { target: destination_block };
     }
 
-    fn combine_intrinsic_assert(
+    fn simplify_intrinsic_assert(
         &self,
         terminator: &mut Terminator<'tcx>,
         _statements: &mut Vec<Statement<'tcx>>,

compiler/rustc_mir_transform/src/lib.rs

@@ -73,7 +73,7 @@ mod ffi_unwind_calls;
 mod function_item_references;
 mod generator;
 mod inline;
-mod instcombine;
+mod instsimplify;
 mod large_enums;
 mod lower_intrinsics;
 mod lower_slice_len;
@@ -547,7 +547,7 @@ fn run_optimization_passes<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
             &match_branches::MatchBranchSimplification,
             // inst combine is after MatchBranchSimplification to clean up Ne(_1, false)
             &multiple_return_terminators::MultipleReturnTerminators,
-            &instcombine::InstCombine,
+            &instsimplify::InstSimplify,
             &separate_const_switch::SeparateConstSwitch,
             &simplify::SimplifyLocals::BeforeConstProp,
             &copy_prop::CopyProp,

compiler/rustc_mir_transform/src/simplify.rs

@@ -278,7 +278,7 @@ impl<'a, 'tcx> CfgSimplifier<'a, 'tcx> {
     }
 }
 
-pub fn combine_duplicate_switch_targets(terminator: &mut Terminator<'_>) {
+pub fn simplify_duplicate_switch_targets(terminator: &mut Terminator<'_>) {
     if let TerminatorKind::SwitchInt { targets, .. } = &mut terminator.kind {
         let otherwise = targets.otherwise();
         if targets.iter().any(|t| t.1 == otherwise) {
@@ -310,7 +310,7 @@ pub fn remove_duplicate_unreachable_blocks<'tcx>(tcx: TyCtxt<'tcx>, body: &mut B
                 }
             }
 
-            combine_duplicate_switch_targets(terminator);
+            simplify_duplicate_switch_targets(terminator);
 
             self.super_terminator(terminator, location);
         }

compiler/rustc_session/src/options.rs

@@ -1555,7 +1555,7 @@ options! {
         "emit Retagging MIR statements, interpreted e.g., by miri; implies -Zmir-opt-level=0 \
         (default: no)"),
     mir_enable_passes: Vec<(String, bool)> = (Vec::new(), parse_list_with_polarity, [TRACKED],
-        "use like `-Zmir-enable-passes=+DestProp,-InstCombine`. Forces the specified passes to be \
+        "use like `-Zmir-enable-passes=+DestinationPropagation,-InstSimplify`. Forces the specified passes to be \
         enabled, overriding all other checks. Passes that are not specified are enabled or \
         disabled by other flags as usual."),
     mir_keep_place_mention: bool = (false, parse_bool, [TRACKED],

tests/mir-opt/bool_compare.opt1.InstSimplify.diff

@@ -1,5 +1,5 @@
-- // MIR for `opt1` before InstCombine
-+ // MIR for `opt1` after InstCombine
+- // MIR for `opt1` before InstSimplify
++ // MIR for `opt1` after InstSimplify
   
   fn opt1(_1: bool) -> u32 {
       debug x => _1;                       // in scope 0 at $DIR/bool_compare.rs:+0:9: +0:10

tests/mir-opt/bool_compare.opt2.InstSimplify.diff

@@ -1,5 +1,5 @@
-- // MIR for `opt2` before InstCombine
-+ // MIR for `opt2` after InstCombine
+- // MIR for `opt2` before InstSimplify
++ // MIR for `opt2` after InstSimplify
   
   fn opt2(_1: bool) -> u32 {
       debug x => _1;                       // in scope 0 at $DIR/bool_compare.rs:+0:9: +0:10

tests/mir-opt/bool_compare.opt3.InstSimplify.diff

@@ -1,5 +1,5 @@
-- // MIR for `opt3` before InstCombine
-+ // MIR for `opt3` after InstCombine
+- // MIR for `opt3` before InstSimplify
++ // MIR for `opt3` after InstSimplify
   
   fn opt3(_1: bool) -> u32 {
       debug x => _1;                       // in scope 0 at $DIR/bool_compare.rs:+0:9: +0:10

tests/mir-opt/bool_compare.opt4.InstSimplify.diff

@@ -1,5 +1,5 @@
-- // MIR for `opt4` before InstCombine
-+ // MIR for `opt4` after InstCombine
+- // MIR for `opt4` before InstSimplify
++ // MIR for `opt4` after InstSimplify
   
   fn opt4(_1: bool) -> u32 {
       debug x => _1;                       // in scope 0 at $DIR/bool_compare.rs:+0:9: +0:10

tests/mir-opt/bool_compare.rs

@@ -1,21 +1,21 @@
-// unit-test: InstCombine
+// unit-test: InstSimplify
 
-// EMIT_MIR bool_compare.opt1.InstCombine.diff
+// EMIT_MIR bool_compare.opt1.InstSimplify.diff
 fn opt1(x: bool) -> u32 {
     if x != true { 0 } else { 1 }
 }
 
-// EMIT_MIR bool_compare.opt2.InstCombine.diff
+// EMIT_MIR bool_compare.opt2.InstSimplify.diff
 fn opt2(x: bool) -> u32 {
     if true != x { 0 } else { 1 }
 }
 
-// EMIT_MIR bool_compare.opt3.InstCombine.diff
+// EMIT_MIR bool_compare.opt3.InstSimplify.diff
 fn opt3(x: bool) -> u32 {
     if x == false { 0 } else { 1 }
 }
 
-// EMIT_MIR bool_compare.opt4.InstCombine.diff
+// EMIT_MIR bool_compare.opt4.InstSimplify.diff
 fn opt4(x: bool) -> u32 {
     if false == x { 0 } else { 1 }
 }

tests/mir-opt/casts.redundant.InstSimplify.diff

@@ -1,5 +1,5 @@
-- // MIR for `redundant` before InstCombine
-+ // MIR for `redundant` after InstCombine
+- // MIR for `redundant` before InstSimplify
++ // MIR for `redundant` after InstSimplify
   
   fn redundant(_1: *const &u8) -> *const &u8 {
       debug x => _1;                       // in scope 0 at $DIR/casts.rs:+0:30: +0:31

tests/mir-opt/casts.rs

@@ -1,6 +1,6 @@
 #![crate_type = "lib"]
 
-// EMIT_MIR casts.redundant.InstCombine.diff
+// EMIT_MIR casts.redundant.InstSimplify.diff
 // EMIT_MIR casts.redundant.PreCodegen.after.mir
 pub fn redundant<'a, 'b: 'a>(x: *const &'a u8) -> *const &'a u8 {
     generic_cast::<&'a u8, &'b u8>(x) as *const &'a u8

tests/mir-opt/combine_array_len.norm2.InstSimplify.diff

@@ -1,5 +1,5 @@
-- // MIR for `norm2` before InstCombine
-+ // MIR for `norm2` after InstCombine
+- // MIR for `norm2` before InstSimplify
++ // MIR for `norm2` after InstSimplify
   
   fn norm2(_1: [f32; 2]) -> f32 {
       debug x => _1;                       // in scope 0 at $DIR/combine_array_len.rs:+0:10: +0:11

tests/mir-opt/combine_array_len.rs

@@ -1,6 +1,6 @@
 // ignore-wasm32 compiled with panic=abort by default
-// unit-test: InstCombine
-// EMIT_MIR combine_array_len.norm2.InstCombine.diff
+// unit-test: InstSimplify
+// EMIT_MIR combine_array_len.norm2.InstSimplify.diff
 
 fn norm2(x: [f32; 2]) -> f32 {
     let a = x[0];

tests/mir-opt/combine_clone_of_primitives.rs

@@ -1,7 +1,7 @@
-// unit-test: InstCombine
+// unit-test: InstSimplify
 // ignore-wasm32 compiled with panic=abort by default
 
-// EMIT_MIR combine_clone_of_primitives.{impl#0}-clone.InstCombine.diff
+// EMIT_MIR combine_clone_of_primitives.{impl#0}-clone.InstSimplify.diff
 
 #[derive(Clone)]
 struct MyThing<T> {

tests/mir-opt/combine_clone_of_primitives.{impl#0}-clone.InstSimplify.diff

@@ -1,5 +1,5 @@
-- // MIR for `<impl at $DIR/combine_clone_of_primitives.rs:6:10: 6:15>::clone` before InstCombine
-+ // MIR for `<impl at $DIR/combine_clone_of_primitives.rs:6:10: 6:15>::clone` after InstCombine
+- // MIR for `<impl at $DIR/combine_clone_of_primitives.rs:6:10: 6:15>::clone` before InstSimplify
++ // MIR for `<impl at $DIR/combine_clone_of_primitives.rs:6:10: 6:15>::clone` after InstSimplify
   
   fn <impl at $DIR/combine_clone_of_primitives.rs:6:10: 6:15>::clone(_1: &MyThing<T>) -> MyThing<T> {
       debug self => _1;                    // in scope 0 at $DIR/combine_clone_of_primitives.rs:+0:10: +0:15

tests/mir-opt/combine_transmutes.adt_transmutes.InstSimplify.diff

@@ -1,5 +1,5 @@
-- // MIR for `adt_transmutes` before InstCombine
-+ // MIR for `adt_transmutes` after InstCombine
+- // MIR for `adt_transmutes` before InstSimplify
++ // MIR for `adt_transmutes` after InstSimplify
   
   fn adt_transmutes() -> () {
       let mut _0: ();                      // return place in scope 0 at $DIR/combine_transmutes.rs:+0:32: +0:32

tests/mir-opt/combine_transmutes.identity_transmutes.InstSimplify.diff

@@ -1,5 +1,5 @@
-- // MIR for `identity_transmutes` before InstCombine
-+ // MIR for `identity_transmutes` after InstCombine
+- // MIR for `identity_transmutes` before InstSimplify
++ // MIR for `identity_transmutes` after InstSimplify
   
   fn identity_transmutes() -> () {
       let mut _0: ();                      // return place in scope 0 at $DIR/combine_transmutes.rs:+0:37: +0:37

tests/mir-opt/combine_transmutes.integer_transmutes.InstSimplify.diff

@@ -1,5 +1,5 @@
-- // MIR for `integer_transmutes` before InstCombine
-+ // MIR for `integer_transmutes` after InstCombine
+- // MIR for `integer_transmutes` before InstSimplify
++ // MIR for `integer_transmutes` after InstSimplify
   
   fn integer_transmutes() -> () {
       let mut _0: ();                      // return place in scope 0 at $DIR/combine_transmutes.rs:+0:36: +0:36

tests/mir-opt/combine_transmutes.rs

@@ -1,4 +1,4 @@
-// unit-test: InstCombine
+// unit-test: InstSimplify
 // compile-flags: -C panic=abort
 
 #![crate_type = "lib"]
@@ -8,7 +8,7 @@
 use std::intrinsics::mir::*;
 use std::mem::{MaybeUninit, ManuallyDrop, transmute};
 
-// EMIT_MIR combine_transmutes.identity_transmutes.InstCombine.diff
+// EMIT_MIR combine_transmutes.identity_transmutes.InstSimplify.diff
 pub unsafe fn identity_transmutes() {
     // These are nops and should be removed
     let _a = transmute::<i32, i32>(1);
@@ -16,7 +16,7 @@ pub unsafe fn identity_transmutes() {
 }
 
 #[custom_mir(dialect = "runtime", phase = "initial")]
-// EMIT_MIR combine_transmutes.integer_transmutes.InstCombine.diff
+// EMIT_MIR combine_transmutes.integer_transmutes.InstSimplify.diff
 pub unsafe fn integer_transmutes() {
     mir! {
         {
@@ -30,7 +30,7 @@ pub unsafe fn integer_transmutes() {
     }
 }
 
-// EMIT_MIR combine_transmutes.adt_transmutes.InstCombine.diff
+// EMIT_MIR combine_transmutes.adt_transmutes.InstSimplify.diff
 pub unsafe fn adt_transmutes() {
     let _a: u8 = transmute(EnumNoRepr::A);
     let _a: i8 = transmute(EnumNoRepr::B);

tests/mir-opt/const_prop/slice_len.rs

@@ -1,6 +1,6 @@
 // ignore-wasm32 compiled with panic=abort by default
 // unit-test: ConstProp
-// compile-flags: -Zmir-enable-passes=+InstCombine
+// compile-flags: -Zmir-enable-passes=+InstSimplify
 // EMIT_MIR_FOR_EACH_BIT_WIDTH
 
 // EMIT_MIR slice_len.main.ConstProp.diff

tests/mir-opt/dont_yeet_assert.generic.InstSimplify.diff

@@ -1,5 +1,5 @@
-- // MIR for `generic` before InstCombine
-+ // MIR for `generic` after InstCombine
+- // MIR for `generic` before InstSimplify
++ // MIR for `generic` after InstSimplify
   
   fn generic() -> () {
       let mut _0: ();                      // return place in scope 0 at $DIR/dont_yeet_assert.rs:+0:21: +0:21

tests/mir-opt/dont_yeet_assert.rs

@@ -1,11 +1,11 @@
 // compile-flags: --crate-type=lib
-// unit-test: InstCombine
+// unit-test: InstSimplify
 
 #![feature(core_intrinsics)]
 
 // Want to make sure this assertion isn't compiled away in generic code.
 
-// EMIT_MIR dont_yeet_assert.generic.InstCombine.diff
+// EMIT_MIR dont_yeet_assert.generic.InstSimplify.diff
 pub fn generic<T>() {
     core::intrinsics::assert_mem_uninitialized_valid::<&T>();
 }

tests/mir-opt/equal_true.opt.InstSimplify.diff

@@ -1,5 +1,5 @@
-- // MIR for `opt` before InstCombine
-+ // MIR for `opt` after InstCombine
+- // MIR for `opt` before InstSimplify
++ // MIR for `opt` after InstSimplify
   
   fn opt(_1: bool) -> i32 {
       debug x => _1;                       // in scope 0 at $DIR/equal_true.rs:+0:8: +0:9

tests/mir-opt/equal_true.rs

@@ -1,6 +1,6 @@
-// unit-test InstCombine
+// unit-test InstSimplify
 
-// EMIT_MIR equal_true.opt.InstCombine.diff
+// EMIT_MIR equal_true.opt.InstSimplify.diff
 
 fn opt(x: bool) -> i32 {
     if x == true { 0 } else { 1 }

tests/mir-opt/instsimplify_duplicate_switch_targets.assert_zero.InstSimplify.diff

@@ -1,21 +1,21 @@
-- // MIR for `assert_zero` before InstCombine
-+ // MIR for `assert_zero` after InstCombine
+- // MIR for `assert_zero` before InstSimplify
++ // MIR for `assert_zero` after InstSimplify
   
   fn assert_zero(_1: u8) -> u8 {
-      let mut _0: u8;                      // return place in scope 0 at $DIR/instcombine_duplicate_switch_targets.rs:+0:37: +0:39
+      let mut _0: u8;                      // return place in scope 0 at $DIR/instsimplify_duplicate_switch_targets.rs:+0:37: +0:39
   
       bb0: {
--         switchInt(_1) -> [0: bb2, 1: bb1, otherwise: bb1]; // scope 0 at $DIR/instcombine_duplicate_switch_targets.rs:+3:13: +7:14
-+         switchInt(_1) -> [0: bb2, otherwise: bb1]; // scope 0 at $DIR/instcombine_duplicate_switch_targets.rs:+3:13: +7:14
+-         switchInt(_1) -> [0: bb2, 1: bb1, otherwise: bb1]; // scope 0 at $DIR/instsimplify_duplicate_switch_targets.rs:+3:13: +7:14
++         switchInt(_1) -> [0: bb2, otherwise: bb1]; // scope 0 at $DIR/instsimplify_duplicate_switch_targets.rs:+3:13: +7:14
       }
   
       bb1: {
-          unreachable;                     // scope 0 at $DIR/instcombine_duplicate_switch_targets.rs:+10:13: +10:26
+          unreachable;                     // scope 0 at $DIR/instsimplify_duplicate_switch_targets.rs:+10:13: +10:26
       }
   
       bb2: {
-          _0 = _1;                         // scope 0 at $DIR/instcombine_duplicate_switch_targets.rs:+13:13: +13:20
-          return;                          // scope 0 at $DIR/instcombine_duplicate_switch_targets.rs:+14:13: +14:21
+          _0 = _1;                         // scope 0 at $DIR/instsimplify_duplicate_switch_targets.rs:+13:13: +13:20
+          return;                          // scope 0 at $DIR/instsimplify_duplicate_switch_targets.rs:+14:13: +14:21
       }
   }
   

tests/mir-opt/instsimplify_duplicate_switch_targets.rs

@@ -3,9 +3,9 @@
 
 use std::intrinsics::mir::*;
 
-// unit-test: InstCombine
+// unit-test: InstSimplify
 
-// EMIT_MIR instcombine_duplicate_switch_targets.assert_zero.InstCombine.diff
+// EMIT_MIR instsimplify_duplicate_switch_targets.assert_zero.InstSimplify.diff
 #[custom_mir(dialect = "runtime", phase = "post-cleanup")]
 pub unsafe fn assert_zero(x: u8) -> u8 {
     mir!(

tests/mir-opt/intrinsic_asserts.generic.InstSimplify.diff

@@ -1,5 +1,5 @@
-- // MIR for `generic` before InstCombine
-+ // MIR for `generic` after InstCombine
+- // MIR for `generic` before InstSimplify
++ // MIR for `generic` after InstSimplify
   
   fn generic() -> () {
       let mut _0: ();                      // return place in scope 0 at $DIR/intrinsic_asserts.rs:+0:21: +0:21

tests/mir-opt/intrinsic_asserts.panics.InstSimplify.diff

@@ -1,5 +1,5 @@
-- // MIR for `panics` before InstCombine
-+ // MIR for `panics` after InstCombine
+- // MIR for `panics` before InstSimplify
++ // MIR for `panics` after InstSimplify
   
   fn panics() -> () {
       let mut _0: ();                      // return place in scope 0 at $DIR/intrinsic_asserts.rs:+0:17: +0:17

tests/mir-opt/intrinsic_asserts.removable.InstSimplify.diff

@@ -1,5 +1,5 @@
-- // MIR for `removable` before InstCombine
-+ // MIR for `removable` after InstCombine
+- // MIR for `removable` before InstSimplify
++ // MIR for `removable` after InstSimplify
   
   fn removable() -> () {
       let mut _0: ();                      // return place in scope 0 at $DIR/intrinsic_asserts.rs:+0:20: +0:20

tests/mir-opt/intrinsic_asserts.rs

@@ -2,7 +2,7 @@
 #![feature(core_intrinsics)]
 
 // All these assertions pass, so all the intrinsic calls should be deleted.
-// EMIT_MIR intrinsic_asserts.removable.InstCombine.diff
+// EMIT_MIR intrinsic_asserts.removable.InstSimplify.diff
 pub fn removable() {
     core::intrinsics::assert_inhabited::<()>();
     core::intrinsics::assert_zero_valid::<u8>();
@@ -12,7 +12,7 @@ pub fn removable() {
 enum Never {}
 
 // These assertions all diverge, so their target blocks should become None.
-// EMIT_MIR intrinsic_asserts.panics.InstCombine.diff
+// EMIT_MIR intrinsic_asserts.panics.InstSimplify.diff
 pub fn panics() {
     core::intrinsics::assert_inhabited::<Never>();
     core::intrinsics::assert_zero_valid::<&u8>();
@@ -20,7 +20,7 @@ pub fn panics() {
 }
 
 // Whether or not these asserts pass isn't known, so they shouldn't be modified.
-// EMIT_MIR intrinsic_asserts.generic.InstCombine.diff
+// EMIT_MIR intrinsic_asserts.generic.InstSimplify.diff
 pub fn generic<T>() {
     core::intrinsics::assert_inhabited::<T>();
     core::intrinsics::assert_zero_valid::<T>();

tests/mir-opt/issue_78192.f.InstSimplify.diff

@@ -1,5 +1,5 @@
-- // MIR for `f` before InstCombine
-+ // MIR for `f` after InstCombine
+- // MIR for `f` before InstSimplify
++ // MIR for `f` after InstSimplify
   
   fn f(_1: &T) -> *const T {
       debug a => _1;                       // in scope 0 at $DIR/issue_78192.rs:+0:13: +0:14

tests/mir-opt/issue_78192.rs

@@ -8,4 +8,4 @@ fn main() {
     f(&2);
 }
 
-// EMIT_MIR issue_78192.f.InstCombine.diff
+// EMIT_MIR issue_78192.f.InstSimplify.diff

tests/mir-opt/not_equal_false.opt.InstSimplify.diff

@@ -1,5 +1,5 @@
-- // MIR for `opt` before InstCombine
-+ // MIR for `opt` after InstCombine
+- // MIR for `opt` before InstSimplify
++ // MIR for `opt` after InstSimplify
   
   fn opt(_1: bool) -> u32 {
       debug x => _1;                       // in scope 0 at $DIR/not_equal_false.rs:+0:8: +0:9

tests/mir-opt/not_equal_false.rs

@@ -1,5 +1,5 @@
-// unit-test: InstCombine
-// EMIT_MIR not_equal_false.opt.InstCombine.diff
+// unit-test: InstSimplify
+// EMIT_MIR not_equal_false.opt.InstSimplify.diff
 
 fn opt(x: bool) -> u32 {
     if x != false { 0 } else { 1 }

tests/ui/lint/invalid_value-polymorphic.rs

@@ -1,4 +1,4 @@
-// compile-flags: --crate-type=lib -Zmir-enable-passes=+InstCombine
+// compile-flags: --crate-type=lib -Zmir-enable-passes=+InstSimplify
 // build-pass
 
 #![feature(core_intrinsics)]