2 * Copyright (C) 2009 The Android Open Source Project
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
19 #ifndef _DALVIK_INTERP_JIT
20 #define _DALVIK_INTERP_JIT
22 #include "InterpDefs.h"
23 #include "mterp/common/jit-config.h"
25 #define JIT_MAX_TRACE_LEN 100
27 #if defined (WITH_SELF_VERIFICATION)
29 #define REG_SPACE 256 /* default size of shadow space */
30 #define HEAP_SPACE JIT_MAX_TRACE_LEN /* default size of heap space */
32 typedef struct ShadowHeap {
37 typedef struct InstructionTrace {
39 DecodedInstruction decInsn;
42 typedef struct ShadowSpace {
43 const u2* startPC; /* starting pc of jitted region */
44 u4* fp; /* starting fp of jitted region */
46 DvmDex* methodClassDex;
48 const u1* interpStackEnd;
49 SelfVerificationState jitExitState; /* exit point for JIT'ed code */
50 SelfVerificationState selfVerificationState; /* current SV running state */
51 const u2* endPC; /* ending pc of jitted region */
52 void* shadowFP; /* pointer to fp in shadow space */
53 int* registerSpace; /* copy of register state */
54 int registerSpaceSize; /* current size of register space */
55 ShadowHeap heapSpace[HEAP_SPACE]; /* copy of heap space */
56 ShadowHeap* heapSpaceTail; /* tail pointer to heapSpace */
57 const void* endShadowFP; /* ending fp in shadow space */
58 InstructionTrace trace[JIT_MAX_TRACE_LEN]; /* opcode trace for debugging */
59 int traceLength; /* counter for current trace length */
63 * Self verification functions.
65 void* dvmSelfVerificationShadowSpaceAlloc(Thread* self);
66 void dvmSelfVerificationShadowSpaceFree(Thread* self);
67 void* dvmSelfVerificationSaveState(const u2* pc, u4* fp,
70 void* dvmSelfVerificationRestoreState(const u2* pc, u4* fp,
71 SelfVerificationState exitPoint,
73 void dvmCheckSelfVerification(const u2* pc, Thread* self);
77 * Offsets for metadata in the trace run array from the trace that ends with
78 * invoke instructions.
80 #define JIT_TRACE_CLASS_DESC 1
81 #define JIT_TRACE_CLASS_LOADER 2
82 #define JIT_TRACE_CUR_METHOD 3
85 * JitTable hash function.
88 static inline u4 dvmJitHashMask( const u2* p, u4 mask ) {
89 return ((((u4)p>>12)^(u4)p)>>1) & (mask);
92 static inline u4 dvmJitHash( const u2* p ) {
93 return dvmJitHashMask( p, gDvmJit.jitTableMask );
97 * The width of the chain field in JitEntryInfo sets the upper
98 * bound on the number of translations. Be careful if changing
99 * the size of JitEntry struct - the Dalvik PC to JitEntry
100 * hash functions have built-in knowledge of the size.
102 #define JIT_ENTRY_CHAIN_WIDTH 2
103 #define JIT_MAX_ENTRIES (1 << (JIT_ENTRY_CHAIN_WIDTH * 8))
106 * The trace profiling counters are allocated in blocks and individual
107 * counters must not move so long as any referencing trace exists.
109 #define JIT_PROF_BLOCK_ENTRIES 1024
110 #define JIT_PROF_BLOCK_BUCKETS (JIT_MAX_ENTRIES / JIT_PROF_BLOCK_ENTRIES)
112 typedef s4 JitTraceCounter_t;
114 typedef struct JitTraceProfCounters {
116 JitTraceCounter_t *buckets[JIT_PROF_BLOCK_BUCKETS];
117 } JitTraceProfCounters;
120 * Entries in the JIT's address lookup hash table.
121 * Fields which may be updated by multiple threads packed into a
122 * single 32-bit word to allow use of atomic update.
125 typedef struct JitEntryInfo {
126 unsigned int isMethodEntry:1;
127 unsigned int inlineCandidate:1;
128 unsigned int profileEnabled:1;
129 JitInstructionSetType instructionSet:3;
130 unsigned int profileOffset:5;
131 unsigned int unused:5;
132 u2 chain; /* Index of next in chain */
135 typedef union JitEntryInfoUnion {
137 volatile int infoWord;
140 typedef struct JitEntry {
142 const u2* dPC; /* Dalvik code address */
143 void* codeAddress; /* Code address of native translation */
146 void dvmCheckJit(const u2* pc, Thread* self);
147 void* dvmJitGetTraceAddr(const u2* dPC);
148 void* dvmJitGetMethodAddr(const u2* dPC);
149 void dvmJitCheckTraceRequest(Thread* self);
150 void dvmJitStopTranslationRequests(void);
151 void dvmJitStats(void);
152 bool dvmJitResizeJitTable(unsigned int size);
153 void dvmJitResetTable(void);
154 struct JitEntry *dvmJitFindEntry(const u2* pc, bool isMethodEntry);
155 s8 dvmJitd2l(double d);
156 s8 dvmJitf2l(float f);
157 void dvmJitSetCodeAddr(const u2* dPC, void *nPC, JitInstructionSetType set,
158 bool isMethodEntry, int profilePrefixSize);
159 void dvmJitEndTraceSelect(Thread* self, const u2* dPC);
160 JitTraceCounter_t *dvmJitNextTraceCounter(void);
161 void dvmJitTraceProfilingOff(void);
162 void dvmJitTraceProfilingOn(void);
163 void dvmJitChangeProfileMode(TraceProfilingModes newState);
164 void dvmJitDumpTraceDesc(JitTraceDescription *trace);
165 void dvmJitUpdateThreadStateSingle(Thread* threead);
166 void dvmJitUpdateThreadStateAll(void);
167 void dvmJitResumeTranslation(Thread* self, const u2* pc, const u4* fp);
169 #endif /*_DALVIK_INTERP_JIT*/