diff --git a/compiler/optimizing/optimization.cc b/compiler/optimizing/optimization.cc
index 57db7a6..d37c43d 100644
--- a/compiler/optimizing/optimization.cc
+++ b/compiler/optimizing/optimization.cc
@@ -121,12 +121,15 @@
     case OptimizationPass::kX86MemoryOperandGeneration:
       return x86::X86MemoryOperandGeneration::kX86MemoryOperandGenerationPassName;
 #endif
+    case OptimizationPass::kNone:
+      LOG(FATAL) << "kNone does not represent an actual pass";
+      UNREACHABLE();
   }
 }
 
-#define X(x) if (name == OptimizationPassName((x))) return (x)
+#define X(x) if (pass_name == OptimizationPassName((x))) return (x)
 
-OptimizationPass OptimizationPassByName(const std::string& name) {
+OptimizationPass OptimizationPassByName(const std::string& pass_name) {
   X(OptimizationPass::kBoundsCheckElimination);
   X(OptimizationPass::kCHAGuardOptimization);
   X(OptimizationPass::kCodeSinking);
@@ -160,7 +163,7 @@
   X(OptimizationPass::kPcRelativeFixupsX86);
   X(OptimizationPass::kX86MemoryOperandGeneration);
 #endif
-  LOG(FATAL) << "Cannot find optimization " << name;
+  LOG(FATAL) << "Cannot find optimization " << pass_name;
   UNREACHABLE();
 }
 
@@ -187,9 +190,9 @@
 
   // Loop over the requested optimizations.
   for (size_t i = 0; i < length; i++) {
-    OptimizationPass pass = definitions[i].first;
-    const char* alt_name = definitions[i].second;
-    const char* name = alt_name != nullptr
+    OptimizationPass pass = definitions[i].pass;
+    const char* alt_name = definitions[i].pass_name;
+    const char* pass_name = alt_name != nullptr
         ? alt_name
         : OptimizationPassName(pass);
     HOptimization* opt = nullptr;
@@ -199,47 +202,48 @@
       // Analysis passes (kept in most recent for subsequent passes).
       //
       case OptimizationPass::kSideEffectsAnalysis:
-        opt = most_recent_side_effects = new (allocator) SideEffectsAnalysis(graph, name);
+        opt = most_recent_side_effects = new (allocator) SideEffectsAnalysis(graph, pass_name);
         break;
       case OptimizationPass::kInductionVarAnalysis:
-        opt = most_recent_induction = new (allocator) HInductionVarAnalysis(graph, name);
+        opt = most_recent_induction = new (allocator) HInductionVarAnalysis(graph, pass_name);
         break;
       case OptimizationPass::kLoadStoreAnalysis:
-        opt = most_recent_lsa = new (allocator) LoadStoreAnalysis(graph, name);
+        opt = most_recent_lsa = new (allocator) LoadStoreAnalysis(graph, pass_name);
         break;
       //
       // Passes that need prior analysis.
       //
       case OptimizationPass::kGlobalValueNumbering:
         CHECK(most_recent_side_effects != nullptr);
-        opt = new (allocator) GVNOptimization(graph, *most_recent_side_effects, name);
+        opt = new (allocator) GVNOptimization(graph, *most_recent_side_effects, pass_name);
         break;
       case OptimizationPass::kInvariantCodeMotion:
         CHECK(most_recent_side_effects != nullptr);
-        opt = new (allocator) LICM(graph, *most_recent_side_effects, stats, name);
+        opt = new (allocator) LICM(graph, *most_recent_side_effects, stats, pass_name);
         break;
       case OptimizationPass::kLoopOptimization:
         CHECK(most_recent_induction != nullptr);
-        opt = new (allocator) HLoopOptimization(graph, driver, most_recent_induction, stats, name);
+        opt = new (allocator) HLoopOptimization(
+            graph, driver, most_recent_induction, stats, pass_name);
         break;
       case OptimizationPass::kBoundsCheckElimination:
         CHECK(most_recent_side_effects != nullptr && most_recent_induction != nullptr);
         opt = new (allocator) BoundsCheckElimination(
-            graph, *most_recent_side_effects, most_recent_induction, name);
+            graph, *most_recent_side_effects, most_recent_induction, pass_name);
         break;
       case OptimizationPass::kLoadStoreElimination:
         CHECK(most_recent_side_effects != nullptr && most_recent_induction != nullptr);
         opt = new (allocator) LoadStoreElimination(
-            graph, *most_recent_side_effects, *most_recent_lsa, stats, name);
+            graph, *most_recent_side_effects, *most_recent_lsa, stats, pass_name);
         break;
       //
       // Regular passes.
       //
       case OptimizationPass::kConstantFolding:
-        opt = new (allocator) HConstantFolding(graph, name);
+        opt = new (allocator) HConstantFolding(graph, pass_name);
         break;
       case OptimizationPass::kDeadCodeElimination:
-        opt = new (allocator) HDeadCodeElimination(graph, stats, name);
+        opt = new (allocator) HDeadCodeElimination(graph, stats, pass_name);
         break;
       case OptimizationPass::kInliner: {
         CodeItemDataAccessor accessor(*dex_compilation_unit.GetDexFile(),
@@ -256,33 +260,33 @@
                                        /* total_number_of_instructions */ 0,
                                        /* parent */ nullptr,
                                        /* depth */ 0,
-                                       name);
+                                       pass_name);
         break;
       }
       case OptimizationPass::kSharpening:
-        opt = new (allocator) HSharpening(graph, codegen, driver, name);
+        opt = new (allocator) HSharpening(graph, codegen, driver, pass_name);
         break;
       case OptimizationPass::kSelectGenerator:
-        opt = new (allocator) HSelectGenerator(graph, handles, stats, name);
+        opt = new (allocator) HSelectGenerator(graph, handles, stats, pass_name);
         break;
       case OptimizationPass::kInstructionSimplifier:
-        opt = new (allocator) InstructionSimplifier(graph, codegen, driver, stats, name);
+        opt = new (allocator) InstructionSimplifier(graph, codegen, driver, stats, pass_name);
         break;
       case OptimizationPass::kIntrinsicsRecognizer:
-        opt = new (allocator) IntrinsicsRecognizer(graph, stats, name);
+        opt = new (allocator) IntrinsicsRecognizer(graph, stats, pass_name);
         break;
       case OptimizationPass::kCHAGuardOptimization:
-        opt = new (allocator) CHAGuardOptimization(graph, name);
+        opt = new (allocator) CHAGuardOptimization(graph, pass_name);
         break;
       case OptimizationPass::kCodeSinking:
-        opt = new (allocator) CodeSinking(graph, stats, name);
+        opt = new (allocator) CodeSinking(graph, stats, pass_name);
         break;
       case OptimizationPass::kConstructorFenceRedundancyElimination:
-        opt = new (allocator) ConstructorFenceRedundancyElimination(graph, stats, name);
+        opt = new (allocator) ConstructorFenceRedundancyElimination(graph, stats, pass_name);
         break;
       case OptimizationPass::kScheduling:
         opt = new (allocator) HInstructionScheduling(
-            graph, driver->GetInstructionSet(), codegen, name);
+            graph, driver->GetInstructionSet(), codegen, pass_name);
         break;
       //
       // Arch-specific passes.
@@ -319,11 +323,14 @@
         opt = new (allocator) x86::X86MemoryOperandGeneration(graph, codegen, stats);
         break;
 #endif
+      case OptimizationPass::kNone:
+        LOG(FATAL) << "kNone does not represent an actual pass";
+        UNREACHABLE();
     }  // switch
 
     // Add each next optimization to result vector.
     CHECK(opt != nullptr);
-    DCHECK_STREQ(name, opt->GetPassName());  // sanity
+    DCHECK_STREQ(pass_name, opt->GetPassName());  // sanity
     optimizations.push_back(opt);
   }
 
diff --git a/compiler/optimizing/optimization.h b/compiler/optimizing/optimization.h
index b00d686..88b283c 100644
--- a/compiler/optimizing/optimization.h
+++ b/compiler/optimizing/optimization.h
@@ -102,21 +102,32 @@
 #if defined(ART_ENABLE_CODEGEN_x86) || defined(ART_ENABLE_CODEGEN_x86_64)
   kX86MemoryOperandGeneration,
 #endif
+  kNone,
+  kLast = kNone
 };
 
 // Lookup name of optimization pass.
 const char* OptimizationPassName(OptimizationPass pass);
 
 // Lookup optimization pass by name.
-OptimizationPass OptimizationPassByName(const std::string& name);
+OptimizationPass OptimizationPassByName(const std::string& pass_name);
 
 // Optimization definition consisting of an optimization pass
-// and an optional alternative name (nullptr denotes default).
-typedef std::pair<OptimizationPass, const char*> OptimizationDef;
+// an optional alternative name (nullptr denotes default), and
+// an optional pass dependence (kNone denotes no dependence).
+struct OptimizationDef {
+  OptimizationDef(OptimizationPass p, const char* pn, OptimizationPass d)
+      : pass(p), pass_name(pn), depends_on(d) {}
+  OptimizationPass pass;
+  const char* pass_name;
+  OptimizationPass depends_on;
+};
 
 // Helper method for optimization definition array entries.
-inline OptimizationDef OptDef(OptimizationPass pass, const char* name = nullptr) {
-  return std::make_pair(pass, name);
+inline OptimizationDef OptDef(OptimizationPass pass,
+                              const char* pass_name = nullptr,
+                              OptimizationPass depends_on = OptimizationPass::kNone) {
+  return OptimizationDef(pass, pass_name, depends_on);
 }
 
 // Helper method to construct series of optimization passes.
diff --git a/compiler/optimizing/optimizing_compiler.cc b/compiler/optimizing/optimizing_compiler.cc
index f68bcbe..a6163a7 100644
--- a/compiler/optimizing/optimizing_compiler.cc
+++ b/compiler/optimizing/optimizing_compiler.cc
@@ -313,11 +313,22 @@
         dex_compilation_unit,
         handles);
     DCHECK_EQ(length, optimizations.size());
-    // Run the optimization passes one by one.
+    // Run the optimization passes one by one. Any "depends_on" pass refers back to
+    // the most recent occurrence of that pass, skipped or executed.
+    std::bitset<static_cast<size_t>(OptimizationPass::kLast) + 1u> pass_changes;
+    pass_changes[static_cast<size_t>(OptimizationPass::kNone)] = true;
     bool change = false;
     for (size_t i = 0; i < length; ++i) {
-      PassScope scope(optimizations[i]->GetPassName(), pass_observer);
-      change |= optimizations[i]->Run();
+      if (pass_changes[static_cast<size_t>(definitions[i].depends_on)]) {
+        // Execute the pass and record whether it changed anything.
+        PassScope scope(optimizations[i]->GetPassName(), pass_observer);
+        bool pass_change = optimizations[i]->Run();
+        pass_changes[static_cast<size_t>(definitions[i].pass)] = pass_change;
+        change |= pass_change;
+      } else {
+        // Skip the pass and record that nothing changed.
+        pass_changes[static_cast<size_t>(definitions[i].pass)] = false;
+      }
     }
     return change;
   }
