diff options
42 files changed, 536 insertions, 355 deletions
diff --git a/compiler/driver/compiler_options.cc b/compiler/driver/compiler_options.cc index a522e0c7b5..30ba8c9e74 100644 --- a/compiler/driver/compiler_options.cc +++ b/compiler/driver/compiler_options.cc @@ -45,7 +45,8 @@ CompilerOptions::CompilerOptions() dump_cfg_file_name_(""), dump_cfg_append_(false), force_determinism_(false), - register_allocation_strategy_(RegisterAllocator::kRegisterAllocatorDefault) { + register_allocation_strategy_(RegisterAllocator::kRegisterAllocatorDefault), + passes_to_run_(nullptr) { } CompilerOptions::~CompilerOptions() { @@ -76,7 +77,8 @@ CompilerOptions::CompilerOptions(CompilerFilter::Filter compiler_filter, const std::string& dump_cfg_file_name, bool dump_cfg_append, bool force_determinism, - RegisterAllocator::Strategy regalloc_strategy + RegisterAllocator::Strategy regalloc_strategy, + const std::vector<std::string>* passes_to_run ) : // NOLINT(whitespace/parens) compiler_filter_(compiler_filter), huge_method_threshold_(huge_method_threshold), @@ -102,7 +104,8 @@ CompilerOptions::CompilerOptions(CompilerFilter::Filter compiler_filter, dump_cfg_file_name_(dump_cfg_file_name), dump_cfg_append_(dump_cfg_append), force_determinism_(force_determinism), - register_allocation_strategy_(regalloc_strategy) { + register_allocation_strategy_(regalloc_strategy), + passes_to_run_(passes_to_run) { } void CompilerOptions::ParseHugeMethodMax(const StringPiece& option, UsageFn Usage) { diff --git a/compiler/driver/compiler_options.h b/compiler/driver/compiler_options.h index cc66d7a577..abc58d7dda 100644 --- a/compiler/driver/compiler_options.h +++ b/compiler/driver/compiler_options.h @@ -76,7 +76,8 @@ class CompilerOptions FINAL { const std::string& dump_cfg_file_name, bool dump_cfg_append, bool force_determinism, - RegisterAllocator::Strategy regalloc_strategy); + RegisterAllocator::Strategy regalloc_strategy, + const std::vector<std::string>* passes_to_run); CompilerFilter::Filter GetCompilerFilter() const { return compiler_filter_; @@ -250,6 +251,10 @@ class CompilerOptions FINAL { return register_allocation_strategy_; } + const std::vector<std::string>* GetPassesToRun() const { + return passes_to_run_; + } + private: void ParseDumpInitFailures(const StringPiece& option, UsageFn Usage); void ParseDumpCfgPasses(const StringPiece& option, UsageFn Usage); @@ -306,6 +311,14 @@ class CompilerOptions FINAL { RegisterAllocator::Strategy register_allocation_strategy_; + // If not null, specifies optimization passes which will be run instead of defaults. + // Note that passes_to_run_ is not checked for correctness and providing an incorrect + // list of passes can lead to unexpected compiler behaviour. This is caused by dependencies + // between passes. Failing to satisfy them can for example lead to compiler crashes. + // Passing pass names which are not recognized by the compiler will result in + // compiler-dependant behavior. + const std::vector<std::string>* passes_to_run_; + friend class Dex2Oat; DISALLOW_COPY_AND_ASSIGN(CompilerOptions); diff --git a/compiler/jit/jit_compiler.cc b/compiler/jit/jit_compiler.cc index 2dd87a8483..6f6a8f5a3b 100644 --- a/compiler/jit/jit_compiler.cc +++ b/compiler/jit/jit_compiler.cc @@ -112,7 +112,8 @@ JitCompiler::JitCompiler() { /* dump_cfg_file_name */ "", /* dump_cfg_append */ false, /* force_determinism */ false, - RegisterAllocator::kRegisterAllocatorDefault)); + RegisterAllocator::kRegisterAllocatorDefault, + /* passes_to_run */ nullptr)); for (const std::string& argument : Runtime::Current()->GetCompilerOptions()) { compiler_options_->ParseCompilerOption(argument, Usage); } diff --git a/compiler/optimizing/dead_code_elimination.h b/compiler/optimizing/dead_code_elimination.h index 0ce0ec1402..58e700deba 100644 --- a/compiler/optimizing/dead_code_elimination.h +++ b/compiler/optimizing/dead_code_elimination.h @@ -31,13 +31,11 @@ class HDeadCodeElimination : public HOptimization { public: HDeadCodeElimination(HGraph* graph, OptimizingCompilerStats* stats = nullptr, - const char* name = kInitialDeadCodeEliminationPassName) + const char* name = kDeadCodeEliminationPassName) : HOptimization(graph, name, stats) {} void Run() OVERRIDE; - - static constexpr const char* kInitialDeadCodeEliminationPassName = "dead_code_elimination"; - static constexpr const char* kFinalDeadCodeEliminationPassName = "dead_code_elimination_final"; + static constexpr const char* kDeadCodeEliminationPassName = "dead_code_elimination"; private: void MaybeRecordDeadBlock(HBasicBlock* block); diff --git a/compiler/optimizing/dex_cache_array_fixups_arm.h b/compiler/optimizing/dex_cache_array_fixups_arm.h index 015f910328..9142e29eff 100644 --- a/compiler/optimizing/dex_cache_array_fixups_arm.h +++ b/compiler/optimizing/dex_cache_array_fixups_arm.h @@ -26,7 +26,9 @@ namespace arm { class DexCacheArrayFixups : public HOptimization { public: DexCacheArrayFixups(HGraph* graph, OptimizingCompilerStats* stats) - : HOptimization(graph, "dex_cache_array_fixups_arm", stats) {} + : HOptimization(graph, kDexCacheArrayFixupsArmPassName, stats) {} + + static constexpr const char* kDexCacheArrayFixupsArmPassName = "dex_cache_array_fixups_arm"; void Run() OVERRIDE; }; diff --git a/compiler/optimizing/dex_cache_array_fixups_mips.h b/compiler/optimizing/dex_cache_array_fixups_mips.h index 21056e130a..861a199d6c 100644 --- a/compiler/optimizing/dex_cache_array_fixups_mips.h +++ b/compiler/optimizing/dex_cache_array_fixups_mips.h @@ -29,9 +29,11 @@ namespace mips { class DexCacheArrayFixups : public HOptimization { public: DexCacheArrayFixups(HGraph* graph, CodeGenerator* codegen, OptimizingCompilerStats* stats) - : HOptimization(graph, "dex_cache_array_fixups_mips", stats), + : HOptimization(graph, kDexCacheArrayFixupsMipsPassName, stats), codegen_(codegen) {} + static constexpr const char* kDexCacheArrayFixupsMipsPassName = "dex_cache_array_fixups_mips"; + void Run() OVERRIDE; private: diff --git a/compiler/optimizing/induction_var_analysis.h b/compiler/optimizing/induction_var_analysis.h index 7c74816c26..cd4c830645 100644 --- a/compiler/optimizing/induction_var_analysis.h +++ b/compiler/optimizing/induction_var_analysis.h @@ -39,9 +39,9 @@ class HInductionVarAnalysis : public HOptimization { void Run() OVERRIDE; - private: static constexpr const char* kInductionPassName = "induction_var_analysis"; + private: struct NodeInfo { explicit NodeInfo(uint32_t d) : depth(d), done(false) {} uint32_t depth; diff --git a/compiler/optimizing/instruction_simplifier_arm.h b/compiler/optimizing/instruction_simplifier_arm.h index 3d297dacc0..782110c40a 100644 --- a/compiler/optimizing/instruction_simplifier_arm.h +++ b/compiler/optimizing/instruction_simplifier_arm.h @@ -48,7 +48,9 @@ class InstructionSimplifierArmVisitor : public HGraphVisitor { class InstructionSimplifierArm : public HOptimization { public: InstructionSimplifierArm(HGraph* graph, OptimizingCompilerStats* stats) - : HOptimization(graph, "instruction_simplifier_arm", stats) {} + : HOptimization(graph, kInstructionSimplifierArmPassName, stats) {} + + static constexpr const char* kInstructionSimplifierArmPassName = "instruction_simplifier_arm"; void Run() OVERRIDE { InstructionSimplifierArmVisitor visitor(graph_, stats_); diff --git a/compiler/optimizing/instruction_simplifier_arm64.h b/compiler/optimizing/instruction_simplifier_arm64.h index 28648b3bea..f71684efe9 100644 --- a/compiler/optimizing/instruction_simplifier_arm64.h +++ b/compiler/optimizing/instruction_simplifier_arm64.h @@ -82,8 +82,9 @@ class InstructionSimplifierArm64Visitor : public HGraphVisitor { class InstructionSimplifierArm64 : public HOptimization { public: InstructionSimplifierArm64(HGraph* graph, OptimizingCompilerStats* stats) - : HOptimization(graph, "instruction_simplifier_arm64", stats) {} - + : HOptimization(graph, kInstructionSimplifierArm64PassName, stats) {} + static constexpr const char* kInstructionSimplifierArm64PassName + = "instruction_simplifier_arm64"; void Run() OVERRIDE { InstructionSimplifierArm64Visitor visitor(graph_, stats_); visitor.VisitReversePostOrder(); diff --git a/compiler/optimizing/optimization.h b/compiler/optimizing/optimization.h index 2f59d4cd5b..0819fb01ac 100644 --- a/compiler/optimizing/optimization.h +++ b/compiler/optimizing/optimization.h @@ -37,7 +37,10 @@ class HOptimization : public ArenaObject<kArenaAllocOptimization> { virtual ~HOptimization() {} - // Return the name of the pass. + // 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', + // 'instruction_simplifier$before_codegen'. const char* GetPassName() const { return pass_name_; } // Perform the analysis itself. diff --git a/compiler/optimizing/optimizing_compiler.cc b/compiler/optimizing/optimizing_compiler.cc index 30da69ffff..f7c82d1987 100644 --- a/compiler/optimizing/optimizing_compiler.cc +++ b/compiler/optimizing/optimizing_compiler.cc @@ -95,6 +95,8 @@ namespace art { static constexpr size_t kArenaAllocatorMemoryReportThreshold = 8 * MB; +static constexpr const char* kPassNameSeparator = "$"; + /** * Used by the code generator, to allocate the code in a vector. */ @@ -266,7 +268,7 @@ class PassScope : public ValueObject { class OptimizingCompiler FINAL : public Compiler { public: explicit OptimizingCompiler(CompilerDriver* driver); - ~OptimizingCompiler(); + ~OptimizingCompiler() OVERRIDE; bool CanCompileMethod(uint32_t method_idx, const DexFile& dex_file) const OVERRIDE; @@ -305,17 +307,17 @@ class OptimizingCompiler FINAL : public Compiler { OVERRIDE SHARED_REQUIRES(Locks::mutator_lock_); - protected: - virtual void RunOptimizations(HGraph* graph, - CodeGenerator* codegen, - CompilerDriver* driver, - const DexCompilationUnit& dex_compilation_unit, - PassObserver* pass_observer, - StackHandleScopeCollection* handles) const; + private: + void RunOptimizations(HGraph* graph, + CodeGenerator* codegen, + CompilerDriver* driver, + const DexCompilationUnit& dex_compilation_unit, + PassObserver* pass_observer, + StackHandleScopeCollection* handles) const; - virtual void RunOptimizations(HOptimization* optimizations[], - size_t length, - PassObserver* pass_observer) const; + void RunOptimizations(HOptimization* optimizations[], + size_t length, + PassObserver* pass_observer) const; private: // Create a 'CompiledMethod' for an optimized graph. @@ -420,6 +422,117 @@ static bool InstructionSetSupportsReadBarrier(InstructionSet instruction_set) { || instruction_set == kX86_64; } +static HOptimization* BuildOptimization( + const std::string& opt_name, + ArenaAllocator* arena, + HGraph* graph, + OptimizingCompilerStats* stats, + CodeGenerator* codegen, + CompilerDriver* driver, + const DexCompilationUnit& dex_compilation_unit, + StackHandleScopeCollection* handles, + SideEffectsAnalysis* most_recent_side_effects, + HInductionVarAnalysis* most_recent_induction) { + if (opt_name == arm::InstructionSimplifierArm::kInstructionSimplifierArmPassName) { + return new (arena) arm::InstructionSimplifierArm(graph, stats); + } else if (opt_name == arm64::InstructionSimplifierArm64::kInstructionSimplifierArm64PassName) { + return new (arena) arm64::InstructionSimplifierArm64(graph, stats); + } else if (opt_name == BoundsCheckElimination::kBoundsCheckEliminationPassName) { + CHECK(most_recent_side_effects != nullptr && most_recent_induction != nullptr); + return new (arena) BoundsCheckElimination(graph, + *most_recent_side_effects, + most_recent_induction); + } else if (opt_name == GVNOptimization::kGlobalValueNumberingPassName) { + CHECK(most_recent_side_effects != nullptr); + return new (arena) GVNOptimization(graph, *most_recent_side_effects); + } else if (opt_name == HConstantFolding::kConstantFoldingPassName) { + return new (arena) HConstantFolding(graph); + } else if (opt_name == HDeadCodeElimination::kDeadCodeEliminationPassName) { + return new (arena) HDeadCodeElimination(graph, stats); + } else if (opt_name == HInliner::kInlinerPassName) { + size_t number_of_dex_registers = dex_compilation_unit.GetCodeItem()->registers_size_; + return new (arena) HInliner(graph, // outer_graph + graph, // outermost_graph + codegen, + dex_compilation_unit, // outer_compilation_unit + dex_compilation_unit, // outermost_compilation_unit + driver, + handles, + stats, + number_of_dex_registers, + /* depth */ 0); + } else if (opt_name == HSharpening::kSharpeningPassName) { + return new (arena) HSharpening(graph, codegen, dex_compilation_unit, driver); + } else if (opt_name == HSelectGenerator::kSelectGeneratorPassName) { + return new (arena) HSelectGenerator(graph, stats); + } else if (opt_name == HInductionVarAnalysis::kInductionPassName) { + return new (arena) HInductionVarAnalysis(graph); + } else if (opt_name == InstructionSimplifier::kInstructionSimplifierPassName) { + return new (arena) InstructionSimplifier(graph, stats); + } else if (opt_name == IntrinsicsRecognizer::kIntrinsicsRecognizerPassName) { + return new (arena) IntrinsicsRecognizer(graph, driver, stats); + } else if (opt_name == LICM::kLoopInvariantCodeMotionPassName) { + CHECK(most_recent_side_effects != nullptr); + return new (arena) LICM(graph, *most_recent_side_effects, stats); + } else if (opt_name == LoadStoreElimination::kLoadStoreEliminationPassName) { + CHECK(most_recent_side_effects != nullptr); + return new (arena) LoadStoreElimination(graph, *most_recent_side_effects); + } else if (opt_name == mips::DexCacheArrayFixups::kDexCacheArrayFixupsMipsPassName) { + return new (arena) mips::DexCacheArrayFixups(graph, codegen, stats); + } else if (opt_name == mips::PcRelativeFixups::kPcRelativeFixupsMipsPassName) { + return new (arena) mips::PcRelativeFixups(graph, codegen, stats); + } else if (opt_name == SideEffectsAnalysis::kSideEffectsAnalysisPassName) { + return new (arena) SideEffectsAnalysis(graph); + } else if (opt_name == x86::PcRelativeFixups::kPcRelativeFixupsX86PassName) { + return new (arena) x86::PcRelativeFixups(graph, codegen, stats); + } else if (opt_name == x86::X86MemoryOperandGeneration::kX86MemoryOperandGenerationPassName) { + return new (arena) x86::X86MemoryOperandGeneration(graph, codegen, stats); + } + return nullptr; +} + +static ArenaVector<HOptimization*> BuildOptimizations( + const std::vector<std::string>& pass_names, + ArenaAllocator* arena, + HGraph* graph, + OptimizingCompilerStats* stats, + CodeGenerator* codegen, + CompilerDriver* driver, + const DexCompilationUnit& dex_compilation_unit, + StackHandleScopeCollection* handles) { + // Few HOptimizations constructors require SideEffectsAnalysis or HInductionVarAnalysis + // instances. This method assumes that each of them expects the nearest instance preceeding it + // in the pass name list. + SideEffectsAnalysis* most_recent_side_effects = nullptr; + HInductionVarAnalysis* most_recent_induction = nullptr; + ArenaVector<HOptimization*> ret(arena->Adapter()); + for (std::string pass_name : pass_names) { + size_t pos = pass_name.find(kPassNameSeparator); // Strip suffix to get base pass name. + std::string opt_name = pos == std::string::npos ? pass_name : pass_name.substr(0, pos); + + HOptimization* opt = BuildOptimization( + opt_name, + arena, + graph, + stats, + codegen, + driver, + dex_compilation_unit, + handles, + most_recent_side_effects, + most_recent_induction); + CHECK(opt != nullptr) << "Couldn't build optimization: \"" << pass_name << "\""; + ret.push_back(opt); + + if (opt_name == SideEffectsAnalysis::kSideEffectsAnalysisPassName) { + most_recent_side_effects = down_cast<SideEffectsAnalysis*>(opt); + } else if (opt_name == HInductionVarAnalysis::kInductionPassName) { + most_recent_induction = down_cast<HInductionVarAnalysis*>(opt); + } + } + return ret; +} + void OptimizingCompiler::RunOptimizations(HOptimization* optimizations[], size_t length, PassObserver* pass_observer) const { @@ -444,11 +557,11 @@ void OptimizingCompiler::MaybeRunInliner(HGraph* graph, } size_t number_of_dex_registers = dex_compilation_unit.GetCodeItem()->registers_size_; HInliner* inliner = new (graph->GetArena()) HInliner( - graph, - graph, + graph, // outer_graph + graph, // outermost_graph codegen, - dex_compilation_unit, - dex_compilation_unit, + dex_compilation_unit, // outer_compilation_unit + dex_compilation_unit, // outermost_compilation_unit driver, handles, stats, @@ -473,7 +586,7 @@ void OptimizingCompiler::RunArchOptimizations(InstructionSet instruction_set, arm::InstructionSimplifierArm* simplifier = new (arena) arm::InstructionSimplifierArm(graph, stats); SideEffectsAnalysis* side_effects = new (arena) SideEffectsAnalysis(graph); - GVNOptimization* gvn = new (arena) GVNOptimization(graph, *side_effects, "GVN_after_arch"); + GVNOptimization* gvn = new (arena) GVNOptimization(graph, *side_effects, "GVN$after_arch"); HOptimization* arm_optimizations[] = { simplifier, side_effects, @@ -489,7 +602,7 @@ void OptimizingCompiler::RunArchOptimizations(InstructionSet instruction_set, arm64::InstructionSimplifierArm64* simplifier = new (arena) arm64::InstructionSimplifierArm64(graph, stats); SideEffectsAnalysis* side_effects = new (arena) SideEffectsAnalysis(graph); - GVNOptimization* gvn = new (arena) GVNOptimization(graph, *side_effects, "GVN_after_arch"); + GVNOptimization* gvn = new (arena) GVNOptimization(graph, *side_effects, "GVN$after_arch"); HOptimization* arm64_optimizations[] = { simplifier, side_effects, @@ -518,7 +631,7 @@ void OptimizingCompiler::RunArchOptimizations(InstructionSet instruction_set, x86::PcRelativeFixups* pc_relative_fixups = new (arena) x86::PcRelativeFixups(graph, codegen, stats); x86::X86MemoryOperandGeneration* memory_gen = - new(arena) x86::X86MemoryOperandGeneration(graph, stats, codegen); + new (arena) x86::X86MemoryOperandGeneration(graph, codegen, stats); HOptimization* x86_optimizations[] = { pc_relative_fixups, memory_gen @@ -530,7 +643,7 @@ void OptimizingCompiler::RunArchOptimizations(InstructionSet instruction_set, #ifdef ART_ENABLE_CODEGEN_x86_64 case kX86_64: { x86::X86MemoryOperandGeneration* memory_gen = - new(arena) x86::X86MemoryOperandGeneration(graph, stats, codegen); + new (arena) x86::X86MemoryOperandGeneration(graph, codegen, stats); HOptimization* x86_64_optimizations[] = { memory_gen }; @@ -572,15 +685,30 @@ void OptimizingCompiler::RunOptimizations(HGraph* graph, StackHandleScopeCollection* handles) const { OptimizingCompilerStats* stats = compilation_stats_.get(); ArenaAllocator* arena = graph->GetArena(); + if (driver->GetCompilerOptions().GetPassesToRun() != nullptr) { + ArenaVector<HOptimization*> optimizations = BuildOptimizations( + *driver->GetCompilerOptions().GetPassesToRun(), + arena, + graph, + stats, + codegen, + driver, + dex_compilation_unit, + handles); + RunOptimizations(&optimizations[0], optimizations.size(), pass_observer); + return; + } + HDeadCodeElimination* dce1 = new (arena) HDeadCodeElimination( - graph, stats, HDeadCodeElimination::kInitialDeadCodeEliminationPassName); + graph, stats, "dead_code_elimination$initial"); HDeadCodeElimination* dce2 = new (arena) HDeadCodeElimination( - graph, stats, HDeadCodeElimination::kFinalDeadCodeEliminationPassName); + graph, stats, "dead_code_elimination$final"); HConstantFolding* fold1 = new (arena) HConstantFolding(graph); InstructionSimplifier* simplify1 = new (arena) InstructionSimplifier(graph, stats); HSelectGenerator* select_generator = new (arena) HSelectGenerator(graph, stats); - HConstantFolding* fold2 = new (arena) HConstantFolding(graph, "constant_folding_after_inlining"); - HConstantFolding* fold3 = new (arena) HConstantFolding(graph, "constant_folding_after_bce"); + HConstantFolding* fold2 = new (arena) HConstantFolding( + graph, "constant_folding$after_inlining"); + HConstantFolding* fold3 = new (arena) HConstantFolding(graph, "constant_folding$after_bce"); SideEffectsAnalysis* side_effects = new (arena) SideEffectsAnalysis(graph); GVNOptimization* gvn = new (arena) GVNOptimization(graph, *side_effects); LICM* licm = new (arena) LICM(graph, *side_effects, stats); @@ -589,9 +717,9 @@ void OptimizingCompiler::RunOptimizations(HGraph* graph, BoundsCheckElimination* bce = new (arena) BoundsCheckElimination(graph, *side_effects, induction); HSharpening* sharpening = new (arena) HSharpening(graph, codegen, dex_compilation_unit, driver); InstructionSimplifier* simplify2 = new (arena) InstructionSimplifier( - graph, stats, "instruction_simplifier_after_bce"); + graph, stats, "instruction_simplifier$after_bce"); InstructionSimplifier* simplify3 = new (arena) InstructionSimplifier( - graph, stats, "instruction_simplifier_before_codegen"); + graph, stats, "instruction_simplifier$before_codegen"); IntrinsicsRecognizer* intrinsics = new (arena) IntrinsicsRecognizer(graph, driver, stats); HOptimization* optimizations1[] = { @@ -627,9 +755,6 @@ void OptimizingCompiler::RunOptimizations(HGraph* graph, RunOptimizations(optimizations2, arraysize(optimizations2), pass_observer); RunArchOptimizations(driver->GetInstructionSet(), graph, codegen, pass_observer); - RegisterAllocator::Strategy regalloc_strategy = - driver->GetCompilerOptions().GetRegisterAllocationStrategy(); - AllocateRegisters(graph, codegen, pass_observer, regalloc_strategy); } static ArenaVector<LinkerPatch> EmitAndSortLinkerPatches(CodeGenerator* codegen) { @@ -844,6 +969,10 @@ CodeGenerator* OptimizingCompiler::TryCompile(ArenaAllocator* arena, &pass_observer, &handles); + RegisterAllocator::Strategy regalloc_strategy = + compiler_options.GetRegisterAllocationStrategy(); + AllocateRegisters(graph, codegen.get(), &pass_observer, regalloc_strategy); + codegen->Compile(code_allocator); pass_observer.DumpDisassembly(); } diff --git a/compiler/optimizing/pc_relative_fixups_mips.h b/compiler/optimizing/pc_relative_fixups_mips.h index 1e8b071bb3..5a7397bf9d 100644 --- a/compiler/optimizing/pc_relative_fixups_mips.h +++ b/compiler/optimizing/pc_relative_fixups_mips.h @@ -32,6 +32,8 @@ class PcRelativeFixups : public HOptimization { : HOptimization(graph, "pc_relative_fixups_mips", stats), codegen_(codegen) {} + static constexpr const char* kPcRelativeFixupsMipsPassName = "pc_relative_fixups_mips"; + void Run() OVERRIDE; private: diff --git a/compiler/optimizing/pc_relative_fixups_x86.h b/compiler/optimizing/pc_relative_fixups_x86.h index 03de2fcece..72fa71ea94 100644 --- a/compiler/optimizing/pc_relative_fixups_x86.h +++ b/compiler/optimizing/pc_relative_fixups_x86.h @@ -29,9 +29,11 @@ namespace x86 { class PcRelativeFixups : public HOptimization { public: PcRelativeFixups(HGraph* graph, CodeGenerator* codegen, OptimizingCompilerStats* stats) - : HOptimization(graph, "pc_relative_fixups_x86", stats), + : HOptimization(graph, kPcRelativeFixupsX86PassName, stats), codegen_(codegen) {} + static constexpr const char* kPcRelativeFixupsX86PassName = "pc_relative_fixups_x86"; + void Run() OVERRIDE; private: diff --git a/compiler/optimizing/x86_memory_gen.cc b/compiler/optimizing/x86_memory_gen.cc index 195159f61b..8aa315a7e3 100644 --- a/compiler/optimizing/x86_memory_gen.cc +++ b/compiler/optimizing/x86_memory_gen.cc @@ -69,8 +69,8 @@ class MemoryOperandVisitor : public HGraphVisitor { }; X86MemoryOperandGeneration::X86MemoryOperandGeneration(HGraph* graph, - OptimizingCompilerStats* stats, - CodeGenerator* codegen) + CodeGenerator* codegen, + OptimizingCompilerStats* stats) : HOptimization(graph, kX86MemoryOperandGenerationPassName, stats), do_implicit_null_checks_(codegen->GetCompilerOptions().GetImplicitNullChecks()) { } diff --git a/compiler/optimizing/x86_memory_gen.h b/compiler/optimizing/x86_memory_gen.h index 7e886819bb..5f15d9f1e6 100644 --- a/compiler/optimizing/x86_memory_gen.h +++ b/compiler/optimizing/x86_memory_gen.h @@ -28,8 +28,8 @@ namespace x86 { class X86MemoryOperandGeneration : public HOptimization { public: X86MemoryOperandGeneration(HGraph* graph, - OptimizingCompilerStats* stats, - CodeGenerator* codegen); + CodeGenerator* codegen, + OptimizingCompilerStats* stats); void Run() OVERRIDE; diff --git a/dex2oat/dex2oat.cc b/dex2oat/dex2oat.cc index 0d1d4d7673..eb11f6d3d7 100644 --- a/dex2oat/dex2oat.cc +++ b/dex2oat/dex2oat.cc @@ -516,6 +516,7 @@ class Dex2Oat FINAL { compiled_classes_filename_(nullptr), compiled_methods_zip_filename_(nullptr), compiled_methods_filename_(nullptr), + passes_to_run_filename_(nullptr), app_image_(false), boot_image_(false), multi_image_(false), @@ -894,6 +895,16 @@ class Dex2Oat FINAL { } } compiler_options_->force_determinism_ = force_determinism_; + + if (passes_to_run_filename_ != nullptr) { + passes_to_run_.reset(ReadCommentedInputFromFile<std::vector<std::string>>( + passes_to_run_filename_, + nullptr)); // No post-processing. + if (passes_to_run_.get() == nullptr) { + Usage("Failed to read list of passes to run."); + } + } + compiler_options_->passes_to_run_ = passes_to_run_.get(); } static bool SupportsDeterministicCompilation() { @@ -1093,6 +1104,8 @@ class Dex2Oat FINAL { compiled_methods_filename_ = option.substr(strlen("--compiled-methods=")).data(); } else if (option.starts_with("--compiled-methods-zip=")) { compiled_methods_zip_filename_ = option.substr(strlen("--compiled-methods-zip=")).data(); + } else if (option.starts_with("--run-passes=")) { + passes_to_run_filename_ = option.substr(strlen("--run-passes=")).data(); } else if (option.starts_with("--base=")) { ParseBase(option); } else if (option.starts_with("--boot-image=")) { @@ -2106,13 +2119,15 @@ class Dex2Oat FINAL { if (compiled_methods_filename_ != nullptr) { std::string error_msg; if (compiled_methods_zip_filename_ != nullptr) { - compiled_methods_.reset(ReadCommentedInputFromZip(compiled_methods_zip_filename_, - compiled_methods_filename_, - nullptr, // No post-processing. - &error_msg)); + compiled_methods_.reset(ReadCommentedInputFromZip<std::unordered_set<std::string>>( + compiled_methods_zip_filename_, + compiled_methods_filename_, + nullptr, // No post-processing. + &error_msg)); } else { - compiled_methods_.reset(ReadCommentedInputFromFile(compiled_methods_filename_, - nullptr)); // No post-processing. + compiled_methods_.reset(ReadCommentedInputFromFile<std::unordered_set<std::string>>( + compiled_methods_filename_, + nullptr)); // No post-processing. } if (compiled_methods_.get() == nullptr) { LOG(ERROR) << "Failed to create list of compiled methods from '" @@ -2346,7 +2361,8 @@ class Dex2Oat FINAL { static std::unordered_set<std::string>* ReadImageClassesFromFile( const char* image_classes_filename) { std::function<std::string(const char*)> process = DotToDescriptor; - return ReadCommentedInputFromFile(image_classes_filename, &process); + return ReadCommentedInputFromFile<std::unordered_set<std::string>>(image_classes_filename, + &process); } // Reads the class names (java.lang.Object) and returns a set of descriptors (Ljava/lang/Object;) @@ -2355,27 +2371,32 @@ class Dex2Oat FINAL { const char* image_classes_filename, std::string* error_msg) { std::function<std::string(const char*)> process = DotToDescriptor; - return ReadCommentedInputFromZip(zip_filename, image_classes_filename, &process, error_msg); + return ReadCommentedInputFromZip<std::unordered_set<std::string>>(zip_filename, + image_classes_filename, + &process, + error_msg); } // Read lines from the given file, dropping comments and empty lines. Post-process each line with // the given function. - static std::unordered_set<std::string>* ReadCommentedInputFromFile( + template <typename T> + static T* ReadCommentedInputFromFile( const char* input_filename, std::function<std::string(const char*)>* process) { std::unique_ptr<std::ifstream> input_file(new std::ifstream(input_filename, std::ifstream::in)); if (input_file.get() == nullptr) { LOG(ERROR) << "Failed to open input file " << input_filename; return nullptr; } - std::unique_ptr<std::unordered_set<std::string>> result( - ReadCommentedInputStream(*input_file, process)); + std::unique_ptr<T> result( + ReadCommentedInputStream<T>(*input_file, process)); input_file->close(); return result.release(); } // Read lines from the given file from the given zip file, dropping comments and empty lines. // Post-process each line with the given function. - static std::unordered_set<std::string>* ReadCommentedInputFromZip( + template <typename T> + static T* ReadCommentedInputFromZip( const char* zip_filename, const char* input_filename, std::function<std::string(const char*)>* process, @@ -2401,16 +2422,16 @@ class Dex2Oat FINAL { const std::string input_string(reinterpret_cast<char*>(input_file->Begin()), input_file->Size()); std::istringstream input_stream(input_string); - return ReadCommentedInputStream(input_stream, process); + return ReadCommentedInputStream<T>(input_stream, process); } // Read lines from the given stream, dropping comments and empty lines. Post-process each line // with the given function. - static std::unordered_set<std::string>* ReadCommentedInputStream( + template <typename T> + static T* ReadCommentedInputStream( std::istream& in_stream, std::function<std::string(const char*)>* process) { - std::unique_ptr<std::unordered_set<std::string>> image_classes( - new std::unordered_set<std::string>); + std::unique_ptr<T> output(new T()); while (in_stream.good()) { std::string dot; std::getline(in_stream, dot); @@ -2419,12 +2440,12 @@ class Dex2Oat FINAL { } if (process != nullptr) { std::string descriptor((*process)(dot.c_str())); - image_classes->insert(descriptor); + output->insert(output->end(), descriptor); } else { - image_classes->insert(dot); + output->insert(output->end(), dot); } } - return image_classes.release(); + return output.release(); } void LogCompletionTime() { @@ -2501,9 +2522,11 @@ class Dex2Oat FINAL { const char* compiled_classes_filename_; const char* compiled_methods_zip_filename_; const char* compiled_methods_filename_; + const char* passes_to_run_filename_; std::unique_ptr<std::unordered_set<std::string>> image_classes_; std::unique_ptr<std::unordered_set<std::string>> compiled_classes_; std::unique_ptr<std::unordered_set<std::string>> compiled_methods_; + std::unique_ptr<std::vector<std::string>> passes_to_run_; bool app_image_; bool boot_image_; bool multi_image_; diff --git a/test/442-checker-constant-folding/src/Main.java b/test/442-checker-constant-folding/src/Main.java index b7712a701f..33ef10bf7f 100644 --- a/test/442-checker-constant-folding/src/Main.java +++ b/test/442-checker-constant-folding/src/Main.java @@ -213,17 +213,17 @@ public class Main { * Exercise constant folding on addition. */ - /// CHECK-START: int Main.IntAddition1() constant_folding_after_inlining (before) + /// CHECK-START: int Main.IntAddition1() constant_folding$after_inlining (before) /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1 /// CHECK-DAG: <<Const2:i\d+>> IntConstant 2 /// CHECK-DAG: <<Add:i\d+>> Add [<<Const1>>,<<Const2>>] /// CHECK-DAG: Return [<<Add>>] - /// CHECK-START: int Main.IntAddition1() constant_folding_after_inlining (after) + /// CHECK-START: int Main.IntAddition1() constant_folding$after_inlining (after) /// CHECK-DAG: <<Const3:i\d+>> IntConstant 3 /// CHECK-DAG: Return [<<Const3>>] - /// CHECK-START: int Main.IntAddition1() constant_folding_after_inlining (after) + /// CHECK-START: int Main.IntAddition1() constant_folding$after_inlining (after) /// CHECK-NOT: Add public static int IntAddition1() { @@ -234,7 +234,7 @@ public class Main { return c; } - /// CHECK-START: int Main.IntAddition2() constant_folding_after_inlining (before) + /// CHECK-START: int Main.IntAddition2() constant_folding$after_inlining (before) /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1 /// CHECK-DAG: <<Const2:i\d+>> IntConstant 2 /// CHECK-DAG: <<Const5:i\d+>> IntConstant 5 @@ -244,11 +244,11 @@ public class Main { /// CHECK-DAG: <<Add3:i\d+>> Add [<<Add1>>,<<Add2>>] /// CHECK-DAG: Return [<<Add3>>] - /// CHECK-START: int Main.IntAddition2() constant_folding_after_inlining (after) + /// CHECK-START: int Main.IntAddition2() constant_folding$after_inlining (after) /// CHECK-DAG: <<Const14:i\d+>> IntConstant 14 /// CHECK-DAG: Return [<<Const14>>] - /// CHECK-START: int Main.IntAddition2() constant_folding_after_inlining (after) + /// CHECK-START: int Main.IntAddition2() constant_folding$after_inlining (after) /// CHECK-NOT: Add public static int IntAddition2() { @@ -263,17 +263,17 @@ public class Main { return c; } - /// CHECK-START: long Main.LongAddition() constant_folding_after_inlining (before) + /// CHECK-START: long Main.LongAddition() constant_folding$after_inlining (before) /// CHECK-DAG: <<Const1:j\d+>> LongConstant 1 /// CHECK-DAG: <<Const2:j\d+>> LongConstant 2 /// CHECK-DAG: <<Add:j\d+>> Add [<<Const1>>,<<Const2>>] /// CHECK-DAG: Return [<<Add>>] - /// CHECK-START: long Main.LongAddition() constant_folding_after_inlining (after) + /// CHECK-START: long Main.LongAddition() constant_folding$after_inlining (after) /// CHECK-DAG: <<Const3:j\d+>> LongConstant 3 /// CHECK-DAG: Return [<<Const3>>] - /// CHECK-START: long Main.LongAddition() constant_folding_after_inlining (after) + /// CHECK-START: long Main.LongAddition() constant_folding$after_inlining (after) /// CHECK-NOT: Add public static long LongAddition() { @@ -284,17 +284,17 @@ public class Main { return c; } - /// CHECK-START: float Main.FloatAddition() constant_folding_after_inlining (before) + /// CHECK-START: float Main.FloatAddition() constant_folding$after_inlining (before) /// CHECK-DAG: <<Const1:f\d+>> FloatConstant 1 /// CHECK-DAG: <<Const2:f\d+>> FloatConstant 2 /// CHECK-DAG: <<Add:f\d+>> Add [<<Const1>>,<<Const2>>] /// CHECK-DAG: Return [<<Add>>] - /// CHECK-START: float Main.FloatAddition() constant_folding_after_inlining (after) + /// CHECK-START: float Main.FloatAddition() constant_folding$after_inlining (after) /// CHECK-DAG: <<Const3:f\d+>> FloatConstant 3 /// CHECK-DAG: Return [<<Const3>>] - /// CHECK-START: float Main.FloatAddition() constant_folding_after_inlining (after) + /// CHECK-START: float Main.FloatAddition() constant_folding$after_inlining (after) /// CHECK-NOT: Add public static float FloatAddition() { @@ -305,17 +305,17 @@ public class Main { return c; } - /// CHECK-START: double Main.DoubleAddition() constant_folding_after_inlining (before) + /// CHECK-START: double Main.DoubleAddition() constant_folding$after_inlining (before) /// CHECK-DAG: <<Const1:d\d+>> DoubleConstant 1 /// CHECK-DAG: <<Const2:d\d+>> DoubleConstant 2 /// CHECK-DAG: <<Add:d\d+>> Add [<<Const1>>,<<Const2>>] /// CHECK-DAG: Return [<<Add>>] - /// CHECK-START: double Main.DoubleAddition() constant_folding_after_inlining (after) + /// CHECK-START: double Main.DoubleAddition() constant_folding$after_inlining (after) /// CHECK-DAG: <<Const3:d\d+>> DoubleConstant 3 /// CHECK-DAG: Return [<<Const3>>] - /// CHECK-START: double Main.DoubleAddition() constant_folding_after_inlining (after) + /// CHECK-START: double Main.DoubleAddition() constant_folding$after_inlining (after) /// CHECK-NOT: Add public static double DoubleAddition() { @@ -331,17 +331,17 @@ public class Main { * Exercise constant folding on subtraction. */ - /// CHECK-START: int Main.IntSubtraction() constant_folding_after_inlining (before) + /// CHECK-START: int Main.IntSubtraction() constant_folding$after_inlining (before) /// CHECK-DAG: <<Const6:i\d+>> IntConstant 6 /// CHECK-DAG: <<Const2:i\d+>> IntConstant 2 /// CHECK-DAG: <<Sub:i\d+>> Sub [<<Const6>>,<<Const2>>] /// CHECK-DAG: Return [<<Sub>>] - /// CHECK-START: int Main.IntSubtraction() constant_folding_after_inlining (after) + /// CHECK-START: int Main.IntSubtraction() constant_folding$after_inlining (after) /// CHECK-DAG: <<Const4:i\d+>> IntConstant 4 /// CHECK-DAG: Return [<<Const4>>] - /// CHECK-START: int Main.IntSubtraction() constant_folding_after_inlining (after) + /// CHECK-START: int Main.IntSubtraction() constant_folding$after_inlining (after) /// CHECK-NOT: Sub public static int IntSubtraction() { @@ -352,17 +352,17 @@ public class Main { return c; } - /// CHECK-START: long Main.LongSubtraction() constant_folding_after_inlining (before) + /// CHECK-START: long Main.LongSubtraction() constant_folding$after_inlining (before) /// CHECK-DAG: <<Const6:j\d+>> LongConstant 6 /// CHECK-DAG: <<Const2:j\d+>> LongConstant 2 /// CHECK-DAG: <<Sub:j\d+>> Sub [<<Const6>>,<<Const2>>] /// CHECK-DAG: Return [<<Sub>>] - /// CHECK-START: long Main.LongSubtraction() constant_folding_after_inlining (after) + /// CHECK-START: long Main.LongSubtraction() constant_folding$after_inlining (after) /// CHECK-DAG: <<Const4:j\d+>> LongConstant 4 /// CHECK-DAG: Return [<<Const4>>] - /// CHECK-START: long Main.LongSubtraction() constant_folding_after_inlining (after) + /// CHECK-START: long Main.LongSubtraction() constant_folding$after_inlining (after) /// CHECK-NOT: Sub public static long LongSubtraction() { @@ -373,17 +373,17 @@ public class Main { return c; } - /// CHECK-START: float Main.FloatSubtraction() constant_folding_after_inlining (before) + /// CHECK-START: float Main.FloatSubtraction() constant_folding$after_inlining (before) /// CHECK-DAG: <<Const6:f\d+>> FloatConstant 6 /// CHECK-DAG: <<Const2:f\d+>> FloatConstant 2 /// CHECK-DAG: <<Sub:f\d+>> Sub [<<Const6>>,<<Const2>>] /// CHECK-DAG: Return [<<Sub>>] - /// CHECK-START: float Main.FloatSubtraction() constant_folding_after_inlining (after) + /// CHECK-START: float Main.FloatSubtraction() constant_folding$after_inlining (after) /// CHECK-DAG: <<Const4:f\d+>> FloatConstant 4 /// CHECK-DAG: Return [<<Const4>>] - /// CHECK-START: float Main.FloatSubtraction() constant_folding_after_inlining (after) + /// CHECK-START: float Main.FloatSubtraction() constant_folding$after_inlining (after) /// CHECK-NOT: Sub public static float FloatSubtraction() { @@ -394,17 +394,17 @@ public class Main { return c; } - /// CHECK-START: double Main.DoubleSubtraction() constant_folding_after_inlining (before) + /// CHECK-START: double Main.DoubleSubtraction() constant_folding$after_inlining (before) /// CHECK-DAG: <<Const6:d\d+>> DoubleConstant 6 /// CHECK-DAG: <<Const2:d\d+>> DoubleConstant 2 /// CHECK-DAG: <<Sub:d\d+>> Sub [<<Const6>>,<<Const2>>] /// CHECK-DAG: Return [<<Sub>>] - /// CHECK-START: double Main.DoubleSubtraction() constant_folding_after_inlining (after) + /// CHECK-START: double Main.DoubleSubtraction() constant_folding$after_inlining (after) /// CHECK-DAG: <<Const4:d\d+>> DoubleConstant 4 /// CHECK-DAG: Return [<<Const4>>] - /// CHECK-START: double Main.DoubleSubtraction() constant_folding_after_inlining (after) + /// CHECK-START: double Main.DoubleSubtraction() constant_folding$after_inlining (after) /// CHECK-NOT: Sub public static double DoubleSubtraction() { @@ -420,17 +420,17 @@ public class Main { * Exercise constant folding on multiplication. */ - /// CHECK-START: int Main.IntMultiplication() constant_folding_after_inlining (before) + /// CHECK-START: int Main.IntMultiplication() constant_folding$after_inlining (before) /// CHECK-DAG: <<Const7:i\d+>> IntConstant 7 /// CHECK-DAG: <<Const3:i\d+>> IntConstant 3 /// CHECK-DAG: <<Mul:i\d+>> Mul [<<Const7>>,<<Const3>>] /// CHECK-DAG: Return [<<Mul>>] - /// CHECK-START: int Main.IntMultiplication() constant_folding_after_inlining (after) + /// CHECK-START: int Main.IntMultiplication() constant_folding$after_inlining (after) /// CHECK-DAG: <<Const21:i\d+>> IntConstant 21 /// CHECK-DAG: Return [<<Const21>>] - /// CHECK-START: int Main.IntMultiplication() constant_folding_after_inlining (after) + /// CHECK-START: int Main.IntMultiplication() constant_folding$after_inlining (after) /// CHECK-NOT: Mul public static int IntMultiplication() { @@ -441,17 +441,17 @@ public class Main { return c; } - /// CHECK-START: long Main.LongMultiplication() constant_folding_after_inlining (before) + /// CHECK-START: long Main.LongMultiplication() constant_folding$after_inlining (before) /// CHECK-DAG: <<Const7:j\d+>> LongConstant 7 /// CHECK-DAG: <<Const3:j\d+>> LongConstant 3 /// CHECK-DAG: <<Mul:j\d+>> Mul [<<Const7>>,<<Const3>>] /// CHECK-DAG: Return [<<Mul>>] - /// CHECK-START: long Main.LongMultiplication() constant_folding_after_inlining (after) + /// CHECK-START: long Main.LongMultiplication() constant_folding$after_inlining (after) /// CHECK-DAG: <<Const21:j\d+>> LongConstant 21 /// CHECK-DAG: Return [<<Const21>>] - /// CHECK-START: long Main.LongMultiplication() constant_folding_after_inlining (after) + /// CHECK-START: long Main.LongMultiplication() constant_folding$after_inlining (after) /// CHECK-NOT: Mul public static long LongMultiplication() { @@ -462,17 +462,17 @@ public class Main { return c; } - /// CHECK-START: float Main.FloatMultiplication() constant_folding_after_inlining (before) + /// CHECK-START: float Main.FloatMultiplication() constant_folding$after_inlining (before) /// CHECK-DAG: <<Const7:f\d+>> FloatConstant 7 /// CHECK-DAG: <<Const3:f\d+>> FloatConstant 3 /// CHECK-DAG: <<Mul:f\d+>> Mul [<<Const7>>,<<Const3>>] /// CHECK-DAG: Return [<<Mul>>] - /// CHECK-START: float Main.FloatMultiplication() constant_folding_after_inlining (after) + /// CHECK-START: float Main.FloatMultiplication() constant_folding$after_inlining (after) /// CHECK-DAG: <<Const21:f\d+>> FloatConstant 21 /// CHECK-DAG: Return [<<Const21>>] - /// CHECK-START: float Main.FloatMultiplication() constant_folding_after_inlining (after) + /// CHECK-START: float Main.FloatMultiplication() constant_folding$after_inlining (after) /// CHECK-NOT: Mul public static float FloatMultiplication() { @@ -483,17 +483,17 @@ public class Main { return c; } - /// CHECK-START: double Main.DoubleMultiplication() constant_folding_after_inlining (before) + /// CHECK-START: double Main.DoubleMultiplication() constant_folding$after_inlining (before) /// CHECK-DAG: <<Const7:d\d+>> DoubleConstant 7 /// CHECK-DAG: <<Const3:d\d+>> DoubleConstant 3 /// CHECK-DAG: <<Mul:d\d+>> Mul [<<Const7>>,<<Const3>>] /// CHECK-DAG: Return [<<Mul>>] - /// CHECK-START: double Main.DoubleMultiplication() constant_folding_after_inlining (after) + /// CHECK-START: double Main.DoubleMultiplication() constant_folding$after_inlining (after) /// CHECK-DAG: <<Const21:d\d+>> DoubleConstant 21 /// CHECK-DAG: Return [<<Const21>>] - /// CHECK-START: double Main.DoubleMultiplication() constant_folding_after_inlining (after) + /// CHECK-START: double Main.DoubleMultiplication() constant_folding$after_inlining (after) /// CHECK-NOT: Mul public static double DoubleMultiplication() { @@ -509,18 +509,18 @@ public class Main { * Exercise constant folding on division. */ - /// CHECK-START: int Main.IntDivision() constant_folding_after_inlining (before) + /// CHECK-START: int Main.IntDivision() constant_folding$after_inlining (before) /// CHECK-DAG: <<Const8:i\d+>> IntConstant 8 /// CHECK-DAG: <<Const3:i\d+>> IntConstant 3 /// CHECK-DAG: <<Div0Chk:i\d+>> DivZeroCheck [<<Const3>>] /// CHECK-DAG: <<Div:i\d+>> Div [<<Const8>>,<<Div0Chk>>] /// CHECK-DAG: Return [<<Div>>] - /// CHECK-START: int Main.IntDivision() constant_folding_after_inlining (after) + /// CHECK-START: int Main.IntDivision() constant_folding$after_inlining (after) /// CHECK-DAG: <<Const2:i\d+>> IntConstant 2 /// CHECK-DAG: Return [<<Const2>>] - /// CHECK-START: int Main.IntDivision() constant_folding_after_inlining (after) + /// CHECK-START: int Main.IntDivision() constant_folding$after_inlining (after) /// CHECK-NOT: DivZeroCheck /// CHECK-NOT: Div @@ -532,18 +532,18 @@ public class Main { return c; } - /// CHECK-START: long Main.LongDivision() constant_folding_after_inlining (before) + /// CHECK-START: long Main.LongDivision() constant_folding$after_inlining (before) /// CHECK-DAG: <<Const8:j\d+>> LongConstant 8 /// CHECK-DAG: <<Const3:j\d+>> LongConstant 3 /// CHECK-DAG: <<Div0Chk:j\d+>> DivZeroCheck [<<Const3>>] /// CHECK-DAG: <<Div:j\d+>> Div [<<Const8>>,<<Div0Chk>>] /// CHECK-DAG: Return [<<Div>>] - /// CHECK-START: long Main.LongDivision() constant_folding_after_inlining (after) + /// CHECK-START: long Main.LongDivision() constant_folding$after_inlining (after) /// CHECK-DAG: <<Const2:j\d+>> LongConstant 2 /// CHECK-DAG: Return [<<Const2>>] - /// CHECK-START: long Main.LongDivision() constant_folding_after_inlining (after) + /// CHECK-START: long Main.LongDivision() constant_folding$after_inlining (after) /// CHECK-NOT: DivZeroCheck /// CHECK-NOT: Div @@ -555,17 +555,17 @@ public class Main { return c; } - /// CHECK-START: float Main.FloatDivision() constant_folding_after_inlining (before) + /// CHECK-START: float Main.FloatDivision() constant_folding$after_inlining (before) /// CHECK-DAG: <<Const8:f\d+>> FloatConstant 8 /// CHECK-DAG: <<Const2P5:f\d+>> FloatConstant 2.5 /// CHECK-DAG: <<Div:f\d+>> Div [<<Const8>>,<<Const2P5>>] /// CHECK-DAG: Return [<<Div>>] - /// CHECK-START: float Main.FloatDivision() constant_folding_after_inlining (after) + /// CHECK-START: float Main.FloatDivision() constant_folding$after_inlining (after) /// CHECK-DAG: <<Const3P2:f\d+>> FloatConstant 3.2 /// CHECK-DAG: Return [<<Const3P2>>] - /// CHECK-START: float Main.FloatDivision() constant_folding_after_inlining (after) + /// CHECK-START: float Main.FloatDivision() constant_folding$after_inlining (after) /// CHECK-NOT: Div public static float FloatDivision() { @@ -576,17 +576,17 @@ public class Main { return c; } - /// CHECK-START: double Main.DoubleDivision() constant_folding_after_inlining (before) + /// CHECK-START: double Main.DoubleDivision() constant_folding$after_inlining (before) /// CHECK-DAG: <<Const8:d\d+>> DoubleConstant 8 /// CHECK-DAG: <<Const2P5:d\d+>> DoubleConstant 2.5 /// CHECK-DAG: <<Div:d\d+>> Div [<<Const8>>,<<Const2P5>>] /// CHECK-DAG: Return [<<Div>>] - /// CHECK-START: double Main.DoubleDivision() constant_folding_after_inlining (after) + /// CHECK-START: double Main.DoubleDivision() constant_folding$after_inlining (after) /// CHECK-DAG: <<Const3P2:d\d+>> DoubleConstant 3.2 /// CHECK-DAG: Return [<<Const3P2>>] - /// CHECK-START: double Main.DoubleDivision() constant_folding_after_inlining (after) + /// CHECK-START: double Main.DoubleDivision() constant_folding$after_inlining (after) /// CHECK-NOT: Div public static double DoubleDivision() { @@ -602,18 +602,18 @@ public class Main { * Exercise constant folding on remainder. */ - /// CHECK-START: int Main.IntRemainder() constant_folding_after_inlining (before) + /// CHECK-START: int Main.IntRemainder() constant_folding$after_inlining (before) /// CHECK-DAG: <<Const8:i\d+>> IntConstant 8 /// CHECK-DAG: <<Const3:i\d+>> IntConstant 3 /// CHECK-DAG: <<Div0Chk:i\d+>> DivZeroCheck [<<Const3>>] /// CHECK-DAG: <<Rem:i\d+>> Rem [<<Const8>>,<<Div0Chk>>] /// CHECK-DAG: Return [<<Rem>>] - /// CHECK-START: int Main.IntRemainder() constant_folding_after_inlining (after) + /// CHECK-START: int Main.IntRemainder() constant_folding$after_inlining (after) /// CHECK-DAG: <<Const2:i\d+>> IntConstant 2 /// CHECK-DAG: Return [<<Const2>>] - /// CHECK-START: int Main.IntRemainder() constant_folding_after_inlining (after) + /// CHECK-START: int Main.IntRemainder() constant_folding$after_inlining (after) /// CHECK-NOT: DivZeroCheck /// CHECK-NOT: Rem @@ -625,18 +625,18 @@ public class Main { return c; } - /// CHECK-START: long Main.LongRemainder() constant_folding_after_inlining (before) + /// CHECK-START: long Main.LongRemainder() constant_folding$after_inlining (before) /// CHECK-DAG: <<Const8:j\d+>> LongConstant 8 /// CHECK-DAG: <<Const3:j\d+>> LongConstant 3 /// CHECK-DAG: <<Div0Chk:j\d+>> DivZeroCheck [<<Const3>>] /// CHECK-DAG: <<Rem:j\d+>> Rem [<<Const8>>,<<Div0Chk>>] /// CHECK-DAG: Return [<<Rem>>] - /// CHECK-START: long Main.LongRemainder() constant_folding_after_inlining (after) + /// CHECK-START: long Main.LongRemainder() constant_folding$after_inlining (after) /// CHECK-DAG: <<Const2:j\d+>> LongConstant 2 /// CHECK-DAG: Return [<<Const2>>] - /// CHECK-START: long Main.LongRemainder() constant_folding_after_inlining (after) + /// CHECK-START: long Main.LongRemainder() constant_folding$after_inlining (after) /// CHECK-NOT: DivZeroCheck /// CHECK-NOT: Rem @@ -648,17 +648,17 @@ public class Main { return c; } - /// CHECK-START: float Main.FloatRemainder() constant_folding_after_inlining (before) + /// CHECK-START: float Main.FloatRemainder() constant_folding$after_inlining (before) /// CHECK-DAG: <<Const8:f\d+>> FloatConstant 8 /// CHECK-DAG: <<Const2P5:f\d+>> FloatConstant 2.5 /// CHECK-DAG: <<Rem:f\d+>> Rem [<<Const8>>,<<Const2P5>>] /// CHECK-DAG: Return [<<Rem>>] - /// CHECK-START: float Main.FloatRemainder() constant_folding_after_inlining (after) + /// CHECK-START: float Main.FloatRemainder() constant_folding$after_inlining (after) /// CHECK-DAG: <<Const0P5:f\d+>> FloatConstant 0.5 /// CHECK-DAG: Return [<<Const0P5>>] - /// CHECK-START: float Main.FloatRemainder() constant_folding_after_inlining (after) + /// CHECK-START: float Main.FloatRemainder() constant_folding$after_inlining (after) /// CHECK-NOT: Rem public static float FloatRemainder() { @@ -669,17 +669,17 @@ public class Main { return c; } - /// CHECK-START: double Main.DoubleRemainder() constant_folding_after_inlining (before) + /// CHECK-START: double Main.DoubleRemainder() constant_folding$after_inlining (before) /// CHECK-DAG: <<Const8:d\d+>> DoubleConstant 8 /// CHECK-DAG: <<Const2P5:d\d+>> DoubleConstant 2.5 /// CHECK-DAG: <<Rem:d\d+>> Rem [<<Const8>>,<<Const2P5>>] /// CHECK-DAG: Return [<<Rem>>] - /// CHECK-START: double Main.DoubleRemainder() constant_folding_after_inlining (after) + /// CHECK-START: double Main.DoubleRemainder() constant_folding$after_inlining (after) /// CHECK-DAG: <<Const0P5:d\d+>> DoubleConstant 0.5 /// CHECK-DAG: Return [<<Const0P5>>] - /// CHECK-START: double Main.DoubleRemainder() constant_folding_after_inlining (after) + /// CHECK-START: double Main.DoubleRemainder() constant_folding$after_inlining (after) /// CHECK-NOT: Rem public static double DoubleRemainder() { @@ -695,18 +695,18 @@ public class Main { * Exercise constant folding on left shift. */ - /// CHECK-START: int Main.ShlIntLong() constant_folding_after_inlining (before) + /// CHECK-START: int Main.ShlIntLong() constant_folding$after_inlining (before) /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1 /// CHECK-DAG: <<Const2L:j\d+>> LongConstant 2 /// CHECK-DAG: <<TypeConv:i\d+>> TypeConversion [<<Const2L>>] /// CHECK-DAG: <<Shl:i\d+>> Shl [<<Const1>>,<<TypeConv>>] /// CHECK-DAG: Return [<<Shl>>] - /// CHECK-START: int Main.ShlIntLong() constant_folding_after_inlining (after) + /// CHECK-START: int Main.ShlIntLong() constant_folding$after_inlining (after) /// CHECK-DAG: <<Const4:i\d+>> IntConstant 4 /// CHECK-DAG: Return [<<Const4>>] - /// CHECK-START: int Main.ShlIntLong() constant_folding_after_inlining (after) + /// CHECK-START: int Main.ShlIntLong() constant_folding$after_inlining (after) /// CHECK-NOT: Shl public static int ShlIntLong() { @@ -715,17 +715,17 @@ public class Main { return lhs << rhs; } - /// CHECK-START: long Main.ShlLongInt() constant_folding_after_inlining (before) + /// CHECK-START: long Main.ShlLongInt() constant_folding$after_inlining (before) /// CHECK-DAG: <<Const3L:j\d+>> LongConstant 3 /// CHECK-DAG: <<Const2:i\d+>> IntConstant 2 /// CHECK-DAG: <<Shl:j\d+>> Shl [<<Const3L>>,<<Const2>>] /// CHECK-DAG: Return [<<Shl>>] - /// CHECK-START: long Main.ShlLongInt() constant_folding_after_inlining (after) + /// CHECK-START: long Main.ShlLongInt() constant_folding$after_inlining (after) /// CHECK-DAG: <<Const12L:j\d+>> LongConstant 12 /// CHECK-DAG: Return [<<Const12L>>] - /// CHECK-START: long Main.ShlLongInt() constant_folding_after_inlining (after) + /// CHECK-START: long Main.ShlLongInt() constant_folding$after_inlining (after) /// CHECK-NOT: Shl public static long ShlLongInt() { @@ -739,18 +739,18 @@ public class Main { * Exercise constant folding on right shift. */ - /// CHECK-START: int Main.ShrIntLong() constant_folding_after_inlining (before) + /// CHECK-START: int Main.ShrIntLong() constant_folding$after_inlining (before) /// CHECK-DAG: <<Const7:i\d+>> IntConstant 7 /// CHECK-DAG: <<Const2L:j\d+>> LongConstant 2 /// CHECK-DAG: <<TypeConv:i\d+>> TypeConversion [<<Const2L>>] /// CHECK-DAG: <<Shr:i\d+>> Shr [<<Const7>>,<<TypeConv>>] /// CHECK-DAG: Return [<<Shr>>] - /// CHECK-START: int Main.ShrIntLong() constant_folding_after_inlining (after) + /// CHECK-START: int Main.ShrIntLong() constant_folding$after_inlining (after) /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1 /// CHECK-DAG: Return [<<Const1>>] - /// CHECK-START: int Main.ShrIntLong() constant_folding_after_inlining (after) + /// CHECK-START: int Main.ShrIntLong() constant_folding$after_inlining (after) /// CHECK-NOT: Shr public static int ShrIntLong() { @@ -759,17 +759,17 @@ public class Main { return lhs >> rhs; } - /// CHECK-START: long Main.ShrLongInt() constant_folding_after_inlining (before) + /// CHECK-START: long Main.ShrLongInt() constant_folding$after_inlining (before) /// CHECK-DAG: <<Const9L:j\d+>> LongConstant 9 /// CHECK-DAG: <<Const2:i\d+>> IntConstant 2 /// CHECK-DAG: <<Shr:j\d+>> Shr [<<Const9L>>,<<Const2>>] /// CHECK-DAG: Return [<<Shr>>] - /// CHECK-START: long Main.ShrLongInt() constant_folding_after_inlining (after) + /// CHECK-START: long Main.ShrLongInt() constant_folding$after_inlining (after) /// CHECK-DAG: <<Const2L:j\d+>> LongConstant 2 /// CHECK-DAG: Return [<<Const2L>>] - /// CHECK-START: long Main.ShrLongInt() constant_folding_after_inlining (after) + /// CHECK-START: long Main.ShrLongInt() constant_folding$after_inlining (after) /// CHECK-NOT: Shr public static long ShrLongInt() { @@ -783,18 +783,18 @@ public class Main { * Exercise constant folding on unsigned right shift. */ - /// CHECK-START: int Main.UShrIntLong() constant_folding_after_inlining (before) + /// CHECK-START: int Main.UShrIntLong() constant_folding$after_inlining (before) /// CHECK-DAG: <<ConstM7:i\d+>> IntConstant -7 /// CHECK-DAG: <<Const2L:j\d+>> LongConstant 2 /// CHECK-DAG: <<TypeConv:i\d+>> TypeConversion [<<Const2L>>] /// CHECK-DAG: <<UShr:i\d+>> UShr [<<ConstM7>>,<<TypeConv>>] /// CHECK-DAG: Return [<<UShr>>] - /// CHECK-START: int Main.UShrIntLong() constant_folding_after_inlining (after) + /// CHECK-START: int Main.UShrIntLong() constant_folding$after_inlining (after) /// CHECK-DAG: <<ConstRes:i\d+>> IntConstant 1073741822 /// CHECK-DAG: Return [<<ConstRes>>] - /// CHECK-START: int Main.UShrIntLong() constant_folding_after_inlining (after) + /// CHECK-START: int Main.UShrIntLong() constant_folding$after_inlining (after) /// CHECK-NOT: UShr public static int UShrIntLong() { @@ -803,17 +803,17 @@ public class Main { return lhs >>> rhs; } - /// CHECK-START: long Main.UShrLongInt() constant_folding_after_inlining (before) + /// CHECK-START: long Main.UShrLongInt() constant_folding$after_inlining (before) /// CHECK-DAG: <<ConstM9L:j\d+>> LongConstant -9 /// CHECK-DAG: <<Const2:i\d+>> IntConstant 2 /// CHECK-DAG: <<UShr:j\d+>> UShr [<<ConstM9L>>,<<Const2>>] /// CHECK-DAG: Return [<<UShr>>] - /// CHECK-START: long Main.UShrLongInt() constant_folding_after_inlining (after) + /// CHECK-START: long Main.UShrLongInt() constant_folding$after_inlining (after) /// CHECK-DAG: <<ConstRes:j\d+>> LongConstant 4611686018427387901 /// CHECK-DAG: Return [<<ConstRes>>] - /// CHECK-START: long Main.UShrLongInt() constant_folding_after_inlining (after) + /// CHECK-START: long Main.UShrLongInt() constant_folding$after_inlining (after) /// CHECK-NOT: UShr public static long UShrLongInt() { @@ -827,18 +827,18 @@ public class Main { * Exercise constant folding on logical and. */ - /// CHECK-START: long Main.AndIntLong() constant_folding_after_inlining (before) + /// CHECK-START: long Main.AndIntLong() constant_folding$after_inlining (before) /// CHECK-DAG: <<Const10:i\d+>> IntConstant 10 /// CHECK-DAG: <<Const3L:j\d+>> LongConstant 3 /// CHECK-DAG: <<TypeConv:j\d+>> TypeConversion [<<Const10>>] /// CHECK-DAG: <<And:j\d+>> And [<<TypeConv>>,<<Const3L>>] /// CHECK-DAG: Return [<<And>>] - /// CHECK-START: long Main.AndIntLong() constant_folding_after_inlining (after) + /// CHECK-START: long Main.AndIntLong() constant_folding$after_inlining (after) /// CHECK-DAG: <<Const2:j\d+>> LongConstant 2 /// CHECK-DAG: Return [<<Const2>>] - /// CHECK-START: long Main.AndIntLong() constant_folding_after_inlining (after) + /// CHECK-START: long Main.AndIntLong() constant_folding$after_inlining (after) /// CHECK-NOT: And public static long AndIntLong() { @@ -847,18 +847,18 @@ public class Main { return lhs & rhs; } - /// CHECK-START: long Main.AndLongInt() constant_folding_after_inlining (before) + /// CHECK-START: long Main.AndLongInt() constant_folding$after_inlining (before) /// CHECK-DAG: <<Const10L:j\d+>> LongConstant 10 /// CHECK-DAG: <<Const3:i\d+>> IntConstant 3 /// CHECK-DAG: <<TypeConv:j\d+>> TypeConversion [<<Const3>>] /// CHECK-DAG: <<And:j\d+>> And [<<TypeConv>>,<<Const10L>>] /// CHECK-DAG: Return [<<And>>] - /// CHECK-START: long Main.AndLongInt() constant_folding_after_inlining (after) + /// CHECK-START: long Main.AndLongInt() constant_folding$after_inlining (after) /// CHECK-DAG: <<Const2:j\d+>> LongConstant 2 /// CHECK-DAG: Return [<<Const2>>] - /// CHECK-START: long Main.AndLongInt() constant_folding_after_inlining (after) + /// CHECK-START: long Main.AndLongInt() constant_folding$after_inlining (after) /// CHECK-NOT: And public static long AndLongInt() { @@ -872,18 +872,18 @@ public class Main { * Exercise constant folding on logical or. */ - /// CHECK-START: long Main.OrIntLong() constant_folding_after_inlining (before) + /// CHECK-START: long Main.OrIntLong() constant_folding$after_inlining (before) /// CHECK-DAG: <<Const10:i\d+>> IntConstant 10 /// CHECK-DAG: <<Const3L:j\d+>> LongConstant 3 /// CHECK-DAG: <<TypeConv:j\d+>> TypeConversion [<<Const10>>] /// CHECK-DAG: <<Or:j\d+>> Or [<<TypeConv>>,<<Const3L>>] /// CHECK-DAG: Return [<<Or>>] - /// CHECK-START: long Main.OrIntLong() constant_folding_after_inlining (after) + /// CHECK-START: long Main.OrIntLong() constant_folding$after_inlining (after) /// CHECK-DAG: <<Const11:j\d+>> LongConstant 11 /// CHECK-DAG: Return [<<Const11>>] - /// CHECK-START: long Main.OrIntLong() constant_folding_after_inlining (after) + /// CHECK-START: long Main.OrIntLong() constant_folding$after_inlining (after) /// CHECK-NOT: Or public static long OrIntLong() { @@ -892,18 +892,18 @@ public class Main { return lhs | rhs; } - /// CHECK-START: long Main.OrLongInt() constant_folding_after_inlining (before) + /// CHECK-START: long Main.OrLongInt() constant_folding$after_inlining (before) /// CHECK-DAG: <<Const10L:j\d+>> LongConstant 10 /// CHECK-DAG: <<Const3:i\d+>> IntConstant 3 /// CHECK-DAG: <<TypeConv:j\d+>> TypeConversion [<<Const3>>] /// CHECK-DAG: <<Or:j\d+>> Or [<<TypeConv>>,<<Const10L>>] /// CHECK-DAG: Return [<<Or>>] - /// CHECK-START: long Main.OrLongInt() constant_folding_after_inlining (after) + /// CHECK-START: long Main.OrLongInt() constant_folding$after_inlining (after) /// CHECK-DAG: <<Const11:j\d+>> LongConstant 11 /// CHECK-DAG: Return [<<Const11>>] - /// CHECK-START: long Main.OrLongInt() constant_folding_after_inlining (after) + /// CHECK-START: long Main.OrLongInt() constant_folding$after_inlining (after) /// CHECK-NOT: Or public static long OrLongInt() { @@ -917,18 +917,18 @@ public class Main { * Exercise constant folding on logical exclusive or. */ - /// CHECK-START: long Main.XorIntLong() constant_folding_after_inlining (before) + /// CHECK-START: long Main.XorIntLong() constant_folding$after_inlining (before) /// CHECK-DAG: <<Const10:i\d+>> IntConstant 10 /// CHECK-DAG: <<Const3L:j\d+>> LongConstant 3 /// CHECK-DAG: <<TypeConv:j\d+>> TypeConversion [<<Const10>>] /// CHECK-DAG: <<Xor:j\d+>> Xor [<<TypeConv>>,<<Const3L>>] /// CHECK-DAG: Return [<<Xor>>] - /// CHECK-START: long Main.XorIntLong() constant_folding_after_inlining (after) + /// CHECK-START: long Main.XorIntLong() constant_folding$after_inlining (after) /// CHECK-DAG: <<Const9:j\d+>> LongConstant 9 /// CHECK-DAG: Return [<<Const9>>] - /// CHECK-START: long Main.XorIntLong() constant_folding_after_inlining (after) + /// CHECK-START: long Main.XorIntLong() constant_folding$after_inlining (after) /// CHECK-NOT: Xor public static long XorIntLong() { @@ -937,18 +937,18 @@ public class Main { return lhs ^ rhs; } - /// CHECK-START: long Main.XorLongInt() constant_folding_after_inlining (before) + /// CHECK-START: long Main.XorLongInt() constant_folding$after_inlining (before) /// CHECK-DAG: <<Const10L:j\d+>> LongConstant 10 /// CHECK-DAG: <<Const3:i\d+>> IntConstant 3 /// CHECK-DAG: <<TypeConv:j\d+>> TypeConversion [<<Const3>>] /// CHECK-DAG: <<Xor:j\d+>> Xor [<<TypeConv>>,<<Const10L>>] /// CHECK-DAG: Return [<<Xor>>] - /// CHECK-START: long Main.XorLongInt() constant_folding_after_inlining (after) + /// CHECK-START: long Main.XorLongInt() constant_folding$after_inlining (after) /// CHECK-DAG: <<Const9:j\d+>> LongConstant 9 /// CHECK-DAG: Return [<<Const9>>] - /// CHECK-START: long Main.XorLongInt() constant_folding_after_inlining (after) + /// CHECK-START: long Main.XorLongInt() constant_folding$after_inlining (after) /// CHECK-NOT: Xor public static long XorLongInt() { @@ -962,17 +962,17 @@ public class Main { * Exercise constant folding on constant (static) condition. */ - /// CHECK-START: int Main.StaticCondition() constant_folding_after_inlining (before) + /// CHECK-START: int Main.StaticCondition() constant_folding$after_inlining (before) /// CHECK-DAG: <<Const7:i\d+>> IntConstant 7 /// CHECK-DAG: <<Const2:i\d+>> IntConstant 2 /// CHECK-DAG: <<Cond:z\d+>> GreaterThanOrEqual [<<Const7>>,<<Const2>>] /// CHECK-DAG: Select [{{i\d+}},{{i\d+}},<<Cond>>] - /// CHECK-START: int Main.StaticCondition() constant_folding_after_inlining (after) + /// CHECK-START: int Main.StaticCondition() constant_folding$after_inlining (after) /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1 /// CHECK-DAG: Select [{{i\d+}},{{i\d+}},<<Const1>>] - /// CHECK-START: int Main.StaticCondition() constant_folding_after_inlining (after) + /// CHECK-START: int Main.StaticCondition() constant_folding$after_inlining (after) /// CHECK-NOT: GreaterThanOrEqual public static int StaticCondition() { @@ -991,16 +991,16 @@ public class Main { * Exercise constant folding on constant (static) condition for null references. */ - /// CHECK-START: int Main.StaticConditionNulls() constant_folding_after_inlining (before) + /// 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-START: int Main.StaticConditionNulls() constant_folding_after_inlining (after) + /// 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-START: int Main.StaticConditionNulls() constant_folding_after_inlining (after) + /// CHECK-START: int Main.StaticConditionNulls() constant_folding$after_inlining (after) /// CHECK-NOT: NotEqual private static Object getNull() { @@ -1023,7 +1023,7 @@ public class Main { * (forward) post-order traversal of the the dominator tree. */ - /// CHECK-START: int Main.JumpsAndConditionals(boolean) constant_folding_after_inlining (before) + /// CHECK-START: int Main.JumpsAndConditionals(boolean) constant_folding$after_inlining (before) /// CHECK-DAG: <<Cond:z\d+>> ParameterValue /// CHECK-DAG: <<Const2:i\d+>> IntConstant 2 /// CHECK-DAG: <<Const5:i\d+>> IntConstant 5 @@ -1032,14 +1032,14 @@ public class Main { /// CHECK-DAG: <<Phi:i\d+>> Select [<<Sub>>,<<Add>>,<<Cond>>] /// CHECK-DAG: Return [<<Phi>>] - /// CHECK-START: int Main.JumpsAndConditionals(boolean) constant_folding_after_inlining (after) + /// CHECK-START: int Main.JumpsAndConditionals(boolean) constant_folding$after_inlining (after) /// CHECK-DAG: <<Cond:z\d+>> ParameterValue /// CHECK-DAG: <<Const3:i\d+>> IntConstant 3 /// CHECK-DAG: <<Const7:i\d+>> IntConstant 7 /// CHECK-DAG: <<Phi:i\d+>> Select [<<Const3>>,<<Const7>>,<<Cond>>] /// CHECK-DAG: Return [<<Phi>>] - /// CHECK-START: int Main.JumpsAndConditionals(boolean) constant_folding_after_inlining (after) + /// CHECK-START: int Main.JumpsAndConditionals(boolean) constant_folding$after_inlining (after) /// CHECK-NOT: Add /// CHECK-NOT: Sub @@ -1325,16 +1325,16 @@ public class Main { * Exercise constant folding on type conversions. */ - /// CHECK-START: int Main.ReturnInt33() constant_folding_after_inlining (before) + /// CHECK-START: int Main.ReturnInt33() constant_folding$after_inlining (before) /// CHECK-DAG: <<Const33:j\d+>> LongConstant 33 /// CHECK-DAG: <<Convert:i\d+>> TypeConversion [<<Const33>>] /// CHECK-DAG: Return [<<Convert>>] - /// CHECK-START: int Main.ReturnInt33() constant_folding_after_inlining (after) + /// CHECK-START: int Main.ReturnInt33() constant_folding$after_inlining (after) /// CHECK-DAG: <<Const33:i\d+>> IntConstant 33 /// CHECK-DAG: Return [<<Const33>>] - /// CHECK-START: int Main.ReturnInt33() constant_folding_after_inlining (after) + /// CHECK-START: int Main.ReturnInt33() constant_folding$after_inlining (after) /// CHECK-NOT: TypeConversion public static int ReturnInt33() { @@ -1342,16 +1342,16 @@ public class Main { return (int) imm; } - /// CHECK-START: int Main.ReturnIntMax() constant_folding_after_inlining (before) + /// CHECK-START: int Main.ReturnIntMax() constant_folding$after_inlining (before) /// CHECK-DAG: <<ConstMax:f\d+>> FloatConstant 1e+34 /// CHECK-DAG: <<Convert:i\d+>> TypeConversion [<<ConstMax>>] /// CHECK-DAG: Return [<<Convert>>] - /// CHECK-START: int Main.ReturnIntMax() constant_folding_after_inlining (after) + /// CHECK-START: int Main.ReturnIntMax() constant_folding$after_inlining (after) /// CHECK-DAG: <<ConstMax:i\d+>> IntConstant 2147483647 /// CHECK-DAG: Return [<<ConstMax>>] - /// CHECK-START: int Main.ReturnIntMax() constant_folding_after_inlining (after) + /// CHECK-START: int Main.ReturnIntMax() constant_folding$after_inlining (after) /// CHECK-NOT: TypeConversion public static int ReturnIntMax() { @@ -1359,16 +1359,16 @@ public class Main { return (int) imm; } - /// CHECK-START: int Main.ReturnInt0() constant_folding_after_inlining (before) + /// CHECK-START: int Main.ReturnInt0() constant_folding$after_inlining (before) /// CHECK-DAG: <<ConstNaN:d\d+>> DoubleConstant nan /// CHECK-DAG: <<Convert:i\d+>> TypeConversion [<<ConstNaN>>] /// CHECK-DAG: Return [<<Convert>>] - /// CHECK-START: int Main.ReturnInt0() constant_folding_after_inlining (after) + /// CHECK-START: int Main.ReturnInt0() constant_folding$after_inlining (after) /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 /// CHECK-DAG: Return [<<Const0>>] - /// CHECK-START: int Main.ReturnInt0() constant_folding_after_inlining (after) + /// CHECK-START: int Main.ReturnInt0() constant_folding$after_inlining (after) /// CHECK-NOT: TypeConversion public static int ReturnInt0() { @@ -1376,16 +1376,16 @@ public class Main { return (int) imm; } - /// CHECK-START: long Main.ReturnLong33() constant_folding_after_inlining (before) + /// CHECK-START: long Main.ReturnLong33() constant_folding$after_inlining (before) /// CHECK-DAG: <<Const33:i\d+>> IntConstant 33 /// CHECK-DAG: <<Convert:j\d+>> TypeConversion [<<Const33>>] /// CHECK-DAG: Return [<<Convert>>] - /// CHECK-START: long Main.ReturnLong33() constant_folding_after_inlining (after) + /// CHECK-START: long Main.ReturnLong33() constant_folding$after_inlining (after) /// CHECK-DAG: <<Const33:j\d+>> LongConstant 33 /// CHECK-DAG: Return [<<Const33>>] - /// CHECK-START: long Main.ReturnLong33() constant_folding_after_inlining (after) + /// CHECK-START: long Main.ReturnLong33() constant_folding$after_inlining (after) /// CHECK-NOT: TypeConversion public static long ReturnLong33() { @@ -1393,16 +1393,16 @@ public class Main { return (long) imm; } - /// CHECK-START: long Main.ReturnLong34() constant_folding_after_inlining (before) + /// CHECK-START: long Main.ReturnLong34() constant_folding$after_inlining (before) /// CHECK-DAG: <<Const34:f\d+>> FloatConstant 34 /// CHECK-DAG: <<Convert:j\d+>> TypeConversion [<<Const34>>] /// CHECK-DAG: Return [<<Convert>>] - /// CHECK-START: long Main.ReturnLong34() constant_folding_after_inlining (after) + /// CHECK-START: long Main.ReturnLong34() constant_folding$after_inlining (after) /// CHECK-DAG: <<Const34:j\d+>> LongConstant 34 /// CHECK-DAG: Return [<<Const34>>] - /// CHECK-START: long Main.ReturnLong34() constant_folding_after_inlining (after) + /// CHECK-START: long Main.ReturnLong34() constant_folding$after_inlining (after) /// CHECK-NOT: TypeConversion public static long ReturnLong34() { @@ -1410,16 +1410,16 @@ public class Main { return (long) imm; } - /// CHECK-START: long Main.ReturnLong0() constant_folding_after_inlining (before) + /// CHECK-START: long Main.ReturnLong0() constant_folding$after_inlining (before) /// CHECK-DAG: <<ConstNaN:d\d+>> DoubleConstant nan /// CHECK-DAG: <<Convert:j\d+>> TypeConversion [<<ConstNaN>>] /// CHECK-DAG: Return [<<Convert>>] - /// CHECK-START: long Main.ReturnLong0() constant_folding_after_inlining (after) + /// CHECK-START: long Main.ReturnLong0() constant_folding$after_inlining (after) /// CHECK-DAG: <<Const0:j\d+>> LongConstant 0 /// CHECK-DAG: Return [<<Const0>>] - /// CHECK-START: long Main.ReturnLong0() constant_folding_after_inlining (after) + /// CHECK-START: long Main.ReturnLong0() constant_folding$after_inlining (after) /// CHECK-NOT: TypeConversion public static long ReturnLong0() { @@ -1427,16 +1427,16 @@ public class Main { return (long) imm; } - /// CHECK-START: float Main.ReturnFloat33() constant_folding_after_inlining (before) + /// CHECK-START: float Main.ReturnFloat33() constant_folding$after_inlining (before) /// CHECK-DAG: <<Const33:i\d+>> IntConstant 33 /// CHECK-DAG: <<Convert:f\d+>> TypeConversion [<<Const33>>] /// CHECK-DAG: Return [<<Convert>>] - /// CHECK-START: float Main.ReturnFloat33() constant_folding_after_inlining (after) + /// CHECK-START: float Main.ReturnFloat33() constant_folding$after_inlining (after) /// CHECK-DAG: <<Const33:f\d+>> FloatConstant 33 /// CHECK-DAG: Return [<<Const33>>] - /// CHECK-START: float Main.ReturnFloat33() constant_folding_after_inlining (after) + /// CHECK-START: float Main.ReturnFloat33() constant_folding$after_inlining (after) /// CHECK-NOT: TypeConversion public static float ReturnFloat33() { @@ -1444,16 +1444,16 @@ public class Main { return (float) imm; } - /// CHECK-START: float Main.ReturnFloat34() constant_folding_after_inlining (before) + /// CHECK-START: float Main.ReturnFloat34() constant_folding$after_inlining (before) /// CHECK-DAG: <<Const34:j\d+>> LongConstant 34 /// CHECK-DAG: <<Convert:f\d+>> TypeConversion [<<Const34>>] /// CHECK-DAG: Return [<<Convert>>] - /// CHECK-START: float Main.ReturnFloat34() constant_folding_after_inlining (after) + /// CHECK-START: float Main.ReturnFloat34() constant_folding$after_inlining (after) /// CHECK-DAG: <<Const34:f\d+>> FloatConstant 34 /// CHECK-DAG: Return [<<Const34>>] - /// CHECK-START: float Main.ReturnFloat34() constant_folding_after_inlining (after) + /// CHECK-START: float Main.ReturnFloat34() constant_folding$after_inlining (after) /// CHECK-NOT: TypeConversion public static float ReturnFloat34() { @@ -1461,16 +1461,16 @@ public class Main { return (float) imm; } - /// CHECK-START: float Main.ReturnFloat99P25() constant_folding_after_inlining (before) + /// CHECK-START: float Main.ReturnFloat99P25() constant_folding$after_inlining (before) /// CHECK-DAG: <<Const:d\d+>> DoubleConstant 99.25 /// CHECK-DAG: <<Convert:f\d+>> TypeConversion [<<Const>>] /// CHECK-DAG: Return [<<Convert>>] - /// CHECK-START: float Main.ReturnFloat99P25() constant_folding_after_inlining (after) + /// CHECK-START: float Main.ReturnFloat99P25() constant_folding$after_inlining (after) /// CHECK-DAG: <<Const:f\d+>> FloatConstant 99.25 /// CHECK-DAG: Return [<<Const>>] - /// CHECK-START: float Main.ReturnFloat99P25() constant_folding_after_inlining (after) + /// CHECK-START: float Main.ReturnFloat99P25() constant_folding$after_inlining (after) /// CHECK-NOT: TypeConversion public static float ReturnFloat99P25() { @@ -1478,12 +1478,12 @@ public class Main { return (float) imm; } - /// CHECK-START: double Main.ReturnDouble33() constant_folding_after_inlining (before) + /// CHECK-START: double Main.ReturnDouble33() constant_folding$after_inlining (before) /// CHECK-DAG: <<Const33:i\d+>> IntConstant 33 /// CHECK-DAG: <<Convert:d\d+>> TypeConversion [<<Const33>>] /// CHECK-DAG: Return [<<Convert>>] - /// CHECK-START: double Main.ReturnDouble33() constant_folding_after_inlining (after) + /// CHECK-START: double Main.ReturnDouble33() constant_folding$after_inlining (after) /// CHECK-DAG: <<Const33:d\d+>> DoubleConstant 33 /// CHECK-DAG: Return [<<Const33>>] @@ -1492,16 +1492,16 @@ public class Main { return (double) imm; } - /// CHECK-START: double Main.ReturnDouble34() constant_folding_after_inlining (before) + /// CHECK-START: double Main.ReturnDouble34() constant_folding$after_inlining (before) /// CHECK-DAG: <<Const34:j\d+>> LongConstant 34 /// CHECK-DAG: <<Convert:d\d+>> TypeConversion [<<Const34>>] /// CHECK-DAG: Return [<<Convert>>] - /// CHECK-START: double Main.ReturnDouble34() constant_folding_after_inlining (after) + /// CHECK-START: double Main.ReturnDouble34() constant_folding$after_inlining (after) /// CHECK-DAG: <<Const34:d\d+>> DoubleConstant 34 /// CHECK-DAG: Return [<<Const34>>] - /// CHECK-START: double Main.ReturnDouble34() constant_folding_after_inlining (after) + /// CHECK-START: double Main.ReturnDouble34() constant_folding$after_inlining (after) /// CHECK-NOT: TypeConversion public static double ReturnDouble34() { @@ -1509,16 +1509,16 @@ public class Main { return (double) imm; } - /// CHECK-START: double Main.ReturnDouble99P25() constant_folding_after_inlining (before) + /// CHECK-START: double Main.ReturnDouble99P25() constant_folding$after_inlining (before) /// CHECK-DAG: <<Const:f\d+>> FloatConstant 99.25 /// CHECK-DAG: <<Convert:d\d+>> TypeConversion [<<Const>>] /// CHECK-DAG: Return [<<Convert>>] - /// CHECK-START: double Main.ReturnDouble99P25() constant_folding_after_inlining (after) + /// CHECK-START: double Main.ReturnDouble99P25() constant_folding$after_inlining (after) /// CHECK-DAG: <<Const:d\d+>> DoubleConstant 99.25 /// CHECK-DAG: Return [<<Const>>] - /// CHECK-START: double Main.ReturnDouble99P25() constant_folding_after_inlining (after) + /// CHECK-START: double Main.ReturnDouble99P25() constant_folding$after_inlining (after) /// CHECK-NOT: TypeConversion public static double ReturnDouble99P25() { diff --git a/test/449-checker-bce/src/Main.java b/test/449-checker-bce/src/Main.java index c125e337cb..3a56c3b7d5 100644 --- a/test/449-checker-bce/src/Main.java +++ b/test/449-checker-bce/src/Main.java @@ -1380,7 +1380,7 @@ public class Main { /// 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$after_bce (after) // Simplification removes the redundant check /// CHECK: Deoptimize /// CHECK: Deoptimize diff --git a/test/450-checker-types/src/Main.java b/test/450-checker-types/src/Main.java index 99a1557eaf..6e453af616 100644 --- a/test/450-checker-types/src/Main.java +++ b/test/450-checker-types/src/Main.java @@ -214,11 +214,11 @@ public class Main { /// CHECK-DAG: <<IOf:z\d+>> InstanceOf /// CHECK-DAG: If [<<IOf>>] - /// CHECK-START: void Main.testInstanceOf_Inlined(java.lang.Object) instruction_simplifier_after_bce (before) + /// CHECK-START: void Main.testInstanceOf_Inlined(java.lang.Object) instruction_simplifier$after_bce (before) /// CHECK: CheckCast /// CHECK-NOT: CheckCast - /// CHECK-START: void Main.testInstanceOf_Inlined(java.lang.Object) instruction_simplifier_after_bce (after) + /// CHECK-START: void Main.testInstanceOf_Inlined(java.lang.Object) instruction_simplifier$after_bce (after) /// CHECK-NOT: CheckCast public void testInstanceOf_Inlined(Object o) { if (!$inline$InstanceofSubclassC(o)) { diff --git a/test/458-checker-instruction-simplification/src/Main.java b/test/458-checker-instruction-simplification/src/Main.java index 8a426eba60..5b1473523b 100644 --- a/test/458-checker-instruction-simplification/src/Main.java +++ b/test/458-checker-instruction-simplification/src/Main.java @@ -876,7 +876,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_inlining (after) /// CHECK: <<Const0:i\d+>> IntConstant 0 /// CHECK-NOT: Neg /// CHECK-NOT: Add @@ -1126,7 +1126,7 @@ public class Main { return res; } - /// CHECK-START: boolean Main.$noinline$EqualBoolVsIntConst(boolean) instruction_simplifier_after_bce (before) + /// CHECK-START: boolean Main.$noinline$EqualBoolVsIntConst(boolean) instruction_simplifier$after_bce (before) /// CHECK-DAG: <<Arg:z\d+>> ParameterValue /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1 @@ -1136,7 +1136,7 @@ public class Main { /// CHECK-DAG: <<NotCond:i\d+>> Select [<<Const1>>,<<Const0>>,<<Cond>>] /// CHECK-DAG: Return [<<NotCond>>] - /// CHECK-START: boolean Main.$noinline$EqualBoolVsIntConst(boolean) instruction_simplifier_after_bce (after) + /// CHECK-START: boolean Main.$noinline$EqualBoolVsIntConst(boolean) instruction_simplifier$after_bce (after) /// CHECK-DAG: <<True:i\d+>> IntConstant 1 /// CHECK-DAG: Return [<<True>>] @@ -1151,7 +1151,7 @@ public class Main { return arg; } - /// CHECK-START: boolean Main.$noinline$NotEqualBoolVsIntConst(boolean) instruction_simplifier_after_bce (before) + /// CHECK-START: boolean Main.$noinline$NotEqualBoolVsIntConst(boolean) instruction_simplifier$after_bce (before) /// CHECK-DAG: <<Arg:z\d+>> ParameterValue /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1 @@ -1161,7 +1161,7 @@ public class Main { /// CHECK-DAG: <<NotCond:i\d+>> Select [<<Const1>>,<<Const0>>,<<Cond>>] /// CHECK-DAG: Return [<<NotCond>>] - /// CHECK-START: boolean Main.$noinline$NotEqualBoolVsIntConst(boolean) instruction_simplifier_after_bce (after) + /// CHECK-START: boolean Main.$noinline$NotEqualBoolVsIntConst(boolean) instruction_simplifier$after_bce (after) /// CHECK-DAG: <<False:i\d+>> IntConstant 0 /// CHECK-DAG: Return [<<False>>] @@ -1178,7 +1178,7 @@ public class Main { * remove the second. */ - /// CHECK-START: boolean Main.$noinline$NotNotBool(boolean) instruction_simplifier_after_bce (before) + /// CHECK-START: boolean Main.$noinline$NotNotBool(boolean) instruction_simplifier$after_bce (before) /// CHECK-DAG: <<Arg:z\d+>> ParameterValue /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1 @@ -1186,7 +1186,7 @@ public class Main { /// CHECK-DAG: <<NotNotArg:i\d+>> Select [<<Const1>>,<<Const0>>,<<NotArg>>] /// CHECK-DAG: Return [<<NotNotArg>>] - /// CHECK-START: boolean Main.$noinline$NotNotBool(boolean) instruction_simplifier_after_bce (after) + /// CHECK-START: boolean Main.$noinline$NotNotBool(boolean) instruction_simplifier$after_bce (after) /// CHECK-DAG: <<Arg:z\d+>> ParameterValue /// CHECK-DAG: Return [<<Arg>>] @@ -1317,7 +1317,7 @@ public class Main { return arg * 31; } - /// CHECK-START: int Main.$noinline$booleanFieldNotEqualOne() instruction_simplifier_after_bce (before) + /// CHECK-START: int Main.$noinline$booleanFieldNotEqualOne() instruction_simplifier$after_bce (before) /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1 /// CHECK-DAG: <<Const13:i\d+>> IntConstant 13 /// CHECK-DAG: <<Const54:i\d+>> IntConstant 54 @@ -1327,7 +1327,7 @@ public class Main { /// CHECK-DAG: <<Select:i\d+>> Select [<<Const13>>,<<Const54>>,<<NE>>] /// CHECK-DAG: Return [<<Select>>] - /// CHECK-START: int Main.$noinline$booleanFieldNotEqualOne() instruction_simplifier_after_bce (after) + /// CHECK-START: int Main.$noinline$booleanFieldNotEqualOne() instruction_simplifier$after_bce (after) /// CHECK-DAG: <<doThrow:z\d+>> StaticFieldGet /// CHECK-DAG: <<Field:z\d+>> StaticFieldGet /// CHECK-DAG: <<Const13:i\d+>> IntConstant 13 @@ -1340,7 +1340,7 @@ public class Main { return (booleanField == $inline$true()) ? 13 : 54; } - /// CHECK-START: int Main.$noinline$booleanFieldEqualZero() instruction_simplifier_after_bce (before) + /// CHECK-START: int Main.$noinline$booleanFieldEqualZero() instruction_simplifier$after_bce (before) /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 /// CHECK-DAG: <<Const13:i\d+>> IntConstant 13 /// CHECK-DAG: <<Const54:i\d+>> IntConstant 54 @@ -1350,7 +1350,7 @@ public class Main { /// CHECK-DAG: <<Select:i\d+>> Select [<<Const13>>,<<Const54>>,<<NE>>] /// CHECK-DAG: Return [<<Select>>] - /// CHECK-START: int Main.$noinline$booleanFieldEqualZero() instruction_simplifier_after_bce (after) + /// CHECK-START: int Main.$noinline$booleanFieldEqualZero() instruction_simplifier$after_bce (after) /// CHECK-DAG: <<doThrow:z\d+>> StaticFieldGet /// CHECK-DAG: <<Field:z\d+>> StaticFieldGet /// CHECK-DAG: <<Const13:i\d+>> IntConstant 13 @@ -1363,7 +1363,7 @@ public class Main { return (booleanField != $inline$false()) ? 13 : 54; } - /// CHECK-START: int Main.$noinline$intConditionNotEqualOne(int) instruction_simplifier_after_bce (before) + /// CHECK-START: int Main.$noinline$intConditionNotEqualOne(int) instruction_simplifier$after_bce (before) /// CHECK-DAG: <<Arg:i\d+>> ParameterValue /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1 @@ -1376,7 +1376,7 @@ public class Main { /// CHECK-DAG: <<Result:i\d+>> Select [<<Const13>>,<<Const54>>,<<NE>>] /// CHECK-DAG: Return [<<Result>>] - /// CHECK-START: int Main.$noinline$intConditionNotEqualOne(int) instruction_simplifier_after_bce (after) + /// CHECK-START: int Main.$noinline$intConditionNotEqualOne(int) instruction_simplifier$after_bce (after) /// CHECK-DAG: <<Arg:i\d+>> ParameterValue /// CHECK-DAG: <<Const13:i\d+>> IntConstant 13 /// CHECK-DAG: <<Const42:i\d+>> IntConstant 42 @@ -1392,7 +1392,7 @@ public class Main { return ((i > 42) == $inline$true()) ? 13 : 54; } - /// CHECK-START: int Main.$noinline$intConditionEqualZero(int) instruction_simplifier_after_bce (before) + /// CHECK-START: int Main.$noinline$intConditionEqualZero(int) instruction_simplifier$after_bce (before) /// CHECK-DAG: <<Arg:i\d+>> ParameterValue /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1 @@ -1405,7 +1405,7 @@ public class Main { /// CHECK-DAG: <<Result:i\d+>> Select [<<Const13>>,<<Const54>>,<<NE>>] /// CHECK-DAG: Return [<<Result>>] - /// CHECK-START: int Main.$noinline$intConditionEqualZero(int) instruction_simplifier_after_bce (after) + /// CHECK-START: int Main.$noinline$intConditionEqualZero(int) instruction_simplifier$after_bce (after) /// CHECK-DAG: <<Arg:i\d+>> ParameterValue /// CHECK-DAG: <<Const13:i\d+>> IntConstant 13 /// CHECK-DAG: <<Const42:i\d+>> IntConstant 42 @@ -1426,7 +1426,7 @@ public class Main { /// CHECK-START: int Main.$noinline$floatConditionNotEqualOne(float) builder (after) /// CHECK: LessThanOrEqual - /// CHECK-START: int Main.$noinline$floatConditionNotEqualOne(float) instruction_simplifier_before_codegen (after) + /// CHECK-START: int Main.$noinline$floatConditionNotEqualOne(float) instruction_simplifier$before_codegen (after) /// CHECK-DAG: <<Arg:f\d+>> ParameterValue /// CHECK-DAG: <<Const13:i\d+>> IntConstant 13 /// CHECK-DAG: <<Const54:i\d+>> IntConstant 54 @@ -1443,7 +1443,7 @@ public class Main { /// CHECK-START: int Main.$noinline$doubleConditionEqualZero(double) builder (after) /// CHECK: LessThanOrEqual - /// CHECK-START: int Main.$noinline$doubleConditionEqualZero(double) instruction_simplifier_before_codegen (after) + /// CHECK-START: int Main.$noinline$doubleConditionEqualZero(double) instruction_simplifier$before_codegen (after) /// CHECK-DAG: <<Arg:d\d+>> ParameterValue /// CHECK-DAG: <<Const13:i\d+>> IntConstant 13 /// CHECK-DAG: <<Const54:i\d+>> IntConstant 54 diff --git a/test/480-checker-dead-blocks/src/Main.java b/test/480-checker-dead-blocks/src/Main.java index e5171f045f..141054d23a 100644 --- a/test/480-checker-dead-blocks/src/Main.java +++ b/test/480-checker-dead-blocks/src/Main.java @@ -30,7 +30,7 @@ public class Main { return false; } - /// CHECK-START: int Main.testTrueBranch(int, int) dead_code_elimination_final (before) + /// CHECK-START: int Main.testTrueBranch(int, int) dead_code_elimination$final (before) /// CHECK-DAG: <<ArgX:i\d+>> ParameterValue /// CHECK-DAG: <<ArgY:i\d+>> ParameterValue /// CHECK-DAG: If @@ -39,13 +39,13 @@ public class Main { /// CHECK-DAG: <<Phi:i\d+>> Phi [<<Add>>,<<Sub>>] /// CHECK-DAG: Return [<<Phi>>] - /// CHECK-START: int Main.testTrueBranch(int, int) dead_code_elimination_final (after) + /// CHECK-START: int Main.testTrueBranch(int, int) dead_code_elimination$final (after) /// CHECK-DAG: <<ArgX:i\d+>> ParameterValue /// CHECK-DAG: <<ArgY:i\d+>> ParameterValue /// CHECK-DAG: <<Add:i\d+>> Add [<<ArgX>>,<<ArgY>>] /// CHECK-DAG: Return [<<Add>>] - /// CHECK-START: int Main.testTrueBranch(int, int) dead_code_elimination_final (after) + /// CHECK-START: int Main.testTrueBranch(int, int) dead_code_elimination$final (after) /// CHECK-NOT: If /// CHECK-NOT: Sub /// CHECK-NOT: Phi @@ -62,7 +62,7 @@ public class Main { return z; } - /// CHECK-START: int Main.testFalseBranch(int, int) dead_code_elimination_final (before) + /// CHECK-START: int Main.testFalseBranch(int, int) dead_code_elimination$final (before) /// CHECK-DAG: <<ArgX:i\d+>> ParameterValue /// CHECK-DAG: <<ArgY:i\d+>> ParameterValue /// CHECK-DAG: If @@ -71,13 +71,13 @@ public class Main { /// CHECK-DAG: <<Phi:i\d+>> Phi [<<Add>>,<<Sub>>] /// CHECK-DAG: Return [<<Phi>>] - /// CHECK-START: int Main.testFalseBranch(int, int) dead_code_elimination_final (after) + /// CHECK-START: int Main.testFalseBranch(int, int) dead_code_elimination$final (after) /// CHECK-DAG: <<ArgX:i\d+>> ParameterValue /// CHECK-DAG: <<ArgY:i\d+>> ParameterValue /// CHECK-DAG: <<Sub:i\d+>> Sub [<<ArgX>>,<<ArgY>>] /// CHECK-DAG: Return [<<Sub>>] - /// CHECK-START: int Main.testFalseBranch(int, int) dead_code_elimination_final (after) + /// CHECK-START: int Main.testFalseBranch(int, int) dead_code_elimination$final (after) /// CHECK-NOT: If /// CHECK-NOT: Add /// CHECK-NOT: Phi @@ -94,10 +94,10 @@ public class Main { return z; } - /// CHECK-START: int Main.testRemoveLoop(int) dead_code_elimination_final (before) + /// CHECK-START: int Main.testRemoveLoop(int) dead_code_elimination$final (before) /// CHECK: Mul - /// CHECK-START: int Main.testRemoveLoop(int) dead_code_elimination_final (after) + /// CHECK-START: int Main.testRemoveLoop(int) dead_code_elimination$final (after) /// CHECK-NOT: Mul public static int testRemoveLoop(int x) { @@ -109,11 +109,11 @@ public class Main { return x; } - /// CHECK-START: int Main.testInfiniteLoop(int) dead_code_elimination_final (before) + /// CHECK-START: int Main.testInfiniteLoop(int) dead_code_elimination$final (before) /// CHECK-DAG: Return /// CHECK-DAG: Exit - /// CHECK-START: int Main.testInfiniteLoop(int) dead_code_elimination_final (after) + /// CHECK-START: int Main.testInfiniteLoop(int) dead_code_elimination$final (after) /// CHECK-NOT: Return /// CHECK-NOT: Exit @@ -124,15 +124,15 @@ public class Main { return x; } - /// CHECK-START: int Main.testDeadLoop(int) dead_code_elimination_final (before) + /// CHECK-START: int Main.testDeadLoop(int) dead_code_elimination$final (before) /// CHECK-DAG: If /// CHECK-DAG: Add - /// CHECK-START: int Main.testDeadLoop(int) dead_code_elimination_final (after) + /// CHECK-START: int Main.testDeadLoop(int) dead_code_elimination$final (after) /// CHECK-DAG: <<Arg:i\d+>> ParameterValue /// CHECK-DAG: Return [<<Arg>>] - /// CHECK-START: int Main.testDeadLoop(int) dead_code_elimination_final (after) + /// CHECK-START: int Main.testDeadLoop(int) dead_code_elimination$final (after) /// CHECK-NOT: If /// CHECK-NOT: Add @@ -143,16 +143,16 @@ public class Main { return x; } - /// CHECK-START: int Main.testUpdateLoopInformation(int) dead_code_elimination_final (before) + /// CHECK-START: int Main.testUpdateLoopInformation(int) dead_code_elimination$final (before) /// CHECK-DAG: If /// CHECK-DAG: If /// CHECK-DAG: Add - /// CHECK-START: int Main.testUpdateLoopInformation(int) dead_code_elimination_final (after) + /// CHECK-START: int Main.testUpdateLoopInformation(int) dead_code_elimination$final (after) /// CHECK-DAG: <<Arg:i\d+>> ParameterValue /// CHECK-DAG: Return [<<Arg>>] - /// CHECK-START: int Main.testUpdateLoopInformation(int) dead_code_elimination_final (after) + /// CHECK-START: int Main.testUpdateLoopInformation(int) dead_code_elimination$final (after) /// CHECK-NOT: If /// CHECK-NOT: Add @@ -165,13 +165,13 @@ public class Main { return x; } - /// CHECK-START: int Main.testRemoveSuspendCheck(int, int) dead_code_elimination_final (before) + /// CHECK-START: int Main.testRemoveSuspendCheck(int, int) dead_code_elimination$final (before) /// CHECK: SuspendCheck /// CHECK: SuspendCheck /// CHECK: SuspendCheck /// CHECK-NOT: SuspendCheck - /// CHECK-START: int Main.testRemoveSuspendCheck(int, int) dead_code_elimination_final (after) + /// CHECK-START: int Main.testRemoveSuspendCheck(int, int) dead_code_elimination$final (after) /// CHECK: SuspendCheck /// CHECK: SuspendCheck /// CHECK-NOT: SuspendCheck diff --git a/test/485-checker-dce-loop-update/smali/TestCase.smali b/test/485-checker-dce-loop-update/smali/TestCase.smali index 056f22c71c..e3617c7477 100644 --- a/test/485-checker-dce-loop-update/smali/TestCase.smali +++ b/test/485-checker-dce-loop-update/smali/TestCase.smali @@ -23,7 +23,7 @@ .end method -## CHECK-START: int TestCase.testSingleExit(int, boolean) dead_code_elimination_final (before) +## CHECK-START: int TestCase.testSingleExit(int, boolean) dead_code_elimination$final (before) ## CHECK-DAG: <<ArgX:i\d+>> ParameterValue ## CHECK-DAG: <<ArgY:z\d+>> ParameterValue ## CHECK-DAG: <<Cst1:i\d+>> IntConstant 1 @@ -36,7 +36,7 @@ ## CHECK-DAG: <<Add7>> Add [<<PhiX>>,<<Cst7>>] loop:<<HeaderY>> ## CHECK-DAG: Return [<<PhiX>>] loop:none -## CHECK-START: int TestCase.testSingleExit(int, boolean) dead_code_elimination_final (after) +## CHECK-START: int TestCase.testSingleExit(int, boolean) dead_code_elimination$final (after) ## CHECK-DAG: <<ArgX:i\d+>> ParameterValue ## CHECK-DAG: <<ArgY:z\d+>> ParameterValue ## CHECK-DAG: <<Cst7:i\d+>> IntConstant 7 @@ -73,7 +73,7 @@ .end method -## CHECK-START: int TestCase.testMultipleExits(int, boolean, boolean) dead_code_elimination_final (before) +## CHECK-START: int TestCase.testMultipleExits(int, boolean, boolean) dead_code_elimination$final (before) ## CHECK-DAG: <<ArgX:i\d+>> ParameterValue ## CHECK-DAG: <<ArgY:z\d+>> ParameterValue ## CHECK-DAG: <<ArgZ:z\d+>> ParameterValue @@ -88,7 +88,7 @@ ## CHECK-DAG: <<Add7>> Add [<<PhiX>>,<<Cst7>>] loop:<<HeaderY>> ## CHECK-DAG: Return [<<PhiX>>] loop:none -## CHECK-START: int TestCase.testMultipleExits(int, boolean, boolean) dead_code_elimination_final (after) +## CHECK-START: int TestCase.testMultipleExits(int, boolean, boolean) dead_code_elimination$final (after) ## CHECK-DAG: <<ArgX:i\d+>> ParameterValue ## CHECK-DAG: <<ArgY:z\d+>> ParameterValue ## CHECK-DAG: <<ArgZ:z\d+>> ParameterValue @@ -129,7 +129,7 @@ .end method -## CHECK-START: int TestCase.testExitPredecessors(int, boolean, boolean) dead_code_elimination_final (before) +## CHECK-START: int TestCase.testExitPredecessors(int, boolean, boolean) dead_code_elimination$final (before) ## CHECK-DAG: <<ArgX:i\d+>> ParameterValue ## CHECK-DAG: <<ArgY:z\d+>> ParameterValue ## CHECK-DAG: <<ArgZ:z\d+>> ParameterValue @@ -146,7 +146,7 @@ ## CHECK-DAG: <<Add7>> Add [<<PhiX>>,<<Cst7>>] loop:<<HeaderY>> ## CHECK-DAG: Return [<<SelX>>] loop:none -## CHECK-START: int TestCase.testExitPredecessors(int, boolean, boolean) dead_code_elimination_final (after) +## CHECK-START: int TestCase.testExitPredecessors(int, boolean, boolean) dead_code_elimination$final (after) ## CHECK-DAG: <<ArgX:i\d+>> ParameterValue ## CHECK-DAG: <<ArgY:z\d+>> ParameterValue ## CHECK-DAG: <<ArgZ:z\d+>> ParameterValue @@ -194,7 +194,7 @@ .end method -## CHECK-START: int TestCase.testInnerLoop(int, boolean, boolean) dead_code_elimination_final (before) +## CHECK-START: int TestCase.testInnerLoop(int, boolean, boolean) dead_code_elimination$final (before) ## CHECK-DAG: <<ArgX:i\d+>> ParameterValue ## CHECK-DAG: <<ArgY:z\d+>> ParameterValue ## CHECK-DAG: <<ArgZ:z\d+>> ParameterValue @@ -217,7 +217,7 @@ ## CHECK-DAG: <<Add7>> Add [<<PhiX>>,<<Cst7>>] loop:<<HeaderY>> ## CHECK-DAG: Return [<<PhiX>>] loop:none -## CHECK-START: int TestCase.testInnerLoop(int, boolean, boolean) dead_code_elimination_final (after) +## CHECK-START: int TestCase.testInnerLoop(int, boolean, boolean) dead_code_elimination$final (after) ## CHECK-DAG: <<ArgX:i\d+>> ParameterValue ## CHECK-DAG: <<ArgY:z\d+>> ParameterValue ## CHECK-DAG: <<ArgZ:z\d+>> ParameterValue diff --git a/test/485-checker-dce-switch/src/Main.java b/test/485-checker-dce-switch/src/Main.java index 019d876ec8..7d5fd4fd53 100644 --- a/test/485-checker-dce-switch/src/Main.java +++ b/test/485-checker-dce-switch/src/Main.java @@ -20,14 +20,14 @@ public class Main { return 5; } - /// CHECK-START: int Main.wholeSwitchDead(int) dead_code_elimination_final (before) + /// CHECK-START: int Main.wholeSwitchDead(int) dead_code_elimination$final (before) /// CHECK-DAG: PackedSwitch - /// CHECK-START: int Main.wholeSwitchDead(int) dead_code_elimination_final (after) + /// CHECK-START: int Main.wholeSwitchDead(int) dead_code_elimination$final (after) /// CHECK-DAG: <<Const100:i\d+>> IntConstant 100 /// CHECK-DAG: Return [<<Const100>>] - /// CHECK-START: int Main.wholeSwitchDead(int) dead_code_elimination_final (after) + /// CHECK-START: int Main.wholeSwitchDead(int) dead_code_elimination$final (after) /// CHECK-NOT: PackedSwitch public static int wholeSwitchDead(int j) { @@ -60,14 +60,14 @@ public class Main { return l; } - /// CHECK-START: int Main.constantSwitch_InRange() dead_code_elimination_final (before) + /// CHECK-START: int Main.constantSwitch_InRange() dead_code_elimination$final (before) /// CHECK-DAG: PackedSwitch - /// CHECK-START: int Main.constantSwitch_InRange() dead_code_elimination_final (after) + /// CHECK-START: int Main.constantSwitch_InRange() dead_code_elimination$final (after) /// CHECK-DAG: <<Const7:i\d+>> IntConstant 7 /// CHECK-DAG: Return [<<Const7>>] - /// CHECK-START: int Main.constantSwitch_InRange() dead_code_elimination_final (after) + /// CHECK-START: int Main.constantSwitch_InRange() dead_code_elimination$final (after) /// CHECK-NOT: PackedSwitch public static int constantSwitch_InRange() { @@ -96,14 +96,14 @@ public class Main { return i; } - /// CHECK-START: int Main.constantSwitch_AboveRange() dead_code_elimination_final (before) + /// CHECK-START: int Main.constantSwitch_AboveRange() dead_code_elimination$final (before) /// CHECK-DAG: PackedSwitch - /// CHECK-START: int Main.constantSwitch_AboveRange() dead_code_elimination_final (after) + /// CHECK-START: int Main.constantSwitch_AboveRange() dead_code_elimination$final (after) /// CHECK-DAG: <<Const15:i\d+>> IntConstant 15 /// CHECK-DAG: Return [<<Const15>>] - /// CHECK-START: int Main.constantSwitch_AboveRange() dead_code_elimination_final (after) + /// CHECK-START: int Main.constantSwitch_AboveRange() dead_code_elimination$final (after) /// CHECK-NOT: PackedSwitch public static int constantSwitch_AboveRange() { @@ -132,14 +132,14 @@ public class Main { return i; } - /// CHECK-START: int Main.constantSwitch_BelowRange() dead_code_elimination_final (before) + /// CHECK-START: int Main.constantSwitch_BelowRange() dead_code_elimination$final (before) /// CHECK-DAG: PackedSwitch - /// CHECK-START: int Main.constantSwitch_BelowRange() dead_code_elimination_final (after) + /// CHECK-START: int Main.constantSwitch_BelowRange() dead_code_elimination$final (after) /// CHECK-DAG: <<ConstM5:i\d+>> IntConstant -5 /// CHECK-DAG: Return [<<ConstM5>>] - /// CHECK-START: int Main.constantSwitch_BelowRange() dead_code_elimination_final (after) + /// CHECK-START: int Main.constantSwitch_BelowRange() dead_code_elimination$final (after) /// CHECK-NOT: PackedSwitch public static int constantSwitch_BelowRange() { diff --git a/test/510-checker-try-catch/smali/Builder.smali b/test/510-checker-try-catch/smali/Builder.smali index 733a1dd0d2..1324cf23a7 100644 --- a/test/510-checker-try-catch/smali/Builder.smali +++ b/test/510-checker-try-catch/smali/Builder.smali @@ -1360,7 +1360,7 @@ # Test that a throw-catch loop on monitor-exit is eliminated. # Note that we do not test this until after DCE which merges trivially split blocks. -## CHECK-START: int Builder.testSynchronized(java.lang.Object) dead_code_elimination (after) +## CHECK-START: int Builder.testSynchronized(java.lang.Object) dead_code_elimination$initial(after) ## CHECK: flags "catch_block" ## CHECK-NOT: end_block ## CHECK: MonitorOperation kind:exit diff --git a/test/522-checker-regression-monitor-exit/smali/Test.smali b/test/522-checker-regression-monitor-exit/smali/Test.smali index c8e91984e0..f4684700eb 100644 --- a/test/522-checker-regression-monitor-exit/smali/Test.smali +++ b/test/522-checker-regression-monitor-exit/smali/Test.smali @@ -17,11 +17,11 @@ .super Ljava/lang/Object; -## CHECK-START: int Test.synchronizedHashCode(java.lang.Object) dead_code_elimination (before) +## CHECK-START: int Test.synchronizedHashCode(java.lang.Object) dead_code_elimination$initial(before) ## CHECK: MonitorOperation [<<Param:l\d+>>] kind:enter ## CHECK: MonitorOperation [<<Param>>] kind:exit -## CHECK-START: int Test.synchronizedHashCode(java.lang.Object) dead_code_elimination (after) +## CHECK-START: int Test.synchronizedHashCode(java.lang.Object) dead_code_elimination$initial(after) ## CHECK: MonitorOperation [<<Param:l\d+>>] kind:enter ## CHECK: MonitorOperation [<<Param>>] kind:exit diff --git a/test/527-checker-array-access-split/src/Main.java b/test/527-checker-array-access-split/src/Main.java index 3366f20cc5..9435ef1def 100644 --- a/test/527-checker-array-access-split/src/Main.java +++ b/test/527-checker-array-access-split/src/Main.java @@ -189,7 +189,7 @@ public class Main { /// CHECK: <<Address2:l\d+>> IntermediateAddress [<<Array>>,<<DataOffset>>] /// CHECK-NEXT: ArraySet [<<Address2>>,<<Index>>,<<Add>>] - /// CHECK-START-ARM64: void Main.getSet(int[], int) GVN_after_arch (after) + /// CHECK-START-ARM64: void Main.getSet(int[], int) GVN$after_arch (after) /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1 /// CHECK-DAG: <<DataOffset:i\d+>> IntConstant /// CHECK: <<Array:l\d+>> NullCheck @@ -220,7 +220,7 @@ public class Main { /// CHECK: <<Address2:l\d+>> IntermediateAddress [<<Array>>,<<DataOffset>>] /// CHECK-NEXT: ArraySet [<<Address2>>,<<Index>>,<<Add>>] - /// CHECK-START-ARM: void Main.getSet(int[], int) GVN_after_arch (after) + /// CHECK-START-ARM: void Main.getSet(int[], int) GVN$after_arch (after) /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1 /// CHECK-DAG: <<DataOffset:i\d+>> IntConstant /// CHECK: <<Array:l\d+>> NullCheck @@ -260,7 +260,7 @@ public class Main { /// CHECK: <<Address2:l\d+>> IntermediateAddress [<<Array>>,<<DataOffset>>] /// CHECK-NEXT: ArraySet [<<Address2>>,<<Index>>,<<Add>>] - /// CHECK-START-ARM64: int[] Main.accrossGC(int[], int) GVN_after_arch (after) + /// CHECK-START-ARM64: int[] Main.accrossGC(int[], int) GVN$after_arch (after) /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1 /// CHECK-DAG: <<DataOffset:i\d+>> IntConstant /// CHECK: <<Array:l\d+>> NullCheck @@ -294,7 +294,7 @@ public class Main { /// CHECK: <<Address2:l\d+>> IntermediateAddress [<<Array>>,<<DataOffset>>] /// CHECK-NEXT: ArraySet [<<Address2>>,<<Index>>,<<Add>>] - /// CHECK-START-ARM: int[] Main.accrossGC(int[], int) GVN_after_arch (after) + /// CHECK-START-ARM: int[] Main.accrossGC(int[], int) GVN$after_arch (after) /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1 /// CHECK-DAG: <<DataOffset:i\d+>> IntConstant /// CHECK: <<Array:l\d+>> NullCheck @@ -349,7 +349,7 @@ public class Main { /// CHECK: <<Address2:l\d+>> IntermediateAddress [<<Array>>,<<DataOffset>>] /// CHECK-NEXT: ArraySet [<<Address2>>,<<Index>>,<<Add>>] - /// CHECK-START-ARM64: int Main.canMergeAfterBCE1() GVN_after_arch (after) + /// CHECK-START-ARM64: int Main.canMergeAfterBCE1() GVN$after_arch (after) /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1 /// CHECK-DAG: <<DataOffset:i\d+>> IntConstant 12 /// CHECK: <<Array:l\d+>> NewArray @@ -386,7 +386,7 @@ public class Main { /// CHECK: <<Address2:l\d+>> IntermediateAddress [<<Array>>,<<DataOffset>>] /// CHECK-NEXT: ArraySet [<<Address2>>,<<Index>>,<<Add>>] - /// CHECK-START-ARM: int Main.canMergeAfterBCE1() GVN_after_arch (after) + /// CHECK-START-ARM: int Main.canMergeAfterBCE1() GVN$after_arch (after) /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1 /// CHECK-DAG: <<DataOffset:i\d+>> IntConstant 12 /// CHECK: <<Array:l\d+>> NewArray @@ -445,7 +445,7 @@ public class Main { /// CHECK: <<Address3:l\d+>> IntermediateAddress [<<Array>>,<<DataOffset>>] /// CHECK: ArraySet [<<Address3>>,<<Index1>>,<<Add>>] - /// CHECK-START-ARM64: int Main.canMergeAfterBCE2() GVN_after_arch (after) + /// CHECK-START-ARM64: int Main.canMergeAfterBCE2() GVN$after_arch (after) /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1 /// CHECK-DAG: <<DataOffset:i\d+>> IntConstant 12 /// CHECK: <<Array:l\d+>> NewArray @@ -461,7 +461,7 @@ public class Main { // There should be only one intermediate address computation in the loop. - /// CHECK-START-ARM64: int Main.canMergeAfterBCE2() GVN_after_arch (after) + /// CHECK-START-ARM64: int Main.canMergeAfterBCE2() GVN$after_arch (after) /// CHECK: IntermediateAddress /// CHECK-NOT: IntermediateAddress @@ -494,7 +494,7 @@ public class Main { /// CHECK: <<Address3:l\d+>> IntermediateAddress [<<Array>>,<<DataOffset>>] /// CHECK: ArraySet [<<Address3>>,<<Index1>>,<<Add>>] - /// CHECK-START-ARM: int Main.canMergeAfterBCE2() GVN_after_arch (after) + /// CHECK-START-ARM: int Main.canMergeAfterBCE2() GVN$after_arch (after) /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1 /// CHECK-DAG: <<DataOffset:i\d+>> IntConstant 12 /// CHECK: <<Array:l\d+>> NewArray @@ -508,7 +508,7 @@ public class Main { /// CHECK: <<Add:i\d+>> Add [<<ArrayGetI>>,<<ArrayGetI1>>] /// CHECK: ArraySet [<<Address>>,<<Index1>>,<<Add>>] - /// CHECK-START-ARM: int Main.canMergeAfterBCE2() GVN_after_arch (after) + /// CHECK-START-ARM: int Main.canMergeAfterBCE2() GVN$after_arch (after) /// CHECK: IntermediateAddress /// CHECK-NOT: IntermediateAddress diff --git a/test/530-checker-loops3/src/Main.java b/test/530-checker-loops3/src/Main.java index 5ffcbe964d..6b5c657294 100644 --- a/test/530-checker-loops3/src/Main.java +++ b/test/530-checker-loops3/src/Main.java @@ -132,7 +132,7 @@ public class Main { /// 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$after_bce (after) /// CHECK-DAG: Deoptimize loop:none /// CHECK-DAG: Deoptimize loop:none /// CHECK-DAG: Deoptimize loop:none @@ -164,7 +164,7 @@ public class Main { /// 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$after_bce (after) /// CHECK-DAG: Deoptimize loop:none /// CHECK-DAG: Deoptimize loop:none /// CHECK-DAG: Deoptimize loop:none @@ -196,7 +196,7 @@ public class Main { /// 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$after_bce (after) /// CHECK-DAG: Deoptimize loop:none /// CHECK-DAG: Deoptimize loop:none /// CHECK-NOT: Deoptimize diff --git a/test/540-checker-rtp-bug/src/Main.java b/test/540-checker-rtp-bug/src/Main.java index 17b11db295..65fb574801 100644 --- a/test/540-checker-rtp-bug/src/Main.java +++ b/test/540-checker-rtp-bug/src/Main.java @@ -48,7 +48,7 @@ public class Main { /// CHECK: <<Class:l\d+>> LoadClass /// CHECK: InstanceOf [<<Phi>>,<<Class>>] - /// CHECK-START: void Main.testKeepInstanceOf(java.lang.Object, boolean) dead_code_elimination (after) + /// CHECK-START: void Main.testKeepInstanceOf(java.lang.Object, boolean) dead_code_elimination$initial(after) /// CHECK: <<Phi:l\d+>> Phi /// CHECK: <<Class:l\d+>> LoadClass /// CHECK: InstanceOf [<<Phi>>,<<Class>>] diff --git a/test/543-checker-dce-trycatch/smali/TestCase.smali b/test/543-checker-dce-trycatch/smali/TestCase.smali index 9f9916d2f5..5557c7b321 100644 --- a/test/543-checker-dce-trycatch/smali/TestCase.smali +++ b/test/543-checker-dce-trycatch/smali/TestCase.smali @@ -26,18 +26,18 @@ # Test a case when one entering TryBoundary is dead but the rest of the try # block remains live. -## CHECK-START: int TestCase.testDeadEntry(int, int, int, int) dead_code_elimination_final (before) +## CHECK-START: int TestCase.testDeadEntry(int, int, int, int) dead_code_elimination$final (before) ## CHECK: Add -## CHECK-START: int TestCase.testDeadEntry(int, int, int, int) dead_code_elimination_final (before) +## CHECK-START: int TestCase.testDeadEntry(int, int, int, int) dead_code_elimination$final (before) ## CHECK: TryBoundary kind:entry ## CHECK: TryBoundary kind:entry ## CHECK-NOT: TryBoundary kind:entry -## CHECK-START: int TestCase.testDeadEntry(int, int, int, int) dead_code_elimination_final (after) +## CHECK-START: int TestCase.testDeadEntry(int, int, int, int) dead_code_elimination$final (after) ## CHECK-NOT: Add -## CHECK-START: int TestCase.testDeadEntry(int, int, int, int) dead_code_elimination_final (after) +## CHECK-START: int TestCase.testDeadEntry(int, int, int, int) dead_code_elimination$final (after) ## CHECK: TryBoundary kind:entry ## CHECK-NOT: TryBoundary kind:entry @@ -71,18 +71,18 @@ # Test a case when one exiting TryBoundary is dead but the rest of the try # block remains live. -## CHECK-START: int TestCase.testDeadExit(int, int, int, int) dead_code_elimination_final (before) +## CHECK-START: int TestCase.testDeadExit(int, int, int, int) dead_code_elimination$final (before) ## CHECK: Add -## CHECK-START: int TestCase.testDeadExit(int, int, int, int) dead_code_elimination_final (before) +## CHECK-START: int TestCase.testDeadExit(int, int, int, int) dead_code_elimination$final (before) ## CHECK: TryBoundary kind:exit ## CHECK: TryBoundary kind:exit ## CHECK-NOT: TryBoundary kind:exit -## CHECK-START: int TestCase.testDeadExit(int, int, int, int) dead_code_elimination_final (after) +## CHECK-START: int TestCase.testDeadExit(int, int, int, int) dead_code_elimination$final (after) ## CHECK-NOT: Add -## CHECK-START: int TestCase.testDeadExit(int, int, int, int) dead_code_elimination_final (after) +## CHECK-START: int TestCase.testDeadExit(int, int, int, int) dead_code_elimination$final (after) ## CHECK: TryBoundary kind:exit ## CHECK-NOT: TryBoundary kind:exit @@ -117,21 +117,21 @@ # Test that a catch block remains live and consistent if some of try blocks # throwing into it are removed. -## CHECK-START: int TestCase.testOneTryBlockDead(int, int, int, int) dead_code_elimination_final (before) +## CHECK-START: int TestCase.testOneTryBlockDead(int, int, int, int) dead_code_elimination$final (before) ## CHECK: TryBoundary kind:entry ## CHECK: TryBoundary kind:entry ## CHECK-NOT: TryBoundary kind:entry -## CHECK-START: int TestCase.testOneTryBlockDead(int, int, int, int) dead_code_elimination_final (before) +## CHECK-START: int TestCase.testOneTryBlockDead(int, int, int, int) dead_code_elimination$final (before) ## CHECK: TryBoundary kind:exit ## CHECK: TryBoundary kind:exit ## CHECK-NOT: TryBoundary kind:exit -## CHECK-START: int TestCase.testOneTryBlockDead(int, int, int, int) dead_code_elimination_final (after) +## CHECK-START: int TestCase.testOneTryBlockDead(int, int, int, int) dead_code_elimination$final (after) ## CHECK: TryBoundary kind:entry ## CHECK-NOT: TryBoundary kind:entry -## CHECK-START: int TestCase.testOneTryBlockDead(int, int, int, int) dead_code_elimination_final (after) +## CHECK-START: int TestCase.testOneTryBlockDead(int, int, int, int) dead_code_elimination$final (after) ## CHECK: TryBoundary kind:exit ## CHECK-NOT: TryBoundary kind:exit @@ -203,7 +203,7 @@ # Test that DCE removes catch phi uses of instructions defined in dead try blocks. -## CHECK-START: int TestCase.testCatchPhiInputs_DefinedInTryBlock(int, int, int, int) dead_code_elimination_final (before) +## CHECK-START: int TestCase.testCatchPhiInputs_DefinedInTryBlock(int, int, int, int) dead_code_elimination$final (before) ## CHECK-DAG: <<Arg0:i\d+>> ParameterValue ## CHECK-DAG: <<Arg1:i\d+>> ParameterValue ## CHECK-DAG: <<Const0xa:i\d+>> IntConstant 10 @@ -220,7 +220,7 @@ ## 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-START: int TestCase.testCatchPhiInputs_DefinedInTryBlock(int, int, int, int) dead_code_elimination_final (after) +## CHECK-START: int TestCase.testCatchPhiInputs_DefinedInTryBlock(int, int, int, int) dead_code_elimination$final (after) ## CHECK-DAG: <<Const0xb:i\d+>> IntConstant 11 ## CHECK-DAG: <<Const0xc:i\d+>> IntConstant 12 ## CHECK-DAG: <<Const0xd:i\d+>> IntConstant 13 @@ -277,7 +277,7 @@ # Test that DCE does not remove catch phi uses of instructions defined outside # dead try blocks. -## CHECK-START: int TestCase.testCatchPhiInputs_DefinedOutsideTryBlock(int, int, int, int) dead_code_elimination_final (before) +## CHECK-START: int TestCase.testCatchPhiInputs_DefinedOutsideTryBlock(int, int, int, int) dead_code_elimination$final (before) ## CHECK-DAG: <<Const0xa:i\d+>> IntConstant 10 ## CHECK-DAG: <<Const0xb:i\d+>> IntConstant 11 ## CHECK-DAG: <<Const0xc:i\d+>> IntConstant 12 @@ -287,7 +287,7 @@ ## CHECK-DAG: Phi [<<Const0xa>>,<<Const0xb>>,<<Const0xd>>] reg:1 is_catch_phi:true ## CHECK-DAG: Phi [<<Const0xf>>,<<Const0xc>>,<<Const0xe>>] reg:2 is_catch_phi:true -## CHECK-START: int TestCase.testCatchPhiInputs_DefinedOutsideTryBlock(int, int, int, int) dead_code_elimination_final (after) +## CHECK-START: int TestCase.testCatchPhiInputs_DefinedOutsideTryBlock(int, int, int, int) dead_code_elimination$final (after) ## CHECK-DAG: <<Const0xa:i\d+>> IntConstant 10 ## CHECK-DAG: <<Const0xb:i\d+>> IntConstant 11 ## CHECK-DAG: <<Const0xc:i\d+>> IntConstant 12 diff --git a/test/543-checker-dce-trycatch/src/Main.java b/test/543-checker-dce-trycatch/src/Main.java index 6e73d0dbd1..19587e78b9 100644 --- a/test/543-checker-dce-trycatch/src/Main.java +++ b/test/543-checker-dce-trycatch/src/Main.java @@ -35,10 +35,10 @@ public class Main { // where TryBoundary still has exception handler successors after having removed // some already. - /// CHECK-START: void Main.testDeadTryCatch(boolean) dead_code_elimination_final (after) + /// CHECK-START: void Main.testDeadTryCatch(boolean) dead_code_elimination$final (after) /// CHECK-NOT: TryBoundary - /// CHECK-START: void Main.testDeadTryCatch(boolean) dead_code_elimination_final (after) + /// CHECK-START: void Main.testDeadTryCatch(boolean) dead_code_elimination$final (after) /// CHECK: begin_block /// CHECK: begin_block /// CHECK: begin_block diff --git a/test/557-checker-instruction-simplifier-ror/src/Main.java b/test/557-checker-instruction-simplifier-ror/src/Main.java index 6d8b74d1ec..0e3d14518a 100644 --- a/test/557-checker-instruction-simplifier-ror/src/Main.java +++ b/test/557-checker-instruction-simplifier-ror/src/Main.java @@ -175,7 +175,7 @@ public class Main { // (i >>> #distance) | (i << #-distance) - /// CHECK-START: int Main.ror_int_constant_c_negc(int) instruction_simplifier_after_bce (before) + /// CHECK-START: int Main.ror_int_constant_c_negc(int) instruction_simplifier$after_bce (before) /// CHECK: <<ArgValue:i\d+>> ParameterValue /// CHECK: <<Const2:i\d+>> IntConstant 2 /// CHECK: <<ConstNeg2:i\d+>> IntConstant -2 @@ -184,13 +184,13 @@ public class Main { /// CHECK: <<Or:i\d+>> Or [<<UShr>>,<<Shl>>] /// CHECK: Return [<<Or>>] - /// CHECK-START: int Main.ror_int_constant_c_negc(int) instruction_simplifier_after_bce (after) + /// CHECK-START: int Main.ror_int_constant_c_negc(int) instruction_simplifier$after_bce (after) /// CHECK: <<ArgValue:i\d+>> ParameterValue /// CHECK: <<Const2:i\d+>> IntConstant 2 /// CHECK: <<Ror:i\d+>> Ror [<<ArgValue>>,<<Const2>>] /// CHECK: Return [<<Ror>>] - /// CHECK-START: int Main.ror_int_constant_c_negc(int) instruction_simplifier_after_bce (after) + /// CHECK-START: int Main.ror_int_constant_c_negc(int) instruction_simplifier$after_bce (after) /// CHECK-NOT: UShr /// CHECK-NOT: Shl public static int ror_int_constant_c_negc(int value) { diff --git a/test/559-checker-irreducible-loop/smali/IrreducibleLoop.smali b/test/559-checker-irreducible-loop/smali/IrreducibleLoop.smali index 7ce60a304b..3db86293d0 100644 --- a/test/559-checker-irreducible-loop/smali/IrreducibleLoop.smali +++ b/test/559-checker-irreducible-loop/smali/IrreducibleLoop.smali @@ -28,7 +28,7 @@ # exit \- \ # other_loop_entry # -## CHECK-START: int IrreducibleLoop.simpleLoop(int) dead_code_elimination (before) +## CHECK-START: int IrreducibleLoop.simpleLoop(int) dead_code_elimination$initial(before) ## CHECK: irreducible:true .method public static simpleLoop(I)I .registers 2 @@ -65,7 +65,7 @@ # other_loop_entry # set 30 in p1:myField # -## CHECK-START: int IrreducibleLoop.lse(int, Main) dead_code_elimination (after) +## CHECK-START: int IrreducibleLoop.lse(int, Main) dead_code_elimination$initial(after) ## CHECK: irreducible:true # ## CHECK-START: int IrreducibleLoop.lse(int, Main) load_store_elimination (after) @@ -101,10 +101,10 @@ # exit \- \ # other_loop_entry # -## CHECK-START: int IrreducibleLoop.dce(int) dead_code_elimination (before) +## CHECK-START: int IrreducibleLoop.dce(int) dead_code_elimination$initial(before) ## CHECK: irreducible:true -## CHECK-START: int IrreducibleLoop.dce(int) dead_code_elimination (after) +## CHECK-START: int IrreducibleLoop.dce(int) dead_code_elimination$initial(after) ## CHECK: irreducible:true .method public static dce(I)I .registers 3 diff --git a/test/564-checker-irreducible-loop/smali/IrreducibleLoop.smali b/test/564-checker-irreducible-loop/smali/IrreducibleLoop.smali index b82ed921a5..ab8f06b2fc 100644 --- a/test/564-checker-irreducible-loop/smali/IrreducibleLoop.smali +++ b/test/564-checker-irreducible-loop/smali/IrreducibleLoop.smali @@ -16,7 +16,7 @@ .super Ljava/lang/Object; -## CHECK-START-X86: int IrreducibleLoop.simpleLoop(int) dead_code_elimination (before) +## CHECK-START-X86: int IrreducibleLoop.simpleLoop(int) dead_code_elimination$initial(before) ## CHECK-DAG: <<Method:(i|j)\d+>> CurrentMethod ## CHECK-DAG: <<Constant:i\d+>> IntConstant 42 ## CHECK-DAG: InvokeStaticOrDirect [<<Constant>>,<<Method>>] loop:{{B\d+}} irreducible:true diff --git a/test/565-checker-doublenegbitwise/src/Main.java b/test/565-checker-doublenegbitwise/src/Main.java index e426b75bf0..811c280474 100644 --- a/test/565-checker-doublenegbitwise/src/Main.java +++ b/test/565-checker-doublenegbitwise/src/Main.java @@ -70,7 +70,7 @@ public class Main { * same pass. */ - /// CHECK-START: boolean Main.$opt$noinline$booleanAndToOr(boolean, boolean) instruction_simplifier_after_bce (before) + /// CHECK-START: boolean Main.$opt$noinline$booleanAndToOr(boolean, boolean) instruction_simplifier$after_bce (before) /// CHECK: <<P1:z\d+>> ParameterValue /// CHECK: <<P2:z\d+>> ParameterValue /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 @@ -80,18 +80,18 @@ public class Main { /// CHECK: <<And:i\d+>> And [<<Select2>>,<<Select1>>] /// CHECK: Return [<<And>>] - /// CHECK-START: boolean Main.$opt$noinline$booleanAndToOr(boolean, boolean) instruction_simplifier_after_bce (after) + /// CHECK-START: boolean Main.$opt$noinline$booleanAndToOr(boolean, boolean) instruction_simplifier$after_bce (after) /// CHECK: <<Cond1:z\d+>> ParameterValue /// CHECK: <<Cond2:z\d+>> ParameterValue /// CHECK: <<Or:i\d+>> Or [<<Cond2>>,<<Cond1>>] /// CHECK: <<BooleanNot:z\d+>> BooleanNot [<<Or>>] /// CHECK: Return [<<BooleanNot>>] - /// CHECK-START: boolean Main.$opt$noinline$booleanAndToOr(boolean, boolean) instruction_simplifier_after_bce (after) + /// CHECK-START: boolean Main.$opt$noinline$booleanAndToOr(boolean, boolean) instruction_simplifier$after_bce (after) /// CHECK: BooleanNot /// CHECK-NOT: BooleanNot - /// CHECK-START: boolean Main.$opt$noinline$booleanAndToOr(boolean, boolean) instruction_simplifier_after_bce (after) + /// CHECK-START: boolean Main.$opt$noinline$booleanAndToOr(boolean, boolean) instruction_simplifier$after_bce (after) /// CHECK-NOT: And public static boolean $opt$noinline$booleanAndToOr(boolean a, boolean b) { @@ -138,7 +138,7 @@ public class Main { * same pass. */ - /// CHECK-START: boolean Main.$opt$noinline$booleanOrToAnd(boolean, boolean) instruction_simplifier_after_bce (before) + /// CHECK-START: boolean Main.$opt$noinline$booleanOrToAnd(boolean, boolean) instruction_simplifier$after_bce (before) /// CHECK: <<P1:z\d+>> ParameterValue /// CHECK: <<P2:z\d+>> ParameterValue /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 @@ -148,18 +148,18 @@ public class Main { /// CHECK: <<Or:i\d+>> Or [<<Select2>>,<<Select1>>] /// CHECK: Return [<<Or>>] - /// CHECK-START: boolean Main.$opt$noinline$booleanOrToAnd(boolean, boolean) instruction_simplifier_after_bce (after) + /// CHECK-START: boolean Main.$opt$noinline$booleanOrToAnd(boolean, boolean) instruction_simplifier$after_bce (after) /// CHECK: <<Cond1:z\d+>> ParameterValue /// CHECK: <<Cond2:z\d+>> ParameterValue /// CHECK: <<And:i\d+>> And [<<Cond2>>,<<Cond1>>] /// CHECK: <<BooleanNot:z\d+>> BooleanNot [<<And>>] /// CHECK: Return [<<BooleanNot>>] - /// CHECK-START: boolean Main.$opt$noinline$booleanOrToAnd(boolean, boolean) instruction_simplifier_after_bce (after) + /// CHECK-START: boolean Main.$opt$noinline$booleanOrToAnd(boolean, boolean) instruction_simplifier$after_bce (after) /// CHECK: BooleanNot /// CHECK-NOT: BooleanNot - /// CHECK-START: boolean Main.$opt$noinline$booleanOrToAnd(boolean, boolean) instruction_simplifier_after_bce (after) + /// CHECK-START: boolean Main.$opt$noinline$booleanOrToAnd(boolean, boolean) instruction_simplifier$after_bce (after) /// CHECK-NOT: Or public static boolean $opt$noinline$booleanOrToAnd(boolean a, boolean b) { @@ -246,7 +246,7 @@ public class Main { * same pass. */ - /// CHECK-START: boolean Main.$opt$noinline$booleanNotXorToXor(boolean, boolean) instruction_simplifier_after_bce (before) + /// CHECK-START: boolean Main.$opt$noinline$booleanNotXorToXor(boolean, boolean) instruction_simplifier$after_bce (before) /// CHECK: <<P1:z\d+>> ParameterValue /// CHECK: <<P2:z\d+>> ParameterValue /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 @@ -256,13 +256,13 @@ public class Main { /// CHECK: <<Xor:i\d+>> Xor [<<Select2>>,<<Select1>>] /// CHECK: Return [<<Xor>>] - /// CHECK-START: boolean Main.$opt$noinline$booleanNotXorToXor(boolean, boolean) instruction_simplifier_after_bce (after) + /// CHECK-START: boolean Main.$opt$noinline$booleanNotXorToXor(boolean, boolean) instruction_simplifier$after_bce (after) /// CHECK: <<Cond1:z\d+>> ParameterValue /// CHECK: <<Cond2:z\d+>> ParameterValue /// CHECK: <<Xor:i\d+>> Xor [<<Cond2>>,<<Cond1>>] /// CHECK: Return [<<Xor>>] - /// CHECK-START: boolean Main.$opt$noinline$booleanNotXorToXor(boolean, boolean) instruction_simplifier_after_bce (after) + /// CHECK-START: boolean Main.$opt$noinline$booleanNotXorToXor(boolean, boolean) instruction_simplifier$after_bce (after) /// CHECK-NOT: BooleanNot public static boolean $opt$noinline$booleanNotXorToXor(boolean a, boolean b) { diff --git a/test/565-checker-rotate/src/Main.java b/test/565-checker-rotate/src/Main.java index aadb5978e8..eb0e8688c0 100644 --- a/test/565-checker-rotate/src/Main.java +++ b/test/565-checker-rotate/src/Main.java @@ -52,14 +52,14 @@ public class Main { /// CHECK-START: int Main.rotateLeftBoolean(boolean, int) select_generator (after) /// CHECK-NOT: Phi - /// CHECK-START: int Main.rotateLeftBoolean(boolean, int) instruction_simplifier_after_bce (after) + /// CHECK-START: int Main.rotateLeftBoolean(boolean, int) instruction_simplifier$after_bce (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 Main.rotateLeftBoolean(boolean, int) instruction_simplifier_after_bce (after) + /// CHECK-START: int Main.rotateLeftBoolean(boolean, int) instruction_simplifier$after_bce (after) /// CHECK-NOT: Select private static int rotateLeftBoolean(boolean value, int distance) { @@ -206,13 +206,13 @@ public class Main { /// CHECK-START: int Main.rotateRightBoolean(boolean, int) select_generator (after) /// CHECK-NOT: Phi - /// CHECK-START: int Main.rotateRightBoolean(boolean, int) instruction_simplifier_after_bce (after) + /// CHECK-START: int Main.rotateRightBoolean(boolean, int) instruction_simplifier$after_bce (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 Main.rotateRightBoolean(boolean, int) instruction_simplifier_after_bce (after) + /// CHECK-START: int Main.rotateRightBoolean(boolean, int) instruction_simplifier$after_bce (after) /// CHECK-NOT: Select private static int rotateRightBoolean(boolean value, int distance) { diff --git a/test/566-checker-signum/src/Main.java b/test/566-checker-signum/src/Main.java index 5f2cf3dc95..7fc9e84055 100644 --- a/test/566-checker-signum/src/Main.java +++ b/test/566-checker-signum/src/Main.java @@ -45,13 +45,13 @@ public class Main { /// CHECK-START: int Main.signBoolean(boolean) select_generator (after) /// CHECK-NOT: Phi - /// CHECK-START: int Main.signBoolean(boolean) instruction_simplifier_after_bce (after) + /// CHECK-START: int Main.signBoolean(boolean) instruction_simplifier$after_bce (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 Main.signBoolean(boolean) instruction_simplifier_after_bce (after) + /// CHECK-START: int Main.signBoolean(boolean) instruction_simplifier$after_bce (after) /// CHECK-NOT: Select private static int signBoolean(boolean x) { diff --git a/test/567-checker-compare/src/Main.java b/test/567-checker-compare/src/Main.java index 85879500d9..a05bb60fad 100644 --- a/test/567-checker-compare/src/Main.java +++ b/test/567-checker-compare/src/Main.java @@ -75,13 +75,13 @@ public class Main { /// CHECK-START: int Main.compareBooleans(boolean, boolean) select_generator (after) /// CHECK-NOT: Phi - /// CHECK-START: int Main.compareBooleans(boolean, boolean) instruction_simplifier_after_bce (after) + /// CHECK-START: int Main.compareBooleans(boolean, boolean) instruction_simplifier$after_bce (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 Main.compareBooleans(boolean, boolean) instruction_simplifier_after_bce (after) + /// CHECK-START: int Main.compareBooleans(boolean, boolean) instruction_simplifier$after_bce (after) /// CHECK-NOT: Select private static int compareBooleans(boolean x, boolean y) { diff --git a/test/570-checker-osr/smali/Osr.smali b/test/570-checker-osr/smali/Osr.smali index 869c7c31b8..6592b7b9d3 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_final (after) +## CHECK-START: int Osr.simpleLoop(int, int) dead_code_elimination$final (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/588-checker-irreducible-lifetime-hole/smali/IrreducibleLoop.smali b/test/588-checker-irreducible-lifetime-hole/smali/IrreducibleLoop.smali index 7dbd9dae21..56545c756f 100644 --- a/test/588-checker-irreducible-lifetime-hole/smali/IrreducibleLoop.smali +++ b/test/588-checker-irreducible-lifetime-hole/smali/IrreducibleLoop.smali @@ -16,7 +16,7 @@ .super Ljava/lang/Object; -## CHECK-START-X86: int IrreducibleLoop.simpleLoop1(int) dead_code_elimination (before) +## CHECK-START-X86: int IrreducibleLoop.simpleLoop1(int) dead_code_elimination$initial(before) ## CHECK-DAG: <<Method:(i|j)\d+>> CurrentMethod ## CHECK-DAG: <<Constant:i\d+>> IntConstant 42 ## CHECK-DAG: Goto irreducible:true @@ -57,7 +57,7 @@ return v0 .end method -## CHECK-START-X86: int IrreducibleLoop.simpleLoop2(int) dead_code_elimination (before) +## CHECK-START-X86: int IrreducibleLoop.simpleLoop2(int) dead_code_elimination$initial(before) ## CHECK-DAG: <<Method:(i|j)\d+>> CurrentMethod ## CHECK-DAG: <<Constant:i\d+>> IntConstant 42 ## CHECK-DAG: Goto irreducible:true diff --git a/test/591-checker-regression-dead-loop/src/Main.java b/test/591-checker-regression-dead-loop/src/Main.java index 6d9fcf8e6e..174cad9a6d 100644 --- a/test/591-checker-regression-dead-loop/src/Main.java +++ b/test/591-checker-regression-dead-loop/src/Main.java @@ -17,7 +17,7 @@ class Main { private static boolean $inline$false() { return false; } - /// CHECK-START: void Main.main(java.lang.String[]) dead_code_elimination (before) + /// CHECK-START: void Main.main(java.lang.String[]) dead_code_elimination$initial(before) /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1 /// CHECK-DAG: <<Phi:i\d+>> Phi [<<Const0>>,<<Add:i\d+>>] loop:{{B\d+}} diff --git a/test/593-checker-boolean-to-integral-conv/src/Main.java b/test/593-checker-boolean-to-integral-conv/src/Main.java index ba65839376..b4c91c8db6 100644 --- a/test/593-checker-boolean-to-integral-conv/src/Main.java +++ b/test/593-checker-boolean-to-integral-conv/src/Main.java @@ -46,7 +46,7 @@ public class Main { /// CHECK-DAG: <<IToS:b\d+>> TypeConversion [<<Sel>>] /// CHECK-DAG: Return [<<IToS>>] - /// CHECK-START: byte Main.booleanToByte(boolean) instruction_simplifier_after_bce (after) + /// CHECK-START: byte Main.booleanToByte(boolean) instruction_simplifier$after_bce (after) /// CHECK: <<Arg:z\d+>> ParameterValue /// CHECK-DAG: Return [<<Arg>>] @@ -72,7 +72,7 @@ public class Main { /// CHECK-DAG: <<IToS:s\d+>> TypeConversion [<<Sel>>] /// CHECK-DAG: Return [<<IToS>>] - /// CHECK-START: short Main.booleanToShort(boolean) instruction_simplifier_after_bce (after) + /// CHECK-START: short Main.booleanToShort(boolean) instruction_simplifier$after_bce (after) /// CHECK: <<Arg:z\d+>> ParameterValue /// CHECK-DAG: Return [<<Arg>>] @@ -98,7 +98,7 @@ public class Main { /// CHECK-DAG: <<IToC:c\d+>> TypeConversion [<<Sel>>] /// CHECK-DAG: Return [<<IToC>>] - /// CHECK-START: char Main.booleanToChar(boolean) instruction_simplifier_after_bce (after) + /// CHECK-START: char Main.booleanToChar(boolean) instruction_simplifier$after_bce (after) /// CHECK: <<Arg:z\d+>> ParameterValue /// CHECK-DAG: Return [<<Arg>>] @@ -122,7 +122,7 @@ public class Main { /// CHECK-DAG: <<Sel:i\d+>> Select [<<Zero>>,<<One>>,<<Arg>>] /// CHECK-DAG: Return [<<Sel>>] - /// CHECK-START: int Main.booleanToInt(boolean) instruction_simplifier_after_bce (after) + /// CHECK-START: int Main.booleanToInt(boolean) instruction_simplifier$after_bce (after) /// CHECK: <<Arg:z\d+>> ParameterValue /// CHECK-DAG: Return [<<Arg>>] @@ -148,7 +148,7 @@ public class Main { /// CHECK-DAG: <<IToJ:j\d+>> TypeConversion [<<Sel>>] /// CHECK-DAG: Return [<<IToJ>>] - /// CHECK-START: long Main.booleanToLong(boolean) instruction_simplifier_after_bce (after) + /// CHECK-START: long Main.booleanToLong(boolean) instruction_simplifier$after_bce (after) /// CHECK: <<Arg:z\d+>> ParameterValue /// CHECK-DAG: <<ZToJ:j\d+>> TypeConversion [<<Arg>>] /// CHECK-DAG: Return [<<ZToJ>>] @@ -185,7 +185,7 @@ public class Main { /// CHECK-DAG: <<JToI:i\d+>> TypeConversion [<<IToJ>>] /// CHECK-DAG: Return [<<JToI>>] - /// CHECK-START: int Main.longToIntOfBoolean() instruction_simplifier_after_bce (after) + /// CHECK-START: int Main.longToIntOfBoolean() instruction_simplifier$after_bce (after) /// CHECK-DAG: <<Method:[ij]\d+>> CurrentMethod /// CHECK-DAG: <<Sget:z\d+>> StaticFieldGet /// CHECK-DAG: Return [<<Sget>>] diff --git a/test/611-checker-simplify-if/src/Main.java b/test/611-checker-simplify-if/src/Main.java index 21f4115c55..399a752672 100644 --- a/test/611-checker-simplify-if/src/Main.java +++ b/test/611-checker-simplify-if/src/Main.java @@ -35,14 +35,14 @@ public class Main { // Test when a condition is the input of the if. - /// CHECK-START: void Main.testNoInline(java.lang.String[]) dead_code_elimination (before) + /// CHECK-START: void Main.testNoInline(java.lang.String[]) dead_code_elimination$initial(before) /// CHECK: <<Const0:i\d+>> IntConstant 0 /// CHECK: If /// CHECK: <<Phi:i\d+>> Phi /// CHECK: <<Equal:z\d+>> Equal [<<Phi>>,<<Const0>>] /// CHECK: If [<<Equal>>] - /// CHECK-START: void Main.testNoInline(java.lang.String[]) dead_code_elimination (after) + /// CHECK-START: void Main.testNoInline(java.lang.String[]) dead_code_elimination$initial(after) /// CHECK: If /// CHECK-NOT: Phi /// CHECK-NOT: Equal @@ -64,13 +64,13 @@ public class Main { // Test when the phi is the input of the if. - /// CHECK-START: void Main.testInline(java.lang.String[]) dead_code_elimination_final (before) + /// CHECK-START: void Main.testInline(java.lang.String[]) dead_code_elimination$final (before) /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 /// CHECK-DAG: If /// CHECK-DAG: <<Phi:i\d+>> Phi /// CHECK-DAG: If [<<Phi>>] - /// CHECK-START: void Main.testInline(java.lang.String[]) dead_code_elimination_final (after) + /// CHECK-START: void Main.testInline(java.lang.String[]) dead_code_elimination$final (after) /// CHECK: If /// CHECK-NOT: Phi /// CHECK-NOT: If @@ -96,7 +96,7 @@ public class Main { // Test when one input is not a constant. We can only optimize the constant input. - /// CHECK-START: void Main.testNonConstantInputs(java.lang.String[]) dead_code_elimination (before) + /// CHECK-START: void Main.testNonConstantInputs(java.lang.String[]) dead_code_elimination$initial(before) /// CHECK-DAG: <<Const34:i\d+>> IntConstant 34 /// CHECK-DAG: <<Const42:i\d+>> IntConstant 42 /// CHECK-DAG: If @@ -105,7 +105,7 @@ public class Main { /// CHECK-DAG: <<NotEqual:z\d+>> NotEqual [<<Phi>>,<<Const42>>] /// CHECK-DAG: If [<<NotEqual>>] - /// CHECK-START: void Main.testNonConstantInputs(java.lang.String[]) dead_code_elimination (after) + /// CHECK-START: void Main.testNonConstantInputs(java.lang.String[]) dead_code_elimination$initial(after) /// CHECK-DAG: <<Const42:i\d+>> IntConstant 42 /// CHECK-DAG: If /// CHECK-DAG: <<StaticFieldGet:i\d+>> StaticFieldGet @@ -129,7 +129,7 @@ public class Main { // Test with a condition. - /// CHECK-START: void Main.testGreaterCondition(java.lang.String[]) dead_code_elimination (before) + /// CHECK-START: void Main.testGreaterCondition(java.lang.String[]) dead_code_elimination$initial(before) /// CHECK-DAG: <<Const34:i\d+>> IntConstant 34 /// CHECK-DAG: <<Const22:i\d+>> IntConstant 22 /// CHECK-DAG: <<Const25:i\d+>> IntConstant 25 @@ -138,7 +138,7 @@ public class Main { /// CHECK-DAG: <<GE:z\d+>> GreaterThanOrEqual [<<Phi>>,<<Const25>>] /// CHECK-DAG: If [<<GE>>] - /// CHECK-START: void Main.testGreaterCondition(java.lang.String[]) dead_code_elimination (after) + /// CHECK-START: void Main.testGreaterCondition(java.lang.String[]) dead_code_elimination$initial(after) /// CHECK-DAG: If /// CHECK-NOT: Phi /// CHECK-NOT: GreaterThanOrEqual @@ -160,7 +160,7 @@ public class Main { // Test when comparing non constants. - /// CHECK-START: void Main.testNonConstantEqual(java.lang.String[]) dead_code_elimination (before) + /// CHECK-START: void Main.testNonConstantEqual(java.lang.String[]) dead_code_elimination$initial(before) /// CHECK-DAG: <<Const34:i\d+>> IntConstant 34 /// CHECK-DAG: <<Const42:i\d+>> IntConstant 42 /// CHECK-DAG: If @@ -169,7 +169,7 @@ public class Main { /// CHECK-DAG: <<NotEqual:z\d+>> NotEqual [<<Phi>>,<<StaticFieldGet>>] /// CHECK-DAG: If [<<NotEqual>>] - /// CHECK-START: void Main.testNonConstantEqual(java.lang.String[]) dead_code_elimination (after) + /// CHECK-START: void Main.testNonConstantEqual(java.lang.String[]) dead_code_elimination$initial(after) /// CHECK-DAG: <<Const34:i\d+>> IntConstant 34 /// CHECK-DAG: If /// CHECK-DAG: <<StaticFieldGet:i\d+>> StaticFieldGet @@ -217,12 +217,12 @@ public class Main { return true; } - /// CHECK-START: void Main.testSwitch(java.lang.String[]) dead_code_elimination (before) + /// CHECK-START: void Main.testSwitch(java.lang.String[]) dead_code_elimination$initial(before) /// CHECK: If /// CHECK: If /// CHECK: If - /// CHECK-START: void Main.testSwitch(java.lang.String[]) dead_code_elimination (after) + /// CHECK-START: void Main.testSwitch(java.lang.String[]) dead_code_elimination$initial(after) /// CHECK: If /// CHECK: If /// CHECK-NOT: If @@ -248,11 +248,11 @@ public class Main { // Redirect default here. } - /// CHECK-START: void Main.testFP(java.lang.String[]) dead_code_elimination (before) + /// CHECK-START: void Main.testFP(java.lang.String[]) dead_code_elimination$initial(before) /// CHECK: If /// CHECK: If - /// CHECK-START: void Main.testFP(java.lang.String[]) dead_code_elimination (after) + /// CHECK-START: void Main.testFP(java.lang.String[]) dead_code_elimination$initial(after) /// CHECK: If /// CHECK: If public static void testFP(String[] args) { |