Unify simplification passes after high-level optimizations

* Add a constant folding pass after the later high-level optimizations
* Remove dead_code_elimination$after_lse to unify simplification passes (always constant folding, instruction simplifier, dead code elimination)
* Make dead_code_elimination$before_codegen run always.

Locally speed compile Pixel 5:
* system server -64.28KB (-0.13%)
* SystemUIGoogle: -16.31KB (-0.06%)
* AGSA: -140.57 (-0.04%)

Test: art/test/testrunner/testrunner.py --host --64 --optimizing -b
Change-Id: I305877fd83471dff059fe1d4f5b98e5b1063f1a5
diff --git a/compiler/optimizing/optimization.h b/compiler/optimizing/optimization.h
index c3ba175..2ef21b3 100644
--- a/compiler/optimizing/optimization.h
+++ b/compiler/optimizing/optimization.h
@@ -43,7 +43,7 @@
 
   // Return the name of the pass. Pass names for a single HOptimization should be of form
   // <optimization_name> or <optimization_name>$<pass_name> for common <optimization_name> prefix.
-  // Example: 'instruction_simplifier', 'instruction_simplifier$after_bce',
+  // Example: 'instruction_simplifier', 'instruction_simplifier$before_codegen',
   // 'instruction_simplifier$before_codegen'.
   const char* GetPassName() const { return pass_name_; }
 
diff --git a/compiler/optimizing/optimizing_compiler.cc b/compiler/optimizing/optimizing_compiler.cc
index db39ff9..60d5e6f 100644
--- a/compiler/optimizing/optimizing_compiler.cc
+++ b/compiler/optimizing/optimizing_compiler.cc
@@ -671,18 +671,18 @@
     OptDef(OptimizationPass::kLoopOptimization),
     // Simplification.
     OptDef(OptimizationPass::kConstantFolding,
-           "constant_folding$after_bce"),
+           "constant_folding$after_loop_opt"),
     OptDef(OptimizationPass::kAggressiveInstructionSimplifier,
-           "instruction_simplifier$after_bce"),
+           "instruction_simplifier$after_loop_opt"),
     OptDef(OptimizationPass::kDeadCodeElimination,
-           "dead_code_elimination$after_bce"),
+           "dead_code_elimination$after_loop_opt"),
     // Other high-level optimizations.
     OptDef(OptimizationPass::kLoadStoreElimination),
-    OptDef(OptimizationPass::kDeadCodeElimination,
-           "dead_code_elimination$after_lse",
-           OptimizationPass::kLoadStoreElimination),
     OptDef(OptimizationPass::kCHAGuardOptimization),
     OptDef(OptimizationPass::kCodeSinking),
+    // Simplification.
+    OptDef(OptimizationPass::kConstantFolding,
+           "constant_folding$before_codegen"),
     // 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.
@@ -691,8 +691,7 @@
     // Simplification may result in dead code that should be removed prior to
     // code generation.
     OptDef(OptimizationPass::kDeadCodeElimination,
-           "dead_code_elimination$before_codegen",
-           OptimizationPass::kAggressiveInstructionSimplifier),
+           "dead_code_elimination$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/2042-checker-dce-always-throw/src/Main.java b/test/2042-checker-dce-always-throw/src/Main.java
index e164917..4df4e63 100644
--- a/test/2042-checker-dce-always-throw/src/Main.java
+++ b/test/2042-checker-dce-always-throw/src/Main.java
@@ -214,7 +214,7 @@
   /// CHECK:       TryBoundary kind:entry
 
   // Consistency check to that we do not simplify it by the last DCE pass either
-  /// CHECK-START: int Main.$noinline$testDoNotSimplifyInTry(int) dead_code_elimination$after_bce (after)
+  /// CHECK-START: int Main.$noinline$testDoNotSimplifyInTry(int) dead_code_elimination$before_codegen (after)
   /// CHECK-DAG:   InvokeStaticOrDirect block:<<InvokeBlock:B\d+>> method_name:Main.alwaysThrows always_throws:true
   /// CHECK-DAG:   Exit block:<<ExitBlock:B\d+>>
   /// CHECK-DAG:   Goto block:<<InvokeBlock>> target:<<TargetBlock:B\d+>>
@@ -282,7 +282,7 @@
   /// CHECK-DAG:   TryBoundary kind:entry
 
   // Consistency check to that we do not simplify it by the last DCE pass either
-  /// CHECK-START: int Main.$noinline$testDoNotSimplifyInCatchInOuterTry(int, int) dead_code_elimination$after_bce (after)
+  /// CHECK-START: int Main.$noinline$testDoNotSimplifyInCatchInOuterTry(int, int) dead_code_elimination$before_codegen (after)
   /// CHECK-DAG:   InvokeStaticOrDirect block:<<InvokeBlock:B\d+>> method_name:Main.alwaysThrows always_throws:true
   /// CHECK-DAG:   Exit block:<<ExitBlock:B\d+>>
   /// CHECK-DAG:   Goto block:<<InvokeBlock>> target:<<TargetBlock:B\d+>>
diff --git a/test/2257-checker-constant-folding-before-codegen/expected-stderr.txt b/test/2257-checker-constant-folding-before-codegen/expected-stderr.txt
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/test/2257-checker-constant-folding-before-codegen/expected-stderr.txt
diff --git a/test/2257-checker-constant-folding-before-codegen/expected-stdout.txt b/test/2257-checker-constant-folding-before-codegen/expected-stdout.txt
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/test/2257-checker-constant-folding-before-codegen/expected-stdout.txt
diff --git a/test/2257-checker-constant-folding-before-codegen/info.txt b/test/2257-checker-constant-folding-before-codegen/info.txt
new file mode 100644
index 0000000..f6eb041
--- /dev/null
+++ b/test/2257-checker-constant-folding-before-codegen/info.txt
@@ -0,0 +1 @@
+Test the benefits of running constant folding after LSE.
diff --git a/test/2257-checker-constant-folding-before-codegen/src/Main.java b/test/2257-checker-constant-folding-before-codegen/src/Main.java
new file mode 100644
index 0000000..492ad9e
--- /dev/null
+++ b/test/2257-checker-constant-folding-before-codegen/src/Main.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+public class Main {
+    public static void main(String[] args) {
+        assertEquals(0, $noinline$testRemoveAbsAndReturnConstant());
+    }
+
+    // After LSE we know that some values are 0, making the Abs operation redundant.
+
+    /// CHECK-START: int Main.$noinline$testRemoveAbsAndReturnConstant() constant_folding$before_codegen (before)
+    /// CHECK:     Abs
+
+    /// CHECK-START: int Main.$noinline$testRemoveAbsAndReturnConstant() constant_folding$before_codegen (after)
+    /// CHECK-NOT:  Abs
+
+    // This enables DCE to know the return value at compile time.
+
+    /// CHECK-START: int Main.$noinline$testRemoveAbsAndReturnConstant() dead_code_elimination$before_codegen (before)
+    /// CHECK:     <<ReturnPhi:i\d+>> Phi [<<Val1:i\d+>>,<<Val2:i\d+>>]
+    /// CHECK:     Return [<<ReturnPhi>>]
+
+    /// CHECK-START: int Main.$noinline$testRemoveAbsAndReturnConstant() dead_code_elimination$before_codegen (after)
+    /// CHECK:     <<Const0:i\d+>> IntConstant 0
+    /// CHECK:     Return [<<Const0>>]
+
+    private static int $noinline$testRemoveAbsAndReturnConstant() {
+        final int ARRAY_SIZE = 10;
+        int[] result = new int[ARRAY_SIZE];
+        int[] source = new int[ARRAY_SIZE];
+
+        int value = 0;
+        for (int i = 0; i < ARRAY_SIZE; ++i) {
+            value += Math.abs(source[i]);
+            result[i] = value;
+        }
+        return value;
+    }
+
+    public static void assertEquals(int expected, int result) {
+        if (expected != result) {
+            throw new Error("Expected: " + expected + ", found: " + result);
+        }
+    }
+}
diff --git a/test/411-checker-instruct-simplifier-hrem/src/Main.java b/test/411-checker-instruct-simplifier-hrem/src/Main.java
index e6853dd..d790eda 100644
--- a/test/411-checker-instruct-simplifier-hrem/src/Main.java
+++ b/test/411-checker-instruct-simplifier-hrem/src/Main.java
@@ -381,11 +381,11 @@
   /// CHECK:           Div loop:B{{\d+}}
   /// CHECK-NEXT:      Rem loop:B{{\d+}}
   //
-  /// CHECK-START: int Main.$noinline$IntRemBy18InLoop(int) instruction_simplifier$after_bce (before)
+  /// CHECK-START: int Main.$noinline$IntRemBy18InLoop(int) instruction_simplifier$after_loop_opt (before)
   /// CHECK:           Div loop:B{{\d+}}
   /// CHECK-NEXT:      Rem loop:B{{\d+}}
   //
-  /// CHECK-START: int Main.$noinline$IntRemBy18InLoop(int) instruction_simplifier$after_bce (after)
+  /// CHECK-START: int Main.$noinline$IntRemBy18InLoop(int) instruction_simplifier$after_loop_opt (after)
   /// CHECK-NOT:       Rem
   /// CHECK:           Div loop:B{{\d+}}
   /// CHECK-NEXT:      Mul loop:B{{\d+}}
