compiler/dex/quick/dex_file_method_inliner.h - LeafOS-Project/android_art - Gitiles

 /*
  * 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.
  */

 #ifndef ART_COMPILER_DEX_QUICK_DEX_FILE_METHOD_INLINER_H_
 #define ART_COMPILER_DEX_QUICK_DEX_FILE_METHOD_INLINER_H_

 #include <stdint.h>
 #include "base/mutex.h"
 #include "base/macros.h"
 #include "safe_map.h"
 #include "dex/compiler_enums.h"
 #include "dex_file.h"
 #include "quick/inline_method_analyser.h"

 namespace art {

 namespace verifier {
 class MethodVerifier;
 }  // namespace verifier

 struct BasicBlock;
 struct CallInfo;
 struct MIR;
 class MIRGraph;
 class Mir2Lir;

 /**
  * Handles inlining of methods from a particular DexFile.
  *
  * Intrinsics are a special case of inline methods. The DexFile indices for
  * all the supported intrinsic methods are looked up once by the FindIntrinsics
  * function and cached by this class for quick lookup by the method index.
  *
  * TODO: Detect short methods (at least getters, setters and empty functions)
  * from the verifier and mark them for inlining. Inline these methods early
  * during compilation to allow further optimizations. Similarly, provide
  * additional information about intrinsics to the early phases of compilation.
  */
 class DexFileMethodInliner {
   public:
     DexFileMethodInliner();
     ~DexFileMethodInliner();

     /**
      * Analyse method code to determine if the method is a candidate for inlining.
      * If it is, record its data for later.
      *
      * @param verifier the method verifier holding data about the method to analyse.
      * @return true if the method is a candidate for inlining, false otherwise.
      */
     bool AnalyseMethodCode(verifier::MethodVerifier* verifier)
         SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) LOCKS_EXCLUDED(lock_);

     /**
      * Check whether a particular method index corresponds to an intrinsic function.
      */
     bool IsIntrinsic(uint32_t method_index, InlineMethod* intrinsic) LOCKS_EXCLUDED(lock_);

     /**
      * Generate code for an intrinsic function invocation.
      */
     bool GenIntrinsic(Mir2Lir* backend, CallInfo* info) LOCKS_EXCLUDED(lock_);

     /**
      * Check whether a particular method index corresponds to a special function.
      */
     bool IsSpecial(uint32_t method_index) LOCKS_EXCLUDED(lock_);

     /**
      * Generate code for a special function.
      */
     bool GenSpecial(Mir2Lir* backend, uint32_t method_idx) LOCKS_EXCLUDED(lock_);

     /**
      * Try to inline an invoke.
      */
     bool GenInline(MIRGraph* mir_graph, BasicBlock* bb, MIR* invoke, uint32_t method_idx)
         LOCKS_EXCLUDED(lock_);

     /**
      * To avoid multiple lookups of a class by its descriptor, we cache its
      * type index in the IndexCache. These are the indexes into the IndexCache
      * class_indexes array.
      */
     enum ClassCacheIndex : uint8_t {  // unit8_t to save space, make larger if needed
       kClassCacheFirst = 0,
       kClassCacheBoolean = kClassCacheFirst,
       kClassCacheByte,
       kClassCacheChar,
       kClassCacheShort,
       kClassCacheInt,
       kClassCacheLong,
       kClassCacheFloat,
       kClassCacheDouble,
       kClassCacheVoid,
       kClassCacheJavaLangObject,
       kClassCacheJavaLangRefReference,
       kClassCacheJavaLangString,
       kClassCacheJavaLangDouble,
       kClassCacheJavaLangFloat,
       kClassCacheJavaLangInteger,
       kClassCacheJavaLangLong,
       kClassCacheJavaLangShort,
       kClassCacheJavaLangMath,
       kClassCacheJavaLangStrictMath,
       kClassCacheJavaLangThread,
       kClassCacheLibcoreIoMemory,
       kClassCacheSunMiscUnsafe,
       kClassCacheJavaLangSystem,
       kClassCacheJavaLangCharArray,
       kClassCacheLast
     };

     /**
      * To avoid multiple lookups of a method name string, we cache its string
      * index in the IndexCache. These are the indexes into the IndexCache
      * name_indexes array.
      */
     enum NameCacheIndex : uint8_t {  // unit8_t to save space, make larger if needed
       kNameCacheFirst = 0,
       kNameCacheReverse =  kNameCacheFirst,
       kNameCacheReverseBytes,
       kNameCacheDoubleToRawLongBits,
       kNameCacheLongBitsToDouble,
       kNameCacheFloatToRawIntBits,
       kNameCacheIntBitsToFloat,
       kNameCacheAbs,
       kNameCacheMax,
       kNameCacheMin,
       kNameCacheSqrt,
       kNameCacheCeil,
       kNameCacheFloor,
       kNameCacheRint,
       kNameCacheRound,
       kNameCacheReferenceGetReferent,
       kNameCacheCharAt,
       kNameCacheCompareTo,
       kNameCacheIsEmpty,
       kNameCacheIndexOf,
       kNameCacheLength,
       kNameCacheCurrentThread,
       kNameCachePeekByte,
       kNameCachePeekIntNative,
       kNameCachePeekLongNative,
       kNameCachePeekShortNative,
       kNameCachePokeByte,
       kNameCachePokeIntNative,
       kNameCachePokeLongNative,
       kNameCachePokeShortNative,
       kNameCacheCompareAndSwapInt,
       kNameCacheCompareAndSwapLong,
       kNameCacheCompareAndSwapObject,
       kNameCacheGetInt,
       kNameCacheGetIntVolatile,
       kNameCachePutInt,
       kNameCachePutIntVolatile,
       kNameCachePutOrderedInt,
       kNameCacheGetLong,
       kNameCacheGetLongVolatile,
       kNameCachePutLong,
       kNameCachePutLongVolatile,
       kNameCachePutOrderedLong,
       kNameCacheGetObject,
       kNameCacheGetObjectVolatile,
       kNameCachePutObject,
       kNameCachePutObjectVolatile,
       kNameCachePutOrderedObject,
       kNameCacheArrayCopy,
       kNameCacheLast
     };

     /**
      * To avoid multiple lookups of a method signature, we cache its proto
      * index in the IndexCache. These are the indexes into the IndexCache
      * proto_indexes array.
      */
     enum ProtoCacheIndex : uint8_t {  // unit8_t to save space, make larger if needed
       kProtoCacheFirst = 0,
       kProtoCacheI_I = kProtoCacheFirst,
       kProtoCacheJ_J,
       kProtoCacheS_S,
       kProtoCacheD_D,
       kProtoCacheDD_D,
       kProtoCacheF_F,
       kProtoCacheFF_F,
       kProtoCacheD_J,
       kProtoCacheJ_D,
       kProtoCacheF_I,
       kProtoCacheI_F,
       kProtoCacheII_I,
       kProtoCacheI_C,
       kProtoCacheString_I,
       kProtoCache_Z,
       kProtoCache_I,
       kProtoCache_Object,
       kProtoCache_Thread,
       kProtoCacheJ_B,
       kProtoCacheJ_I,
       kProtoCacheJ_S,
       kProtoCacheJB_V,
       kProtoCacheJI_V,
       kProtoCacheJJ_J,
       kProtoCacheJJ_V,
       kProtoCacheJS_V,
       kProtoCacheObjectJII_Z,
       kProtoCacheObjectJJJ_Z,
       kProtoCacheObjectJObjectObject_Z,
       kProtoCacheObjectJ_I,
       kProtoCacheObjectJI_V,
       kProtoCacheObjectJ_J,
       kProtoCacheObjectJJ_V,
       kProtoCacheObjectJ_Object,
       kProtoCacheObjectJObject_V,
       kProtoCacheCharArrayICharArrayII_V,
       kProtoCacheLast
     };

   private:
     /**
      * The maximum number of method parameters we support in the ProtoDef.
      */
     static constexpr uint32_t kProtoMaxParams = 6;

     /**
      * The method signature (proto) definition using cached class indexes.
      * The return_type and params are used with the IndexCache to look up
      * appropriate class indexes to be passed to DexFile::FindProtoId().
      */
     struct ProtoDef {
       ClassCacheIndex return_type;
       uint8_t param_count;
       ClassCacheIndex params[kProtoMaxParams];
     };

     /**
      * The method definition using cached class, name and proto indexes.
      * The class index, method name index and proto index are used with
      * IndexCache to look up appropriate parameters for DexFile::FindMethodId().
      */
     struct MethodDef {
       ClassCacheIndex declaring_class;
       NameCacheIndex name;
       ProtoCacheIndex proto;
     };

     /**
      * The definition of an intrinsic function binds the method definition
      * to an Intrinsic.
      */
     struct IntrinsicDef {
       MethodDef method_def;
       InlineMethod intrinsic;
     };

     /**
      * Cache for class, method name and method signature indexes used during
      * intrinsic function lookup to avoid multiple lookups of the same items.
      *
      * Many classes have multiple intrinsics and/or they are used in multiple
      * method signatures and we want to avoid repeated lookups since they are
      * not exactly cheap. The method names and method signatures are sometimes
      * reused and therefore cached as well.
      */
     struct IndexCache {
       IndexCache();

       uint32_t class_indexes[kClassCacheLast - kClassCacheFirst];
       uint32_t name_indexes[kNameCacheLast - kNameCacheFirst];
       uint32_t proto_indexes[kProtoCacheLast - kProtoCacheFirst];
     };

     static const char* const kClassCacheNames[];
     static const char* const kNameCacheNames[];
     static const ProtoDef kProtoCacheDefs[];
     static const IntrinsicDef kIntrinsicMethods[];

     static const uint32_t kIndexNotFound = static_cast<uint32_t>(-1);
     static const uint32_t kIndexUnresolved = static_cast<uint32_t>(-2);

     static uint32_t FindClassIndex(const DexFile* dex_file, IndexCache* cache,
                                    ClassCacheIndex index);
     static uint32_t FindNameIndex(const DexFile* dex_file, IndexCache* cache,
                                   NameCacheIndex index);
     static uint32_t FindProtoIndex(const DexFile* dex_file, IndexCache* cache,
                                    ProtoCacheIndex index);
     static uint32_t FindMethodIndex(const DexFile* dex_file, IndexCache* cache,
                                     const MethodDef& method_def);

     /**
      * Find all known intrinsic methods in the dex_file and cache their indices.
      *
      * Only DexFileToMethodInlinerMap may call this function to initialize the inliner.
      */
     void FindIntrinsics(const DexFile* dex_file) EXCLUSIVE_LOCKS_REQUIRED(lock_);

     friend class DexFileToMethodInlinerMap;

     bool AddInlineMethod(int32_t method_idx, const InlineMethod& method) LOCKS_EXCLUDED(lock_);

     static bool GenInlineConst(MIRGraph* mir_graph, BasicBlock* bb, MIR* invoke,
                                MIR* move_result, const InlineMethod& method);
     static bool GenInlineReturnArg(MIRGraph* mir_graph, BasicBlock* bb, MIR* invoke,
                                    MIR* move_result, const InlineMethod& method);
     static bool GenInlineIGet(MIRGraph* mir_graph, BasicBlock* bb, MIR* invoke,
                               MIR* move_result, const InlineMethod& method, uint32_t method_idx);
     static bool GenInlineIPut(MIRGraph* mir_graph, BasicBlock* bb, MIR* invoke,
                               MIR* move_result, const InlineMethod& method, uint32_t method_idx);

     ReaderWriterMutex lock_;
     /*
      * Maps method indexes (for the particular DexFile) to Intrinsic defintions.
      */
     SafeMap<uint32_t, InlineMethod> inline_methods_ GUARDED_BY(lock_);
     const DexFile* dex_file_;

     DISALLOW_COPY_AND_ASSIGN(DexFileMethodInliner);
 };

 }  // namespace art

 #endif  // ART_COMPILER_DEX_QUICK_DEX_FILE_METHOD_INLINER_H_
	/*
	* 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.
	*/

	#ifndef ART_COMPILER_DEX_QUICK_DEX_FILE_METHOD_INLINER_H_
	#define ART_COMPILER_DEX_QUICK_DEX_FILE_METHOD_INLINER_H_

	#include <stdint.h>
	#include "base/mutex.h"
	#include "base/macros.h"
	#include "safe_map.h"
	#include "dex/compiler_enums.h"
	#include "dex_file.h"
	#include "quick/inline_method_analyser.h"

	namespace art {

	namespace verifier {
	class MethodVerifier;
	} // namespace verifier

	struct BasicBlock;
	struct CallInfo;
	struct MIR;
	class MIRGraph;
	class Mir2Lir;

	/**
	* Handles inlining of methods from a particular DexFile.
	*
	* Intrinsics are a special case of inline methods. The DexFile indices for
	* all the supported intrinsic methods are looked up once by the FindIntrinsics
	* function and cached by this class for quick lookup by the method index.
	*
	* TODO: Detect short methods (at least getters, setters and empty functions)
	* from the verifier and mark them for inlining. Inline these methods early
	* during compilation to allow further optimizations. Similarly, provide
	* additional information about intrinsics to the early phases of compilation.
	*/
	class DexFileMethodInliner {
	public:
	DexFileMethodInliner();
	~DexFileMethodInliner();

	/**
	* Analyse method code to determine if the method is a candidate for inlining.
	* If it is, record its data for later.
	*
	* @param verifier the method verifier holding data about the method to analyse.
	* @return true if the method is a candidate for inlining, false otherwise.
	*/
	bool AnalyseMethodCode(verifier::MethodVerifier* verifier)
	SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) LOCKS_EXCLUDED(lock_);

	/**
	* Check whether a particular method index corresponds to an intrinsic function.
	*/
	bool IsIntrinsic(uint32_t method_index, InlineMethod* intrinsic) LOCKS_EXCLUDED(lock_);

	/**
	* Generate code for an intrinsic function invocation.
	*/
	bool GenIntrinsic(Mir2Lir* backend, CallInfo* info) LOCKS_EXCLUDED(lock_);

	/**
	* Check whether a particular method index corresponds to a special function.
	*/
	bool IsSpecial(uint32_t method_index) LOCKS_EXCLUDED(lock_);

	/**
	* Generate code for a special function.
	*/
	bool GenSpecial(Mir2Lir* backend, uint32_t method_idx) LOCKS_EXCLUDED(lock_);

	/**
	* Try to inline an invoke.
	*/
	bool GenInline(MIRGraph* mir_graph, BasicBlock* bb, MIR* invoke, uint32_t method_idx)
	LOCKS_EXCLUDED(lock_);

	/**
	* To avoid multiple lookups of a class by its descriptor, we cache its
	* type index in the IndexCache. These are the indexes into the IndexCache
	* class_indexes array.
	*/
	enum ClassCacheIndex : uint8_t { // unit8_t to save space, make larger if needed
	kClassCacheFirst = 0,
	kClassCacheBoolean = kClassCacheFirst,
	kClassCacheByte,
	kClassCacheChar,
	kClassCacheShort,
	kClassCacheInt,
	kClassCacheLong,
	kClassCacheFloat,
	kClassCacheDouble,
	kClassCacheVoid,
	kClassCacheJavaLangObject,
	kClassCacheJavaLangRefReference,
	kClassCacheJavaLangString,
	kClassCacheJavaLangDouble,
	kClassCacheJavaLangFloat,
	kClassCacheJavaLangInteger,
	kClassCacheJavaLangLong,
	kClassCacheJavaLangShort,
	kClassCacheJavaLangMath,
	kClassCacheJavaLangStrictMath,
	kClassCacheJavaLangThread,
	kClassCacheLibcoreIoMemory,
	kClassCacheSunMiscUnsafe,
	kClassCacheJavaLangSystem,
	kClassCacheJavaLangCharArray,
	kClassCacheLast
	};

	/**
	* To avoid multiple lookups of a method name string, we cache its string
	* index in the IndexCache. These are the indexes into the IndexCache
	* name_indexes array.
	*/
	enum NameCacheIndex : uint8_t { // unit8_t to save space, make larger if needed
	kNameCacheFirst = 0,
	kNameCacheReverse = kNameCacheFirst,
	kNameCacheReverseBytes,
	kNameCacheDoubleToRawLongBits,
	kNameCacheLongBitsToDouble,
	kNameCacheFloatToRawIntBits,
	kNameCacheIntBitsToFloat,
	kNameCacheAbs,
	kNameCacheMax,
	kNameCacheMin,
	kNameCacheSqrt,
	kNameCacheCeil,
	kNameCacheFloor,
	kNameCacheRint,
	kNameCacheRound,
	kNameCacheReferenceGetReferent,
	kNameCacheCharAt,
	kNameCacheCompareTo,
	kNameCacheIsEmpty,
	kNameCacheIndexOf,
	kNameCacheLength,
	kNameCacheCurrentThread,
	kNameCachePeekByte,
	kNameCachePeekIntNative,
	kNameCachePeekLongNative,
	kNameCachePeekShortNative,
	kNameCachePokeByte,
	kNameCachePokeIntNative,
	kNameCachePokeLongNative,
	kNameCachePokeShortNative,
	kNameCacheCompareAndSwapInt,
	kNameCacheCompareAndSwapLong,
	kNameCacheCompareAndSwapObject,
	kNameCacheGetInt,
	kNameCacheGetIntVolatile,
	kNameCachePutInt,
	kNameCachePutIntVolatile,
	kNameCachePutOrderedInt,
	kNameCacheGetLong,
	kNameCacheGetLongVolatile,
	kNameCachePutLong,
	kNameCachePutLongVolatile,
	kNameCachePutOrderedLong,
	kNameCacheGetObject,
	kNameCacheGetObjectVolatile,
	kNameCachePutObject,
	kNameCachePutObjectVolatile,
	kNameCachePutOrderedObject,
	kNameCacheArrayCopy,
	kNameCacheLast
	};

	/**
	* To avoid multiple lookups of a method signature, we cache its proto
	* index in the IndexCache. These are the indexes into the IndexCache
	* proto_indexes array.
	*/
	enum ProtoCacheIndex : uint8_t { // unit8_t to save space, make larger if needed
	kProtoCacheFirst = 0,
	kProtoCacheI_I = kProtoCacheFirst,
	kProtoCacheJ_J,
	kProtoCacheS_S,
	kProtoCacheD_D,
	kProtoCacheDD_D,
	kProtoCacheF_F,
	kProtoCacheFF_F,
	kProtoCacheD_J,
	kProtoCacheJ_D,
	kProtoCacheF_I,
	kProtoCacheI_F,
	kProtoCacheII_I,
	kProtoCacheI_C,
	kProtoCacheString_I,
	kProtoCache_Z,
	kProtoCache_I,
	kProtoCache_Object,
	kProtoCache_Thread,
	kProtoCacheJ_B,
	kProtoCacheJ_I,
	kProtoCacheJ_S,
	kProtoCacheJB_V,
	kProtoCacheJI_V,
	kProtoCacheJJ_J,
	kProtoCacheJJ_V,
	kProtoCacheJS_V,
	kProtoCacheObjectJII_Z,
	kProtoCacheObjectJJJ_Z,
	kProtoCacheObjectJObjectObject_Z,
	kProtoCacheObjectJ_I,
	kProtoCacheObjectJI_V,
	kProtoCacheObjectJ_J,
	kProtoCacheObjectJJ_V,
	kProtoCacheObjectJ_Object,
	kProtoCacheObjectJObject_V,
	kProtoCacheCharArrayICharArrayII_V,
	kProtoCacheLast
	};

	private:
	/**
	* The maximum number of method parameters we support in the ProtoDef.
	*/
	static constexpr uint32_t kProtoMaxParams = 6;

	/**
	* The method signature (proto) definition using cached class indexes.
	* The return_type and params are used with the IndexCache to look up
	* appropriate class indexes to be passed to DexFile::FindProtoId().
	*/
	struct ProtoDef {
	ClassCacheIndex return_type;
	uint8_t param_count;
	ClassCacheIndex params[kProtoMaxParams];
	};

	/**
	* The method definition using cached class, name and proto indexes.
	* The class index, method name index and proto index are used with
	* IndexCache to look up appropriate parameters for DexFile::FindMethodId().
	*/
	struct MethodDef {
	ClassCacheIndex declaring_class;
	NameCacheIndex name;
	ProtoCacheIndex proto;
	};

	/**
	* The definition of an intrinsic function binds the method definition
	* to an Intrinsic.
	*/
	struct IntrinsicDef {
	MethodDef method_def;
	InlineMethod intrinsic;
	};

	/**
	* Cache for class, method name and method signature indexes used during
	* intrinsic function lookup to avoid multiple lookups of the same items.
	*
	* Many classes have multiple intrinsics and/or they are used in multiple
	* method signatures and we want to avoid repeated lookups since they are
	* not exactly cheap. The method names and method signatures are sometimes
	* reused and therefore cached as well.
	*/
	struct IndexCache {
	IndexCache();

	uint32_t class_indexes[kClassCacheLast - kClassCacheFirst];
	uint32_t name_indexes[kNameCacheLast - kNameCacheFirst];
	uint32_t proto_indexes[kProtoCacheLast - kProtoCacheFirst];
	};

	static const char* const kClassCacheNames[];
	static const char* const kNameCacheNames[];
	static const ProtoDef kProtoCacheDefs[];
	static const IntrinsicDef kIntrinsicMethods[];

	static const uint32_t kIndexNotFound = static_cast<uint32_t>(-1);
	static const uint32_t kIndexUnresolved = static_cast<uint32_t>(-2);

	static uint32_t FindClassIndex(const DexFile* dex_file, IndexCache* cache,
	ClassCacheIndex index);
	static uint32_t FindNameIndex(const DexFile* dex_file, IndexCache* cache,
	NameCacheIndex index);
	static uint32_t FindProtoIndex(const DexFile* dex_file, IndexCache* cache,
	ProtoCacheIndex index);
	static uint32_t FindMethodIndex(const DexFile* dex_file, IndexCache* cache,
	const MethodDef& method_def);

	/**
	* Find all known intrinsic methods in the dex_file and cache their indices.
	*
	* Only DexFileToMethodInlinerMap may call this function to initialize the inliner.
	*/
	void FindIntrinsics(const DexFile* dex_file) EXCLUSIVE_LOCKS_REQUIRED(lock_);

	friend class DexFileToMethodInlinerMap;

	bool AddInlineMethod(int32_t method_idx, const InlineMethod& method) LOCKS_EXCLUDED(lock_);

	static bool GenInlineConst(MIRGraph* mir_graph, BasicBlock* bb, MIR* invoke,
	MIR* move_result, const InlineMethod& method);
	static bool GenInlineReturnArg(MIRGraph* mir_graph, BasicBlock* bb, MIR* invoke,
	MIR* move_result, const InlineMethod& method);
	static bool GenInlineIGet(MIRGraph* mir_graph, BasicBlock* bb, MIR* invoke,
	MIR* move_result, const InlineMethod& method, uint32_t method_idx);
	static bool GenInlineIPut(MIRGraph* mir_graph, BasicBlock* bb, MIR* invoke,
	MIR* move_result, const InlineMethod& method, uint32_t method_idx);

	ReaderWriterMutex lock_;
	/*
	* Maps method indexes (for the particular DexFile) to Intrinsic defintions.
	*/
	SafeMap<uint32_t, InlineMethod> inline_methods_ GUARDED_BY(lock_);
	const DexFile* dex_file_;

	DISALLOW_COPY_AND_ASSIGN(DexFileMethodInliner);
	};

	} // namespace art

	#endif // ART_COMPILER_DEX_QUICK_DEX_FILE_METHOD_INLINER_H_