/*
* 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"
#include "method_reference.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,
kIntrinsicFloat2Int,
kIntrinsicDouble2Long,
kIntrinsicFloatIsInfinite,
kIntrinsicDoubleIsInfinite,
kIntrinsicFloatIsNaN,
kIntrinsicDoubleIsNaN,
kIntrinsicReverseBits,
kIntrinsicReverseBytes,
kIntrinsicBitCount,
kIntrinsicCompare,
kIntrinsicHighestOneBit,
kIntrinsicLowestOneBit,
kIntrinsicNumberOfLeadingZeros,
kIntrinsicNumberOfTrailingZeros,
kIntrinsicRotateRight,
kIntrinsicRotateLeft,
kIntrinsicSignum,
kIntrinsicAbsInt,
kIntrinsicAbsLong,
kIntrinsicAbsFloat,
kIntrinsicAbsDouble,
kIntrinsicMinMaxInt,
kIntrinsicMinMaxLong,
kIntrinsicMinMaxFloat,
kIntrinsicMinMaxDouble,
kIntrinsicCos,
kIntrinsicSin,
kIntrinsicAcos,
kIntrinsicAsin,
kIntrinsicAtan,
kIntrinsicAtan2,
kIntrinsicCbrt,
kIntrinsicCosh,
kIntrinsicExp,
kIntrinsicExpm1,
kIntrinsicHypot,
kIntrinsicLog,
kIntrinsicLog10,
kIntrinsicNextAfter,
kIntrinsicSinh,
kIntrinsicTan,
kIntrinsicTanh,
kIntrinsicSqrt,
kIntrinsicCeil,
kIntrinsicFloor,
kIntrinsicRint,
kIntrinsicRoundFloat,
kIntrinsicRoundDouble,
kIntrinsicReferenceGetReferent,
kIntrinsicCharAt,
kIntrinsicCompareTo,
kIntrinsicEquals,
kIntrinsicGetCharsNoCheck,
kIntrinsicIsEmptyOrLength,
kIntrinsicIndexOf,
kIntrinsicNewStringFromBytes,
kIntrinsicNewStringFromChars,
kIntrinsicNewStringFromString,
kIntrinsicCurrentThread,
kIntrinsicPeek,
kIntrinsicPoke,
kIntrinsicCas,
kIntrinsicUnsafeGet,
kIntrinsicUnsafePut,
// 1.8.
kIntrinsicUnsafeGetAndAddInt,
kIntrinsicUnsafeGetAndAddLong,
kIntrinsicUnsafeGetAndSetInt,
kIntrinsicUnsafeGetAndSetLong,
kIntrinsicUnsafeGetAndSetObject,
kIntrinsicUnsafeLoadFence,
kIntrinsicUnsafeStoreFence,
kIntrinsicUnsafeFullFence,
kIntrinsicSystemArrayCopyCharArray,
kIntrinsicSystemArrayCopy,
kInlineOpNop,
kInlineOpReturnArg,
kInlineOpNonWideConst,
kInlineOpIGet,
kInlineOpIPut,
kInlineOpConstructor,
kInlineStringInit,
};
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,
// kIntrinsicDoubleCvt, kIntrinsicFloatCvt.
kIntrinsicFlagToFloatingPoint = kIntrinsicFlagMin,
};
struct InlineIGetIPutData {
// The op_variant below is DexMemAccessType but the runtime doesn't know that enumeration.
uint16_t op_variant : 3;
uint16_t method_is_static : 1;
uint16_t object_arg : 4;
uint16_t src_arg : 4; // iput only
uint16_t return_arg_plus1 : 4; // iput only, method argument to return + 1, 0 = return void.
uint16_t field_idx;
uint32_t is_volatile : 1;
uint32_t field_offset : 31;
};
static_assert(sizeof(InlineIGetIPutData) == sizeof(uint64_t), "Invalid size of InlineIGetIPutData");
struct InlineReturnArgData {
uint16_t arg;
uint16_t is_wide : 1;
uint16_t is_object : 1;
uint16_t reserved : 14;
uint32_t reserved2;
};
static_assert(sizeof(InlineReturnArgData) == sizeof(uint64_t),
"Invalid size of InlineReturnArgData");
struct InlineConstructorData {
// There can be up to 3 IPUTs, unused fields are marked with kNoDexIndex16.
uint16_t iput0_field_index;
uint16_t iput1_field_index;
uint16_t iput2_field_index;
uint16_t iput0_arg : 4;
uint16_t iput1_arg : 4;
uint16_t iput2_arg : 4;
uint16_t reserved : 4;
};
static_assert(sizeof(InlineConstructorData) == sizeof(uint64_t),
"Invalid size of InlineConstructorData");
struct InlineMethod {
InlineMethodOpcode opcode;
InlineMethodFlags flags;
union {
uint64_t data;
InlineIGetIPutData ifield_data;
InlineReturnArgData return_data;
InlineConstructorData constructor_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* result)
SHARED_REQUIRES(Locks::mutator_lock_);
static bool AnalyseMethodCode(ArtMethod* method, InlineMethod* result)
SHARED_REQUIRES(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;
}
// Determines whether the method is a synthetic accessor (method name starts with "access$").
static bool IsSyntheticAccessor(MethodReference ref);
private:
static bool AnalyseMethodCode(const DexFile::CodeItem* code_item,
const MethodReference& method_ref,
bool is_static,
ArtMethod* method,
InlineMethod* result)
SHARED_REQUIRES(Locks::mutator_lock_);
static bool AnalyseReturnMethod(const DexFile::CodeItem* code_item, InlineMethod* result);
static bool AnalyseConstMethod(const DexFile::CodeItem* code_item, InlineMethod* result);
static bool AnalyseIGetMethod(const DexFile::CodeItem* code_item,
const MethodReference& method_ref,
bool is_static,
ArtMethod* method,
InlineMethod* result)
SHARED_REQUIRES(Locks::mutator_lock_);
static bool AnalyseIPutMethod(const DexFile::CodeItem* code_item,
const MethodReference& method_ref,
bool is_static,
ArtMethod* method,
InlineMethod* result)
SHARED_REQUIRES(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(ArtMethod* method,
uint32_t field_idx,
bool is_put,
InlineIGetIPutData* result)
SHARED_REQUIRES(Locks::mutator_lock_);
};
} // namespace art
#endif // ART_RUNTIME_QUICK_INLINE_METHOD_ANALYSER_H_