@@ -799,11 +799,11 @@
   /// CHECK:           Div loop:B{{\d+}}
   /// CHECK-NEXT:      Rem loop:B{{\d+}}
   //
-  /// CHECK-START: long Main.$noinline$LongRemBy18InLoop(long) instruction_simplifier$after_bce (before)
+  /// CHECK-START: long Main.$noinline$LongRemBy18InLoop(long) instruction_simplifier$after_loop_opt (before)
   /// CHECK:           Div loop:B{{\d+}}
   /// CHECK-NEXT:      Rem loop:B{{\d+}}
   //
-  /// CHECK-START: long Main.$noinline$LongRemBy18InLoop(long) instruction_simplifier$after_bce (after)
+  /// CHECK-START: long Main.$noinline$LongRemBy18InLoop(long) instruction_simplifier$after_loop_opt (after)
   /// CHECK-NOT:       Rem
   /// CHECK:           Div loop:B{{\d+}}
   /// CHECK-NEXT:      Mul loop:B{{\d+}}
diff --git a/test/449-checker-bce/src/Main.java b/test/449-checker-bce/src/Main.java
index fbe3586..3e41410 100644
--- a/test/449-checker-bce/src/Main.java
+++ b/test/449-checker-bce/src/Main.java
@@ -1576,7 +1576,7 @@
   /// CHECK-NOT: BoundsCheck
   /// CHECK: ArrayGet
 
-  /// CHECK-START: void Main.foo9(int[], boolean) instruction_simplifier$after_bce (after)
+  /// CHECK-START: void Main.foo9(int[], boolean) instruction_simplifier$before_codegen (after)
   //  Simplification removes the redundant check
   /// CHECK: Deoptimize
   /// CHECK: Deoptimize
diff --git a/test/458-checker-instruct-simplification/smali/SmaliTests.smali b/test/458-checker-instruct-simplification/smali/SmaliTests.smali
index f0436d2..1dd66d6 100644
--- a/test/458-checker-instruct-simplification/smali/SmaliTests.smali
+++ b/test/458-checker-instruct-simplification/smali/SmaliTests.smali
@@ -415,7 +415,7 @@
 ## CHECK-DAG:     <<NotArg:z\d+>>    BooleanNot [<<Arg>>]
 ## CHECK-DAG:                        Return [<<Arg>>]
 
-## CHECK-START: boolean SmaliTests.$noinline$NotNotBool(boolean) dead_code_elimination$after_bce (after)
+## CHECK-START: boolean SmaliTests.$noinline$NotNotBool(boolean) dead_code_elimination$before_codegen (after)
 ## CHECK-DAG:     <<Arg:z\d+>>       ParameterValue
 ## CHECK-DAG:                        Return [<<Arg>>]
 
diff --git a/test/530-checker-loops-try-catch/src/Main.java b/test/530-checker-loops-try-catch/src/Main.java
index 8d44b65..7927d9b 100644
--- a/test/530-checker-loops-try-catch/src/Main.java
+++ b/test/530-checker-loops-try-catch/src/Main.java
@@ -393,7 +393,7 @@
   /// CHECK-DAG: <<Add:i\d+>> Add [<<Int>>,<<Zer>>] loop:none
   /// CHECK-DAG:              Return [<<Add>>]      loop:none
 
-  /// CHECK-START: int Main.$noinline$poly1() instruction_simplifier$after_bce (after)
+  /// CHECK-START: int Main.$noinline$poly1() instruction_simplifier$before_codegen (after)
   /// CHECK-DAG: <<Int:i\d+>>  IntConstant 55 loop:none
   /// CHECK-DAG:               Return [<<Int>>]  loop:none
 
@@ -541,7 +541,7 @@
   /// CHECK-DAG: <<Add:i\d+>> Add [<<Int>>,<<Ini>>]   loop:none
   /// CHECK-DAG:              Return [<<Add>>]        loop:none
 
-  /// CHECK-START: int Main.$noinline$poly3() instruction_simplifier$after_bce (after)
+  /// CHECK-START: int Main.$noinline$poly3() instruction_simplifier$before_codegen (after)
   /// CHECK-DAG: <<Int:i\d+>>  IntConstant -2146724623 loop:none
   /// CHECK-DAG:               Return [<<Int>>]        loop:none
 
diff --git a/test/530-checker-loops3/src/Main.java b/test/530-checker-loops3/src/Main.java
index dfc4a5f..c7eaa56 100644
--- a/test/530-checker-loops3/src/Main.java
+++ b/test/530-checker-loops3/src/Main.java
@@ -132,7 +132,7 @@
   /// CHECK-DAG: Deoptimize loop:none
   /// CHECK-NOT: Deoptimize
   //
-  /// CHECK-START: void Main.multipleUnitStrides(int[], int[]) instruction_simplifier$after_bce (after)
+  /// CHECK-START: void Main.multipleUnitStrides(int[], int[]) instruction_simplifier$before_codegen (after)
   /// CHECK-DAG: Deoptimize loop:none
   /// CHECK-DAG: Deoptimize loop:none
   /// CHECK-DAG: Deoptimize loop:none
@@ -164,7 +164,7 @@
   /// CHECK-DAG: Deoptimize loop:none
   /// CHECK-NOT: Deoptimize
   //
-  /// CHECK-START: void Main.multipleUnitStridesConditional(int[], int[]) instruction_simplifier$after_bce (after)
+  /// CHECK-START: void Main.multipleUnitStridesConditional(int[], int[]) instruction_simplifier$before_codegen (after)
   /// CHECK-DAG: Deoptimize loop:none
   /// CHECK-DAG: Deoptimize loop:none
   /// CHECK-DAG: Deoptimize loop:none
@@ -196,7 +196,7 @@
   /// CHECK-DAG: Deoptimize loop:none
   /// CHECK-NOT: Deoptimize
   //
-  /// CHECK-START: void Main.shifter(int[]) instruction_simplifier$after_bce (after)
+  /// CHECK-START: void Main.shifter(int[]) instruction_simplifier$before_codegen (after)
   /// CHECK-DAG: Deoptimize loop:none
   /// CHECK-DAG: Deoptimize loop:none
   /// CHECK-NOT: Deoptimize
diff --git a/test/530-checker-loops5/src/Main.java b/test/530-checker-loops5/src/Main.java
index 54b54d0..f934df3 100644
--- a/test/530-checker-loops5/src/Main.java
+++ b/test/530-checker-loops5/src/Main.java
@@ -30,7 +30,7 @@
   /// CHECK-DAG: <<Add:i\d+>> Add [<<Int>>,<<Zer>>] loop:none
   /// CHECK-DAG:              Return [<<Add>>]      loop:none
   //
-  /// CHECK-START: int Main.poly1() instruction_simplifier$after_bce (after)
+  /// CHECK-START: int Main.poly1() instruction_simplifier$before_codegen (after)
   /// CHECK-DAG: <<Int:i\d+>>  IntConstant 55 loop:none
   /// CHECK-DAG:               Return [<<Int>>]  loop:none
   //
@@ -83,7 +83,7 @@
   /// CHECK-DAG: <<Add:i\d+>> Add [<<Int>>,<<Ini>>]   loop:none
   /// CHECK-DAG:              Return [<<Add>>]        loop:none
   //
-  /// CHECK-START: int Main.poly3() instruction_simplifier$after_bce (after)
+  /// CHECK-START: int Main.poly3() instruction_simplifier$before_codegen (after)
   /// CHECK-DAG: <<Int:i\d+>>  IntConstant -2146724623 loop:none
   /// CHECK-DAG:               Return [<<Int>>]        loop:none
   //
diff --git a/test/530-checker-peel-unroll/src/Main.java b/test/530-checker-peel-unroll/src/Main.java
index d97de2a..ce3d71b 100644
--- a/test/530-checker-peel-unroll/src/Main.java
+++ b/test/530-checker-peel-unroll/src/Main.java
@@ -1015,7 +1015,7 @@
   /// CHECK:                      ArraySet
   /// CHECK-NOT:                  ArraySet
 
-  /// CHECK-START: void Main.peelingSimple(int[], boolean) dead_code_elimination$after_bce (after)
+  /// CHECK-START: void Main.peelingSimple(int[], boolean) dead_code_elimination$before_codegen (after)
   /// CHECK-DAG: <<Param:z\d+>>     ParameterValue                            loop:none
   /// CHECK-DAG: <<Const0:i\d+>>    IntConstant 0                             loop:none
   /// CHECK-DAG: <<Const1:i\d+>>    IntConstant 1                             loop:none
@@ -1030,21 +1030,21 @@
   /// CHECK-DAG:                    ArraySet                                  loop:<<Loop>>      outer_loop:none
   /// CHECK-DAG: <<IndAdd:i\d+>>    Add [<<Phi>>,<<Const1>>]                  loop:<<Loop>>      outer_loop:none
 
-  /// CHECK-START: void Main.peelingSimple(int[], boolean) dead_code_elimination$after_bce (after)
+  /// CHECK-START: void Main.peelingSimple(int[], boolean) dead_code_elimination$before_codegen (after)
   /// CHECK:                      GreaterThanOrEqual
   /// CHECK-NOT:                  GreaterThanOrEqual
 
