diff options
| author | 2018-04-18 16:11:12 -0700 | |
|---|---|---|
| committer | 2018-04-30 08:58:32 -0700 | |
| commit | 2e14868d43b4f8c21f8567f336a9bf1a2576dc1b (patch) | |
| tree | 3f17fc543c912e66ea937cd77b760f92faa4ea32 | |
| parent | 5503d264ac1b5dd23df4079dc14f26919de42bec (diff) | |
Step 2 of 2: conditional passes.
Rationale:
The change introduces actual conditional passes
(dependence on inliner). This ensures more
cases are optimized downstream without
needlessly introducing compile-time.
NOTE:
Some checker tests needed to be rewritten
due to subtle changes in the phase ordering.
No optimizations were harmed in the process,
though.
Bug: b/78171933, b/74026074
Test: test-art-host,target
Change-Id: I335260df780e14ba1f22499ad74d79060c7be44d
18 files changed, 416 insertions, 308 deletions
diff --git a/compiler/optimizing/optimization.cc b/compiler/optimizing/optimization.cc index 57db7a634c..d37c43db81 100644 --- a/compiler/optimizing/optimization.cc +++ b/compiler/optimizing/optimization.cc @@ -121,12 +121,15 @@ const char* OptimizationPassName(OptimizationPass pass) { 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 @@ OptimizationPass OptimizationPassByName(const std::string& name) { 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 @@ ArenaVector<HOptimization*> ConstructOptimizations( // 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 @@ ArenaVector<HOptimization*> ConstructOptimizations( // 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 @@ ArenaVector<HOptimization*> ConstructOptimizations( /* 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 @@ ArenaVector<HOptimization*> ConstructOptimizations( 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 b00d686e5f..88b283cebf 100644 --- a/compiler/optimizing/optimization.h +++ b/compiler/optimizing/optimization.h @@ -102,21 +102,32 @@ enum class OptimizationPass { #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 f68bcbe59f..a6163a7fcf 100644 --- a/compiler/optimizing/optimizing_compiler.cc +++ b/compiler/optimizing/optimizing_compiler.cc @@ -313,11 +313,22 @@ class OptimizingCompiler FINAL : public Compiler { 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 @@ void OptimizingCompiler::RunOptimizations(HGraph* graph, 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 @@ void OptimizingCompiler::RunOptimizations(HGraph* graph, } 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 95c19eaabc..fcc3c1a852 100644 --- a/test/442-checker-constant-folding/src/Main.java +++ b/test/442-checker-constant-folding/src/Main.java @@ -991,15 +991,23 @@ public class Main { /// 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 444b4557ce..b24cfcb775 100644 --- a/test/458-checker-instruct-simplification/src/Main.java +++ b/test/458-checker-instruct-simplification/src/Main.java @@ -882,7 +882,7 @@ public class Main { /// 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 @@ public class Main { 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-START: boolean Main.$noinline$EqualBoolVsIntConst(boolean) instruction_simplifier$after_inlining (after) + /// 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) dead_code_elimination$after_inlining (after) /// CHECK-DAG: <<True:i\d+>> IntConstant 1 /// CHECK-DAG: Return [<<True>>] @@ -1157,12 +1159,14 @@ public class Main { /// 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-START: boolean Main.$noinline$NotEqualBoolVsIntConst(boolean) instruction_simplifier$after_inlining (after) + /// 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) dead_code_elimination$after_inlining (after) /// CHECK-DAG: <<False:i\d+>> IntConstant 0 /// CHECK-DAG: Return [<<False>>] @@ -1198,28 +1202,14 @@ public class Main { /// 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-START: boolean Main.$noinline$NotNotBool(boolean) instruction_simplifier$after_inlining (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-DAG: If [<<Arg>>] + /// CHECK-DAG: <<Phi:i\d+>> Phi [<<Const1>>,<<Const0>>] + /// CHECK-DAG: Return [<<Phi>>] - /// CHECK-START: boolean Main.$noinline$NotNotBool(boolean) dead_code_elimination$final (after) + /// CHECK-START: boolean Main.$noinline$NotNotBool(boolean) instruction_simplifier$after_gvn (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 @@ public class Main { /// 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 @@ public class Main { /// 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 @@ public class Main { /// 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-START: int Main.$noinline$intConditionNotEqualOne(int) instruction_simplifier$after_inlining (after) + /// 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) 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 @@ public class Main { /// 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-START: int Main.$noinline$intConditionEqualZero(int) instruction_simplifier$after_inlining (after) + /// 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) 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 @@ public class Main { /// 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 cda6f73861..5290bad3ed 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 f50e01e51b..7ad9ba8e64 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 fb76904677..b3e4a60e9a 100644 --- a/test/551-checker-shifter-operand/src/Main.java +++ b/test/551-checker-shifter-operand/src/Main.java @@ -728,9 +728,41 @@ public class Main { /// 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 @@ public class Main { /// 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 @@ public class Main { /// 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 80358cd2ba..e36a2bab40 100644 --- a/test/565-checker-doublenegbitwise/src/Main.java +++ b/test/565-checker-doublenegbitwise/src/Main.java @@ -94,7 +94,7 @@ public class Main { * 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 @@ public class Main { /// 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 @@ public class Main { * 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 @@ public class Main { /// 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 @@ public class Main { * 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 @@ public class Main { /// 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 494ab95434..f74e88f580 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 61c0adf624..b318168713 100644 --- a/test/631-checker-get-class/src/Main.java +++ b/test/631-checker-get-class/src/Main.java @@ -34,11 +34,14 @@ public class Main { } /// 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 @@ public class Main { } /// 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 @@ public class Main { } /// 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 @@ public class Main { } /// 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 cd7fbcbdb9..bcd62c4852 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 @@ public class Main { 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 @@ public class Main { 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 @@ public class Main { 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 @@ public class Main { 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 @@ public class Main { 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 @@ public class Main { 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 ecf748ae07..998ec33119 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 @@ public class Main { 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 @@ public class Main { 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 @@ public class Main { 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 @@ public class Main { 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 @@ public class Main { 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 @@ public class Main { 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 280dd66a51..09878a5052 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 @@ public class Main { 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 @@ public class Main { 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 @@ public class Main { 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 @@ public class Main { 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 @@ public class Main { 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 @@ public class Main { 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 @@ public class Main { 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 ca0f4b71dd..b9eeb5ff81 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 @@ public class Main { 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 @@ public class Main { 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 @@ public class Main { 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 b712a146f4..0a1a4dc92e 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 @@ public class Main { 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 @@ public class Main { 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 @@ public class Main { 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 @@ public class Main { 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 @@ public class Main { 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 @@ public class Main { 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 48de1da291..abf8c279da 100644 --- a/test/679-checker-minmax/src/Main.java +++ b/test/679-checker-minmax/src/Main.java @@ -99,211 +99,211 @@ public class Main { // 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 @@ public class Main { // 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 @@ public class Main { 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 @@ public class Main { 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 @@ public class Main { /// 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 @@ public class Main { /// 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 @@ public class Main { 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 @@ public class Main { /// 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 @@ public class Main { /// 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 @@ public class Main { 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 @@ public class Main { /// 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 @@ public class Main { /// 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 @@ public class Main { /// 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 @@ public class Main { /// 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 @@ public class Main { 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 2b95a8d56e..00390c3145 100644 --- a/test/681-checker-abs/src/Main.java +++ b/test/681-checker-abs/src/Main.java @@ -59,7 +59,7 @@ public class Main { // 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 @@ public class Main { /// 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 @@ public class Main { /// 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 @@ public class Main { /// 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 @@ public class Main { /// 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 @@ public class Main { /// 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 @@ public class Main { /// 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 @@ public class Main { /// 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 @@ public class Main { // 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 @@ public class Main { /// 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 @@ public class Main { /// 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) { |