| /* |
| * Copyright (C) 2009 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 <Thread.h> |
| #include <setjmp.h> |
| |
| #ifndef _DALVIK_VM_COMPILER |
| #define _DALVIK_VM_COMPILER |
| |
| /* |
| * Uncomment the following to enable JIT signature breakpoint |
| * #define SIGNATURE_BREAKPOINT |
| */ |
| |
| #define COMPILER_WORK_QUEUE_SIZE 100 |
| #define COMPILER_IC_PATCH_QUEUE_SIZE 64 |
| |
| /* Architectural-independent parameters for predicted chains */ |
| #define PREDICTED_CHAIN_CLAZZ_INIT 0 |
| #define PREDICTED_CHAIN_METHOD_INIT 0 |
| #define PREDICTED_CHAIN_COUNTER_INIT 0 |
| /* A fake value which will avoid initialization and won't match any class */ |
| #define PREDICTED_CHAIN_FAKE_CLAZZ 0xdeadc001 |
| /* Has to be positive */ |
| #define PREDICTED_CHAIN_COUNTER_AVOID 0x7fffffff |
| /* Rechain after this many misses - shared globally and has to be positive */ |
| #define PREDICTED_CHAIN_COUNTER_RECHAIN 8192 |
| |
| #define COMPILER_TRACED(X) |
| #define COMPILER_TRACEE(X) |
| #define COMPILER_TRACE_CHAINING(X) |
| |
| /* Macro to change the permissions applied to a chunk of the code cache */ |
| #define PROTECT_CODE_CACHE_ATTRS (PROT_READ | PROT_EXEC) |
| #define UNPROTECT_CODE_CACHE_ATTRS (PROT_READ | PROT_EXEC | PROT_WRITE) |
| |
| /* Acquire the lock before removing PROT_WRITE from the specified mem region */ |
| #define UNPROTECT_CODE_CACHE(addr, size) \ |
| { \ |
| dvmLockMutex(&gDvmJit.codeCacheProtectionLock); \ |
| mprotect((void *) (((intptr_t) (addr)) & ~gDvmJit.pageSizeMask), \ |
| (size) + (((intptr_t) (addr)) & gDvmJit.pageSizeMask), \ |
| (UNPROTECT_CODE_CACHE_ATTRS)); \ |
| } |
| |
| /* Add the PROT_WRITE to the specified memory region then release the lock */ |
| #define PROTECT_CODE_CACHE(addr, size) \ |
| { \ |
| mprotect((void *) (((intptr_t) (addr)) & ~gDvmJit.pageSizeMask), \ |
| (size) + (((intptr_t) (addr)) & gDvmJit.pageSizeMask), \ |
| (PROTECT_CODE_CACHE_ATTRS)); \ |
| dvmUnlockMutex(&gDvmJit.codeCacheProtectionLock); \ |
| } |
| |
| #define SINGLE_STEP_OP(opcode) \ |
| (gDvmJit.includeSelectedOp != \ |
| ((gDvmJit.opList[opcode >> 3] & (1 << (opcode & 0x7))) != 0)) |
| |
| typedef enum JitInstructionSetType { |
| DALVIK_JIT_NONE = 0, |
| DALVIK_JIT_ARM, |
| DALVIK_JIT_THUMB, |
| DALVIK_JIT_THUMB2, |
| DALVIK_JIT_IA32 |
| } JitInstructionSetType; |
| |
| /* Description of a compiled trace. */ |
| typedef struct JitTranslationInfo { |
| void *codeAddress; |
| JitInstructionSetType instructionSet; |
| int profileCodeSize; |
| bool discardResult; // Used for debugging divergence and IC patching |
| bool methodCompilationAborted; // Cannot compile the whole method |
| Thread *requestingThread; // For debugging purpose |
| int cacheVersion; // Used to identify stale trace requests |
| } JitTranslationInfo; |
| |
| typedef enum WorkOrderKind { |
| kWorkOrderInvalid = 0, // Should never see by the backend |
| kWorkOrderMethod = 1, // Work is to compile a whole method |
| kWorkOrderTrace = 2, // Work is to compile code fragment(s) |
| kWorkOrderTraceDebug = 3, // Work is to compile/debug code fragment(s) |
| kWorkOrderProfileMode = 4, // Change profiling mode |
| } WorkOrderKind; |
| |
| typedef struct CompilerWorkOrder { |
| const u2* pc; |
| WorkOrderKind kind; |
| void* info; |
| JitTranslationInfo result; |
| jmp_buf *bailPtr; |
| } CompilerWorkOrder; |
| |
| /* Chain cell for predicted method invocation */ |
| typedef struct PredictedChainingCell { |
| u4 branch; /* Branch to chained destination */ |
| const ClassObject *clazz; /* key for prediction */ |
| const Method *method; /* to lookup native PC from dalvik PC */ |
| const ClassObject *stagedClazz; /* possible next key for prediction */ |
| } PredictedChainingCell; |
| |
| /* Work order for inline cache patching */ |
| typedef struct ICPatchWorkOrder { |
| PredictedChainingCell *cellAddr; /* Address to be patched */ |
| PredictedChainingCell cellContent; /* content of the new cell */ |
| const char *classDescriptor; /* Descriptor of the class object */ |
| Object *classLoader; /* Class loader */ |
| u4 serialNumber; /* Serial # (for verification only) */ |
| } ICPatchWorkOrder; |
| |
| /* |
| * Trace description as will appear in the translation cache. Note |
| * flexible array at end, as these will be of variable size. To |
| * conserve space in the translation cache, total length of JitTraceRun |
| * array must be recomputed via seqential scan if needed. |
| */ |
| typedef struct { |
| const Method* method; |
| JitTraceRun trace[0]; // Variable-length trace descriptors |
| } JitTraceDescription; |
| |
| typedef enum JitMethodAttributes { |
| kIsCallee = 0, /* Code is part of a callee (invoked by a hot trace) */ |
| kIsHot, /* Code is part of a hot trace */ |
| kIsLeaf, /* Method is leaf */ |
| kIsEmpty, /* Method is empty */ |
| kIsThrowFree, /* Method doesn't throw */ |
| kIsGetter, /* Method fits the getter pattern */ |
| kIsSetter, /* Method fits the setter pattern */ |
| kCannotCompile, /* Method cannot be compiled */ |
| } JitMethodAttributes; |
| |
| #define METHOD_IS_CALLEE (1 << kIsCallee) |
| #define METHOD_IS_HOT (1 << kIsHot) |
| #define METHOD_IS_LEAF (1 << kIsLeaf) |
| #define METHOD_IS_EMPTY (1 << kIsEmpty) |
| #define METHOD_IS_THROW_FREE (1 << kIsThrowFree) |
| #define METHOD_IS_GETTER (1 << kIsGetter) |
| #define METHOD_IS_SETTER (1 << kIsSetter) |
| #define METHOD_CANNOT_COMPILE (1 << kCannotCompile) |
| |
| /* Vectors to provide optimization hints */ |
| typedef enum JitOptimizationHints { |
| kJitOptNoLoop = 0, // Disable loop formation/optimization |
| } JitOptimizationHints; |
| |
| #define JIT_OPT_NO_LOOP (1 << kJitOptNoLoop) |
| |
| /* Customized node traversal orders for different needs */ |
| typedef enum DataFlowAnalysisMode { |
| kAllNodes = 0, // All nodes |
| kReachableNodes, // All reachable nodes |
| kPreOrderDFSTraversal, // Depth-First-Search / Pre-Order |
| kPostOrderDFSTraversal, // Depth-First-Search / Post-Order |
| kPostOrderDOMTraversal, // Dominator tree / Post-Order |
| } DataFlowAnalysisMode; |
| |
| typedef struct CompilerMethodStats { |
| const Method *method; // Used as hash entry signature |
| int dalvikSize; // # of bytes for dalvik bytecodes |
| int compiledDalvikSize; // # of compiled dalvik bytecodes |
| int nativeSize; // # of bytes for produced native code |
| int attributes; // attribute vector |
| } CompilerMethodStats; |
| |
| struct CompilationUnit; |
| struct BasicBlock; |
| struct SSARepresentation; |
| struct GrowableList; |
| struct JitEntry; |
| struct MIR; |
| |
| bool dvmCompilerSetupCodeCache(void); |
| bool dvmCompilerArchInit(void); |
| void dvmCompilerArchDump(void); |
| bool dvmCompilerStartup(void); |
| void dvmCompilerShutdown(void); |
| void dvmCompilerForceWorkEnqueue(const u2* pc, WorkOrderKind kind, void* info); |
| bool dvmCompilerWorkEnqueue(const u2* pc, WorkOrderKind kind, void* info); |
| void *dvmCheckCodeCache(void *method); |
| CompilerMethodStats *dvmCompilerAnalyzeMethodBody(const Method *method, |
| bool isCallee); |
| bool dvmCompilerCanIncludeThisInstruction(const Method *method, |
| const DecodedInstruction *insn); |
| bool dvmCompileMethod(const Method *method, JitTranslationInfo *info); |
| bool dvmCompileTrace(JitTraceDescription *trace, int numMaxInsts, |
| JitTranslationInfo *info, jmp_buf *bailPtr, int optHints); |
| void dvmCompilerDumpStats(void); |
| void dvmCompilerDrainQueue(void); |
| void dvmJitUnchainAll(void); |
| void dvmJitScanAllClassPointers(void (*callback)(void *ptr)); |
| void dvmCompilerSortAndPrintTraceProfiles(void); |
| void dvmCompilerPerformSafePointChecks(void); |
| void dvmCompilerInlineMIR(struct CompilationUnit *cUnit, |
| JitTranslationInfo *info); |
| void dvmInitializeSSAConversion(struct CompilationUnit *cUnit); |
| int dvmConvertSSARegToDalvik(const struct CompilationUnit *cUnit, int ssaReg); |
| bool dvmCompilerLoopOpt(struct CompilationUnit *cUnit); |
| void dvmCompilerInsertBackwardChaining(struct CompilationUnit *cUnit); |
| void dvmCompilerNonLoopAnalysis(struct CompilationUnit *cUnit); |
| bool dvmCompilerFindLocalLiveIn(struct CompilationUnit *cUnit, |
| struct BasicBlock *bb); |
| bool dvmCompilerDoSSAConversion(struct CompilationUnit *cUnit, |
| struct BasicBlock *bb); |
| bool dvmCompilerDoConstantPropagation(struct CompilationUnit *cUnit, |
| struct BasicBlock *bb); |
| bool dvmCompilerFindInductionVariables(struct CompilationUnit *cUnit, |
| struct BasicBlock *bb); |
| /* Clear the visited flag for each BB */ |
| bool dvmCompilerClearVisitedFlag(struct CompilationUnit *cUnit, |
| struct BasicBlock *bb); |
| char *dvmCompilerGetDalvikDisassembly(const DecodedInstruction *insn, |
| char *note); |
| char *dvmCompilerFullDisassembler(const struct CompilationUnit *cUnit, |
| const struct MIR *mir); |
| char *dvmCompilerGetSSAString(struct CompilationUnit *cUnit, |
| struct SSARepresentation *ssaRep); |
| void dvmCompilerDataFlowAnalysisDispatcher(struct CompilationUnit *cUnit, |
| bool (*func)(struct CompilationUnit *, struct BasicBlock *), |
| DataFlowAnalysisMode dfaMode, |
| bool isIterative); |
| void dvmCompilerMethodSSATransformation(struct CompilationUnit *cUnit); |
| bool dvmCompilerBuildLoop(struct CompilationUnit *cUnit); |
| void dvmCompilerUpdateGlobalState(void); |
| JitTraceDescription *dvmCopyTraceDescriptor(const u2 *pc, |
| const struct JitEntry *desc); |
| void *dvmCompilerGetInterpretTemplate(); |
| JitInstructionSetType dvmCompilerGetInterpretTemplateSet(); |
| u8 dvmGetRegResourceMask(int reg); |
| void dvmDumpCFG(struct CompilationUnit *cUnit, const char *dirPrefix); |
| #endif /* _DALVIK_VM_COMPILER */ |