-  /// CHECK-START: void Main.peelingSimple(int[], boolean) dead_code_elimination$after_bce (after)
+  /// CHECK-START: void Main.peelingSimple(int[], boolean) dead_code_elimination$before_codegen (after)
   /// CHECK:                      If
   /// CHECK:                      If
   /// CHECK-NOT:                  If
 
-  /// CHECK-START: void Main.peelingSimple(int[], boolean) dead_code_elimination$after_bce (after)
+  /// CHECK-START: void Main.peelingSimple(int[], boolean) dead_code_elimination$before_codegen (after)
   /// CHECK:                      ArrayGet
   /// CHECK:                      ArrayGet
   /// CHECK-NOT:                  ArrayGet
 
-  /// CHECK-START: void Main.peelingSimple(int[], boolean) dead_code_elimination$after_bce (after)
+  /// CHECK-START: void Main.peelingSimple(int[], boolean) dead_code_elimination$before_codegen (after)
   /// CHECK:                      ArraySet
   /// CHECK:                      ArraySet
   /// CHECK-NOT:                  ArraySet
@@ -1069,7 +1069,7 @@
   /// CHECK-DAG:                    If [<<Check>>]                        loop:<<Loop>>      outer_loop:none
   /// CHECK-DAG:                    ArraySet                              loop:<<Loop>>      outer_loop:none
 
-  /// CHECK-START: void Main.peelingAddInts(int[]) dead_code_elimination$after_bce (after)
+  /// CHECK-START: void Main.peelingAddInts(int[]) dead_code_elimination$before_codegen (after)
   /// CHECK-DAG: <<Param:l\d+>>     ParameterValue                        loop:none
   /// CHECK-DAG: <<ConstNull:l\d+>> NullConstant                          loop:none
   /// CHECK-DAG: <<Eq:z\d+>>        Equal [<<Param>>,<<ConstNull>>]       loop:none
@@ -1081,7 +1081,7 @@
   /// CHECK-DAG:                    ArraySet                              loop:<<Loop>>      outer_loop:none
 
   // There's a 3rd `if` due to bounds checks.
-  /// CHECK-START: void Main.peelingAddInts(int[]) dead_code_elimination$after_bce (after)
+  /// CHECK-START: void Main.peelingAddInts(int[]) dead_code_elimination$before_codegen (after)
   /// CHECK:                        If
   /// CHECK:                        If
   /// CHECK:                        If
@@ -1118,7 +1118,7 @@
   /// CHECK:                        ArraySet
   /// CHECK-NOT:                    ArraySet
 
-  /// CHECK-START: void Main.peelingBreakFromNest(int[], boolean) dead_code_elimination$after_bce (after)
+  /// CHECK-START: void Main.peelingBreakFromNest(int[], boolean) dead_code_elimination$before_codegen (after)
   /// CHECK-DAG: <<Param:z\d+>>     ParameterValue                          loop:none
   /// CHECK-DAG: <<Const0:i\d+>>    IntConstant 0                           loop:none
   /// CHECK-DAG: <<Const1:i\d+>>    IntConstant 1                           loop:none
@@ -1135,13 +1135,13 @@
   /// CHECK-DAG: <<IndAdd1:i\d+>>   Add [<<Phi1>>,<<Const1>>]               loop:<<Loop1>>      outer_loop:<<Loop0>>
   /// CHECK-DAG: <<IndAdd0:i\d+>>   Add [<<Phi0>>,<<Const1>>]               loop:<<Loop0>>      outer_loop:none
 
-  /// CHECK-START: void Main.peelingBreakFromNest(int[], boolean) dead_code_elimination$after_bce (after)
+  /// CHECK-START: void Main.peelingBreakFromNest(int[], boolean) dead_code_elimination$before_codegen (after)
   /// CHECK:                        If
   /// CHECK:                        If
   /// CHECK:                        If
   /// CHECK-NOT:                    If
 
-  /// CHECK-START: void Main.peelingBreakFromNest(int[], boolean) dead_code_elimination$after_bce (after)
+  /// CHECK-START: void Main.peelingBreakFromNest(int[], boolean) dead_code_elimination$before_codegen (after)
   /// CHECK:                        ArraySet
   /// CHECK:                        ArraySet
   /// CHECK-NOT:                    ArraySet
@@ -1170,7 +1170,7 @@
   /// CHECK:                        If
   /// CHECK-NOT:                    If
 
-  /// CHECK-START: int Main.peelingHoistOneControl(int) dead_code_elimination$after_bce (after)
+  /// CHECK-START: int Main.peelingHoistOneControl(int) dead_code_elimination$before_codegen (after)
   /// CHECK-DAG: <<Param:i\d+>>     ParameterValue                            loop:none
   /// CHECK-DAG: <<Const0:i\d+>>    IntConstant 0                             loop:none
   /// CHECK-DAG: <<Check:z\d+>>     NotEqual [<<Param>>,<<Const0>>]           loop:none
@@ -1181,14 +1181,14 @@
   //  Check that the loop has no instruction except SuspendCheck and Goto (indefinite loop).
   /// CHECK-NOT:                                                              loop:<<Loop>>      outer_loop:none
 
-  /// CHECK-START: int Main.peelingHoistOneControl(int) dead_code_elimination$after_bce (after)
+  /// CHECK-START: int Main.peelingHoistOneControl(int) dead_code_elimination$before_codegen (after)
   /// CHECK:                        If
   /// CHECK-NOT:                    If
 
-  /// CHECK-START: int Main.peelingHoistOneControl(int) dead_code_elimination$after_bce (after)
+  /// CHECK-START: int Main.peelingHoistOneControl(int) dead_code_elimination$before_codegen (after)
   /// CHECK-NOT:                    Phi
 
-  /// CHECK-START: int Main.peelingHoistOneControl(int) dead_code_elimination$after_bce (after)
+  /// CHECK-START: int Main.peelingHoistOneControl(int) dead_code_elimination$before_codegen (after)
   /// CHECK-NOT:                    Add
   private static final int peelingHoistOneControl(int x) {
     int i = 0;
@@ -1204,12 +1204,12 @@
   /// CHECK-DAG:              If   loop:<<Loop>>      outer_loop:none
   /// CHECK-DAG:              If   loop:<<Loop>>      outer_loop:none
 
-  /// CHECK-START: int Main.peelingHoistOneControl(int, int) dead_code_elimination$after_bce (after)
+  /// CHECK-START: int Main.peelingHoistOneControl(int, int) dead_code_elimination$before_codegen (after)
   /// CHECK-DAG: <<Phi:i\d+>> Phi  loop:<<Loop:B\d+>> outer_loop:none
   /// CHECK-DAG:              If   loop:<<Loop>>      outer_loop:none
 
   // One `if` inside the loop (the one no longer invariant), two outside of it.
-  /// CHECK-START: int Main.peelingHoistOneControl(int, int) dead_code_elimination$after_bce (after)
+  /// CHECK-START: int Main.peelingHoistOneControl(int, int) dead_code_elimination$before_codegen (after)
   /// CHECK:                  If
   /// CHECK:                  If
   /// CHECK:                  If
@@ -1230,12 +1230,12 @@
   /// CHECK-DAG:              If   loop:<<Loop>>      outer_loop:none
   /// CHECK-DAG:              If   loop:<<Loop>>      outer_loop:none
 
-  /// CHECK-START: int Main.peelingHoistTwoControl(int, int, int) dead_code_elimination$after_bce (after)
+  /// CHECK-START: int Main.peelingHoistTwoControl(int, int, int) dead_code_elimination$before_codegen (after)
   /// CHECK-DAG: <<Phi:i\d+>> Phi  loop:<<Loop:B\d+>> outer_loop:none
   /// CHECK-DAG:              If   loop:<<Loop>>      outer_loop:none
 
   // One `if` inside the loop (the one no longer invariant), three outside of it.
-  /// CHECK-START: int Main.peelingHoistTwoControl(int, int, int) dead_code_elimination$after_bce (after)
+  /// CHECK-START: int Main.peelingHoistTwoControl(int, int, int) dead_code_elimination$before_codegen (after)
   /// CHECK:                  If
   /// CHECK:                  If
   /// CHECK:                  If
diff --git a/test/550-checker-multiply-accumulate/src/Main.java b/test/550-checker-multiply-accumulate/src/Main.java
index a07111b..f50968b 100644
--- a/test/550-checker-multiply-accumulate/src/Main.java
+++ b/test/550-checker-multiply-accumulate/src/Main.java
@@ -413,16 +413,16 @@
     return - (left * right);
   }
 
-  /// CHECK-START-ARM64: void Main.SimdMulAdd(int[], int[]) instruction_simplifier$after_bce (before)
+  /// CHECK-START-ARM64: void Main.SimdMulAdd(int[], int[]) instruction_simplifier$after_loop_opt (before)
   /// CHECK-DAG:     Phi                            loop:<<Loop:B\d+>> outer_loop:none
   /// CHECK-DAG:     VecMul                         loop:<<Loop>>      outer_loop:none
   /// CHECK-DAG:     VecAdd                         loop:<<Loop>>      outer_loop:none
 
