1 /*
2 * Copyright (C) 2008 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 /* common includes */
18 #include "Dalvik.h"
19 #include "interp/InterpDefs.h"
20 #include "mterp/Mterp.h"
21 #include <math.h> // needed for fmod, fmodf
22 #include "mterp/common/FindInterface.h"
23
24 /*
25 * Configuration defines. These affect the C implementations, i.e. the
26 * portable interpreter(s) and C stubs.
27 *
28 * Some defines are controlled by the Makefile, e.g.:
29 * WITH_INSTR_CHECKS
30 * WITH_TRACKREF_CHECKS
31 * EASY_GDB
32 * NDEBUG
33 */
34
35 #ifdef WITH_INSTR_CHECKS /* instruction-level paranoia (slow!) */
36 # define CHECK_BRANCH_OFFSETS
37 # define CHECK_REGISTER_INDICES
38 #endif
39
40 /*
41 * Some architectures require 64-bit alignment for access to 64-bit data
42 * types. We can't just use pointers to copy 64-bit values out of our
43 * interpreted register set, because gcc may assume the pointer target is
44 * aligned and generate invalid code.
45 *
46 * There are two common approaches:
47 * (1) Use a union that defines a 32-bit pair and a 64-bit value.
48 * (2) Call memcpy().
49 *
50 * Depending upon what compiler you're using and what options are specified,
51 * one may be faster than the other. For example, the compiler might
52 * convert a memcpy() of 8 bytes into a series of instructions and omit
53 * the call. The union version could cause some strange side-effects,
54 * e.g. for a while ARM gcc thought it needed separate storage for each
55 * inlined instance, and generated instructions to zero out ~700 bytes of
56 * stack space at the top of the interpreter.
57 *
58 * The default is to use memcpy(). The current gcc for ARM seems to do
59 * better with the union.
60 */
61 #if defined(__ARM_EABI__)
62 # define NO_UNALIGN_64__UNION
63 #endif
64 /*
65 * MIPS ABI requires 64-bit alignment for access to 64-bit data types.
66 *
67 * Use memcpy() to do the transfer
68 */
69 #if defined(__mips__)
70 /* # define NO_UNALIGN_64__UNION */
71 #endif
72
73
74 //#define LOG_INSTR /* verbose debugging */
75 /* set and adjust ANDROID_LOG_TAGS='*:i jdwp:i dalvikvm:i dalvikvmi:i' */
76
77 /*
78 * Export another copy of the PC on every instruction; this is largely
79 * redundant with EXPORT_PC and the debugger code. This value can be
80 * compared against what we have stored on the stack with EXPORT_PC to
81 * help ensure that we aren't missing any export calls.
82 */
83 #if WITH_EXTRA_GC_CHECKS > 1
84 # define EXPORT_EXTRA_PC() (self->currentPc2 = pc)
85 #else
86 # define EXPORT_EXTRA_PC()
87 #endif
88
89 /*
90 * Adjust the program counter. "_offset" is a signed int, in 16-bit units.
91 *
92 * Assumes the existence of "const u2* pc" and "const u2* curMethod->insns".
93 *
94 * We don't advance the program counter until we finish an instruction or
95 * branch, because we do want to have to unroll the PC if there's an
96 * exception.
97 */
98 #ifdef CHECK_BRANCH_OFFSETS
99 # define ADJUST_PC(_offset) do { \
100 int myoff = _offset; /* deref only once */ \
101 if (pc + myoff < curMethod->insns || \
102 pc + myoff >= curMethod->insns + dvmGetMethodInsnsSize(curMethod)) \
103 { \
104 char* desc; \
105 desc = dexProtoCopyMethodDescriptor(&curMethod->prototype); \
106 ALOGE("Invalid branch %d at 0x%04x in %s.%s %s", \
107 myoff, (int) (pc - curMethod->insns), \
108 curMethod->clazz->descriptor, curMethod->name, desc); \
109 free(desc); \
110 dvmAbort(); \
111 } \
112 pc += myoff; \
113 EXPORT_EXTRA_PC(); \
114 } while (false)
115 #else
116 # define ADJUST_PC(_offset) do { \
117 pc += _offset; \
118 EXPORT_EXTRA_PC(); \
119 } while (false)
120 #endif
121
122 /*
123 * If enabled, log instructions as we execute them.
124 */
125 #ifdef LOG_INSTR
126 # define ILOGD(...) ILOG(LOG_DEBUG, __VA_ARGS__)
127 # define ILOGV(...) ILOG(LOG_VERBOSE, __VA_ARGS__)
128 # define ILOG(_level, ...) do { \
129 char debugStrBuf[128]; \
130 snprintf(debugStrBuf, sizeof(debugStrBuf), __VA_ARGS__); \
131 if (curMethod != NULL) \
132 ALOG(_level, LOG_TAG"i", "%-2d|%04x%s", \
133 self->threadId, (int)(pc - curMethod->insns), debugStrBuf); \
134 else \
135 ALOG(_level, LOG_TAG"i", "%-2d|####%s", \
136 self->threadId, debugStrBuf); \
137 } while(false)
138 void dvmDumpRegs(const Method* method, const u4* framePtr, bool inOnly);
139 # define DUMP_REGS(_meth, _frame, _inOnly) dvmDumpRegs(_meth, _frame, _inOnly)
140 static const char kSpacing[] = " ";
141 #else
142 # define ILOGD(...) ((void)0)
143 # define ILOGV(...) ((void)0)
144 # define DUMP_REGS(_meth, _frame, _inOnly) ((void)0)
145 #endif
146
147 /* get a long from an array of u4 */
getLongFromArray(const u4 * ptr,int idx)148 static inline s8 getLongFromArray(const u4* ptr, int idx)
149 {
150 #if defined(NO_UNALIGN_64__UNION)
151 union { s8 ll; u4 parts[2]; } conv;
152
153 ptr += idx;
154 conv.parts[0] = ptr[0];
155 conv.parts[1] = ptr[1];
156 return conv.ll;
157 #else
158 s8 val;
159 memcpy(&val, &ptr[idx], 8);
160 return val;
161 #endif
162 }
163
164 /* store a long into an array of u4 */
putLongToArray(u4 * ptr,int idx,s8 val)165 static inline void putLongToArray(u4* ptr, int idx, s8 val)
166 {
167 #if defined(NO_UNALIGN_64__UNION)
168 union { s8 ll; u4 parts[2]; } conv;
169
170 ptr += idx;
171 conv.ll = val;
172 ptr[0] = conv.parts[0];
173 ptr[1] = conv.parts[1];
174 #else
175 memcpy(&ptr[idx], &val, 8);
176 #endif
177 }
178
179 /* get a double from an array of u4 */
getDoubleFromArray(const u4 * ptr,int idx)180 static inline double getDoubleFromArray(const u4* ptr, int idx)
181 {
182 #if defined(NO_UNALIGN_64__UNION)
183 union { double d; u4 parts[2]; } conv;
184
185 ptr += idx;
186 conv.parts[0] = ptr[0];
187 conv.parts[1] = ptr[1];
188 return conv.d;
189 #else
190 double dval;
191 memcpy(&dval, &ptr[idx], 8);
192 return dval;
193 #endif
194 }
195
196 /* store a double into an array of u4 */
putDoubleToArray(u4 * ptr,int idx,double dval)197 static inline void putDoubleToArray(u4* ptr, int idx, double dval)
198 {
199 #if defined(NO_UNALIGN_64__UNION)
200 union { double d; u4 parts[2]; } conv;
201
202 ptr += idx;
203 conv.d = dval;
204 ptr[0] = conv.parts[0];
205 ptr[1] = conv.parts[1];
206 #else
207 memcpy(&ptr[idx], &dval, 8);
208 #endif
209 }
210
211 /*
212 * If enabled, validate the register number on every access. Otherwise,
213 * just do an array access.
214 *
215 * Assumes the existence of "u4* fp".
216 *
217 * "_idx" may be referenced more than once.
218 */
219 #ifdef CHECK_REGISTER_INDICES
220 # define GET_REGISTER(_idx) \
221 ( (_idx) < curMethod->registersSize ? \
222 (fp[(_idx)]) : (assert(!"bad reg"),1969) )
223 # define SET_REGISTER(_idx, _val) \
224 ( (_idx) < curMethod->registersSize ? \
225 (fp[(_idx)] = (u4)(_val)) : (assert(!"bad reg"),1969) )
226 # define GET_REGISTER_AS_OBJECT(_idx) ((Object *)GET_REGISTER(_idx))
227 # define SET_REGISTER_AS_OBJECT(_idx, _val) SET_REGISTER(_idx, (s4)_val)
228 # define GET_REGISTER_INT(_idx) ((s4) GET_REGISTER(_idx))
229 # define SET_REGISTER_INT(_idx, _val) SET_REGISTER(_idx, (s4)_val)
230 # define GET_REGISTER_WIDE(_idx) \
231 ( (_idx) < curMethod->registersSize-1 ? \
232 getLongFromArray(fp, (_idx)) : (assert(!"bad reg"),1969) )
233 # define SET_REGISTER_WIDE(_idx, _val) \
234 ( (_idx) < curMethod->registersSize-1 ? \
235 (void)putLongToArray(fp, (_idx), (_val)) : assert(!"bad reg") )
236 # define GET_REGISTER_FLOAT(_idx) \
237 ( (_idx) < curMethod->registersSize ? \
238 (*((float*) &fp[(_idx)])) : (assert(!"bad reg"),1969.0f) )
239 # define SET_REGISTER_FLOAT(_idx, _val) \
240 ( (_idx) < curMethod->registersSize ? \
241 (*((float*) &fp[(_idx)]) = (_val)) : (assert(!"bad reg"),1969.0f) )
242 # define GET_REGISTER_DOUBLE(_idx) \
243 ( (_idx) < curMethod->registersSize-1 ? \
244 getDoubleFromArray(fp, (_idx)) : (assert(!"bad reg"),1969.0) )
245 # define SET_REGISTER_DOUBLE(_idx, _val) \
246 ( (_idx) < curMethod->registersSize-1 ? \
247 (void)putDoubleToArray(fp, (_idx), (_val)) : assert(!"bad reg") )
248 #else
249 # define GET_REGISTER(_idx) (fp[(_idx)])
250 # define SET_REGISTER(_idx, _val) (fp[(_idx)] = (_val))
251 # define GET_REGISTER_AS_OBJECT(_idx) ((Object*) fp[(_idx)])
252 # define SET_REGISTER_AS_OBJECT(_idx, _val) (fp[(_idx)] = (u4)(_val))
253 # define GET_REGISTER_INT(_idx) ((s4)GET_REGISTER(_idx))
254 # define SET_REGISTER_INT(_idx, _val) SET_REGISTER(_idx, (s4)_val)
255 # define GET_REGISTER_WIDE(_idx) getLongFromArray(fp, (_idx))
256 # define SET_REGISTER_WIDE(_idx, _val) putLongToArray(fp, (_idx), (_val))
257 # define GET_REGISTER_FLOAT(_idx) (*((float*) &fp[(_idx)]))
258 # define SET_REGISTER_FLOAT(_idx, _val) (*((float*) &fp[(_idx)]) = (_val))
259 # define GET_REGISTER_DOUBLE(_idx) getDoubleFromArray(fp, (_idx))
260 # define SET_REGISTER_DOUBLE(_idx, _val) putDoubleToArray(fp, (_idx), (_val))
261 #endif
262
263 /*
264 * Get 16 bits from the specified offset of the program counter. We always
265 * want to load 16 bits at a time from the instruction stream -- it's more
266 * efficient than 8 and won't have the alignment problems that 32 might.
267 *
268 * Assumes existence of "const u2* pc".
269 */
270 #define FETCH(_offset) (pc[(_offset)])
271
272 /*
273 * Extract instruction byte from 16-bit fetch (_inst is a u2).
274 */
275 #define INST_INST(_inst) ((_inst) & 0xff)
276
277 /*
278 * Replace the opcode (used when handling breakpoints). _opcode is a u1.
279 */
280 #define INST_REPLACE_OP(_inst, _opcode) (((_inst) & 0xff00) | _opcode)
281
282 /*
283 * Extract the "vA, vB" 4-bit registers from the instruction word (_inst is u2).
284 */
285 #define INST_A(_inst) (((_inst) >> 8) & 0x0f)
286 #define INST_B(_inst) ((_inst) >> 12)
287
288 /*
289 * Get the 8-bit "vAA" 8-bit register index from the instruction word.
290 * (_inst is u2)
291 */
292 #define INST_AA(_inst) ((_inst) >> 8)
293
294 /*
295 * The current PC must be available to Throwable constructors, e.g.
296 * those created by the various exception throw routines, so that the
297 * exception stack trace can be generated correctly. If we don't do this,
298 * the offset within the current method won't be shown correctly. See the
299 * notes in Exception.c.
300 *
301 * This is also used to determine the address for precise GC.
302 *
303 * Assumes existence of "u4* fp" and "const u2* pc".
304 */
305 #define EXPORT_PC() (SAVEAREA_FROM_FP(fp)->xtra.currentPc = pc)
306
307 /*
308 * Check to see if "obj" is NULL. If so, throw an exception. Assumes the
309 * pc has already been exported to the stack.
310 *
311 * Perform additional checks on debug builds.
312 *
313 * Use this to check for NULL when the instruction handler calls into
314 * something that could throw an exception (so we have already called
315 * EXPORT_PC at the top).
316 */
checkForNull(Object * obj)317 static inline bool checkForNull(Object* obj)
318 {
319 if (obj == NULL) {
320 dvmThrowNullPointerException(NULL);
321 return false;
322 }
323 #ifdef WITH_EXTRA_OBJECT_VALIDATION
324 if (!dvmIsHeapAddress(obj)) {
325 ALOGE("Invalid object %p", obj);
326 dvmAbort();
327 }
328 #endif
329 #ifndef NDEBUG
330 if (obj->clazz == NULL || ((u4) obj->clazz) <= 65536) {
331 /* probable heap corruption */
332 ALOGE("Invalid object class %p (in %p)", obj->clazz, obj);
333 dvmAbort();
334 }
335 #endif
336 return true;
337 }
338
339 /*
340 * Check to see if "obj" is NULL. If so, export the PC into the stack
341 * frame and throw an exception.
342 *
343 * Perform additional checks on debug builds.
344 *
345 * Use this to check for NULL when the instruction handler doesn't do
346 * anything else that can throw an exception.
347 */
checkForNullExportPC(Object * obj,u4 * fp,const u2 * pc)348 static inline bool checkForNullExportPC(Object* obj, u4* fp, const u2* pc)
349 {
350 if (obj == NULL) {
351 EXPORT_PC();
352 dvmThrowNullPointerException(NULL);
353 return false;
354 }
355 #ifdef WITH_EXTRA_OBJECT_VALIDATION
356 if (!dvmIsHeapAddress(obj)) {
357 ALOGE("Invalid object %p", obj);
358 dvmAbort();
359 }
360 #endif
361 #ifndef NDEBUG
362 if (obj->clazz == NULL || ((u4) obj->clazz) <= 65536) {
363 /* probable heap corruption */
364 ALOGE("Invalid object class %p (in %p)", obj->clazz, obj);
365 dvmAbort();
366 }
367 #endif
368 return true;
369 }
370