diff options
author | Vladimir Marko <vmarko@google.com> | 2014-03-12 15:42:41 +0000 |
---|---|---|
committer | Vladimir Marko <vmarko@google.com> | 2014-03-12 17:59:23 +0000 |
commit | e3e0260c23d8999b9433715ac7ee5296ee2fd633 (patch) | |
tree | 8f13f12f929e36d9366583934ebb4a20b4ce09b7 /runtime/quick | |
parent | ca46e2003360b44f4c043f6da87092592bc3d6d6 (diff) | |
download | art-e3e0260c23d8999b9433715ac7ee5296ee2fd633.tar.gz art-e3e0260c23d8999b9433715ac7ee5296ee2fd633.tar.bz2 art-e3e0260c23d8999b9433715ac7ee5296ee2fd633.zip |
Move inline method detection to runtime.
The debugger needs this for selective deoptimization.
Change-Id: I8100000449b56e619288fb05d41ea6f02b53b334
Diffstat (limited to 'runtime/quick')
-rw-r--r-- | runtime/quick/inline_method_analyser.cc | 303 | ||||
-rw-r--r-- | runtime/quick/inline_method_analyser.h | 177 |
2 files changed, 480 insertions, 0 deletions
diff --git a/runtime/quick/inline_method_analyser.cc b/runtime/quick/inline_method_analyser.cc new file mode 100644 index 0000000000..4388d31698 --- /dev/null +++ b/runtime/quick/inline_method_analyser.cc @@ -0,0 +1,303 @@ +/* + * Copyright (C) 2014 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 "inline_method_analyser.h" +#include "dex_instruction.h" +#include "dex_instruction-inl.h" +#include "mirror/art_field.h" +#include "mirror/art_field-inl.h" +#include "mirror/art_method.h" +#include "mirror/art_method-inl.h" +#include "mirror/class.h" +#include "mirror/class-inl.h" +#include "mirror/dex_cache.h" +#include "mirror/dex_cache-inl.h" +#include "verifier/method_verifier.h" +#include "verifier/method_verifier-inl.h" + +/* + * NOTE: This code is part of the quick compiler. It lives in the runtime + * only to allow the debugger to check whether a method has been inlined. + */ + +namespace art { + +COMPILE_ASSERT(InlineMethodAnalyser::IsInstructionIGet(Instruction::IGET), + check_iget_type); +COMPILE_ASSERT(InlineMethodAnalyser::IsInstructionIGet(Instruction::IGET_WIDE), + check_iget_wide_type); +COMPILE_ASSERT(InlineMethodAnalyser::IsInstructionIGet(Instruction::IGET_OBJECT), + check_iget_object_type); +COMPILE_ASSERT(InlineMethodAnalyser::IsInstructionIGet(Instruction::IGET_BOOLEAN), + check_iget_boolean_type); +COMPILE_ASSERT(InlineMethodAnalyser::IsInstructionIGet(Instruction::IGET_BYTE), + check_iget_byte_type); +COMPILE_ASSERT(InlineMethodAnalyser::IsInstructionIGet(Instruction::IGET_CHAR), + check_iget_char_type); +COMPILE_ASSERT(InlineMethodAnalyser::IsInstructionIGet(Instruction::IGET_SHORT), + check_iget_short_type); + +COMPILE_ASSERT(InlineMethodAnalyser::IsInstructionIPut(Instruction::IPUT), + check_iput_type); +COMPILE_ASSERT(InlineMethodAnalyser::IsInstructionIPut(Instruction::IPUT_WIDE), + check_iput_wide_type); +COMPILE_ASSERT(InlineMethodAnalyser::IsInstructionIPut(Instruction::IPUT_OBJECT), + check_iput_object_type); +COMPILE_ASSERT(InlineMethodAnalyser::IsInstructionIPut(Instruction::IPUT_BOOLEAN), + check_iput_boolean_type); +COMPILE_ASSERT(InlineMethodAnalyser::IsInstructionIPut(Instruction::IPUT_BYTE), + check_iput_byte_type); +COMPILE_ASSERT(InlineMethodAnalyser::IsInstructionIPut(Instruction::IPUT_CHAR), + check_iput_char_type); +COMPILE_ASSERT(InlineMethodAnalyser::IsInstructionIPut(Instruction::IPUT_SHORT), + check_iput_short_type); + +COMPILE_ASSERT(InlineMethodAnalyser::IGetVariant(Instruction::IGET) == + InlineMethodAnalyser::IPutVariant(Instruction::IPUT), check_iget_iput_variant); +COMPILE_ASSERT(InlineMethodAnalyser::IGetVariant(Instruction::IGET_WIDE) == + InlineMethodAnalyser::IPutVariant(Instruction::IPUT_WIDE), check_iget_iput_wide_variant); +COMPILE_ASSERT(InlineMethodAnalyser::IGetVariant(Instruction::IGET_OBJECT) == + InlineMethodAnalyser::IPutVariant(Instruction::IPUT_OBJECT), check_iget_iput_object_variant); +COMPILE_ASSERT(InlineMethodAnalyser::IGetVariant(Instruction::IGET_BOOLEAN) == + InlineMethodAnalyser::IPutVariant(Instruction::IPUT_BOOLEAN), check_iget_iput_boolean_variant); +COMPILE_ASSERT(InlineMethodAnalyser::IGetVariant(Instruction::IGET_BYTE) == + InlineMethodAnalyser::IPutVariant(Instruction::IPUT_BYTE), check_iget_iput_byte_variant); +COMPILE_ASSERT(InlineMethodAnalyser::IGetVariant(Instruction::IGET_CHAR) == + InlineMethodAnalyser::IPutVariant(Instruction::IPUT_CHAR), check_iget_iput_char_variant); +COMPILE_ASSERT(InlineMethodAnalyser::IGetVariant(Instruction::IGET_SHORT) == + InlineMethodAnalyser::IPutVariant(Instruction::IPUT_SHORT), check_iget_iput_short_variant); + +bool InlineMethodAnalyser::AnalyseMethodCode(verifier::MethodVerifier* verifier, + InlineMethod* method) { + // We currently support only plain return or 2-instruction methods. + + const DexFile::CodeItem* code_item = verifier->CodeItem(); + DCHECK_NE(code_item->insns_size_in_code_units_, 0u); + const Instruction* instruction = Instruction::At(code_item->insns_); + Instruction::Code opcode = instruction->Opcode(); + + switch (opcode) { + case Instruction::RETURN_VOID: + method->opcode = kInlineOpNop; + method->flags = kInlineSpecial; + method->d.data = 0u; + return true; + case Instruction::RETURN: + case Instruction::RETURN_OBJECT: + case Instruction::RETURN_WIDE: + return AnalyseReturnMethod(code_item, method); + case Instruction::CONST: + case Instruction::CONST_4: + case Instruction::CONST_16: + case Instruction::CONST_HIGH16: + // TODO: Support wide constants (RETURN_WIDE). + return AnalyseConstMethod(code_item, method); + case Instruction::IGET: + case Instruction::IGET_OBJECT: + case Instruction::IGET_BOOLEAN: + case Instruction::IGET_BYTE: + case Instruction::IGET_CHAR: + case Instruction::IGET_SHORT: + case Instruction::IGET_WIDE: + return AnalyseIGetMethod(verifier, method); + case Instruction::IPUT: + case Instruction::IPUT_OBJECT: + case Instruction::IPUT_BOOLEAN: + case Instruction::IPUT_BYTE: + case Instruction::IPUT_CHAR: + case Instruction::IPUT_SHORT: + case Instruction::IPUT_WIDE: + return AnalyseIPutMethod(verifier, method); + default: + return false; + } +} + +bool InlineMethodAnalyser::AnalyseReturnMethod(const DexFile::CodeItem* code_item, + InlineMethod* result) { + const Instruction* return_instruction = Instruction::At(code_item->insns_); + Instruction::Code return_opcode = return_instruction->Opcode(); + uint32_t reg = return_instruction->VRegA_11x(); + uint32_t arg_start = code_item->registers_size_ - code_item->ins_size_; + DCHECK_GE(reg, arg_start); + DCHECK_LT((return_opcode == Instruction::RETURN_WIDE) ? reg + 1 : reg, + code_item->registers_size_); + + result->opcode = kInlineOpReturnArg; + result->flags = kInlineSpecial; + InlineReturnArgData* data = &result->d.return_data; + data->arg = reg - arg_start; + data->is_wide = (return_opcode == Instruction::RETURN_WIDE) ? 1u : 0u; + data->is_object = (return_opcode == Instruction::RETURN_OBJECT) ? 1u : 0u; + data->reserved = 0u; + data->reserved2 = 0u; + return true; +} + +bool InlineMethodAnalyser::AnalyseConstMethod(const DexFile::CodeItem* code_item, + InlineMethod* result) { + const Instruction* instruction = Instruction::At(code_item->insns_); + const Instruction* return_instruction = instruction->Next(); + Instruction::Code return_opcode = return_instruction->Opcode(); + if (return_opcode != Instruction::RETURN && + return_opcode != Instruction::RETURN_OBJECT) { + return false; + } + + uint32_t return_reg = return_instruction->VRegA_11x(); + DCHECK_LT(return_reg, code_item->registers_size_); + + uint32_t vA, vB, dummy; + uint64_t dummy_wide; + instruction->Decode(vA, vB, dummy_wide, dummy, nullptr); + if (instruction->Opcode() == Instruction::CONST_HIGH16) { + vB <<= 16; + } + DCHECK_LT(vA, code_item->registers_size_); + if (vA != return_reg) { + return false; // Not returning the value set by const? + } + if (return_opcode == Instruction::RETURN_OBJECT && vB != 0) { + return false; // Returning non-null reference constant? + } + result->opcode = kInlineOpNonWideConst; + result->flags = kInlineSpecial; + result->d.data = static_cast<uint64_t>(vB); + return true; +} + +bool InlineMethodAnalyser::AnalyseIGetMethod(verifier::MethodVerifier* verifier, + InlineMethod* result) { + const DexFile::CodeItem* code_item = verifier->CodeItem(); + const Instruction* instruction = Instruction::At(code_item->insns_); + Instruction::Code opcode = instruction->Opcode(); + DCHECK(IsInstructionIGet(opcode)); + + const Instruction* return_instruction = instruction->Next(); + Instruction::Code return_opcode = return_instruction->Opcode(); + if (!(return_opcode == Instruction::RETURN_WIDE && opcode == Instruction::IGET_WIDE) && + !(return_opcode == Instruction::RETURN_OBJECT && opcode == Instruction::IGET_OBJECT) && + !(return_opcode == Instruction::RETURN && opcode != Instruction::IGET_WIDE && + opcode != Instruction::IGET_OBJECT)) { + return false; + } + + uint32_t return_reg = return_instruction->VRegA_11x(); + DCHECK_LT(return_opcode == Instruction::RETURN_WIDE ? return_reg + 1 : return_reg, + code_item->registers_size_); + + uint32_t dst_reg = instruction->VRegA_22c(); + uint32_t object_reg = instruction->VRegB_22c(); + uint32_t field_idx = instruction->VRegC_22c(); + uint32_t arg_start = code_item->registers_size_ - code_item->ins_size_; + DCHECK_GE(object_reg, arg_start); + DCHECK_LT(object_reg, code_item->registers_size_); + DCHECK_LT(opcode == Instruction::IGET_WIDE ? dst_reg + 1 : dst_reg, code_item->registers_size_); + if (dst_reg != return_reg) { + return false; // Not returning the value retrieved by IGET? + } + + if ((verifier->GetAccessFlags() & kAccStatic) != 0 || object_reg != arg_start) { + // TODO: Support inlining IGET on other register than "this". + return false; + } + + if (!ComputeSpecialAccessorInfo(field_idx, false, verifier, &result->d.ifield_data)) { + return false; + } + + result->opcode = kInlineOpIGet; + result->flags = kInlineSpecial; + InlineIGetIPutData* data = &result->d.ifield_data; + data->op_variant = IGetVariant(opcode); + data->object_arg = object_reg - arg_start; // Allow IGET on any register, not just "this". + data->src_arg = 0; + data->method_is_static = (verifier->GetAccessFlags() & kAccStatic) != 0; + data->reserved = 0; + return true; +} + +bool InlineMethodAnalyser::AnalyseIPutMethod(verifier::MethodVerifier* verifier, + InlineMethod* result) { + const DexFile::CodeItem* code_item = verifier->CodeItem(); + const Instruction* instruction = Instruction::At(code_item->insns_); + Instruction::Code opcode = instruction->Opcode(); + DCHECK(IsInstructionIPut(opcode)); + + const Instruction* return_instruction = instruction->Next(); + Instruction::Code return_opcode = return_instruction->Opcode(); + if (return_opcode != Instruction::RETURN_VOID) { + // TODO: Support returning an argument. + // This is needed by builder classes and generated accessor setters. + // builder.setX(value): iput value, this, fieldX; return-object this; + // object.access$nnn(value): iput value, this, fieldX; return value; + // Use InlineIGetIPutData::reserved to hold the information. + return false; + } + + uint32_t src_reg = instruction->VRegA_22c(); + uint32_t object_reg = instruction->VRegB_22c(); + uint32_t field_idx = instruction->VRegC_22c(); + uint32_t arg_start = code_item->registers_size_ - code_item->ins_size_; + DCHECK_GE(object_reg, arg_start); + DCHECK_LT(object_reg, code_item->registers_size_); + DCHECK_GE(src_reg, arg_start); + DCHECK_LT(opcode == Instruction::IPUT_WIDE ? src_reg + 1 : src_reg, code_item->registers_size_); + + if ((verifier->GetAccessFlags() & kAccStatic) != 0 || object_reg != arg_start) { + // TODO: Support inlining IPUT on other register than "this". + return false; + } + + if (!ComputeSpecialAccessorInfo(field_idx, true, verifier, &result->d.ifield_data)) { + return false; + } + + result->opcode = kInlineOpIPut; + result->flags = kInlineSpecial; + InlineIGetIPutData* data = &result->d.ifield_data; + data->op_variant = IPutVariant(opcode); + data->object_arg = object_reg - arg_start; // Allow IPUT on any register, not just "this". + data->src_arg = src_reg - arg_start; + data->method_is_static = (verifier->GetAccessFlags() & kAccStatic) != 0; + data->reserved = 0; + return true; +} + +bool InlineMethodAnalyser::ComputeSpecialAccessorInfo(uint32_t field_idx, bool is_put, + verifier::MethodVerifier* verifier, + InlineIGetIPutData* result) { + mirror::DexCache* dex_cache = verifier->GetDexCache(); + uint32_t method_idx = verifier->GetMethodReference().dex_method_index; + mirror::ArtMethod* method = dex_cache->GetResolvedMethod(method_idx); + mirror::ArtField* field = dex_cache->GetResolvedField(field_idx); + if (method == nullptr || field == nullptr || field->IsStatic()) { + return false; + } + mirror::Class* method_class = method->GetDeclaringClass(); + mirror::Class* field_class = field->GetDeclaringClass(); + if (!method_class->CanAccessResolvedField(field_class, field, dex_cache, field_idx) || + (is_put && field->IsFinal() && method_class != field_class)) { + return false; + } + DCHECK_GE(field->GetOffset().Int32Value(), 0); + result->field_idx = field_idx; + result->field_offset = field->GetOffset().Int32Value(); + result->is_volatile = field->IsVolatile(); + return true; +} + +} // namespace art diff --git a/runtime/quick/inline_method_analyser.h b/runtime/quick/inline_method_analyser.h new file mode 100644 index 0000000000..8e1a4083cd --- /dev/null +++ b/runtime/quick/inline_method_analyser.h @@ -0,0 +1,177 @@ +/* + * Copyright (C) 2014 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_QUICK_INLINE_METHOD_ANALYSER_H_ +#define ART_RUNTIME_QUICK_INLINE_METHOD_ANALYSER_H_ + +#include "base/macros.h" +#include "base/mutex.h" +#include "dex_file.h" +#include "dex_instruction.h" + +/* + * NOTE: This code is part of the quick compiler. It lives in the runtime + * only to allow the debugger to check whether a method has been inlined. + */ + +namespace art { + +namespace verifier { +class MethodVerifier; +} // namespace verifier + +enum InlineMethodOpcode : uint16_t { + kIntrinsicDoubleCvt, + kIntrinsicFloatCvt, + kIntrinsicReverseBytes, + kIntrinsicAbsInt, + kIntrinsicAbsLong, + kIntrinsicAbsFloat, + kIntrinsicAbsDouble, + kIntrinsicMinMaxInt, + kIntrinsicSqrt, + kIntrinsicCharAt, + kIntrinsicCompareTo, + kIntrinsicIsEmptyOrLength, + kIntrinsicIndexOf, + kIntrinsicCurrentThread, + kIntrinsicPeek, + kIntrinsicPoke, + kIntrinsicCas, + kIntrinsicUnsafeGet, + kIntrinsicUnsafePut, + + kInlineOpNop, + kInlineOpReturnArg, + kInlineOpNonWideConst, + kInlineOpIGet, + kInlineOpIPut, +}; +std::ostream& operator<<(std::ostream& os, const InlineMethodOpcode& rhs); + +enum InlineMethodFlags : uint16_t { + kNoInlineMethodFlags = 0x0000, + kInlineIntrinsic = 0x0001, + kInlineSpecial = 0x0002, +}; + +// IntrinsicFlags are stored in InlineMethod::d::raw_data +enum IntrinsicFlags { + kIntrinsicFlagNone = 0, + + // kIntrinsicMinMaxInt + kIntrinsicFlagMax = kIntrinsicFlagNone, + kIntrinsicFlagMin = 1, + + // kIntrinsicIsEmptyOrLength + kIntrinsicFlagLength = kIntrinsicFlagNone, + kIntrinsicFlagIsEmpty = kIntrinsicFlagMin, + + // kIntrinsicIndexOf + kIntrinsicFlagBase0 = kIntrinsicFlagMin, + + // kIntrinsicUnsafeGet, kIntrinsicUnsafePut, kIntrinsicUnsafeCas + kIntrinsicFlagIsLong = kIntrinsicFlagMin, + // kIntrinsicUnsafeGet, kIntrinsicUnsafePut + kIntrinsicFlagIsVolatile = 2, + // kIntrinsicUnsafePut, kIntrinsicUnsafeCas + kIntrinsicFlagIsObject = 4, + // kIntrinsicUnsafePut + kIntrinsicFlagIsOrdered = 8, +}; + +struct InlineIGetIPutData { + // The op_variant below is opcode-Instruction::IGET for IGETs and + // opcode-Instruction::IPUT for IPUTs. This is because the runtime + // doesn't know the OpSize enumeration. + uint16_t op_variant : 3; + uint16_t object_arg : 4; + uint16_t src_arg : 4; // iput only + uint16_t method_is_static : 1; + uint16_t reserved : 4; + uint16_t field_idx; + uint32_t is_volatile : 1; + uint32_t field_offset : 31; +}; +COMPILE_ASSERT(sizeof(InlineIGetIPutData) == sizeof(uint64_t), InvalidSizeOfInlineIGetIPutData); + +struct InlineReturnArgData { + uint16_t arg; + uint16_t is_wide : 1; + uint16_t is_object : 1; + uint16_t reserved : 14; + uint32_t reserved2; +}; +COMPILE_ASSERT(sizeof(InlineReturnArgData) == sizeof(uint64_t), InvalidSizeOfInlineReturnArgData); + +struct InlineMethod { + InlineMethodOpcode opcode; + InlineMethodFlags flags; + union { + uint64_t data; + InlineIGetIPutData ifield_data; + InlineReturnArgData return_data; + } d; +}; + +class InlineMethodAnalyser { + public: + /** + * Analyse method code to determine if the method is a candidate for inlining. + * If it is, record the inlining data. + * + * @param verifier the method verifier holding data about the method to analyse. + * @param method placeholder for the inline method data. + * @return true if the method is a candidate for inlining, false otherwise. + */ + static bool AnalyseMethodCode(verifier::MethodVerifier* verifier, InlineMethod* method) + SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); + + static constexpr bool IsInstructionIGet(Instruction::Code opcode) { + return Instruction::IGET <= opcode && opcode <= Instruction::IGET_SHORT; + } + + static constexpr bool IsInstructionIPut(Instruction::Code opcode) { + return Instruction::IPUT <= opcode && opcode <= Instruction::IPUT_SHORT; + } + + static constexpr uint16_t IGetVariant(Instruction::Code opcode) { + return opcode - Instruction::IGET; + } + + static constexpr uint16_t IPutVariant(Instruction::Code opcode) { + return opcode - Instruction::IPUT; + } + + private: + static bool AnalyseReturnMethod(const DexFile::CodeItem* code_item, InlineMethod* result); + static bool AnalyseConstMethod(const DexFile::CodeItem* code_item, InlineMethod* result); + static bool AnalyseIGetMethod(verifier::MethodVerifier* verifier, InlineMethod* result) + SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); + static bool AnalyseIPutMethod(verifier::MethodVerifier* verifier, InlineMethod* result) + SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); + + // Can we fast path instance field access in a verified accessor? + // If yes, computes field's offset and volatility and whether the method is static or not. + static bool ComputeSpecialAccessorInfo(uint32_t field_idx, bool is_put, + verifier::MethodVerifier* verifier, + InlineIGetIPutData* result) + SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); +}; + +} // namespace art + +#endif // ART_RUNTIME_QUICK_INLINE_METHOD_ANALYSER_H_ |