/*
* Copyright (C) 2013 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 "dex_file_method_inliner.h"
#include <algorithm>
#include "base/logging.h"
#include "base/macros.h"
#include "base/mutex-inl.h"
#include "driver/compiler_driver.h"
#include "thread-inl.h"
#include "dex_instruction-inl.h"
#include "driver/dex_compilation_unit.h"
#include "verifier/method_verifier-inl.h"
namespace art {
namespace { // anonymous namespace
static constexpr bool kIntrinsicIsStatic[] = {
true, // kIntrinsicDoubleCvt
true, // kIntrinsicFloatCvt
true, // kIntrinsicFloat2Int
true, // kIntrinsicDouble2Long
true, // kIntrinsicFloatIsInfinite
true, // kIntrinsicDoubleIsInfinite
true, // kIntrinsicFloatIsNaN
true, // kIntrinsicDoubleIsNaN
true, // kIntrinsicReverseBits
true, // kIntrinsicReverseBytes
true, // kIntrinsicBitCount
true, // kIntrinsicCompare,
true, // kIntrinsicHighestOneBit
true, // kIntrinsicLowestOneBit
true, // kIntrinsicNumberOfLeadingZeros
true, // kIntrinsicNumberOfTrailingZeros
true, // kIntrinsicRotateRight
true, // kIntrinsicRotateLeft
true, // kIntrinsicSignum
true, // kIntrinsicAbsInt
true, // kIntrinsicAbsLong
true, // kIntrinsicAbsFloat
true, // kIntrinsicAbsDouble
true, // kIntrinsicMinMaxInt
true, // kIntrinsicMinMaxLong
true, // kIntrinsicMinMaxFloat
true, // kIntrinsicMinMaxDouble
true, // kIntrinsicCos
true, // kIntrinsicSin
true, // kIntrinsicAcos
true, // kIntrinsicAsin
true, // kIntrinsicAtan
true, // kIntrinsicAtan2
true, // kIntrinsicCbrt
true, // kIntrinsicCosh
true, // kIntrinsicExp
true, // kIntrinsicExpm1
true, // kIntrinsicHypot
true, // kIntrinsicLog
true, // kIntrinsicLog10
true, // kIntrinsicNextAfter
true, // kIntrinsicSinh
true, // kIntrinsicTan
true, // kIntrinsicTanh
true, // kIntrinsicSqrt
true, // kIntrinsicCeil
true, // kIntrinsicFloor
true, // kIntrinsicRint
true, // kIntrinsicRoundFloat
true, // kIntrinsicRoundDouble
false, // kIntrinsicReferenceGetReferent
false, // kIntrinsicCharAt
false, // kIntrinsicCompareTo
false, // kIntrinsicEquals
false, // kIntrinsicGetCharsNoCheck
false, // kIntrinsicIsEmptyOrLength
false, // kIntrinsicIndexOf
true, // kIntrinsicNewStringFromBytes
true, // kIntrinsicNewStringFromChars
true, // kIntrinsicNewStringFromString
true, // kIntrinsicCurrentThread
true, // kIntrinsicPeek
true, // kIntrinsicPoke
false, // kIntrinsicCas
false, // kIntrinsicUnsafeGet
false, // kIntrinsicUnsafePut
false, // kIntrinsicUnsafeGetAndAddInt,
false, // kIntrinsicUnsafeGetAndAddLong,
false, // kIntrinsicUnsafeGetAndSetInt,
false, // kIntrinsicUnsafeGetAndSetLong,
false, // kIntrinsicUnsafeGetAndSetObject,
false, // kIntrinsicUnsafeLoadFence,
false, // kIntrinsicUnsafeStoreFence,
false, // kIntrinsicUnsafeFullFence,
true, // kIntrinsicSystemArrayCopyCharArray
true, // kIntrinsicSystemArrayCopy
};
static_assert(arraysize(kIntrinsicIsStatic) == kInlineOpNop,
"arraysize of kIntrinsicIsStatic unexpected");
static_assert(kIntrinsicIsStatic[kIntrinsicDoubleCvt], "DoubleCvt must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicFloatCvt], "FloatCvt must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicFloat2Int], "Float2Int must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicDouble2Long], "Double2Long must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicFloatIsInfinite], "FloatIsInfinite must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicDoubleIsInfinite], "DoubleIsInfinite must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicFloatIsNaN], "FloatIsNaN must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicDoubleIsNaN], "DoubleIsNaN must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicReverseBits], "ReverseBits must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicReverseBytes], "ReverseBytes must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicBitCount], "BitCount must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicCompare], "Compare must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicHighestOneBit], "HighestOneBit must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicLowestOneBit], "LowestOneBit must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicNumberOfLeadingZeros],
"NumberOfLeadingZeros must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicNumberOfTrailingZeros],
"NumberOfTrailingZeros must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicRotateRight], "RotateRight must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicRotateLeft], "RotateLeft must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicSignum], "Signum must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicAbsInt], "AbsInt must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicAbsLong], "AbsLong must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicAbsFloat], "AbsFloat must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicAbsDouble], "AbsDouble must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicMinMaxInt], "MinMaxInt must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicMinMaxLong], "MinMaxLong must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicMinMaxFloat], "MinMaxFloat must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicMinMaxDouble], "MinMaxDouble must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicCos], "Cos must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicSin], "Sin must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicAcos], "Acos must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicAsin], "Asin must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicAtan], "Atan must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicAtan2], "Atan2 must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicCbrt], "Cbrt must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicCosh], "Cosh must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicExp], "Exp must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicExpm1], "Expm1 must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicHypot], "Hypot must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicLog], "Log must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicLog10], "Log10 must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicNextAfter], "NextAfter must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicSinh], "Sinh must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicTan], "Tan must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicTanh], "Tanh must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicSqrt], "Sqrt must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicCeil], "Ceil must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicFloor], "Floor must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicRint], "Rint must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicRoundFloat], "RoundFloat must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicRoundDouble], "RoundDouble must be static");
static_assert(!kIntrinsicIsStatic[kIntrinsicReferenceGetReferent], "Get must not be static");
static_assert(!kIntrinsicIsStatic[kIntrinsicCharAt], "CharAt must not be static");
static_assert(!kIntrinsicIsStatic[kIntrinsicCompareTo], "CompareTo must not be static");
static_assert(!kIntrinsicIsStatic[kIntrinsicEquals], "String equals must not be static");
static_assert(!kIntrinsicIsStatic[kIntrinsicGetCharsNoCheck], "GetCharsNoCheck must not be static");
static_assert(!kIntrinsicIsStatic[kIntrinsicIsEmptyOrLength], "IsEmptyOrLength must not be static");
static_assert(!kIntrinsicIsStatic[kIntrinsicIndexOf], "IndexOf must not be static");
static_assert(kIntrinsicIsStatic[kIntrinsicNewStringFromBytes],
"NewStringFromBytes must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicNewStringFromChars],
"NewStringFromChars must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicNewStringFromString],
"NewStringFromString must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicCurrentThread], "CurrentThread must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicPeek], "Peek must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicPoke], "Poke must be static");
static_assert(!kIntrinsicIsStatic[kIntrinsicCas], "Cas must not be static");
static_assert(!kIntrinsicIsStatic[kIntrinsicUnsafeGet], "UnsafeGet must not be static");
static_assert(!kIntrinsicIsStatic[kIntrinsicUnsafePut], "UnsafePut must not be static");
static_assert(!kIntrinsicIsStatic[kIntrinsicUnsafeGetAndAddInt], "UnsafeGetAndAddInt must not be static");
static_assert(!kIntrinsicIsStatic[kIntrinsicUnsafeGetAndAddLong], "UnsafeGetAndAddLong must not be static");
static_assert(!kIntrinsicIsStatic[kIntrinsicUnsafeGetAndSetInt], "UnsafeGetAndSetInt must not be static");
static_assert(!kIntrinsicIsStatic[kIntrinsicUnsafeGetAndSetLong], "UnsafeGetAndSetLong must not be static");
static_assert(!kIntrinsicIsStatic[kIntrinsicUnsafeGetAndSetObject], "UnsafeGetAndSetObject must not be static");
static_assert(!kIntrinsicIsStatic[kIntrinsicUnsafeLoadFence], "UnsafeLoadFence must not be static");
static_assert(!kIntrinsicIsStatic[kIntrinsicUnsafeStoreFence], "UnsafeStoreFence must not be static");
static_assert(!kIntrinsicIsStatic[kIntrinsicUnsafeFullFence], "UnsafeFullFence must not be static");
static_assert(kIntrinsicIsStatic[kIntrinsicSystemArrayCopyCharArray],
"SystemArrayCopyCharArray must be static");
static_assert(kIntrinsicIsStatic[kIntrinsicSystemArrayCopy],
"SystemArrayCopy must be static");
} // anonymous namespace
const uint32_t DexFileMethodInliner::kIndexUnresolved;
const char* const DexFileMethodInliner::kClassCacheNames[] = {
"Z", // kClassCacheBoolean
"B", // kClassCacheByte
"C", // kClassCacheChar
"S", // kClassCacheShort
"I", // kClassCacheInt
"J", // kClassCacheLong
"F", // kClassCacheFloat
"D", // kClassCacheDouble
"V", // kClassCacheVoid
"[B", // kClassCacheJavaLangByteArray
"[C", // kClassCacheJavaLangCharArray
"[I", // kClassCacheJavaLangIntArray
"Ljava/lang/Object;", // kClassCacheJavaLangObject
"Ljava/lang/ref/Reference;", // kClassCacheJavaLangRefReference
"Ljava/lang/String;", // kClassCacheJavaLangString
"Ljava/lang/StringBuffer;", // kClassCacheJavaLangStringBuffer
"Ljava/lang/StringBuilder;", // kClassCacheJavaLangStringBuilder
"Ljava/lang/StringFactory;", // kClassCacheJavaLangStringFactory
"Ljava/lang/Double;", // kClassCacheJavaLangDouble
"Ljava/lang/Float;", // kClassCacheJavaLangFloat
"Ljava/lang/Integer;", // kClassCacheJavaLangInteger
"Ljava/lang/Long;", // kClassCacheJavaLangLong
"Ljava/lang/Short;", // kClassCacheJavaLangShort
"Ljava/lang/Math;", // kClassCacheJavaLangMath
"Ljava/lang/StrictMath;", // kClassCacheJavaLangStrictMath
"Ljava/lang/Thread;", // kClassCacheJavaLangThread
"Ljava/nio/charset/Charset;", // kClassCacheJavaNioCharsetCharset
"Llibcore/io/Memory;", // kClassCacheLibcoreIoMemory
"Lsun/misc/Unsafe;", // kClassCacheSunMiscUnsafe
"Ljava/lang/System;", // kClassCacheJavaLangSystem
};
const char* const DexFileMethodInliner::kNameCacheNames[] = {
"reverse", // kNameCacheReverse
"reverseBytes", // kNameCacheReverseBytes
"doubleToRawLongBits", // kNameCacheDoubleToRawLongBits
"longBitsToDouble", // kNameCacheLongBitsToDouble
"floatToRawIntBits", // kNameCacheFloatToRawIntBits
"intBitsToFloat", // kNameCacheIntBitsToFloat
"abs", // kNameCacheAbs
"max", // kNameCacheMax
"min", // kNameCacheMin
"cos", // kNameCacheCos
"sin", // kNameCacheSin
"acos", // kNameCacheAcos
"asin", // kNameCacheAsin
"atan", // kNameCacheAtan
"atan2", // kNameCacheAtan2
"cbrt", // kNameCacheCbrt
"cosh", // kNameCacheCosh
"exp", // kNameCacheExp
"expm1", // kNameCacheExpm1
"hypot", // kNameCacheHypot
"log", // kNameCacheLog
"log10", // kNameCacheLog10
"nextAfter", // kNameCacheNextAfter
"sinh", // kNameCacheSinh
"tan", // kNameCacheTan
"tanh", // kNameCacheTanh
"sqrt", // kNameCacheSqrt
"ceil", // kNameCacheCeil
"floor", // kNameCacheFloor
"rint", // kNameCacheRint
"round", // kNameCacheRound
"getReferent", // kNameCacheReferenceGet
"charAt", // kNameCacheCharAt
"compareTo", // kNameCacheCompareTo
"equals", // kNameCacheEquals
"getCharsNoCheck", // kNameCacheGetCharsNoCheck
"isEmpty", // kNameCacheIsEmpty
"floatToIntBits", // kNameCacheFloatToIntBits
"doubleToLongBits", // kNameCacheDoubleToLongBits
"isInfinite", // kNameCacheIsInfinite
"isNaN", // kNameCacheIsNaN
"indexOf", // kNameCacheIndexOf
"length", // kNameCacheLength
"<init>", // kNameCacheInit
"newStringFromBytes", // kNameCacheNewStringFromBytes
"newStringFromChars", // kNameCacheNewStringFromChars
"newStringFromString", // kNameCacheNewStringFromString
"currentThread", // kNameCacheCurrentThread
"peekByte", // kNameCachePeekByte
"peekIntNative", // kNameCachePeekIntNative
"peekLongNative", // kNameCachePeekLongNative
"peekShortNative", // kNameCachePeekShortNative
"pokeByte", // kNameCachePokeByte
"pokeIntNative", // kNameCachePokeIntNative
"pokeLongNative", // kNameCachePokeLongNative
"pokeShortNative", // kNameCachePokeShortNative
"compareAndSwapInt", // kNameCacheCompareAndSwapInt
"compareAndSwapLong", // kNameCacheCompareAndSwapLong
"compareAndSwapObject", // kNameCacheCompareAndSwapObject
"getInt", // kNameCacheGetInt
"getIntVolatile", // kNameCacheGetIntVolatile
"putInt", // kNameCachePutInt
"putIntVolatile", // kNameCachePutIntVolatile
"putOrderedInt", // kNameCachePutOrderedInt
"getLong", // kNameCacheGetLong
"getLongVolatile", // kNameCacheGetLongVolatile
"putLong", // kNameCachePutLong
"putLongVolatile", // kNameCachePutLongVolatile
"putOrderedLong", // kNameCachePutOrderedLong
"getObject", // kNameCacheGetObject
"getObjectVolatile", // kNameCacheGetObjectVolatile
"putObject", // kNameCachePutObject
"putObjectVolatile", // kNameCachePutObjectVolatile
"putOrderedObject", // kNameCachePutOrderedObject
"getAndAddInt", // kNameCacheGetAndAddInt,
"getAndAddLong", // kNameCacheGetAndAddLong,
"getAndSetInt", // kNameCacheGetAndSetInt,
"getAndSetLong", // kNameCacheGetAndSetLong,
"getAndSetObject", // kNameCacheGetAndSetObject,
"loadFence", // kNameCacheLoadFence,
"storeFence", // kNameCacheStoreFence,
"fullFence", // kNameCacheFullFence,
"arraycopy", // kNameCacheArrayCopy
"bitCount", // kNameCacheBitCount
"compare", // kNameCacheCompare
"highestOneBit", // kNameCacheHighestOneBit
"lowestOneBit", // kNameCacheLowestOneBit
"numberOfLeadingZeros", // kNameCacheNumberOfLeadingZeros
"numberOfTrailingZeros", // kNameCacheNumberOfTrailingZeros
"rotateRight", // kNameCacheRotateRight
"rotateLeft", // kNameCacheRotateLeft
"signum", // kNameCacheSignum
};
const DexFileMethodInliner::ProtoDef DexFileMethodInliner::kProtoCacheDefs[] = {
// kProtoCacheI_I
{ kClassCacheInt, 1, { kClassCacheInt } },
// kProtoCacheJ_J
{ kClassCacheLong, 1, { kClassCacheLong } },
// kProtoCacheS_S
{ kClassCacheShort, 1, { kClassCacheShort } },
// kProtoCacheD_D
{ kClassCacheDouble, 1, { kClassCacheDouble } },
// kProtoCacheDD_D
{ kClassCacheDouble, 2, { kClassCacheDouble, kClassCacheDouble } },
// kProtoCacheF_F
{ kClassCacheFloat, 1, { kClassCacheFloat } },
// kProtoCacheFF_F
{ kClassCacheFloat, 2, { kClassCacheFloat, kClassCacheFloat } },
// kProtoCacheD_J
{ kClassCacheLong, 1, { kClassCacheDouble } },
// kProtoCacheD_Z
{ kClassCacheBoolean, 1, { kClassCacheDouble } },
// kProtoCacheJ_D
{ kClassCacheDouble, 1, { kClassCacheLong } },
// kProtoCacheF_I
{ kClassCacheInt, 1, { kClassCacheFloat } },
// kProtoCacheF_Z
{ kClassCacheBoolean, 1, { kClassCacheFloat } },
// kProtoCacheI_F
{ kClassCacheFloat, 1, { kClassCacheInt } },
// kProtoCacheII_I
{ kClassCacheInt, 2, { kClassCacheInt, kClassCacheInt } },
// kProtoCacheI_C
{ kClassCacheChar, 1, { kClassCacheInt } },
// kProtoCacheString_I
{ kClassCacheInt, 1, { kClassCacheJavaLangString } },
// kProtoCache_Z
{ kClassCacheBoolean, 0, { } },
// kProtoCache_I
{ kClassCacheInt, 0, { } },
// kProtoCache_Object
{ kClassCacheJavaLangObject, 0, { } },
// kProtoCache_Thread
{ kClassCacheJavaLangThread, 0, { } },
// kProtoCacheJ_B
{ kClassCacheByte, 1, { kClassCacheLong } },
// kProtoCacheJ_I
{ kClassCacheInt, 1, { kClassCacheLong } },
// kProtoCacheJ_S
{ kClassCacheShort, 1, { kClassCacheLong } },
// kProtoCacheJB_V
{ kClassCacheVoid, 2, { kClassCacheLong, kClassCacheByte } },
// kProtoCacheJI_V
{ kClassCacheVoid, 2, { kClassCacheLong, kClassCacheInt } },
// kProtoCacheJJ_J
{ kClassCacheLong, 2, { kClassCacheLong, kClassCacheLong } },
// kProtoCacheJJ_I
{ kClassCacheInt, 2, { kClassCacheLong, kClassCacheLong } },
// kProtoCacheJJ_V
{ kClassCacheVoid, 2, { kClassCacheLong, kClassCacheLong } },
// kProtoCacheJS_V
{ kClassCacheVoid, 2, { kClassCacheLong, kClassCacheShort } },
// kProtoCacheObject_Z
{ kClassCacheBoolean, 1, { kClassCacheJavaLangObject } },
// kProtoCacheJI_J
{ kClassCacheLong, 2, { kClassCacheLong, kClassCacheInt } },
// kProtoCacheObjectJII_Z
{ kClassCacheBoolean, 4, { kClassCacheJavaLangObject, kClassCacheLong,
kClassCacheInt, kClassCacheInt } },
// kProtoCacheObjectJJJ_Z
{ kClassCacheBoolean, 4, { kClassCacheJavaLangObject, kClassCacheLong,
kClassCacheLong, kClassCacheLong } },
// kProtoCacheObjectJObjectObject_Z
{ kClassCacheBoolean, 4, { kClassCacheJavaLangObject, kClassCacheLong,
kClassCacheJavaLangObject, kClassCacheJavaLangObject } },
// kProtoCacheObjectJ_I
{ kClassCacheInt, 2, { kClassCacheJavaLangObject, kClassCacheLong } },
// kProtoCacheObjectJI_I
{ kClassCacheInt, 3, { kClassCacheJavaLangObject, kClassCacheLong, kClassCacheInt } },
// kProtoCacheObjectJI_V
{ kClassCacheVoid, 3, { kClassCacheJavaLangObject, kClassCacheLong, kClassCacheInt } },
// kProtoCacheObjectJ_J
{ kClassCacheLong, 2, { kClassCacheJavaLangObject, kClassCacheLong } },
// kProtoCacheObjectJJ_J
{ kClassCacheLong, 3, { kClassCacheJavaLangObject, kClassCacheLong, kClassCacheLong } },
// kProtoCacheObjectJJ_V
{ kClassCacheVoid, 3, { kClassCacheJavaLangObject, kClassCacheLong, kClassCacheLong } },
// kProtoCacheObjectJ_Object
{ kClassCacheJavaLangObject, 2, { kClassCacheJavaLangObject, kClassCacheLong } },
// kProtoCacheObjectJObject_V
{ kClassCacheVoid, 3, { kClassCacheJavaLangObject, kClassCacheLong,
kClassCacheJavaLangObject } },
// kProtoCacheObjectJObject_Object
{ kClassCacheJavaLangObject, 3, { kClassCacheJavaLangObject, kClassCacheLong,
kClassCacheJavaLangObject } },
// kProtoCacheCharArrayICharArrayII_V
{ kClassCacheVoid, 5, {kClassCacheJavaLangCharArray, kClassCacheInt,
kClassCacheJavaLangCharArray, kClassCacheInt, kClassCacheInt} },
// kProtoCacheObjectIObjectII_V
{ kClassCacheVoid, 5, {kClassCacheJavaLangObject, kClassCacheInt,
kClassCacheJavaLangObject, kClassCacheInt, kClassCacheInt} },
// kProtoCacheIICharArrayI_V
{ kClassCacheVoid, 4, { kClassCacheInt, kClassCacheInt, kClassCacheJavaLangCharArray,
kClassCacheInt } },
// kProtoCacheByteArrayIII_String
{ kClassCacheJavaLangString, 4, { kClassCacheJavaLangByteArray, kClassCacheInt, kClassCacheInt,
kClassCacheInt } },
// kProtoCacheIICharArray_String
{ kClassCacheJavaLangString, 3, { kClassCacheInt, kClassCacheInt,
kClassCacheJavaLangCharArray } },
// kProtoCacheString_String
{ kClassCacheJavaLangString, 1, { kClassCacheJavaLangString } },
// kProtoCache_V
{ kClassCacheVoid, 0, { } },
// kProtoCacheByteArray_V
{ kClassCacheVoid, 1, { kClassCacheJavaLangByteArray } },
// kProtoCacheByteArrayI_V
{ kClassCacheVoid, 2, { kClassCacheJavaLangByteArray, kClassCacheInt } },
// kProtoCacheByteArrayII_V
{ kClassCacheVoid, 3, { kClassCacheJavaLangByteArray, kClassCacheInt, kClassCacheInt } },
// kProtoCacheByteArrayIII_V
{ kClassCacheVoid, 4, { kClassCacheJavaLangByteArray, kClassCacheInt, kClassCacheInt,
kClassCacheInt } },
// kProtoCacheByteArrayIIString_V
{ kClassCacheVoid, 4, { kClassCacheJavaLangByteArray, kClassCacheInt, kClassCacheInt,
kClassCacheJavaLangString } },
// kProtoCacheByteArrayString_V
{ kClassCacheVoid, 2, { kClassCacheJavaLangByteArray, kClassCacheJavaLangString } },
// kProtoCacheByteArrayIICharset_V
{ kClassCacheVoid, 4, { kClassCacheJavaLangByteArray, kClassCacheInt, kClassCacheInt,
kClassCacheJavaNioCharsetCharset } },
// kProtoCacheByteArrayCharset_V
{ kClassCacheVoid, 2, { kClassCacheJavaLangByteArray, kClassCacheJavaNioCharsetCharset } },
// kProtoCacheCharArray_V
{ kClassCacheVoid, 1, { kClassCacheJavaLangCharArray } },
// kProtoCacheCharArrayII_V
{ kClassCacheVoid, 3, { kClassCacheJavaLangCharArray, kClassCacheInt, kClassCacheInt } },
// kProtoCacheIICharArray_V
{ kClassCacheVoid, 3, { kClassCacheInt, kClassCacheInt, kClassCacheJavaLangCharArray } },
// kProtoCacheIntArrayII_V
{ kClassCacheVoid, 3, { kClassCacheJavaLangIntArray, kClassCacheInt, kClassCacheInt } },
// kProtoCacheString_V
{ kClassCacheVoid, 1, { kClassCacheJavaLangString } },
// kProtoCacheStringBuffer_V
{ kClassCacheVoid, 1, { kClassCacheJavaLangStringBuffer } },
// kProtoCacheStringBuilder_V
{ kClassCacheVoid, 1, { kClassCacheJavaLangStringBuilder } },
};
const DexFileMethodInliner::IntrinsicDef DexFileMethodInliner::kIntrinsicMethods[] = {
#define INTRINSIC(c, n, p, o, d) \
{ { kClassCache ## c, kNameCache ## n, kProtoCache ## p }, { o, kInlineIntrinsic, { d } } }
INTRINSIC(JavaLangDouble, DoubleToRawLongBits, D_J, kIntrinsicDoubleCvt, 0),
INTRINSIC(JavaLangDouble, LongBitsToDouble, J_D, kIntrinsicDoubleCvt, kIntrinsicFlagToFloatingPoint),
INTRINSIC(JavaLangFloat, FloatToRawIntBits, F_I, kIntrinsicFloatCvt, 0),
INTRINSIC(JavaLangFloat, IntBitsToFloat, I_F, kIntrinsicFloatCvt, kIntrinsicFlagToFloatingPoint),
INTRINSIC(JavaLangFloat, FloatToIntBits, F_I, kIntrinsicFloat2Int, 0),
INTRINSIC(JavaLangDouble, DoubleToLongBits, D_J, kIntrinsicDouble2Long, 0),
INTRINSIC(JavaLangFloat, IsInfinite, F_Z, kIntrinsicFloatIsInfinite, 0),
INTRINSIC(JavaLangDouble, IsInfinite, D_Z, kIntrinsicDoubleIsInfinite, 0),
INTRINSIC(JavaLangFloat, IsNaN, F_Z, kIntrinsicFloatIsNaN, 0),
INTRINSIC(JavaLangDouble, IsNaN, D_Z, kIntrinsicDoubleIsNaN, 0),
INTRINSIC(JavaLangInteger, ReverseBytes, I_I, kIntrinsicReverseBytes, k32),
INTRINSIC(JavaLangLong, ReverseBytes, J_J, kIntrinsicReverseBytes, k64),
INTRINSIC(JavaLangShort, ReverseBytes, S_S, kIntrinsicReverseBytes, kSignedHalf),
INTRINSIC(JavaLangInteger, Reverse, I_I, kIntrinsicReverseBits, k32),
INTRINSIC(JavaLangLong, Reverse, J_J, kIntrinsicReverseBits, k64),
INTRINSIC(JavaLangInteger, BitCount, I_I, kIntrinsicBitCount, k32),
INTRINSIC(JavaLangLong, BitCount, J_I, kIntrinsicBitCount, k64),
INTRINSIC(JavaLangInteger, Compare, II_I, kIntrinsicCompare, k32),
INTRINSIC(JavaLangLong, Compare, JJ_I, kIntrinsicCompare, k64),
INTRINSIC(JavaLangInteger, HighestOneBit, I_I, kIntrinsicHighestOneBit, k32),
INTRINSIC(JavaLangLong, HighestOneBit, J_J, kIntrinsicHighestOneBit, k64),
INTRINSIC(JavaLangInteger, LowestOneBit, I_I, kIntrinsicLowestOneBit, k32),
INTRINSIC(JavaLangLong, LowestOneBit, J_J, kIntrinsicLowestOneBit, k64),
INTRINSIC(JavaLangInteger, NumberOfLeadingZeros, I_I, kIntrinsicNumberOfLeadingZeros, k32),
INTRINSIC(JavaLangLong, NumberOfLeadingZeros, J_I, kIntrinsicNumberOfLeadingZeros, k64),
INTRINSIC(JavaLangInteger, NumberOfTrailingZeros, I_I, kIntrinsicNumberOfTrailingZeros, k32),
INTRINSIC(JavaLangLong, NumberOfTrailingZeros, J_I, kIntrinsicNumberOfTrailingZeros, k64),
INTRINSIC(JavaLangInteger, Signum, I_I, kIntrinsicSignum, k32),
INTRINSIC(JavaLangLong, Signum, J_I, kIntrinsicSignum, k64),
INTRINSIC(JavaLangMath, Abs, I_I, kIntrinsicAbsInt, 0),
INTRINSIC(JavaLangStrictMath, Abs, I_I, kIntrinsicAbsInt, 0),
INTRINSIC(JavaLangMath, Abs, J_J, kIntrinsicAbsLong, 0),
INTRINSIC(JavaLangStrictMath, Abs, J_J, kIntrinsicAbsLong, 0),
INTRINSIC(JavaLangMath, Abs, F_F, kIntrinsicAbsFloat, 0),
INTRINSIC(JavaLangStrictMath, Abs, F_F, kIntrinsicAbsFloat, 0),
INTRINSIC(JavaLangMath, Abs, D_D, kIntrinsicAbsDouble, 0),
INTRINSIC(JavaLangStrictMath, Abs, D_D, kIntrinsicAbsDouble, 0),
INTRINSIC(JavaLangMath, Min, II_I, kIntrinsicMinMaxInt, kIntrinsicFlagMin),
INTRINSIC(JavaLangStrictMath, Min, II_I, kIntrinsicMinMaxInt, kIntrinsicFlagMin),
INTRINSIC(JavaLangMath, Max, II_I, kIntrinsicMinMaxInt, kIntrinsicFlagMax),
INTRINSIC(JavaLangStrictMath, Max, II_I, kIntrinsicMinMaxInt, kIntrinsicFlagMax),
INTRINSIC(JavaLangMath, Min, JJ_J, kIntrinsicMinMaxLong, kIntrinsicFlagMin),
INTRINSIC(JavaLangStrictMath, Min, JJ_J, kIntrinsicMinMaxLong, kIntrinsicFlagMin),
INTRINSIC(JavaLangMath, Max, JJ_J, kIntrinsicMinMaxLong, kIntrinsicFlagMax),
INTRINSIC(JavaLangStrictMath, Max, JJ_J, kIntrinsicMinMaxLong, kIntrinsicFlagMax),
INTRINSIC(JavaLangMath, Min, FF_F, kIntrinsicMinMaxFloat, kIntrinsicFlagMin),
INTRINSIC(JavaLangStrictMath, Min, FF_F, kIntrinsicMinMaxFloat, kIntrinsicFlagMin),
INTRINSIC(JavaLangMath, Max, FF_F, kIntrinsicMinMaxFloat, kIntrinsicFlagMax),
INTRINSIC(JavaLangStrictMath, Max, FF_F, kIntrinsicMinMaxFloat, kIntrinsicFlagMax),
INTRINSIC(JavaLangMath, Min, DD_D, kIntrinsicMinMaxDouble, kIntrinsicFlagMin),
INTRINSIC(JavaLangStrictMath, Min, DD_D, kIntrinsicMinMaxDouble, kIntrinsicFlagMin),
INTRINSIC(JavaLangMath, Max, DD_D, kIntrinsicMinMaxDouble, kIntrinsicFlagMax),
INTRINSIC(JavaLangStrictMath, Max, DD_D, kIntrinsicMinMaxDouble, kIntrinsicFlagMax),
INTRINSIC(JavaLangMath, Cos, D_D, kIntrinsicCos, 0),
INTRINSIC(JavaLangMath, Sin, D_D, kIntrinsicSin, 0),
INTRINSIC(JavaLangMath, Acos, D_D, kIntrinsicAcos, 0),
INTRINSIC(JavaLangMath, Asin, D_D, kIntrinsicAsin, 0),
INTRINSIC(JavaLangMath, Atan, D_D, kIntrinsicAtan, 0),
INTRINSIC(JavaLangMath, Atan2, DD_D, kIntrinsicAtan2, 0),
INTRINSIC(JavaLangMath, Cbrt, D_D, kIntrinsicCbrt, 0),
INTRINSIC(JavaLangMath, Cosh, D_D, kIntrinsicCosh, 0),
INTRINSIC(JavaLangMath, Exp, D_D, kIntrinsicExp, 0),
INTRINSIC(JavaLangMath, Expm1, D_D, kIntrinsicExpm1, 0),
INTRINSIC(JavaLangMath, Hypot, DD_D, kIntrinsicHypot, 0),
INTRINSIC(JavaLangMath, Log, D_D, kIntrinsicLog, 0),
INTRINSIC(JavaLangMath, Log10, D_D, kIntrinsicLog10, 0),
INTRINSIC(JavaLangMath, NextAfter, DD_D, kIntrinsicNextAfter, 0),
INTRINSIC(JavaLangMath, Sinh, D_D, kIntrinsicSinh, 0),
INTRINSIC(JavaLangMath, Tan, D_D, kIntrinsicTan, 0),
INTRINSIC(JavaLangMath, Tanh, D_D, kIntrinsicTanh, 0),
INTRINSIC(JavaLangMath, Sqrt, D_D, kIntrinsicSqrt, 0),
INTRINSIC(JavaLangStrictMath, Sqrt, D_D, kIntrinsicSqrt, 0),
INTRINSIC(JavaLangMath, Ceil, D_D, kIntrinsicCeil, 0),
INTRINSIC(JavaLangStrictMath, Ceil, D_D, kIntrinsicCeil, 0),
INTRINSIC(JavaLangMath, Floor, D_D, kIntrinsicFloor, 0),
INTRINSIC(JavaLangStrictMath, Floor, D_D, kIntrinsicFloor, 0),
INTRINSIC(JavaLangMath, Rint, D_D, kIntrinsicRint, 0),
INTRINSIC(JavaLangStrictMath, Rint, D_D, kIntrinsicRint, 0),
INTRINSIC(JavaLangMath, Round, F_I, kIntrinsicRoundFloat, 0),
INTRINSIC(JavaLangStrictMath, Round, F_I, kIntrinsicRoundFloat, 0),
INTRINSIC(JavaLangMath, Round, D_J, kIntrinsicRoundDouble, 0),
INTRINSIC(JavaLangStrictMath, Round, D_J, kIntrinsicRoundDouble, 0),
INTRINSIC(JavaLangRefReference, ReferenceGetReferent, _Object, kIntrinsicReferenceGetReferent, 0),
INTRINSIC(JavaLangString, CharAt, I_C, kIntrinsicCharAt, 0),
INTRINSIC(JavaLangString, CompareTo, String_I, kIntrinsicCompareTo, 0),
INTRINSIC(JavaLangString, Equals, Object_Z, kIntrinsicEquals, 0),
INTRINSIC(JavaLangString, GetCharsNoCheck, IICharArrayI_V, kIntrinsicGetCharsNoCheck, 0),
INTRINSIC(JavaLangString, IsEmpty, _Z, kIntrinsicIsEmptyOrLength, kIntrinsicFlagIsEmpty),
INTRINSIC(JavaLangString, IndexOf, II_I, kIntrinsicIndexOf, kIntrinsicFlagNone),
INTRINSIC(JavaLangString, IndexOf, I_I, kIntrinsicIndexOf, kIntrinsicFlagBase0),
INTRINSIC(JavaLangString, Length, _I, kIntrinsicIsEmptyOrLength, kIntrinsicFlagLength),
INTRINSIC(JavaLangStringFactory, NewStringFromBytes, ByteArrayIII_String,
kIntrinsicNewStringFromBytes, kIntrinsicFlagNone),
INTRINSIC(JavaLangStringFactory, NewStringFromChars, IICharArray_String,
kIntrinsicNewStringFromChars, kIntrinsicFlagNone),
INTRINSIC(JavaLangStringFactory, NewStringFromString, String_String,
kIntrinsicNewStringFromString, kIntrinsicFlagNone),
INTRINSIC(JavaLangThread, CurrentThread, _Thread, kIntrinsicCurrentThread, 0),
INTRINSIC(LibcoreIoMemory, PeekByte, J_B, kIntrinsicPeek, kSignedByte),
INTRINSIC(LibcoreIoMemory, PeekIntNative, J_I, kIntrinsicPeek, k32),
INTRINSIC(LibcoreIoMemory, PeekLongNative, J_J, kIntrinsicPeek, k64),
INTRINSIC(LibcoreIoMemory, PeekShortNative, J_S, kIntrinsicPeek, kSignedHalf),
INTRINSIC(LibcoreIoMemory, PokeByte, JB_V, kIntrinsicPoke, kSignedByte),
INTRINSIC(LibcoreIoMemory, PokeIntNative, JI_V, kIntrinsicPoke, k32),
INTRINSIC(LibcoreIoMemory, PokeLongNative, JJ_V, kIntrinsicPoke, k64),
INTRINSIC(LibcoreIoMemory, PokeShortNative, JS_V, kIntrinsicPoke, kSignedHalf),
INTRINSIC(SunMiscUnsafe, CompareAndSwapInt, ObjectJII_Z, kIntrinsicCas,
kIntrinsicFlagNone),
INTRINSIC(SunMiscUnsafe, CompareAndSwapLong, ObjectJJJ_Z, kIntrinsicCas,
kIntrinsicFlagIsLong),
INTRINSIC(SunMiscUnsafe, CompareAndSwapObject, ObjectJObjectObject_Z, kIntrinsicCas,
kIntrinsicFlagIsObject),
#define UNSAFE_GET_PUT(type, code, type_flags) \
INTRINSIC(SunMiscUnsafe, Get ## type, ObjectJ_ ## code, kIntrinsicUnsafeGet, \
type_flags), \
INTRINSIC(SunMiscUnsafe, Get ## type ## Volatile, ObjectJ_ ## code, kIntrinsicUnsafeGet, \
type_flags | kIntrinsicFlagIsVolatile), \
INTRINSIC(SunMiscUnsafe, Put ## type, ObjectJ ## code ## _V, kIntrinsicUnsafePut, \
type_flags), \
INTRINSIC(SunMiscUnsafe, Put ## type ## Volatile, ObjectJ ## code ## _V, kIntrinsicUnsafePut, \
type_flags | kIntrinsicFlagIsVolatile), \
INTRINSIC(SunMiscUnsafe, PutOrdered ## type, ObjectJ ## code ## _V, kIntrinsicUnsafePut, \
type_flags | kIntrinsicFlagIsOrdered)
UNSAFE_GET_PUT(Int, I, kIntrinsicFlagNone),
UNSAFE_GET_PUT(Long, J, kIntrinsicFlagIsLong),
UNSAFE_GET_PUT(Object, Object, kIntrinsicFlagIsObject),
#undef UNSAFE_GET_PUT
// 1.8
INTRINSIC(SunMiscUnsafe, GetAndAddInt, ObjectJI_I, kIntrinsicUnsafeGetAndAddInt, 0),
INTRINSIC(SunMiscUnsafe, GetAndAddLong, ObjectJJ_J, kIntrinsicUnsafeGetAndAddLong, 0),
INTRINSIC(SunMiscUnsafe, GetAndSetInt, ObjectJI_I, kIntrinsicUnsafeGetAndSetInt, 0),
INTRINSIC(SunMiscUnsafe, GetAndSetLong, ObjectJJ_J, kIntrinsicUnsafeGetAndSetLong, 0),
INTRINSIC(SunMiscUnsafe, GetAndSetObject, ObjectJObject_Object, kIntrinsicUnsafeGetAndSetObject, 0),
INTRINSIC(SunMiscUnsafe, LoadFence, _V, kIntrinsicUnsafeLoadFence, 0),
INTRINSIC(SunMiscUnsafe, StoreFence, _V, kIntrinsicUnsafeStoreFence, 0),
INTRINSIC(SunMiscUnsafe, FullFence, _V, kIntrinsicUnsafeFullFence, 0),
INTRINSIC(JavaLangSystem, ArrayCopy, CharArrayICharArrayII_V , kIntrinsicSystemArrayCopyCharArray,
0),
INTRINSIC(JavaLangSystem, ArrayCopy, ObjectIObjectII_V , kIntrinsicSystemArrayCopy,
0),
INTRINSIC(JavaLangInteger, RotateRight, II_I, kIntrinsicRotateRight, k32),
INTRINSIC(JavaLangLong, RotateRight, JI_J, kIntrinsicRotateRight, k64),
INTRINSIC(JavaLangInteger, RotateLeft, II_I, kIntrinsicRotateLeft, k32),
INTRINSIC(JavaLangLong, RotateLeft, JI_J, kIntrinsicRotateLeft, k64),
#undef INTRINSIC
#define SPECIAL(c, n, p, o, d) \
{ { kClassCache ## c, kNameCache ## n, kProtoCache ## p }, { o, kInlineSpecial, { d } } }
SPECIAL(JavaLangString, Init, _V, kInlineStringInit, 0),
SPECIAL(JavaLangString, Init, ByteArray_V, kInlineStringInit, 1),
SPECIAL(JavaLangString, Init, ByteArrayI_V, kInlineStringInit, 2),
SPECIAL(JavaLangString, Init, ByteArrayII_V, kInlineStringInit, 3),
SPECIAL(JavaLangString, Init, ByteArrayIII_V, kInlineStringInit, 4),
SPECIAL(JavaLangString, Init, ByteArrayIIString_V, kInlineStringInit, 5),
SPECIAL(JavaLangString, Init, ByteArrayString_V, kInlineStringInit, 6),
SPECIAL(JavaLangString, Init, ByteArrayIICharset_V, kInlineStringInit, 7),
SPECIAL(JavaLangString, Init, ByteArrayCharset_V, kInlineStringInit, 8),
SPECIAL(JavaLangString, Init, CharArray_V, kInlineStringInit, 9),
SPECIAL(JavaLangString, Init, CharArrayII_V, kInlineStringInit, 10),
SPECIAL(JavaLangString, Init, IICharArray_V, kInlineStringInit, 11),
SPECIAL(JavaLangString, Init, IntArrayII_V, kInlineStringInit, 12),
SPECIAL(JavaLangString, Init, String_V, kInlineStringInit, 13),
SPECIAL(JavaLangString, Init, StringBuffer_V, kInlineStringInit, 14),
SPECIAL(JavaLangString, Init, StringBuilder_V, kInlineStringInit, 15),
#undef SPECIAL
};
DexFileMethodInliner::DexFileMethodInliner()
: lock_("DexFileMethodInliner lock", kDexFileMethodInlinerLock),
dex_file_(nullptr) {
static_assert(kClassCacheFirst == 0, "kClassCacheFirst not 0");
static_assert(arraysize(kClassCacheNames) == kClassCacheLast,
"bad arraysize for kClassCacheNames");
static_assert(kNameCacheFirst == 0, "kNameCacheFirst not 0");
static_assert(arraysize(kNameCacheNames) == kNameCacheLast,
"bad arraysize for kNameCacheNames");
static_assert(kProtoCacheFirst == 0, "kProtoCacheFirst not 0");
static_assert(arraysize(kProtoCacheDefs) == kProtoCacheLast,
"bad arraysize kProtoCacheNames");
}
DexFileMethodInliner::~DexFileMethodInliner() {
}
bool DexFileMethodInliner::AnalyseMethodCode(verifier::MethodVerifier* verifier) {
InlineMethod method;
bool success = InlineMethodAnalyser::AnalyseMethodCode(verifier, &method);
return success && AddInlineMethod(verifier->GetMethodReference().dex_method_index, method);
}
InlineMethodFlags DexFileMethodInliner::IsIntrinsicOrSpecial(uint32_t method_index) {
ReaderMutexLock mu(Thread::Current(), lock_);
auto it = inline_methods_.find(method_index);
if (it != inline_methods_.end()) {
DCHECK_NE(it->second.flags & (kInlineIntrinsic | kInlineSpecial), 0);
return it->second.flags;
} else {
return kNoInlineMethodFlags;
}
}
bool DexFileMethodInliner::IsIntrinsic(uint32_t method_index, InlineMethod* intrinsic) {
ReaderMutexLock mu(Thread::Current(), lock_);
auto it = inline_methods_.find(method_index);
bool res = (it != inline_methods_.end() && (it->second.flags & kInlineIntrinsic) != 0);
if (res && intrinsic != nullptr) {
*intrinsic = it->second;
}
return res;
}
bool DexFileMethodInliner::IsSpecial(uint32_t method_index) {
ReaderMutexLock mu(Thread::Current(), lock_);
auto it = inline_methods_.find(method_index);
return it != inline_methods_.end() && (it->second.flags & kInlineSpecial) != 0;
}
uint32_t DexFileMethodInliner::FindClassIndex(const DexFile* dex_file, IndexCache* cache,
ClassCacheIndex index) {
uint32_t* class_index = &cache->class_indexes[index];
if (*class_index != kIndexUnresolved) {
return *class_index;
}
const DexFile::TypeId* type_id = dex_file->FindTypeId(kClassCacheNames[index]);
if (type_id == nullptr) {
*class_index = kIndexNotFound;
return *class_index;
}
*class_index = dex_file->GetIndexForTypeId(*type_id);
return *class_index;
}
uint32_t DexFileMethodInliner::FindNameIndex(const DexFile* dex_file, IndexCache* cache,
NameCacheIndex index) {
uint32_t* name_index = &cache->name_indexes[index];
if (*name_index != kIndexUnresolved) {
return *name_index;
}
const DexFile::StringId* string_id = dex_file->FindStringId(kNameCacheNames[index]);
if (string_id == nullptr) {
*name_index = kIndexNotFound;
return *name_index;
}
*name_index = dex_file->GetIndexForStringId(*string_id);
return *name_index;
}
uint32_t DexFileMethodInliner::FindProtoIndex(const DexFile* dex_file, IndexCache* cache,
ProtoCacheIndex index) {
uint32_t* proto_index = &cache->proto_indexes[index];
if (*proto_index != kIndexUnresolved) {
return *proto_index;
}
const ProtoDef& proto_def = kProtoCacheDefs[index];
uint32_t return_index = FindClassIndex(dex_file, cache, proto_def.return_type);
if (return_index == kIndexNotFound) {
*proto_index = kIndexNotFound;
return *proto_index;
}
uint16_t return_type = static_cast<uint16_t>(return_index);
DCHECK_EQ(static_cast<uint32_t>(return_type), return_index);
uint32_t signature_length = proto_def.param_count;
uint16_t signature_type_idxs[kProtoMaxParams];
for (uint32_t i = 0; i != signature_length; ++i) {
uint32_t param_index = FindClassIndex(dex_file, cache, proto_def.params[i]);
if (param_index == kIndexNotFound) {
*proto_index = kIndexNotFound;
return *proto_index;
}
signature_type_idxs[i] = static_cast<uint16_t>(param_index);
DCHECK_EQ(static_cast<uint32_t>(signature_type_idxs[i]), param_index);
}
const DexFile::ProtoId* proto_id = dex_file->FindProtoId(return_type, signature_type_idxs,
signature_length);
if (proto_id == nullptr) {
*proto_index = kIndexNotFound;
return *proto_index;
}
*proto_index = dex_file->GetIndexForProtoId(*proto_id);
return *proto_index;
}
uint32_t DexFileMethodInliner::FindMethodIndex(const DexFile* dex_file, IndexCache* cache,
const MethodDef& method_def) {
uint32_t declaring_class_index = FindClassIndex(dex_file, cache, method_def.declaring_class);
if (declaring_class_index == kIndexNotFound) {
return kIndexNotFound;
}
uint32_t name_index = FindNameIndex(dex_file, cache, method_def.name);
if (name_index == kIndexNotFound) {
return kIndexNotFound;
}
uint32_t proto_index = FindProtoIndex(dex_file, cache, method_def.proto);
if (proto_index == kIndexNotFound) {
return kIndexNotFound;
}
const DexFile::MethodId* method_id =
dex_file->FindMethodId(dex_file->GetTypeId(declaring_class_index),
dex_file->GetStringId(name_index),
dex_file->GetProtoId(proto_index));
if (method_id == nullptr) {
return kIndexNotFound;
}
return dex_file->GetIndexForMethodId(*method_id);
}
DexFileMethodInliner::IndexCache::IndexCache() {
std::fill_n(class_indexes, arraysize(class_indexes), kIndexUnresolved);
std::fill_n(name_indexes, arraysize(name_indexes), kIndexUnresolved);
std::fill_n(proto_indexes, arraysize(proto_indexes), kIndexUnresolved);
}
void DexFileMethodInliner::FindIntrinsics(const DexFile* dex_file) {
DCHECK(dex_file != nullptr);
DCHECK(dex_file_ == nullptr);
IndexCache cache;
for (const IntrinsicDef& def : kIntrinsicMethods) {
uint32_t method_idx = FindMethodIndex(dex_file, &cache, def.method_def);
if (method_idx != kIndexNotFound) {
DCHECK(inline_methods_.find(method_idx) == inline_methods_.end());
inline_methods_.Put(method_idx, def.intrinsic);
}
}
dex_file_ = dex_file;
}
bool DexFileMethodInliner::AddInlineMethod(int32_t method_idx, const InlineMethod& method) {
WriterMutexLock mu(Thread::Current(), lock_);
if (LIKELY(inline_methods_.find(method_idx) == inline_methods_.end())) {
inline_methods_.Put(method_idx, method);
return true;
} else {
if (PrettyMethod(method_idx, *dex_file_) == "int java.lang.String.length()") {
// TODO: String.length is both kIntrinsicIsEmptyOrLength and kInlineOpIGet.
} else {
LOG(WARNING) << "Inliner: " << PrettyMethod(method_idx, *dex_file_) << " already inline";
}
return false;
}
}
uint32_t DexFileMethodInliner::GetOffsetForStringInit(uint32_t method_index, size_t pointer_size) {
ReaderMutexLock mu(Thread::Current(), lock_);
auto it = inline_methods_.find(method_index);
if (it != inline_methods_.end() && (it->second.opcode == kInlineStringInit)) {
uint32_t string_init_base_offset = Thread::QuickEntryPointOffsetWithSize(
OFFSETOF_MEMBER(QuickEntryPoints, pNewEmptyString), pointer_size);
return string_init_base_offset + it->second.d.data * pointer_size;
}
return 0;
}
bool DexFileMethodInliner::IsStringInitMethodIndex(uint32_t method_index) {
ReaderMutexLock mu(Thread::Current(), lock_);
auto it = inline_methods_.find(method_index);
return (it != inline_methods_.end()) && (it->second.opcode == kInlineStringInit);
}
} // namespace art