-  /// CHECK-START-ARM64: void Main.SimdMulAdd(int[], int[]) instruction_simplifier$after_bce (after)
+  /// CHECK-START-ARM64: void Main.SimdMulAdd(int[], int[]) instruction_simplifier$after_loop_opt (after)
   /// CHECK-DAG:     Phi                            loop:<<Loop:B\d+>> outer_loop:none
   /// CHECK-DAG:     VecMultiplyAccumulate kind:Add loop:<<Loop>>      outer_loop:none
 
-  /// CHECK-START-ARM64: void Main.SimdMulAdd(int[], int[]) instruction_simplifier$after_bce (after)
+  /// CHECK-START-ARM64: void Main.SimdMulAdd(int[], int[]) instruction_simplifier$after_loop_opt (after)
   /// CHECK-NOT:     VecMul
   /// CHECK-NOT:     VecAdd
 
@@ -438,16 +438,16 @@
     }
   }
 
-  /// CHECK-START-ARM64: void Main.SimdMulSub(int[], int[]) instruction_simplifier$after_bce (before)
+  /// CHECK-START-ARM64: void Main.SimdMulSub(int[], int[]) instruction_simplifier$after_loop_opt (before)
   /// CHECK-DAG:     Phi                            loop:<<Loop:B\d+>> outer_loop:none
   /// CHECK-DAG:     VecMul                         loop:<<Loop>>      outer_loop:none
   /// CHECK-DAG:     VecSub                         loop:<<Loop>>      outer_loop:none
 
-  /// CHECK-START-ARM64: void Main.SimdMulSub(int[], int[]) instruction_simplifier$after_bce (after)
+  /// CHECK-START-ARM64: void Main.SimdMulSub(int[], int[]) instruction_simplifier$after_loop_opt (after)
   /// CHECK-DAG:     Phi                            loop:<<Loop:B\d+>> outer_loop:none
   /// CHECK-DAG:     VecMultiplyAccumulate kind:Sub loop:<<Loop>>      outer_loop:none
 
-  /// CHECK-START-ARM64: void Main.SimdMulSub(int[], int[]) instruction_simplifier$after_bce (after)
+  /// CHECK-START-ARM64: void Main.SimdMulSub(int[], int[]) instruction_simplifier$after_loop_opt (after)
   /// CHECK-NOT:     VecMul
   /// CHECK-NOT:     VecSub
 
@@ -463,12 +463,12 @@
     }
   }
 
-  /// CHECK-START-ARM64: void Main.SimdMulMultipleUses(int[], int[]) instruction_simplifier$after_bce (before)
+  /// CHECK-START-ARM64: void Main.SimdMulMultipleUses(int[], int[]) instruction_simplifier$after_loop_opt (before)
   /// CHECK-DAG:     Phi                            loop:<<Loop:B\d+>> outer_loop:none
   /// CHECK-DAG:     VecMul                         loop:<<Loop>>      outer_loop:none
   /// CHECK-DAG:     VecSub                         loop:<<Loop>>      outer_loop:none
 
