1 /*
2 * Copyright (C) 2009 The Android Open Source Project
3 *
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
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
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.
15 */
16 /*
17 * Jit control
18 */
19 #ifndef DALVIK_INTERP_JIT_H_
20 #define DALVIK_INTERP_JIT_H_
21
22 #include "InterpDefs.h"
23 #include "mterp/common/jit-config.h"
24
25 #define JIT_MAX_TRACE_LEN 100
26
27 #if defined (WITH_SELF_VERIFICATION)
28
29 #define REG_SPACE 256 /* default size of shadow space */
30 #define HEAP_SPACE JIT_MAX_TRACE_LEN /* default size of heap space */
31
32 struct ShadowHeap {
33 int addr;
34 int data;
35 };
36
37 struct InstructionTrace {
38 int addr;
39 DecodedInstruction decInsn;
40 };
41
42 struct ShadowSpace {
43 const u2* startPC; /* starting pc of jitted region */
44 u4* fp; /* starting fp of jitted region */
45 const Method *method;
46 DvmDex* methodClassDex;
47 JValue retval;
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 */
60 };
61
62 /*
63 * Self verification functions.
64 */
65 extern "C" {
66 void* dvmSelfVerificationShadowSpaceAlloc(Thread* self);
67 void dvmSelfVerificationShadowSpaceFree(Thread* self);
68 void* dvmSelfVerificationSaveState(const u2* pc, u4* fp,
69 Thread* self,
70 int targetTrace);
71 void* dvmSelfVerificationRestoreState(const u2* pc, u4* fp,
72 SelfVerificationState exitPoint,
73 Thread *self);
74 void dvmCheckSelfVerification(const u2* pc, Thread* self);
75 }
76 #endif
77
78 /*
79 * Offsets for metadata in the trace run array from the trace that ends with
80 * invoke instructions.
81 */
82 #define JIT_TRACE_CLASS_DESC 1
83 #define JIT_TRACE_CLASS_LOADER 2
84 #define JIT_TRACE_CUR_METHOD 3
85
86 /*
87 * JitTable hash function.
88 */
89
dvmJitHashMask(const u2 * p,u4 mask)90 static inline u4 dvmJitHashMask( const u2* p, u4 mask ) {
91 return ((((u4)p>>12)^(u4)p)>>1) & (mask);
92 }
93
dvmJitHash(const u2 * p)94 static inline u4 dvmJitHash( const u2* p ) {
95 return dvmJitHashMask( p, gDvmJit.jitTableMask );
96 }
97
98 /*
99 * The width of the chain field in JitEntryInfo sets the upper
100 * bound on the number of translations. Be careful if changing
101 * the size of JitEntry struct - the Dalvik PC to JitEntry
102 * hash functions have built-in knowledge of the size.
103 */
104 #define JIT_ENTRY_CHAIN_WIDTH 2
105 #define JIT_MAX_ENTRIES (1 << (JIT_ENTRY_CHAIN_WIDTH * 8))
106
107 /*
108 * The trace profiling counters are allocated in blocks and individual
109 * counters must not move so long as any referencing trace exists.
110 */
111 #define JIT_PROF_BLOCK_ENTRIES 1024
112 #define JIT_PROF_BLOCK_BUCKETS (JIT_MAX_ENTRIES / JIT_PROF_BLOCK_ENTRIES)
113
114 typedef s4 JitTraceCounter_t;
115
116 struct JitTraceProfCounters {
117 unsigned int next;
118 JitTraceCounter_t *buckets[JIT_PROF_BLOCK_BUCKETS];
119 };
120
121 /*
122 * Entries in the JIT's address lookup hash table.
123 * Fields which may be updated by multiple threads packed into a
124 * single 32-bit word to allow use of atomic update.
125 */
126
127 struct JitEntryInfo {
128 unsigned int isMethodEntry:1;
129 unsigned int inlineCandidate:1;
130 unsigned int profileEnabled:1;
131 JitInstructionSetType instructionSet:3;
132 unsigned int profileOffset:5;
133 unsigned int unused:5;
134 u2 chain; /* Index of next in chain */
135 };
136
137 union JitEntryInfoUnion {
138 JitEntryInfo info;
139 volatile int infoWord;
140 };
141
142 struct JitEntry {
143 JitEntryInfoUnion u;
144 const u2* dPC; /* Dalvik code address */
145 void* codeAddress; /* Code address of native translation */
146 };
147
148 extern "C" {
149 void dvmCheckJit(const u2* pc, Thread* self);
150 void* dvmJitGetTraceAddr(const u2* dPC);
151 void* dvmJitGetMethodAddr(const u2* dPC);
152 void* dvmJitGetTraceAddrThread(const u2* dPC, Thread* self);
153 void* dvmJitGetMethodAddrThread(const u2* dPC, Thread* self);
154 void dvmJitCheckTraceRequest(Thread* self);
155 void dvmJitStopTranslationRequests(void);
156 #if defined(WITH_JIT_TUNING)
157 void dvmBumpNoChain(int from);
158 void dvmBumpNormal(void);
159 void dvmBumpPunt(int from);
160 #endif
161 void dvmJitStats(void);
162 bool dvmJitResizeJitTable(unsigned int size);
163 void dvmJitResetTable(void);
164 JitEntry *dvmJitFindEntry(const u2* pc, bool isMethodEntry);
165 s8 dvmJitd2l(double d);
166 s8 dvmJitf2l(float f);
167 void dvmJitSetCodeAddr(const u2* dPC, void *nPC, JitInstructionSetType set,
168 bool isMethodEntry, int profilePrefixSize);
169 void dvmJitEndTraceSelect(Thread* self, const u2* dPC);
170 JitTraceCounter_t *dvmJitNextTraceCounter(void);
171 void dvmJitTraceProfilingOff(void);
172 void dvmJitTraceProfilingOn(void);
173 void dvmJitChangeProfileMode(TraceProfilingModes newState);
174 void dvmJitDumpTraceDesc(JitTraceDescription *trace);
175 void dvmJitUpdateThreadStateSingle(Thread* threead);
176 void dvmJitUpdateThreadStateAll(void);
177 void dvmJitResumeTranslation(Thread* self, const u2* pc, const u4* fp);
178 }
179
180 #endif // DALVIK_INTERP_JIT_H_
181