@@ -579,6 +590,7 @@
   if (pass_names != nullptr) {
     // If passes were defined on command-line, build the optimization
     // passes and run these instead of the built-in optimizations.
+    // TODO: a way to define depends_on via command-line?
     const size_t length = pass_names->size();
     std::vector<OptimizationDef> optimizations;
     for (const std::string& pass_name : *pass_names) {
@@ -596,36 +608,63 @@
   }
 
   OptimizationDef optimizations[] = {
+    // Initial optimizations.
     OptDef(OptimizationPass::kIntrinsicsRecognizer),
     OptDef(OptimizationPass::kSharpening),
     OptDef(OptimizationPass::kConstantFolding),
     OptDef(OptimizationPass::kInstructionSimplifier),
-    OptDef(OptimizationPass::kDeadCodeElimination, "dead_code_elimination$initial"),
+    OptDef(OptimizationPass::kDeadCodeElimination,
+           "dead_code_elimination$initial"),
+    // Inlining.
     OptDef(OptimizationPass::kInliner),
-    OptDef(OptimizationPass::kSideEffectsAnalysis,   "side_effects$before_gvn"),
+    // Simplification (only if inlining occurred).
+    OptDef(OptimizationPass::kConstantFolding,
+           "constant_folding$after_inlining",
+           OptimizationPass::kInliner),
+    OptDef(OptimizationPass::kInstructionSimplifier,
+           "instruction_simplifier$after_inlining",
+           OptimizationPass::kInliner),
+    OptDef(OptimizationPass::kDeadCodeElimination,
+           "dead_code_elimination$after_inlining",
+           OptimizationPass::kInliner),
+    // GVN.
+    OptDef(OptimizationPass::kSideEffectsAnalysis,
+           "side_effects$before_gvn"),
     OptDef(OptimizationPass::kGlobalValueNumbering),
+    // Simplification (TODO: only if GVN occurred).
     OptDef(OptimizationPass::kSelectGenerator),
-    OptDef(OptimizationPass::kConstantFolding,       "constant_folding$after_inlining"),
-    OptDef(OptimizationPass::kInstructionSimplifier, "instruction_simplifier$after_inlining"),
-    OptDef(OptimizationPass::kDeadCodeElimination,   "dead_code_elimination$after_inlining"),
-    OptDef(OptimizationPass::kSideEffectsAnalysis,   "side_effects$before_licm"),
+    OptDef(OptimizationPass::kConstantFolding,
+           "constant_folding$after_gvn"),
+    OptDef(OptimizationPass::kInstructionSimplifier,
+           "instruction_simplifier$after_gvn"),
+    OptDef(OptimizationPass::kDeadCodeElimination,
+           "dead_code_elimination$after_gvn"),
+    // High-level optimizations.
+    OptDef(OptimizationPass::kSideEffectsAnalysis,
+           "side_effects$before_licm"),
     OptDef(OptimizationPass::kInvariantCodeMotion),
     OptDef(OptimizationPass::kInductionVarAnalysis),
     OptDef(OptimizationPass::kBoundsCheckElimination),
     OptDef(OptimizationPass::kLoopOptimization),
-    // Evaluates code generated by dynamic bce.
-    OptDef(OptimizationPass::kConstantFolding,       "constant_folding$after_bce"),
-    OptDef(OptimizationPass::kInstructionSimplifier, "instruction_simplifier$after_bce"),
-    OptDef(OptimizationPass::kSideEffectsAnalysis,   "side_effects$before_lse"),
+    // Simplification.
+    OptDef(OptimizationPass::kConstantFolding,
+           "constant_folding$after_bce"),
+    OptDef(OptimizationPass::kInstructionSimplifier,
+           "instruction_simplifier$after_bce"),
+    // Other high-level optimizations.
+    OptDef(OptimizationPass::kSideEffectsAnalysis,
+           "side_effects$before_lse"),
     OptDef(OptimizationPass::kLoadStoreAnalysis),
     OptDef(OptimizationPass::kLoadStoreElimination),
     OptDef(OptimizationPass::kCHAGuardOptimization),
-    OptDef(OptimizationPass::kDeadCodeElimination,   "dead_code_elimination$final"),
+    OptDef(OptimizationPass::kDeadCodeElimination,
+           "dead_code_elimination$final"),
     OptDef(OptimizationPass::kCodeSinking),
     // The codegen has a few assumptions that only the instruction simplifier
     // can satisfy. For example, the code generator does not expect to see a
     // HTypeConversion from a type to the same type.
-    OptDef(OptimizationPass::kInstructionSimplifier, "instruction_simplifier$before_codegen"),
+    OptDef(OptimizationPass::kInstructionSimplifier,
+           "instruction_simplifier$before_codegen"),
     // Eliminate constructor fences after code sinking to avoid
     // complicated sinking logic to split a fence with many inputs.
     OptDef(OptimizationPass::kConstructorFenceRedundancyElimination)
diff --git a/test/442-checker-constant-folding/src/Main.java b/test/442-checker-constant-folding/src/Main.java
index 95c19ea..fcc3c1a 100644
--- a/test/442-checker-constant-folding/src/Main.java
+++ b/test/442-checker-constant-folding/src/Main.java
@@ -991,15 +991,23 @@
   /// CHECK-START: int Main.StaticConditionNulls() constant_folding$after_inlining (before)
   /// CHECK-DAG:     <<Null:l\d+>>    NullConstant
   /// CHECK-DAG:     <<Cond:z\d+>>    NotEqual [<<Null>>,<<Null>>]
-  /// CHECK-DAG:                      Select [{{i\d+}},{{i\d+}},<<Cond>>]
+  /// CHECK-DAG:                      If [<<Cond>>]
 
   /// CHECK-START: int Main.StaticConditionNulls() constant_folding$after_inlining (after)
   /// CHECK-DAG:     <<Const0:i\d+>>  IntConstant 0
-  /// CHECK-DAG:                      Select [{{i\d+}},{{i\d+}},<<Const0>>]
+  /// CHECK-DAG:                      If [<<Const0>>]
 
   /// CHECK-START: int Main.StaticConditionNulls() constant_folding$after_inlining (after)
   /// CHECK-NOT:                      NotEqual
 
+  /// CHECK-START: int Main.StaticConditionNulls() dead_code_elimination$after_inlining (before)
+  /// CHECK-DAG:     <<Phi:i\d+>>     Phi
+  /// CHECK-DAG:                      Return [<<Phi>>]
+  //
+  /// CHECK-START: int Main.StaticConditionNulls() dead_code_elimination$after_inlining (after)
+  /// CHECK-DAG:     <<Const5:i\d+>>  IntConstant 5
+  /// CHECK-DAG:                      Return [<<Const5>>]
+
   private static Object getNull() {
     return null;
   }
diff --git a/test/458-checker-instruct-simplification/src/Main.java b/test/458-checker-instruct-simplification/src/Main.java
index 444b455..b24cfcb 100644
--- a/test/458-checker-instruct-simplification/src/Main.java
+++ b/test/458-checker-instruct-simplification/src/Main.java
@@ -882,7 +882,7 @@
   /// CHECK-NOT:                       Neg
   /// CHECK-NOT:                       Add
 
-  /// CHECK-START: int Main.$noinline$NegNeg2(int) constant_folding$after_inlining (after)
+  /// CHECK-START: int Main.$noinline$NegNeg2(int) constant_folding$after_gvn (after)
   /// CHECK:         <<Const0:i\d+>>   IntConstant 0
   /// CHECK-NOT:                       Neg
   /// CHECK-NOT:                       Add
@@ -1128,17 +1128,19 @@
     return res;
   }
 
-  /// CHECK-START: boolean Main.$noinline$EqualBoolVsIntConst(boolean) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: boolean Main.$noinline$EqualBoolVsIntConst(boolean) dead_code_elimination$after_inlining (before)
   /// CHECK-DAG:     <<Arg:z\d+>>      ParameterValue
   /// CHECK-DAG:     <<Const0:i\d+>>   IntConstant 0
   /// CHECK-DAG:     <<Const1:i\d+>>   IntConstant 1
   /// CHECK-DAG:     <<Const2:i\d+>>   IntConstant 2
-  /// CHECK-DAG:     <<NotArg:i\d+>>   Select [<<Const1>>,<<Const0>>,<<Arg>>]
-  /// CHECK-DAG:     <<Cond:z\d+>>     Equal [<<NotArg>>,<<Const2>>]
-  /// CHECK-DAG:     <<NotCond:i\d+>>  Select [<<Const1>>,<<Const0>>,<<Cond>>]
-  /// CHECK-DAG:                       Return [<<NotCond>>]
+  /// CHECK-DAG:                       If [<<Arg>>]
+  /// CHECK-DAG:     <<Phi1:i\d+>>     Phi [<<Const0>>,<<Const1>>]
+  /// CHECK-DAG:     <<Cond:z\d+>>     Equal [<<Phi1>>,<<Const2>>]
+  /// CHECK-DAG:                       If [<<Cond>>]
+  /// CHECK-DAG:     <<Phi2:i\d+>>     Phi [<<Const1>>,<<Const0>>]
+  /// CHECK-DAG:                       Return [<<Phi2>>]
 
-  /// CHECK-START: boolean Main.$noinline$EqualBoolVsIntConst(boolean) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: boolean Main.$noinline$EqualBoolVsIntConst(boolean) dead_code_elimination$after_inlining (after)
   /// CHECK-DAG:     <<True:i\d+>>     IntConstant 1
   /// CHECK-DAG:                       Return [<<True>>]
 
@@ -1157,12 +1159,14 @@
   /// CHECK-DAG:     <<Const0:i\d+>>   IntConstant 0
   /// CHECK-DAG:     <<Const1:i\d+>>   IntConstant 1
   /// CHECK-DAG:     <<Const2:i\d+>>   IntConstant 2
-  /// CHECK-DAG:     <<NotArg:i\d+>>   Select [<<Const1>>,<<Const0>>,<<Arg>>]
-  /// CHECK-DAG:     <<Cond:z\d+>>     NotEqual [<<NotArg>>,<<Const2>>]
-  /// CHECK-DAG:     <<NotCond:i\d+>>  Select [<<Const1>>,<<Const0>>,<<Cond>>]
-  /// CHECK-DAG:                       Return [<<NotCond>>]
+  /// CHECK-DAG:                       If [<<Arg>>]
+  /// CHECK-DAG:     <<Phi1:i\d+>>     Phi [<<Const0>>,<<Const1>>]
+  /// CHECK-DAG:     <<Cond:z\d+>>     NotEqual [<<Phi1>>,<<Const2>>]
+  /// CHECK-DAG:                       If [<<Cond>>]
+  /// CHECK-DAG:     <<Phi2:i\d+>>     Phi [<<Const1>>,<<Const0>>]
+  /// CHECK-DAG:                       Return [<<Phi2>>]
 
-  /// CHECK-START: boolean Main.$noinline$NotEqualBoolVsIntConst(boolean) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: boolean Main.$noinline$NotEqualBoolVsIntConst(boolean) dead_code_elimination$after_inlining (after)
   /// CHECK-DAG:     <<False:i\d+>>    IntConstant 0
   /// CHECK-DAG:                       Return [<<False>>]
 
@@ -1198,28 +1202,14 @@
 
   /// CHECK-START: boolean Main.$noinline$NotNotBool(boolean) instruction_simplifier$after_inlining (before)
   /// CHECK-DAG:     <<Arg:z\d+>>       ParameterValue
-  /// CHECK-NOT:                        BooleanNot [<<Arg>>]
-  /// CHECK-NOT:                        Phi
-
-  /// CHECK-START: boolean Main.$noinline$NotNotBool(boolean) instruction_simplifier$after_inlining (before)
-  /// CHECK-DAG:     <<Arg:z\d+>>       ParameterValue
   /// CHECK-DAG:     <<Const0:i\d+>>    IntConstant 0
   /// CHECK-DAG:     <<Const1:i\d+>>    IntConstant 1
-  /// CHECK-DAG:     <<Sel:i\d+>>       Select [<<Const1>>,<<Const0>>,<<Arg>>]
-  /// CHECK-DAG:     <<Sel2:i\d+>>      Select [<<Const1>>,<<Const0>>,<<Sel>>]
-  /// CHECK-DAG:                        Return [<<Sel2>>]
+  /// CHECK-DAG:                        If [<<Arg>>]
+  /// CHECK-DAG:     <<Phi:i\d+>>       Phi [<<Const1>>,<<Const0>>]
+  /// CHECK-DAG:                        Return [<<Phi>>]
 
-  /// CHECK-START: boolean Main.$noinline$NotNotBool(boolean) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: boolean Main.$noinline$NotNotBool(boolean) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG:     <<Arg:z\d+>>       ParameterValue
-  /// CHECK:                            BooleanNot [<<Arg>>]
-  /// CHECK-NEXT:                       Goto
-
-  /// CHECK-START: boolean Main.$noinline$NotNotBool(boolean) instruction_simplifier$after_inlining (after)
-  /// CHECK-NOT:                        Select
-
-  /// CHECK-START: boolean Main.$noinline$NotNotBool(boolean) dead_code_elimination$final (after)
-  /// CHECK-DAG:     <<Arg:z\d+>>       ParameterValue
-  /// CHECK-NOT:                        BooleanNot [<<Arg>>]
   /// CHECK-DAG:                        Return [<<Arg>>]
 
   public static boolean NegateValue(boolean arg) {
@@ -1348,10 +1338,11 @@
   /// CHECK-DAG:      <<Const54:i\d+>>  IntConstant 54
   /// CHECK-DAG:      <<Field:z\d+>>    StaticFieldGet
   /// CHECK-DAG:      <<NE:z\d+>>       NotEqual [<<Field>>,<<Const1>>]
-  /// CHECK-DAG:      <<Select:i\d+>>   Select [<<Const13>>,<<Const54>>,<<NE>>]
-  /// CHECK-DAG:                        Return [<<Select>>]
+  /// CHECK-DAG:                        If [<<NE>>]
+  /// CHECK-DAG:      <<Phi:i\d+>>      Phi [<<Const13>>,<<Const54>>]
+  /// CHECK-DAG:                        Return [<<Phi>>]
 
-  /// CHECK-START: int Main.$noinline$booleanFieldNotEqualOne() instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.$noinline$booleanFieldNotEqualOne() select_generator (after)
   /// CHECK-DAG:      <<Field:z\d+>>    StaticFieldGet
   /// CHECK-DAG:      <<Const13:i\d+>>  IntConstant 13
   /// CHECK-DAG:      <<Const54:i\d+>>  IntConstant 54
@@ -1367,11 +1358,12 @@
   /// CHECK-DAG:      <<Const13:i\d+>>  IntConstant 13
   /// CHECK-DAG:      <<Const54:i\d+>>  IntConstant 54
   /// CHECK-DAG:      <<Field:z\d+>>    StaticFieldGet
-  /// CHECK-DAG:      <<NE:z\d+>>       Equal [<<Field>>,<<Const0>>]
-  /// CHECK-DAG:      <<Select:i\d+>>   Select [<<Const13>>,<<Const54>>,<<NE>>]
-  /// CHECK-DAG:                        Return [<<Select>>]
+  /// CHECK-DAG:      <<EQ:z\d+>>       Equal [<<Field>>,<<Const0>>]
+  /// CHECK-DAG:                        If [<<EQ>>]
+  /// CHECK-DAG:      <<Phi:i\d+>>      Phi [<<Const13>>,<<Const54>>]
+  /// CHECK-DAG:                        Return [<<Phi>>]
 
-  /// CHECK-START: int Main.$noinline$booleanFieldEqualZero() instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.$noinline$booleanFieldEqualZero() select_generator (after)
   /// CHECK-DAG:      <<Field:z\d+>>    StaticFieldGet
   /// CHECK-DAG:      <<Const13:i\d+>>  IntConstant 13
   /// CHECK-DAG:      <<Const54:i\d+>>  IntConstant 54
@@ -1390,18 +1382,20 @@
   /// CHECK-DAG:      <<Const42:i\d+>>  IntConstant 42
   /// CHECK-DAG:      <<Const54:i\d+>>  IntConstant 54
   /// CHECK-DAG:      <<LE:z\d+>>       LessThanOrEqual [<<Arg>>,<<Const42>>]
-  /// CHECK-DAG:      <<GT:i\d+>>       Select [<<Const1>>,<<Const0>>,<<LE>>]
-  /// CHECK-DAG:      <<NE:z\d+>>       NotEqual [<<GT>>,<<Const1>>]
-  /// CHECK-DAG:      <<Result:i\d+>>   Select [<<Const13>>,<<Const54>>,<<NE>>]
-  /// CHECK-DAG:                        Return [<<Result>>]
+  /// CHECK-DAG:                        If [<<LE>>]
+  /// CHECK-DAG:      <<Phi1:i\d+>>     Phi [<<Const1>>,<<Const0>>]
+  /// CHECK-DAG:      <<NE:z\d+>>       NotEqual [<<Phi1>>,<<Const1>>]
+  /// CHECK-DAG:                        If [<<NE>>]
+  /// CHECK-DAG:      <<Phi2:i\d+>>     Phi [<<Const13>>,<<Const54>>]
+  /// CHECK-DAG:                        Return [<<Phi2>>]
 
-  /// CHECK-START: int Main.$noinline$intConditionNotEqualOne(int) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.$noinline$intConditionNotEqualOne(int) select_generator (after)
   /// CHECK-DAG:      <<Arg:i\d+>>      ParameterValue
   /// CHECK-DAG:      <<Const13:i\d+>>  IntConstant 13
   /// CHECK-DAG:      <<Const42:i\d+>>  IntConstant 42
   /// CHECK-DAG:      <<Const54:i\d+>>  IntConstant 54
-  /// CHECK-DAG:      <<Result:i\d+>>   Select [<<Const13>>,<<Const54>>,<<LE:z\d+>>]
-  /// CHECK-DAG:      <<LE>>            LessThanOrEqual [<<Arg>>,<<Const42>>]
+  /// CHECK-DAG:      <<LE:z\d+>>       LessThanOrEqual [<<Arg>>,<<Const42>>]
+  /// CHECK-DAG:      <<Result:i\d+>>   Select [<<Const13>>,<<Const54>>,<<LE>>]
   /// CHECK-DAG:                        Return [<<Result>>]
   // Note that we match `LE` from Select because there are two identical
   // LessThanOrEqual instructions.
@@ -1418,18 +1412,20 @@
   /// CHECK-DAG:      <<Const42:i\d+>>  IntConstant 42
   /// CHECK-DAG:      <<Const54:i\d+>>  IntConstant 54
   /// CHECK-DAG:      <<LE:z\d+>>       LessThanOrEqual [<<Arg>>,<<Const42>>]
-  /// CHECK-DAG:      <<GT:i\d+>>       Select [<<Const1>>,<<Const0>>,<<LE>>]
-  /// CHECK-DAG:      <<NE:z\d+>>       Equal [<<GT>>,<<Const0>>]
-  /// CHECK-DAG:      <<Result:i\d+>>   Select [<<Const13>>,<<Const54>>,<<NE>>]
-  /// CHECK-DAG:                        Return [<<Result>>]
+  /// CHECK-DAG:                        If [<<LE>>]
+  /// CHECK-DAG:      <<Phi1:i\d+>>     Phi [<<Const1>>,<<Const0>>]
+  /// CHECK-DAG:      <<EQ:z\d+>>       Equal [<<Phi1>>,<<Const0>>]
+  /// CHECK-DAG:                        If [<<EQ>>]
+  /// CHECK-DAG:      <<Phi2:i\d+>>     Phi [<<Const13>>,<<Const54>>]
+  /// CHECK-DAG:                        Return [<<Phi2>>]
 
-  /// CHECK-START: int Main.$noinline$intConditionEqualZero(int) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.$noinline$intConditionEqualZero(int) select_generator (after)
   /// CHECK-DAG:      <<Arg:i\d+>>      ParameterValue
   /// CHECK-DAG:      <<Const13:i\d+>>  IntConstant 13
   /// CHECK-DAG:      <<Const42:i\d+>>  IntConstant 42
   /// CHECK-DAG:      <<Const54:i\d+>>  IntConstant 54
-  /// CHECK-DAG:      <<Result:i\d+>>   Select [<<Const13>>,<<Const54>>,<<LE:z\d+>>]
-  /// CHECK-DAG:      <<LE>>            LessThanOrEqual [<<Arg>>,<<Const42>>]
+  /// CHECK-DAG:      <<LE:z\d+>>       LessThanOrEqual [<<Arg>>,<<Const42>>]
+  /// CHECK-DAG:      <<Result:i\d+>>   Select [<<Const13>>,<<Const54>>,<<LE>>]
   /// CHECK-DAG:                        Return [<<Result>>]
   // Note that we match `LE` from Select because there are two identical
   // LessThanOrEqual instructions.
@@ -2571,12 +2567,13 @@
   /// CHECK-DAG:      <<Const0:i\d+>>   IntConstant 0
   /// CHECK-DAG:      <<Const1:i\d+>>   IntConstant 1
   /// CHECK-DAG:      <<Const255:i\d+>> IntConstant 255
-  /// CHECK-DAG:      <<Select:i\d+>>   Select [<<Const0>>,<<Const1>>,<<Arg>>]
-  /// CHECK-DAG:      <<And:i\d+>>      And [<<Select>>,<<Const255>>]
+  /// CHECK-DAG:                        If [<<Arg>>]
+  /// CHECK-DAG:      <<Phi:i\d+>>      Phi [<<Const1>>,<<Const0>>]
+  /// CHECK-DAG:      <<And:i\d+>>      And [<<Const255>>,<<Phi>>]
   /// CHECK-DAG:      <<Conv:b\d+>>     TypeConversion [<<And>>]
   /// CHECK-DAG:                        Return [<<Conv>>]
 
-  /// CHECK-START: int Main.$noinline$bug68142795Boolean(boolean) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.$noinline$bug68142795Boolean(boolean) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG:      <<Arg:z\d+>>      ParameterValue
   /// CHECK-DAG:                        Return [<<Arg>>]
   public static int $noinline$bug68142795Boolean(boolean b) {
diff --git a/test/485-checker-dce-loop-update/smali/TestCase.smali b/test/485-checker-dce-loop-update/smali/TestCase.smali
index cda6f73..5290bad 100644
--- a/test/485-checker-dce-loop-update/smali/TestCase.smali
+++ b/test/485-checker-dce-loop-update/smali/TestCase.smali
@@ -140,11 +140,11 @@
 ## CHECK-DAG:     <<PhiX:i\d+>>  Phi [<<ArgX>>,<<Add5:i\d+>>,<<Add7:i\d+>>] loop:<<HeaderY:B\d+>>
 ## CHECK-DAG:                    If [<<ArgY>>]                              loop:<<HeaderY>>
 ## CHECK-DAG:     <<Mul9:i\d+>>  Mul [<<PhiX>>,<<Cst11>>]                   loop:<<HeaderY>>
-## CHECK-DAG:     <<SelX:i\d+>>  Select [<<PhiX>>,<<Mul9>>,<<ArgZ>>]        loop:<<HeaderY>>
+## CHECK-DAG:     <<PhiY:i\d+>>  Phi [<<PhiX>>,<<Mul9>>]                    loop:<<HeaderY>>
 ## CHECK-DAG:                    If [<<Cst1>>]                              loop:<<HeaderY>>
-## CHECK-DAG:     <<Add5>>       Add [<<SelX>>,<<Cst5>>]                    loop:<<HeaderY>>
+## CHECK-DAG:     <<Add5>>       Add [<<PhiY>>,<<Cst5>>]                    loop:<<HeaderY>>
 ## CHECK-DAG:     <<Add7>>       Add [<<PhiX>>,<<Cst7>>]                    loop:<<HeaderY>>
-## CHECK-DAG:                    Return [<<SelX>>]                          loop:none
+## CHECK-DAG:                    Return [<<PhiY>>]                          loop:none
 
 ## CHECK-START: int TestCase.testExitPredecessors(int, boolean, boolean) dead_code_elimination$after_inlining (after)
 ## CHECK-DAG:     <<ArgX:i\d+>>  ParameterValue
@@ -156,6 +156,22 @@
 ## CHECK-DAG:                    If [<<ArgY>>]                              loop:<<HeaderY>>
 ## CHECK-DAG:     <<Add7>>       Add [<<PhiX>>,<<Cst7>>]                    loop:<<HeaderY>>
 ## CHECK-DAG:     <<Mul9:i\d+>>  Mul [<<PhiX>>,<<Cst11>>]                   loop:none
+## CHECK-DAG:     <<Phi:i\d+>>   Phi [<<PhiX>>,<<Mul9>>]                    loop:none
+## CHECK-DAG:                    Return [<<Phi>>]                           loop:none
+
+## CHECK-START: int TestCase.testExitPredecessors(int, boolean, boolean) dead_code_elimination$after_inlining (after)
+## CHECK-NOT:                    IntConstant 5
+
+## CHECK-START: int TestCase.testExitPredecessors(int, boolean, boolean) select_generator (after)
+## CHECK-DAG:     <<ArgX:i\d+>>  ParameterValue
+## CHECK-DAG:     <<ArgY:z\d+>>  ParameterValue
+## CHECK-DAG:     <<ArgZ:z\d+>>  ParameterValue
+## CHECK-DAG:     <<Cst7:i\d+>>  IntConstant 7
+## CHECK-DAG:     <<Cst11:i\d+>> IntConstant 11
+## CHECK-DAG:     <<PhiX:i\d+>>  Phi [<<ArgX>>,<<Add7:i\d+>>]               loop:<<HeaderY:B\d+>>
+## CHECK-DAG:                    If [<<ArgY>>]                              loop:<<HeaderY>>
+## CHECK-DAG:     <<Add7>>       Add [<<PhiX>>,<<Cst7>>]                    loop:<<HeaderY>>
+## CHECK-DAG:     <<Mul9:i\d+>>  Mul [<<PhiX>>,<<Cst11>>]                   loop:none
 ## CHECK-DAG:     <<SelX:i\d+>>  Select [<<PhiX>>,<<Mul9>>,<<ArgZ>>]        loop:none
 ## CHECK-DAG:                    Return [<<SelX>>]                          loop:none
 
diff --git a/test/543-checker-dce-trycatch/smali/TestCase.smali b/test/543-checker-dce-trycatch/smali/TestCase.smali
index f50e01e..7ad9ba8 100644
--- a/test/543-checker-dce-trycatch/smali/TestCase.smali
+++ b/test/543-checker-dce-trycatch/smali/TestCase.smali
@@ -215,10 +215,10 @@
 ## CHECK-DAG:     <<Const0x10:i\d+>> IntConstant 16
 ## CHECK-DAG:     <<Const0x11:i\d+>> IntConstant 17
 ## CHECK-DAG:     <<Add:i\d+>>       Add [<<Arg0>>,<<Arg1>>]
-## CHECK-DAG:     <<Select:i\d+>>    Select [<<Const0xf>>,<<Add>>,{{z\d+}}]
+## CHECK-DAG:     <<Phi:i\d+>>       Phi [<<Add>>,<<Const0xf>>] reg:3 is_catch_phi:false
 ## CHECK-DAG:                        Phi [<<Const0xa>>,<<Const0xb>>,<<Const0xd>>] reg:1 is_catch_phi:true
 ## CHECK-DAG:                        Phi [<<Add>>,<<Const0xc>>,<<Const0xe>>] reg:2 is_catch_phi:true
-## CHECK-DAG:                        Phi [<<Select>>,<<Const0x10>>,<<Const0x11>>] reg:3 is_catch_phi:true
+## CHECK-DAG:                        Phi [<<Phi>>,<<Const0x10>>,<<Const0x11>>] reg:3 is_catch_phi:true
 
 ## CHECK-START: int TestCase.testCatchPhiInputs_DefinedInTryBlock(int, int, int, int) dead_code_elimination$after_inlining (after)
 ## CHECK-DAG:     <<Const0xb:i\d+>>  IntConstant 11
diff --git a/test/551-checker-shifter-operand/src/Main.java b/test/551-checker-shifter-operand/src/Main.java
index fb76904..b3e4a60 100644
--- a/test/551-checker-shifter-operand/src/Main.java
+++ b/test/551-checker-shifter-operand/src/Main.java
@@ -728,9 +728,41 @@
   /// CHECK:                            UShr
   /// CHECK-NOT:                        UShr
   //
-  // Note: running extra simplification before GVN would expose the common subexpressions between
-  // shifts with larger distance `b << 62`, `b << 63` etc. and the equivalent smaller distances.
-  // TODO: b/78171933
+  // Note: running extra simplification after inlining and before GVN exposes the common
+  // subexpressions between shifts with larger distance `b << 62`, `b << 63` etc.
+  // and the equivalent smaller distances.
+  //
+  /// CHECK-START: void Main.$opt$validateShiftInt(int, int) GVN (after)
+  /// CHECK:                            Shl
+  /// CHECK:                            Shl
+  /// CHECK:                            Shl
+  /// CHECK:                            Shl
+  /// CHECK:                            Shl
+  /// CHECK:                            Shl
+  /// CHECK:                            Shl
+  /// CHECK:                            Shl
+  /// CHECK:                            Shl
+  /// CHECK-NOT:                        Shl
+  /// CHECK:                            Shr
+  /// CHECK:                            Shr
+  /// CHECK:                            Shr
+  /// CHECK:                            Shr
+  /// CHECK:                            Shr
+  /// CHECK:                            Shr
+  /// CHECK:                            Shr
+  /// CHECK:                            Shr
+  /// CHECK:                            Shr
+  /// CHECK-NOT:                        Shl
+  /// CHECK:                            UShr
+  /// CHECK:                            UShr
+  /// CHECK:                            UShr
+  /// CHECK:                            UShr
+  /// CHECK:                            UShr
+  /// CHECK:                            UShr
+  /// CHECK:                            UShr
+  /// CHECK:                            UShr
+  /// CHECK:                            UShr
+  /// CHECK-NOT:                        UShr
   //
   /// CHECK-START-ARM: void Main.$opt$validateShiftInt(int, int) instruction_simplifier_arm (after)
   /// CHECK:                            DataProcWithShifterOp
@@ -760,12 +792,6 @@
   /// CHECK:                            DataProcWithShifterOp
   /// CHECK:                            DataProcWithShifterOp
   /// CHECK:                            DataProcWithShifterOp
-  /// CHECK:                            DataProcWithShifterOp
-  /// CHECK:                            DataProcWithShifterOp
-  /// CHECK:                            DataProcWithShifterOp
-  /// CHECK:                            DataProcWithShifterOp
-  /// CHECK:                            DataProcWithShifterOp
-  /// CHECK:                            DataProcWithShifterOp
   /// CHECK-NOT:                        DataProcWithShifterOp
 
   /// CHECK-START-ARM: void Main.$opt$validateShiftInt(int, int) instruction_simplifier_arm (after)
@@ -801,12 +827,6 @@
   /// CHECK:                            DataProcWithShifterOp
   /// CHECK:                            DataProcWithShifterOp
   /// CHECK:                            DataProcWithShifterOp
-  /// CHECK:                            DataProcWithShifterOp
-  /// CHECK:                            DataProcWithShifterOp
-  /// CHECK:                            DataProcWithShifterOp
-  /// CHECK:                            DataProcWithShifterOp
-  /// CHECK:                            DataProcWithShifterOp
-  /// CHECK:                            DataProcWithShifterOp
   /// CHECK-NOT:                        DataProcWithShifterOp
 
   /// CHECK-START-ARM64: void Main.$opt$validateShiftInt(int, int) instruction_simplifier_arm64 (after)
diff --git a/test/565-checker-doublenegbitwise/src/Main.java b/test/565-checker-doublenegbitwise/src/Main.java
index 80358cd..e36a2ba 100644
--- a/test/565-checker-doublenegbitwise/src/Main.java
+++ b/test/565-checker-doublenegbitwise/src/Main.java
@@ -94,7 +94,7 @@
    * same pass.
    */
 
-  /// CHECK-START: boolean Main.$opt$noinline$booleanAndToOr(boolean, boolean) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: boolean Main.$opt$noinline$booleanAndToOr(boolean, boolean) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG:       <<P1:z\d+>>          ParameterValue
   /// CHECK-DAG:       <<P2:z\d+>>          ParameterValue
   /// CHECK-DAG:       <<Const0:i\d+>>      IntConstant 0
@@ -104,7 +104,7 @@
   /// CHECK-DAG:       <<And:i\d+>>         And [<<Select1>>,<<Select2>>]
   /// CHECK-DAG:                            Return [<<And>>]
 
-  /// CHECK-START: boolean Main.$opt$noinline$booleanAndToOr(boolean, boolean) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: boolean Main.$opt$noinline$booleanAndToOr(boolean, boolean) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG:       <<Cond1:z\d+>>       ParameterValue
   /// CHECK-DAG:       <<Cond2:z\d+>>       ParameterValue
   /// CHECK-DAG:       <<Or:i\d+>>          Or [<<Cond1>>,<<Cond2>>]
@@ -165,7 +165,7 @@
    * same pass.
    */
 
-  /// CHECK-START: boolean Main.$opt$noinline$booleanOrToAnd(boolean, boolean) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: boolean Main.$opt$noinline$booleanOrToAnd(boolean, boolean) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG:       <<P1:z\d+>>          ParameterValue
   /// CHECK-DAG:       <<P2:z\d+>>          ParameterValue
   /// CHECK-DAG:       <<Const0:i\d+>>      IntConstant 0
@@ -175,7 +175,7 @@
   /// CHECK-DAG:       <<Or:i\d+>>          Or [<<Select1>>,<<Select2>>]
   /// CHECK-DAG:                            Return [<<Or>>]
 
-  /// CHECK-START: boolean Main.$opt$noinline$booleanOrToAnd(boolean, boolean) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: boolean Main.$opt$noinline$booleanOrToAnd(boolean, boolean) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG:       <<Cond1:z\d+>>       ParameterValue
   /// CHECK-DAG:       <<Cond2:z\d+>>       ParameterValue
   /// CHECK-DAG:       <<And:i\d+>>         And [<<Cond1>>,<<Cond2>>]
@@ -275,7 +275,7 @@
    * same pass.
    */
 
-  /// CHECK-START: boolean Main.$opt$noinline$booleanNotXorToXor(boolean, boolean) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: boolean Main.$opt$noinline$booleanNotXorToXor(boolean, boolean) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG:       <<P1:z\d+>>          ParameterValue
   /// CHECK-DAG:       <<P2:z\d+>>          ParameterValue
   /// CHECK-DAG:       <<Const0:i\d+>>      IntConstant 0
@@ -285,7 +285,7 @@
   /// CHECK-DAG:       <<Xor:i\d+>>         Xor [<<Select1>>,<<Select2>>]
   /// CHECK-DAG:                            Return [<<Xor>>]
 
-  /// CHECK-START: boolean Main.$opt$noinline$booleanNotXorToXor(boolean, boolean) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: boolean Main.$opt$noinline$booleanNotXorToXor(boolean, boolean) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG:       <<Cond1:z\d+>>       ParameterValue
   /// CHECK-DAG:       <<Cond2:z\d+>>       ParameterValue
   /// CHECK-DAG:       <<Xor:i\d+>>         Xor [<<Cond1>>,<<Cond2>>]
diff --git a/test/593-checker-boolean-2-integral-conv/smali/SmaliTests.smali b/test/593-checker-boolean-2-integral-conv/smali/SmaliTests.smali
index 494ab95..f74e88f 100644
--- a/test/593-checker-boolean-2-integral-conv/smali/SmaliTests.smali
+++ b/test/593-checker-boolean-2-integral-conv/smali/SmaliTests.smali
@@ -233,9 +233,7 @@
 ## CHECK-DAG:     <<One:i\d+>>           IntConstant 1
 ## CHECK-DAG:     <<Sget:z\d+>>          StaticFieldGet
 ## CHECK-DAG:     <<Sel:i\d+>>           Select [<<Zero>>,<<One>>,<<Sget>>]
-## CHECK-DAG:     <<IToJ:j\d+>>          TypeConversion [<<Sel>>]
-## CHECK-DAG:     <<JToI:i\d+>>          TypeConversion [<<IToJ>>]
-## CHECK-DAG:                            Return [<<JToI>>]
+## CHECK-DAG:                            Return [<<Sel>>]
 
 ## CHECK-START: int SmaliTests.longToIntOfBoolean() instruction_simplifier$after_bce (after)
 ## CHECK-DAG:     <<Method:[ij]\d+>>     CurrentMethod
diff --git a/test/631-checker-get-class/src/Main.java b/test/631-checker-get-class/src/Main.java
index 61c0adf..b318168 100644
--- a/test/631-checker-get-class/src/Main.java
+++ b/test/631-checker-get-class/src/Main.java
@@ -34,11 +34,14 @@
   }
 
   /// CHECK-START: boolean Main.classEquality1() instruction_simplifier$after_inlining (before)
+  /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+  /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
   /// CHECK-DAG: <<Eq:z\d+>>     {{Equal|NotEqual}}
-  /// CHECK-DAG: <<Select:i\d+>> Select [{{i\d+}},{{i\d+}},<<Eq>>]
-  /// CHECK-DAG:                 Return [<<Select>>]
+  /// CHECK-DAG:                 If [<<Eq>>]
+  /// CHECK-DAG: <<Phi:i\d+>>    Phi [<<Const1>>,<<Const0>>]
+  /// CHECK-DAG:                 Return [<<Phi>>]
 
-  /// CHECK-START: boolean Main.classEquality1() instruction_simplifier$after_inlining (after)
+  /// CHECK-START: boolean Main.classEquality1() dead_code_elimination$after_inlining (after)
   /// CHECK-DAG: <<Constant:i\d+>> IntConstant 1
   /// CHECK-DAG:                   Return [<<Constant>>]
   public static boolean classEquality1() {
@@ -46,11 +49,14 @@
   }
 
   /// CHECK-START: boolean Main.classEquality2() instruction_simplifier$after_inlining (before)
+  /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+  /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
   /// CHECK-DAG: <<Eq:z\d+>>     {{Equal|NotEqual}}
-  /// CHECK-DAG: <<Select:i\d+>> Select [{{i\d+}},{{i\d+}},<<Eq>>]
-  /// CHECK-DAG:                 Return [<<Select>>]
+  /// CHECK-DAG:                 If [<<Eq>>]
+  /// CHECK-DAG: <<Phi:i\d+>>    Phi [<<Const1>>,<<Const0>>]
+  /// CHECK-DAG:                 Return [<<Phi>>]
 
-  /// CHECK-START: boolean Main.classEquality2() instruction_simplifier$after_inlining (after)
+  /// CHECK-START: boolean Main.classEquality2() dead_code_elimination$after_inlining (after)
   /// CHECK-DAG: <<Constant:i\d+>> IntConstant 0
   /// CHECK-DAG:                   Return [<<Constant>>]
   public static boolean classEquality2() {
@@ -59,11 +65,14 @@
   }
 
   /// CHECK-START: boolean Main.classEquality3() instruction_simplifier$after_inlining (before)
+  /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+  /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
   /// CHECK-DAG: <<Eq:z\d+>>     {{Equal|NotEqual}}
-  /// CHECK-DAG: <<Select:i\d+>> Select [{{i\d+}},{{i\d+}},<<Eq>>]
-  /// CHECK-DAG:                 Return [<<Select>>]
+  /// CHECK-DAG:                 If [<<Eq>>]
+  /// CHECK-DAG: <<Phi:i\d+>>    Phi [<<Const1>>,<<Const0>>]
+  /// CHECK-DAG:                 Return [<<Phi>>]
 
-  /// CHECK-START: boolean Main.classEquality3() instruction_simplifier$after_inlining (after)
+  /// CHECK-START: boolean Main.classEquality3() dead_code_elimination$after_inlining (after)
   /// CHECK-DAG: <<Constant:i\d+>> IntConstant 0
   /// CHECK-DAG:                   Return [<<Constant>>]
   public static boolean classEquality3() {
@@ -71,11 +80,14 @@
   }
 
   /// CHECK-START: boolean Main.classEquality4() instruction_simplifier$after_inlining (before)
+  /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
+  /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
   /// CHECK-DAG: <<Eq:z\d+>>     {{Equal|NotEqual}}
-  /// CHECK-DAG: <<Select:i\d+>> Select [{{i\d+}},{{i\d+}},<<Eq>>]
-  /// CHECK-DAG:                 Return [<<Select>>]
+  /// CHECK-DAG:                 If [<<Eq>>]
+  /// CHECK-DAG: <<Phi:i\d+>>    Phi [<<Const1>>,<<Const0>>]
+  /// CHECK-DAG:                 Return [<<Phi>>]
 
-  /// CHECK-START: boolean Main.classEquality4() instruction_simplifier$after_inlining (after)
+  /// CHECK-START: boolean Main.classEquality4() dead_code_elimination$after_inlining (after)
   /// CHECK-DAG: <<Constant:i\d+>> IntConstant 1
   /// CHECK-DAG:                   Return [<<Constant>>]
   public static boolean classEquality4() {
diff --git a/test/660-checker-sad-byte/src/Main.java b/test/660-checker-sad-byte/src/Main.java
index cd7fbcb..bcd62c4 100644
--- a/test/660-checker-sad-byte/src/Main.java
+++ b/test/660-checker-sad-byte/src/Main.java
@@ -19,22 +19,22 @@
  */
 public class Main {
 
-  /// CHECK-START: int Main.sad1(byte, byte) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: int Main.sad1(byte, byte) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Select:i\d+>> Select
   /// CHECK-DAG:                 Return [<<Select>>]
   //
-  /// CHECK-START: int Main.sad1(byte, byte) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.sad1(byte, byte) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Intrin:i\d+>> Abs
   /// CHECK-DAG:                 Return [<<Intrin>>]
   static int sad1(byte x, byte y) {
     return x >= y ? x - y : y - x;
   }
 
-  /// CHECK-START: int Main.sad2(byte, byte) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: int Main.sad2(byte, byte) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Select:i\d+>> Select
   /// CHECK-DAG:                 Return [<<Select>>]
   //
-  /// CHECK-START: int Main.sad2(byte, byte) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.sad2(byte, byte) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Intrin:i\d+>> Abs
   /// CHECK-DAG:                 Return [<<Intrin>>]
   static int sad2(byte x, byte y) {
@@ -43,11 +43,11 @@
     return diff;
   }
 
-  /// CHECK-START: int Main.sad3(byte, byte) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: int Main.sad3(byte, byte) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Select:i\d+>> Select
   /// CHECK-DAG:                 Return [<<Select>>]
   //
-  /// CHECK-START: int Main.sad3(byte, byte) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.sad3(byte, byte) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Intrin:i\d+>> Abs
   /// CHECK-DAG:                 Return [<<Intrin>>]
   static int sad3(byte x, byte y) {
@@ -55,11 +55,11 @@
     return diff >= 0 ? diff : -diff;
   }
 
-  /// CHECK-START: int Main.sad3Alt(byte, byte) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: int Main.sad3Alt(byte, byte) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Select:i\d+>> Select
   /// CHECK-DAG:                 Return [<<Select>>]
   //
-  /// CHECK-START: int Main.sad3Alt(byte, byte) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.sad3Alt(byte, byte) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Intrin:i\d+>> Abs
   /// CHECK-DAG:                 Return [<<Intrin>>]
   static int sad3Alt(byte x, byte y) {
@@ -67,11 +67,11 @@
     return 0 <= diff ? diff : -diff;
   }
 
-  /// CHECK-START: long Main.sadL1(byte, byte) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: long Main.sadL1(byte, byte) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Select:j\d+>> Select
   /// CHECK-DAG:                 Return [<<Select>>]
   //
-  /// CHECK-START: long Main.sadL1(byte, byte) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: long Main.sadL1(byte, byte) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Intrin:j\d+>> Abs
   /// CHECK-DAG:                 Return [<<Intrin>>]
   static long sadL1(byte x, byte y) {
@@ -80,11 +80,11 @@
     return xl >= yl ? xl - yl : yl - xl;
   }
 
-  /// CHECK-START: long Main.sadL2(byte, byte) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: long Main.sadL2(byte, byte) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Select:j\d+>> Select
   /// CHECK-DAG:                 Return [<<Select>>]
   //
-  /// CHECK-START: long Main.sadL2(byte, byte) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: long Main.sadL2(byte, byte) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Intrin:j\d+>> Abs
   /// CHECK-DAG:                 Return [<<Intrin>>]
   static long sadL2(byte x, byte y) {
@@ -93,11 +93,11 @@
     return diff;
   }
 
-  /// CHECK-START: long Main.sadL3(byte, byte) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: long Main.sadL3(byte, byte) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Select:j\d+>> Select
   /// CHECK-DAG:                 Return [<<Select>>]
   //
-  /// CHECK-START: long Main.sadL3(byte, byte) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: long Main.sadL3(byte, byte) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Intrin:j\d+>> Abs
   /// CHECK-DAG:                 Return [<<Intrin>>]
   static long sadL3(byte x, byte y) {
@@ -105,11 +105,11 @@
     return diff >= 0L ? diff : -diff;
   }
 
-  /// CHECK-START: long Main.sadL3Alt(byte, byte) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: long Main.sadL3Alt(byte, byte) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Select:j\d+>> Select
   /// CHECK-DAG:                 Return [<<Select>>]
   //
-  /// CHECK-START: long Main.sadL3Alt(byte, byte) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: long Main.sadL3Alt(byte, byte) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Intrin:j\d+>> Abs
   /// CHECK-DAG:                 Return [<<Intrin>>]
   static long sadL3Alt(byte x, byte y) {
diff --git a/test/660-checker-sad-char/src/Main.java b/test/660-checker-sad-char/src/Main.java
index ecf748a..998ec33 100644
--- a/test/660-checker-sad-char/src/Main.java
+++ b/test/660-checker-sad-char/src/Main.java
@@ -19,22 +19,22 @@
  */
 public class Main {
 
-  /// CHECK-START: int Main.sad1(char, char) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: int Main.sad1(char, char) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Select:i\d+>> Select
   /// CHECK-DAG:                 Return [<<Select>>]
   //
-  /// CHECK-START: int Main.sad1(char, char) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.sad1(char, char) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Intrin:i\d+>> Abs
   /// CHECK-DAG:                 Return [<<Intrin>>]
   static int sad1(char x, char y) {
     return x >= y ? x - y : y - x;
   }
 
-  /// CHECK-START: int Main.sad2(char, char) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: int Main.sad2(char, char) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Select:i\d+>> Select
   /// CHECK-DAG:                 Return [<<Select>>]
   //
-  /// CHECK-START: int Main.sad2(char, char) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.sad2(char, char) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Intrin:i\d+>> Abs
   /// CHECK-DAG:                 Return [<<Intrin>>]
   static int sad2(char x, char y) {
@@ -43,11 +43,11 @@
     return diff;
   }
 
-  /// CHECK-START: int Main.sad3(char, char) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: int Main.sad3(char, char) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Select:i\d+>> Select
   /// CHECK-DAG:                 Return [<<Select>>]
   //
-  /// CHECK-START: int Main.sad3(char, char) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.sad3(char, char) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Intrin:i\d+>> Abs
   /// CHECK-DAG:                 Return [<<Intrin>>]
   static int sad3(char x, char y) {
@@ -55,11 +55,11 @@
     return diff >= 0 ? diff : -diff;
   }
 
-  /// CHECK-START: int Main.sad3Alt(char, char) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: int Main.sad3Alt(char, char) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Select:i\d+>> Select
   /// CHECK-DAG:                 Return [<<Select>>]
   //
-  /// CHECK-START: int Main.sad3Alt(char, char) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.sad3Alt(char, char) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Intrin:i\d+>> Abs
   /// CHECK-DAG:                 Return [<<Intrin>>]
   static int sad3Alt(char x, char y) {
@@ -67,11 +67,11 @@
     return 0 <= diff ? diff : -diff;
   }
 
-  /// CHECK-START: long Main.sadL1(char, char) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: long Main.sadL1(char, char) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Select:j\d+>> Select
   /// CHECK-DAG:                 Return [<<Select>>]
   //
-  /// CHECK-START: long Main.sadL1(char, char) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: long Main.sadL1(char, char) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Intrin:j\d+>> Abs
   /// CHECK-DAG:                 Return [<<Intrin>>]
   static long sadL1(char x, char y) {
@@ -80,11 +80,11 @@
     return xl >= yl ? xl - yl : yl - xl;
   }
 
-  /// CHECK-START: long Main.sadL2(char, char) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: long Main.sadL2(char, char) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Select:j\d+>> Select
   /// CHECK-DAG:                 Return [<<Select>>]
   //
-  /// CHECK-START: long Main.sadL2(char, char) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: long Main.sadL2(char, char) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Intrin:j\d+>> Abs
   /// CHECK-DAG:                 Return [<<Intrin>>]
   static long sadL2(char x, char y) {
@@ -93,11 +93,11 @@
     return diff;
   }
 
-  /// CHECK-START: long Main.sadL3(char, char) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: long Main.sadL3(char, char) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Select:j\d+>> Select
   /// CHECK-DAG:                 Return [<<Select>>]
   //
-  /// CHECK-START: long Main.sadL3(char, char) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: long Main.sadL3(char, char) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Intrin:j\d+>> Abs
   /// CHECK-DAG:                 Return [<<Intrin>>]
   static long sadL3(char x, char y) {
@@ -105,11 +105,11 @@
     return diff >= 0L ? diff : -diff;
   }
 
-  /// CHECK-START: long Main.sadL3Alt(char, char) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: long Main.sadL3Alt(char, char) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Select:j\d+>> Select
   /// CHECK-DAG:                 Return [<<Select>>]
   //
-  /// CHECK-START: long Main.sadL3Alt(char, char) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: long Main.sadL3Alt(char, char) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Intrin:j\d+>> Abs
   /// CHECK-DAG:                 Return [<<Intrin>>]
   static long sadL3Alt(char x, char y) {
diff --git a/test/660-checker-sad-int/src/Main.java b/test/660-checker-sad-int/src/Main.java
index 280dd66..09878a5 100644
--- a/test/660-checker-sad-int/src/Main.java
+++ b/test/660-checker-sad-int/src/Main.java
@@ -19,15 +19,15 @@
  */
 public class Main {
 
-  /// CHECK-START: int Main.sad1(int, int) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: int Main.sad1(int, int) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Select:i\d+>> Select
   /// CHECK-DAG:                 Return [<<Select>>]
   //
-  /// CHECK-START: int Main.sad1(int, int) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.sad1(int, int) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Select:i\d+>> Select
   /// CHECK-DAG:                 Return [<<Select>>]
   //
-  /// CHECK-START: int Main.sad1(int, int) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.sad1(int, int) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT: Abs
   //
   // NOTE: for direct 32-bit operands, this is not an ABS.
@@ -35,11 +35,11 @@
     return x >= y ? x - y : y - x;
   }
 
-  /// CHECK-START: int Main.sad2(int, int) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: int Main.sad2(int, int) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Select:i\d+>> Select
   /// CHECK-DAG:                 Return [<<Select>>]
   //
-  /// CHECK-START: int Main.sad2(int, int) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.sad2(int, int) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Intrin:i\d+>> Abs
   /// CHECK-DAG:                 Return [<<Intrin>>]
   static int sad2(int x, int y) {
@@ -48,11 +48,11 @@
     return diff;
   }
 
-  /// CHECK-START: int Main.sad3(int, int) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: int Main.sad3(int, int) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Select:i\d+>> Select
   /// CHECK-DAG:                 Return [<<Select>>]
   //
-  /// CHECK-START: int Main.sad3(int, int) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.sad3(int, int) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Intrin:i\d+>> Abs
   /// CHECK-DAG:                 Return [<<Intrin>>]
   static int sad3(int x, int y) {
@@ -60,11 +60,11 @@
     return diff >= 0 ? diff : -diff;
   }
 
-  /// CHECK-START: int Main.sad3Alt(int, int) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: int Main.sad3Alt(int, int) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Select:i\d+>> Select
   /// CHECK-DAG:                 Return [<<Select>>]
   //
-  /// CHECK-START: int Main.sad3Alt(int, int) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.sad3Alt(int, int) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Intrin:i\d+>> Abs
   /// CHECK-DAG:                 Return [<<Intrin>>]
   static int sad3Alt(int x, int y) {
@@ -72,11 +72,11 @@
     return 0 <= diff ? diff : -diff;
   }
 
-  /// CHECK-START: long Main.sadL1(int, int) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: long Main.sadL1(int, int) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Select:j\d+>> Select
   /// CHECK-DAG:                 Return [<<Select>>]
   //
-  /// CHECK-START: long Main.sadL1(int, int) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: long Main.sadL1(int, int) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Intrin:j\d+>> Abs
   /// CHECK-DAG:                 Return [<<Intrin>>]
   static long sadL1(int x, int y) {
@@ -85,11 +85,11 @@
     return xl >= yl ? xl - yl : yl - xl;
   }
 
-  /// CHECK-START: long Main.sadL2(int, int) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: long Main.sadL2(int, int) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Select:j\d+>> Select
   /// CHECK-DAG:                 Return [<<Select>>]
   //
-  /// CHECK-START: long Main.sadL2(int, int) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: long Main.sadL2(int, int) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Intrin:j\d+>> Abs
   /// CHECK-DAG:                 Return [<<Intrin>>]
   static long sadL2(int x, int y) {
@@ -98,11 +98,11 @@
     return diff;
   }
 
-  /// CHECK-START: long Main.sadL3(int, int) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: long Main.sadL3(int, int) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Select:j\d+>> Select
   /// CHECK-DAG:                 Return [<<Select>>]
   //
-  /// CHECK-START: long Main.sadL3(int, int) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: long Main.sadL3(int, int) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Intrin:j\d+>> Abs
   /// CHECK-DAG:                 Return [<<Intrin>>]
   static long sadL3(int x, int y) {
@@ -110,11 +110,11 @@
     return diff >= 0L ? diff : -diff;
   }
 
-  /// CHECK-START: long Main.sadL3Alt(int, int) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: long Main.sadL3Alt(int, int) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Select:j\d+>> Select
   /// CHECK-DAG:                 Return [<<Select>>]
   //
-  /// CHECK-START: long Main.sadL3Alt(int, int) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: long Main.sadL3Alt(int, int) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Intrin:j\d+>> Abs
   /// CHECK-DAG:                 Return [<<Intrin>>]
   static long sadL3Alt(int x, int y) {
diff --git a/test/660-checker-sad-long/src/Main.java b/test/660-checker-sad-long/src/Main.java
index ca0f4b7..b9eeb5f 100644
--- a/test/660-checker-sad-long/src/Main.java
+++ b/test/660-checker-sad-long/src/Main.java
@@ -19,15 +19,15 @@
  */
 public class Main {
 
-  /// CHECK-START: long Main.sad1(long, long) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: long Main.sad1(long, long) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Select:j\d+>> Select
   /// CHECK-DAG:                 Return [<<Select>>]
   //
-  /// CHECK-START: long Main.sad1(long, long) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: long Main.sad1(long, long) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Select:j\d+>> Select
   /// CHECK-DAG:                 Return [<<Select>>]
   //
-  /// CHECK-START: long Main.sad1(long, long) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: long Main.sad1(long, long) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT: Abs
   //
   // NOTE: for direct 64-bit operands, this is not an ABS.
@@ -35,11 +35,11 @@
     return x >= y ? x - y : y - x;
   }
 
-  /// CHECK-START: long Main.sad2(long, long) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: long Main.sad2(long, long) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Select:j\d+>> Select
   /// CHECK-DAG:                 Return [<<Select>>]
   //
-  /// CHECK-START: long Main.sad2(long, long) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: long Main.sad2(long, long) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Intrin:j\d+>> Abs
   /// CHECK-DAG:                 Return [<<Intrin>>]
   static long sad2(long x, long y) {
@@ -48,11 +48,11 @@
     return diff;
   }
 
-  /// CHECK-START: long Main.sad3(long, long) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: long Main.sad3(long, long) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Select:j\d+>> Select
   /// CHECK-DAG:                 Return [<<Select>>]
   //
-  /// CHECK-START: long Main.sad3(long, long) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: long Main.sad3(long, long) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Intrin:j\d+>> Abs
   /// CHECK-DAG:                 Return [<<Intrin>>]
   static long sad3(long x, long y) {
@@ -60,11 +60,11 @@
     return diff >= 0 ? diff : -diff;
   }
 
-  /// CHECK-START: long Main.sad3Alt(long, long) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: long Main.sad3Alt(long, long) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Select:j\d+>> Select
   /// CHECK-DAG:                 Return [<<Select>>]
   //
-  /// CHECK-START: long Main.sad3Alt(long, long) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: long Main.sad3Alt(long, long) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Intrin:j\d+>> Abs
   /// CHECK-DAG:                 Return [<<Intrin>>]
   static long sad3Alt(long x, long y) {
diff --git a/test/660-checker-sad-short/src/Main.java b/test/660-checker-sad-short/src/Main.java
index b712a14..0a1a4dc 100644
--- a/test/660-checker-sad-short/src/Main.java
+++ b/test/660-checker-sad-short/src/Main.java
@@ -19,22 +19,22 @@
  */
 public class Main {
 
-  /// CHECK-START: int Main.sad1(short, short) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: int Main.sad1(short, short) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Select:i\d+>> Select
   /// CHECK-DAG:                 Return [<<Select>>]
   //
-  /// CHECK-START: int Main.sad1(short, short) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.sad1(short, short) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Intrin:i\d+>> Abs
   /// CHECK-DAG:                 Return [<<Intrin>>]
   static int sad1(short x, short y) {
     return x >= y ? x - y : y - x;
   }
 
-  /// CHECK-START: int Main.sad2(short, short) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: int Main.sad2(short, short) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Select:i\d+>> Select
   /// CHECK-DAG:                 Return [<<Select>>]
   //
-  /// CHECK-START: int Main.sad2(short, short) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.sad2(short, short) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Intrin:i\d+>> Abs
   /// CHECK-DAG:                 Return [<<Intrin>>]
   static int sad2(short x, short y) {
@@ -43,11 +43,11 @@
     return diff;
   }
 
-  /// CHECK-START: int Main.sad3(short, short) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: int Main.sad3(short, short) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Select:i\d+>> Select
   /// CHECK-DAG:                 Return [<<Select>>]
   //
-  /// CHECK-START: int Main.sad3(short, short) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.sad3(short, short) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Intrin:i\d+>> Abs
   /// CHECK-DAG:                 Return [<<Intrin>>]
   static int sad3(short x, short y) {
@@ -55,11 +55,11 @@
     return diff >= 0 ? diff : -diff;
   }
 
-  /// CHECK-START: int Main.sad3Alt(short, short) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: int Main.sad3Alt(short, short) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Select:i\d+>> Select
   /// CHECK-DAG:                 Return [<<Select>>]
   //
-  /// CHECK-START: int Main.sad3Alt(short, short) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.sad3Alt(short, short) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Intrin:i\d+>> Abs
   /// CHECK-DAG:                 Return [<<Intrin>>]
   static int sad3Alt(short x, short y) {
@@ -67,11 +67,11 @@
     return 0 <= diff ? diff : -diff;
   }
 
-  /// CHECK-START: long Main.sadL1(short, short) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: long Main.sadL1(short, short) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Select:j\d+>> Select
   /// CHECK-DAG:                 Return [<<Select>>]
   //
-  /// CHECK-START: long Main.sadL1(short, short) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: long Main.sadL1(short, short) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Intrin:j\d+>> Abs
   /// CHECK-DAG:                 Return [<<Intrin>>]
   static long sadL1(short x, short y) {
@@ -80,11 +80,11 @@
     return xl >= yl ? xl - yl : yl - xl;
   }
 
-  /// CHECK-START: long Main.sadL2(short, short) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: long Main.sadL2(short, short) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Select:j\d+>> Select
   /// CHECK-DAG:                 Return [<<Select>>]
   //
-  /// CHECK-START: long Main.sadL2(short, short) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: long Main.sadL2(short, short) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Intrin:j\d+>> Abs
   /// CHECK-DAG:                 Return [<<Intrin>>]
   static long sadL2(short x, short y) {
@@ -93,11 +93,11 @@
     return diff;
   }
 
-  /// CHECK-START: long Main.sadL3(short, short) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: long Main.sadL3(short, short) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Select:j\d+>> Select
   /// CHECK-DAG:                 Return [<<Select>>]
   //
-  /// CHECK-START: long Main.sadL3(short, short) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: long Main.sadL3(short, short) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Intrin:j\d+>> Abs
   /// CHECK-DAG:                 Return [<<Intrin>>]
   static long sadL3(short x, short y) {
@@ -105,11 +105,11 @@
     return diff >= 0L ? diff : -diff;
   }
 
-  /// CHECK-START: long Main.sadL3Alt(short, short) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: long Main.sadL3Alt(short, short) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Select:j\d+>> Select
   /// CHECK-DAG:                 Return [<<Select>>]
   //
-  /// CHECK-START: long Main.sadL3Alt(short, short) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: long Main.sadL3Alt(short, short) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Intrin:j\d+>> Abs
   /// CHECK-DAG:                 Return [<<Intrin>>]
   static long sadL3Alt(short x, short y) {
diff --git a/test/679-checker-minmax/src/Main.java b/test/679-checker-minmax/src/Main.java
index 48de1da..abf8c27 100644
--- a/test/679-checker-minmax/src/Main.java
+++ b/test/679-checker-minmax/src/Main.java
@@ -99,211 +99,211 @@
   // Different types.
   //
 
-  /// CHECK-START: int Main.min1(int, int) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: int Main.min1(int, int) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Cnd:z\d+>> GreaterThanOrEqual [<<Op1:i\d+>>,<<Op2:i\d+>>]
   /// CHECK-DAG: <<Sel:i\d+>> Select [<<Op1>>,<<Op2>>,<<Cnd>>]
   /// CHECK-DAG:              Return [<<Sel>>]
   //
-  /// CHECK-START: int Main.min1(int, int) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.min1(int, int) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Min:i\d+>> Min
   /// CHECK-DAG:              Return [<<Min>>]
   //
-  /// CHECK-START: int Main.min1(int, int) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.min1(int, int) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:              Select
   public static int min1(int a, int b) {
     return a < b ? a : b;
   }
 
-  /// CHECK-START: int Main.min2(int, int) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: int Main.min2(int, int) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Cnd:z\d+>> GreaterThan [<<Op1:i\d+>>,<<Op2:i\d+>>]
   /// CHECK-DAG: <<Sel:i\d+>> Select [<<Op1>>,<<Op2>>,<<Cnd>>]
   /// CHECK-DAG:              Return [<<Sel>>]
   //
-  /// CHECK-START: int Main.min2(int, int) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.min2(int, int) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Min:i\d+>> Min
   /// CHECK-DAG:              Return [<<Min>>]
   //
-  /// CHECK-START: int Main.min2(int, int) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.min2(int, int) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:              Select
   public static int min2(int a, int b) {
     return a <= b ? a : b;
   }
 
-  /// CHECK-START: int Main.min3(int, int) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: int Main.min3(int, int) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Cnd:z\d+>> LessThanOrEqual [<<Op1:i\d+>>,<<Op2:i\d+>>]
   /// CHECK-DAG: <<Sel:i\d+>> Select [<<Op2>>,<<Op1>>,<<Cnd>>]
   /// CHECK-DAG:              Return [<<Sel>>]
   //
-  /// CHECK-START: int Main.min3(int, int) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.min3(int, int) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Min:i\d+>> Min
   /// CHECK-DAG:              Return [<<Min>>]
   //
-  /// CHECK-START: int Main.min3(int, int) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.min3(int, int) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:              Select
   public static int min3(int a, int b) {
     return a > b ? b : a;
   }
 
-  /// CHECK-START: int Main.min4(int, int) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: int Main.min4(int, int) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Cnd:z\d+>> LessThan [<<Op1:i\d+>>,<<Op2:i\d+>>]
   /// CHECK-DAG: <<Sel:i\d+>> Select [<<Op2>>,<<Op1>>,<<Cnd>>]
   /// CHECK-DAG:              Return [<<Sel>>]
   //
-  /// CHECK-START: int Main.min4(int, int) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.min4(int, int) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Min:i\d+>> Min
   /// CHECK-DAG:              Return [<<Min>>]
   //
-  /// CHECK-START: int Main.min4(int, int) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.min4(int, int) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:              Select
   public static int min4(int a, int b) {
     return a >= b ? b : a;
   }
 
-  /// CHECK-START: int Main.min5(short, short) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: int Main.min5(short, short) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Cnd:z\d+>> LessThan [<<Op1:s\d+>>,<<Op2:s\d+>>]
   /// CHECK-DAG: <<Sel:i\d+>> Select [<<Op2>>,<<Op1>>,<<Cnd>>]
   /// CHECK-DAG:              Return [<<Sel>>]
   //
-  /// CHECK-START: int Main.min5(short, short) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.min5(short, short) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Min:i\d+>> Min
   /// CHECK-DAG:              Return [<<Min>>]
   //
-  /// CHECK-START: int Main.min5(short, short) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.min5(short, short) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:              Select
   public static int min5(short a, short b) {
     return a >= b ? b : a;
   }
 
-  /// CHECK-START: int Main.min6(byte, byte) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: int Main.min6(byte, byte) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Cnd:z\d+>> LessThan [<<Op1:b\d+>>,<<Op2:b\d+>>]
   /// CHECK-DAG: <<Sel:i\d+>> Select [<<Op2>>,<<Op1>>,<<Cnd>>]
   /// CHECK-DAG:              Return [<<Sel>>]
   //
-  /// CHECK-START: int Main.min6(byte, byte) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.min6(byte, byte) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Min:i\d+>> Min
   /// CHECK-DAG:              Return [<<Min>>]
   //
-  /// CHECK-START: int Main.min6(byte, byte) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.min6(byte, byte) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:              Select
   public static int min6(byte a, byte b) {
     return a >= b ? b : a;
   }
 
-  /// CHECK-START: long Main.min7(long, long) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: long Main.min7(long, long) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Cnd:z\d+>> LessThan [<<Op1:j\d+>>,<<Op2:j\d+>>]
   /// CHECK-DAG: <<Sel:j\d+>> Select [<<Op2>>,<<Op1>>,<<Cnd>>]
   /// CHECK-DAG:              Return [<<Sel>>]
   //
-  /// CHECK-START: long Main.min7(long, long) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: long Main.min7(long, long) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Min:j\d+>> Min
   /// CHECK-DAG:              Return [<<Min>>]
   //
-  /// CHECK-START: long Main.min7(long, long) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: long Main.min7(long, long) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:              Select
   public static long min7(long a, long b) {
     return a >= b ? b : a;
   }
 
-  /// CHECK-START: int Main.max1(int, int) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: int Main.max1(int, int) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Cnd:z\d+>> GreaterThanOrEqual [<<Op1:i\d+>>,<<Op2:i\d+>>]
   /// CHECK-DAG: <<Sel:i\d+>> Select [<<Op2>>,<<Op1>>,<<Cnd>>]
   /// CHECK-DAG:              Return [<<Sel>>]
   //
-  /// CHECK-START: int Main.max1(int, int) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.max1(int, int) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Max:i\d+>> Max
   /// CHECK-DAG:              Return [<<Max>>]
   //
-  /// CHECK-START: int Main.max1(int, int) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.max1(int, int) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:              Select
   public static int max1(int a, int b) {
     return a < b ? b : a;
   }
 
-  /// CHECK-START: int Main.max2(int, int) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: int Main.max2(int, int) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Cnd:z\d+>> GreaterThan [<<Op1:i\d+>>,<<Op2:i\d+>>]
   /// CHECK-DAG: <<Sel:i\d+>> Select [<<Op2>>,<<Op1>>,<<Cnd>>]
   /// CHECK-DAG:              Return [<<Sel>>]
   //
-  /// CHECK-START: int Main.max2(int, int) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.max2(int, int) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Max:i\d+>> Max
   /// CHECK-DAG:              Return [<<Max>>]
   //
-  /// CHECK-START: int Main.max2(int, int) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.max2(int, int) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:              Select
   public static int max2(int a, int b) {
     return a <= b ? b : a;
   }
 
-  /// CHECK-START: int Main.max3(int, int) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: int Main.max3(int, int) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Cnd:z\d+>> LessThanOrEqual [<<Op1:i\d+>>,<<Op2:i\d+>>]
   /// CHECK-DAG: <<Sel:i\d+>> Select [<<Op1>>,<<Op2>>,<<Cnd>>]
   /// CHECK-DAG:              Return [<<Sel>>]
   //
-  /// CHECK-START: int Main.max3(int, int) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.max3(int, int) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Max:i\d+>> Max
   /// CHECK-DAG:              Return [<<Max>>]
   //
-  /// CHECK-START: int Main.max3(int, int) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.max3(int, int) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:              Select
   public static int max3(int a, int b) {
     return a > b ? a : b;
   }
 
-  /// CHECK-START: int Main.max4(int, int) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: int Main.max4(int, int) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Cnd:z\d+>> LessThan [<<Op1:i\d+>>,<<Op2:i\d+>>]
   /// CHECK-DAG: <<Sel:i\d+>> Select [<<Op1>>,<<Op2>>,<<Cnd>>]
   /// CHECK-DAG:              Return [<<Sel>>]
   //
-  /// CHECK-START: int Main.max4(int, int) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.max4(int, int) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Max:i\d+>> Max
   /// CHECK-DAG:              Return [<<Max>>]
   //
-  /// CHECK-START: int Main.max4(int, int) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.max4(int, int) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:              Select
   public static int max4(int a, int b) {
     return a >= b ? a : b;
   }
 
-  /// CHECK-START: int Main.max5(short, short) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: int Main.max5(short, short) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Cnd:z\d+>> LessThan [<<Op1:s\d+>>,<<Op2:s\d+>>]
   /// CHECK-DAG: <<Sel:i\d+>> Select [<<Op1>>,<<Op2>>,<<Cnd>>]
   /// CHECK-DAG:              Return [<<Sel>>]
   //
-  /// CHECK-START: int Main.max5(short, short) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.max5(short, short) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Max:i\d+>> Max
   /// CHECK-DAG:              Return [<<Max>>]
   //
-  /// CHECK-START: int Main.max5(short, short) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.max5(short, short) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:              Select
   public static int max5(short a, short b) {
     return a >= b ? a : b;
   }
 
-  /// CHECK-START: int Main.max6(byte, byte) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: int Main.max6(byte, byte) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Cnd:z\d+>> LessThan [<<Op1:b\d+>>,<<Op2:b\d+>>]
   /// CHECK-DAG: <<Sel:i\d+>> Select [<<Op1>>,<<Op2>>,<<Cnd>>]
   /// CHECK-DAG:              Return [<<Sel>>]
   //
-  /// CHECK-START: int Main.max6(byte, byte) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.max6(byte, byte) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Max:i\d+>> Max
   /// CHECK-DAG:              Return [<<Max>>]
   //
-  /// CHECK-START: int Main.max6(byte, byte) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.max6(byte, byte) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:              Select
   public static int max6(byte a, byte b) {
     return a >= b ? a : b;
   }
 
-  /// CHECK-START: long Main.max7(long, long) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: long Main.max7(long, long) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Cnd:z\d+>> LessThan [<<Op1:j\d+>>,<<Op2:j\d+>>]
   /// CHECK-DAG: <<Sel:j\d+>> Select [<<Op1>>,<<Op2>>,<<Cnd>>]
   /// CHECK-DAG:              Return [<<Sel>>]
   //
-  /// CHECK-START: long Main.max7(long, long) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: long Main.max7(long, long) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Max:j\d+>> Max
   /// CHECK-DAG:              Return [<<Max>>]
   //
-  /// CHECK-START: long Main.max7(long, long) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: long Main.max7(long, long) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:              Select
   public static long max7(long a, long b) {
     return a >= b ? a : b;
@@ -313,18 +313,18 @@
   // Complications.
   //
 
-  /// CHECK-START: int Main.min0(int[], int[]) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: int Main.min0(int[], int[]) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Ar1:i\d+>> ArrayGet [{{l\d+}},{{i\d+}}]
   /// CHECK-DAG: <<Ar2:i\d+>> ArrayGet [{{l\d+}},{{i\d+}}]
   /// CHECK-DAG: <<Cnd:z\d+>> GreaterThan [<<Ar1>>,<<Ar2>>]
   /// CHECK-DAG: <<Sel:i\d+>> Select [<<Ar1>>,<<Ar2>>,<<Cnd>>]
   /// CHECK-DAG:              Return [<<Sel>>]
   //
-  /// CHECK-START: int Main.min0(int[], int[]) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.min0(int[], int[]) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Min:i\d+>> Min
   /// CHECK-DAG:              Return [<<Min>>]
   //
-  /// CHECK-START: int Main.min0(int[], int[]) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.min0(int[], int[]) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:              Select
   public static int min0(int[] a, int[] b) {
     // Repeat of array references needs finding the common subexpressions
@@ -332,18 +332,18 @@
     return a[0] <= b[0] ? a[0] : b[0];
   }
 
-  /// CHECK-START: int Main.max0(int[], int[]) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: int Main.max0(int[], int[]) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Ar1:i\d+>> ArrayGet [{{l\d+}},{{i\d+}}]
   /// CHECK-DAG: <<Ar2:i\d+>> ArrayGet [{{l\d+}},{{i\d+}}]
   /// CHECK-DAG: <<Cnd:z\d+>> LessThan [<<Ar1>>,<<Ar2>>]
   /// CHECK-DAG: <<Sel:i\d+>> Select [<<Ar1>>,<<Ar2>>,<<Cnd>>]
   /// CHECK-DAG:              Return [<<Sel>>]
   //
-  /// CHECK-START: int Main.max0(int[], int[]) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.max0(int[], int[]) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Max:i\d+>> Max
   /// CHECK-DAG:              Return [<<Max>>]
   //
-  /// CHECK-START: int Main.max0(int[], int[]) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.max0(int[], int[]) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:              Select
   public static int max0(int[] a, int[] b) {
     // Repeat of array references needs finding the common subexpressions
@@ -351,7 +351,7 @@
     return a[0] >= b[0] ? a[0] : b[0];
   }
 
-  /// CHECK-START: int Main.minmax1(int) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: int Main.minmax1(int) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Par:i\d+>>  ParameterValue
   /// CHECK-DAG: <<P100:i\d+>> IntConstant 100
   /// CHECK-DAG: <<M100:i\d+>> IntConstant -100
@@ -361,7 +361,7 @@
   /// CHECK-DAG: <<Sel2:i\d+>> Select [<<M100>>,<<Sel1>>,<<Cnd2>>]
   /// CHECK-DAG:               Return [<<Sel2>>]
   //
-  /// CHECK-START: int Main.minmax1(int) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.minmax1(int) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Par:i\d+>>  ParameterValue
   /// CHECK-DAG: <<P100:i\d+>> IntConstant 100
   /// CHECK-DAG: <<M100:i\d+>> IntConstant -100
@@ -369,7 +369,7 @@
   /// CHECK-DAG: <<Max:i\d+>>  Max [<<Min>>,<<M100>>]
   /// CHECK-DAG:               Return [<<Max>>]
   //
-  /// CHECK-START: int Main.minmax1(int) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.minmax1(int) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:               Select
   public static int minmax1(int x) {
     // Simple if-if gives clean select sequence.
@@ -382,7 +382,7 @@
     return x;
   }
 
-  /// CHECK-START: int Main.minmax2(int) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: int Main.minmax2(int) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Par:i\d+>>  ParameterValue
   /// CHECK-DAG: <<P100:i\d+>> IntConstant 100
   /// CHECK-DAG: <<M100:i\d+>> IntConstant -100
@@ -392,7 +392,7 @@
   /// CHECK-DAG: <<Sel2:i\d+>> Select [<<P100>>,<<Sel1>>,<<Cnd1>>]
   /// CHECK-DAG:               Return [<<Sel2>>]
   //
-  /// CHECK-START: int Main.minmax2(int) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.minmax2(int) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Par:i\d+>>  ParameterValue
   /// CHECK-DAG: <<P100:i\d+>> IntConstant 100
   /// CHECK-DAG: <<M100:i\d+>> IntConstant -100
@@ -400,7 +400,7 @@
   /// CHECK-DAG: <<Min:i\d+>>  Min [<<Max>>,<<P100>>]
   /// CHECK-DAG:               Return [<<Min>>]
   //
-  /// CHECK-START: int Main.minmax2(int) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.minmax2(int) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:               Select
   public static int minmax2(int x) {
     // Simple if-else requires inspecting bounds of resulting selects.
@@ -412,7 +412,7 @@
     return x;
   }
 
-  /// CHECK-START: int Main.minmax3(int) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.minmax3(int) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Par:i\d+>>  ParameterValue
   /// CHECK-DAG: <<P100:i\d+>> IntConstant 100
   /// CHECK-DAG: <<M100:i\d+>> IntConstant -100
@@ -420,13 +420,13 @@
   /// CHECK-DAG: <<Min:i\d+>>  Min [<<Max>>,<<P100>>]
   /// CHECK-DAG:               Return [<<Min>>]
   //
-  /// CHECK-START: int Main.minmax3(int) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.minmax3(int) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:               Select
   public static int minmax3(int x) {
     return (x > 100) ? 100 : ((x < -100) ? -100 : x);
   }
 
-  /// CHECK-START: int Main.minmax4(int) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.minmax4(int) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Par:i\d+>>  ParameterValue
   /// CHECK-DAG: <<P100:i\d+>> IntConstant 100
   /// CHECK-DAG: <<M100:i\d+>> IntConstant -100
@@ -434,7 +434,7 @@
   /// CHECK-DAG: <<Max:i\d+>>  Max [<<Min>>,<<M100>>]
   /// CHECK-DAG:               Return [<<Max>>]
   //
-  /// CHECK-START: int Main.minmax4(int) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.minmax4(int) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:               Select
   public static int minmax4(int x) {
     return (x < -100) ? -100 : ((x > 100) ? 100 : x);
@@ -454,7 +454,7 @@
   /// CHECK-DAG: <<Add5:i\d+>> Add                [<<Sel2>>,<<Add4>>]
   /// CHECK-DAG:               Return             [<<Add5>>]
   //
-  /// CHECK-START: int Main.minmaxCSEScalar(int, int) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.minmaxCSEScalar(int, int) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Par1:i\d+>> ParameterValue
   /// CHECK-DAG: <<Par2:i\d+>> ParameterValue
   /// CHECK-DAG: <<Max:i\d+>>  Max    [<<Par1>>,<<Par2>>]
@@ -490,7 +490,7 @@
   /// CHECK-DAG: <<Add5:i\d+>> Add                [<<Sel2>>,<<Add4>>]
   /// CHECK-DAG:               Return             [<<Add5>>]
   //
-  /// CHECK-START: int Main.minmaxCSEArray(int[], int[]) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.minmaxCSEArray(int[], int[]) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Arr1:i\d+>> ArrayGet
   /// CHECK-DAG: <<Arr2:i\d+>> ArrayGet
   /// CHECK-DAG: <<Max:i\d+>>  Max    [<<Arr1>>,<<Arr2>>]
@@ -512,7 +512,7 @@
     return t1 + t2 + t3 + t4 + t5 + t6;
   }
 
-  /// CHECK-START: int Main.minmaxCSEScalarAndCond(int, int) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.minmaxCSEScalarAndCond(int, int) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Par1:i\d+>> ParameterValue
   /// CHECK-DAG: <<Par2:i\d+>> ParameterValue
   /// CHECK-DAG: <<Max:i\d+>>  Max    [<<Par1>>,<<Par2>>]
diff --git a/test/681-checker-abs/src/Main.java b/test/681-checker-abs/src/Main.java
index 2b95a8d..00390c3 100644
--- a/test/681-checker-abs/src/Main.java
+++ b/test/681-checker-abs/src/Main.java
@@ -59,7 +59,7 @@
   // Types.
   //
 
-  /// CHECK-START: int Main.abs1(int) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: int Main.abs1(int) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Par:i\d+>> ParameterValue
   /// CHECK-DAG: <<Zer:i\d+>> IntConstant 0
   /// CHECK-DAG: <<Cnd:z\d+>> GreaterThanOrEqual [<<Par>>,<<Zer>>]
@@ -67,18 +67,18 @@
   /// CHECK-DAG: <<Sel:i\d+>> Select [<<Neg>>,<<Par>>,<<Cnd>>]
   /// CHECK-DAG:              Return [<<Sel>>]
   //
-  /// CHECK-START: int Main.abs1(int) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.abs1(int) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Par:i\d+>> ParameterValue
   /// CHECK-DAG: <<Abs:i\d+>> Abs [<<Par>>]
   /// CHECK-DAG:              Return [<<Abs>>]
   //
-  /// CHECK-START: int Main.abs1(int) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.abs1(int) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:              Select
   public static int abs1(int a) {
     return a < 0 ? -a : a;
   }
 
-  /// CHECK-START: int Main.abs2(int) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: int Main.abs2(int) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Par:i\d+>> ParameterValue
   /// CHECK-DAG: <<Zer:i\d+>> IntConstant 0
   /// CHECK-DAG: <<Cnd:z\d+>> GreaterThan [<<Par>>,<<Zer>>]
@@ -86,18 +86,18 @@
   /// CHECK-DAG: <<Sel:i\d+>> Select [<<Neg>>,<<Par>>,<<Cnd>>]
   /// CHECK-DAG:              Return [<<Sel>>]
   //
-  /// CHECK-START: int Main.abs2(int) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.abs2(int) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Par:i\d+>> ParameterValue
   /// CHECK-DAG: <<Abs:i\d+>> Abs [<<Par>>]
   /// CHECK-DAG:              Return [<<Abs>>]
   //
-  /// CHECK-START: int Main.abs2(int) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.abs2(int) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:              Select
   public static int abs2(int a) {
     return a <= 0 ? -a : a;
   }
 
-  /// CHECK-START: int Main.abs3(int) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: int Main.abs3(int) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Par:i\d+>> ParameterValue
   /// CHECK-DAG: <<Zer:i\d+>> IntConstant 0
   /// CHECK-DAG: <<Cnd:z\d+>> LessThanOrEqual [<<Par>>,<<Zer>>]
@@ -105,18 +105,18 @@
   /// CHECK-DAG: <<Sel:i\d+>> Select [<<Par>>,<<Neg>>,<<Cnd>>]
   /// CHECK-DAG:              Return [<<Sel>>]
   //
-  /// CHECK-START: int Main.abs3(int) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.abs3(int) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Par:i\d+>> ParameterValue
   /// CHECK-DAG: <<Abs:i\d+>> Abs [<<Par>>]
   /// CHECK-DAG:              Return [<<Abs>>]
   //
-  /// CHECK-START: int Main.abs3(int) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.abs3(int) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:              Select
   public static int abs3(int a) {
     return a > 0 ? a : -a;
   }
 
-  /// CHECK-START: int Main.abs4(int) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: int Main.abs4(int) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Par:i\d+>> ParameterValue
   /// CHECK-DAG: <<Zer:i\d+>> IntConstant 0
   /// CHECK-DAG: <<Cnd:z\d+>> LessThan [<<Par>>,<<Zer>>]
@@ -124,18 +124,18 @@
   /// CHECK-DAG: <<Sel:i\d+>> Select [<<Par>>,<<Neg>>,<<Cnd>>]
   /// CHECK-DAG:              Return [<<Sel>>]
   //
-  /// CHECK-START: int Main.abs4(int) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.abs4(int) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Par:i\d+>> ParameterValue
   /// CHECK-DAG: <<Abs:i\d+>> Abs [<<Par>>]
   /// CHECK-DAG:              Return [<<Abs>>]
   //
-  /// CHECK-START: int Main.abs4(int) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.abs4(int) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:              Select
   public static int abs4(int a) {
     return a >= 0 ? a : -a;
   }
 
-  /// CHECK-START: int Main.abs5(short) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: int Main.abs5(short) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Par:s\d+>> ParameterValue
   /// CHECK-DAG: <<Zer:i\d+>> IntConstant 0
   /// CHECK-DAG: <<Cnd:z\d+>> LessThan [<<Par>>,<<Zer>>]
@@ -143,18 +143,18 @@
   /// CHECK-DAG: <<Sel:i\d+>> Select [<<Par>>,<<Neg>>,<<Cnd>>]
   /// CHECK-DAG:              Return [<<Sel>>]
   //
-  /// CHECK-START: int Main.abs5(short) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.abs5(short) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Par:s\d+>> ParameterValue
   /// CHECK-DAG: <<Abs:i\d+>> Abs [<<Par>>]
   /// CHECK-DAG:              Return [<<Abs>>]
   //
-  /// CHECK-START: int Main.abs5(short) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.abs5(short) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:              Select
   public static int abs5(short a) {
     return a >= 0 ? a : -a;
   }
 
-  /// CHECK-START: int Main.abs6(byte) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: int Main.abs6(byte) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Par:b\d+>> ParameterValue
   /// CHECK-DAG: <<Zer:i\d+>> IntConstant 0
   /// CHECK-DAG: <<Cnd:z\d+>> LessThan [<<Par>>,<<Zer>>]
@@ -162,18 +162,18 @@
   /// CHECK-DAG: <<Sel:i\d+>> Select [<<Par>>,<<Neg>>,<<Cnd>>]
   /// CHECK-DAG:              Return [<<Sel>>]
   //
-  /// CHECK-START: int Main.abs6(byte) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.abs6(byte) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Par:b\d+>> ParameterValue
   /// CHECK-DAG: <<Abs:i\d+>> Abs [<<Par>>]
   /// CHECK-DAG:              Return [<<Abs>>]
   //
-  /// CHECK-START: int Main.abs6(byte) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.abs6(byte) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:              Select
   public static int abs6(byte a) {
     return a >= 0 ? a : -a;
   }
 
-  /// CHECK-START: long Main.abs7(long) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: long Main.abs7(long) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Par:j\d+>> ParameterValue
   /// CHECK-DAG: <<Zer:j\d+>> LongConstant 0
   /// CHECK-DAG: <<Cnd:z\d+>> LessThan [<<Par>>,<<Zer>>]
@@ -181,12 +181,12 @@
   /// CHECK-DAG: <<Sel:j\d+>> Select [<<Par>>,<<Neg>>,<<Cnd>>]
   /// CHECK-DAG:              Return [<<Sel>>]
   //
-  /// CHECK-START: long Main.abs7(long) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: long Main.abs7(long) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Par:j\d+>> ParameterValue
   /// CHECK-DAG: <<Abs:j\d+>> Abs [<<Par>>]
   /// CHECK-DAG:              Return [<<Abs>>]
   //
-  /// CHECK-START: long Main.abs7(long) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: long Main.abs7(long) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:              Select
   public static long abs7(long a) {
     return a >= 0 ? a : -a;
@@ -196,7 +196,7 @@
   // Complications.
   //
 
-  /// CHECK-START: int Main.abs0(int[]) instruction_simplifier$after_inlining (before)
+  /// CHECK-START: int Main.abs0(int[]) instruction_simplifier$after_gvn (before)
   /// CHECK-DAG: <<Zer:i\d+>> IntConstant 0
   /// CHECK-DAG: <<Arr:i\d+>> ArrayGet [{{l\d+}},{{i\d+}}]
   /// CHECK-DAG: <<Cnd:z\d+>> LessThan [<<Arr>>,<<Zer>>]
@@ -204,12 +204,12 @@
   /// CHECK-DAG: <<Sel:i\d+>> Select [<<Arr>>,<<Neg>>,<<Cnd>>]
   /// CHECK-DAG:              Return [<<Sel>>]
   //
-  /// CHECK-START: int Main.abs0(int[]) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.abs0(int[]) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Arr:i\d+>> ArrayGet [{{l\d+}},{{i\d+}}]
   /// CHECK-DAG: <<Abs:i\d+>> Abs [<<Arr>>]
   /// CHECK-DAG:              Return [<<Abs>>]
   //
-  /// CHECK-START: int Main.abs0(int[]) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.abs0(int[]) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:              Select
   public static int abs0(int[] a) {
     return a[0] >= 0 ? a[0] : -a[0];
@@ -267,11 +267,11 @@
   /// CHECK-DAG: <<Abs:i\d+>> Abs [<<Par>>]
   /// CHECK-DAG:              Return [<<Abs>>]
   //
-  /// CHECK-START: int Main.zabs3(char) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.zabs3(char) instruction_simplifier$after_gvn (after)
   /// CHECK-DAG: <<Par:c\d+>> ParameterValue
   /// CHECK-DAG:              Return [<<Par>>]
   //
-  /// CHECK-START: int Main.zabs3(char) instruction_simplifier$after_inlining (after)
+  /// CHECK-START: int Main.zabs3(char) instruction_simplifier$after_gvn (after)
   /// CHECK-NOT:              InvokeStaticOrDirect
   /// CHECK-NOT:              Abs
   public static int zabs3(char a) {