-  /// CHECK-START-ARM64: void Main.SimdMulMultipleUses(int[], int[]) instruction_simplifier$after_bce (after)
+  /// CHECK-START-ARM64: void Main.SimdMulMultipleUses(int[], int[]) instruction_simplifier$after_loop_opt (after)
   /// CHECK-NOT: VecMultiplyAccumulate
 
   public static void SimdMulMultipleUses(int[] array1, int[] array2) {
diff --git a/test/565-checker-doublenegbitwise/smali/SmaliTests.smali b/test/565-checker-doublenegbitwise/smali/SmaliTests.smali
index 27412f6..549b650 100644
--- a/test/565-checker-doublenegbitwise/smali/SmaliTests.smali
+++ b/test/565-checker-doublenegbitwise/smali/SmaliTests.smali
@@ -76,11 +76,11 @@
 ## CHECK-DAG:       <<BooleanNot:z\d+>>  BooleanNot [<<Or>>]
 ## CHECK-DAG:                            Return [<<BooleanNot>>]
 
-## CHECK-START: boolean SmaliTests.$opt$noinline$booleanAndToOr(boolean, boolean) instruction_simplifier$after_bce (after)
+## CHECK-START: boolean SmaliTests.$opt$noinline$booleanAndToOr(boolean, boolean) instruction_simplifier$before_codegen (after)
 ## CHECK-DAG:                            BooleanNot
 ## CHECK-NOT:                            BooleanNot
 
-## CHECK-START: boolean SmaliTests.$opt$noinline$booleanAndToOr(boolean, boolean) instruction_simplifier$after_bce (after)
+## CHECK-START: boolean SmaliTests.$opt$noinline$booleanAndToOr(boolean, boolean) instruction_simplifier$before_codegen (after)
 ## CHECK-NOT:                            And
 .method public static $opt$noinline$booleanAndToOr(ZZ)Z
     .registers 4
@@ -153,11 +153,11 @@
 ## CHECK-DAG:       <<BooleanNot:z\d+>>  BooleanNot [<<And>>]
 ## CHECK-DAG:                            Return [<<BooleanNot>>]
 
-## CHECK-START: boolean SmaliTests.$opt$noinline$booleanOrToAnd(boolean, boolean) instruction_simplifier$after_bce (after)
+## CHECK-START: boolean SmaliTests.$opt$noinline$booleanOrToAnd(boolean, boolean) instruction_simplifier$before_codegen (after)
 ## CHECK-DAG:                            BooleanNot
 ## CHECK-NOT:                            BooleanNot
 
-## CHECK-START: boolean SmaliTests.$opt$noinline$booleanOrToAnd(boolean, boolean) instruction_simplifier$after_bce (after)
+## CHECK-START: boolean SmaliTests.$opt$noinline$booleanOrToAnd(boolean, boolean) instruction_simplifier$before_codegen (after)
 ## CHECK-NOT:                            Or
 .method public static $opt$noinline$booleanOrToAnd(ZZ)Z
     .registers 4
@@ -277,7 +277,7 @@
 ## CHECK-DAG:       <<Xor:i\d+>>         Xor [<<Cond1>>,<<Cond2>>]
 ## CHECK-DAG:                            Return [<<Xor>>]
 
-## CHECK-START: boolean SmaliTests.$opt$noinline$booleanNotXorToXor(boolean, boolean) instruction_simplifier$after_bce (after)
+## CHECK-START: boolean SmaliTests.$opt$noinline$booleanNotXorToXor(boolean, boolean) instruction_simplifier$before_codegen (after)
 ## CHECK-NOT:                            BooleanNot
 .method public static $opt$noinline$booleanNotXorToXor(ZZ)Z
     .registers 4
@@ -408,11 +408,11 @@
 ## CHECK-DAG:       <<BooleanNot:z\d+>>  BooleanNot [<<Or>>]
 ## CHECK-DAG:                            Return [<<BooleanNot>>]
 
-## CHECK-START: boolean SmaliTests.$opt$noinline$booleanAndToOrV2(boolean, boolean) instruction_simplifier$after_bce (after)
+## CHECK-START: boolean SmaliTests.$opt$noinline$booleanAndToOrV2(boolean, boolean) instruction_simplifier$before_codegen (after)
 ## CHECK-DAG:                            BooleanNot
 ## CHECK-NOT:                            BooleanNot
 
-## CHECK-START: boolean SmaliTests.$opt$noinline$booleanAndToOrV2(boolean, boolean) instruction_simplifier$after_bce (after)
+## CHECK-START: boolean SmaliTests.$opt$noinline$booleanAndToOrV2(boolean, boolean) instruction_simplifier$before_codegen (after)
 ## CHECK-NOT:                            And
 
 # Original java source:
@@ -530,11 +530,11 @@
 ## CHECK-DAG:       <<BooleanNot:z\d+>>  BooleanNot [<<And>>]
 ## CHECK-DAG:                            Return [<<BooleanNot>>]
 
-## CHECK-START: boolean SmaliTests.$opt$noinline$booleanOrToAndV2(boolean, boolean) instruction_simplifier$after_bce (after)
+## CHECK-START: boolean SmaliTests.$opt$noinline$booleanOrToAndV2(boolean, boolean) instruction_simplifier$before_codegen (after)
 ## CHECK-DAG:                            BooleanNot
 ## CHECK-NOT:                            BooleanNot
 
-## CHECK-START: boolean SmaliTests.$opt$noinline$booleanOrToAndV2(boolean, boolean) instruction_simplifier$after_bce (after)
+## CHECK-START: boolean SmaliTests.$opt$noinline$booleanOrToAndV2(boolean, boolean) instruction_simplifier$before_codegen (after)
 ## CHECK-NOT:                            Or
 
 # Original java source:
@@ -717,7 +717,7 @@
 ## CHECK-DAG:       <<Xor:i\d+>>         Xor [<<Cond1>>,<<Cond2>>]
 ## CHECK-DAG:                            Return [<<Xor>>]
 
-## CHECK-START: boolean SmaliTests.$opt$noinline$booleanNotXorToXorV2(boolean, boolean) instruction_simplifier$after_bce (after)
+## CHECK-START: boolean SmaliTests.$opt$noinline$booleanNotXorToXorV2(boolean, boolean) instruction_simplifier$before_codegen (after)
 ## CHECK-NOT:                            BooleanNot
 
 # Original java source:
diff --git a/test/567-checker-builder-intrinsics/src/TestCompare.java b/test/567-checker-builder-intrinsics/src/TestCompare.java
index 185616a..1feb249 100644
--- a/test/567-checker-builder-intrinsics/src/TestCompare.java
+++ b/test/567-checker-builder-intrinsics/src/TestCompare.java
@@ -40,13 +40,13 @@
   /// CHECK-START: int TestCompare.compareBooleans(boolean, boolean) select_generator (after)
   /// CHECK-NOT:                     Phi
 
-  /// CHECK-START: int TestCompare.compareBooleans(boolean, boolean) instruction_simplifier$after_bce (after)
+  /// CHECK-START: int TestCompare.compareBooleans(boolean, boolean) instruction_simplifier$before_codegen (after)
   /// CHECK:         <<ArgX:z\d+>>   ParameterValue
   /// CHECK:         <<ArgY:z\d+>>   ParameterValue
   /// CHECK-DAG:     <<Result:i\d+>> Compare [<<ArgX>>,<<ArgY>>]
   /// CHECK-DAG:                     Return [<<Result>>]
 
-  /// CHECK-START: int TestCompare.compareBooleans(boolean, boolean) instruction_simplifier$after_bce (after)
+  /// CHECK-START: int TestCompare.compareBooleans(boolean, boolean) instruction_simplifier$before_codegen (after)
   /// CHECK-NOT:                     Select
 
   private static int compareBooleans(boolean x, boolean y) {
@@ -77,13 +77,13 @@
   ///  CHECK-START: int TestCompare.compareBooleans2(boolean, boolean) select_generator (after)
   ///  CHECK-NOT:                     Phi
 
-  ///  CHECK-START: int TestCompare.compareBooleans2(boolean, boolean) instruction_simplifier$after_bce (after)
+  ///  CHECK-START: int TestCompare.compareBooleans2(boolean, boolean) instruction_simplifier$before_codegen (after)
   ///  CHECK:         <<ArgX:z\d+>>   ParameterValue
   ///  CHECK:         <<ArgY:z\d+>>   ParameterValue
   ///  CHECK-DAG:     <<Result:i\d+>> Compare [<<ArgX>>,<<ArgY>>]
   ///  CHECK-DAG:                     Return [<<Result>>]
 
-  ///  CHECK-START: int TestCompare.compareBooleans2(boolean, boolean) instruction_simplifier$after_bce (after)
+  ///  CHECK-START: int TestCompare.compareBooleans2(boolean, boolean) instruction_simplifier$before_codegen (after)
   ///  CHECK-NOT:                     Select
 
   private static int compareBooleans2(boolean x, boolean y) {
diff --git a/test/567-checker-builder-intrinsics/src/TestRotate.java b/test/567-checker-builder-intrinsics/src/TestRotate.java
index 0593e60..2037ccf 100644
--- a/test/567-checker-builder-intrinsics/src/TestRotate.java
+++ b/test/567-checker-builder-intrinsics/src/TestRotate.java
@@ -205,14 +205,14 @@
   /// CHECK-START: int TestRotate.rotateLeftBoolean(boolean, int) select_generator (after)
   /// CHECK-NOT:                      Phi
 
-  /// CHECK-START: int TestRotate.rotateLeftBoolean(boolean, int) instruction_simplifier$after_bce (after)
+  /// CHECK-START: int TestRotate.rotateLeftBoolean(boolean, int) instruction_simplifier$before_codegen (after)
   /// CHECK:         <<ArgVal:z\d+>>  ParameterValue
   /// CHECK:         <<ArgDist:i\d+>> ParameterValue
   /// CHECK-DAG:     <<NegDist:i\d+>> Neg [<<ArgDist>>]
   /// CHECK-DAG:     <<Result:i\d+>>  Ror [<<ArgVal>>,<<NegDist>>]
   /// CHECK-DAG:                      Return [<<Result>>]
 
-  /// CHECK-START: int TestRotate.rotateLeftBoolean(boolean, int) instruction_simplifier$after_bce (after)
+  /// CHECK-START: int TestRotate.rotateLeftBoolean(boolean, int) instruction_simplifier$before_codegen (after)
   /// CHECK-NOT:                      Select
 
   private static int rotateLeftBoolean(boolean value, int distance) {
@@ -350,13 +350,13 @@
   /// CHECK-START: int TestRotate.rotateRightBoolean(boolean, int) select_generator (after)
   /// CHECK-NOT:                     Phi
 
-  /// CHECK-START: int TestRotate.rotateRightBoolean(boolean, int) instruction_simplifier$after_bce (after)
+  /// CHECK-START: int TestRotate.rotateRightBoolean(boolean, int) instruction_simplifier$before_codegen (after)
   /// CHECK:         <<ArgVal:z\d+>>  ParameterValue
   /// CHECK:         <<ArgDist:i\d+>> ParameterValue
   /// CHECK-DAG:     <<Result:i\d+>>  Ror [<<ArgVal>>,<<ArgDist>>]
   /// CHECK-DAG:                      Return [<<Result>>]
 
-  /// CHECK-START: int TestRotate.rotateRightBoolean(boolean, int) instruction_simplifier$after_bce (after)
+  /// CHECK-START: int TestRotate.rotateRightBoolean(boolean, int) instruction_simplifier$before_codegen (after)
   /// CHECK-NOT:                     Select
 
   private static int rotateRightBoolean(boolean value, int distance) {
diff --git a/test/567-checker-builder-intrinsics/src/TestSignum.java b/test/567-checker-builder-intrinsics/src/TestSignum.java
index 0a68ac2..ed3c5fe 100644
--- a/test/567-checker-builder-intrinsics/src/TestSignum.java
+++ b/test/567-checker-builder-intrinsics/src/TestSignum.java
@@ -92,13 +92,13 @@
   /// CHECK-START: int TestSignum.signBoolean(boolean) select_generator (after)
   /// CHECK-NOT:                     Phi
 
-  /// CHECK-START: int TestSignum.signBoolean(boolean) instruction_simplifier$after_bce (after)
+  /// CHECK-START: int TestSignum.signBoolean(boolean) instruction_simplifier$before_codegen (after)
   /// CHECK-DAG:     <<Arg:z\d+>>    ParameterValue
   /// CHECK-DAG:     <<Zero:i\d+>>   IntConstant 0
   /// CHECK-DAG:     <<Result:i\d+>> Compare [<<Arg>>,<<Zero>>]
   /// CHECK-DAG:                     Return [<<Result>>]
 
-  /// CHECK-START: int TestSignum.signBoolean(boolean) instruction_simplifier$after_bce (after)
+  /// CHECK-START: int TestSignum.signBoolean(boolean) instruction_simplifier$before_codegen (after)
   /// CHECK-NOT:                     Select
 
   private static int signBoolean(boolean x) {
diff --git a/test/570-checker-osr/smali/Osr.smali b/test/570-checker-osr/smali/Osr.smali
index 857cf64..ee4c7ca 100644
--- a/test/570-checker-osr/smali/Osr.smali
+++ b/test/570-checker-osr/smali/Osr.smali
@@ -19,7 +19,7 @@
 # Check that blocks only havig nops are not merged when they are loop headers.
 # This ensures we can do on-stack replacement for branches to those nop blocks.
 
-## CHECK-START: int Osr.simpleLoop(int, int) dead_code_elimination$after_bce (after)
+## CHECK-START: int Osr.simpleLoop(int, int) dead_code_elimination$before_codegen (after)
 ## CHECK-DAG:                     SuspendCheck loop:<<OuterLoop:B\d+>> outer_loop:none
 ## CHECK-DAG:                     SuspendCheck loop:{{B\d+}} outer_loop:<<OuterLoop>>
 .method public static simpleLoop(II)I
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 bd90fe7..f3f52a8 100644
--- a/test/593-checker-boolean-2-integral-conv/smali/SmaliTests.smali
+++ b/test/593-checker-boolean-2-integral-conv/smali/SmaliTests.smali
@@ -48,7 +48,7 @@
 ##  CHECK-DAG:     <<IToS:b\d+>>          TypeConversion [<<Sel>>]
 ##  CHECK-DAG:                            Return [<<IToS>>]
 
-##  CHECK-START: byte SmaliTests.booleanToByte(boolean) instruction_simplifier$after_bce (after)
+##  CHECK-START: byte SmaliTests.booleanToByte(boolean) instruction_simplifier$before_codegen (after)
 ##  CHECK:         <<Arg:z\d+>>           ParameterValue
 ##  CHECK-DAG:                            Return [<<Arg>>]
 .method static booleanToByte(Z)B
@@ -83,7 +83,7 @@
 ##  CHECK-DAG:     <<IToS:s\d+>>          TypeConversion [<<Sel>>]
 ##  CHECK-DAG:                            Return [<<IToS>>]
 
-##  CHECK-START: short SmaliTests.booleanToShort(boolean) instruction_simplifier$after_bce (after)
+##  CHECK-START: short SmaliTests.booleanToShort(boolean) instruction_simplifier$before_codegen (after)
 ##  CHECK:         <<Arg:z\d+>>           ParameterValue
 ##  CHECK-DAG:                            Return [<<Arg>>]
 .method static booleanToShort(Z)S
@@ -118,7 +118,7 @@
 ##  CHECK-DAG:     <<IToC:c\d+>>          TypeConversion [<<Sel>>]
 ##  CHECK-DAG:                            Return [<<IToC>>]
 
-##  CHECK-START: char SmaliTests.booleanToChar(boolean) instruction_simplifier$after_bce (after)
+##  CHECK-START: char SmaliTests.booleanToChar(boolean) instruction_simplifier$before_codegen (after)
 ##  CHECK:         <<Arg:z\d+>>           ParameterValue
 ##  CHECK-DAG:                            Return [<<Arg>>]
 .method static booleanToChar(Z)C
@@ -151,7 +151,7 @@
 ##  CHECK-DAG:     <<Sel:i\d+>>           Select [<<Zero>>,<<One>>,<<Arg>>]
 ##  CHECK-DAG:                            Return [<<Sel>>]
 
-##  CHECK-START: int SmaliTests.booleanToInt(boolean) instruction_simplifier$after_bce (after)
+##  CHECK-START: int SmaliTests.booleanToInt(boolean) instruction_simplifier$before_codegen (after)
 ##  CHECK:         <<Arg:z\d+>>           ParameterValue
 ##  CHECK-DAG:                            Return [<<Arg>>]
 .method static booleanToInt(Z)I
@@ -185,7 +185,7 @@
 ## CHECK-DAG:     <<IToJ:j\d+>>          TypeConversion [<<Sel>>]
 ## CHECK-DAG:                            Return [<<IToJ>>]
 
-## CHECK-START: long SmaliTests.booleanToLong(boolean) instruction_simplifier$after_bce (after)
+## CHECK-START: long SmaliTests.booleanToLong(boolean) instruction_simplifier$before_codegen (after)
 ## CHECK-DAG:     <<Arg:z\d+>>           ParameterValue
 ## CHECK-DAG:     <<ZToJ:j\d+>>          TypeConversion [<<Arg>>]
 ## CHECK-DAG:                            Return [<<ZToJ>>]
@@ -232,7 +232,7 @@
 ## CHECK-DAG:     <<Sel:i\d+>>           Select [<<Zero>>,<<One>>,<<Sget>>]
 ## CHECK-DAG:                            Return [<<Sel>>]
 
-## CHECK-START: int SmaliTests.longToIntOfBoolean() instruction_simplifier$after_bce (after)
+## CHECK-START: int SmaliTests.longToIntOfBoolean() instruction_simplifier$before_codegen (after)
 ## CHECK-DAG:     <<Sget:z\d+>>          StaticFieldGet
 ## CHECK-DAG:                            Return [<<Sget>>]
 .method public static longToIntOfBoolean()I
diff --git a/test/593-checker-boolean-2-integral-conv/src/Main.java b/test/593-checker-boolean-2-integral-conv/src/Main.java
index b085c42..545f16d 100644
--- a/test/593-checker-boolean-2-integral-conv/src/Main.java
+++ b/test/593-checker-boolean-2-integral-conv/src/Main.java
@@ -32,7 +32,7 @@
     System.out.println("passed");
   }
 
-  /// CHECK-START: byte Main.booleanToByte(boolean) instruction_simplifier$after_bce (after)
+  /// CHECK-START: byte Main.booleanToByte(boolean) instruction_simplifier$before_codegen (after)
   /// CHECK:         <<Arg:z\d+>>           ParameterValue
   /// CHECK-DAG:                            Return [<<Arg>>]
 
@@ -40,7 +40,7 @@
     return (byte)(b ? 1 : 0);
   }
 
-  /// CHECK-START: short Main.booleanToShort(boolean) instruction_simplifier$after_bce (after)
+  /// CHECK-START: short Main.booleanToShort(boolean) instruction_simplifier$before_codegen (after)
   /// CHECK:         <<Arg:z\d+>>           ParameterValue
   /// CHECK-DAG:                            Return [<<Arg>>]
 
@@ -48,7 +48,7 @@
     return (short)(b ? 1 : 0);
   }
 
-  /// CHECK-START: char Main.booleanToChar(boolean) instruction_simplifier$after_bce (after)
+  /// CHECK-START: char Main.booleanToChar(boolean) instruction_simplifier$before_codegen (after)
   /// CHECK:         <<Arg:z\d+>>           ParameterValue
   /// CHECK-DAG:                            Return [<<Arg>>]
 
@@ -56,7 +56,7 @@
     return (char)(b ? 1 : 0);
   }
 
-  /// CHECK-START: int Main.booleanToInt(boolean) instruction_simplifier$after_bce (after)
+  /// CHECK-START: int Main.booleanToInt(boolean) instruction_simplifier$before_codegen (after)
   /// CHECK:         <<Arg:z\d+>>           ParameterValue
   /// CHECK-DAG:                            Return [<<Arg>>]
 
@@ -90,7 +90,7 @@
   // As of now, the code is not optimized any further than the above.
   // TODO: Re-enable checks below after simplifier is updated to handle this pattern: b/63064517
 
-  // CHECK-START: long Main.booleanToLong(boolean) instruction_simplifier$after_bce (after)
+  // CHECK-START: long Main.booleanToLong(boolean) instruction_simplifier$before_codegen (after)
   // CHECK:         <<Arg:z\d+>>           ParameterValue
   // CHECK-DAG:     <<ZToJ:j\d+>>          TypeConversion [<<Arg>>]
   // CHECK-DAG:                            Return [<<ZToJ>>]
@@ -131,7 +131,7 @@
   // As of now, the code is not optimized any further than the above.
   // TODO: Re-enable checks below after simplifier is updated to handle this pattern: b/63064517
 
-  // CHECK-START: int Main.longToIntOfBoolean() instruction_simplifier$after_bce (after)
+  // CHECK-START: int Main.longToIntOfBoolean() instruction_simplifier$before_codegen (after)
   // CHECK-DAG:     <<Sget:z\d+>>          StaticFieldGet
   // CHECK-DAG:                            Return [<<Sget>>]
 
diff --git a/test/593-checker-long-2-float-regression/src/Main.java b/test/593-checker-long-2-float-regression/src/Main.java
index d55d0fd..079ebbc 100644
--- a/test/593-checker-long-2-float-regression/src/Main.java
+++ b/test/593-checker-long-2-float-regression/src/Main.java
@@ -25,25 +25,35 @@
   }
 
   public static void main(String[] args) {
-    assertEquals(1.0F, $noinline$longToFloat());
+    assertEquals(1.0F, $noinline$longToFloat(true));
+    assertEquals(2.0F, $noinline$longToFloat(false));
   }
 
-  /// CHECK-START: float Main.$noinline$longToFloat() register (after)
-  /// CHECK-DAG:     <<Const1:j\d+>>   LongConstant 1
-  /// CHECK-DAG:     <<Convert:f\d+>>  TypeConversion [<<Const1>>]
-  /// CHECK-DAG:                       Return [<<Convert>>]
+  /// CHECK-START: float Main.$noinline$longToFloat(boolean) register (after)
+  /// CHECK:     <<Get:j\d+>>      StaticFieldGet field_name:Main.longValue
+  /// CHECK:     <<Convert:f\d+>>  TypeConversion [<<Get>>]
+  /// CHECK:                       Return [<<Convert>>]
 
-  static float $noinline$longToFloat() {
-    longValue = $inline$returnConst();
+  static float $noinline$longToFloat(boolean param) {
+    // This if else is to avoid constant folding the long constant into a float constant.
+    if (param) {
+      longValue = $inline$returnConstOne();
+    } else {
+      longValue = $inline$returnConstTwo();
+    }
     // This call prevents D8 from replacing the result of the sget instruction
-    // in line 41 by the result of the call to $inline$returnConst() in line 39.
+    // in the return below by the result of the call to $inline$returnConstOne/Two() above.
     $inline$preventRedundantFieldLoadEliminationInD8();
     return (float) longValue;
   }
 
-  static long $inline$returnConst() {
+  static long $inline$returnConstOne() {
     return 1L;
   }
 
+  static long $inline$returnConstTwo() {
+    return 2L;
+  }
+
   static void $inline$preventRedundantFieldLoadEliminationInD8() {}
 }
diff --git a/test/618-checker-induction/src/Main.java b/test/618-checker-induction/src/Main.java
index d15de18..5dc8e98 100644
--- a/test/618-checker-induction/src/Main.java
+++ b/test/618-checker-induction/src/Main.java
@@ -227,7 +227,7 @@
     /// CHECK-START: int Main.closedFormInductionUp() loop_optimization (after)
     /// CHECK-NOT:               Phi
     //
-    /// CHECK-START: int Main.closedFormInductionUp() instruction_simplifier$after_bce (after)
+    /// CHECK-START: int Main.closedFormInductionUp() instruction_simplifier$before_codegen (after)
     /// CHECK-DAG: <<Int:i\d+>>  IntConstant 12395 loop:none
     /// CHECK-DAG:               Return [<<Int>>]  loop:none
     static int closedFormInductionUp() {
@@ -246,7 +246,7 @@
     /// CHECK-START: int Main.closedFormInductionInAndDown(int) loop_optimization (after)
     /// CHECK-NOT:               Phi
     //
-    /// CHECK-START: int Main.closedFormInductionInAndDown(int) instruction_simplifier$after_bce (after)
+    /// CHECK-START: int Main.closedFormInductionInAndDown(int) instruction_simplifier$before_codegen (after)
     /// CHECK-DAG: <<Par:i\d+>>  ParameterValue        loop:none
     /// CHECK-DAG: <<Int:i\d+>>  IntConstant -50       loop:none
     /// CHECK-DAG: <<Add:i\d+>>  Add [<<Int>>,<<Par>>] loop:none
@@ -268,7 +268,7 @@
     /// CHECK-NOT:               Phi
     /// CHECK-NOT:               Select
     //
-    /// CHECK-START: int Main.closedFormInductionTrivialIf() instruction_simplifier$after_bce (after)
+    /// CHECK-START: int Main.closedFormInductionTrivialIf() instruction_simplifier$before_codegen (after)
     /// CHECK-DAG: <<Int:i\d+>>  IntConstant 81    loop:none
     /// CHECK-DAG:               Return [<<Int>>]  loop:none
     static int closedFormInductionTrivialIf() {
@@ -295,7 +295,7 @@
     /// CHECK-START: int Main.closedFormNested() loop_optimization (after)
     /// CHECK-NOT:               Phi
     //
-    /// CHECK-START: int Main.closedFormNested() instruction_simplifier$after_bce (after)
+    /// CHECK-START: int Main.closedFormNested() instruction_simplifier$before_codegen (after)
     /// CHECK-DAG: <<Int:i\d+>>  IntConstant 100  loop:none
     /// CHECK-DAG:               Return [<<Int>>] loop:none
     static int closedFormNested() {
@@ -318,7 +318,7 @@
     /// CHECK-START: int Main.closedFormNestedAlt() loop_optimization (after)
     /// CHECK-NOT:               Phi
     //
-    /// CHECK-START: int Main.closedFormNestedAlt() instruction_simplifier$after_bce (after)
+    /// CHECK-START: int Main.closedFormNestedAlt() instruction_simplifier$before_codegen (after)
     /// CHECK-DAG: <<Int:i\d+>>  IntConstant 15082 loop:none
     /// CHECK-DAG:               Return [<<Int>>]  loop:none
     static int closedFormNestedAlt() {
@@ -399,7 +399,7 @@
     /// CHECK-START: int Main.mainIndexReturned() loop_optimization (after)
     /// CHECK-NOT:              Phi
     //
-    /// CHECK-START: int Main.mainIndexReturned() instruction_simplifier$after_bce (after)
+    /// CHECK-START: int Main.mainIndexReturned() instruction_simplifier$before_codegen (after)
     /// CHECK-DAG: <<Int:i\d+>>  IntConstant 10   loop:none
     /// CHECK-DAG:               Return [<<Int>>] loop:none
     static int mainIndexReturned() {
@@ -416,7 +416,7 @@
     /// CHECK-START: int Main.periodicReturned9() loop_optimization (after)
     /// CHECK-NOT:               Phi
     //
-    /// CHECK-START: int Main.periodicReturned9() instruction_simplifier$after_bce (after)
+    /// CHECK-START: int Main.periodicReturned9() instruction_simplifier$before_codegen (after)
     /// CHECK-DAG: <<Int:i\d+>>  IntConstant 1    loop:none
     /// CHECK-DAG:               Return [<<Int>>] loop:none
     static int periodicReturned9() {
@@ -435,7 +435,7 @@
     /// CHECK-START: int Main.periodicReturned10() loop_optimization (after)
     /// CHECK-NOT:               Phi
     //
-    /// CHECK-START: int Main.periodicReturned10() instruction_simplifier$after_bce (after)
+    /// CHECK-START: int Main.periodicReturned10() instruction_simplifier$before_codegen (after)
     /// CHECK-DAG: <<Int:i\d+>>  IntConstant 0    loop:none
     /// CHECK-DAG:               Return [<<Int>>] loop:none
     static int periodicReturned10() {
@@ -455,7 +455,7 @@
     /// CHECK-START: int Main.getSum21() loop_optimization (after)
     /// CHECK-NOT:               Phi
     //
-    /// CHECK-START: int Main.getSum21() instruction_simplifier$after_bce (after)
+    /// CHECK-START: int Main.getSum21() instruction_simplifier$before_codegen (after)
     /// CHECK-DAG: <<Int:i\d+>>  IntConstant 21   loop:none
     /// CHECK-DAG:               Return [<<Int>>] loop:none
     private static int getSum21() {
@@ -553,7 +553,7 @@
     /// CHECK-START: int Main.closedFeed() loop_optimization (after)
     /// CHECK-NOT:               Phi
     //
-    /// CHECK-START: int Main.closedFeed() instruction_simplifier$after_bce (after)
+    /// CHECK-START: int Main.closedFeed() instruction_simplifier$before_codegen (after)
     /// CHECK-DAG: <<Int:i\d+>>  IntConstant 20   loop:none
     /// CHECK-DAG:               Return [<<Int>>] loop:none
     private static int closedFeed() {
@@ -577,7 +577,7 @@
     /// CHECK-START: int Main.closedLargeUp() loop_optimization (after)
     /// CHECK-NOT:               Phi
     //
-    /// CHECK-START: int Main.closedLargeUp() instruction_simplifier$after_bce (after)
+    /// CHECK-START: int Main.closedLargeUp() instruction_simplifier$before_codegen (after)
     /// CHECK-DAG: <<Int:i\d+>>  IntConstant -10  loop:none
     /// CHECK-DAG:               Return [<<Int>>] loop:none
     private static int closedLargeUp() {
@@ -596,7 +596,7 @@
     /// CHECK-START: int Main.closedLargeDown() loop_optimization (after)
     /// CHECK-NOT:               Phi
     //
-    /// CHECK-START: int Main.closedLargeDown() instruction_simplifier$after_bce (after)
+    /// CHECK-START: int Main.closedLargeDown() instruction_simplifier$before_codegen (after)
     /// CHECK-DAG: <<Int:i\d+>>  IntConstant 10   loop:none
     /// CHECK-DAG:               Return [<<Int>>] loop:none
     private static int closedLargeDown() {
@@ -656,7 +656,7 @@
     /// CHECK-START: int Main.closedByParametersWithInline() loop_optimization (after)
     /// CHECK-NOT:               Phi
     //
-    /// CHECK-START: int Main.closedByParametersWithInline() instruction_simplifier$after_bce (after)
+    /// CHECK-START: int Main.closedByParametersWithInline() instruction_simplifier$before_codegen (after)
     /// CHECK-DAG: <<Int:i\d+>>  IntConstant 10   loop:none
     /// CHECK-DAG:               Return [<<Int>>] loop:none
     private static int closedByParametersWithInline() {
@@ -674,7 +674,7 @@
     /// CHECK-START: int Main.waterFall() loop_optimization (after)
     /// CHECK-NOT:               Phi
     //
-    /// CHECK-START: int Main.waterFall() instruction_simplifier$after_bce (after)
+    /// CHECK-START: int Main.waterFall() instruction_simplifier$before_codegen (after)
     /// CHECK-DAG: <<Int:i\d+>>  IntConstant 50   loop:none
     /// CHECK-DAG:               Return [<<Int>>] loop:none
     private static int waterFall() {
@@ -695,7 +695,7 @@
     /// CHECK-START: boolean Main.periodicBoolIdiom1() loop_optimization (after)
     /// CHECK-NOT:               Phi
     //
-    /// CHECK-START: boolean Main.periodicBoolIdiom1() instruction_simplifier$after_bce (after)
+    /// CHECK-START: boolean Main.periodicBoolIdiom1() instruction_simplifier$before_codegen (after)
     /// CHECK-DAG: <<Int:i\d+>>  IntConstant 0    loop:none
     /// CHECK-DAG:               Return [<<Int>>] loop:none
     private static boolean periodicBoolIdiom1() {
@@ -714,7 +714,7 @@
     /// CHECK-START: boolean Main.periodicBoolIdiom2() loop_optimization (after)
     /// CHECK-NOT:               Phi
     //
-    /// CHECK-START: boolean Main.periodicBoolIdiom2() instruction_simplifier$after_bce (after)
+    /// CHECK-START: boolean Main.periodicBoolIdiom2() instruction_simplifier$before_codegen (after)
     /// CHECK-DAG: <<Int:i\d+>>  IntConstant 0    loop:none
     /// CHECK-DAG:               Return [<<Int>>] loop:none
     private static boolean periodicBoolIdiom2() {
@@ -733,7 +733,7 @@
     /// CHECK-START: boolean Main.periodicBoolIdiom3() loop_optimization (after)
     /// CHECK-NOT:               Phi
     //
-    /// CHECK-START: boolean Main.periodicBoolIdiom3() instruction_simplifier$after_bce (after)
+    /// CHECK-START: boolean Main.periodicBoolIdiom3() instruction_simplifier$before_codegen (after)
     /// CHECK-DAG: <<Int:i\d+>>  IntConstant 0    loop:none
     /// CHECK-DAG:               Return [<<Int>>] loop:none
     private static boolean periodicBoolIdiom3() {
diff --git a/test/623-checker-loop-regressions/src/Main.java b/test/623-checker-loop-regressions/src/Main.java
index 3f3a12c..2b280bb 100644
--- a/test/623-checker-loop-regressions/src/Main.java
+++ b/test/623-checker-loop-regressions/src/Main.java
@@ -155,7 +155,7 @@
   /// CHECK-START: int Main.polynomialInt() loop_optimization (after)
   /// CHECK-NOT: Phi
   //
-  /// CHECK-START: int Main.polynomialInt() instruction_simplifier$after_bce (after)
+  /// CHECK-START: int Main.polynomialInt() instruction_simplifier$before_codegen (after)
   /// CHECK-DAG: <<Int:i\d+>>  IntConstant -45  loop:none
   /// CHECK-DAG:               Return [<<Int>>] loop:none
   static int polynomialInt() {
@@ -176,7 +176,7 @@
   /// CHECK-START: int Main.geoIntDivLastValue(int) loop_optimization (after)
   /// CHECK-NOT: Phi
   //
-  /// CHECK-START: int Main.geoIntDivLastValue(int) instruction_simplifier$after_bce (after)
+  /// CHECK-START: int Main.geoIntDivLastValue(int) instruction_simplifier$before_codegen (after)
   /// CHECK-DAG: <<Int:i\d+>> IntConstant 0    loop:none
   /// CHECK-DAG:              Return [<<Int>>] loop:none
   static int geoIntDivLastValue(int x) {
@@ -193,7 +193,7 @@
   /// CHECK-START: int Main.geoIntMulLastValue(int) loop_optimization (after)
   /// CHECK-NOT: Phi
   //
-  /// CHECK-START: int Main.geoIntMulLastValue(int) instruction_simplifier$after_bce (after)
+  /// CHECK-START: int Main.geoIntMulLastValue(int) instruction_simplifier$before_codegen (after)
   /// CHECK-DAG: <<Par:i\d+>> ParameterValue         loop:none
   /// CHECK-DAG: <<Int:i\d+>> IntConstant -194211840 loop:none
   /// CHECK-DAG: <<Mul:i\d+>> Mul [<<Par>>,<<Int>>]  loop:none
@@ -212,7 +212,7 @@
   /// CHECK-START: long Main.geoLongDivLastValue(long) loop_optimization (after)
   /// CHECK-NOT: Phi
   //
-  /// CHECK-START: long Main.geoLongDivLastValue(long) instruction_simplifier$after_bce (after)
+  /// CHECK-START: long Main.geoLongDivLastValue(long) instruction_simplifier$before_codegen (after)
   /// CHECK-DAG: <<Long:j\d+>> LongConstant 0    loop:none
   /// CHECK-DAG:               Return [<<Long>>] loop:none
   //
@@ -231,7 +231,7 @@
   /// CHECK-START: long Main.geoLongDivLastValue() loop_optimization (after)
   /// CHECK-NOT: Phi
   //
-  /// CHECK-START: long Main.geoLongDivLastValue() instruction_simplifier$after_bce (after)
+  /// CHECK-START: long Main.geoLongDivLastValue() instruction_simplifier$before_codegen (after)
   /// CHECK-DAG: <<Long:j\d+>> LongConstant 0    loop:none
   /// CHECK-DAG:               Return [<<Long>>] loop:none
   //
@@ -251,7 +251,7 @@
   /// CHECK-START: long Main.geoLongMulLastValue(long) loop_optimization (after)
   /// CHECK-NOT: Phi
   //
-  /// CHECK-START: long Main.geoLongMulLastValue(long) instruction_simplifier$after_bce (after)
+  /// CHECK-START: long Main.geoLongMulLastValue(long) instruction_simplifier$before_codegen (after)
   /// CHECK-DAG: <<Par:j\d+>>  ParameterValue                    loop:none
   /// CHECK-DAG: <<Long:j\d+>> LongConstant -8070450532247928832 loop:none
   /// CHECK-DAG: <<Mul:j\d+>>  Mul [<<Par>>,<<Long>>]            loop:none
diff --git a/test/627-checker-unroll/src/Main.java b/test/627-checker-unroll/src/Main.java
index 9785bdc..413de8e 100644
--- a/test/627-checker-unroll/src/Main.java
+++ b/test/627-checker-unroll/src/Main.java
@@ -29,7 +29,7 @@
   /// CHECK-START: void Main.unroll() loop_optimization (after)
   /// CHECK-DAG: StaticFieldSet loop:none
   //
-  /// CHECK-START: void Main.unroll() instruction_simplifier$after_bce (after)
+  /// CHECK-START: void Main.unroll() instruction_simplifier$before_codegen (after)
   /// CHECK-DAG: <<Int:i\d+>> IntConstant    68                  loop:none
   /// CHECK-DAG:              StaticFieldSet [{{l\d+}},<<Int>>]  loop:none
   //
@@ -49,7 +49,7 @@
   /// CHECK-START: int Main.unrollLV() loop_optimization (after)
   /// CHECK-DAG: StaticFieldSet loop:none
   //
-  /// CHECK-START: int Main.unrollLV() instruction_simplifier$after_bce (after)
+  /// CHECK-START: int Main.unrollLV() instruction_simplifier$before_codegen (after)
   /// CHECK-DAG: <<Int1:i\d+>> IntConstant    187                 loop:none
   /// CHECK-DAG: <<Int2:i\d+>> IntConstant    12                  loop:none
   /// CHECK-DAG:               StaticFieldSet [{{l\d+}},<<Int1>>] loop:none
@@ -80,7 +80,7 @@
   /// CHECK-DAG: SuspendCheck   loop:none
   /// CHECK-NOT: SuspendCheck
   //
-  /// CHECK-START: void Main.unrollNest() instruction_simplifier$after_bce (after)
+  /// CHECK-START: void Main.unrollNest() instruction_simplifier$before_codegen (after)
   /// CHECK-DAG: <<Int:i\d+>> IntConstant    6                   loop:none
   /// CHECK-DAG:              StaticFieldSet [{{l\d+}},<<Int>>]  loop:none
   //
diff --git a/test/646-checker-long-const-to-int/src/Main.java b/test/646-checker-long-const-to-int/src/Main.java
index 85738dc..2133588 100644
--- a/test/646-checker-long-const-to-int/src/Main.java
+++ b/test/646-checker-long-const-to-int/src/Main.java
@@ -15,42 +15,47 @@
  */
 
 public class Main {
-
-  public static void main(String[] args) {
-    System.out.println(test());
-  }
-
-  public static long testField = 0;
-  public static long longField0 = 0;
-  public static long longField1 = 0;
-  public static long longField2 = 0;
-  public static long longField3 = 0;
-  public static long longField4 = 0;
-  public static long longField5 = 0;
-  public static long longField6 = 0;
-  public static long longField7 = 0;
-
-  /// CHECK-START-ARM: int Main.test() register (after)
-  /// CHECK: TypeConversion locations:[#-8690466096623102344]->{{.*}}
-  public static int test() {
-    // To avoid constant folding TypeConversion(const), hide the constant in a field.
-    // We do not run constant folding after load-store-elimination.
-    testField = 0x8765432112345678L;
-    long value = testField;
-    // Now, the `value` is in a register because of the store but we need
-    // a constant location to trigger the bug, so load a bunch of other fields.
-    long l0 = longField0;
-    long l1 = longField1;
-    long l2 = longField2;
-    long l3 = longField3;
-    long l4 = longField4;
-    long l5 = longField5;
-    long l6 = longField6;
-    long l7 = longField7;
-    if (l0 != 0 || l1 != 0 || l2 != 0 || l3 != 0 || l4 != 0 || l5 != 0 || l6 != 0 || l7 != 0) {
-      throw new Error();
+    public static void main(String[] args) {
+        System.out.println(test());
     }
-    // Do the conversion from constant location.
-    return (int)value;
-  }
+
+    public static long testField = 0;
+    public static long longField0 = 0;
+    public static long longField1 = 0;
+    public static long longField2 = 0;
+    public static long longField3 = 0;
+    public static long longField4 = 0;
+    public static long longField5 = 0;
+    public static long longField6 = 0;
+    public static long longField7 = 0;
+
+    /// CHECK-START-ARM: int Main.test() register (after)
+    /// CHECK: TypeConversion locations:[#-8690466096623102344]->{{.*}}
+    public static int test() {
+        // To avoid constant folding TypeConversion(const), hide the constant in a field. Then, hide
+        // it even more inside a Select that can only be reduced after LSE+InstructionSelector. We
+        // don't run constant folding after that.
+        testField = 0x8765432112345678L;
+        long value = testField;
+        if (value + 1 == 0x8765432112345679L) {
+            value = testField;
+        } else {
+            value = 0;
+        }
+        // Now, the `value` is in a register because of the store but we need
+        // a constant location to trigger the bug, so load a bunch of other fields.
+        long l0 = longField0;
+        long l1 = longField1;
+        long l2 = longField2;
+        long l3 = longField3;
+        long l4 = longField4;
+        long l5 = longField5;
+        long l6 = longField6;
+        long l7 = longField7;
+        if (l0 != 0 || l1 != 0 || l2 != 0 || l3 != 0 || l4 != 0 || l5 != 0 || l6 != 0 || l7 != 0) {
+            throw new Error();
+        }
+        // Do the conversion from constant location.
+        return (int) value;
+    }
 }