diff options
91 files changed, 1985 insertions, 1620 deletions
diff --git a/compiler/Android.mk b/compiler/Android.mk index 61ebf1d618..16a158cf6f 100644 --- a/compiler/Android.mk +++ b/compiler/Android.mk @@ -153,6 +153,7 @@ LIBART_COMPILER_SRC_FILES_x86_64 := \ optimizing/intrinsics_x86_64.cc \ optimizing/code_generator_x86_64.cc \ utils/x86_64/assembler_x86_64.cc \ + utils/x86_64/jni_macro_assembler_x86_64.cc \ utils/x86_64/managed_register_x86_64.cc \ diff --git a/compiler/driver/compiler_options.cc b/compiler/driver/compiler_options.cc index f20dba34a6..30ba8c9e74 100644 --- a/compiler/driver/compiler_options.cc +++ b/compiler/driver/compiler_options.cc @@ -44,7 +44,9 @@ CompilerOptions::CompilerOptions() init_failure_output_(nullptr), dump_cfg_file_name_(""), dump_cfg_append_(false), - force_determinism_(false) { + force_determinism_(false), + register_allocation_strategy_(RegisterAllocator::kRegisterAllocatorDefault), + passes_to_run_(nullptr) { } CompilerOptions::~CompilerOptions() { @@ -74,7 +76,9 @@ CompilerOptions::CompilerOptions(CompilerFilter::Filter compiler_filter, bool abort_on_hard_verifier_failure, const std::string& dump_cfg_file_name, bool dump_cfg_append, - bool force_determinism + bool force_determinism, + 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), @@ -99,7 +103,9 @@ CompilerOptions::CompilerOptions(CompilerFilter::Filter compiler_filter, init_failure_output_(init_failure_output), dump_cfg_file_name_(dump_cfg_file_name), dump_cfg_append_(dump_cfg_append), - force_determinism_(force_determinism) { + force_determinism_(force_determinism), + register_allocation_strategy_(regalloc_strategy), + passes_to_run_(passes_to_run) { } void CompilerOptions::ParseHugeMethodMax(const StringPiece& option, UsageFn Usage) { @@ -144,6 +150,19 @@ void CompilerOptions::ParseDumpInitFailures(const StringPiece& option, } } +void CompilerOptions::ParseRegisterAllocationStrategy(const StringPiece& option, + UsageFn Usage) { + DCHECK(option.starts_with("--register-allocation-strategy=")); + StringPiece choice = option.substr(strlen("--register-allocation-strategy=")).data(); + if (choice == "linear-scan") { + register_allocation_strategy_ = RegisterAllocator::Strategy::kRegisterAllocatorLinearScan; + } else if (choice == "graph-color") { + register_allocation_strategy_ = RegisterAllocator::Strategy::kRegisterAllocatorGraphColor; + } else { + Usage("Unrecognized register allocation strategy. Try linear-scan, or graph-color."); + } +} + bool CompilerOptions::ParseCompilerOption(const StringPiece& option, UsageFn Usage) { if (option.starts_with("--compiler-filter=")) { const char* compiler_filter_string = option.substr(strlen("--compiler-filter=")).data(); @@ -190,6 +209,8 @@ bool CompilerOptions::ParseCompilerOption(const StringPiece& option, UsageFn Usa dump_cfg_file_name_ = option.substr(strlen("--dump-cfg=")).data(); } else if (option.starts_with("--dump-cfg-append")) { dump_cfg_append_ = true; + } else if (option.starts_with("--register-allocation-strategy=")) { + ParseRegisterAllocationStrategy(option, Usage); } else { // Option not recognized. return false; diff --git a/compiler/driver/compiler_options.h b/compiler/driver/compiler_options.h index 60b700ad91..abc58d7dda 100644 --- a/compiler/driver/compiler_options.h +++ b/compiler/driver/compiler_options.h @@ -24,6 +24,7 @@ #include "base/macros.h" #include "compiler_filter.h" #include "globals.h" +#include "optimizing/register_allocator.h" #include "utils.h" namespace art { @@ -74,7 +75,9 @@ class CompilerOptions FINAL { bool abort_on_hard_verifier_failure, const std::string& dump_cfg_file_name, bool dump_cfg_append, - bool force_determinism); + bool force_determinism, + RegisterAllocator::Strategy regalloc_strategy, + const std::vector<std::string>* passes_to_run); CompilerFilter::Filter GetCompilerFilter() const { return compiler_filter_; @@ -244,6 +247,14 @@ class CompilerOptions FINAL { return force_determinism_; } + RegisterAllocator::Strategy GetRegisterAllocationStrategy() const { + 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); @@ -254,6 +265,7 @@ class CompilerOptions FINAL { void ParseSmallMethodMax(const StringPiece& option, UsageFn Usage); void ParseLargeMethodMax(const StringPiece& option, UsageFn Usage); void ParseHugeMethodMax(const StringPiece& option, UsageFn Usage); + void ParseRegisterAllocationStrategy(const StringPiece& option, UsageFn Usage); CompilerFilter::Filter compiler_filter_; size_t huge_method_threshold_; @@ -297,6 +309,16 @@ class CompilerOptions FINAL { // outcomes. bool force_determinism_; + 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 178533849b..6f6a8f5a3b 100644 --- a/compiler/jit/jit_compiler.cc +++ b/compiler/jit/jit_compiler.cc @@ -32,6 +32,7 @@ #include "oat_file-inl.h" #include "oat_quick_method_header.h" #include "object_lock.h" +#include "optimizing/register_allocator.h" #include "thread_list.h" namespace art { @@ -110,7 +111,9 @@ JitCompiler::JitCompiler() { /* abort_on_hard_verifier_failure */ false, /* dump_cfg_file_name */ "", /* dump_cfg_append */ false, - /* force_determinism */ false)); + /* force_determinism */ false, + RegisterAllocator::kRegisterAllocatorDefault, + /* passes_to_run */ nullptr)); for (const std::string& argument : Runtime::Current()->GetCompilerOptions()) { compiler_options_->ParseCompilerOption(argument, Usage); } diff --git a/compiler/optimizing/code_generator_arm.cc b/compiler/optimizing/code_generator_arm.cc index c105940f28..5eaf11e9fb 100644 --- a/compiler/optimizing/code_generator_arm.cc +++ b/compiler/optimizing/code_generator_arm.cc @@ -432,6 +432,11 @@ class ReadBarrierMarkSlowPathARM : public SlowPathCode { (instruction_->IsInvokeVirtual()) && instruction_->GetLocations()->Intrinsified()) << "Unexpected instruction in read barrier marking slow path: " << instruction_->DebugName(); + // The read barrier instrumentation of object ArrayGet + // instructions does not support the HIntermediateAddress + // instruction. + DCHECK(!(instruction_->IsArrayGet() && + instruction_->AsArrayGet()->GetArray()->IsIntermediateAddress())); __ Bind(GetEntryLabel()); // No need to save live registers; it's taken care of by the @@ -512,6 +517,11 @@ class ReadBarrierForHeapReferenceSlowPathARM : public SlowPathCode { (instruction_->IsInvokeVirtual()) && instruction_->GetLocations()->Intrinsified()) << "Unexpected instruction in read barrier for heap reference slow path: " << instruction_->DebugName(); + // The read barrier instrumentation of object ArrayGet + // instructions does not support the HIntermediateAddress + // instruction. + DCHECK(!(instruction_->IsArrayGet() && + instruction_->AsArrayGet()->GetArray()->IsIntermediateAddress())); __ Bind(GetEntryLabel()); SaveLiveRegisters(codegen, locations); @@ -4467,8 +4477,6 @@ void InstructionCodeGeneratorARM::VisitArrayGet(HArrayGet* instruction) { Primitive::Type type = instruction->GetType(); HInstruction* array_instr = instruction->GetArray(); bool has_intermediate_address = array_instr->IsIntermediateAddress(); - // The read barrier instrumentation does not support the HIntermediateAddress instruction yet. - DCHECK(!(has_intermediate_address && kEmitCompilerReadBarrier)); switch (type) { case Primitive::kPrimBoolean: @@ -4503,6 +4511,11 @@ void InstructionCodeGeneratorARM::VisitArrayGet(HArrayGet* instruction) { } case Primitive::kPrimNot: { + // The read barrier instrumentation of object ArrayGet + // instructions does not support the HIntermediateAddress + // instruction. + DCHECK(!(has_intermediate_address && kEmitCompilerReadBarrier)); + static_assert( sizeof(mirror::HeapReference<mirror::Object>) == sizeof(int32_t), "art::mirror::HeapReference<art::mirror::Object> and int32_t have different sizes."); @@ -4645,8 +4658,6 @@ void InstructionCodeGeneratorARM::VisitArraySet(HArraySet* instruction) { Location value_loc = locations->InAt(2); HInstruction* array_instr = instruction->GetArray(); bool has_intermediate_address = array_instr->IsIntermediateAddress(); - // The read barrier instrumentation does not support the HIntermediateAddress instruction yet. - DCHECK(!(has_intermediate_address && kEmitCompilerReadBarrier)); switch (value_type) { case Primitive::kPrimBoolean: @@ -4911,8 +4922,6 @@ void InstructionCodeGeneratorARM::VisitArrayLength(HArrayLength* instruction) { } void LocationsBuilderARM::VisitIntermediateAddress(HIntermediateAddress* instruction) { - // The read barrier instrumentation does not support the HIntermediateAddress instruction yet. - DCHECK(!kEmitCompilerReadBarrier); LocationSummary* locations = new (GetGraph()->GetArena()) LocationSummary(instruction, LocationSummary::kNoCall); @@ -4927,9 +4936,6 @@ void InstructionCodeGeneratorARM::VisitIntermediateAddress(HIntermediateAddress* Location first = locations->InAt(0); Location second = locations->InAt(1); - // The read barrier instrumentation does not support the HIntermediateAddress instruction yet. - DCHECK(!kEmitCompilerReadBarrier); - if (second.IsRegister()) { __ add(out.AsRegister<Register>(), first.AsRegister<Register>(), diff --git a/compiler/optimizing/code_generator_arm64.cc b/compiler/optimizing/code_generator_arm64.cc index 54c9efcafe..9ceb3109cd 100644 --- a/compiler/optimizing/code_generator_arm64.cc +++ b/compiler/optimizing/code_generator_arm64.cc @@ -598,6 +598,11 @@ class ReadBarrierMarkSlowPathARM64 : public SlowPathCodeARM64 { (instruction_->IsInvokeVirtual()) && instruction_->GetLocations()->Intrinsified()) << "Unexpected instruction in read barrier marking slow path: " << instruction_->DebugName(); + // The read barrier instrumentation of object ArrayGet + // instructions does not support the HIntermediateAddress + // instruction. + DCHECK(!(instruction_->IsArrayGet() && + instruction_->AsArrayGet()->GetArray()->IsIntermediateAddress())); __ Bind(GetEntryLabel()); // No need to save live registers; it's taken care of by the @@ -680,7 +685,9 @@ class ReadBarrierForHeapReferenceSlowPathARM64 : public SlowPathCodeARM64 { (instruction_->IsInvokeVirtual()) && instruction_->GetLocations()->Intrinsified()) << "Unexpected instruction in read barrier for heap reference slow path: " << instruction_->DebugName(); - // The read barrier instrumentation does not support the HIntermediateAddress instruction yet. + // The read barrier instrumentation of object ArrayGet + // instructions does not support the HIntermediateAddress + // instruction. DCHECK(!(instruction_->IsArrayGet() && instruction_->AsArrayGet()->GetArray()->IsIntermediateAddress())); @@ -1983,8 +1990,6 @@ void InstructionCodeGeneratorARM64::VisitArm64DataProcWithShifterOp( } void LocationsBuilderARM64::VisitIntermediateAddress(HIntermediateAddress* instruction) { - // The read barrier instrumentation does not support the HIntermediateAddress instruction yet. - DCHECK(!kEmitCompilerReadBarrier); LocationSummary* locations = new (GetGraph()->GetArena()) LocationSummary(instruction, LocationSummary::kNoCall); locations->SetInAt(0, Location::RequiresRegister()); @@ -1992,10 +1997,7 @@ void LocationsBuilderARM64::VisitIntermediateAddress(HIntermediateAddress* instr locations->SetOut(Location::RequiresRegister()); } -void InstructionCodeGeneratorARM64::VisitIntermediateAddress( - HIntermediateAddress* instruction) { - // The read barrier instrumentation does not support the HIntermediateAddress instruction yet. - DCHECK(!kEmitCompilerReadBarrier); +void InstructionCodeGeneratorARM64::VisitIntermediateAddress(HIntermediateAddress* instruction) { __ Add(OutputRegister(instruction), InputRegisterAt(instruction, 0), Operand(InputOperandAt(instruction, 1))); @@ -2091,11 +2093,15 @@ void InstructionCodeGeneratorARM64::VisitArrayGet(HArrayGet* instruction) { // Block pools between `Load` and `MaybeRecordImplicitNullCheck`. BlockPoolsScope block_pools(masm); + // The read barrier instrumentation of object ArrayGet instructions + // does not support the HIntermediateAddress instruction. + DCHECK(!((type == Primitive::kPrimNot) && + instruction->GetArray()->IsIntermediateAddress() && + kEmitCompilerReadBarrier)); + if (type == Primitive::kPrimNot && kEmitCompilerReadBarrier && kUseBakerReadBarrier) { // Object ArrayGet with Baker's read barrier case. Register temp = temps.AcquireW(); - // The read barrier instrumentation does not support the HIntermediateAddress instruction yet. - DCHECK(!instruction->GetArray()->IsIntermediateAddress()); // Note that a potential implicit null check is handled in the // CodeGeneratorARM64::GenerateArrayLoadWithBakerReadBarrier call. codegen_->GenerateArrayLoadWithBakerReadBarrier( @@ -2109,9 +2115,6 @@ void InstructionCodeGeneratorARM64::VisitArrayGet(HArrayGet* instruction) { } else { Register temp = temps.AcquireSameSizeAs(obj); if (instruction->GetArray()->IsIntermediateAddress()) { - // The read barrier instrumentation does not support the - // HIntermediateAddress instruction yet. - DCHECK(!kEmitCompilerReadBarrier); // We do not need to compute the intermediate address from the array: the // input instruction has done it already. See the comment in // `TryExtractArrayAccessAddress()`. @@ -2201,9 +2204,6 @@ void InstructionCodeGeneratorARM64::VisitArraySet(HArraySet* instruction) { UseScratchRegisterScope temps(masm); Register temp = temps.AcquireSameSizeAs(array); if (instruction->GetArray()->IsIntermediateAddress()) { - // The read barrier instrumentation does not support the - // HIntermediateAddress instruction yet. - DCHECK(!kEmitCompilerReadBarrier); // We do not need to compute the intermediate address from the array: the // input instruction has done it already. See the comment in // `TryExtractArrayAccessAddress()`. @@ -2223,7 +2223,6 @@ void InstructionCodeGeneratorARM64::VisitArraySet(HArraySet* instruction) { codegen_->Store(value_type, value, destination); codegen_->MaybeRecordImplicitNullCheck(instruction); } else { - DCHECK(needs_write_barrier); DCHECK(!instruction->GetArray()->IsIntermediateAddress()); vixl::aarch64::Label done; SlowPathCodeARM64* slow_path = nullptr; 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/instruction_simplifier_shared.cc b/compiler/optimizing/instruction_simplifier_shared.cc index 8f7778fe68..6632cd9969 100644 --- a/compiler/optimizing/instruction_simplifier_shared.cc +++ b/compiler/optimizing/instruction_simplifier_shared.cc @@ -231,15 +231,6 @@ bool TryExtractArrayAccessAddress(HInstruction* access, HInstruction* array, HInstruction* index, size_t data_offset) { - if (kEmitCompilerReadBarrier) { - // The read barrier instrumentation does not support the - // HIntermediateAddress instruction yet. - // - // TODO: Handle this case properly in the ARM64 and ARM code generator and - // re-enable this optimization; otherwise, remove this TODO. - // b/26601270 - return false; - } if (index->IsConstant() || (index->IsBoundsCheck() && index->AsBoundsCheck()->GetIndex()->IsConstant())) { // When the index is a constant all the addressing can be fitted in the @@ -251,6 +242,13 @@ bool TryExtractArrayAccessAddress(HInstruction* access, // The access may require a runtime call or the original array pointer. return false; } + if (kEmitCompilerReadBarrier && + access->IsArrayGet() && + access->AsArrayGet()->GetType() == Primitive::kPrimNot) { + // For object arrays, the read barrier instrumentation requires + // the original array pointer. + return false; + } // Proceed to extract the base address computation. HGraph* graph = access->GetBlock()->GetGraph(); 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 d5b0d77fe5..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 }; @@ -546,7 +659,8 @@ void OptimizingCompiler::RunArchOptimizations(InstructionSet instruction_set, NO_INLINE // Avoid increasing caller's frame size by large stack-allocated objects. static void AllocateRegisters(HGraph* graph, CodeGenerator* codegen, - PassObserver* pass_observer) { + PassObserver* pass_observer, + RegisterAllocator::Strategy strategy) { { PassScope scope(PrepareForRegisterAllocation::kPrepareForRegisterAllocationPassName, pass_observer); @@ -559,7 +673,7 @@ static void AllocateRegisters(HGraph* graph, } { PassScope scope(RegisterAllocator::kRegisterAllocatorPassName, pass_observer); - RegisterAllocator::Create(graph->GetArena(), codegen, liveness)->AllocateRegisters(); + RegisterAllocator::Create(graph->GetArena(), codegen, liveness, strategy)->AllocateRegisters(); } } @@ -571,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); @@ -588,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[] = { @@ -626,7 +755,6 @@ void OptimizingCompiler::RunOptimizations(HGraph* graph, RunOptimizations(optimizations2, arraysize(optimizations2), pass_observer); RunArchOptimizations(driver->GetInstructionSet(), graph, codegen, pass_observer); - AllocateRegisters(graph, codegen, pass_observer); } static ArenaVector<LinkerPatch> EmitAndSortLinkerPatches(CodeGenerator* codegen) { @@ -841,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/compiler/utils/jni_macro_assembler.cc b/compiler/utils/jni_macro_assembler.cc index 6fdf09baa3..1acc90ca6f 100644 --- a/compiler/utils/jni_macro_assembler.cc +++ b/compiler/utils/jni_macro_assembler.cc @@ -36,7 +36,7 @@ #include "x86/jni_macro_assembler_x86.h" #endif #ifdef ART_ENABLE_CODEGEN_x86_64 -#include "x86_64/assembler_x86_64.h" +#include "x86_64/jni_macro_assembler_x86_64.h" #endif #include "base/casts.h" #include "globals.h" @@ -98,7 +98,7 @@ MacroAsm64UniquePtr JNIMacroAssembler<PointerSize::k64>::Create( #endif #ifdef ART_ENABLE_CODEGEN_x86_64 case kX86_64: - return MacroAsm64UniquePtr(new (arena) x86_64::X86_64Assembler(arena)); + return MacroAsm64UniquePtr(new (arena) x86_64::X86_64JNIMacroAssembler(arena)); #endif default: LOG(FATAL) << "Unknown/unsupported 8B InstructionSet: " << instruction_set; diff --git a/compiler/utils/x86_64/assembler_x86_64.cc b/compiler/utils/x86_64/assembler_x86_64.cc index ce4ea1d8fd..ddc824425e 100644 --- a/compiler/utils/x86_64/assembler_x86_64.cc +++ b/compiler/utils/x86_64/assembler_x86_64.cc @@ -2639,543 +2639,6 @@ void X86_64Assembler::EmitOptionalByteRegNormalizingRex32(CpuRegister dst, const } } -static dwarf::Reg DWARFReg(Register reg) { - return dwarf::Reg::X86_64Core(static_cast<int>(reg)); -} -static dwarf::Reg DWARFReg(FloatRegister reg) { - return dwarf::Reg::X86_64Fp(static_cast<int>(reg)); -} - -constexpr size_t kFramePointerSize = 8; - -void X86_64Assembler::BuildFrame(size_t frame_size, - ManagedRegister method_reg, - ArrayRef<const ManagedRegister> spill_regs, - const ManagedRegisterEntrySpills& entry_spills) { - DCHECK_EQ(buffer_.Size(), 0U); // Nothing emitted yet. - cfi_.SetCurrentCFAOffset(8); // Return address on stack. - CHECK_ALIGNED(frame_size, kStackAlignment); - int gpr_count = 0; - for (int i = spill_regs.size() - 1; i >= 0; --i) { - x86_64::X86_64ManagedRegister spill = spill_regs[i].AsX86_64(); - if (spill.IsCpuRegister()) { - pushq(spill.AsCpuRegister()); - gpr_count++; - cfi_.AdjustCFAOffset(kFramePointerSize); - cfi_.RelOffset(DWARFReg(spill.AsCpuRegister().AsRegister()), 0); - } - } - // return address then method on stack. - int64_t rest_of_frame = static_cast<int64_t>(frame_size) - - (gpr_count * kFramePointerSize) - - kFramePointerSize /*return address*/; - subq(CpuRegister(RSP), Immediate(rest_of_frame)); - cfi_.AdjustCFAOffset(rest_of_frame); - - // spill xmms - int64_t offset = rest_of_frame; - for (int i = spill_regs.size() - 1; i >= 0; --i) { - x86_64::X86_64ManagedRegister spill = spill_regs[i].AsX86_64(); - if (spill.IsXmmRegister()) { - offset -= sizeof(double); - movsd(Address(CpuRegister(RSP), offset), spill.AsXmmRegister()); - cfi_.RelOffset(DWARFReg(spill.AsXmmRegister().AsFloatRegister()), offset); - } - } - - static_assert(static_cast<size_t>(kX86_64PointerSize) == kFramePointerSize, - "Unexpected frame pointer size."); - - movq(Address(CpuRegister(RSP), 0), method_reg.AsX86_64().AsCpuRegister()); - - for (size_t i = 0; i < entry_spills.size(); ++i) { - ManagedRegisterSpill spill = entry_spills.at(i); - if (spill.AsX86_64().IsCpuRegister()) { - if (spill.getSize() == 8) { - movq(Address(CpuRegister(RSP), frame_size + spill.getSpillOffset()), - spill.AsX86_64().AsCpuRegister()); - } else { - CHECK_EQ(spill.getSize(), 4); - movl(Address(CpuRegister(RSP), frame_size + spill.getSpillOffset()), spill.AsX86_64().AsCpuRegister()); - } - } else { - if (spill.getSize() == 8) { - movsd(Address(CpuRegister(RSP), frame_size + spill.getSpillOffset()), spill.AsX86_64().AsXmmRegister()); - } else { - CHECK_EQ(spill.getSize(), 4); - movss(Address(CpuRegister(RSP), frame_size + spill.getSpillOffset()), spill.AsX86_64().AsXmmRegister()); - } - } - } -} - -void X86_64Assembler::RemoveFrame(size_t frame_size, ArrayRef<const ManagedRegister> spill_regs) { - CHECK_ALIGNED(frame_size, kStackAlignment); - cfi_.RememberState(); - int gpr_count = 0; - // unspill xmms - int64_t offset = static_cast<int64_t>(frame_size) - (spill_regs.size() * kFramePointerSize) - 2 * kFramePointerSize; - for (size_t i = 0; i < spill_regs.size(); ++i) { - x86_64::X86_64ManagedRegister spill = spill_regs[i].AsX86_64(); - if (spill.IsXmmRegister()) { - offset += sizeof(double); - movsd(spill.AsXmmRegister(), Address(CpuRegister(RSP), offset)); - cfi_.Restore(DWARFReg(spill.AsXmmRegister().AsFloatRegister())); - } else { - gpr_count++; - } - } - int adjust = static_cast<int>(frame_size) - (gpr_count * kFramePointerSize) - kFramePointerSize; - addq(CpuRegister(RSP), Immediate(adjust)); - cfi_.AdjustCFAOffset(-adjust); - for (size_t i = 0; i < spill_regs.size(); ++i) { - x86_64::X86_64ManagedRegister spill = spill_regs[i].AsX86_64(); - if (spill.IsCpuRegister()) { - popq(spill.AsCpuRegister()); - cfi_.AdjustCFAOffset(-static_cast<int>(kFramePointerSize)); - cfi_.Restore(DWARFReg(spill.AsCpuRegister().AsRegister())); - } - } - ret(); - // The CFI should be restored for any code that follows the exit block. - cfi_.RestoreState(); - cfi_.DefCFAOffset(frame_size); -} - -void X86_64Assembler::IncreaseFrameSize(size_t adjust) { - CHECK_ALIGNED(adjust, kStackAlignment); - addq(CpuRegister(RSP), Immediate(-static_cast<int64_t>(adjust))); - cfi_.AdjustCFAOffset(adjust); -} - -void X86_64Assembler::DecreaseFrameSize(size_t adjust) { - CHECK_ALIGNED(adjust, kStackAlignment); - addq(CpuRegister(RSP), Immediate(adjust)); - cfi_.AdjustCFAOffset(-adjust); -} - -void X86_64Assembler::Store(FrameOffset offs, ManagedRegister msrc, size_t size) { - X86_64ManagedRegister src = msrc.AsX86_64(); - if (src.IsNoRegister()) { - CHECK_EQ(0u, size); - } else if (src.IsCpuRegister()) { - if (size == 4) { - CHECK_EQ(4u, size); - movl(Address(CpuRegister(RSP), offs), src.AsCpuRegister()); - } else { - CHECK_EQ(8u, size); - movq(Address(CpuRegister(RSP), offs), src.AsCpuRegister()); - } - } else if (src.IsRegisterPair()) { - CHECK_EQ(0u, size); - movq(Address(CpuRegister(RSP), offs), src.AsRegisterPairLow()); - movq(Address(CpuRegister(RSP), FrameOffset(offs.Int32Value()+4)), - src.AsRegisterPairHigh()); - } else if (src.IsX87Register()) { - if (size == 4) { - fstps(Address(CpuRegister(RSP), offs)); - } else { - fstpl(Address(CpuRegister(RSP), offs)); - } - } else { - CHECK(src.IsXmmRegister()); - if (size == 4) { - movss(Address(CpuRegister(RSP), offs), src.AsXmmRegister()); - } else { - movsd(Address(CpuRegister(RSP), offs), src.AsXmmRegister()); - } - } -} - -void X86_64Assembler::StoreRef(FrameOffset dest, ManagedRegister msrc) { - X86_64ManagedRegister src = msrc.AsX86_64(); - CHECK(src.IsCpuRegister()); - movl(Address(CpuRegister(RSP), dest), src.AsCpuRegister()); -} - -void X86_64Assembler::StoreRawPtr(FrameOffset dest, ManagedRegister msrc) { - X86_64ManagedRegister src = msrc.AsX86_64(); - CHECK(src.IsCpuRegister()); - movq(Address(CpuRegister(RSP), dest), src.AsCpuRegister()); -} - -void X86_64Assembler::StoreImmediateToFrame(FrameOffset dest, uint32_t imm, - ManagedRegister) { - movl(Address(CpuRegister(RSP), dest), Immediate(imm)); // TODO(64) movq? -} - -void X86_64Assembler::StoreStackOffsetToThread(ThreadOffset64 thr_offs, - FrameOffset fr_offs, - ManagedRegister mscratch) { - X86_64ManagedRegister scratch = mscratch.AsX86_64(); - CHECK(scratch.IsCpuRegister()); - leaq(scratch.AsCpuRegister(), Address(CpuRegister(RSP), fr_offs)); - gs()->movq(Address::Absolute(thr_offs, true), scratch.AsCpuRegister()); -} - -void X86_64Assembler::StoreStackPointerToThread(ThreadOffset64 thr_offs) { - gs()->movq(Address::Absolute(thr_offs, true), CpuRegister(RSP)); -} - -void X86_64Assembler::StoreSpanning(FrameOffset /*dst*/, ManagedRegister /*src*/, - FrameOffset /*in_off*/, ManagedRegister /*scratch*/) { - UNIMPLEMENTED(FATAL); // this case only currently exists for ARM -} - -void X86_64Assembler::Load(ManagedRegister mdest, FrameOffset src, size_t size) { - X86_64ManagedRegister dest = mdest.AsX86_64(); - if (dest.IsNoRegister()) { - CHECK_EQ(0u, size); - } else if (dest.IsCpuRegister()) { - if (size == 4) { - CHECK_EQ(4u, size); - movl(dest.AsCpuRegister(), Address(CpuRegister(RSP), src)); - } else { - CHECK_EQ(8u, size); - movq(dest.AsCpuRegister(), Address(CpuRegister(RSP), src)); - } - } else if (dest.IsRegisterPair()) { - CHECK_EQ(0u, size); - movq(dest.AsRegisterPairLow(), Address(CpuRegister(RSP), src)); - movq(dest.AsRegisterPairHigh(), Address(CpuRegister(RSP), FrameOffset(src.Int32Value()+4))); - } else if (dest.IsX87Register()) { - if (size == 4) { - flds(Address(CpuRegister(RSP), src)); - } else { - fldl(Address(CpuRegister(RSP), src)); - } - } else { - CHECK(dest.IsXmmRegister()); - if (size == 4) { - movss(dest.AsXmmRegister(), Address(CpuRegister(RSP), src)); - } else { - movsd(dest.AsXmmRegister(), Address(CpuRegister(RSP), src)); - } - } -} - -void X86_64Assembler::LoadFromThread(ManagedRegister mdest, ThreadOffset64 src, size_t size) { - X86_64ManagedRegister dest = mdest.AsX86_64(); - if (dest.IsNoRegister()) { - CHECK_EQ(0u, size); - } else if (dest.IsCpuRegister()) { - CHECK_EQ(4u, size); - gs()->movl(dest.AsCpuRegister(), Address::Absolute(src, true)); - } else if (dest.IsRegisterPair()) { - CHECK_EQ(8u, size); - gs()->movq(dest.AsRegisterPairLow(), Address::Absolute(src, true)); - } else if (dest.IsX87Register()) { - if (size == 4) { - gs()->flds(Address::Absolute(src, true)); - } else { - gs()->fldl(Address::Absolute(src, true)); - } - } else { - CHECK(dest.IsXmmRegister()); - if (size == 4) { - gs()->movss(dest.AsXmmRegister(), Address::Absolute(src, true)); - } else { - gs()->movsd(dest.AsXmmRegister(), Address::Absolute(src, true)); - } - } -} - -void X86_64Assembler::LoadRef(ManagedRegister mdest, FrameOffset src) { - X86_64ManagedRegister dest = mdest.AsX86_64(); - CHECK(dest.IsCpuRegister()); - movq(dest.AsCpuRegister(), Address(CpuRegister(RSP), src)); -} - -void X86_64Assembler::LoadRef(ManagedRegister mdest, ManagedRegister base, MemberOffset offs, - bool unpoison_reference) { - X86_64ManagedRegister dest = mdest.AsX86_64(); - CHECK(dest.IsCpuRegister() && dest.IsCpuRegister()); - movl(dest.AsCpuRegister(), Address(base.AsX86_64().AsCpuRegister(), offs)); - if (unpoison_reference) { - MaybeUnpoisonHeapReference(dest.AsCpuRegister()); - } -} - -void X86_64Assembler::LoadRawPtr(ManagedRegister mdest, ManagedRegister base, - Offset offs) { - X86_64ManagedRegister dest = mdest.AsX86_64(); - CHECK(dest.IsCpuRegister() && dest.IsCpuRegister()); - movq(dest.AsCpuRegister(), Address(base.AsX86_64().AsCpuRegister(), offs)); -} - -void X86_64Assembler::LoadRawPtrFromThread(ManagedRegister mdest, ThreadOffset64 offs) { - X86_64ManagedRegister dest = mdest.AsX86_64(); - CHECK(dest.IsCpuRegister()); - gs()->movq(dest.AsCpuRegister(), Address::Absolute(offs, true)); -} - -void X86_64Assembler::SignExtend(ManagedRegister mreg, size_t size) { - X86_64ManagedRegister reg = mreg.AsX86_64(); - CHECK(size == 1 || size == 2) << size; - CHECK(reg.IsCpuRegister()) << reg; - if (size == 1) { - movsxb(reg.AsCpuRegister(), reg.AsCpuRegister()); - } else { - movsxw(reg.AsCpuRegister(), reg.AsCpuRegister()); - } -} - -void X86_64Assembler::ZeroExtend(ManagedRegister mreg, size_t size) { - X86_64ManagedRegister reg = mreg.AsX86_64(); - CHECK(size == 1 || size == 2) << size; - CHECK(reg.IsCpuRegister()) << reg; - if (size == 1) { - movzxb(reg.AsCpuRegister(), reg.AsCpuRegister()); - } else { - movzxw(reg.AsCpuRegister(), reg.AsCpuRegister()); - } -} - -void X86_64Assembler::Move(ManagedRegister mdest, ManagedRegister msrc, size_t size) { - X86_64ManagedRegister dest = mdest.AsX86_64(); - X86_64ManagedRegister src = msrc.AsX86_64(); - if (!dest.Equals(src)) { - if (dest.IsCpuRegister() && src.IsCpuRegister()) { - movq(dest.AsCpuRegister(), src.AsCpuRegister()); - } else if (src.IsX87Register() && dest.IsXmmRegister()) { - // Pass via stack and pop X87 register - subl(CpuRegister(RSP), Immediate(16)); - if (size == 4) { - CHECK_EQ(src.AsX87Register(), ST0); - fstps(Address(CpuRegister(RSP), 0)); - movss(dest.AsXmmRegister(), Address(CpuRegister(RSP), 0)); - } else { - CHECK_EQ(src.AsX87Register(), ST0); - fstpl(Address(CpuRegister(RSP), 0)); - movsd(dest.AsXmmRegister(), Address(CpuRegister(RSP), 0)); - } - addq(CpuRegister(RSP), Immediate(16)); - } else { - // TODO: x87, SSE - UNIMPLEMENTED(FATAL) << ": Move " << dest << ", " << src; - } - } -} - -void X86_64Assembler::CopyRef(FrameOffset dest, FrameOffset src, ManagedRegister mscratch) { - X86_64ManagedRegister scratch = mscratch.AsX86_64(); - CHECK(scratch.IsCpuRegister()); - movl(scratch.AsCpuRegister(), Address(CpuRegister(RSP), src)); - movl(Address(CpuRegister(RSP), dest), scratch.AsCpuRegister()); -} - -void X86_64Assembler::CopyRawPtrFromThread(FrameOffset fr_offs, - ThreadOffset64 thr_offs, - ManagedRegister mscratch) { - X86_64ManagedRegister scratch = mscratch.AsX86_64(); - CHECK(scratch.IsCpuRegister()); - gs()->movq(scratch.AsCpuRegister(), Address::Absolute(thr_offs, true)); - Store(fr_offs, scratch, 8); -} - -void X86_64Assembler::CopyRawPtrToThread(ThreadOffset64 thr_offs, - FrameOffset fr_offs, - ManagedRegister mscratch) { - X86_64ManagedRegister scratch = mscratch.AsX86_64(); - CHECK(scratch.IsCpuRegister()); - Load(scratch, fr_offs, 8); - gs()->movq(Address::Absolute(thr_offs, true), scratch.AsCpuRegister()); -} - -void X86_64Assembler::Copy(FrameOffset dest, FrameOffset src, ManagedRegister mscratch, - size_t size) { - X86_64ManagedRegister scratch = mscratch.AsX86_64(); - if (scratch.IsCpuRegister() && size == 8) { - Load(scratch, src, 4); - Store(dest, scratch, 4); - Load(scratch, FrameOffset(src.Int32Value() + 4), 4); - Store(FrameOffset(dest.Int32Value() + 4), scratch, 4); - } else { - Load(scratch, src, size); - Store(dest, scratch, size); - } -} - -void X86_64Assembler::Copy(FrameOffset /*dst*/, ManagedRegister /*src_base*/, Offset /*src_offset*/, - ManagedRegister /*scratch*/, size_t /*size*/) { - UNIMPLEMENTED(FATAL); -} - -void X86_64Assembler::Copy(ManagedRegister dest_base, Offset dest_offset, FrameOffset src, - ManagedRegister scratch, size_t size) { - CHECK(scratch.IsNoRegister()); - CHECK_EQ(size, 4u); - pushq(Address(CpuRegister(RSP), src)); - popq(Address(dest_base.AsX86_64().AsCpuRegister(), dest_offset)); -} - -void X86_64Assembler::Copy(FrameOffset dest, FrameOffset src_base, Offset src_offset, - ManagedRegister mscratch, size_t size) { - CpuRegister scratch = mscratch.AsX86_64().AsCpuRegister(); - CHECK_EQ(size, 4u); - movq(scratch, Address(CpuRegister(RSP), src_base)); - movq(scratch, Address(scratch, src_offset)); - movq(Address(CpuRegister(RSP), dest), scratch); -} - -void X86_64Assembler::Copy(ManagedRegister dest, Offset dest_offset, - ManagedRegister src, Offset src_offset, - ManagedRegister scratch, size_t size) { - CHECK_EQ(size, 4u); - CHECK(scratch.IsNoRegister()); - pushq(Address(src.AsX86_64().AsCpuRegister(), src_offset)); - popq(Address(dest.AsX86_64().AsCpuRegister(), dest_offset)); -} - -void X86_64Assembler::Copy(FrameOffset dest, Offset dest_offset, FrameOffset src, Offset src_offset, - ManagedRegister mscratch, size_t size) { - CpuRegister scratch = mscratch.AsX86_64().AsCpuRegister(); - CHECK_EQ(size, 4u); - CHECK_EQ(dest.Int32Value(), src.Int32Value()); - movq(scratch, Address(CpuRegister(RSP), src)); - pushq(Address(scratch, src_offset)); - popq(Address(scratch, dest_offset)); -} - -void X86_64Assembler::MemoryBarrier(ManagedRegister) { - mfence(); -} - -void X86_64Assembler::CreateHandleScopeEntry(ManagedRegister mout_reg, - FrameOffset handle_scope_offset, - ManagedRegister min_reg, bool null_allowed) { - X86_64ManagedRegister out_reg = mout_reg.AsX86_64(); - X86_64ManagedRegister in_reg = min_reg.AsX86_64(); - if (in_reg.IsNoRegister()) { // TODO(64): && null_allowed - // Use out_reg as indicator of null. - in_reg = out_reg; - // TODO: movzwl - movl(in_reg.AsCpuRegister(), Address(CpuRegister(RSP), handle_scope_offset)); - } - CHECK(in_reg.IsCpuRegister()); - CHECK(out_reg.IsCpuRegister()); - VerifyObject(in_reg, null_allowed); - if (null_allowed) { - Label null_arg; - if (!out_reg.Equals(in_reg)) { - xorl(out_reg.AsCpuRegister(), out_reg.AsCpuRegister()); - } - testl(in_reg.AsCpuRegister(), in_reg.AsCpuRegister()); - j(kZero, &null_arg); - leaq(out_reg.AsCpuRegister(), Address(CpuRegister(RSP), handle_scope_offset)); - Bind(&null_arg); - } else { - leaq(out_reg.AsCpuRegister(), Address(CpuRegister(RSP), handle_scope_offset)); - } -} - -void X86_64Assembler::CreateHandleScopeEntry(FrameOffset out_off, - FrameOffset handle_scope_offset, - ManagedRegister mscratch, - bool null_allowed) { - X86_64ManagedRegister scratch = mscratch.AsX86_64(); - CHECK(scratch.IsCpuRegister()); - if (null_allowed) { - Label null_arg; - movl(scratch.AsCpuRegister(), Address(CpuRegister(RSP), handle_scope_offset)); - testl(scratch.AsCpuRegister(), scratch.AsCpuRegister()); - j(kZero, &null_arg); - leaq(scratch.AsCpuRegister(), Address(CpuRegister(RSP), handle_scope_offset)); - Bind(&null_arg); - } else { - leaq(scratch.AsCpuRegister(), Address(CpuRegister(RSP), handle_scope_offset)); - } - Store(out_off, scratch, 8); -} - -// Given a handle scope entry, load the associated reference. -void X86_64Assembler::LoadReferenceFromHandleScope(ManagedRegister mout_reg, - ManagedRegister min_reg) { - X86_64ManagedRegister out_reg = mout_reg.AsX86_64(); - X86_64ManagedRegister in_reg = min_reg.AsX86_64(); - CHECK(out_reg.IsCpuRegister()); - CHECK(in_reg.IsCpuRegister()); - Label null_arg; - if (!out_reg.Equals(in_reg)) { - xorl(out_reg.AsCpuRegister(), out_reg.AsCpuRegister()); - } - testl(in_reg.AsCpuRegister(), in_reg.AsCpuRegister()); - j(kZero, &null_arg); - movq(out_reg.AsCpuRegister(), Address(in_reg.AsCpuRegister(), 0)); - Bind(&null_arg); -} - -void X86_64Assembler::VerifyObject(ManagedRegister /*src*/, bool /*could_be_null*/) { - // TODO: not validating references -} - -void X86_64Assembler::VerifyObject(FrameOffset /*src*/, bool /*could_be_null*/) { - // TODO: not validating references -} - -void X86_64Assembler::Call(ManagedRegister mbase, Offset offset, ManagedRegister) { - X86_64ManagedRegister base = mbase.AsX86_64(); - CHECK(base.IsCpuRegister()); - call(Address(base.AsCpuRegister(), offset.Int32Value())); - // TODO: place reference map on call -} - -void X86_64Assembler::Call(FrameOffset base, Offset offset, ManagedRegister mscratch) { - CpuRegister scratch = mscratch.AsX86_64().AsCpuRegister(); - movq(scratch, Address(CpuRegister(RSP), base)); - call(Address(scratch, offset)); -} - -void X86_64Assembler::CallFromThread(ThreadOffset64 offset, ManagedRegister /*mscratch*/) { - gs()->call(Address::Absolute(offset, true)); -} - -void X86_64Assembler::GetCurrentThread(ManagedRegister tr) { - gs()->movq(tr.AsX86_64().AsCpuRegister(), - Address::Absolute(Thread::SelfOffset<kX86_64PointerSize>(), true)); -} - -void X86_64Assembler::GetCurrentThread(FrameOffset offset, ManagedRegister mscratch) { - X86_64ManagedRegister scratch = mscratch.AsX86_64(); - gs()->movq(scratch.AsCpuRegister(), - Address::Absolute(Thread::SelfOffset<kX86_64PointerSize>(), true)); - movq(Address(CpuRegister(RSP), offset), scratch.AsCpuRegister()); -} - -// Slowpath entered when Thread::Current()->_exception is non-null -class X86_64ExceptionSlowPath FINAL : public SlowPath { - public: - explicit X86_64ExceptionSlowPath(size_t stack_adjust) : stack_adjust_(stack_adjust) {} - virtual void Emit(Assembler *sp_asm) OVERRIDE; - private: - const size_t stack_adjust_; -}; - -void X86_64Assembler::ExceptionPoll(ManagedRegister /*scratch*/, size_t stack_adjust) { - X86_64ExceptionSlowPath* slow = new (GetArena()) X86_64ExceptionSlowPath(stack_adjust); - buffer_.EnqueueSlowPath(slow); - gs()->cmpl(Address::Absolute(Thread::ExceptionOffset<kX86_64PointerSize>(), true), Immediate(0)); - j(kNotEqual, slow->Entry()); -} - -void X86_64ExceptionSlowPath::Emit(Assembler *sasm) { - X86_64Assembler* sp_asm = down_cast<X86_64Assembler*>(sasm); -#define __ sp_asm-> - __ Bind(&entry_); - // Note: the return value is dead - if (stack_adjust_ != 0) { // Fix up the frame. - __ DecreaseFrameSize(stack_adjust_); - } - // Pass exception as argument in RDI - __ gs()->movq(CpuRegister(RDI), - Address::Absolute(Thread::ExceptionOffset<kX86_64PointerSize>(), true)); - __ gs()->call( - Address::Absolute(QUICK_ENTRYPOINT_OFFSET(kX86_64PointerSize, pDeliverException), true)); - // this call should never return - __ int3(); -#undef __ -} - void X86_64Assembler::AddConstantArea() { ArrayRef<const int32_t> area = constant_area_.GetBuffer(); for (size_t i = 0, e = area.size(); i < e; i++) { diff --git a/compiler/utils/x86_64/assembler_x86_64.h b/compiler/utils/x86_64/assembler_x86_64.h index d298da2e6c..370f49cb05 100644 --- a/compiler/utils/x86_64/assembler_x86_64.h +++ b/compiler/utils/x86_64/assembler_x86_64.h @@ -333,20 +333,11 @@ class NearLabel : private Label { }; -class X86_64Assembler FINAL : public Assembler, public JNIMacroAssembler<PointerSize::k64> { +class X86_64Assembler FINAL : public Assembler { public: explicit X86_64Assembler(ArenaAllocator* arena) : Assembler(arena), constant_area_(arena) {} virtual ~X86_64Assembler() {} - size_t CodeSize() const OVERRIDE { return Assembler::CodeSize(); } - DebugFrameOpCodeWriterForAssembler& cfi() { return Assembler::cfi(); } - void FinalizeCode() OVERRIDE { - Assembler::FinalizeCode(); - } - void FinalizeInstructions(const MemoryRegion& region) { - Assembler::FinalizeInstructions(region); - } - /* * Emit Machine Instructions. */ @@ -709,124 +700,6 @@ class X86_64Assembler FINAL : public Assembler, public JNIMacroAssembler<Pointer } void Bind(NearLabel* label); - // - // Overridden common assembler high-level functionality - // - - // Emit code that will create an activation on the stack - void BuildFrame(size_t frame_size, - ManagedRegister method_reg, - ArrayRef<const ManagedRegister> callee_save_regs, - const ManagedRegisterEntrySpills& entry_spills) OVERRIDE; - - // Emit code that will remove an activation from the stack - void RemoveFrame(size_t frame_size, ArrayRef<const ManagedRegister> callee_save_regs) - OVERRIDE; - - void IncreaseFrameSize(size_t adjust) OVERRIDE; - void DecreaseFrameSize(size_t adjust) OVERRIDE; - - // Store routines - void Store(FrameOffset offs, ManagedRegister src, size_t size) OVERRIDE; - void StoreRef(FrameOffset dest, ManagedRegister src) OVERRIDE; - void StoreRawPtr(FrameOffset dest, ManagedRegister src) OVERRIDE; - - void StoreImmediateToFrame(FrameOffset dest, uint32_t imm, ManagedRegister scratch) OVERRIDE; - - void StoreStackOffsetToThread(ThreadOffset64 thr_offs, - FrameOffset fr_offs, - ManagedRegister scratch) OVERRIDE; - - void StoreStackPointerToThread(ThreadOffset64 thr_offs) OVERRIDE; - - void StoreSpanning(FrameOffset dest, ManagedRegister src, FrameOffset in_off, - ManagedRegister scratch) OVERRIDE; - - // Load routines - void Load(ManagedRegister dest, FrameOffset src, size_t size) OVERRIDE; - - void LoadFromThread(ManagedRegister dest, ThreadOffset64 src, size_t size) OVERRIDE; - - void LoadRef(ManagedRegister dest, FrameOffset src) OVERRIDE; - - void LoadRef(ManagedRegister dest, ManagedRegister base, MemberOffset offs, - bool unpoison_reference) OVERRIDE; - - void LoadRawPtr(ManagedRegister dest, ManagedRegister base, Offset offs) OVERRIDE; - - void LoadRawPtrFromThread(ManagedRegister dest, ThreadOffset64 offs) OVERRIDE; - - // Copying routines - void Move(ManagedRegister dest, ManagedRegister src, size_t size); - - void CopyRawPtrFromThread(FrameOffset fr_offs, - ThreadOffset64 thr_offs, - ManagedRegister scratch) OVERRIDE; - - void CopyRawPtrToThread(ThreadOffset64 thr_offs, FrameOffset fr_offs, ManagedRegister scratch) - OVERRIDE; - - void CopyRef(FrameOffset dest, FrameOffset src, ManagedRegister scratch) OVERRIDE; - - void Copy(FrameOffset dest, FrameOffset src, ManagedRegister scratch, size_t size) OVERRIDE; - - void Copy(FrameOffset dest, ManagedRegister src_base, Offset src_offset, ManagedRegister scratch, - size_t size) OVERRIDE; - - void Copy(ManagedRegister dest_base, Offset dest_offset, FrameOffset src, ManagedRegister scratch, - size_t size) OVERRIDE; - - void Copy(FrameOffset dest, FrameOffset src_base, Offset src_offset, ManagedRegister scratch, - size_t size) OVERRIDE; - - void Copy(ManagedRegister dest, Offset dest_offset, ManagedRegister src, Offset src_offset, - ManagedRegister scratch, size_t size) OVERRIDE; - - void Copy(FrameOffset dest, Offset dest_offset, FrameOffset src, Offset src_offset, - ManagedRegister scratch, size_t size) OVERRIDE; - - void MemoryBarrier(ManagedRegister) OVERRIDE; - - // Sign extension - void SignExtend(ManagedRegister mreg, size_t size) OVERRIDE; - - // Zero extension - void ZeroExtend(ManagedRegister mreg, size_t size) OVERRIDE; - - // Exploit fast access in managed code to Thread::Current() - void GetCurrentThread(ManagedRegister tr) OVERRIDE; - void GetCurrentThread(FrameOffset dest_offset, ManagedRegister scratch) OVERRIDE; - - // Set up out_reg to hold a Object** into the handle scope, or to be null if the - // value is null and null_allowed. in_reg holds a possibly stale reference - // that can be used to avoid loading the handle scope entry to see if the value is - // null. - void CreateHandleScopeEntry(ManagedRegister out_reg, FrameOffset handlescope_offset, - ManagedRegister in_reg, bool null_allowed) OVERRIDE; - - // Set up out_off to hold a Object** into the handle scope, or to be null if the - // value is null and null_allowed. - void CreateHandleScopeEntry(FrameOffset out_off, FrameOffset handlescope_offset, - ManagedRegister scratch, bool null_allowed) OVERRIDE; - - // src holds a handle scope entry (Object**) load this into dst - virtual void LoadReferenceFromHandleScope(ManagedRegister dst, - ManagedRegister src); - - // Heap::VerifyObject on src. In some cases (such as a reference to this) we - // know that src may not be null. - void VerifyObject(ManagedRegister src, bool could_be_null) OVERRIDE; - void VerifyObject(FrameOffset src, bool could_be_null) OVERRIDE; - - // Call to address held at [base+offset] - void Call(ManagedRegister base, Offset offset, ManagedRegister scratch) OVERRIDE; - void Call(FrameOffset base, Offset offset, ManagedRegister scratch) OVERRIDE; - void CallFromThread(ThreadOffset64 offset, ManagedRegister scratch) OVERRIDE; - - // Generate code to check if Thread::Current()->exception_ is non-null - // and branch to a ExceptionSlowPath if it is. - void ExceptionPoll(ManagedRegister scratch, size_t stack_adjust) OVERRIDE; - // Add a double to the constant area, returning the offset into // the constant area where the literal resides. size_t AddDouble(double v) { return constant_area_.AddDouble(v); } diff --git a/compiler/utils/x86_64/assembler_x86_64_test.cc b/compiler/utils/x86_64/assembler_x86_64_test.cc index 788c7253cf..36c966b3cf 100644 --- a/compiler/utils/x86_64/assembler_x86_64_test.cc +++ b/compiler/utils/x86_64/assembler_x86_64_test.cc @@ -22,7 +22,9 @@ #include "base/bit_utils.h" #include "base/stl_util.h" +#include "jni_macro_assembler_x86_64.h" #include "utils/assembler_test.h" +#include "utils/jni_macro_assembler_test.h" namespace art { @@ -1485,6 +1487,62 @@ TEST_F(AssemblerX86_64Test, SetCC) { DriverFn(&setcc_test_fn, "setcc"); } +TEST_F(AssemblerX86_64Test, MovzxbRegs) { + DriverStr(Repeatrb(&x86_64::X86_64Assembler::movzxb, "movzbl %{reg2}, %{reg1}"), "movzxb"); +} + +TEST_F(AssemblerX86_64Test, MovsxbRegs) { + DriverStr(Repeatrb(&x86_64::X86_64Assembler::movsxb, "movsbl %{reg2}, %{reg1}"), "movsxb"); +} + +TEST_F(AssemblerX86_64Test, Repnescasw) { + GetAssembler()->repne_scasw(); + const char* expected = "repne scasw\n"; + DriverStr(expected, "Repnescasw"); +} + +TEST_F(AssemblerX86_64Test, Repecmpsw) { + GetAssembler()->repe_cmpsw(); + const char* expected = "repe cmpsw\n"; + DriverStr(expected, "Repecmpsw"); +} + +TEST_F(AssemblerX86_64Test, Repecmpsl) { + GetAssembler()->repe_cmpsl(); + const char* expected = "repe cmpsl\n"; + DriverStr(expected, "Repecmpsl"); +} + +TEST_F(AssemblerX86_64Test, Repecmpsq) { + GetAssembler()->repe_cmpsq(); + const char* expected = "repe cmpsq\n"; + DriverStr(expected, "Repecmpsq"); +} + +TEST_F(AssemblerX86_64Test, Cmpb) { + GetAssembler()->cmpb(x86_64::Address(x86_64::CpuRegister(x86_64::RDI), 128), + x86_64::Immediate(0)); + const char* expected = "cmpb $0, 128(%RDI)\n"; + DriverStr(expected, "cmpb"); +} + +class JNIMacroAssemblerX86_64Test : public JNIMacroAssemblerTest<x86_64::X86_64JNIMacroAssembler> { + public: + using Base = JNIMacroAssemblerTest<x86_64::X86_64JNIMacroAssembler>; + + protected: + // Get the typically used name for this architecture, e.g., aarch64, x86-64, ... + std::string GetArchitectureString() OVERRIDE { + return "x86_64"; + } + + std::string GetDisassembleParameters() OVERRIDE { + return " -D -bbinary -mi386:x86-64 -Mx86-64,addr64,data32 --no-show-raw-insn"; + } + + private: +}; + static x86_64::X86_64ManagedRegister ManagedFromCpu(x86_64::Register r) { return x86_64::X86_64ManagedRegister::FromCpuRegister(r); } @@ -1493,8 +1551,8 @@ static x86_64::X86_64ManagedRegister ManagedFromFpu(x86_64::FloatRegister r) { return x86_64::X86_64ManagedRegister::FromXmmRegister(r); } -std::string buildframe_test_fn(AssemblerX86_64Test::Base* assembler_test ATTRIBUTE_UNUSED, - x86_64::X86_64Assembler* assembler) { +std::string buildframe_test_fn(JNIMacroAssemblerX86_64Test::Base* assembler_test ATTRIBUTE_UNUSED, + x86_64::X86_64JNIMacroAssembler* assembler) { // TODO: more interesting spill registers / entry spills. // Two random spill regs. @@ -1536,12 +1594,12 @@ std::string buildframe_test_fn(AssemblerX86_64Test::Base* assembler_test ATTRIBU return str.str(); } -TEST_F(AssemblerX86_64Test, BuildFrame) { +TEST_F(JNIMacroAssemblerX86_64Test, BuildFrame) { DriverFn(&buildframe_test_fn, "BuildFrame"); } -std::string removeframe_test_fn(AssemblerX86_64Test::Base* assembler_test ATTRIBUTE_UNUSED, - x86_64::X86_64Assembler* assembler) { +std::string removeframe_test_fn(JNIMacroAssemblerX86_64Test::Base* assembler_test ATTRIBUTE_UNUSED, + x86_64::X86_64JNIMacroAssembler* assembler) { // TODO: more interesting spill registers / entry spills. // Two random spill regs. @@ -1567,12 +1625,13 @@ std::string removeframe_test_fn(AssemblerX86_64Test::Base* assembler_test ATTRIB return str.str(); } -TEST_F(AssemblerX86_64Test, RemoveFrame) { +TEST_F(JNIMacroAssemblerX86_64Test, RemoveFrame) { DriverFn(&removeframe_test_fn, "RemoveFrame"); } -std::string increaseframe_test_fn(AssemblerX86_64Test::Base* assembler_test ATTRIBUTE_UNUSED, - x86_64::X86_64Assembler* assembler) { +std::string increaseframe_test_fn( + JNIMacroAssemblerX86_64Test::Base* assembler_test ATTRIBUTE_UNUSED, + x86_64::X86_64JNIMacroAssembler* assembler) { assembler->IncreaseFrameSize(0U); assembler->IncreaseFrameSize(kStackAlignment); assembler->IncreaseFrameSize(10 * kStackAlignment); @@ -1586,12 +1645,13 @@ std::string increaseframe_test_fn(AssemblerX86_64Test::Base* assembler_test ATTR return str.str(); } -TEST_F(AssemblerX86_64Test, IncreaseFrame) { +TEST_F(JNIMacroAssemblerX86_64Test, IncreaseFrame) { DriverFn(&increaseframe_test_fn, "IncreaseFrame"); } -std::string decreaseframe_test_fn(AssemblerX86_64Test::Base* assembler_test ATTRIBUTE_UNUSED, - x86_64::X86_64Assembler* assembler) { +std::string decreaseframe_test_fn( + JNIMacroAssemblerX86_64Test::Base* assembler_test ATTRIBUTE_UNUSED, + x86_64::X86_64JNIMacroAssembler* assembler) { assembler->DecreaseFrameSize(0U); assembler->DecreaseFrameSize(kStackAlignment); assembler->DecreaseFrameSize(10 * kStackAlignment); @@ -1605,47 +1665,8 @@ std::string decreaseframe_test_fn(AssemblerX86_64Test::Base* assembler_test ATTR return str.str(); } -TEST_F(AssemblerX86_64Test, DecreaseFrame) { +TEST_F(JNIMacroAssemblerX86_64Test, DecreaseFrame) { DriverFn(&decreaseframe_test_fn, "DecreaseFrame"); } -TEST_F(AssemblerX86_64Test, MovzxbRegs) { - DriverStr(Repeatrb(&x86_64::X86_64Assembler::movzxb, "movzbl %{reg2}, %{reg1}"), "movzxb"); -} - -TEST_F(AssemblerX86_64Test, MovsxbRegs) { - DriverStr(Repeatrb(&x86_64::X86_64Assembler::movsxb, "movsbl %{reg2}, %{reg1}"), "movsxb"); -} - -TEST_F(AssemblerX86_64Test, Repnescasw) { - GetAssembler()->repne_scasw(); - const char* expected = "repne scasw\n"; - DriverStr(expected, "Repnescasw"); -} - -TEST_F(AssemblerX86_64Test, Repecmpsw) { - GetAssembler()->repe_cmpsw(); - const char* expected = "repe cmpsw\n"; - DriverStr(expected, "Repecmpsw"); -} - -TEST_F(AssemblerX86_64Test, Repecmpsl) { - GetAssembler()->repe_cmpsl(); - const char* expected = "repe cmpsl\n"; - DriverStr(expected, "Repecmpsl"); -} - -TEST_F(AssemblerX86_64Test, Repecmpsq) { - GetAssembler()->repe_cmpsq(); - const char* expected = "repe cmpsq\n"; - DriverStr(expected, "Repecmpsq"); -} - -TEST_F(AssemblerX86_64Test, Cmpb) { - GetAssembler()->cmpb(x86_64::Address(x86_64::CpuRegister(x86_64::RDI), 128), - x86_64::Immediate(0)); - const char* expected = "cmpb $0, 128(%RDI)\n"; - DriverStr(expected, "cmpb"); -} - } // namespace art diff --git a/compiler/utils/x86_64/jni_macro_assembler_x86_64.cc b/compiler/utils/x86_64/jni_macro_assembler_x86_64.cc new file mode 100644 index 0000000000..47fb59b1d8 --- /dev/null +++ b/compiler/utils/x86_64/jni_macro_assembler_x86_64.cc @@ -0,0 +1,603 @@ +/* + * Copyright (C) 2016 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "jni_macro_assembler_x86_64.h" + +#include "base/casts.h" +#include "entrypoints/quick/quick_entrypoints.h" +#include "memory_region.h" +#include "thread.h" + +namespace art { +namespace x86_64 { + +static dwarf::Reg DWARFReg(Register reg) { + return dwarf::Reg::X86_64Core(static_cast<int>(reg)); +} +static dwarf::Reg DWARFReg(FloatRegister reg) { + return dwarf::Reg::X86_64Fp(static_cast<int>(reg)); +} + +constexpr size_t kFramePointerSize = 8; + +#define __ asm_. + +void X86_64JNIMacroAssembler::BuildFrame(size_t frame_size, + ManagedRegister method_reg, + ArrayRef<const ManagedRegister> spill_regs, + const ManagedRegisterEntrySpills& entry_spills) { + DCHECK_EQ(CodeSize(), 0U); // Nothing emitted yet. + cfi().SetCurrentCFAOffset(8); // Return address on stack. + CHECK_ALIGNED(frame_size, kStackAlignment); + int gpr_count = 0; + for (int i = spill_regs.size() - 1; i >= 0; --i) { + x86_64::X86_64ManagedRegister spill = spill_regs[i].AsX86_64(); + if (spill.IsCpuRegister()) { + __ pushq(spill.AsCpuRegister()); + gpr_count++; + cfi().AdjustCFAOffset(kFramePointerSize); + cfi().RelOffset(DWARFReg(spill.AsCpuRegister().AsRegister()), 0); + } + } + // return address then method on stack. + int64_t rest_of_frame = static_cast<int64_t>(frame_size) + - (gpr_count * kFramePointerSize) + - kFramePointerSize /*return address*/; + __ subq(CpuRegister(RSP), Immediate(rest_of_frame)); + cfi().AdjustCFAOffset(rest_of_frame); + + // spill xmms + int64_t offset = rest_of_frame; + for (int i = spill_regs.size() - 1; i >= 0; --i) { + x86_64::X86_64ManagedRegister spill = spill_regs[i].AsX86_64(); + if (spill.IsXmmRegister()) { + offset -= sizeof(double); + __ movsd(Address(CpuRegister(RSP), offset), spill.AsXmmRegister()); + cfi().RelOffset(DWARFReg(spill.AsXmmRegister().AsFloatRegister()), offset); + } + } + + static_assert(static_cast<size_t>(kX86_64PointerSize) == kFramePointerSize, + "Unexpected frame pointer size."); + + __ movq(Address(CpuRegister(RSP), 0), method_reg.AsX86_64().AsCpuRegister()); + + for (size_t i = 0; i < entry_spills.size(); ++i) { + ManagedRegisterSpill spill = entry_spills.at(i); + if (spill.AsX86_64().IsCpuRegister()) { + if (spill.getSize() == 8) { + __ movq(Address(CpuRegister(RSP), frame_size + spill.getSpillOffset()), + spill.AsX86_64().AsCpuRegister()); + } else { + CHECK_EQ(spill.getSize(), 4); + __ movl(Address(CpuRegister(RSP), frame_size + spill.getSpillOffset()), + spill.AsX86_64().AsCpuRegister()); + } + } else { + if (spill.getSize() == 8) { + __ movsd(Address(CpuRegister(RSP), frame_size + spill.getSpillOffset()), + spill.AsX86_64().AsXmmRegister()); + } else { + CHECK_EQ(spill.getSize(), 4); + __ movss(Address(CpuRegister(RSP), frame_size + spill.getSpillOffset()), + spill.AsX86_64().AsXmmRegister()); + } + } + } +} + +void X86_64JNIMacroAssembler::RemoveFrame(size_t frame_size, + ArrayRef<const ManagedRegister> spill_regs) { + CHECK_ALIGNED(frame_size, kStackAlignment); + cfi().RememberState(); + int gpr_count = 0; + // unspill xmms + int64_t offset = static_cast<int64_t>(frame_size) + - (spill_regs.size() * kFramePointerSize) + - 2 * kFramePointerSize; + for (size_t i = 0; i < spill_regs.size(); ++i) { + x86_64::X86_64ManagedRegister spill = spill_regs[i].AsX86_64(); + if (spill.IsXmmRegister()) { + offset += sizeof(double); + __ movsd(spill.AsXmmRegister(), Address(CpuRegister(RSP), offset)); + cfi().Restore(DWARFReg(spill.AsXmmRegister().AsFloatRegister())); + } else { + gpr_count++; + } + } + int adjust = static_cast<int>(frame_size) - (gpr_count * kFramePointerSize) - kFramePointerSize; + __ addq(CpuRegister(RSP), Immediate(adjust)); + cfi().AdjustCFAOffset(-adjust); + for (size_t i = 0; i < spill_regs.size(); ++i) { + x86_64::X86_64ManagedRegister spill = spill_regs[i].AsX86_64(); + if (spill.IsCpuRegister()) { + __ popq(spill.AsCpuRegister()); + cfi().AdjustCFAOffset(-static_cast<int>(kFramePointerSize)); + cfi().Restore(DWARFReg(spill.AsCpuRegister().AsRegister())); + } + } + __ ret(); + // The CFI should be restored for any code that follows the exit block. + cfi().RestoreState(); + cfi().DefCFAOffset(frame_size); +} + +void X86_64JNIMacroAssembler::IncreaseFrameSize(size_t adjust) { + CHECK_ALIGNED(adjust, kStackAlignment); + __ addq(CpuRegister(RSP), Immediate(-static_cast<int64_t>(adjust))); + cfi().AdjustCFAOffset(adjust); +} + +static void DecreaseFrameSizeImpl(size_t adjust, X86_64Assembler* assembler) { + CHECK_ALIGNED(adjust, kStackAlignment); + assembler->addq(CpuRegister(RSP), Immediate(adjust)); + assembler->cfi().AdjustCFAOffset(-adjust); +} + +void X86_64JNIMacroAssembler::DecreaseFrameSize(size_t adjust) { + DecreaseFrameSizeImpl(adjust, &asm_); +} + +void X86_64JNIMacroAssembler::Store(FrameOffset offs, ManagedRegister msrc, size_t size) { + X86_64ManagedRegister src = msrc.AsX86_64(); + if (src.IsNoRegister()) { + CHECK_EQ(0u, size); + } else if (src.IsCpuRegister()) { + if (size == 4) { + CHECK_EQ(4u, size); + __ movl(Address(CpuRegister(RSP), offs), src.AsCpuRegister()); + } else { + CHECK_EQ(8u, size); + __ movq(Address(CpuRegister(RSP), offs), src.AsCpuRegister()); + } + } else if (src.IsRegisterPair()) { + CHECK_EQ(0u, size); + __ movq(Address(CpuRegister(RSP), offs), src.AsRegisterPairLow()); + __ movq(Address(CpuRegister(RSP), FrameOffset(offs.Int32Value()+4)), + src.AsRegisterPairHigh()); + } else if (src.IsX87Register()) { + if (size == 4) { + __ fstps(Address(CpuRegister(RSP), offs)); + } else { + __ fstpl(Address(CpuRegister(RSP), offs)); + } + } else { + CHECK(src.IsXmmRegister()); + if (size == 4) { + __ movss(Address(CpuRegister(RSP), offs), src.AsXmmRegister()); + } else { + __ movsd(Address(CpuRegister(RSP), offs), src.AsXmmRegister()); + } + } +} + +void X86_64JNIMacroAssembler::StoreRef(FrameOffset dest, ManagedRegister msrc) { + X86_64ManagedRegister src = msrc.AsX86_64(); + CHECK(src.IsCpuRegister()); + __ movl(Address(CpuRegister(RSP), dest), src.AsCpuRegister()); +} + +void X86_64JNIMacroAssembler::StoreRawPtr(FrameOffset dest, ManagedRegister msrc) { + X86_64ManagedRegister src = msrc.AsX86_64(); + CHECK(src.IsCpuRegister()); + __ movq(Address(CpuRegister(RSP), dest), src.AsCpuRegister()); +} + +void X86_64JNIMacroAssembler::StoreImmediateToFrame(FrameOffset dest, + uint32_t imm, + ManagedRegister) { + __ movl(Address(CpuRegister(RSP), dest), Immediate(imm)); // TODO(64) movq? +} + +void X86_64JNIMacroAssembler::StoreStackOffsetToThread(ThreadOffset64 thr_offs, + FrameOffset fr_offs, + ManagedRegister mscratch) { + X86_64ManagedRegister scratch = mscratch.AsX86_64(); + CHECK(scratch.IsCpuRegister()); + __ leaq(scratch.AsCpuRegister(), Address(CpuRegister(RSP), fr_offs)); + __ gs()->movq(Address::Absolute(thr_offs, true), scratch.AsCpuRegister()); +} + +void X86_64JNIMacroAssembler::StoreStackPointerToThread(ThreadOffset64 thr_offs) { + __ gs()->movq(Address::Absolute(thr_offs, true), CpuRegister(RSP)); +} + +void X86_64JNIMacroAssembler::StoreSpanning(FrameOffset /*dst*/, + ManagedRegister /*src*/, + FrameOffset /*in_off*/, + ManagedRegister /*scratch*/) { + UNIMPLEMENTED(FATAL); // this case only currently exists for ARM +} + +void X86_64JNIMacroAssembler::Load(ManagedRegister mdest, FrameOffset src, size_t size) { + X86_64ManagedRegister dest = mdest.AsX86_64(); + if (dest.IsNoRegister()) { + CHECK_EQ(0u, size); + } else if (dest.IsCpuRegister()) { + if (size == 4) { + CHECK_EQ(4u, size); + __ movl(dest.AsCpuRegister(), Address(CpuRegister(RSP), src)); + } else { + CHECK_EQ(8u, size); + __ movq(dest.AsCpuRegister(), Address(CpuRegister(RSP), src)); + } + } else if (dest.IsRegisterPair()) { + CHECK_EQ(0u, size); + __ movq(dest.AsRegisterPairLow(), Address(CpuRegister(RSP), src)); + __ movq(dest.AsRegisterPairHigh(), Address(CpuRegister(RSP), FrameOffset(src.Int32Value()+4))); + } else if (dest.IsX87Register()) { + if (size == 4) { + __ flds(Address(CpuRegister(RSP), src)); + } else { + __ fldl(Address(CpuRegister(RSP), src)); + } + } else { + CHECK(dest.IsXmmRegister()); + if (size == 4) { + __ movss(dest.AsXmmRegister(), Address(CpuRegister(RSP), src)); + } else { + __ movsd(dest.AsXmmRegister(), Address(CpuRegister(RSP), src)); + } + } +} + +void X86_64JNIMacroAssembler::LoadFromThread(ManagedRegister mdest, + ThreadOffset64 src, size_t size) { + X86_64ManagedRegister dest = mdest.AsX86_64(); + if (dest.IsNoRegister()) { + CHECK_EQ(0u, size); + } else if (dest.IsCpuRegister()) { + CHECK_EQ(4u, size); + __ gs()->movl(dest.AsCpuRegister(), Address::Absolute(src, true)); + } else if (dest.IsRegisterPair()) { + CHECK_EQ(8u, size); + __ gs()->movq(dest.AsRegisterPairLow(), Address::Absolute(src, true)); + } else if (dest.IsX87Register()) { + if (size == 4) { + __ gs()->flds(Address::Absolute(src, true)); + } else { + __ gs()->fldl(Address::Absolute(src, true)); + } + } else { + CHECK(dest.IsXmmRegister()); + if (size == 4) { + __ gs()->movss(dest.AsXmmRegister(), Address::Absolute(src, true)); + } else { + __ gs()->movsd(dest.AsXmmRegister(), Address::Absolute(src, true)); + } + } +} + +void X86_64JNIMacroAssembler::LoadRef(ManagedRegister mdest, FrameOffset src) { + X86_64ManagedRegister dest = mdest.AsX86_64(); + CHECK(dest.IsCpuRegister()); + __ movq(dest.AsCpuRegister(), Address(CpuRegister(RSP), src)); +} + +void X86_64JNIMacroAssembler::LoadRef(ManagedRegister mdest, + ManagedRegister base, + MemberOffset offs, + bool unpoison_reference) { + X86_64ManagedRegister dest = mdest.AsX86_64(); + CHECK(dest.IsCpuRegister() && dest.IsCpuRegister()); + __ movl(dest.AsCpuRegister(), Address(base.AsX86_64().AsCpuRegister(), offs)); + if (unpoison_reference) { + __ MaybeUnpoisonHeapReference(dest.AsCpuRegister()); + } +} + +void X86_64JNIMacroAssembler::LoadRawPtr(ManagedRegister mdest, ManagedRegister base, Offset offs) { + X86_64ManagedRegister dest = mdest.AsX86_64(); + CHECK(dest.IsCpuRegister() && dest.IsCpuRegister()); + __ movq(dest.AsCpuRegister(), Address(base.AsX86_64().AsCpuRegister(), offs)); +} + +void X86_64JNIMacroAssembler::LoadRawPtrFromThread(ManagedRegister mdest, ThreadOffset64 offs) { + X86_64ManagedRegister dest = mdest.AsX86_64(); + CHECK(dest.IsCpuRegister()); + __ gs()->movq(dest.AsCpuRegister(), Address::Absolute(offs, true)); +} + +void X86_64JNIMacroAssembler::SignExtend(ManagedRegister mreg, size_t size) { + X86_64ManagedRegister reg = mreg.AsX86_64(); + CHECK(size == 1 || size == 2) << size; + CHECK(reg.IsCpuRegister()) << reg; + if (size == 1) { + __ movsxb(reg.AsCpuRegister(), reg.AsCpuRegister()); + } else { + __ movsxw(reg.AsCpuRegister(), reg.AsCpuRegister()); + } +} + +void X86_64JNIMacroAssembler::ZeroExtend(ManagedRegister mreg, size_t size) { + X86_64ManagedRegister reg = mreg.AsX86_64(); + CHECK(size == 1 || size == 2) << size; + CHECK(reg.IsCpuRegister()) << reg; + if (size == 1) { + __ movzxb(reg.AsCpuRegister(), reg.AsCpuRegister()); + } else { + __ movzxw(reg.AsCpuRegister(), reg.AsCpuRegister()); + } +} + +void X86_64JNIMacroAssembler::Move(ManagedRegister mdest, ManagedRegister msrc, size_t size) { + X86_64ManagedRegister dest = mdest.AsX86_64(); + X86_64ManagedRegister src = msrc.AsX86_64(); + if (!dest.Equals(src)) { + if (dest.IsCpuRegister() && src.IsCpuRegister()) { + __ movq(dest.AsCpuRegister(), src.AsCpuRegister()); + } else if (src.IsX87Register() && dest.IsXmmRegister()) { + // Pass via stack and pop X87 register + __ subl(CpuRegister(RSP), Immediate(16)); + if (size == 4) { + CHECK_EQ(src.AsX87Register(), ST0); + __ fstps(Address(CpuRegister(RSP), 0)); + __ movss(dest.AsXmmRegister(), Address(CpuRegister(RSP), 0)); + } else { + CHECK_EQ(src.AsX87Register(), ST0); + __ fstpl(Address(CpuRegister(RSP), 0)); + __ movsd(dest.AsXmmRegister(), Address(CpuRegister(RSP), 0)); + } + __ addq(CpuRegister(RSP), Immediate(16)); + } else { + // TODO: x87, SSE + UNIMPLEMENTED(FATAL) << ": Move " << dest << ", " << src; + } + } +} + +void X86_64JNIMacroAssembler::CopyRef(FrameOffset dest, FrameOffset src, ManagedRegister mscratch) { + X86_64ManagedRegister scratch = mscratch.AsX86_64(); + CHECK(scratch.IsCpuRegister()); + __ movl(scratch.AsCpuRegister(), Address(CpuRegister(RSP), src)); + __ movl(Address(CpuRegister(RSP), dest), scratch.AsCpuRegister()); +} + +void X86_64JNIMacroAssembler::CopyRawPtrFromThread(FrameOffset fr_offs, + ThreadOffset64 thr_offs, + ManagedRegister mscratch) { + X86_64ManagedRegister scratch = mscratch.AsX86_64(); + CHECK(scratch.IsCpuRegister()); + __ gs()->movq(scratch.AsCpuRegister(), Address::Absolute(thr_offs, true)); + Store(fr_offs, scratch, 8); +} + +void X86_64JNIMacroAssembler::CopyRawPtrToThread(ThreadOffset64 thr_offs, + FrameOffset fr_offs, + ManagedRegister mscratch) { + X86_64ManagedRegister scratch = mscratch.AsX86_64(); + CHECK(scratch.IsCpuRegister()); + Load(scratch, fr_offs, 8); + __ gs()->movq(Address::Absolute(thr_offs, true), scratch.AsCpuRegister()); +} + +void X86_64JNIMacroAssembler::Copy(FrameOffset dest, + FrameOffset src, + ManagedRegister mscratch, + size_t size) { + X86_64ManagedRegister scratch = mscratch.AsX86_64(); + if (scratch.IsCpuRegister() && size == 8) { + Load(scratch, src, 4); + Store(dest, scratch, 4); + Load(scratch, FrameOffset(src.Int32Value() + 4), 4); + Store(FrameOffset(dest.Int32Value() + 4), scratch, 4); + } else { + Load(scratch, src, size); + Store(dest, scratch, size); + } +} + +void X86_64JNIMacroAssembler::Copy(FrameOffset /*dst*/, + ManagedRegister /*src_base*/, + Offset /*src_offset*/, + ManagedRegister /*scratch*/, + size_t /*size*/) { + UNIMPLEMENTED(FATAL); +} + +void X86_64JNIMacroAssembler::Copy(ManagedRegister dest_base, + Offset dest_offset, + FrameOffset src, + ManagedRegister scratch, + size_t size) { + CHECK(scratch.IsNoRegister()); + CHECK_EQ(size, 4u); + __ pushq(Address(CpuRegister(RSP), src)); + __ popq(Address(dest_base.AsX86_64().AsCpuRegister(), dest_offset)); +} + +void X86_64JNIMacroAssembler::Copy(FrameOffset dest, + FrameOffset src_base, + Offset src_offset, + ManagedRegister mscratch, + size_t size) { + CpuRegister scratch = mscratch.AsX86_64().AsCpuRegister(); + CHECK_EQ(size, 4u); + __ movq(scratch, Address(CpuRegister(RSP), src_base)); + __ movq(scratch, Address(scratch, src_offset)); + __ movq(Address(CpuRegister(RSP), dest), scratch); +} + +void X86_64JNIMacroAssembler::Copy(ManagedRegister dest, + Offset dest_offset, + ManagedRegister src, + Offset src_offset, + ManagedRegister scratch, + size_t size) { + CHECK_EQ(size, 4u); + CHECK(scratch.IsNoRegister()); + __ pushq(Address(src.AsX86_64().AsCpuRegister(), src_offset)); + __ popq(Address(dest.AsX86_64().AsCpuRegister(), dest_offset)); +} + +void X86_64JNIMacroAssembler::Copy(FrameOffset dest, + Offset dest_offset, + FrameOffset src, + Offset src_offset, + ManagedRegister mscratch, + size_t size) { + CpuRegister scratch = mscratch.AsX86_64().AsCpuRegister(); + CHECK_EQ(size, 4u); + CHECK_EQ(dest.Int32Value(), src.Int32Value()); + __ movq(scratch, Address(CpuRegister(RSP), src)); + __ pushq(Address(scratch, src_offset)); + __ popq(Address(scratch, dest_offset)); +} + +void X86_64JNIMacroAssembler::MemoryBarrier(ManagedRegister) { + __ mfence(); +} + +void X86_64JNIMacroAssembler::CreateHandleScopeEntry(ManagedRegister mout_reg, + FrameOffset handle_scope_offset, + ManagedRegister min_reg, + bool null_allowed) { + X86_64ManagedRegister out_reg = mout_reg.AsX86_64(); + X86_64ManagedRegister in_reg = min_reg.AsX86_64(); + if (in_reg.IsNoRegister()) { // TODO(64): && null_allowed + // Use out_reg as indicator of null. + in_reg = out_reg; + // TODO: movzwl + __ movl(in_reg.AsCpuRegister(), Address(CpuRegister(RSP), handle_scope_offset)); + } + CHECK(in_reg.IsCpuRegister()); + CHECK(out_reg.IsCpuRegister()); + VerifyObject(in_reg, null_allowed); + if (null_allowed) { + Label null_arg; + if (!out_reg.Equals(in_reg)) { + __ xorl(out_reg.AsCpuRegister(), out_reg.AsCpuRegister()); + } + __ testl(in_reg.AsCpuRegister(), in_reg.AsCpuRegister()); + __ j(kZero, &null_arg); + __ leaq(out_reg.AsCpuRegister(), Address(CpuRegister(RSP), handle_scope_offset)); + __ Bind(&null_arg); + } else { + __ leaq(out_reg.AsCpuRegister(), Address(CpuRegister(RSP), handle_scope_offset)); + } +} + +void X86_64JNIMacroAssembler::CreateHandleScopeEntry(FrameOffset out_off, + FrameOffset handle_scope_offset, + ManagedRegister mscratch, + bool null_allowed) { + X86_64ManagedRegister scratch = mscratch.AsX86_64(); + CHECK(scratch.IsCpuRegister()); + if (null_allowed) { + Label null_arg; + __ movl(scratch.AsCpuRegister(), Address(CpuRegister(RSP), handle_scope_offset)); + __ testl(scratch.AsCpuRegister(), scratch.AsCpuRegister()); + __ j(kZero, &null_arg); + __ leaq(scratch.AsCpuRegister(), Address(CpuRegister(RSP), handle_scope_offset)); + __ Bind(&null_arg); + } else { + __ leaq(scratch.AsCpuRegister(), Address(CpuRegister(RSP), handle_scope_offset)); + } + Store(out_off, scratch, 8); +} + +// Given a handle scope entry, load the associated reference. +void X86_64JNIMacroAssembler::LoadReferenceFromHandleScope(ManagedRegister mout_reg, + ManagedRegister min_reg) { + X86_64ManagedRegister out_reg = mout_reg.AsX86_64(); + X86_64ManagedRegister in_reg = min_reg.AsX86_64(); + CHECK(out_reg.IsCpuRegister()); + CHECK(in_reg.IsCpuRegister()); + Label null_arg; + if (!out_reg.Equals(in_reg)) { + __ xorl(out_reg.AsCpuRegister(), out_reg.AsCpuRegister()); + } + __ testl(in_reg.AsCpuRegister(), in_reg.AsCpuRegister()); + __ j(kZero, &null_arg); + __ movq(out_reg.AsCpuRegister(), Address(in_reg.AsCpuRegister(), 0)); + __ Bind(&null_arg); +} + +void X86_64JNIMacroAssembler::VerifyObject(ManagedRegister /*src*/, bool /*could_be_null*/) { + // TODO: not validating references +} + +void X86_64JNIMacroAssembler::VerifyObject(FrameOffset /*src*/, bool /*could_be_null*/) { + // TODO: not validating references +} + +void X86_64JNIMacroAssembler::Call(ManagedRegister mbase, Offset offset, ManagedRegister) { + X86_64ManagedRegister base = mbase.AsX86_64(); + CHECK(base.IsCpuRegister()); + __ call(Address(base.AsCpuRegister(), offset.Int32Value())); + // TODO: place reference map on call +} + +void X86_64JNIMacroAssembler::Call(FrameOffset base, Offset offset, ManagedRegister mscratch) { + CpuRegister scratch = mscratch.AsX86_64().AsCpuRegister(); + __ movq(scratch, Address(CpuRegister(RSP), base)); + __ call(Address(scratch, offset)); +} + +void X86_64JNIMacroAssembler::CallFromThread(ThreadOffset64 offset, ManagedRegister /*mscratch*/) { + __ gs()->call(Address::Absolute(offset, true)); +} + +void X86_64JNIMacroAssembler::GetCurrentThread(ManagedRegister tr) { + __ gs()->movq(tr.AsX86_64().AsCpuRegister(), + Address::Absolute(Thread::SelfOffset<kX86_64PointerSize>(), true)); +} + +void X86_64JNIMacroAssembler::GetCurrentThread(FrameOffset offset, ManagedRegister mscratch) { + X86_64ManagedRegister scratch = mscratch.AsX86_64(); + __ gs()->movq(scratch.AsCpuRegister(), + Address::Absolute(Thread::SelfOffset<kX86_64PointerSize>(), true)); + __ movq(Address(CpuRegister(RSP), offset), scratch.AsCpuRegister()); +} + +// Slowpath entered when Thread::Current()->_exception is non-null +class X86_64ExceptionSlowPath FINAL : public SlowPath { + public: + explicit X86_64ExceptionSlowPath(size_t stack_adjust) : stack_adjust_(stack_adjust) {} + virtual void Emit(Assembler *sp_asm) OVERRIDE; + private: + const size_t stack_adjust_; +}; + +void X86_64JNIMacroAssembler::ExceptionPoll(ManagedRegister /*scratch*/, size_t stack_adjust) { + X86_64ExceptionSlowPath* slow = new (__ GetArena()) X86_64ExceptionSlowPath(stack_adjust); + __ GetBuffer()->EnqueueSlowPath(slow); + __ gs()->cmpl(Address::Absolute(Thread::ExceptionOffset<kX86_64PointerSize>(), true), Immediate(0)); + __ j(kNotEqual, slow->Entry()); +} + +#undef __ + +void X86_64ExceptionSlowPath::Emit(Assembler *sasm) { + X86_64Assembler* sp_asm = down_cast<X86_64Assembler*>(sasm); +#define __ sp_asm-> + __ Bind(&entry_); + // Note: the return value is dead + if (stack_adjust_ != 0) { // Fix up the frame. + DecreaseFrameSizeImpl(stack_adjust_, sp_asm); + } + // Pass exception as argument in RDI + __ gs()->movq(CpuRegister(RDI), + Address::Absolute(Thread::ExceptionOffset<kX86_64PointerSize>(), true)); + __ gs()->call( + Address::Absolute(QUICK_ENTRYPOINT_OFFSET(kX86_64PointerSize, pDeliverException), true)); + // this call should never return + __ int3(); +#undef __ +} + +} // namespace x86_64 +} // namespace art diff --git a/compiler/utils/x86_64/jni_macro_assembler_x86_64.h b/compiler/utils/x86_64/jni_macro_assembler_x86_64.h new file mode 100644 index 0000000000..cc4e57c999 --- /dev/null +++ b/compiler/utils/x86_64/jni_macro_assembler_x86_64.h @@ -0,0 +1,190 @@ +/* + * Copyright (C) 2016 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ART_COMPILER_UTILS_X86_64_JNI_MACRO_ASSEMBLER_X86_64_H_ +#define ART_COMPILER_UTILS_X86_64_JNI_MACRO_ASSEMBLER_X86_64_H_ + +#include <vector> + +#include "assembler_x86_64.h" +#include "base/arena_containers.h" +#include "base/enums.h" +#include "base/macros.h" +#include "offsets.h" +#include "utils/array_ref.h" +#include "utils/assembler.h" +#include "utils/jni_macro_assembler.h" + +namespace art { +namespace x86_64 { + +class X86_64JNIMacroAssembler FINAL : public JNIMacroAssemblerFwd<X86_64Assembler, + PointerSize::k64> { + public: + explicit X86_64JNIMacroAssembler(ArenaAllocator* arena) + : JNIMacroAssemblerFwd<X86_64Assembler, PointerSize::k64>(arena) {} + virtual ~X86_64JNIMacroAssembler() {} + + // + // Overridden common assembler high-level functionality + // + + // Emit code that will create an activation on the stack + void BuildFrame(size_t frame_size, + ManagedRegister method_reg, + ArrayRef<const ManagedRegister> callee_save_regs, + const ManagedRegisterEntrySpills& entry_spills) OVERRIDE; + + // Emit code that will remove an activation from the stack + void RemoveFrame(size_t frame_size, ArrayRef<const ManagedRegister> callee_save_regs) + OVERRIDE; + + void IncreaseFrameSize(size_t adjust) OVERRIDE; + void DecreaseFrameSize(size_t adjust) OVERRIDE; + + // Store routines + void Store(FrameOffset offs, ManagedRegister src, size_t size) OVERRIDE; + void StoreRef(FrameOffset dest, ManagedRegister src) OVERRIDE; + void StoreRawPtr(FrameOffset dest, ManagedRegister src) OVERRIDE; + + void StoreImmediateToFrame(FrameOffset dest, uint32_t imm, ManagedRegister scratch) OVERRIDE; + + void StoreStackOffsetToThread(ThreadOffset64 thr_offs, + FrameOffset fr_offs, + ManagedRegister scratch) OVERRIDE; + + void StoreStackPointerToThread(ThreadOffset64 thr_offs) OVERRIDE; + + void StoreSpanning(FrameOffset dest, + ManagedRegister src, + FrameOffset in_off, + ManagedRegister scratch) OVERRIDE; + + // Load routines + void Load(ManagedRegister dest, FrameOffset src, size_t size) OVERRIDE; + + void LoadFromThread(ManagedRegister dest, ThreadOffset64 src, size_t size) OVERRIDE; + + void LoadRef(ManagedRegister dest, FrameOffset src) OVERRIDE; + + void LoadRef(ManagedRegister dest, + ManagedRegister base, + MemberOffset offs, + bool unpoison_reference) OVERRIDE; + + void LoadRawPtr(ManagedRegister dest, ManagedRegister base, Offset offs) OVERRIDE; + + void LoadRawPtrFromThread(ManagedRegister dest, ThreadOffset64 offs) OVERRIDE; + + // Copying routines + void Move(ManagedRegister dest, ManagedRegister src, size_t size); + + void CopyRawPtrFromThread(FrameOffset fr_offs, + ThreadOffset64 thr_offs, + ManagedRegister scratch) OVERRIDE; + + void CopyRawPtrToThread(ThreadOffset64 thr_offs, FrameOffset fr_offs, ManagedRegister scratch) + OVERRIDE; + + void CopyRef(FrameOffset dest, FrameOffset src, ManagedRegister scratch) OVERRIDE; + + void Copy(FrameOffset dest, FrameOffset src, ManagedRegister scratch, size_t size) OVERRIDE; + + void Copy(FrameOffset dest, + ManagedRegister src_base, + Offset src_offset, + ManagedRegister scratch, + size_t size) OVERRIDE; + + void Copy(ManagedRegister dest_base, + Offset dest_offset, + FrameOffset src, + ManagedRegister scratch, + size_t size) OVERRIDE; + + void Copy(FrameOffset dest, + FrameOffset src_base, + Offset src_offset, + ManagedRegister scratch, + size_t size) OVERRIDE; + + void Copy(ManagedRegister dest, + Offset dest_offset, + ManagedRegister src, + Offset src_offset, + ManagedRegister scratch, + size_t size) OVERRIDE; + + void Copy(FrameOffset dest, + Offset dest_offset, + FrameOffset src, + Offset src_offset, + ManagedRegister scratch, + size_t size) OVERRIDE; + + void MemoryBarrier(ManagedRegister) OVERRIDE; + + // Sign extension + void SignExtend(ManagedRegister mreg, size_t size) OVERRIDE; + + // Zero extension + void ZeroExtend(ManagedRegister mreg, size_t size) OVERRIDE; + + // Exploit fast access in managed code to Thread::Current() + void GetCurrentThread(ManagedRegister tr) OVERRIDE; + void GetCurrentThread(FrameOffset dest_offset, ManagedRegister scratch) OVERRIDE; + + // Set up out_reg to hold a Object** into the handle scope, or to be null if the + // value is null and null_allowed. in_reg holds a possibly stale reference + // that can be used to avoid loading the handle scope entry to see if the value is + // null. + void CreateHandleScopeEntry(ManagedRegister out_reg, + FrameOffset handlescope_offset, + ManagedRegister in_reg, + bool null_allowed) OVERRIDE; + + // Set up out_off to hold a Object** into the handle scope, or to be null if the + // value is null and null_allowed. + void CreateHandleScopeEntry(FrameOffset out_off, + FrameOffset handlescope_offset, + ManagedRegister scratch, + bool null_allowed) OVERRIDE; + + // src holds a handle scope entry (Object**) load this into dst + virtual void LoadReferenceFromHandleScope(ManagedRegister dst, ManagedRegister src) OVERRIDE; + + // Heap::VerifyObject on src. In some cases (such as a reference to this) we + // know that src may not be null. + void VerifyObject(ManagedRegister src, bool could_be_null) OVERRIDE; + void VerifyObject(FrameOffset src, bool could_be_null) OVERRIDE; + + // Call to address held at [base+offset] + void Call(ManagedRegister base, Offset offset, ManagedRegister scratch) OVERRIDE; + void Call(FrameOffset base, Offset offset, ManagedRegister scratch) OVERRIDE; + void CallFromThread(ThreadOffset64 offset, ManagedRegister scratch) OVERRIDE; + + // Generate code to check if Thread::Current()->exception_ is non-null + // and branch to a ExceptionSlowPath if it is. + void ExceptionPoll(ManagedRegister scratch, size_t stack_adjust) OVERRIDE; + + private: + DISALLOW_COPY_AND_ASSIGN(X86_64JNIMacroAssembler); +}; + +} // namespace x86_64 +} // namespace art + +#endif // ART_COMPILER_UTILS_X86_64_JNI_MACRO_ASSEMBLER_X86_64_H_ 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/runtime/Android.mk b/runtime/Android.mk index 9c813e2c66..7a37f606eb 100644 --- a/runtime/Android.mk +++ b/runtime/Android.mk @@ -132,6 +132,7 @@ LIBART_COMMON_SRC_FILES := \ mirror/throwable.cc \ monitor.cc \ native_bridge_art_interface.cc \ + native_stack_dump.cc \ native/dalvik_system_DexFile.cc \ native/dalvik_system_VMDebug.cc \ native/dalvik_system_VMRuntime.cc \ diff --git a/runtime/arch/arm64/quick_entrypoints_arm64.S b/runtime/arch/arm64/quick_entrypoints_arm64.S index c8181ba920..415bb71ba0 100644 --- a/runtime/arch/arm64/quick_entrypoints_arm64.S +++ b/runtime/arch/arm64/quick_entrypoints_arm64.S @@ -1788,20 +1788,7 @@ END art_quick_set64_static ONE_ARG_DOWNCALL art_quick_resolve_string, artResolveStringFromCode, RETURN_IF_RESULT_IS_NON_ZERO_OR_DELIVER // Generate the allocation entrypoints for each allocator. -GENERATE_ALLOC_ENTRYPOINTS_FOR_NON_REGION_ALLOCATORS -// Comment out allocators that have arm64 specific asm. -// GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT(_region_tlab, RegionTLAB) implemented in asm -// GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_RESOLVED(_region_tlab, RegionTLAB) -// GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_INITIALIZED(_region_tlab, RegionTLAB) -GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_WITH_ACCESS_CHECK(_region_tlab, RegionTLAB) -// GENERATE_ALLOC_ENTRYPOINTS_ALLOC_ARRAY(_region_tlab, RegionTLAB) implemented in asm -// GENERATE_ALLOC_ENTRYPOINTS_ALLOC_ARRAY_RESOLVED(_region_tlab, RegionTLAB) -GENERATE_ALLOC_ENTRYPOINTS_ALLOC_ARRAY_WITH_ACCESS_CHECK(_region_tlab, RegionTLAB) -GENERATE_ALLOC_ENTRYPOINTS_CHECK_AND_ALLOC_ARRAY(_region_tlab, RegionTLAB) -GENERATE_ALLOC_ENTRYPOINTS_CHECK_AND_ALLOC_ARRAY_WITH_ACCESS_CHECK(_region_tlab, RegionTLAB) -GENERATE_ALLOC_ENTRYPOINTS_ALLOC_STRING_FROM_BYTES(_region_tlab, RegionTLAB) -GENERATE_ALLOC_ENTRYPOINTS_ALLOC_STRING_FROM_CHARS(_region_tlab, RegionTLAB) -GENERATE_ALLOC_ENTRYPOINTS_ALLOC_STRING_FROM_STRING(_region_tlab, RegionTLAB) +GENERATE_ALLOC_ENTRYPOINTS_FOR_EACH_ALLOCATOR // A hand-written override for GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT(_rosalloc, RosAlloc). ENTRY art_quick_alloc_object_rosalloc @@ -1908,63 +1895,6 @@ ENTRY art_quick_alloc_object_rosalloc RETURN_IF_RESULT_IS_NON_ZERO_OR_DELIVER END art_quick_alloc_object_rosalloc - -// The common fast path code for art_quick_alloc_array_region_tlab. -.macro ALLOC_ARRAY_TLAB_FAST_PATH slowPathLabel, xClass, wClass, xCount, wCount, xTemp0, wTemp0, xTemp1, wTemp1, xTemp2, wTemp2 - // Check null class - cbz \wClass, \slowPathLabel - ALLOC_ARRAY_TLAB_FAST_PATH_RESOLVED \slowPathLabel, \xClass, \wClass, \xCount, \wCount, \xTemp0, \wTemp0, \xTemp1, \wTemp1, \xTemp2, \wTemp2 -.endm - -// The common fast path code for art_quick_alloc_array_region_tlab. -.macro ALLOC_ARRAY_TLAB_FAST_PATH_RESOLVED slowPathLabel, xClass, wClass, xCount, wCount, xTemp0, wTemp0, xTemp1, wTemp1, xTemp2, wTemp2 - // Arrays are never finalizable, no need to check. - ldr \wTemp0, [\xClass, #MIRROR_CLASS_COMPONENT_TYPE_OFFSET] // Load component type - ldr \wTemp0, [\xTemp0, #MIRROR_CLASS_OBJECT_PRIMITIVE_TYPE_OFFSET] - lsr \xTemp0, \xTemp0, #PRIMITIVE_TYPE_SIZE_SHIFT_SHIFT // Component size shift is in high 16 - // bits. - lsl \xTemp1, \xCount, \xTemp0 // Calculate data size - // Add array data offset and alignment. - add \xTemp1, \xTemp1, #(MIRROR_INT_ARRAY_DATA_OFFSET + OBJECT_ALIGNMENT_MASK) - add \xTemp0, \xTemp0, #1 // Add 4 to the length only if the - // component size shift is 3 - // (for 64 bit alignment). - and \xTemp0, \xTemp0, #4 - add \xTemp1, \xTemp1, \xTemp0 - ldr \xTemp0, [xSELF, #THREAD_LOCAL_POS_OFFSET] // Check tlab for space, note that - // we use (end - begin) to handle - // negative size arrays. - ldr \xTemp2, [xSELF, #THREAD_LOCAL_END_OFFSET] - sub \xTemp2, \xTemp2, \xTemp0 - cmp \xTemp1, \xTemp2 - bhi \slowPathLabel - - // "Point of no slow path". Won't go to the slow path from here on. OK to clobber x0 and x1. - // Round up the object size by the - // object alignment. (addr + 7) & ~7. - and \xTemp1, \xTemp1, #OBJECT_ALIGNMENT_MASK_TOGGLED - // Move old thread_local_pos to x0 - // for the return value. - mov x0, \xTemp0 - add \xTemp0, \xTemp0, \xTemp1 - str \xTemp0, [xSELF, #THREAD_LOCAL_POS_OFFSET] // Store new thread_local_pos. - ldr \xTemp0, [xSELF, #THREAD_LOCAL_OBJECTS_OFFSET] // Increment thread_local_objects. - add \xTemp0, \xTemp0, #1 - str \xTemp0, [xSELF, #THREAD_LOCAL_OBJECTS_OFFSET] - POISON_HEAP_REF \wClass - str \wClass, [x0, #MIRROR_OBJECT_CLASS_OFFSET] // Store the class pointer. - str \wCount, [x0, #MIRROR_ARRAY_LENGTH_OFFSET] // Store the array length. - // Fence. This is "ish" not "ishst" so - // that the code after this allocation - // site will see the right values in - // the fields of the class. - // Alternatively we could use "ishst" - // if we use load-acquire for the - // class status load.) - dmb ish - ret -.endm - // The common fast path code for art_quick_alloc_object_tlab and art_quick_alloc_object_region_tlab. // // x0: type_idx/return value, x1: ArtMethod*, x2: Class*, xSELF(x19): Thread::Current @@ -1972,11 +1902,8 @@ END art_quick_alloc_object_rosalloc // Need to preserve x0 and x1 to the slow path. .macro ALLOC_OBJECT_TLAB_FAST_PATH slowPathLabel cbz x2, \slowPathLabel // Check null class - ALLOC_OBJECT_TLAB_FAST_PATH_RESOLVED \slowPathLabel -.endm - -.macro ALLOC_OBJECT_TLAB_FAST_PATH_RESOLVED slowPathLabel - ldr w3, [x2, #MIRROR_CLASS_STATUS_OFFSET] // Check class status. + // Check class status. + ldr w3, [x2, #MIRROR_CLASS_STATUS_OFFSET] cmp x3, #MIRROR_CLASS_STATUS_INITIALIZED bne \slowPathLabel // Add a fake dependence from the @@ -1989,10 +1916,6 @@ END art_quick_alloc_object_rosalloc // a load-acquire for the status). eor x3, x3, x3 add x2, x2, x3 - ALLOC_OBJECT_TLAB_FAST_PATH_INITIALIZED \slowPathLabel -.endm - -.macro ALLOC_OBJECT_TLAB_FAST_PATH_INITIALIZED slowPathLabel // Check access flags has // kAccClassIsFinalizable. ldr w3, [x2, #MIRROR_CLASS_ACCESS_FLAGS_OFFSET] @@ -2055,8 +1978,7 @@ ENTRY art_quick_alloc_object_tlab END art_quick_alloc_object_tlab // A hand-written override for GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT(_region_tlab, RegionTLAB) -.macro GENERATE_ALLOC_OBJECT_REGION_TLAB name, entrypoint, fast_path, is_resolved -ENTRY \name +ENTRY art_quick_alloc_object_region_tlab // Fast path region tlab allocation. // x0: type_idx/return value, x1: ArtMethod*, xSELF(x19): Thread::Current // x2-x7: free. @@ -2064,26 +1986,23 @@ ENTRY \name mvn x0, xzr // Read barrier must be enabled here. ret // Return -1. #endif -.if \is_resolved - mov x2, x0 // class is actually stored in x0 already -.else ldr x2, [x1, #ART_METHOD_DEX_CACHE_TYPES_OFFSET_64] // Load dex cache resolved types array // Load the class (x2) ldr w2, [x2, x0, lsl #COMPRESSED_REFERENCE_SIZE_SHIFT] -.endif + // Most common case: GC is not marking. ldr w3, [xSELF, #THREAD_IS_GC_MARKING_OFFSET] - cbnz x3, .Lmarking\name -.Ldo_allocation\name: - \fast_path .Lslow_path\name -.Lmarking\name: + cbnz x3, .Lart_quick_alloc_object_region_tlab_marking +.Lart_quick_alloc_object_region_tlab_do_allocation: + ALLOC_OBJECT_TLAB_FAST_PATH .Lart_quick_alloc_object_region_tlab_slow_path +.Lart_quick_alloc_object_region_tlab_marking: // GC is marking, check the lock word of the class for the mark bit. // If the class is null, go slow path. The check is required to read the lock word. - cbz w2, .Lslow_path\name + cbz w2, .Lart_quick_alloc_object_region_tlab_slow_path // Class is not null, check mark bit in lock word. ldr w3, [x2, #MIRROR_OBJECT_LOCK_WORD_OFFSET] // If the bit is not zero, do the allocation. - tbnz w3, #LOCK_WORD_MARK_BIT_SHIFT, .Ldo_allocation\name + tbnz w3, #LOCK_WORD_MARK_BIT_SHIFT, .Lart_quick_alloc_object_region_tlab_do_allocation // The read barrier slow path. Mark // the class. stp x0, x1, [sp, #-32]! // Save registers (x0, x1, lr). @@ -2094,82 +2013,14 @@ ENTRY \name ldp x0, x1, [sp, #0] // Restore registers. ldr xLR, [sp, #16] add sp, sp, #32 - b .Ldo_allocation\name -.Lslow_path\name: + b .Lart_quick_alloc_object_region_tlab_do_allocation +.Lart_quick_alloc_object_region_tlab_slow_path: SETUP_REFS_ONLY_CALLEE_SAVE_FRAME // Save callee saves in case of GC. mov x2, xSELF // Pass Thread::Current. - bl \entrypoint // (uint32_t type_idx, Method* method, Thread*) + bl artAllocObjectFromCodeRegionTLAB // (uint32_t type_idx, Method* method, Thread*) RESTORE_REFS_ONLY_CALLEE_SAVE_FRAME RETURN_IF_RESULT_IS_NON_ZERO_OR_DELIVER -END \name -.endm - -GENERATE_ALLOC_OBJECT_REGION_TLAB art_quick_alloc_object_region_tlab, artAllocObjectFromCodeRegionTLAB, ALLOC_OBJECT_TLAB_FAST_PATH, 0 -GENERATE_ALLOC_OBJECT_REGION_TLAB art_quick_alloc_object_resolved_region_tlab, artAllocObjectFromCodeResolvedRegionTLAB, ALLOC_OBJECT_TLAB_FAST_PATH_RESOLVED, 1 -GENERATE_ALLOC_OBJECT_REGION_TLAB art_quick_alloc_object_initialized_region_tlab, artAllocObjectFromCodeInitializedRegionTLAB, ALLOC_OBJECT_TLAB_FAST_PATH_INITIALIZED, 1 - -// A hand-written override for GENERATE_ALLOC_ENTRYPOINTS_ALLOC_ARRAY*(_region_tlab, RegionTLAB) -.macro GENERATE_ALLOC_ARRAY_REGION_TLAB name, entrypoint, fast_path, is_resolved -ENTRY \name - // Fast path array allocation for region tlab allocation. - // x0: uint32_t type_idx - // x1: int32_t component_count - // x2: ArtMethod* method - // x3: Thread* self - // x2-x7: free. -#if !defined(USE_READ_BARRIER) - mvn x0, xzr // Read barrier must be enabled here. - ret // Return -1. -#endif -.if \is_resolved - mov x3, x0 - // If already resolved, class is stored in x0 -.else - ldr x3, [x2, #ART_METHOD_DEX_CACHE_TYPES_OFFSET_64] // Load dex cache resolved types array - // Load the class (x2) - ldr w3, [x3, x0, lsl #COMPRESSED_REFERENCE_SIZE_SHIFT] -.endif - // Most common case: GC is not marking. - ldr w4, [xSELF, #THREAD_IS_GC_MARKING_OFFSET] - cbnz x4, .Lmarking\name -.Ldo_allocation\name: - \fast_path .Lslow_path\name, x3, w3, x1, w1, x4, w4, x5, w5, x6, w6 -.Lmarking\name: - // GC is marking, check the lock word of the class for the mark bit. - // If the class is null, go slow path. The check is required to read the lock word. - cbz w3, .Lslow_path\name - // Class is not null, check mark bit in lock word. - ldr w4, [x3, #MIRROR_OBJECT_LOCK_WORD_OFFSET] - // If the bit is not zero, do the allocation. - tbnz w4, #LOCK_WORD_MARK_BIT_SHIFT, .Ldo_allocation\name - b .Lslow_path\name - // The read barrier slow path. Mark - // the class. - stp x0, x1, [sp, #-32]! // Save registers (x0, x1, x2, lr). - stp x2, xLR, [sp, #16] - mov x0, x3 // Pass the class as the first param. - bl artReadBarrierMark - mov x3, x0 // Get the (marked) class back. - ldp x0, x1, [sp, #0] // Restore registers. - ldp x2, xLR, [sp, #16] - add sp, sp, #32 - b .Ldo_allocation\name -.Lslow_path\name: - // x0: uint32_t type_idx - // x1: int32_t component_count - // x2: ArtMethod* method - // x3: Thread* self - SETUP_REFS_ONLY_CALLEE_SAVE_FRAME // save callee saves in case of GC - mov x3, xSELF // pass Thread::Current - bl \entrypoint - RESTORE_REFS_ONLY_CALLEE_SAVE_FRAME - RETURN_IF_RESULT_IS_NON_ZERO_OR_DELIVER -END \name -.endm - -GENERATE_ALLOC_ARRAY_REGION_TLAB art_quick_alloc_array_region_tlab, artAllocArrayFromCodeRegionTLAB, ALLOC_ARRAY_TLAB_FAST_PATH, 0 -// TODO: art_quick_alloc_array_resolved_region_tlab seems to not get called. Investigate compiler. -GENERATE_ALLOC_ARRAY_REGION_TLAB art_quick_alloc_array_resolved_region_tlab, artAllocArrayFromCodeResolvedRegionTLAB, ALLOC_ARRAY_TLAB_FAST_PATH_RESOLVED, 1 +END art_quick_alloc_object_region_tlab /* * Called by managed code when the thread has been asked to suspend. diff --git a/runtime/arch/quick_alloc_entrypoints.S b/runtime/arch/quick_alloc_entrypoints.S index 34e74a1c00..290769b365 100644 --- a/runtime/arch/quick_alloc_entrypoints.S +++ b/runtime/arch/quick_alloc_entrypoints.S @@ -87,27 +87,6 @@ GENERATE_ALLOC_ENTRYPOINTS _region_tlab_instrumented, RegionTLABInstrumented ONE_ARG_DOWNCALL art_quick_alloc_string_from_string ## c_suffix, artAllocStringFromStringFromCode ## cxx_suffix, RETURN_IF_RESULT_IS_NON_ZERO_OR_DELIVER .macro GENERATE_ALLOC_ENTRYPOINTS_FOR_EACH_ALLOCATOR -GENERATE_ALLOC_ENTRYPOINTS_FOR_NON_REGION_ALLOCATORS -GENERATE_ALLOC_ENTRYPOINTS_FOR_REGION_ALLOCATOR -.endm - -.macro GENERATE_ALLOC_ENTRYPOINTS_FOR_REGION_ALLOCATOR -// This is to be separately defined for each architecture to allow a hand-written assembly fast path. -// GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT(_region_tlab, RegionTLAB) -GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_RESOLVED(_region_tlab, RegionTLAB) -GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_INITIALIZED(_region_tlab, RegionTLAB) -GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_WITH_ACCESS_CHECK(_region_tlab, RegionTLAB) -GENERATE_ALLOC_ENTRYPOINTS_ALLOC_ARRAY(_region_tlab, RegionTLAB) -GENERATE_ALLOC_ENTRYPOINTS_ALLOC_ARRAY_RESOLVED(_region_tlab, RegionTLAB) -GENERATE_ALLOC_ENTRYPOINTS_ALLOC_ARRAY_WITH_ACCESS_CHECK(_region_tlab, RegionTLAB) -GENERATE_ALLOC_ENTRYPOINTS_CHECK_AND_ALLOC_ARRAY(_region_tlab, RegionTLAB) -GENERATE_ALLOC_ENTRYPOINTS_CHECK_AND_ALLOC_ARRAY_WITH_ACCESS_CHECK(_region_tlab, RegionTLAB) -GENERATE_ALLOC_ENTRYPOINTS_ALLOC_STRING_FROM_BYTES(_region_tlab, RegionTLAB) -GENERATE_ALLOC_ENTRYPOINTS_ALLOC_STRING_FROM_CHARS(_region_tlab, RegionTLAB) -GENERATE_ALLOC_ENTRYPOINTS_ALLOC_STRING_FROM_STRING(_region_tlab, RegionTLAB) -.endm - -.macro GENERATE_ALLOC_ENTRYPOINTS_FOR_NON_REGION_ALLOCATORS GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT(_dlmalloc, DlMalloc) GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_RESOLVED(_dlmalloc, DlMalloc) GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_INITIALIZED(_dlmalloc, DlMalloc) @@ -240,6 +219,20 @@ GENERATE_ALLOC_ENTRYPOINTS_ALLOC_STRING_FROM_BYTES(_region_instrumented, RegionI GENERATE_ALLOC_ENTRYPOINTS_ALLOC_STRING_FROM_CHARS(_region_instrumented, RegionInstrumented) GENERATE_ALLOC_ENTRYPOINTS_ALLOC_STRING_FROM_STRING(_region_instrumented, RegionInstrumented) +// This is to be separately defined for each architecture to allow a hand-written assembly fast path. +// GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT(_region_tlab, RegionTLAB) +GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_RESOLVED(_region_tlab, RegionTLAB) +GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_INITIALIZED(_region_tlab, RegionTLAB) +GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_WITH_ACCESS_CHECK(_region_tlab, RegionTLAB) +GENERATE_ALLOC_ENTRYPOINTS_ALLOC_ARRAY(_region_tlab, RegionTLAB) +GENERATE_ALLOC_ENTRYPOINTS_ALLOC_ARRAY_RESOLVED(_region_tlab, RegionTLAB) +GENERATE_ALLOC_ENTRYPOINTS_ALLOC_ARRAY_WITH_ACCESS_CHECK(_region_tlab, RegionTLAB) +GENERATE_ALLOC_ENTRYPOINTS_CHECK_AND_ALLOC_ARRAY(_region_tlab, RegionTLAB) +GENERATE_ALLOC_ENTRYPOINTS_CHECK_AND_ALLOC_ARRAY_WITH_ACCESS_CHECK(_region_tlab, RegionTLAB) +GENERATE_ALLOC_ENTRYPOINTS_ALLOC_STRING_FROM_BYTES(_region_tlab, RegionTLAB) +GENERATE_ALLOC_ENTRYPOINTS_ALLOC_STRING_FROM_CHARS(_region_tlab, RegionTLAB) +GENERATE_ALLOC_ENTRYPOINTS_ALLOC_STRING_FROM_STRING(_region_tlab, RegionTLAB) + GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT(_region_tlab_instrumented, RegionTLABInstrumented) GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_RESOLVED(_region_tlab_instrumented, RegionTLABInstrumented) GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_INITIALIZED(_region_tlab_instrumented, RegionTLABInstrumented) diff --git a/runtime/asm_support.h b/runtime/asm_support.h index 87b0bcb74f..0619af8139 100644 --- a/runtime/asm_support.h +++ b/runtime/asm_support.h @@ -174,17 +174,10 @@ ADD_TEST_EQ(MIRROR_CLASS_ACCESS_FLAGS_OFFSET, #define MIRROR_CLASS_OBJECT_SIZE_OFFSET (100 + MIRROR_OBJECT_HEADER_SIZE) ADD_TEST_EQ(MIRROR_CLASS_OBJECT_SIZE_OFFSET, art::mirror::Class::ObjectSizeOffset().Int32Value()) -#define MIRROR_CLASS_OBJECT_PRIMITIVE_TYPE_OFFSET (104 + MIRROR_OBJECT_HEADER_SIZE) -ADD_TEST_EQ(MIRROR_CLASS_OBJECT_PRIMITIVE_TYPE_OFFSET, - art::mirror::Class::PrimitiveTypeOffset().Int32Value()) #define MIRROR_CLASS_STATUS_OFFSET (112 + MIRROR_OBJECT_HEADER_SIZE) ADD_TEST_EQ(MIRROR_CLASS_STATUS_OFFSET, art::mirror::Class::StatusOffset().Int32Value()) -#define PRIMITIVE_TYPE_SIZE_SHIFT_SHIFT 16 -ADD_TEST_EQ(PRIMITIVE_TYPE_SIZE_SHIFT_SHIFT, - static_cast<int>(art::mirror::Class::kPrimitiveTypeSizeShiftShift)) - // Array offsets. #define MIRROR_ARRAY_LENGTH_OFFSET MIRROR_OBJECT_HEADER_SIZE ADD_TEST_EQ(MIRROR_ARRAY_LENGTH_OFFSET, art::mirror::Array::LengthOffset().Int32Value()) diff --git a/runtime/interpreter/mterp/arm/binopLit8.S b/runtime/interpreter/mterp/arm/binopLit8.S index b8f0d925cd..7c9c6312cd 100644 --- a/runtime/interpreter/mterp/arm/binopLit8.S +++ b/runtime/interpreter/mterp/arm/binopLit8.S @@ -1,10 +1,14 @@ -%default {"preinstr":"", "result":"r0", "chkzero":"0"} +%default {"extract":"asr r1, r3, #8", "result":"r0", "chkzero":"0"} /* * Generic 32-bit "lit8" binary operation. Provide an "instr" line * that specifies an instruction that performs "result = r0 op r1". * This could be an ARM instruction or a function call. (If the result * comes back in a register other than r0, you can override "result".) * + * You can override "extract" if the extraction of the literal value + * from r3 to r1 is not the default "asr r1, r3, #8". The extraction + * can be omitted completely if the shift is embedded in "instr". + * * If "chkzero" is set to 1, we perform a divide-by-zero check on * vCC (r1). Useful for integer division and modulus. * @@ -17,14 +21,13 @@ mov r9, rINST, lsr #8 @ r9<- AA and r2, r3, #255 @ r2<- BB GET_VREG r0, r2 @ r0<- vBB - movs r1, r3, asr #8 @ r1<- ssssssCC (sign extended) + $extract @ optional; typically r1<- ssssssCC (sign extended) .if $chkzero @cmp r1, #0 @ is second operand zero? beq common_errDivideByZero .endif FETCH_ADVANCE_INST 2 @ advance rPC, load rINST - $preinstr @ optional op; may set condition codes $instr @ $result<- op, r0-r3 changed GET_INST_OPCODE ip @ extract opcode from rINST SET_VREG $result, r9 @ vAA<- $result diff --git a/runtime/interpreter/mterp/arm/op_add_int_lit8.S b/runtime/interpreter/mterp/arm/op_add_int_lit8.S index b84684a3a3..035510d062 100644 --- a/runtime/interpreter/mterp/arm/op_add_int_lit8.S +++ b/runtime/interpreter/mterp/arm/op_add_int_lit8.S @@ -1 +1 @@ -%include "arm/binopLit8.S" {"instr":"add r0, r0, r1"} +%include "arm/binopLit8.S" {"extract":"", "instr":"add r0, r0, r3, asr #8"} diff --git a/runtime/interpreter/mterp/arm/op_and_int_lit8.S b/runtime/interpreter/mterp/arm/op_and_int_lit8.S index d5783e52e1..af746b5447 100644 --- a/runtime/interpreter/mterp/arm/op_and_int_lit8.S +++ b/runtime/interpreter/mterp/arm/op_and_int_lit8.S @@ -1 +1 @@ -%include "arm/binopLit8.S" {"instr":"and r0, r0, r1"} +%include "arm/binopLit8.S" {"extract":"", "instr":"and r0, r0, r3, asr #8"} diff --git a/runtime/interpreter/mterp/arm/op_or_int_lit8.S b/runtime/interpreter/mterp/arm/op_or_int_lit8.S index 2d85038d59..9882bfcf5e 100644 --- a/runtime/interpreter/mterp/arm/op_or_int_lit8.S +++ b/runtime/interpreter/mterp/arm/op_or_int_lit8.S @@ -1 +1 @@ -%include "arm/binopLit8.S" {"instr":"orr r0, r0, r1"} +%include "arm/binopLit8.S" {"extract":"", "instr":"orr r0, r0, r3, asr #8"} diff --git a/runtime/interpreter/mterp/arm/op_rsub_int_lit8.S b/runtime/interpreter/mterp/arm/op_rsub_int_lit8.S index 2ee11e159e..dc953dcc4a 100644 --- a/runtime/interpreter/mterp/arm/op_rsub_int_lit8.S +++ b/runtime/interpreter/mterp/arm/op_rsub_int_lit8.S @@ -1 +1 @@ -%include "arm/binopLit8.S" {"instr":"rsb r0, r0, r1"} +%include "arm/binopLit8.S" {"extract":"", "instr":"rsb r0, r0, r3, asr #8"} diff --git a/runtime/interpreter/mterp/arm/op_shl_int_lit8.S b/runtime/interpreter/mterp/arm/op_shl_int_lit8.S index 6a48bfcf17..60a149880f 100644 --- a/runtime/interpreter/mterp/arm/op_shl_int_lit8.S +++ b/runtime/interpreter/mterp/arm/op_shl_int_lit8.S @@ -1 +1 @@ -%include "arm/binopLit8.S" {"preinstr":"and r1, r1, #31", "instr":"mov r0, r0, asl r1"} +%include "arm/binopLit8.S" {"extract":"ubfx r1, r3, #8, #5", "instr":"mov r0, r0, asl r1"} diff --git a/runtime/interpreter/mterp/arm/op_shr_int_lit8.S b/runtime/interpreter/mterp/arm/op_shr_int_lit8.S index 60fe5fca94..c2f6cb0503 100644 --- a/runtime/interpreter/mterp/arm/op_shr_int_lit8.S +++ b/runtime/interpreter/mterp/arm/op_shr_int_lit8.S @@ -1 +1 @@ -%include "arm/binopLit8.S" {"preinstr":"and r1, r1, #31", "instr":"mov r0, r0, asr r1"} +%include "arm/binopLit8.S" {"extract":"ubfx r1, r3, #8, #5", "instr":"mov r0, r0, asr r1"} diff --git a/runtime/interpreter/mterp/arm/op_ushr_int_lit8.S b/runtime/interpreter/mterp/arm/op_ushr_int_lit8.S index 40a443549a..5554eb06f7 100644 --- a/runtime/interpreter/mterp/arm/op_ushr_int_lit8.S +++ b/runtime/interpreter/mterp/arm/op_ushr_int_lit8.S @@ -1 +1 @@ -%include "arm/binopLit8.S" {"preinstr":"and r1, r1, #31", "instr":"mov r0, r0, lsr r1"} +%include "arm/binopLit8.S" {"extract":"ubfx r1, r3, #8, #5", "instr":"mov r0, r0, lsr r1"} diff --git a/runtime/interpreter/mterp/arm/op_xor_int_lit8.S b/runtime/interpreter/mterp/arm/op_xor_int_lit8.S index 46bb712167..97d0b9ee14 100644 --- a/runtime/interpreter/mterp/arm/op_xor_int_lit8.S +++ b/runtime/interpreter/mterp/arm/op_xor_int_lit8.S @@ -1 +1 @@ -%include "arm/binopLit8.S" {"instr":"eor r0, r0, r1"} +%include "arm/binopLit8.S" {"extract":"", "instr":"eor r0, r0, r3, asr #8"} diff --git a/runtime/interpreter/mterp/arm64/binopLit8.S b/runtime/interpreter/mterp/arm64/binopLit8.S index 0b7c68a64b..dfa3169905 100644 --- a/runtime/interpreter/mterp/arm64/binopLit8.S +++ b/runtime/interpreter/mterp/arm64/binopLit8.S @@ -1,10 +1,14 @@ -%default {"preinstr":"", "result":"w0", "chkzero":"0"} +%default {"extract": "asr w1, w3, #8", "preinstr":"", "result":"w0", "chkzero":"0"} /* * Generic 32-bit "lit8" binary operation. Provide an "instr" line * that specifies an instruction that performs "result = w0 op w1". * This could be an ARM instruction or a function call. (If the result * comes back in a register other than w0, you can override "result".) * + * You can override "extract" if the extraction of the literal value + * from w3 to w1 is not the default "asr w1, w3, #8". The extraction + * can be omitted completely if the shift is embedded in "instr". + * * If "chkzero" is set to 1, we perform a divide-by-zero check on * vCC (w1). Useful for integer division and modulus. * @@ -17,7 +21,7 @@ lsr w9, wINST, #8 // w9<- AA and w2, w3, #255 // w2<- BB GET_VREG w0, w2 // w0<- vBB - asr w1, w3, #8 // w1<- ssssssCC (sign extended) + $extract // optional; typically w1<- ssssssCC (sign extended) .if $chkzero cbz w1, common_errDivideByZero .endif diff --git a/runtime/interpreter/mterp/arm64/op_add_int_lit8.S b/runtime/interpreter/mterp/arm64/op_add_int_lit8.S index 196ea9934d..2dfb8b9b56 100644 --- a/runtime/interpreter/mterp/arm64/op_add_int_lit8.S +++ b/runtime/interpreter/mterp/arm64/op_add_int_lit8.S @@ -1 +1 @@ -%include "arm64/binopLit8.S" {"instr":"add w0, w0, w1"} +%include "arm64/binopLit8.S" {"extract":"", "instr":"add w0, w0, w3, asr #8"} diff --git a/runtime/interpreter/mterp/arm64/op_and_int_lit8.S b/runtime/interpreter/mterp/arm64/op_and_int_lit8.S index 167b40ecfb..495b5cddd6 100644 --- a/runtime/interpreter/mterp/arm64/op_and_int_lit8.S +++ b/runtime/interpreter/mterp/arm64/op_and_int_lit8.S @@ -1 +1 @@ -%include "arm64/binopLit8.S" {"instr":"and w0, w0, w1"} +%include "arm64/binopLit8.S" {"extract":"", "instr":"and w0, w0, w3, asr #8"} diff --git a/runtime/interpreter/mterp/arm64/op_or_int_lit8.S b/runtime/interpreter/mterp/arm64/op_or_int_lit8.S index 51675f8b82..7cb26b7796 100644 --- a/runtime/interpreter/mterp/arm64/op_or_int_lit8.S +++ b/runtime/interpreter/mterp/arm64/op_or_int_lit8.S @@ -1 +1 @@ -%include "arm64/binopLit8.S" {"instr":"orr w0, w0, w1"} +%include "arm64/binopLit8.S" {"extract":"", "instr":"orr w0, w0, w3, asr #8"} diff --git a/runtime/interpreter/mterp/arm64/op_shl_int_lit8.S b/runtime/interpreter/mterp/arm64/op_shl_int_lit8.S index 17f57f9f5c..9c19b55550 100644 --- a/runtime/interpreter/mterp/arm64/op_shl_int_lit8.S +++ b/runtime/interpreter/mterp/arm64/op_shl_int_lit8.S @@ -1 +1 @@ -%include "arm64/binopLit8.S" {"instr":"lsl w0, w0, w1"} +%include "arm64/binopLit8.S" {"extract":"ubfx w1, w3, #8, #5", "instr":"lsl w0, w0, w1"} diff --git a/runtime/interpreter/mterp/arm64/op_shr_int_lit8.S b/runtime/interpreter/mterp/arm64/op_shr_int_lit8.S index 274080c4b2..c7b61df13d 100644 --- a/runtime/interpreter/mterp/arm64/op_shr_int_lit8.S +++ b/runtime/interpreter/mterp/arm64/op_shr_int_lit8.S @@ -1 +1 @@ -%include "arm64/binopLit8.S" {"instr":"asr w0, w0, w1"} +%include "arm64/binopLit8.S" {"extract":"ubfx w1, w3, #8, #5", "instr":"asr w0, w0, w1"} diff --git a/runtime/interpreter/mterp/arm64/op_ushr_int_lit8.S b/runtime/interpreter/mterp/arm64/op_ushr_int_lit8.S index ff30e1f1a8..555ed4eb29 100644 --- a/runtime/interpreter/mterp/arm64/op_ushr_int_lit8.S +++ b/runtime/interpreter/mterp/arm64/op_ushr_int_lit8.S @@ -1 +1 @@ -%include "arm64/binopLit8.S" {"instr":"lsr w0, w0, w1"} +%include "arm64/binopLit8.S" {"extract":"ubfx w1, w3, #8, #5", "instr":"lsr w0, w0, w1"} diff --git a/runtime/interpreter/mterp/arm64/op_xor_int_lit8.S b/runtime/interpreter/mterp/arm64/op_xor_int_lit8.S index 6d187b5797..1d3d93e3f7 100644 --- a/runtime/interpreter/mterp/arm64/op_xor_int_lit8.S +++ b/runtime/interpreter/mterp/arm64/op_xor_int_lit8.S @@ -1 +1 @@ -%include "arm64/binopLit8.S" {"instr":"eor w0, w0, w1"} +%include "arm64/binopLit8.S" {"extract":"", "instr":"eor w0, w0, w3, asr #8"} diff --git a/runtime/interpreter/mterp/out/mterp_arm.S b/runtime/interpreter/mterp/out/mterp_arm.S index df25767fc0..02b462fef3 100644 --- a/runtime/interpreter/mterp/out/mterp_arm.S +++ b/runtime/interpreter/mterp/out/mterp_arm.S @@ -6473,6 +6473,10 @@ constvalop_long_to_double: * This could be an ARM instruction or a function call. (If the result * comes back in a register other than r0, you can override "result".) * + * You can override "extract" if the extraction of the literal value + * from r3 to r1 is not the default "asr r1, r3, #8". The extraction + * can be omitted completely if the shift is embedded in "instr". + * * If "chkzero" is set to 1, we perform a divide-by-zero check on * vCC (r1). Useful for integer division and modulus. * @@ -6485,15 +6489,14 @@ constvalop_long_to_double: mov r9, rINST, lsr #8 @ r9<- AA and r2, r3, #255 @ r2<- BB GET_VREG r0, r2 @ r0<- vBB - movs r1, r3, asr #8 @ r1<- ssssssCC (sign extended) + @ optional; typically r1<- ssssssCC (sign extended) .if 0 @cmp r1, #0 @ is second operand zero? beq common_errDivideByZero .endif FETCH_ADVANCE_INST 2 @ advance rPC, load rINST - @ optional op; may set condition codes - add r0, r0, r1 @ r0<- op, r0-r3 changed + add r0, r0, r3, asr #8 @ r0<- op, r0-r3 changed GET_INST_OPCODE ip @ extract opcode from rINST SET_VREG r0, r9 @ vAA<- r0 GOTO_OPCODE ip @ jump to next instruction @@ -6511,6 +6514,10 @@ constvalop_long_to_double: * This could be an ARM instruction or a function call. (If the result * comes back in a register other than r0, you can override "result".) * + * You can override "extract" if the extraction of the literal value + * from r3 to r1 is not the default "asr r1, r3, #8". The extraction + * can be omitted completely if the shift is embedded in "instr". + * * If "chkzero" is set to 1, we perform a divide-by-zero check on * vCC (r1). Useful for integer division and modulus. * @@ -6523,15 +6530,14 @@ constvalop_long_to_double: mov r9, rINST, lsr #8 @ r9<- AA and r2, r3, #255 @ r2<- BB GET_VREG r0, r2 @ r0<- vBB - movs r1, r3, asr #8 @ r1<- ssssssCC (sign extended) + @ optional; typically r1<- ssssssCC (sign extended) .if 0 @cmp r1, #0 @ is second operand zero? beq common_errDivideByZero .endif FETCH_ADVANCE_INST 2 @ advance rPC, load rINST - @ optional op; may set condition codes - rsb r0, r0, r1 @ r0<- op, r0-r3 changed + rsb r0, r0, r3, asr #8 @ r0<- op, r0-r3 changed GET_INST_OPCODE ip @ extract opcode from rINST SET_VREG r0, r9 @ vAA<- r0 GOTO_OPCODE ip @ jump to next instruction @@ -6550,6 +6556,10 @@ constvalop_long_to_double: * This could be an ARM instruction or a function call. (If the result * comes back in a register other than r0, you can override "result".) * + * You can override "extract" if the extraction of the literal value + * from r3 to r1 is not the default "asr r1, r3, #8". The extraction + * can be omitted completely if the shift is embedded in "instr". + * * If "chkzero" is set to 1, we perform a divide-by-zero check on * vCC (r1). Useful for integer division and modulus. * @@ -6562,14 +6572,13 @@ constvalop_long_to_double: mov r9, rINST, lsr #8 @ r9<- AA and r2, r3, #255 @ r2<- BB GET_VREG r0, r2 @ r0<- vBB - movs r1, r3, asr #8 @ r1<- ssssssCC (sign extended) + asr r1, r3, #8 @ optional; typically r1<- ssssssCC (sign extended) .if 0 @cmp r1, #0 @ is second operand zero? beq common_errDivideByZero .endif FETCH_ADVANCE_INST 2 @ advance rPC, load rINST - @ optional op; may set condition codes mul r0, r1, r0 @ r0<- op, r0-r3 changed GET_INST_OPCODE ip @ extract opcode from rINST SET_VREG r0, r9 @ vAA<- r0 @@ -6657,6 +6666,10 @@ constvalop_long_to_double: * This could be an ARM instruction or a function call. (If the result * comes back in a register other than r0, you can override "result".) * + * You can override "extract" if the extraction of the literal value + * from r3 to r1 is not the default "asr r1, r3, #8". The extraction + * can be omitted completely if the shift is embedded in "instr". + * * If "chkzero" is set to 1, we perform a divide-by-zero check on * vCC (r1). Useful for integer division and modulus. * @@ -6669,15 +6682,14 @@ constvalop_long_to_double: mov r9, rINST, lsr #8 @ r9<- AA and r2, r3, #255 @ r2<- BB GET_VREG r0, r2 @ r0<- vBB - movs r1, r3, asr #8 @ r1<- ssssssCC (sign extended) + @ optional; typically r1<- ssssssCC (sign extended) .if 0 @cmp r1, #0 @ is second operand zero? beq common_errDivideByZero .endif FETCH_ADVANCE_INST 2 @ advance rPC, load rINST - @ optional op; may set condition codes - and r0, r0, r1 @ r0<- op, r0-r3 changed + and r0, r0, r3, asr #8 @ r0<- op, r0-r3 changed GET_INST_OPCODE ip @ extract opcode from rINST SET_VREG r0, r9 @ vAA<- r0 GOTO_OPCODE ip @ jump to next instruction @@ -6695,6 +6707,10 @@ constvalop_long_to_double: * This could be an ARM instruction or a function call. (If the result * comes back in a register other than r0, you can override "result".) * + * You can override "extract" if the extraction of the literal value + * from r3 to r1 is not the default "asr r1, r3, #8". The extraction + * can be omitted completely if the shift is embedded in "instr". + * * If "chkzero" is set to 1, we perform a divide-by-zero check on * vCC (r1). Useful for integer division and modulus. * @@ -6707,15 +6723,14 @@ constvalop_long_to_double: mov r9, rINST, lsr #8 @ r9<- AA and r2, r3, #255 @ r2<- BB GET_VREG r0, r2 @ r0<- vBB - movs r1, r3, asr #8 @ r1<- ssssssCC (sign extended) + @ optional; typically r1<- ssssssCC (sign extended) .if 0 @cmp r1, #0 @ is second operand zero? beq common_errDivideByZero .endif FETCH_ADVANCE_INST 2 @ advance rPC, load rINST - @ optional op; may set condition codes - orr r0, r0, r1 @ r0<- op, r0-r3 changed + orr r0, r0, r3, asr #8 @ r0<- op, r0-r3 changed GET_INST_OPCODE ip @ extract opcode from rINST SET_VREG r0, r9 @ vAA<- r0 GOTO_OPCODE ip @ jump to next instruction @@ -6733,6 +6748,10 @@ constvalop_long_to_double: * This could be an ARM instruction or a function call. (If the result * comes back in a register other than r0, you can override "result".) * + * You can override "extract" if the extraction of the literal value + * from r3 to r1 is not the default "asr r1, r3, #8". The extraction + * can be omitted completely if the shift is embedded in "instr". + * * If "chkzero" is set to 1, we perform a divide-by-zero check on * vCC (r1). Useful for integer division and modulus. * @@ -6745,15 +6764,14 @@ constvalop_long_to_double: mov r9, rINST, lsr #8 @ r9<- AA and r2, r3, #255 @ r2<- BB GET_VREG r0, r2 @ r0<- vBB - movs r1, r3, asr #8 @ r1<- ssssssCC (sign extended) + @ optional; typically r1<- ssssssCC (sign extended) .if 0 @cmp r1, #0 @ is second operand zero? beq common_errDivideByZero .endif FETCH_ADVANCE_INST 2 @ advance rPC, load rINST - @ optional op; may set condition codes - eor r0, r0, r1 @ r0<- op, r0-r3 changed + eor r0, r0, r3, asr #8 @ r0<- op, r0-r3 changed GET_INST_OPCODE ip @ extract opcode from rINST SET_VREG r0, r9 @ vAA<- r0 GOTO_OPCODE ip @ jump to next instruction @@ -6771,6 +6789,10 @@ constvalop_long_to_double: * This could be an ARM instruction or a function call. (If the result * comes back in a register other than r0, you can override "result".) * + * You can override "extract" if the extraction of the literal value + * from r3 to r1 is not the default "asr r1, r3, #8". The extraction + * can be omitted completely if the shift is embedded in "instr". + * * If "chkzero" is set to 1, we perform a divide-by-zero check on * vCC (r1). Useful for integer division and modulus. * @@ -6783,14 +6805,13 @@ constvalop_long_to_double: mov r9, rINST, lsr #8 @ r9<- AA and r2, r3, #255 @ r2<- BB GET_VREG r0, r2 @ r0<- vBB - movs r1, r3, asr #8 @ r1<- ssssssCC (sign extended) + ubfx r1, r3, #8, #5 @ optional; typically r1<- ssssssCC (sign extended) .if 0 @cmp r1, #0 @ is second operand zero? beq common_errDivideByZero .endif FETCH_ADVANCE_INST 2 @ advance rPC, load rINST - and r1, r1, #31 @ optional op; may set condition codes mov r0, r0, asl r1 @ r0<- op, r0-r3 changed GET_INST_OPCODE ip @ extract opcode from rINST SET_VREG r0, r9 @ vAA<- r0 @@ -6809,6 +6830,10 @@ constvalop_long_to_double: * This could be an ARM instruction or a function call. (If the result * comes back in a register other than r0, you can override "result".) * + * You can override "extract" if the extraction of the literal value + * from r3 to r1 is not the default "asr r1, r3, #8". The extraction + * can be omitted completely if the shift is embedded in "instr". + * * If "chkzero" is set to 1, we perform a divide-by-zero check on * vCC (r1). Useful for integer division and modulus. * @@ -6821,14 +6846,13 @@ constvalop_long_to_double: mov r9, rINST, lsr #8 @ r9<- AA and r2, r3, #255 @ r2<- BB GET_VREG r0, r2 @ r0<- vBB - movs r1, r3, asr #8 @ r1<- ssssssCC (sign extended) + ubfx r1, r3, #8, #5 @ optional; typically r1<- ssssssCC (sign extended) .if 0 @cmp r1, #0 @ is second operand zero? beq common_errDivideByZero .endif FETCH_ADVANCE_INST 2 @ advance rPC, load rINST - and r1, r1, #31 @ optional op; may set condition codes mov r0, r0, asr r1 @ r0<- op, r0-r3 changed GET_INST_OPCODE ip @ extract opcode from rINST SET_VREG r0, r9 @ vAA<- r0 @@ -6847,6 +6871,10 @@ constvalop_long_to_double: * This could be an ARM instruction or a function call. (If the result * comes back in a register other than r0, you can override "result".) * + * You can override "extract" if the extraction of the literal value + * from r3 to r1 is not the default "asr r1, r3, #8". The extraction + * can be omitted completely if the shift is embedded in "instr". + * * If "chkzero" is set to 1, we perform a divide-by-zero check on * vCC (r1). Useful for integer division and modulus. * @@ -6859,14 +6887,13 @@ constvalop_long_to_double: mov r9, rINST, lsr #8 @ r9<- AA and r2, r3, #255 @ r2<- BB GET_VREG r0, r2 @ r0<- vBB - movs r1, r3, asr #8 @ r1<- ssssssCC (sign extended) + ubfx r1, r3, #8, #5 @ optional; typically r1<- ssssssCC (sign extended) .if 0 @cmp r1, #0 @ is second operand zero? beq common_errDivideByZero .endif FETCH_ADVANCE_INST 2 @ advance rPC, load rINST - and r1, r1, #31 @ optional op; may set condition codes mov r0, r0, lsr r1 @ r0<- op, r0-r3 changed GET_INST_OPCODE ip @ extract opcode from rINST SET_VREG r0, r9 @ vAA<- r0 diff --git a/runtime/interpreter/mterp/out/mterp_arm64.S b/runtime/interpreter/mterp/out/mterp_arm64.S index de37e07e31..0a99802c2c 100644 --- a/runtime/interpreter/mterp/out/mterp_arm64.S +++ b/runtime/interpreter/mterp/out/mterp_arm64.S @@ -6044,6 +6044,10 @@ artMterpAsmInstructionStart = .L_op_nop * This could be an ARM instruction or a function call. (If the result * comes back in a register other than w0, you can override "result".) * + * You can override "extract" if the extraction of the literal value + * from w3 to w1 is not the default "asr w1, w3, #8". The extraction + * can be omitted completely if the shift is embedded in "instr". + * * If "chkzero" is set to 1, we perform a divide-by-zero check on * vCC (w1). Useful for integer division and modulus. * @@ -6056,13 +6060,13 @@ artMterpAsmInstructionStart = .L_op_nop lsr w9, wINST, #8 // w9<- AA and w2, w3, #255 // w2<- BB GET_VREG w0, w2 // w0<- vBB - asr w1, w3, #8 // w1<- ssssssCC (sign extended) + // optional; typically w1<- ssssssCC (sign extended) .if 0 cbz w1, common_errDivideByZero .endif FETCH_ADVANCE_INST 2 // advance rPC, load rINST // optional op; may set condition codes - add w0, w0, w1 // w0<- op, w0-w3 changed + add w0, w0, w3, asr #8 // w0<- op, w0-w3 changed GET_INST_OPCODE ip // extract opcode from rINST SET_VREG w0, w9 // vAA<- w0 GOTO_OPCODE ip // jump to next instruction @@ -6080,6 +6084,10 @@ artMterpAsmInstructionStart = .L_op_nop * This could be an ARM instruction or a function call. (If the result * comes back in a register other than w0, you can override "result".) * + * You can override "extract" if the extraction of the literal value + * from w3 to w1 is not the default "asr w1, w3, #8". The extraction + * can be omitted completely if the shift is embedded in "instr". + * * If "chkzero" is set to 1, we perform a divide-by-zero check on * vCC (w1). Useful for integer division and modulus. * @@ -6092,7 +6100,7 @@ artMterpAsmInstructionStart = .L_op_nop lsr w9, wINST, #8 // w9<- AA and w2, w3, #255 // w2<- BB GET_VREG w0, w2 // w0<- vBB - asr w1, w3, #8 // w1<- ssssssCC (sign extended) + asr w1, w3, #8 // optional; typically w1<- ssssssCC (sign extended) .if 0 cbz w1, common_errDivideByZero .endif @@ -6117,6 +6125,10 @@ artMterpAsmInstructionStart = .L_op_nop * This could be an ARM instruction or a function call. (If the result * comes back in a register other than w0, you can override "result".) * + * You can override "extract" if the extraction of the literal value + * from w3 to w1 is not the default "asr w1, w3, #8". The extraction + * can be omitted completely if the shift is embedded in "instr". + * * If "chkzero" is set to 1, we perform a divide-by-zero check on * vCC (w1). Useful for integer division and modulus. * @@ -6129,7 +6141,7 @@ artMterpAsmInstructionStart = .L_op_nop lsr w9, wINST, #8 // w9<- AA and w2, w3, #255 // w2<- BB GET_VREG w0, w2 // w0<- vBB - asr w1, w3, #8 // w1<- ssssssCC (sign extended) + asr w1, w3, #8 // optional; typically w1<- ssssssCC (sign extended) .if 0 cbz w1, common_errDivideByZero .endif @@ -6153,6 +6165,10 @@ artMterpAsmInstructionStart = .L_op_nop * This could be an ARM instruction or a function call. (If the result * comes back in a register other than w0, you can override "result".) * + * You can override "extract" if the extraction of the literal value + * from w3 to w1 is not the default "asr w1, w3, #8". The extraction + * can be omitted completely if the shift is embedded in "instr". + * * If "chkzero" is set to 1, we perform a divide-by-zero check on * vCC (w1). Useful for integer division and modulus. * @@ -6165,7 +6181,7 @@ artMterpAsmInstructionStart = .L_op_nop lsr w9, wINST, #8 // w9<- AA and w2, w3, #255 // w2<- BB GET_VREG w0, w2 // w0<- vBB - asr w1, w3, #8 // w1<- ssssssCC (sign extended) + asr w1, w3, #8 // optional; typically w1<- ssssssCC (sign extended) .if 1 cbz w1, common_errDivideByZero .endif @@ -6189,6 +6205,10 @@ artMterpAsmInstructionStart = .L_op_nop * This could be an ARM instruction or a function call. (If the result * comes back in a register other than w0, you can override "result".) * + * You can override "extract" if the extraction of the literal value + * from w3 to w1 is not the default "asr w1, w3, #8". The extraction + * can be omitted completely if the shift is embedded in "instr". + * * If "chkzero" is set to 1, we perform a divide-by-zero check on * vCC (w1). Useful for integer division and modulus. * @@ -6201,7 +6221,7 @@ artMterpAsmInstructionStart = .L_op_nop lsr w9, wINST, #8 // w9<- AA and w2, w3, #255 // w2<- BB GET_VREG w0, w2 // w0<- vBB - asr w1, w3, #8 // w1<- ssssssCC (sign extended) + asr w1, w3, #8 // optional; typically w1<- ssssssCC (sign extended) .if 1 cbz w1, common_errDivideByZero .endif @@ -6225,6 +6245,10 @@ artMterpAsmInstructionStart = .L_op_nop * This could be an ARM instruction or a function call. (If the result * comes back in a register other than w0, you can override "result".) * + * You can override "extract" if the extraction of the literal value + * from w3 to w1 is not the default "asr w1, w3, #8". The extraction + * can be omitted completely if the shift is embedded in "instr". + * * If "chkzero" is set to 1, we perform a divide-by-zero check on * vCC (w1). Useful for integer division and modulus. * @@ -6237,13 +6261,13 @@ artMterpAsmInstructionStart = .L_op_nop lsr w9, wINST, #8 // w9<- AA and w2, w3, #255 // w2<- BB GET_VREG w0, w2 // w0<- vBB - asr w1, w3, #8 // w1<- ssssssCC (sign extended) + // optional; typically w1<- ssssssCC (sign extended) .if 0 cbz w1, common_errDivideByZero .endif FETCH_ADVANCE_INST 2 // advance rPC, load rINST // optional op; may set condition codes - and w0, w0, w1 // w0<- op, w0-w3 changed + and w0, w0, w3, asr #8 // w0<- op, w0-w3 changed GET_INST_OPCODE ip // extract opcode from rINST SET_VREG w0, w9 // vAA<- w0 GOTO_OPCODE ip // jump to next instruction @@ -6261,6 +6285,10 @@ artMterpAsmInstructionStart = .L_op_nop * This could be an ARM instruction or a function call. (If the result * comes back in a register other than w0, you can override "result".) * + * You can override "extract" if the extraction of the literal value + * from w3 to w1 is not the default "asr w1, w3, #8". The extraction + * can be omitted completely if the shift is embedded in "instr". + * * If "chkzero" is set to 1, we perform a divide-by-zero check on * vCC (w1). Useful for integer division and modulus. * @@ -6273,13 +6301,13 @@ artMterpAsmInstructionStart = .L_op_nop lsr w9, wINST, #8 // w9<- AA and w2, w3, #255 // w2<- BB GET_VREG w0, w2 // w0<- vBB - asr w1, w3, #8 // w1<- ssssssCC (sign extended) + // optional; typically w1<- ssssssCC (sign extended) .if 0 cbz w1, common_errDivideByZero .endif FETCH_ADVANCE_INST 2 // advance rPC, load rINST // optional op; may set condition codes - orr w0, w0, w1 // w0<- op, w0-w3 changed + orr w0, w0, w3, asr #8 // w0<- op, w0-w3 changed GET_INST_OPCODE ip // extract opcode from rINST SET_VREG w0, w9 // vAA<- w0 GOTO_OPCODE ip // jump to next instruction @@ -6297,6 +6325,10 @@ artMterpAsmInstructionStart = .L_op_nop * This could be an ARM instruction or a function call. (If the result * comes back in a register other than w0, you can override "result".) * + * You can override "extract" if the extraction of the literal value + * from w3 to w1 is not the default "asr w1, w3, #8". The extraction + * can be omitted completely if the shift is embedded in "instr". + * * If "chkzero" is set to 1, we perform a divide-by-zero check on * vCC (w1). Useful for integer division and modulus. * @@ -6309,13 +6341,13 @@ artMterpAsmInstructionStart = .L_op_nop lsr w9, wINST, #8 // w9<- AA and w2, w3, #255 // w2<- BB GET_VREG w0, w2 // w0<- vBB - asr w1, w3, #8 // w1<- ssssssCC (sign extended) + // optional; typically w1<- ssssssCC (sign extended) .if 0 cbz w1, common_errDivideByZero .endif FETCH_ADVANCE_INST 2 // advance rPC, load rINST // optional op; may set condition codes - eor w0, w0, w1 // w0<- op, w0-w3 changed + eor w0, w0, w3, asr #8 // w0<- op, w0-w3 changed GET_INST_OPCODE ip // extract opcode from rINST SET_VREG w0, w9 // vAA<- w0 GOTO_OPCODE ip // jump to next instruction @@ -6333,6 +6365,10 @@ artMterpAsmInstructionStart = .L_op_nop * This could be an ARM instruction or a function call. (If the result * comes back in a register other than w0, you can override "result".) * + * You can override "extract" if the extraction of the literal value + * from w3 to w1 is not the default "asr w1, w3, #8". The extraction + * can be omitted completely if the shift is embedded in "instr". + * * If "chkzero" is set to 1, we perform a divide-by-zero check on * vCC (w1). Useful for integer division and modulus. * @@ -6345,7 +6381,7 @@ artMterpAsmInstructionStart = .L_op_nop lsr w9, wINST, #8 // w9<- AA and w2, w3, #255 // w2<- BB GET_VREG w0, w2 // w0<- vBB - asr w1, w3, #8 // w1<- ssssssCC (sign extended) + ubfx w1, w3, #8, #5 // optional; typically w1<- ssssssCC (sign extended) .if 0 cbz w1, common_errDivideByZero .endif @@ -6369,6 +6405,10 @@ artMterpAsmInstructionStart = .L_op_nop * This could be an ARM instruction or a function call. (If the result * comes back in a register other than w0, you can override "result".) * + * You can override "extract" if the extraction of the literal value + * from w3 to w1 is not the default "asr w1, w3, #8". The extraction + * can be omitted completely if the shift is embedded in "instr". + * * If "chkzero" is set to 1, we perform a divide-by-zero check on * vCC (w1). Useful for integer division and modulus. * @@ -6381,7 +6421,7 @@ artMterpAsmInstructionStart = .L_op_nop lsr w9, wINST, #8 // w9<- AA and w2, w3, #255 // w2<- BB GET_VREG w0, w2 // w0<- vBB - asr w1, w3, #8 // w1<- ssssssCC (sign extended) + ubfx w1, w3, #8, #5 // optional; typically w1<- ssssssCC (sign extended) .if 0 cbz w1, common_errDivideByZero .endif @@ -6405,6 +6445,10 @@ artMterpAsmInstructionStart = .L_op_nop * This could be an ARM instruction or a function call. (If the result * comes back in a register other than w0, you can override "result".) * + * You can override "extract" if the extraction of the literal value + * from w3 to w1 is not the default "asr w1, w3, #8". The extraction + * can be omitted completely if the shift is embedded in "instr". + * * If "chkzero" is set to 1, we perform a divide-by-zero check on * vCC (w1). Useful for integer division and modulus. * @@ -6417,7 +6461,7 @@ artMterpAsmInstructionStart = .L_op_nop lsr w9, wINST, #8 // w9<- AA and w2, w3, #255 // w2<- BB GET_VREG w0, w2 // w0<- vBB - asr w1, w3, #8 // w1<- ssssssCC (sign extended) + ubfx w1, w3, #8, #5 // optional; typically w1<- ssssssCC (sign extended) .if 0 cbz w1, common_errDivideByZero .endif diff --git a/runtime/mirror/class-inl.h b/runtime/mirror/class-inl.h index 8ad47eb799..8f5419cd49 100644 --- a/runtime/mirror/class-inl.h +++ b/runtime/mirror/class-inl.h @@ -636,9 +636,8 @@ inline Primitive::Type Class::GetPrimitiveType() { static_assert(sizeof(Primitive::Type) == sizeof(int32_t), "art::Primitive::Type and int32_t have different sizes."); int32_t v32 = GetField32<kVerifyFlags>(OFFSET_OF_OBJECT_MEMBER(Class, primitive_type_)); - Primitive::Type type = static_cast<Primitive::Type>(v32 & kPrimitiveTypeMask); - DCHECK_EQ(static_cast<size_t>(v32 >> kPrimitiveTypeSizeShiftShift), - Primitive::ComponentSizeShift(type)); + Primitive::Type type = static_cast<Primitive::Type>(v32 & 0xFFFF); + DCHECK_EQ(static_cast<size_t>(v32 >> 16), Primitive::ComponentSizeShift(type)); return type; } @@ -647,9 +646,8 @@ inline size_t Class::GetPrimitiveTypeSizeShift() { static_assert(sizeof(Primitive::Type) == sizeof(int32_t), "art::Primitive::Type and int32_t have different sizes."); int32_t v32 = GetField32<kVerifyFlags>(OFFSET_OF_OBJECT_MEMBER(Class, primitive_type_)); - size_t size_shift = static_cast<Primitive::Type>(v32 >> kPrimitiveTypeSizeShiftShift); - DCHECK_EQ(size_shift, - Primitive::ComponentSizeShift(static_cast<Primitive::Type>(v32 & kPrimitiveTypeMask))); + size_t size_shift = static_cast<Primitive::Type>(v32 >> 16); + DCHECK_EQ(size_shift, Primitive::ComponentSizeShift(static_cast<Primitive::Type>(v32 & 0xFFFF))); return size_shift; } diff --git a/runtime/mirror/class.h b/runtime/mirror/class.h index 8f6ce44ff4..5c490dec3e 100644 --- a/runtime/mirror/class.h +++ b/runtime/mirror/class.h @@ -64,12 +64,6 @@ class MANAGED Class FINAL : public Object { // 2 ref instance fields.] static constexpr uint32_t kClassWalkSuper = 0xC0000000; - // Shift primitive type by kPrimitiveTypeSizeShiftShift to get the component type size shift - // Used for computing array size as follows: - // array_bytes = header_size + (elements << (primitive_type >> kPrimitiveTypeSizeShiftShift)) - static constexpr uint32_t kPrimitiveTypeSizeShiftShift = 16; - static constexpr uint32_t kPrimitiveTypeMask = (1u << kPrimitiveTypeSizeShiftShift) - 1; - // Class Status // // kStatusRetired: Class that's temporarily used till class linking time @@ -377,10 +371,10 @@ class MANAGED Class FINAL : public Object { void SetPrimitiveType(Primitive::Type new_type) SHARED_REQUIRES(Locks::mutator_lock_) { DCHECK_EQ(sizeof(Primitive::Type), sizeof(int32_t)); - uint32_t v32 = static_cast<uint32_t>(new_type); - DCHECK_EQ(v32 & kPrimitiveTypeMask, v32) << "upper 16 bits aren't zero"; + int32_t v32 = static_cast<int32_t>(new_type); + DCHECK_EQ(v32 & 0xFFFF, v32) << "upper 16 bits aren't zero"; // Store the component size shift in the upper 16 bits. - v32 |= Primitive::ComponentSizeShift(new_type) << kPrimitiveTypeSizeShiftShift; + v32 |= Primitive::ComponentSizeShift(new_type) << 16; SetField32<false>(OFFSET_OF_OBJECT_MEMBER(Class, primitive_type_), v32); } diff --git a/runtime/native_stack_dump.cc b/runtime/native_stack_dump.cc new file mode 100644 index 0000000000..8c5b386932 --- /dev/null +++ b/runtime/native_stack_dump.cc @@ -0,0 +1,264 @@ +/* + * Copyright (C) 2016 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "native_stack_dump.h" + +#include <ostream> + +#include <stdio.h> + +#include "art_method.h" + +// For DumpNativeStack. +#include <backtrace/Backtrace.h> +#include <backtrace/BacktraceMap.h> + +#if defined(__linux__) + +#include <memory> +#include <vector> + +#include <linux/unistd.h> +#include <signal.h> +#include <stdlib.h> +#include <sys/time.h> +#include <sys/types.h> + +#include "arch/instruction_set.h" +#include "base/memory_tool.h" +#include "base/mutex.h" +#include "base/stringprintf.h" +#include "oat_quick_method_header.h" +#include "thread-inl.h" +#include "utils.h" + +#endif + +namespace art { + +#if defined(__linux__) + +static constexpr bool kUseAddr2line = !kIsTargetBuild; + +ALWAYS_INLINE +static inline void WritePrefix(std::ostream* os, const char* prefix, bool odd) { + if (prefix != nullptr) { + *os << prefix; + } + *os << " "; + if (!odd) { + *os << " "; + } +} + +static bool RunCommand(std::string cmd, std::ostream* os, const char* prefix) { + FILE* stream = popen(cmd.c_str(), "r"); + if (stream) { + if (os != nullptr) { + bool odd_line = true; // We indent them differently. + bool wrote_prefix = false; // Have we already written a prefix? + constexpr size_t kMaxBuffer = 128; // Relatively small buffer. Should be OK as we're on an + // alt stack, but just to be sure... + char buffer[kMaxBuffer]; + while (!feof(stream)) { + if (fgets(buffer, kMaxBuffer, stream) != nullptr) { + // Split on newlines. + char* tmp = buffer; + for (;;) { + char* new_line = strchr(tmp, '\n'); + if (new_line == nullptr) { + // Print the rest. + if (*tmp != 0) { + if (!wrote_prefix) { + WritePrefix(os, prefix, odd_line); + } + wrote_prefix = true; + *os << tmp; + } + break; + } + if (!wrote_prefix) { + WritePrefix(os, prefix, odd_line); + } + char saved = *(new_line + 1); + *(new_line + 1) = 0; + *os << tmp; + *(new_line + 1) = saved; + tmp = new_line + 1; + odd_line = !odd_line; + wrote_prefix = false; + } + } + } + } + pclose(stream); + return true; + } else { + return false; + } +} + +static void Addr2line(const std::string& map_src, uintptr_t offset, std::ostream& os, + const char* prefix) { + std::string cmdline(StringPrintf("addr2line --functions --inlines --demangle -e %s %zx", + map_src.c_str(), offset)); + RunCommand(cmdline.c_str(), &os, prefix); +} + +static bool PcIsWithinQuickCode(ArtMethod* method, uintptr_t pc) NO_THREAD_SAFETY_ANALYSIS { + uintptr_t code = reinterpret_cast<uintptr_t>(EntryPointToCodePointer( + method->GetEntryPointFromQuickCompiledCode())); + if (code == 0) { + return pc == 0; + } + uintptr_t code_size = reinterpret_cast<const OatQuickMethodHeader*>(code)[-1].code_size_; + return code <= pc && pc <= (code + code_size); +} + +void DumpNativeStack(std::ostream& os, pid_t tid, BacktraceMap* existing_map, const char* prefix, + ArtMethod* current_method, void* ucontext_ptr) { + // b/18119146 + if (RUNNING_ON_MEMORY_TOOL != 0) { + return; + } + + BacktraceMap* map = existing_map; + std::unique_ptr<BacktraceMap> tmp_map; + if (map == nullptr) { + tmp_map.reset(BacktraceMap::Create(getpid())); + map = tmp_map.get(); + } + std::unique_ptr<Backtrace> backtrace(Backtrace::Create(BACKTRACE_CURRENT_PROCESS, tid, map)); + if (!backtrace->Unwind(0, reinterpret_cast<ucontext*>(ucontext_ptr))) { + os << prefix << "(backtrace::Unwind failed for thread " << tid + << ": " << backtrace->GetErrorString(backtrace->GetError()) << ")\n"; + return; + } else if (backtrace->NumFrames() == 0) { + os << prefix << "(no native stack frames for thread " << tid << ")\n"; + return; + } + + // Check whether we have and should use addr2line. + bool use_addr2line; + if (kUseAddr2line) { + // Try to run it to see whether we have it. Push an argument so that it doesn't assume a.out + // and print to stderr. + use_addr2line = (gAborting > 0) && RunCommand("addr2line -h", nullptr, nullptr); + } else { + use_addr2line = false; + } + + for (Backtrace::const_iterator it = backtrace->begin(); + it != backtrace->end(); ++it) { + // We produce output like this: + // ] #00 pc 000075bb8 /system/lib/libc.so (unwind_backtrace_thread+536) + // In order for parsing tools to continue to function, the stack dump + // format must at least adhere to this format: + // #XX pc <RELATIVE_ADDR> <FULL_PATH_TO_SHARED_LIBRARY> ... + // The parsers require a single space before and after pc, and two spaces + // after the <RELATIVE_ADDR>. There can be any prefix data before the + // #XX. <RELATIVE_ADDR> has to be a hex number but with no 0x prefix. + os << prefix << StringPrintf("#%02zu pc ", it->num); + bool try_addr2line = false; + if (!BacktraceMap::IsValid(it->map)) { + os << StringPrintf(Is64BitInstructionSet(kRuntimeISA) ? "%016" PRIxPTR " ???" + : "%08" PRIxPTR " ???", + it->pc); + } else { + os << StringPrintf(Is64BitInstructionSet(kRuntimeISA) ? "%016" PRIxPTR " " + : "%08" PRIxPTR " ", + BacktraceMap::GetRelativePc(it->map, it->pc)); + os << it->map.name; + os << " ("; + if (!it->func_name.empty()) { + os << it->func_name; + if (it->func_offset != 0) { + os << "+" << it->func_offset; + } + try_addr2line = true; + } else if (current_method != nullptr && + Locks::mutator_lock_->IsSharedHeld(Thread::Current()) && + PcIsWithinQuickCode(current_method, it->pc)) { + const void* start_of_code = current_method->GetEntryPointFromQuickCompiledCode(); + os << JniLongName(current_method) << "+" + << (it->pc - reinterpret_cast<uintptr_t>(start_of_code)); + } else { + os << "???"; + } + os << ")"; + } + os << "\n"; + if (try_addr2line && use_addr2line) { + Addr2line(it->map.name, it->pc - it->map.start, os, prefix); + } + } +} + +void DumpKernelStack(std::ostream& os, pid_t tid, const char* prefix, bool include_count) { + if (tid == GetTid()) { + // There's no point showing that we're reading our stack out of /proc! + return; + } + + std::string kernel_stack_filename(StringPrintf("/proc/self/task/%d/stack", tid)); + std::string kernel_stack; + if (!ReadFileToString(kernel_stack_filename, &kernel_stack)) { + os << prefix << "(couldn't read " << kernel_stack_filename << ")\n"; + return; + } + + std::vector<std::string> kernel_stack_frames; + Split(kernel_stack, '\n', &kernel_stack_frames); + // We skip the last stack frame because it's always equivalent to "[<ffffffff>] 0xffffffff", + // which looking at the source appears to be the kernel's way of saying "that's all, folks!". + kernel_stack_frames.pop_back(); + for (size_t i = 0; i < kernel_stack_frames.size(); ++i) { + // Turn "[<ffffffff8109156d>] futex_wait_queue_me+0xcd/0x110" + // into "futex_wait_queue_me+0xcd/0x110". + const char* text = kernel_stack_frames[i].c_str(); + const char* close_bracket = strchr(text, ']'); + if (close_bracket != nullptr) { + text = close_bracket + 2; + } + os << prefix; + if (include_count) { + os << StringPrintf("#%02zd ", i); + } + os << text << "\n"; + } +} + +#elif defined(__APPLE__) + +void DumpNativeStack(std::ostream& os ATTRIBUTE_UNUSED, + pid_t tid ATTRIBUTE_UNUSED, + BacktraceMap* existing_map ATTRIBUTE_UNUSED, + const char* prefix ATTRIBUTE_UNUSED, + ArtMethod* current_method ATTRIBUTE_UNUSED, + void* ucontext_ptr ATTRIBUTE_UNUSED) { +} + +void DumpKernelStack(std::ostream& os ATTRIBUTE_UNUSED, + pid_t tid ATTRIBUTE_UNUSED, + const char* prefix ATTRIBUTE_UNUSED, + bool include_count ATTRIBUTE_UNUSED) { +} + +#else +#error "Unsupported architecture for native stack dumps." +#endif + +} // namespace art diff --git a/runtime/native_stack_dump.h b/runtime/native_stack_dump.h new file mode 100644 index 0000000000..d64bc824a5 --- /dev/null +++ b/runtime/native_stack_dump.h @@ -0,0 +1,49 @@ +/* + * Copyright (C) 2016 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ART_RUNTIME_NATIVE_STACK_DUMP_H_ +#define ART_RUNTIME_NATIVE_STACK_DUMP_H_ + +#include <unistd.h> + +#include <iosfwd> + +#include "base/macros.h" + +class BacktraceMap; + +namespace art { + +class ArtMethod; + +// Dumps the native stack for thread 'tid' to 'os'. +void DumpNativeStack(std::ostream& os, + pid_t tid, + BacktraceMap* map = nullptr, + const char* prefix = "", + ArtMethod* current_method = nullptr, + void* ucontext = nullptr) + NO_THREAD_SAFETY_ANALYSIS; + +// Dumps the kernel stack for thread 'tid' to 'os'. Note that this is only available on linux-x86. +void DumpKernelStack(std::ostream& os, + pid_t tid, + const char* prefix = "", + bool include_count = true); + +} // namespace art + +#endif // ART_RUNTIME_NATIVE_STACK_DUMP_H_ diff --git a/runtime/runtime.cc b/runtime/runtime.cc index 9f0ef7c1d0..50bea658bc 100644 --- a/runtime/runtime.cc +++ b/runtime/runtime.cc @@ -115,6 +115,7 @@ #include "native/org_apache_harmony_dalvik_ddmc_DdmVmInternal.h" #include "native/sun_misc_Unsafe.h" #include "native_bridge_art_interface.h" +#include "native_stack_dump.h" #include "oat_file.h" #include "oat_file_manager.h" #include "os.h" diff --git a/runtime/runtime_linux.cc b/runtime/runtime_linux.cc index bc963c5b8c..60ebabc109 100644 --- a/runtime/runtime_linux.cc +++ b/runtime/runtime_linux.cc @@ -28,6 +28,7 @@ #include "base/macros.h" #include "base/mutex.h" #include "base/stringprintf.h" +#include "native_stack_dump.h" #include "thread-inl.h" #include "thread_list.h" #include "utils.h" diff --git a/runtime/thread.cc b/runtime/thread.cc index 76f316149b..7482d932a4 100644 --- a/runtime/thread.cc +++ b/runtime/thread.cc @@ -55,6 +55,7 @@ #include "mirror/object_array-inl.h" #include "mirror/stack_trace_element.h" #include "monitor.h" +#include "native_stack_dump.h" #include "nth_caller_visitor.h" #include "oat_quick_method_header.h" #include "object_lock.h" diff --git a/runtime/thread_list.cc b/runtime/thread_list.cc index 16ef0fff22..419ecec696 100644 --- a/runtime/thread_list.cc +++ b/runtime/thread_list.cc @@ -35,6 +35,7 @@ #include "jni_internal.h" #include "lock_word.h" #include "monitor.h" +#include "native_stack_dump.h" #include "scoped_thread_state_change.h" #include "thread.h" #include "trace.h" diff --git a/runtime/utils.cc b/runtime/utils.cc index 3f779df15a..515ba9f9e3 100644 --- a/runtime/utils.cc +++ b/runtime/utils.cc @@ -46,20 +46,12 @@ #include <sys/syscall.h> #endif -// For DumpNativeStack. -#include <backtrace/Backtrace.h> -#include <backtrace/BacktraceMap.h> - #if defined(__linux__) #include <linux/unistd.h> #endif namespace art { -#if defined(__linux__) -static constexpr bool kUseAddr2line = !kIsTargetBuild; -#endif - pid_t GetTid() { #if defined(__APPLE__) uint64_t owner; @@ -1026,210 +1018,6 @@ std::string GetSchedulerGroupName(pid_t tid) { return ""; } -#if defined(__linux__) - -ALWAYS_INLINE -static inline void WritePrefix(std::ostream* os, const char* prefix, bool odd) { - if (prefix != nullptr) { - *os << prefix; - } - *os << " "; - if (!odd) { - *os << " "; - } -} - -static bool RunCommand(std::string cmd, std::ostream* os, const char* prefix) { - FILE* stream = popen(cmd.c_str(), "r"); - if (stream) { - if (os != nullptr) { - bool odd_line = true; // We indent them differently. - bool wrote_prefix = false; // Have we already written a prefix? - constexpr size_t kMaxBuffer = 128; // Relatively small buffer. Should be OK as we're on an - // alt stack, but just to be sure... - char buffer[kMaxBuffer]; - while (!feof(stream)) { - if (fgets(buffer, kMaxBuffer, stream) != nullptr) { - // Split on newlines. - char* tmp = buffer; - for (;;) { - char* new_line = strchr(tmp, '\n'); - if (new_line == nullptr) { - // Print the rest. - if (*tmp != 0) { - if (!wrote_prefix) { - WritePrefix(os, prefix, odd_line); - } - wrote_prefix = true; - *os << tmp; - } - break; - } - if (!wrote_prefix) { - WritePrefix(os, prefix, odd_line); - } - char saved = *(new_line + 1); - *(new_line + 1) = 0; - *os << tmp; - *(new_line + 1) = saved; - tmp = new_line + 1; - odd_line = !odd_line; - wrote_prefix = false; - } - } - } - } - pclose(stream); - return true; - } else { - return false; - } -} - -static void Addr2line(const std::string& map_src, uintptr_t offset, std::ostream& os, - const char* prefix) { - std::string cmdline(StringPrintf("addr2line --functions --inlines --demangle -e %s %zx", - map_src.c_str(), offset)); - RunCommand(cmdline.c_str(), &os, prefix); -} - -static bool PcIsWithinQuickCode(ArtMethod* method, uintptr_t pc) NO_THREAD_SAFETY_ANALYSIS { - uintptr_t code = reinterpret_cast<uintptr_t>(EntryPointToCodePointer( - method->GetEntryPointFromQuickCompiledCode())); - if (code == 0) { - return pc == 0; - } - uintptr_t code_size = reinterpret_cast<const OatQuickMethodHeader*>(code)[-1].code_size_; - return code <= pc && pc <= (code + code_size); -} -#endif - -void DumpNativeStack(std::ostream& os, pid_t tid, BacktraceMap* existing_map, const char* prefix, - ArtMethod* current_method, void* ucontext_ptr) { -#if __linux__ - // b/18119146 - if (RUNNING_ON_MEMORY_TOOL != 0) { - return; - } - - BacktraceMap* map = existing_map; - std::unique_ptr<BacktraceMap> tmp_map; - if (map == nullptr) { - tmp_map.reset(BacktraceMap::Create(getpid())); - map = tmp_map.get(); - } - std::unique_ptr<Backtrace> backtrace(Backtrace::Create(BACKTRACE_CURRENT_PROCESS, tid, map)); - if (!backtrace->Unwind(0, reinterpret_cast<ucontext*>(ucontext_ptr))) { - os << prefix << "(backtrace::Unwind failed for thread " << tid - << ": " << backtrace->GetErrorString(backtrace->GetError()) << ")\n"; - return; - } else if (backtrace->NumFrames() == 0) { - os << prefix << "(no native stack frames for thread " << tid << ")\n"; - return; - } - - // Check whether we have and should use addr2line. - bool use_addr2line; - if (kUseAddr2line) { - // Try to run it to see whether we have it. Push an argument so that it doesn't assume a.out - // and print to stderr. - use_addr2line = (gAborting > 0) && RunCommand("addr2line -h", nullptr, nullptr); - } else { - use_addr2line = false; - } - - for (Backtrace::const_iterator it = backtrace->begin(); - it != backtrace->end(); ++it) { - // We produce output like this: - // ] #00 pc 000075bb8 /system/lib/libc.so (unwind_backtrace_thread+536) - // In order for parsing tools to continue to function, the stack dump - // format must at least adhere to this format: - // #XX pc <RELATIVE_ADDR> <FULL_PATH_TO_SHARED_LIBRARY> ... - // The parsers require a single space before and after pc, and two spaces - // after the <RELATIVE_ADDR>. There can be any prefix data before the - // #XX. <RELATIVE_ADDR> has to be a hex number but with no 0x prefix. - os << prefix << StringPrintf("#%02zu pc ", it->num); - bool try_addr2line = false; - if (!BacktraceMap::IsValid(it->map)) { - os << StringPrintf(Is64BitInstructionSet(kRuntimeISA) ? "%016" PRIxPTR " ???" - : "%08" PRIxPTR " ???", - it->pc); - } else { - os << StringPrintf(Is64BitInstructionSet(kRuntimeISA) ? "%016" PRIxPTR " " - : "%08" PRIxPTR " ", - BacktraceMap::GetRelativePc(it->map, it->pc)); - os << it->map.name; - os << " ("; - if (!it->func_name.empty()) { - os << it->func_name; - if (it->func_offset != 0) { - os << "+" << it->func_offset; - } - try_addr2line = true; - } else if (current_method != nullptr && - Locks::mutator_lock_->IsSharedHeld(Thread::Current()) && - PcIsWithinQuickCode(current_method, it->pc)) { - const void* start_of_code = current_method->GetEntryPointFromQuickCompiledCode(); - os << JniLongName(current_method) << "+" - << (it->pc - reinterpret_cast<uintptr_t>(start_of_code)); - } else { - os << "???"; - } - os << ")"; - } - os << "\n"; - if (try_addr2line && use_addr2line) { - Addr2line(it->map.name, it->pc - it->map.start, os, prefix); - } - } -#else - UNUSED(os, tid, existing_map, prefix, current_method, ucontext_ptr); -#endif -} - -#if defined(__APPLE__) - -// TODO: is there any way to get the kernel stack on Mac OS? -void DumpKernelStack(std::ostream&, pid_t, const char*, bool) {} - -#else - -void DumpKernelStack(std::ostream& os, pid_t tid, const char* prefix, bool include_count) { - if (tid == GetTid()) { - // There's no point showing that we're reading our stack out of /proc! - return; - } - - std::string kernel_stack_filename(StringPrintf("/proc/self/task/%d/stack", tid)); - std::string kernel_stack; - if (!ReadFileToString(kernel_stack_filename, &kernel_stack)) { - os << prefix << "(couldn't read " << kernel_stack_filename << ")\n"; - return; - } - - std::vector<std::string> kernel_stack_frames; - Split(kernel_stack, '\n', &kernel_stack_frames); - // We skip the last stack frame because it's always equivalent to "[<ffffffff>] 0xffffffff", - // which looking at the source appears to be the kernel's way of saying "that's all, folks!". - kernel_stack_frames.pop_back(); - for (size_t i = 0; i < kernel_stack_frames.size(); ++i) { - // Turn "[<ffffffff8109156d>] futex_wait_queue_me+0xcd/0x110" - // into "futex_wait_queue_me+0xcd/0x110". - const char* text = kernel_stack_frames[i].c_str(); - const char* close_bracket = strchr(text, ']'); - if (close_bracket != nullptr) { - text = close_bracket + 2; - } - os << prefix; - if (include_count) { - os << StringPrintf("#%02zd ", i); - } - os << text << "\n"; - } -} - -#endif - const char* GetAndroidRoot() { const char* android_root = getenv("ANDROID_ROOT"); if (android_root == nullptr) { diff --git a/runtime/utils.h b/runtime/utils.h index b2746ee1eb..699b732522 100644 --- a/runtime/utils.h +++ b/runtime/utils.h @@ -242,21 +242,6 @@ std::string GetSchedulerGroupName(pid_t tid); // implementation-defined limit. void SetThreadName(const char* thread_name); -// Dumps the native stack for thread 'tid' to 'os'. -void DumpNativeStack(std::ostream& os, - pid_t tid, - BacktraceMap* map = nullptr, - const char* prefix = "", - ArtMethod* current_method = nullptr, - void* ucontext = nullptr) - NO_THREAD_SAFETY_ANALYSIS; - -// Dumps the kernel stack for thread 'tid' to 'os'. Note that this is only available on linux-x86. -void DumpKernelStack(std::ostream& os, - pid_t tid, - const char* prefix = "", - bool include_count = true); - // Find $ANDROID_ROOT, /system, or abort. const char* GetAndroidRoot(); 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) { diff --git a/test/Android.run-test.mk b/test/Android.run-test.mk index 8d7d70dcbe..2d777226de 100644 --- a/test/Android.run-test.mk +++ b/test/Android.run-test.mk @@ -535,13 +535,10 @@ TEST_ART_BROKEN_INTERPRETER_READ_BARRIER_RUN_TESTS := # Tests that should fail in the read barrier configuration with the Optimizing compiler (AOT). # 484: Baker's fast path based read barrier compiler instrumentation generates code containing # more parallel moves on x86, thus some Checker assertions may fail. -# 527: On ARM64 and ARM, the read barrier instrumentation does not support the HIntermediateAddress -# instruction yet (b/26601270). # 537: Expects an array copy to be intrinsified on x86-64, but calling-on-slowpath intrinsics are # not yet handled in the read barrier configuration. TEST_ART_BROKEN_OPTIMIZING_READ_BARRIER_RUN_TESTS := \ 484-checker-register-hints \ - 527-checker-array-access-split \ 537-checker-arraycopy # Tests that should fail in the read barrier configuration with JIT (Optimizing compiler). diff --git a/tools/ahat/Android.mk b/tools/ahat/Android.mk index 834426d3f6..60e0cd8ec8 100644 --- a/tools/ahat/Android.mk +++ b/tools/ahat/Android.mk @@ -30,6 +30,10 @@ LOCAL_STATIC_JAVA_LIBRARIES := perflib-prebuilt guavalib trove-prebuilt LOCAL_IS_HOST_MODULE := true LOCAL_MODULE_TAGS := optional LOCAL_MODULE := ahat + +# Let users with Java 7 run ahat (b/28303627) +LOCAL_JAVA_LANGUAGE_VERSION := 1.7 + include $(BUILD_HOST_JAVA_LIBRARY) # --- ahat script ---------------- diff --git a/tools/ahat/src/AhatSnapshot.java b/tools/ahat/src/AhatSnapshot.java index e6f8411c90..a8205c7f1a 100644 --- a/tools/ahat/src/AhatSnapshot.java +++ b/tools/ahat/src/AhatSnapshot.java @@ -86,7 +86,7 @@ class AhatSnapshot { mSnapshot = snapshot; mHeaps = new ArrayList<Heap>(mSnapshot.getHeaps()); - ClassObj javaLangClass = mSnapshot.findClass("java.lang.Class"); + final ClassObj javaLangClass = mSnapshot.findClass("java.lang.Class"); for (Heap heap : mHeaps) { // Use a single element array for the total to act as a reference to a // long. diff --git a/tools/buildbot-build.sh b/tools/buildbot-build.sh index d88a4a027e..12e03386d6 100755 --- a/tools/buildbot-build.sh +++ b/tools/buildbot-build.sh @@ -21,7 +21,7 @@ fi out_dir=${OUT_DIR-out} java_libraries_dir=${out_dir}/target/common/obj/JAVA_LIBRARIES -common_targets="vogar core-tests apache-harmony-jdwp-tests-hostdex jsr166-tests ${out_dir}/host/linux-x86/bin/jack" +common_targets="vogar core-tests apache-harmony-jdwp-tests-hostdex jsr166-tests mockito-target ${out_dir}/host/linux-x86/bin/jack" mode="target" j_arg="-j$(nproc)" showcommands= diff --git a/tools/libcore_failures.txt b/tools/libcore_failures.txt index 8d87e4fafe..e5d75975f6 100644 --- a/tools/libcore_failures.txt +++ b/tools/libcore_failures.txt @@ -180,12 +180,6 @@ bug: 25437292 }, { - description: "Failing tests after OpenJDK move.", - result: EXEC_FAILED, - bug: 26326992, - names: ["libcore.java.lang.OldSystemTest#test_load"] -}, -{ description: "Missing resource in classpath", result: EXEC_FAILED, modes: [device], diff --git a/tools/run-libcore-tests.sh b/tools/run-libcore-tests.sh index 3605aa0294..2a6e172c69 100755 --- a/tools/run-libcore-tests.sh +++ b/tools/run-libcore-tests.sh @@ -25,17 +25,22 @@ else JAVA_LIBRARIES=${ANDROID_PRODUCT_OUT}/../../common/obj/JAVA_LIBRARIES fi -# Jar containing jsr166 tests. -jsr166_test_jack=${JAVA_LIBRARIES}/jsr166-tests_intermediates/classes.jack +function cparg { + for var + do + printf -- "--classpath ${JAVA_LIBRARIES}/${var}_intermediates/classes.jack "; + done +} -# Jar containing all the other tests. -test_jack=${JAVA_LIBRARIES}/core-tests_intermediates/classes.jack +DEPS="core-tests jsr166-tests mockito-target" -if [ ! -f $test_jack ]; then - echo "Before running, you must build core-tests, jsr166-tests and vogar: \ - make core-tests jsr166-tests vogar" - exit 1 -fi +for lib in $DEPS +do + if [ ! -f "${JAVA_LIBRARIES}/${lib}_intermediates/classes.jack" ]; then + echo "${lib} is missing. Before running, you must run art/tools/buildbot-build.sh" + exit 1 + fi +done expectations="--expectations art/tools/libcore_failures.txt" if [ "x$ART_USE_READ_BARRIER" = xtrue ]; then @@ -133,4 +138,4 @@ vogar_args="$vogar_args --vm-arg -Xusejit:$use_jit" # Run the tests using vogar. echo "Running tests for the following test packages:" echo ${working_packages[@]} | tr " " "\n" -vogar $vogar_args $expectations --classpath $jsr166_test_jack --classpath $test_jack ${working_packages[@]} +vogar $vogar_args $expectations $(cparg $DEPS) ${working_packages[@]} |