Gitiles
Code Review Sign In
review.blissroms.org / platform_art / d2fe10a3a34af171bf1631219cd2d6ff6b7778b5 / . / runtime / interpreter / interpreter_switch_impl.cc
blob: abee1dbec64b4d57c581fb4672af7f4ac71e256f [file] [log] [blame]
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1/*
2 * Copyright (C) 2012 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#include "interpreter_common.h"
18
19namespace art {
20namespace interpreter {
21
22#define HANDLE_PENDING_EXCEPTION() \
23 do { \
24 CHECK(self->IsExceptionPending()); \
Sebastien Hertz1eda2262013-09-09 16:53:14 +0200[diff] [blame]25 if (UNLIKELY(self->TestAllFlags())) { \
26 CheckSuspend(self); \
27 } \
Sebastien Hertz947ff082013-09-17 14:10:13 +0200[diff] [blame]28 Object* this_object = shadow_frame.GetThisObject(code_item->ins_size_); \
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]29 uint32_t found_dex_pc = FindNextInstructionFollowingException(self, shadow_frame, \
30 inst->GetDexPc(insns), \
Sebastien Hertz947ff082013-09-17 14:10:13 +0200[diff] [blame]31 this_object, \
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]32 instrumentation); \
33 if (found_dex_pc == DexFile::kDexNoIndex) { \
34 return JValue(); /* Handled in caller. */ \
35 } else { \
36 int32_t displacement = static_cast<int32_t>(found_dex_pc) - static_cast<int32_t>(dex_pc); \
37 inst = inst->RelativeAt(displacement); \
38 } \
39 } while (false)
40
41#define POSSIBLY_HANDLE_PENDING_EXCEPTION(_is_exception_pending, _next_function) \
42 do { \
43 if (UNLIKELY(_is_exception_pending)) { \
44 HANDLE_PENDING_EXCEPTION(); \
45 } else { \
46 inst = inst->_next_function(); \
47 } \
48 } while (false)
49
50// Code to run before each dex instruction.
51#define PREAMBLE()
52
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100[diff] [blame^]53template<bool do_access_check, bool transaction_active>
Sebastien Hertzc6714852013-09-30 16:42:32 +0200[diff] [blame]54JValue ExecuteSwitchImpl(Thread* self, MethodHelper& mh, const DexFile::CodeItem* code_item,
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]55 ShadowFrame& shadow_frame, JValue result_register) {
Jeff Haoa3faaf42013-09-03 19:07:00 -0700[diff] [blame]56 bool do_assignability_check = do_access_check;
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]57 if (UNLIKELY(!shadow_frame.HasReferenceArray())) {
58 LOG(FATAL) << "Invalid shadow frame for interpreter use";
59 return JValue();
60 }
61 self->VerifyStack();
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]62
63 uint32_t dex_pc = shadow_frame.GetDexPC();
Sebastien Hertz947ff082013-09-17 14:10:13 +0200[diff] [blame]64 const instrumentation::Instrumentation* const instrumentation = Runtime::Current()->GetInstrumentation();
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]65 if (LIKELY(dex_pc == 0)) { // We are entering the method as opposed to deoptimizing..
66 if (UNLIKELY(instrumentation->HasMethodEntryListeners())) {
Sebastien Hertz947ff082013-09-17 14:10:13 +0200[diff] [blame]67 instrumentation->MethodEnterEvent(self, shadow_frame.GetThisObject(code_item->ins_size_),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]68 shadow_frame.GetMethod(), 0);
69 }
70 }
71 const uint16_t* const insns = code_item->insns_;
72 const Instruction* inst = Instruction::At(insns + dex_pc);
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]73 uint16_t inst_data;
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]74 while (true) {
75 dex_pc = inst->GetDexPc(insns);
76 shadow_frame.SetDexPC(dex_pc);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]77 if (UNLIKELY(instrumentation->HasDexPcListeners())) {
Sebastien Hertz947ff082013-09-17 14:10:13 +0200[diff] [blame]78 instrumentation->DexPcMovedEvent(self, shadow_frame.GetThisObject(code_item->ins_size_),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]79 shadow_frame.GetMethod(), dex_pc);
80 }
81 TraceExecution(shadow_frame, inst, dex_pc, mh);
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]82 inst_data = inst->Fetch16(0);
83 switch (inst->Opcode(inst_data)) {
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]84 case Instruction::NOP:
85 PREAMBLE();
86 inst = inst->Next_1xx();
87 break;
88 case Instruction::MOVE:
89 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]90 shadow_frame.SetVReg(inst->VRegA_12x(inst_data),
91 shadow_frame.GetVReg(inst->VRegB_12x(inst_data)));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]92 inst = inst->Next_1xx();
93 break;
94 case Instruction::MOVE_FROM16:
95 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]96 shadow_frame.SetVReg(inst->VRegA_22x(inst_data),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]97 shadow_frame.GetVReg(inst->VRegB_22x()));
98 inst = inst->Next_2xx();
99 break;
100 case Instruction::MOVE_16:
101 PREAMBLE();
102 shadow_frame.SetVReg(inst->VRegA_32x(),
103 shadow_frame.GetVReg(inst->VRegB_32x()));
104 inst = inst->Next_3xx();
105 break;
106 case Instruction::MOVE_WIDE:
107 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]108 shadow_frame.SetVRegLong(inst->VRegA_12x(inst_data),
109 shadow_frame.GetVRegLong(inst->VRegB_12x(inst_data)));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]110 inst = inst->Next_1xx();
111 break;
112 case Instruction::MOVE_WIDE_FROM16:
113 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]114 shadow_frame.SetVRegLong(inst->VRegA_22x(inst_data),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]115 shadow_frame.GetVRegLong(inst->VRegB_22x()));
116 inst = inst->Next_2xx();
117 break;
118 case Instruction::MOVE_WIDE_16:
119 PREAMBLE();
120 shadow_frame.SetVRegLong(inst->VRegA_32x(),
121 shadow_frame.GetVRegLong(inst->VRegB_32x()));
122 inst = inst->Next_3xx();
123 break;
124 case Instruction::MOVE_OBJECT:
125 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]126 shadow_frame.SetVRegReference(inst->VRegA_12x(inst_data),
127 shadow_frame.GetVRegReference(inst->VRegB_12x(inst_data)));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]128 inst = inst->Next_1xx();
129 break;
130 case Instruction::MOVE_OBJECT_FROM16:
131 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]132 shadow_frame.SetVRegReference(inst->VRegA_22x(inst_data),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]133 shadow_frame.GetVRegReference(inst->VRegB_22x()));
134 inst = inst->Next_2xx();
135 break;
136 case Instruction::MOVE_OBJECT_16:
137 PREAMBLE();
138 shadow_frame.SetVRegReference(inst->VRegA_32x(),
139 shadow_frame.GetVRegReference(inst->VRegB_32x()));
140 inst = inst->Next_3xx();
141 break;
142 case Instruction::MOVE_RESULT:
143 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]144 shadow_frame.SetVReg(inst->VRegA_11x(inst_data), result_register.GetI());
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]145 inst = inst->Next_1xx();
146 break;
147 case Instruction::MOVE_RESULT_WIDE:
148 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]149 shadow_frame.SetVRegLong(inst->VRegA_11x(inst_data), result_register.GetJ());
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]150 inst = inst->Next_1xx();
151 break;
152 case Instruction::MOVE_RESULT_OBJECT:
153 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]154 shadow_frame.SetVRegReference(inst->VRegA_11x(inst_data), result_register.GetL());
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]155 inst = inst->Next_1xx();
156 break;
157 case Instruction::MOVE_EXCEPTION: {
158 PREAMBLE();
159 Throwable* exception = self->GetException(NULL);
160 self->ClearException();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]161 shadow_frame.SetVRegReference(inst->VRegA_11x(inst_data), exception);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]162 inst = inst->Next_1xx();
163 break;
164 }
165 case Instruction::RETURN_VOID: {
166 PREAMBLE();
167 JValue result;
Sebastien Hertz043036f2013-09-09 18:26:48 +0200[diff] [blame]168 if (do_access_check) {
169 // If access checks are required then the dex-to-dex compiler and analysis of
170 // whether the class has final fields hasn't been performed. Conservatively
171 // perform the memory barrier now.
Ian Rogersb122a4b2013-11-19 18:00:50 -0800[diff] [blame]172 QuasiAtomic::MembarStoreLoad();
Sebastien Hertz043036f2013-09-09 18:26:48 +0200[diff] [blame]173 }
Sebastien Hertz1eda2262013-09-09 16:53:14 +0200[diff] [blame]174 if (UNLIKELY(self->TestAllFlags())) {
175 CheckSuspend(self);
176 }
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]177 if (UNLIKELY(instrumentation->HasMethodExitListeners())) {
Sebastien Hertz947ff082013-09-17 14:10:13 +0200[diff] [blame]178 instrumentation->MethodExitEvent(self, shadow_frame.GetThisObject(code_item->ins_size_),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]179 shadow_frame.GetMethod(), inst->GetDexPc(insns),
180 result);
181 }
182 return result;
183 }
184 case Instruction::RETURN_VOID_BARRIER: {
185 PREAMBLE();
Ian Rogersb122a4b2013-11-19 18:00:50 -0800[diff] [blame]186 QuasiAtomic::MembarStoreLoad();
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]187 JValue result;
Sebastien Hertz1eda2262013-09-09 16:53:14 +0200[diff] [blame]188 if (UNLIKELY(self->TestAllFlags())) {
189 CheckSuspend(self);
190 }
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]191 if (UNLIKELY(instrumentation->HasMethodExitListeners())) {
Sebastien Hertz947ff082013-09-17 14:10:13 +0200[diff] [blame]192 instrumentation->MethodExitEvent(self, shadow_frame.GetThisObject(code_item->ins_size_),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]193 shadow_frame.GetMethod(), inst->GetDexPc(insns),
194 result);
195 }
196 return result;
197 }
198 case Instruction::RETURN: {
199 PREAMBLE();
200 JValue result;
201 result.SetJ(0);
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]202 result.SetI(shadow_frame.GetVReg(inst->VRegA_11x(inst_data)));
Sebastien Hertz1eda2262013-09-09 16:53:14 +0200[diff] [blame]203 if (UNLIKELY(self->TestAllFlags())) {
204 CheckSuspend(self);
205 }
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]206 if (UNLIKELY(instrumentation->HasMethodExitListeners())) {
Sebastien Hertz947ff082013-09-17 14:10:13 +0200[diff] [blame]207 instrumentation->MethodExitEvent(self, shadow_frame.GetThisObject(code_item->ins_size_),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]208 shadow_frame.GetMethod(), inst->GetDexPc(insns),
209 result);
210 }
211 return result;
212 }
213 case Instruction::RETURN_WIDE: {
214 PREAMBLE();
215 JValue result;
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]216 result.SetJ(shadow_frame.GetVRegLong(inst->VRegA_11x(inst_data)));
Sebastien Hertz1eda2262013-09-09 16:53:14 +0200[diff] [blame]217 if (UNLIKELY(self->TestAllFlags())) {
218 CheckSuspend(self);
219 }
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]220 if (UNLIKELY(instrumentation->HasMethodExitListeners())) {
Sebastien Hertz947ff082013-09-17 14:10:13 +0200[diff] [blame]221 instrumentation->MethodExitEvent(self, shadow_frame.GetThisObject(code_item->ins_size_),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]222 shadow_frame.GetMethod(), inst->GetDexPc(insns),
223 result);
224 }
225 return result;
226 }
227 case Instruction::RETURN_OBJECT: {
228 PREAMBLE();
229 JValue result;
Sebastien Hertz1eda2262013-09-09 16:53:14 +0200[diff] [blame]230 if (UNLIKELY(self->TestAllFlags())) {
231 CheckSuspend(self);
232 }
Mathieu Chartiere861ebd2013-10-09 15:01:21 -0700[diff] [blame]233 Object* obj_result = shadow_frame.GetVRegReference(inst->VRegA_11x(inst_data));
234 result.SetJ(0);
235 result.SetL(obj_result);
Jeff Haoa3faaf42013-09-03 19:07:00 -0700[diff] [blame]236 if (do_assignability_check && obj_result != NULL) {
237 Class* return_type = MethodHelper(shadow_frame.GetMethod()).GetReturnType();
238 if (return_type == NULL) {
239 // Return the pending exception.
240 HANDLE_PENDING_EXCEPTION();
241 }
242 if (!obj_result->VerifierInstanceOf(return_type)) {
243 // This should never happen.
244 self->ThrowNewExceptionF(self->GetCurrentLocationForThrow(),
245 "Ljava/lang/VirtualMachineError;",
246 "Returning '%s' that is not instance of return type '%s'",
247 ClassHelper(obj_result->GetClass()).GetDescriptor(),
248 ClassHelper(return_type).GetDescriptor());
249 HANDLE_PENDING_EXCEPTION();
250 }
251 }
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]252 if (UNLIKELY(instrumentation->HasMethodExitListeners())) {
Sebastien Hertz947ff082013-09-17 14:10:13 +0200[diff] [blame]253 instrumentation->MethodExitEvent(self, shadow_frame.GetThisObject(code_item->ins_size_),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]254 shadow_frame.GetMethod(), inst->GetDexPc(insns),
255 result);
256 }
257 return result;
258 }
259 case Instruction::CONST_4: {
260 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]261 uint4_t dst = inst->VRegA_11n(inst_data);
262 int4_t val = inst->VRegB_11n(inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]263 shadow_frame.SetVReg(dst, val);
264 if (val == 0) {
265 shadow_frame.SetVRegReference(dst, NULL);
266 }
267 inst = inst->Next_1xx();
268 break;
269 }
270 case Instruction::CONST_16: {
271 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]272 uint8_t dst = inst->VRegA_21s(inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]273 int16_t val = inst->VRegB_21s();
274 shadow_frame.SetVReg(dst, val);
275 if (val == 0) {
276 shadow_frame.SetVRegReference(dst, NULL);
277 }
278 inst = inst->Next_2xx();
279 break;
280 }
281 case Instruction::CONST: {
282 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]283 uint8_t dst = inst->VRegA_31i(inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]284 int32_t val = inst->VRegB_31i();
285 shadow_frame.SetVReg(dst, val);
286 if (val == 0) {
287 shadow_frame.SetVRegReference(dst, NULL);
288 }
289 inst = inst->Next_3xx();
290 break;
291 }
292 case Instruction::CONST_HIGH16: {
293 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]294 uint8_t dst = inst->VRegA_21h(inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]295 int32_t val = static_cast<int32_t>(inst->VRegB_21h() << 16);
296 shadow_frame.SetVReg(dst, val);
297 if (val == 0) {
298 shadow_frame.SetVRegReference(dst, NULL);
299 }
300 inst = inst->Next_2xx();
301 break;
302 }
303 case Instruction::CONST_WIDE_16:
304 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]305 shadow_frame.SetVRegLong(inst->VRegA_21s(inst_data), inst->VRegB_21s());
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]306 inst = inst->Next_2xx();
307 break;
308 case Instruction::CONST_WIDE_32:
309 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]310 shadow_frame.SetVRegLong(inst->VRegA_31i(inst_data), inst->VRegB_31i());
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]311 inst = inst->Next_3xx();
312 break;
313 case Instruction::CONST_WIDE:
314 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]315 shadow_frame.SetVRegLong(inst->VRegA_51l(inst_data), inst->VRegB_51l());
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]316 inst = inst->Next_51l();
317 break;
318 case Instruction::CONST_WIDE_HIGH16:
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]319 shadow_frame.SetVRegLong(inst->VRegA_21h(inst_data),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]320 static_cast<uint64_t>(inst->VRegB_21h()) << 48);
321 inst = inst->Next_2xx();
322 break;
323 case Instruction::CONST_STRING: {
324 PREAMBLE();
325 String* s = ResolveString(self, mh, inst->VRegB_21c());
326 if (UNLIKELY(s == NULL)) {
327 HANDLE_PENDING_EXCEPTION();
328 } else {
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]329 shadow_frame.SetVRegReference(inst->VRegA_21c(inst_data), s);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]330 inst = inst->Next_2xx();
331 }
332 break;
333 }
334 case Instruction::CONST_STRING_JUMBO: {
335 PREAMBLE();
336 String* s = ResolveString(self, mh, inst->VRegB_31c());
337 if (UNLIKELY(s == NULL)) {
338 HANDLE_PENDING_EXCEPTION();
339 } else {
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]340 shadow_frame.SetVRegReference(inst->VRegA_31c(inst_data), s);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]341 inst = inst->Next_3xx();
342 }
343 break;
344 }
345 case Instruction::CONST_CLASS: {
346 PREAMBLE();
347 Class* c = ResolveVerifyAndClinit(inst->VRegB_21c(), shadow_frame.GetMethod(),
348 self, false, do_access_check);
349 if (UNLIKELY(c == NULL)) {
350 HANDLE_PENDING_EXCEPTION();
351 } else {
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]352 shadow_frame.SetVRegReference(inst->VRegA_21c(inst_data), c);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]353 inst = inst->Next_2xx();
354 }
355 break;
356 }
357 case Instruction::MONITOR_ENTER: {
358 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]359 Object* obj = shadow_frame.GetVRegReference(inst->VRegA_11x(inst_data));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]360 if (UNLIKELY(obj == NULL)) {
361 ThrowNullPointerExceptionFromDexPC(shadow_frame.GetCurrentLocationForThrow());
362 HANDLE_PENDING_EXCEPTION();
363 } else {
364 DoMonitorEnter(self, obj);
365 POSSIBLY_HANDLE_PENDING_EXCEPTION(self->IsExceptionPending(), Next_1xx);
366 }
367 break;
368 }
369 case Instruction::MONITOR_EXIT: {
370 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]371 Object* obj = shadow_frame.GetVRegReference(inst->VRegA_11x(inst_data));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]372 if (UNLIKELY(obj == NULL)) {
373 ThrowNullPointerExceptionFromDexPC(shadow_frame.GetCurrentLocationForThrow());
374 HANDLE_PENDING_EXCEPTION();
375 } else {
376 DoMonitorExit(self, obj);
377 POSSIBLY_HANDLE_PENDING_EXCEPTION(self->IsExceptionPending(), Next_1xx);
378 }
379 break;
380 }
381 case Instruction::CHECK_CAST: {
382 PREAMBLE();
383 Class* c = ResolveVerifyAndClinit(inst->VRegB_21c(), shadow_frame.GetMethod(),
384 self, false, do_access_check);
385 if (UNLIKELY(c == NULL)) {
386 HANDLE_PENDING_EXCEPTION();
387 } else {
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]388 Object* obj = shadow_frame.GetVRegReference(inst->VRegA_21c(inst_data));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]389 if (UNLIKELY(obj != NULL && !obj->InstanceOf(c))) {
390 ThrowClassCastException(c, obj->GetClass());
391 HANDLE_PENDING_EXCEPTION();
392 } else {
393 inst = inst->Next_2xx();
394 }
395 }
396 break;
397 }
398 case Instruction::INSTANCE_OF: {
399 PREAMBLE();
400 Class* c = ResolveVerifyAndClinit(inst->VRegC_22c(), shadow_frame.GetMethod(),
401 self, false, do_access_check);
402 if (UNLIKELY(c == NULL)) {
403 HANDLE_PENDING_EXCEPTION();
404 } else {
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]405 Object* obj = shadow_frame.GetVRegReference(inst->VRegB_22c(inst_data));
406 shadow_frame.SetVReg(inst->VRegA_22c(inst_data), (obj != NULL && obj->InstanceOf(c)) ? 1 : 0);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]407 inst = inst->Next_2xx();
408 }
409 break;
410 }
411 case Instruction::ARRAY_LENGTH: {
412 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]413 Object* array = shadow_frame.GetVRegReference(inst->VRegB_12x(inst_data));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]414 if (UNLIKELY(array == NULL)) {
415 ThrowNullPointerExceptionFromDexPC(shadow_frame.GetCurrentLocationForThrow());
416 HANDLE_PENDING_EXCEPTION();
417 } else {
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]418 shadow_frame.SetVReg(inst->VRegA_12x(inst_data), array->AsArray()->GetLength());
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]419 inst = inst->Next_1xx();
420 }
421 break;
422 }
423 case Instruction::NEW_INSTANCE: {
424 PREAMBLE();
Mathieu Chartiercbb2d202013-11-14 17:45:16 -0800[diff] [blame]425 Object* obj = AllocObjectFromCode<do_access_check, true>(
426 inst->VRegB_21c(), shadow_frame.GetMethod(), self,
427 Runtime::Current()->GetHeap()->GetCurrentAllocator());
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]428 if (UNLIKELY(obj == NULL)) {
429 HANDLE_PENDING_EXCEPTION();
430 } else {
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]431 shadow_frame.SetVRegReference(inst->VRegA_21c(inst_data), obj);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]432 inst = inst->Next_2xx();
433 }
434 break;
435 }
436 case Instruction::NEW_ARRAY: {
437 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]438 int32_t length = shadow_frame.GetVReg(inst->VRegB_22c(inst_data));
Mathieu Chartiercbb2d202013-11-14 17:45:16 -0800[diff] [blame]439 Object* obj = AllocArrayFromCode<do_access_check, true>(
440 inst->VRegC_22c(), shadow_frame.GetMethod(), length, self,
441 Runtime::Current()->GetHeap()->GetCurrentAllocator());
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]442 if (UNLIKELY(obj == NULL)) {
443 HANDLE_PENDING_EXCEPTION();
444 } else {
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]445 shadow_frame.SetVRegReference(inst->VRegA_22c(inst_data), obj);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]446 inst = inst->Next_2xx();
447 }
448 break;
449 }
450 case Instruction::FILLED_NEW_ARRAY: {
451 PREAMBLE();
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100[diff] [blame^]452 bool success =
453 DoFilledNewArray<false, do_access_check, transaction_active>(inst, shadow_frame, self,
454 &result_register);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]455 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_3xx);
456 break;
457 }
458 case Instruction::FILLED_NEW_ARRAY_RANGE: {
459 PREAMBLE();
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100[diff] [blame^]460 bool success =
461 DoFilledNewArray<true, do_access_check, transaction_active>(inst, shadow_frame,
462 self, &result_register);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]463 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_3xx);
464 break;
465 }
466 case Instruction::FILL_ARRAY_DATA: {
467 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]468 Object* obj = shadow_frame.GetVRegReference(inst->VRegA_31t(inst_data));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]469 if (UNLIKELY(obj == NULL)) {
470 ThrowNullPointerException(NULL, "null array in FILL_ARRAY_DATA");
471 HANDLE_PENDING_EXCEPTION();
472 break;
473 }
474 Array* array = obj->AsArray();
475 DCHECK(array->IsArrayInstance() && !array->IsObjectArray());
476 const uint16_t* payload_addr = reinterpret_cast<const uint16_t*>(inst) + inst->VRegB_31t();
477 const Instruction::ArrayDataPayload* payload =
478 reinterpret_cast<const Instruction::ArrayDataPayload*>(payload_addr);
479 if (UNLIKELY(static_cast<int32_t>(payload->element_count) > array->GetLength())) {
480 self->ThrowNewExceptionF(shadow_frame.GetCurrentLocationForThrow(),
481 "Ljava/lang/ArrayIndexOutOfBoundsException;",
482 "failed FILL_ARRAY_DATA; length=%d, index=%d",
483 array->GetLength(), payload->element_count);
484 HANDLE_PENDING_EXCEPTION();
485 break;
486 }
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100[diff] [blame^]487 if (transaction_active) {
488 RecordArrayElementsInTransaction(array, payload->element_count);
489 }
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]490 uint32_t size_in_bytes = payload->element_count * payload->element_width;
Ian Rogersef7d42f2014-01-06 12:55:46 -0800[diff] [blame]491 memcpy(array->GetRawData(payload->element_width, 0), payload->data, size_in_bytes);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]492 inst = inst->Next_3xx();
493 break;
494 }
495 case Instruction::THROW: {
496 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]497 Object* exception = shadow_frame.GetVRegReference(inst->VRegA_11x(inst_data));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]498 if (UNLIKELY(exception == NULL)) {
499 ThrowNullPointerException(NULL, "throw with null exception");
Jeff Haoa3faaf42013-09-03 19:07:00 -0700[diff] [blame]500 } else if (do_assignability_check && !exception->GetClass()->IsThrowableClass()) {
501 // This should never happen.
502 self->ThrowNewExceptionF(self->GetCurrentLocationForThrow(),
503 "Ljava/lang/VirtualMachineError;",
504 "Throwing '%s' that is not instance of Throwable",
505 ClassHelper(exception->GetClass()).GetDescriptor());
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]506 } else {
507 self->SetException(shadow_frame.GetCurrentLocationForThrow(), exception->AsThrowable());
508 }
509 HANDLE_PENDING_EXCEPTION();
510 break;
511 }
512 case Instruction::GOTO: {
513 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]514 int8_t offset = inst->VRegA_10t(inst_data);
Sebastien Hertz1eda2262013-09-09 16:53:14 +0200[diff] [blame]515 if (IsBackwardBranch(offset)) {
516 if (UNLIKELY(self->TestAllFlags())) {
517 CheckSuspend(self);
518 }
519 }
520 inst = inst->RelativeAt(offset);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]521 break;
522 }
523 case Instruction::GOTO_16: {
524 PREAMBLE();
Sebastien Hertz1eda2262013-09-09 16:53:14 +0200[diff] [blame]525 int16_t offset = inst->VRegA_20t();
526 if (IsBackwardBranch(offset)) {
527 if (UNLIKELY(self->TestAllFlags())) {
528 CheckSuspend(self);
529 }
530 }
531 inst = inst->RelativeAt(offset);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]532 break;
533 }
534 case Instruction::GOTO_32: {
535 PREAMBLE();
Sebastien Hertz1eda2262013-09-09 16:53:14 +0200[diff] [blame]536 int32_t offset = inst->VRegA_30t();
537 if (IsBackwardBranch(offset)) {
538 if (UNLIKELY(self->TestAllFlags())) {
539 CheckSuspend(self);
540 }
541 }
542 inst = inst->RelativeAt(offset);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]543 break;
544 }
545 case Instruction::PACKED_SWITCH: {
546 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]547 int32_t offset = DoPackedSwitch(inst, shadow_frame, inst_data);
Sebastien Hertz1eda2262013-09-09 16:53:14 +0200[diff] [blame]548 if (IsBackwardBranch(offset)) {
549 if (UNLIKELY(self->TestAllFlags())) {
550 CheckSuspend(self);
551 }
552 }
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]553 inst = inst->RelativeAt(offset);
554 break;
555 }
556 case Instruction::SPARSE_SWITCH: {
557 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]558 int32_t offset = DoSparseSwitch(inst, shadow_frame, inst_data);
Sebastien Hertz1eda2262013-09-09 16:53:14 +0200[diff] [blame]559 if (IsBackwardBranch(offset)) {
560 if (UNLIKELY(self->TestAllFlags())) {
561 CheckSuspend(self);
562 }
563 }
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]564 inst = inst->RelativeAt(offset);
565 break;
566 }
567 case Instruction::CMPL_FLOAT: {
568 PREAMBLE();
569 float val1 = shadow_frame.GetVRegFloat(inst->VRegB_23x());
570 float val2 = shadow_frame.GetVRegFloat(inst->VRegC_23x());
571 int32_t result;
572 if (val1 > val2) {
573 result = 1;
574 } else if (val1 == val2) {
575 result = 0;
576 } else {
577 result = -1;
578 }
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]579 shadow_frame.SetVReg(inst->VRegA_23x(inst_data), result);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]580 inst = inst->Next_2xx();
581 break;
582 }
583 case Instruction::CMPG_FLOAT: {
584 PREAMBLE();
585 float val1 = shadow_frame.GetVRegFloat(inst->VRegB_23x());
586 float val2 = shadow_frame.GetVRegFloat(inst->VRegC_23x());
587 int32_t result;
588 if (val1 < val2) {
589 result = -1;
590 } else if (val1 == val2) {
591 result = 0;
592 } else {
593 result = 1;
594 }
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]595 shadow_frame.SetVReg(inst->VRegA_23x(inst_data), result);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]596 inst = inst->Next_2xx();
597 break;
598 }
599 case Instruction::CMPL_DOUBLE: {
600 PREAMBLE();
601 double val1 = shadow_frame.GetVRegDouble(inst->VRegB_23x());
602 double val2 = shadow_frame.GetVRegDouble(inst->VRegC_23x());
603 int32_t result;
604 if (val1 > val2) {
605 result = 1;
606 } else if (val1 == val2) {
607 result = 0;
608 } else {
609 result = -1;
610 }
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]611 shadow_frame.SetVReg(inst->VRegA_23x(inst_data), result);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]612 inst = inst->Next_2xx();
613 break;
614 }
615
616 case Instruction::CMPG_DOUBLE: {
617 PREAMBLE();
618 double val1 = shadow_frame.GetVRegDouble(inst->VRegB_23x());
619 double val2 = shadow_frame.GetVRegDouble(inst->VRegC_23x());
620 int32_t result;
621 if (val1 < val2) {
622 result = -1;
623 } else if (val1 == val2) {
624 result = 0;
625 } else {
626 result = 1;
627 }
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]628 shadow_frame.SetVReg(inst->VRegA_23x(inst_data), result);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]629 inst = inst->Next_2xx();
630 break;
631 }
632 case Instruction::CMP_LONG: {
633 PREAMBLE();
634 int64_t val1 = shadow_frame.GetVRegLong(inst->VRegB_23x());
635 int64_t val2 = shadow_frame.GetVRegLong(inst->VRegC_23x());
636 int32_t result;
637 if (val1 > val2) {
638 result = 1;
639 } else if (val1 == val2) {
640 result = 0;
641 } else {
642 result = -1;
643 }
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]644 shadow_frame.SetVReg(inst->VRegA_23x(inst_data), result);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]645 inst = inst->Next_2xx();
646 break;
647 }
648 case Instruction::IF_EQ: {
649 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]650 if (shadow_frame.GetVReg(inst->VRegA_22t(inst_data)) == shadow_frame.GetVReg(inst->VRegB_22t(inst_data))) {
Sebastien Hertz1eda2262013-09-09 16:53:14 +0200[diff] [blame]651 int16_t offset = inst->VRegC_22t();
652 if (IsBackwardBranch(offset)) {
653 if (UNLIKELY(self->TestAllFlags())) {
654 CheckSuspend(self);
655 }
656 }
657 inst = inst->RelativeAt(offset);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]658 } else {
659 inst = inst->Next_2xx();
660 }
661 break;
662 }
663 case Instruction::IF_NE: {
664 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]665 if (shadow_frame.GetVReg(inst->VRegA_22t(inst_data)) != shadow_frame.GetVReg(inst->VRegB_22t(inst_data))) {
Sebastien Hertz1eda2262013-09-09 16:53:14 +0200[diff] [blame]666 int16_t offset = inst->VRegC_22t();
667 if (IsBackwardBranch(offset)) {
668 if (UNLIKELY(self->TestAllFlags())) {
669 CheckSuspend(self);
670 }
671 }
672 inst = inst->RelativeAt(offset);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]673 } else {
674 inst = inst->Next_2xx();
675 }
676 break;
677 }
678 case Instruction::IF_LT: {
679 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]680 if (shadow_frame.GetVReg(inst->VRegA_22t(inst_data)) < shadow_frame.GetVReg(inst->VRegB_22t(inst_data))) {
Sebastien Hertz1eda2262013-09-09 16:53:14 +0200[diff] [blame]681 int16_t offset = inst->VRegC_22t();
682 if (IsBackwardBranch(offset)) {
683 if (UNLIKELY(self->TestAllFlags())) {
684 CheckSuspend(self);
685 }
686 }
687 inst = inst->RelativeAt(offset);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]688 } else {
689 inst = inst->Next_2xx();
690 }
691 break;
692 }
693 case Instruction::IF_GE: {
694 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]695 if (shadow_frame.GetVReg(inst->VRegA_22t(inst_data)) >= shadow_frame.GetVReg(inst->VRegB_22t(inst_data))) {
Sebastien Hertz1eda2262013-09-09 16:53:14 +0200[diff] [blame]696 int16_t offset = inst->VRegC_22t();
697 if (IsBackwardBranch(offset)) {
698 if (UNLIKELY(self->TestAllFlags())) {
699 CheckSuspend(self);
700 }
701 }
702 inst = inst->RelativeAt(offset);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]703 } else {
704 inst = inst->Next_2xx();
705 }
706 break;
707 }
708 case Instruction::IF_GT: {
709 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]710 if (shadow_frame.GetVReg(inst->VRegA_22t(inst_data)) > shadow_frame.GetVReg(inst->VRegB_22t(inst_data))) {
Sebastien Hertz1eda2262013-09-09 16:53:14 +0200[diff] [blame]711 int16_t offset = inst->VRegC_22t();
712 if (IsBackwardBranch(offset)) {
713 if (UNLIKELY(self->TestAllFlags())) {
714 CheckSuspend(self);
715 }
716 }
717 inst = inst->RelativeAt(offset);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]718 } else {
719 inst = inst->Next_2xx();
720 }
721 break;
722 }
723 case Instruction::IF_LE: {
724 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]725 if (shadow_frame.GetVReg(inst->VRegA_22t(inst_data)) <= shadow_frame.GetVReg(inst->VRegB_22t(inst_data))) {
Sebastien Hertz1eda2262013-09-09 16:53:14 +0200[diff] [blame]726 int16_t offset = inst->VRegC_22t();
727 if (IsBackwardBranch(offset)) {
728 if (UNLIKELY(self->TestAllFlags())) {
729 CheckSuspend(self);
730 }
731 }
732 inst = inst->RelativeAt(offset);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]733 } else {
734 inst = inst->Next_2xx();
735 }
736 break;
737 }
738 case Instruction::IF_EQZ: {
739 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]740 if (shadow_frame.GetVReg(inst->VRegA_21t(inst_data)) == 0) {
Sebastien Hertz1eda2262013-09-09 16:53:14 +0200[diff] [blame]741 int16_t offset = inst->VRegB_21t();
742 if (IsBackwardBranch(offset)) {
743 if (UNLIKELY(self->TestAllFlags())) {
744 CheckSuspend(self);
745 }
746 }
747 inst = inst->RelativeAt(offset);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]748 } else {
749 inst = inst->Next_2xx();
750 }
751 break;
752 }
753 case Instruction::IF_NEZ: {
754 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]755 if (shadow_frame.GetVReg(inst->VRegA_21t(inst_data)) != 0) {
Sebastien Hertz1eda2262013-09-09 16:53:14 +0200[diff] [blame]756 int16_t offset = inst->VRegB_21t();
757 if (IsBackwardBranch(offset)) {
758 if (UNLIKELY(self->TestAllFlags())) {
759 CheckSuspend(self);
760 }
761 }
762 inst = inst->RelativeAt(offset);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]763 } else {
764 inst = inst->Next_2xx();
765 }
766 break;
767 }
768 case Instruction::IF_LTZ: {
769 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]770 if (shadow_frame.GetVReg(inst->VRegA_21t(inst_data)) < 0) {
Sebastien Hertz1eda2262013-09-09 16:53:14 +0200[diff] [blame]771 int16_t offset = inst->VRegB_21t();
772 if (IsBackwardBranch(offset)) {
773 if (UNLIKELY(self->TestAllFlags())) {
774 CheckSuspend(self);
775 }
776 }
777 inst = inst->RelativeAt(offset);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]778 } else {
779 inst = inst->Next_2xx();
780 }
781 break;
782 }
783 case Instruction::IF_GEZ: {
784 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]785 if (shadow_frame.GetVReg(inst->VRegA_21t(inst_data)) >= 0) {
Sebastien Hertz1eda2262013-09-09 16:53:14 +0200[diff] [blame]786 int16_t offset = inst->VRegB_21t();
787 if (IsBackwardBranch(offset)) {
788 if (UNLIKELY(self->TestAllFlags())) {
789 CheckSuspend(self);
790 }
791 }
792 inst = inst->RelativeAt(offset);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]793 } else {
794 inst = inst->Next_2xx();
795 }
796 break;
797 }
798 case Instruction::IF_GTZ: {
799 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]800 if (shadow_frame.GetVReg(inst->VRegA_21t(inst_data)) > 0) {
Sebastien Hertz1eda2262013-09-09 16:53:14 +0200[diff] [blame]801 int16_t offset = inst->VRegB_21t();
802 if (IsBackwardBranch(offset)) {
803 if (UNLIKELY(self->TestAllFlags())) {
804 CheckSuspend(self);
805 }
806 }
807 inst = inst->RelativeAt(offset);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]808 } else {
809 inst = inst->Next_2xx();
810 }
811 break;
812 }
813 case Instruction::IF_LEZ: {
814 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]815 if (shadow_frame.GetVReg(inst->VRegA_21t(inst_data)) <= 0) {
Sebastien Hertz1eda2262013-09-09 16:53:14 +0200[diff] [blame]816 int16_t offset = inst->VRegB_21t();
817 if (IsBackwardBranch(offset)) {
818 if (UNLIKELY(self->TestAllFlags())) {
819 CheckSuspend(self);
820 }
821 }
822 inst = inst->RelativeAt(offset);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]823 } else {
824 inst = inst->Next_2xx();
825 }
826 break;
827 }
828 case Instruction::AGET_BOOLEAN: {
829 PREAMBLE();
830 Object* a = shadow_frame.GetVRegReference(inst->VRegB_23x());
831 if (UNLIKELY(a == NULL)) {
832 ThrowNullPointerExceptionFromDexPC(shadow_frame.GetCurrentLocationForThrow());
833 HANDLE_PENDING_EXCEPTION();
834 break;
835 }
836 int32_t index = shadow_frame.GetVReg(inst->VRegC_23x());
837 BooleanArray* array = a->AsBooleanArray();
Sebastien Hertzabff6432014-01-27 18:01:39 +0100[diff] [blame]838 if (LIKELY(array->CheckIsValidIndex(index))) {
839 shadow_frame.SetVReg(inst->VRegA_23x(inst_data), array->GetWithoutChecks(index));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]840 inst = inst->Next_2xx();
841 } else {
842 HANDLE_PENDING_EXCEPTION();
843 }
844 break;
845 }
846 case Instruction::AGET_BYTE: {
847 PREAMBLE();
848 Object* a = shadow_frame.GetVRegReference(inst->VRegB_23x());
849 if (UNLIKELY(a == NULL)) {
850 ThrowNullPointerExceptionFromDexPC(shadow_frame.GetCurrentLocationForThrow());
851 HANDLE_PENDING_EXCEPTION();
852 break;
853 }
854 int32_t index = shadow_frame.GetVReg(inst->VRegC_23x());
855 ByteArray* array = a->AsByteArray();
Sebastien Hertzabff6432014-01-27 18:01:39 +0100[diff] [blame]856 if (LIKELY(array->CheckIsValidIndex(index))) {
857 shadow_frame.SetVReg(inst->VRegA_23x(inst_data), array->GetWithoutChecks(index));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]858 inst = inst->Next_2xx();
859 } else {
860 HANDLE_PENDING_EXCEPTION();
861 }
862 break;
863 }
864 case Instruction::AGET_CHAR: {
865 PREAMBLE();
866 Object* a = shadow_frame.GetVRegReference(inst->VRegB_23x());
867 if (UNLIKELY(a == NULL)) {
868 ThrowNullPointerExceptionFromDexPC(shadow_frame.GetCurrentLocationForThrow());
869 HANDLE_PENDING_EXCEPTION();
870 break;
871 }
872 int32_t index = shadow_frame.GetVReg(inst->VRegC_23x());
873 CharArray* array = a->AsCharArray();
Sebastien Hertzabff6432014-01-27 18:01:39 +0100[diff] [blame]874 if (LIKELY(array->CheckIsValidIndex(index))) {
875 shadow_frame.SetVReg(inst->VRegA_23x(inst_data), array->GetWithoutChecks(index));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]876 inst = inst->Next_2xx();
877 } else {
878 HANDLE_PENDING_EXCEPTION();
879 }
880 break;
881 }
882 case Instruction::AGET_SHORT: {
883 PREAMBLE();
884 Object* a = shadow_frame.GetVRegReference(inst->VRegB_23x());
885 if (UNLIKELY(a == NULL)) {
886 ThrowNullPointerExceptionFromDexPC(shadow_frame.GetCurrentLocationForThrow());
887 HANDLE_PENDING_EXCEPTION();
888 break;
889 }
890 int32_t index = shadow_frame.GetVReg(inst->VRegC_23x());
891 ShortArray* array = a->AsShortArray();
Sebastien Hertzabff6432014-01-27 18:01:39 +0100[diff] [blame]892 if (LIKELY(array->CheckIsValidIndex(index))) {
893 shadow_frame.SetVReg(inst->VRegA_23x(inst_data), array->GetWithoutChecks(index));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]894 inst = inst->Next_2xx();
895 } else {
896 HANDLE_PENDING_EXCEPTION();
897 }
898 break;
899 }
900 case Instruction::AGET: {
901 PREAMBLE();
902 Object* a = shadow_frame.GetVRegReference(inst->VRegB_23x());
903 if (UNLIKELY(a == NULL)) {
904 ThrowNullPointerExceptionFromDexPC(shadow_frame.GetCurrentLocationForThrow());
905 HANDLE_PENDING_EXCEPTION();
906 break;
907 }
908 int32_t index = shadow_frame.GetVReg(inst->VRegC_23x());
909 IntArray* array = a->AsIntArray();
Sebastien Hertzabff6432014-01-27 18:01:39 +0100[diff] [blame]910 if (LIKELY(array->CheckIsValidIndex(index))) {
911 shadow_frame.SetVReg(inst->VRegA_23x(inst_data), array->GetWithoutChecks(index));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]912 inst = inst->Next_2xx();
913 } else {
914 HANDLE_PENDING_EXCEPTION();
915 }
916 break;
917 }
918 case Instruction::AGET_WIDE: {
919 PREAMBLE();
920 Object* a = shadow_frame.GetVRegReference(inst->VRegB_23x());
921 if (UNLIKELY(a == NULL)) {
922 ThrowNullPointerExceptionFromDexPC(shadow_frame.GetCurrentLocationForThrow());
923 HANDLE_PENDING_EXCEPTION();
924 break;
925 }
926 int32_t index = shadow_frame.GetVReg(inst->VRegC_23x());
927 LongArray* array = a->AsLongArray();
Sebastien Hertzabff6432014-01-27 18:01:39 +0100[diff] [blame]928 if (LIKELY(array->CheckIsValidIndex(index))) {
929 shadow_frame.SetVRegLong(inst->VRegA_23x(inst_data), array->GetWithoutChecks(index));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]930 inst = inst->Next_2xx();
931 } else {
932 HANDLE_PENDING_EXCEPTION();
933 }
934 break;
935 }
936 case Instruction::AGET_OBJECT: {
937 PREAMBLE();
938 Object* a = shadow_frame.GetVRegReference(inst->VRegB_23x());
939 if (UNLIKELY(a == NULL)) {
940 ThrowNullPointerExceptionFromDexPC(shadow_frame.GetCurrentLocationForThrow());
941 HANDLE_PENDING_EXCEPTION();
942 break;
943 }
944 int32_t index = shadow_frame.GetVReg(inst->VRegC_23x());
945 ObjectArray<Object>* array = a->AsObjectArray<Object>();
Sebastien Hertzabff6432014-01-27 18:01:39 +0100[diff] [blame]946 if (LIKELY(array->CheckIsValidIndex(index))) {
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]947 shadow_frame.SetVRegReference(inst->VRegA_23x(inst_data), array->GetWithoutChecks(index));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]948 inst = inst->Next_2xx();
949 } else {
950 HANDLE_PENDING_EXCEPTION();
951 }
952 break;
953 }
954 case Instruction::APUT_BOOLEAN: {
955 PREAMBLE();
956 Object* a = shadow_frame.GetVRegReference(inst->VRegB_23x());
957 if (UNLIKELY(a == NULL)) {
958 ThrowNullPointerExceptionFromDexPC(shadow_frame.GetCurrentLocationForThrow());
959 HANDLE_PENDING_EXCEPTION();
960 break;
961 }
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]962 uint8_t val = shadow_frame.GetVReg(inst->VRegA_23x(inst_data));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]963 int32_t index = shadow_frame.GetVReg(inst->VRegC_23x());
964 BooleanArray* array = a->AsBooleanArray();
Sebastien Hertzabff6432014-01-27 18:01:39 +0100[diff] [blame]965 if (LIKELY(array->CheckIsValidIndex(index))) {
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100[diff] [blame^]966 array->SetWithoutChecks<transaction_active>(index, val);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]967 inst = inst->Next_2xx();
968 } else {
969 HANDLE_PENDING_EXCEPTION();
970 }
971 break;
972 }
973 case Instruction::APUT_BYTE: {
974 PREAMBLE();
975 Object* a = shadow_frame.GetVRegReference(inst->VRegB_23x());
976 if (UNLIKELY(a == NULL)) {
977 ThrowNullPointerExceptionFromDexPC(shadow_frame.GetCurrentLocationForThrow());
978 HANDLE_PENDING_EXCEPTION();
979 break;
980 }
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]981 int8_t val = shadow_frame.GetVReg(inst->VRegA_23x(inst_data));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]982 int32_t index = shadow_frame.GetVReg(inst->VRegC_23x());
983 ByteArray* array = a->AsByteArray();
Sebastien Hertzabff6432014-01-27 18:01:39 +0100[diff] [blame]984 if (LIKELY(array->CheckIsValidIndex(index))) {
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100[diff] [blame^]985 array->SetWithoutChecks<transaction_active>(index, val);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]986 inst = inst->Next_2xx();
987 } else {
988 HANDLE_PENDING_EXCEPTION();
989 }
990 break;
991 }
992 case Instruction::APUT_CHAR: {
993 PREAMBLE();
994 Object* a = shadow_frame.GetVRegReference(inst->VRegB_23x());
995 if (UNLIKELY(a == NULL)) {
996 ThrowNullPointerExceptionFromDexPC(shadow_frame.GetCurrentLocationForThrow());
997 HANDLE_PENDING_EXCEPTION();
998 break;
999 }
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1000 uint16_t val = shadow_frame.GetVReg(inst->VRegA_23x(inst_data));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1001 int32_t index = shadow_frame.GetVReg(inst->VRegC_23x());
1002 CharArray* array = a->AsCharArray();
Sebastien Hertzabff6432014-01-27 18:01:39 +0100[diff] [blame]1003 if (LIKELY(array->CheckIsValidIndex(index))) {
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100[diff] [blame^]1004 array->SetWithoutChecks<transaction_active>(index, val);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1005 inst = inst->Next_2xx();
1006 } else {
1007 HANDLE_PENDING_EXCEPTION();
1008 }
1009 break;
1010 }
1011 case Instruction::APUT_SHORT: {
1012 PREAMBLE();
1013 Object* a = shadow_frame.GetVRegReference(inst->VRegB_23x());
1014 if (UNLIKELY(a == NULL)) {
1015 ThrowNullPointerExceptionFromDexPC(shadow_frame.GetCurrentLocationForThrow());
1016 HANDLE_PENDING_EXCEPTION();
1017 break;
1018 }
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1019 int16_t val = shadow_frame.GetVReg(inst->VRegA_23x(inst_data));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1020 int32_t index = shadow_frame.GetVReg(inst->VRegC_23x());
1021 ShortArray* array = a->AsShortArray();
Sebastien Hertzabff6432014-01-27 18:01:39 +0100[diff] [blame]1022 if (LIKELY(array->CheckIsValidIndex(index))) {
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100[diff] [blame^]1023 array->SetWithoutChecks<transaction_active>(index, val);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1024 inst = inst->Next_2xx();
1025 } else {
1026 HANDLE_PENDING_EXCEPTION();
1027 }
1028 break;
1029 }
1030 case Instruction::APUT: {
1031 PREAMBLE();
1032 Object* a = shadow_frame.GetVRegReference(inst->VRegB_23x());
1033 if (UNLIKELY(a == NULL)) {
1034 ThrowNullPointerExceptionFromDexPC(shadow_frame.GetCurrentLocationForThrow());
1035 HANDLE_PENDING_EXCEPTION();
1036 break;
1037 }
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1038 int32_t val = shadow_frame.GetVReg(inst->VRegA_23x(inst_data));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1039 int32_t index = shadow_frame.GetVReg(inst->VRegC_23x());
1040 IntArray* array = a->AsIntArray();
Sebastien Hertzabff6432014-01-27 18:01:39 +0100[diff] [blame]1041 if (LIKELY(array->CheckIsValidIndex(index))) {
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100[diff] [blame^]1042 array->SetWithoutChecks<transaction_active>(index, val);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1043 inst = inst->Next_2xx();
1044 } else {
1045 HANDLE_PENDING_EXCEPTION();
1046 }
1047 break;
1048 }
1049 case Instruction::APUT_WIDE: {
1050 PREAMBLE();
1051 Object* a = shadow_frame.GetVRegReference(inst->VRegB_23x());
1052 if (UNLIKELY(a == NULL)) {
1053 ThrowNullPointerExceptionFromDexPC(shadow_frame.GetCurrentLocationForThrow());
1054 HANDLE_PENDING_EXCEPTION();
1055 break;
1056 }
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1057 int64_t val = shadow_frame.GetVRegLong(inst->VRegA_23x(inst_data));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1058 int32_t index = shadow_frame.GetVReg(inst->VRegC_23x());
1059 LongArray* array = a->AsLongArray();
Sebastien Hertzabff6432014-01-27 18:01:39 +0100[diff] [blame]1060 if (LIKELY(array->CheckIsValidIndex(index))) {
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100[diff] [blame^]1061 array->SetWithoutChecks<transaction_active>(index, val);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1062 inst = inst->Next_2xx();
1063 } else {
1064 HANDLE_PENDING_EXCEPTION();
1065 }
1066 break;
1067 }
1068 case Instruction::APUT_OBJECT: {
1069 PREAMBLE();
1070 Object* a = shadow_frame.GetVRegReference(inst->VRegB_23x());
1071 if (UNLIKELY(a == NULL)) {
1072 ThrowNullPointerExceptionFromDexPC(shadow_frame.GetCurrentLocationForThrow());
1073 HANDLE_PENDING_EXCEPTION();
1074 break;
1075 }
1076 int32_t index = shadow_frame.GetVReg(inst->VRegC_23x());
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1077 Object* val = shadow_frame.GetVRegReference(inst->VRegA_23x(inst_data));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1078 ObjectArray<Object>* array = a->AsObjectArray<Object>();
Sebastien Hertzabff6432014-01-27 18:01:39 +0100[diff] [blame]1079 if (LIKELY(array->CheckIsValidIndex(index) && array->CheckAssignable(val))) {
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100[diff] [blame^]1080 array->SetWithoutChecks<transaction_active>(index, val);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1081 inst = inst->Next_2xx();
1082 } else {
1083 HANDLE_PENDING_EXCEPTION();
1084 }
1085 break;
1086 }
1087 case Instruction::IGET_BOOLEAN: {
1088 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1089 bool success = DoFieldGet<InstancePrimitiveRead, Primitive::kPrimBoolean, do_access_check>(self, shadow_frame, inst, inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1090 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx);
1091 break;
1092 }
1093 case Instruction::IGET_BYTE: {
1094 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1095 bool success = DoFieldGet<InstancePrimitiveRead, Primitive::kPrimByte, do_access_check>(self, shadow_frame, inst, inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1096 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx);
1097 break;
1098 }
1099 case Instruction::IGET_CHAR: {
1100 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1101 bool success = DoFieldGet<InstancePrimitiveRead, Primitive::kPrimChar, do_access_check>(self, shadow_frame, inst, inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1102 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx);
1103 break;
1104 }
1105 case Instruction::IGET_SHORT: {
1106 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1107 bool success = DoFieldGet<InstancePrimitiveRead, Primitive::kPrimShort, do_access_check>(self, shadow_frame, inst, inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1108 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx);
1109 break;
1110 }
1111 case Instruction::IGET: {
1112 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1113 bool success = DoFieldGet<InstancePrimitiveRead, Primitive::kPrimInt, do_access_check>(self, shadow_frame, inst, inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1114 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx);
1115 break;
1116 }
1117 case Instruction::IGET_WIDE: {
1118 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1119 bool success = DoFieldGet<InstancePrimitiveRead, Primitive::kPrimLong, do_access_check>(self, shadow_frame, inst, inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1120 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx);
1121 break;
1122 }
1123 case Instruction::IGET_OBJECT: {
1124 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1125 bool success = DoFieldGet<InstanceObjectRead, Primitive::kPrimNot, do_access_check>(self, shadow_frame, inst, inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1126 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx);
1127 break;
1128 }
1129 case Instruction::IGET_QUICK: {
1130 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1131 bool success = DoIGetQuick<Primitive::kPrimInt>(shadow_frame, inst, inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1132 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx);
1133 break;
1134 }
1135 case Instruction::IGET_WIDE_QUICK: {
1136 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1137 bool success = DoIGetQuick<Primitive::kPrimLong>(shadow_frame, inst, inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1138 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx);
1139 break;
1140 }
1141 case Instruction::IGET_OBJECT_QUICK: {
1142 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1143 bool success = DoIGetQuick<Primitive::kPrimNot>(shadow_frame, inst, inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1144 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx);
1145 break;
1146 }
1147 case Instruction::SGET_BOOLEAN: {
1148 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1149 bool success = DoFieldGet<StaticPrimitiveRead, Primitive::kPrimBoolean, do_access_check>(self, shadow_frame, inst, inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1150 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx);
1151 break;
1152 }
1153 case Instruction::SGET_BYTE: {
1154 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1155 bool success = DoFieldGet<StaticPrimitiveRead, Primitive::kPrimByte, do_access_check>(self, shadow_frame, inst, inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1156 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx);
1157 break;
1158 }
1159 case Instruction::SGET_CHAR: {
1160 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1161 bool success = DoFieldGet<StaticPrimitiveRead, Primitive::kPrimChar, do_access_check>(self, shadow_frame, inst, inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1162 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx);
1163 break;
1164 }
1165 case Instruction::SGET_SHORT: {
1166 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1167 bool success = DoFieldGet<StaticPrimitiveRead, Primitive::kPrimShort, do_access_check>(self, shadow_frame, inst, inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1168 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx);
1169 break;
1170 }
1171 case Instruction::SGET: {
1172 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1173 bool success = DoFieldGet<StaticPrimitiveRead, Primitive::kPrimInt, do_access_check>(self, shadow_frame, inst, inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1174 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx);
1175 break;
1176 }
1177 case Instruction::SGET_WIDE: {
1178 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1179 bool success = DoFieldGet<StaticPrimitiveRead, Primitive::kPrimLong, do_access_check>(self, shadow_frame, inst, inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1180 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx);
1181 break;
1182 }
1183 case Instruction::SGET_OBJECT: {
1184 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1185 bool success = DoFieldGet<StaticObjectRead, Primitive::kPrimNot, do_access_check>(self, shadow_frame, inst, inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1186 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx);
1187 break;
1188 }
1189 case Instruction::IPUT_BOOLEAN: {
1190 PREAMBLE();
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100[diff] [blame^]1191 bool success = DoFieldPut<InstancePrimitiveWrite, Primitive::kPrimBoolean, do_access_check, transaction_active>(self, shadow_frame, inst, inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1192 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx);
1193 break;
1194 }
1195 case Instruction::IPUT_BYTE: {
1196 PREAMBLE();
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100[diff] [blame^]1197 bool success = DoFieldPut<InstancePrimitiveWrite, Primitive::kPrimByte, do_access_check, transaction_active>(self, shadow_frame, inst, inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1198 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx);
1199 break;
1200 }
1201 case Instruction::IPUT_CHAR: {
1202 PREAMBLE();
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100[diff] [blame^]1203 bool success = DoFieldPut<InstancePrimitiveWrite, Primitive::kPrimChar, do_access_check, transaction_active>(self, shadow_frame, inst, inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1204 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx);
1205 break;
1206 }
1207 case Instruction::IPUT_SHORT: {
1208 PREAMBLE();
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100[diff] [blame^]1209 bool success = DoFieldPut<InstancePrimitiveWrite, Primitive::kPrimShort, do_access_check, transaction_active>(self, shadow_frame, inst, inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1210 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx);
1211 break;
1212 }
1213 case Instruction::IPUT: {
1214 PREAMBLE();
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100[diff] [blame^]1215 bool success = DoFieldPut<InstancePrimitiveWrite, Primitive::kPrimInt, do_access_check, transaction_active>(self, shadow_frame, inst, inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1216 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx);
1217 break;
1218 }
1219 case Instruction::IPUT_WIDE: {
1220 PREAMBLE();
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100[diff] [blame^]1221 bool success = DoFieldPut<InstancePrimitiveWrite, Primitive::kPrimLong, do_access_check, transaction_active>(self, shadow_frame, inst, inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1222 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx);
1223 break;
1224 }
1225 case Instruction::IPUT_OBJECT: {
1226 PREAMBLE();
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100[diff] [blame^]1227 bool success = DoFieldPut<InstanceObjectWrite, Primitive::kPrimNot, do_access_check, transaction_active>(self, shadow_frame, inst, inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1228 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx);
1229 break;
1230 }
1231 case Instruction::IPUT_QUICK: {
1232 PREAMBLE();
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100[diff] [blame^]1233 bool success = DoIPutQuick<Primitive::kPrimInt, transaction_active>(shadow_frame, inst, inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1234 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx);
1235 break;
1236 }
1237 case Instruction::IPUT_WIDE_QUICK: {
1238 PREAMBLE();
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100[diff] [blame^]1239 bool success = DoIPutQuick<Primitive::kPrimLong, transaction_active>(shadow_frame, inst, inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1240 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx);
1241 break;
1242 }
1243 case Instruction::IPUT_OBJECT_QUICK: {
1244 PREAMBLE();
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100[diff] [blame^]1245 bool success = DoIPutQuick<Primitive::kPrimNot, transaction_active>(shadow_frame, inst, inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1246 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx);
1247 break;
1248 }
1249 case Instruction::SPUT_BOOLEAN: {
1250 PREAMBLE();
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100[diff] [blame^]1251 bool success = DoFieldPut<StaticPrimitiveWrite, Primitive::kPrimBoolean, do_access_check, transaction_active>(self, shadow_frame, inst, inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1252 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx);
1253 break;
1254 }
1255 case Instruction::SPUT_BYTE: {
1256 PREAMBLE();
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100[diff] [blame^]1257 bool success = DoFieldPut<StaticPrimitiveWrite, Primitive::kPrimByte, do_access_check, transaction_active>(self, shadow_frame, inst, inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1258 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx);
1259 break;
1260 }
1261 case Instruction::SPUT_CHAR: {
1262 PREAMBLE();
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100[diff] [blame^]1263 bool success = DoFieldPut<StaticPrimitiveWrite, Primitive::kPrimChar, do_access_check, transaction_active>(self, shadow_frame, inst, inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1264 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx);
1265 break;
1266 }
1267 case Instruction::SPUT_SHORT: {
1268 PREAMBLE();
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100[diff] [blame^]1269 bool success = DoFieldPut<StaticPrimitiveWrite, Primitive::kPrimShort, do_access_check, transaction_active>(self, shadow_frame, inst, inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1270 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx);
1271 break;
1272 }
1273 case Instruction::SPUT: {
1274 PREAMBLE();
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100[diff] [blame^]1275 bool success = DoFieldPut<StaticPrimitiveWrite, Primitive::kPrimInt, do_access_check, transaction_active>(self, shadow_frame, inst, inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1276 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx);
1277 break;
1278 }
1279 case Instruction::SPUT_WIDE: {
1280 PREAMBLE();
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100[diff] [blame^]1281 bool success = DoFieldPut<StaticPrimitiveWrite, Primitive::kPrimLong, do_access_check, transaction_active>(self, shadow_frame, inst, inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1282 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx);
1283 break;
1284 }
1285 case Instruction::SPUT_OBJECT: {
1286 PREAMBLE();
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100[diff] [blame^]1287 bool success = DoFieldPut<StaticObjectWrite, Primitive::kPrimNot, do_access_check, transaction_active>(self, shadow_frame, inst, inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1288 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx);
1289 break;
1290 }
1291 case Instruction::INVOKE_VIRTUAL: {
1292 PREAMBLE();
Sebastien Hertzc61124b2013-09-10 11:44:19 +0200[diff] [blame]1293 bool success = DoInvoke<kVirtual, false, do_access_check>(self, shadow_frame, inst, inst_data, &result_register);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1294 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_3xx);
1295 break;
1296 }
1297 case Instruction::INVOKE_VIRTUAL_RANGE: {
1298 PREAMBLE();
Sebastien Hertzc61124b2013-09-10 11:44:19 +0200[diff] [blame]1299 bool success = DoInvoke<kVirtual, true, do_access_check>(self, shadow_frame, inst, inst_data, &result_register);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1300 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_3xx);
1301 break;
1302 }
1303 case Instruction::INVOKE_SUPER: {
1304 PREAMBLE();
Sebastien Hertzc61124b2013-09-10 11:44:19 +0200[diff] [blame]1305 bool success = DoInvoke<kSuper, false, do_access_check>(self, shadow_frame, inst, inst_data, &result_register);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1306 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_3xx);
1307 break;
1308 }
1309 case Instruction::INVOKE_SUPER_RANGE: {
1310 PREAMBLE();
Sebastien Hertzc61124b2013-09-10 11:44:19 +0200[diff] [blame]1311 bool success = DoInvoke<kSuper, true, do_access_check>(self, shadow_frame, inst, inst_data, &result_register);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1312 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_3xx);
1313 break;
1314 }
1315 case Instruction::INVOKE_DIRECT: {
1316 PREAMBLE();
Sebastien Hertzc61124b2013-09-10 11:44:19 +0200[diff] [blame]1317 bool success = DoInvoke<kDirect, false, do_access_check>(self, shadow_frame, inst, inst_data, &result_register);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1318 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_3xx);
1319 break;
1320 }
1321 case Instruction::INVOKE_DIRECT_RANGE: {
1322 PREAMBLE();
Sebastien Hertzc61124b2013-09-10 11:44:19 +0200[diff] [blame]1323 bool success = DoInvoke<kDirect, true, do_access_check>(self, shadow_frame, inst, inst_data, &result_register);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1324 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_3xx);
1325 break;
1326 }
1327 case Instruction::INVOKE_INTERFACE: {
1328 PREAMBLE();
Sebastien Hertzc61124b2013-09-10 11:44:19 +0200[diff] [blame]1329 bool success = DoInvoke<kInterface, false, do_access_check>(self, shadow_frame, inst, inst_data, &result_register);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1330 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_3xx);
1331 break;
1332 }
1333 case Instruction::INVOKE_INTERFACE_RANGE: {
1334 PREAMBLE();
Sebastien Hertzc61124b2013-09-10 11:44:19 +0200[diff] [blame]1335 bool success = DoInvoke<kInterface, true, do_access_check>(self, shadow_frame, inst, inst_data, &result_register);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1336 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_3xx);
1337 break;
1338 }
1339 case Instruction::INVOKE_STATIC: {
1340 PREAMBLE();
Sebastien Hertzc61124b2013-09-10 11:44:19 +0200[diff] [blame]1341 bool success = DoInvoke<kStatic, false, do_access_check>(self, shadow_frame, inst, inst_data, &result_register);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1342 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_3xx);
1343 break;
1344 }
1345 case Instruction::INVOKE_STATIC_RANGE: {
1346 PREAMBLE();
Sebastien Hertzc61124b2013-09-10 11:44:19 +0200[diff] [blame]1347 bool success = DoInvoke<kStatic, true, do_access_check>(self, shadow_frame, inst, inst_data, &result_register);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1348 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_3xx);
1349 break;
1350 }
1351 case Instruction::INVOKE_VIRTUAL_QUICK: {
1352 PREAMBLE();
Sebastien Hertzc61124b2013-09-10 11:44:19 +0200[diff] [blame]1353 bool success = DoInvokeVirtualQuick<false>(self, shadow_frame, inst, inst_data, &result_register);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1354 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_3xx);
1355 break;
1356 }
1357 case Instruction::INVOKE_VIRTUAL_RANGE_QUICK: {
1358 PREAMBLE();
Sebastien Hertzc61124b2013-09-10 11:44:19 +0200[diff] [blame]1359 bool success = DoInvokeVirtualQuick<true>(self, shadow_frame, inst, inst_data, &result_register);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1360 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_3xx);
1361 break;
1362 }
1363 case Instruction::NEG_INT:
1364 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1365 shadow_frame.SetVReg(inst->VRegA_12x(inst_data), -shadow_frame.GetVReg(inst->VRegB_12x(inst_data)));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1366 inst = inst->Next_1xx();
1367 break;
1368 case Instruction::NOT_INT:
1369 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1370 shadow_frame.SetVReg(inst->VRegA_12x(inst_data), ~shadow_frame.GetVReg(inst->VRegB_12x(inst_data)));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1371 inst = inst->Next_1xx();
1372 break;
1373 case Instruction::NEG_LONG:
1374 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1375 shadow_frame.SetVRegLong(inst->VRegA_12x(inst_data), -shadow_frame.GetVRegLong(inst->VRegB_12x(inst_data)));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1376 inst = inst->Next_1xx();
1377 break;
1378 case Instruction::NOT_LONG:
1379 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1380 shadow_frame.SetVRegLong(inst->VRegA_12x(inst_data), ~shadow_frame.GetVRegLong(inst->VRegB_12x(inst_data)));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1381 inst = inst->Next_1xx();
1382 break;
1383 case Instruction::NEG_FLOAT:
1384 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1385 shadow_frame.SetVRegFloat(inst->VRegA_12x(inst_data), -shadow_frame.GetVRegFloat(inst->VRegB_12x(inst_data)));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1386 inst = inst->Next_1xx();
1387 break;
1388 case Instruction::NEG_DOUBLE:
1389 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1390 shadow_frame.SetVRegDouble(inst->VRegA_12x(inst_data), -shadow_frame.GetVRegDouble(inst->VRegB_12x(inst_data)));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1391 inst = inst->Next_1xx();
1392 break;
1393 case Instruction::INT_TO_LONG:
1394 PREAMBLE();
Ian Rogers450dcb52013-09-20 17:36:02 -0700[diff] [blame]1395 shadow_frame.SetVRegLong(inst->VRegA_12x(inst_data),
1396 shadow_frame.GetVReg(inst->VRegB_12x(inst_data)));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1397 inst = inst->Next_1xx();
1398 break;
1399 case Instruction::INT_TO_FLOAT:
1400 PREAMBLE();
Ian Rogers450dcb52013-09-20 17:36:02 -0700[diff] [blame]1401 shadow_frame.SetVRegFloat(inst->VRegA_12x(inst_data),
1402 shadow_frame.GetVReg(inst->VRegB_12x(inst_data)));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1403 inst = inst->Next_1xx();
1404 break;
1405 case Instruction::INT_TO_DOUBLE:
1406 PREAMBLE();
Ian Rogers450dcb52013-09-20 17:36:02 -0700[diff] [blame]1407 shadow_frame.SetVRegDouble(inst->VRegA_12x(inst_data),
1408 shadow_frame.GetVReg(inst->VRegB_12x(inst_data)));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1409 inst = inst->Next_1xx();
1410 break;
1411 case Instruction::LONG_TO_INT:
1412 PREAMBLE();
Ian Rogers450dcb52013-09-20 17:36:02 -0700[diff] [blame]1413 shadow_frame.SetVReg(inst->VRegA_12x(inst_data),
1414 shadow_frame.GetVRegLong(inst->VRegB_12x(inst_data)));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1415 inst = inst->Next_1xx();
1416 break;
1417 case Instruction::LONG_TO_FLOAT:
1418 PREAMBLE();
Ian Rogers450dcb52013-09-20 17:36:02 -0700[diff] [blame]1419 shadow_frame.SetVRegFloat(inst->VRegA_12x(inst_data),
1420 shadow_frame.GetVRegLong(inst->VRegB_12x(inst_data)));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1421 inst = inst->Next_1xx();
1422 break;
1423 case Instruction::LONG_TO_DOUBLE:
1424 PREAMBLE();
Ian Rogers450dcb52013-09-20 17:36:02 -0700[diff] [blame]1425 shadow_frame.SetVRegDouble(inst->VRegA_12x(inst_data),
1426 shadow_frame.GetVRegLong(inst->VRegB_12x(inst_data)));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1427 inst = inst->Next_1xx();
1428 break;
1429 case Instruction::FLOAT_TO_INT: {
1430 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1431 float val = shadow_frame.GetVRegFloat(inst->VRegB_12x(inst_data));
Ian Rogers450dcb52013-09-20 17:36:02 -0700[diff] [blame]1432 int32_t result = art_float_to_integral<int32_t, float>(val);
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1433 shadow_frame.SetVReg(inst->VRegA_12x(inst_data), result);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1434 inst = inst->Next_1xx();
1435 break;
1436 }
1437 case Instruction::FLOAT_TO_LONG: {
1438 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1439 float val = shadow_frame.GetVRegFloat(inst->VRegB_12x(inst_data));
Ian Rogers450dcb52013-09-20 17:36:02 -0700[diff] [blame]1440 int64_t result = art_float_to_integral<int64_t, float>(val);
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1441 shadow_frame.SetVRegLong(inst->VRegA_12x(inst_data), result);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1442 inst = inst->Next_1xx();
1443 break;
1444 }
1445 case Instruction::FLOAT_TO_DOUBLE:
1446 PREAMBLE();
Ian Rogers450dcb52013-09-20 17:36:02 -0700[diff] [blame]1447 shadow_frame.SetVRegDouble(inst->VRegA_12x(inst_data),
1448 shadow_frame.GetVRegFloat(inst->VRegB_12x(inst_data)));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1449 inst = inst->Next_1xx();
1450 break;
1451 case Instruction::DOUBLE_TO_INT: {
1452 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1453 double val = shadow_frame.GetVRegDouble(inst->VRegB_12x(inst_data));
Ian Rogers450dcb52013-09-20 17:36:02 -0700[diff] [blame]1454 int32_t result = art_float_to_integral<int32_t, double>(val);
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1455 shadow_frame.SetVReg(inst->VRegA_12x(inst_data), result);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1456 inst = inst->Next_1xx();
1457 break;
1458 }
1459 case Instruction::DOUBLE_TO_LONG: {
1460 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1461 double val = shadow_frame.GetVRegDouble(inst->VRegB_12x(inst_data));
Ian Rogers450dcb52013-09-20 17:36:02 -0700[diff] [blame]1462 int64_t result = art_float_to_integral<int64_t, double>(val);
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1463 shadow_frame.SetVRegLong(inst->VRegA_12x(inst_data), result);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1464 inst = inst->Next_1xx();
1465 break;
1466 }
1467 case Instruction::DOUBLE_TO_FLOAT:
1468 PREAMBLE();
Ian Rogers450dcb52013-09-20 17:36:02 -0700[diff] [blame]1469 shadow_frame.SetVRegFloat(inst->VRegA_12x(inst_data),
1470 shadow_frame.GetVRegDouble(inst->VRegB_12x(inst_data)));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1471 inst = inst->Next_1xx();
1472 break;
1473 case Instruction::INT_TO_BYTE:
1474 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1475 shadow_frame.SetVReg(inst->VRegA_12x(inst_data),
1476 static_cast<int8_t>(shadow_frame.GetVReg(inst->VRegB_12x(inst_data))));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1477 inst = inst->Next_1xx();
1478 break;
1479 case Instruction::INT_TO_CHAR:
1480 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1481 shadow_frame.SetVReg(inst->VRegA_12x(inst_data),
1482 static_cast<uint16_t>(shadow_frame.GetVReg(inst->VRegB_12x(inst_data))));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1483 inst = inst->Next_1xx();
1484 break;
1485 case Instruction::INT_TO_SHORT:
1486 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1487 shadow_frame.SetVReg(inst->VRegA_12x(inst_data),
1488 static_cast<int16_t>(shadow_frame.GetVReg(inst->VRegB_12x(inst_data))));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1489 inst = inst->Next_1xx();
1490 break;
1491 case Instruction::ADD_INT:
1492 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1493 shadow_frame.SetVReg(inst->VRegA_23x(inst_data),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1494 shadow_frame.GetVReg(inst->VRegB_23x()) +
1495 shadow_frame.GetVReg(inst->VRegC_23x()));
1496 inst = inst->Next_2xx();
1497 break;
1498 case Instruction::SUB_INT:
1499 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1500 shadow_frame.SetVReg(inst->VRegA_23x(inst_data),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1501 shadow_frame.GetVReg(inst->VRegB_23x()) -
1502 shadow_frame.GetVReg(inst->VRegC_23x()));
1503 inst = inst->Next_2xx();
1504 break;
1505 case Instruction::MUL_INT:
1506 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1507 shadow_frame.SetVReg(inst->VRegA_23x(inst_data),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1508 shadow_frame.GetVReg(inst->VRegB_23x()) *
1509 shadow_frame.GetVReg(inst->VRegC_23x()));
1510 inst = inst->Next_2xx();
1511 break;
1512 case Instruction::DIV_INT: {
1513 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1514 bool success = DoIntDivide(shadow_frame, inst->VRegA_23x(inst_data),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1515 shadow_frame.GetVReg(inst->VRegB_23x()),
1516 shadow_frame.GetVReg(inst->VRegC_23x()));
1517 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx);
1518 break;
1519 }
1520 case Instruction::REM_INT: {
1521 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1522 bool success = DoIntRemainder(shadow_frame, inst->VRegA_23x(inst_data),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1523 shadow_frame.GetVReg(inst->VRegB_23x()),
1524 shadow_frame.GetVReg(inst->VRegC_23x()));
1525 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx);
1526 break;
1527 }
1528 case Instruction::SHL_INT:
1529 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1530 shadow_frame.SetVReg(inst->VRegA_23x(inst_data),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1531 shadow_frame.GetVReg(inst->VRegB_23x()) <<
1532 (shadow_frame.GetVReg(inst->VRegC_23x()) & 0x1f));
1533 inst = inst->Next_2xx();
1534 break;
1535 case Instruction::SHR_INT:
1536 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1537 shadow_frame.SetVReg(inst->VRegA_23x(inst_data),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1538 shadow_frame.GetVReg(inst->VRegB_23x()) >>
1539 (shadow_frame.GetVReg(inst->VRegC_23x()) & 0x1f));
1540 inst = inst->Next_2xx();
1541 break;
1542 case Instruction::USHR_INT:
1543 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1544 shadow_frame.SetVReg(inst->VRegA_23x(inst_data),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1545 static_cast<uint32_t>(shadow_frame.GetVReg(inst->VRegB_23x())) >>
1546 (shadow_frame.GetVReg(inst->VRegC_23x()) & 0x1f));
1547 inst = inst->Next_2xx();
1548 break;
1549 case Instruction::AND_INT:
1550 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1551 shadow_frame.SetVReg(inst->VRegA_23x(inst_data),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1552 shadow_frame.GetVReg(inst->VRegB_23x()) &
1553 shadow_frame.GetVReg(inst->VRegC_23x()));
1554 inst = inst->Next_2xx();
1555 break;
1556 case Instruction::OR_INT:
1557 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1558 shadow_frame.SetVReg(inst->VRegA_23x(inst_data),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1559 shadow_frame.GetVReg(inst->VRegB_23x()) |
1560 shadow_frame.GetVReg(inst->VRegC_23x()));
1561 inst = inst->Next_2xx();
1562 break;
1563 case Instruction::XOR_INT:
1564 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1565 shadow_frame.SetVReg(inst->VRegA_23x(inst_data),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1566 shadow_frame.GetVReg(inst->VRegB_23x()) ^
1567 shadow_frame.GetVReg(inst->VRegC_23x()));
1568 inst = inst->Next_2xx();
1569 break;
1570 case Instruction::ADD_LONG:
1571 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1572 shadow_frame.SetVRegLong(inst->VRegA_23x(inst_data),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1573 shadow_frame.GetVRegLong(inst->VRegB_23x()) +
1574 shadow_frame.GetVRegLong(inst->VRegC_23x()));
1575 inst = inst->Next_2xx();
1576 break;
1577 case Instruction::SUB_LONG:
1578 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1579 shadow_frame.SetVRegLong(inst->VRegA_23x(inst_data),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1580 shadow_frame.GetVRegLong(inst->VRegB_23x()) -
1581 shadow_frame.GetVRegLong(inst->VRegC_23x()));
1582 inst = inst->Next_2xx();
1583 break;
1584 case Instruction::MUL_LONG:
1585 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1586 shadow_frame.SetVRegLong(inst->VRegA_23x(inst_data),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1587 shadow_frame.GetVRegLong(inst->VRegB_23x()) *
1588 shadow_frame.GetVRegLong(inst->VRegC_23x()));
1589 inst = inst->Next_2xx();
1590 break;
1591 case Instruction::DIV_LONG:
1592 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1593 DoLongDivide(shadow_frame, inst->VRegA_23x(inst_data),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1594 shadow_frame.GetVRegLong(inst->VRegB_23x()),
1595 shadow_frame.GetVRegLong(inst->VRegC_23x()));
1596 POSSIBLY_HANDLE_PENDING_EXCEPTION(self->IsExceptionPending(), Next_2xx);
1597 break;
1598 case Instruction::REM_LONG:
1599 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1600 DoLongRemainder(shadow_frame, inst->VRegA_23x(inst_data),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1601 shadow_frame.GetVRegLong(inst->VRegB_23x()),
1602 shadow_frame.GetVRegLong(inst->VRegC_23x()));
1603 POSSIBLY_HANDLE_PENDING_EXCEPTION(self->IsExceptionPending(), Next_2xx);
1604 break;
1605 case Instruction::AND_LONG:
1606 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1607 shadow_frame.SetVRegLong(inst->VRegA_23x(inst_data),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1608 shadow_frame.GetVRegLong(inst->VRegB_23x()) &
1609 shadow_frame.GetVRegLong(inst->VRegC_23x()));
1610 inst = inst->Next_2xx();
1611 break;
1612 case Instruction::OR_LONG:
1613 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1614 shadow_frame.SetVRegLong(inst->VRegA_23x(inst_data),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1615 shadow_frame.GetVRegLong(inst->VRegB_23x()) |
1616 shadow_frame.GetVRegLong(inst->VRegC_23x()));
1617 inst = inst->Next_2xx();
1618 break;
1619 case Instruction::XOR_LONG:
1620 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1621 shadow_frame.SetVRegLong(inst->VRegA_23x(inst_data),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1622 shadow_frame.GetVRegLong(inst->VRegB_23x()) ^
1623 shadow_frame.GetVRegLong(inst->VRegC_23x()));
1624 inst = inst->Next_2xx();
1625 break;
1626 case Instruction::SHL_LONG:
1627 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1628 shadow_frame.SetVRegLong(inst->VRegA_23x(inst_data),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1629 shadow_frame.GetVRegLong(inst->VRegB_23x()) <<
1630 (shadow_frame.GetVReg(inst->VRegC_23x()) & 0x3f));
1631 inst = inst->Next_2xx();
1632 break;
1633 case Instruction::SHR_LONG:
1634 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1635 shadow_frame.SetVRegLong(inst->VRegA_23x(inst_data),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1636 shadow_frame.GetVRegLong(inst->VRegB_23x()) >>
1637 (shadow_frame.GetVReg(inst->VRegC_23x()) & 0x3f));
1638 inst = inst->Next_2xx();
1639 break;
1640 case Instruction::USHR_LONG:
1641 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1642 shadow_frame.SetVRegLong(inst->VRegA_23x(inst_data),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1643 static_cast<uint64_t>(shadow_frame.GetVRegLong(inst->VRegB_23x())) >>
1644 (shadow_frame.GetVReg(inst->VRegC_23x()) & 0x3f));
1645 inst = inst->Next_2xx();
1646 break;
1647 case Instruction::ADD_FLOAT:
1648 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1649 shadow_frame.SetVRegFloat(inst->VRegA_23x(inst_data),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1650 shadow_frame.GetVRegFloat(inst->VRegB_23x()) +
1651 shadow_frame.GetVRegFloat(inst->VRegC_23x()));
1652 inst = inst->Next_2xx();
1653 break;
1654 case Instruction::SUB_FLOAT:
1655 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1656 shadow_frame.SetVRegFloat(inst->VRegA_23x(inst_data),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1657 shadow_frame.GetVRegFloat(inst->VRegB_23x()) -
1658 shadow_frame.GetVRegFloat(inst->VRegC_23x()));
1659 inst = inst->Next_2xx();
1660 break;
1661 case Instruction::MUL_FLOAT:
1662 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1663 shadow_frame.SetVRegFloat(inst->VRegA_23x(inst_data),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1664 shadow_frame.GetVRegFloat(inst->VRegB_23x()) *
1665 shadow_frame.GetVRegFloat(inst->VRegC_23x()));
1666 inst = inst->Next_2xx();
1667 break;
1668 case Instruction::DIV_FLOAT:
1669 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1670 shadow_frame.SetVRegFloat(inst->VRegA_23x(inst_data),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1671 shadow_frame.GetVRegFloat(inst->VRegB_23x()) /
1672 shadow_frame.GetVRegFloat(inst->VRegC_23x()));
1673 inst = inst->Next_2xx();
1674 break;
1675 case Instruction::REM_FLOAT:
1676 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1677 shadow_frame.SetVRegFloat(inst->VRegA_23x(inst_data),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1678 fmodf(shadow_frame.GetVRegFloat(inst->VRegB_23x()),
1679 shadow_frame.GetVRegFloat(inst->VRegC_23x())));
1680 inst = inst->Next_2xx();
1681 break;
1682 case Instruction::ADD_DOUBLE:
1683 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1684 shadow_frame.SetVRegDouble(inst->VRegA_23x(inst_data),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1685 shadow_frame.GetVRegDouble(inst->VRegB_23x()) +
1686 shadow_frame.GetVRegDouble(inst->VRegC_23x()));
1687 inst = inst->Next_2xx();
1688 break;
1689 case Instruction::SUB_DOUBLE:
1690 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1691 shadow_frame.SetVRegDouble(inst->VRegA_23x(inst_data),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1692 shadow_frame.GetVRegDouble(inst->VRegB_23x()) -
1693 shadow_frame.GetVRegDouble(inst->VRegC_23x()));
1694 inst = inst->Next_2xx();
1695 break;
1696 case Instruction::MUL_DOUBLE:
1697 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1698 shadow_frame.SetVRegDouble(inst->VRegA_23x(inst_data),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1699 shadow_frame.GetVRegDouble(inst->VRegB_23x()) *
1700 shadow_frame.GetVRegDouble(inst->VRegC_23x()));
1701 inst = inst->Next_2xx();
1702 break;
1703 case Instruction::DIV_DOUBLE:
1704 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1705 shadow_frame.SetVRegDouble(inst->VRegA_23x(inst_data),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1706 shadow_frame.GetVRegDouble(inst->VRegB_23x()) /
1707 shadow_frame.GetVRegDouble(inst->VRegC_23x()));
1708 inst = inst->Next_2xx();
1709 break;
1710 case Instruction::REM_DOUBLE:
1711 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1712 shadow_frame.SetVRegDouble(inst->VRegA_23x(inst_data),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1713 fmod(shadow_frame.GetVRegDouble(inst->VRegB_23x()),
1714 shadow_frame.GetVRegDouble(inst->VRegC_23x())));
1715 inst = inst->Next_2xx();
1716 break;
1717 case Instruction::ADD_INT_2ADDR: {
1718 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1719 uint4_t vregA = inst->VRegA_12x(inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1720 shadow_frame.SetVReg(vregA,
1721 shadow_frame.GetVReg(vregA) +
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1722 shadow_frame.GetVReg(inst->VRegB_12x(inst_data)));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1723 inst = inst->Next_1xx();
1724 break;
1725 }
1726 case Instruction::SUB_INT_2ADDR: {
1727 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1728 uint4_t vregA = inst->VRegA_12x(inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1729 shadow_frame.SetVReg(vregA,
1730 shadow_frame.GetVReg(vregA) -
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1731 shadow_frame.GetVReg(inst->VRegB_12x(inst_data)));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1732 inst = inst->Next_1xx();
1733 break;
1734 }
1735 case Instruction::MUL_INT_2ADDR: {
1736 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1737 uint4_t vregA = inst->VRegA_12x(inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1738 shadow_frame.SetVReg(vregA,
1739 shadow_frame.GetVReg(vregA) *
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1740 shadow_frame.GetVReg(inst->VRegB_12x(inst_data)));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1741 inst = inst->Next_1xx();
1742 break;
1743 }
1744 case Instruction::DIV_INT_2ADDR: {
1745 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1746 uint4_t vregA = inst->VRegA_12x(inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1747 bool success = DoIntDivide(shadow_frame, vregA, shadow_frame.GetVReg(vregA),
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1748 shadow_frame.GetVReg(inst->VRegB_12x(inst_data)));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1749 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_1xx);
1750 break;
1751 }
1752 case Instruction::REM_INT_2ADDR: {
1753 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1754 uint4_t vregA = inst->VRegA_12x(inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1755 bool success = DoIntRemainder(shadow_frame, vregA, shadow_frame.GetVReg(vregA),
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1756 shadow_frame.GetVReg(inst->VRegB_12x(inst_data)));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1757 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_1xx);
1758 break;
1759 }
1760 case Instruction::SHL_INT_2ADDR: {
1761 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1762 uint4_t vregA = inst->VRegA_12x(inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1763 shadow_frame.SetVReg(vregA,
1764 shadow_frame.GetVReg(vregA) <<
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1765 (shadow_frame.GetVReg(inst->VRegB_12x(inst_data)) & 0x1f));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1766 inst = inst->Next_1xx();
1767 break;
1768 }
1769 case Instruction::SHR_INT_2ADDR: {
1770 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1771 uint4_t vregA = inst->VRegA_12x(inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1772 shadow_frame.SetVReg(vregA,
1773 shadow_frame.GetVReg(vregA) >>
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1774 (shadow_frame.GetVReg(inst->VRegB_12x(inst_data)) & 0x1f));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1775 inst = inst->Next_1xx();
1776 break;
1777 }
1778 case Instruction::USHR_INT_2ADDR: {
1779 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1780 uint4_t vregA = inst->VRegA_12x(inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1781 shadow_frame.SetVReg(vregA,
1782 static_cast<uint32_t>(shadow_frame.GetVReg(vregA)) >>
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1783 (shadow_frame.GetVReg(inst->VRegB_12x(inst_data)) & 0x1f));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1784 inst = inst->Next_1xx();
1785 break;
1786 }
1787 case Instruction::AND_INT_2ADDR: {
1788 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1789 uint4_t vregA = inst->VRegA_12x(inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1790 shadow_frame.SetVReg(vregA,
1791 shadow_frame.GetVReg(vregA) &
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1792 shadow_frame.GetVReg(inst->VRegB_12x(inst_data)));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1793 inst = inst->Next_1xx();
1794 break;
1795 }
1796 case Instruction::OR_INT_2ADDR: {
1797 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1798 uint4_t vregA = inst->VRegA_12x(inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1799 shadow_frame.SetVReg(vregA,
1800 shadow_frame.GetVReg(vregA) |
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1801 shadow_frame.GetVReg(inst->VRegB_12x(inst_data)));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1802 inst = inst->Next_1xx();
1803 break;
1804 }
1805 case Instruction::XOR_INT_2ADDR: {
1806 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1807 uint4_t vregA = inst->VRegA_12x(inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1808 shadow_frame.SetVReg(vregA,
1809 shadow_frame.GetVReg(vregA) ^
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1810 shadow_frame.GetVReg(inst->VRegB_12x(inst_data)));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1811 inst = inst->Next_1xx();
1812 break;
1813 }
1814 case Instruction::ADD_LONG_2ADDR: {
1815 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1816 uint4_t vregA = inst->VRegA_12x(inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1817 shadow_frame.SetVRegLong(vregA,
1818 shadow_frame.GetVRegLong(vregA) +
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1819 shadow_frame.GetVRegLong(inst->VRegB_12x(inst_data)));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1820 inst = inst->Next_1xx();
1821 break;
1822 }
1823 case Instruction::SUB_LONG_2ADDR: {
1824 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1825 uint4_t vregA = inst->VRegA_12x(inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1826 shadow_frame.SetVRegLong(vregA,
1827 shadow_frame.GetVRegLong(vregA) -
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1828 shadow_frame.GetVRegLong(inst->VRegB_12x(inst_data)));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1829 inst = inst->Next_1xx();
1830 break;
1831 }
1832 case Instruction::MUL_LONG_2ADDR: {
1833 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1834 uint4_t vregA = inst->VRegA_12x(inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1835 shadow_frame.SetVRegLong(vregA,
1836 shadow_frame.GetVRegLong(vregA) *
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1837 shadow_frame.GetVRegLong(inst->VRegB_12x(inst_data)));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1838 inst = inst->Next_1xx();
1839 break;
1840 }
1841 case Instruction::DIV_LONG_2ADDR: {
1842 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1843 uint4_t vregA = inst->VRegA_12x(inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1844 DoLongDivide(shadow_frame, vregA, shadow_frame.GetVRegLong(vregA),
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1845 shadow_frame.GetVRegLong(inst->VRegB_12x(inst_data)));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1846 POSSIBLY_HANDLE_PENDING_EXCEPTION(self->IsExceptionPending(), Next_1xx);
1847 break;
1848 }
1849 case Instruction::REM_LONG_2ADDR: {
1850 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1851 uint4_t vregA = inst->VRegA_12x(inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1852 DoLongRemainder(shadow_frame, vregA, shadow_frame.GetVRegLong(vregA),
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1853 shadow_frame.GetVRegLong(inst->VRegB_12x(inst_data)));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1854 POSSIBLY_HANDLE_PENDING_EXCEPTION(self->IsExceptionPending(), Next_1xx);
1855 break;
1856 }
1857 case Instruction::AND_LONG_2ADDR: {
1858 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1859 uint4_t vregA = inst->VRegA_12x(inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1860 shadow_frame.SetVRegLong(vregA,
1861 shadow_frame.GetVRegLong(vregA) &
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1862 shadow_frame.GetVRegLong(inst->VRegB_12x(inst_data)));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1863 inst = inst->Next_1xx();
1864 break;
1865 }
1866 case Instruction::OR_LONG_2ADDR: {
1867 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1868 uint4_t vregA = inst->VRegA_12x(inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1869 shadow_frame.SetVRegLong(vregA,
1870 shadow_frame.GetVRegLong(vregA) |
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1871 shadow_frame.GetVRegLong(inst->VRegB_12x(inst_data)));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1872 inst = inst->Next_1xx();
1873 break;
1874 }
1875 case Instruction::XOR_LONG_2ADDR: {
1876 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1877 uint4_t vregA = inst->VRegA_12x(inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1878 shadow_frame.SetVRegLong(vregA,
1879 shadow_frame.GetVRegLong(vregA) ^
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1880 shadow_frame.GetVRegLong(inst->VRegB_12x(inst_data)));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1881 inst = inst->Next_1xx();
1882 break;
1883 }
1884 case Instruction::SHL_LONG_2ADDR: {
1885 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1886 uint4_t vregA = inst->VRegA_12x(inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1887 shadow_frame.SetVRegLong(vregA,
1888 shadow_frame.GetVRegLong(vregA) <<
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1889 (shadow_frame.GetVReg(inst->VRegB_12x(inst_data)) & 0x3f));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1890 inst = inst->Next_1xx();
1891 break;
1892 }
1893 case Instruction::SHR_LONG_2ADDR: {
1894 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1895 uint4_t vregA = inst->VRegA_12x(inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1896 shadow_frame.SetVRegLong(vregA,
1897 shadow_frame.GetVRegLong(vregA) >>
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1898 (shadow_frame.GetVReg(inst->VRegB_12x(inst_data)) & 0x3f));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1899 inst = inst->Next_1xx();
1900 break;
1901 }
1902 case Instruction::USHR_LONG_2ADDR: {
1903 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1904 uint4_t vregA = inst->VRegA_12x(inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1905 shadow_frame.SetVRegLong(vregA,
1906 static_cast<uint64_t>(shadow_frame.GetVRegLong(vregA)) >>
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1907 (shadow_frame.GetVReg(inst->VRegB_12x(inst_data)) & 0x3f));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1908 inst = inst->Next_1xx();
1909 break;
1910 }
1911 case Instruction::ADD_FLOAT_2ADDR: {
1912 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1913 uint4_t vregA = inst->VRegA_12x(inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1914 shadow_frame.SetVRegFloat(vregA,
1915 shadow_frame.GetVRegFloat(vregA) +
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1916 shadow_frame.GetVRegFloat(inst->VRegB_12x(inst_data)));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1917 inst = inst->Next_1xx();
1918 break;
1919 }
1920 case Instruction::SUB_FLOAT_2ADDR: {
1921 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1922 uint4_t vregA = inst->VRegA_12x(inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1923 shadow_frame.SetVRegFloat(vregA,
1924 shadow_frame.GetVRegFloat(vregA) -
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1925 shadow_frame.GetVRegFloat(inst->VRegB_12x(inst_data)));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1926 inst = inst->Next_1xx();
1927 break;
1928 }
1929 case Instruction::MUL_FLOAT_2ADDR: {
1930 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1931 uint4_t vregA = inst->VRegA_12x(inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1932 shadow_frame.SetVRegFloat(vregA,
1933 shadow_frame.GetVRegFloat(vregA) *
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1934 shadow_frame.GetVRegFloat(inst->VRegB_12x(inst_data)));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1935 inst = inst->Next_1xx();
1936 break;
1937 }
1938 case Instruction::DIV_FLOAT_2ADDR: {
1939 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1940 uint4_t vregA = inst->VRegA_12x(inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1941 shadow_frame.SetVRegFloat(vregA,
1942 shadow_frame.GetVRegFloat(vregA) /
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1943 shadow_frame.GetVRegFloat(inst->VRegB_12x(inst_data)));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1944 inst = inst->Next_1xx();
1945 break;
1946 }
1947 case Instruction::REM_FLOAT_2ADDR: {
1948 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1949 uint4_t vregA = inst->VRegA_12x(inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1950 shadow_frame.SetVRegFloat(vregA,
1951 fmodf(shadow_frame.GetVRegFloat(vregA),
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1952 shadow_frame.GetVRegFloat(inst->VRegB_12x(inst_data))));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1953 inst = inst->Next_1xx();
1954 break;
1955 }
1956 case Instruction::ADD_DOUBLE_2ADDR: {
1957 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1958 uint4_t vregA = inst->VRegA_12x(inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1959 shadow_frame.SetVRegDouble(vregA,
1960 shadow_frame.GetVRegDouble(vregA) +
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1961 shadow_frame.GetVRegDouble(inst->VRegB_12x(inst_data)));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1962 inst = inst->Next_1xx();
1963 break;
1964 }
1965 case Instruction::SUB_DOUBLE_2ADDR: {
1966 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1967 uint4_t vregA = inst->VRegA_12x(inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1968 shadow_frame.SetVRegDouble(vregA,
1969 shadow_frame.GetVRegDouble(vregA) -
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1970 shadow_frame.GetVRegDouble(inst->VRegB_12x(inst_data)));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1971 inst = inst->Next_1xx();
1972 break;
1973 }
1974 case Instruction::MUL_DOUBLE_2ADDR: {
1975 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1976 uint4_t vregA = inst->VRegA_12x(inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1977 shadow_frame.SetVRegDouble(vregA,
1978 shadow_frame.GetVRegDouble(vregA) *
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1979 shadow_frame.GetVRegDouble(inst->VRegB_12x(inst_data)));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1980 inst = inst->Next_1xx();
1981 break;
1982 }
1983 case Instruction::DIV_DOUBLE_2ADDR: {
1984 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1985 uint4_t vregA = inst->VRegA_12x(inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1986 shadow_frame.SetVRegDouble(vregA,
1987 shadow_frame.GetVRegDouble(vregA) /
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1988 shadow_frame.GetVRegDouble(inst->VRegB_12x(inst_data)));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1989 inst = inst->Next_1xx();
1990 break;
1991 }
1992 case Instruction::REM_DOUBLE_2ADDR: {
1993 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1994 uint4_t vregA = inst->VRegA_12x(inst_data);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1995 shadow_frame.SetVRegDouble(vregA,
1996 fmod(shadow_frame.GetVRegDouble(vregA),
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]1997 shadow_frame.GetVRegDouble(inst->VRegB_12x(inst_data))));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]1998 inst = inst->Next_1xx();
1999 break;
2000 }
2001 case Instruction::ADD_INT_LIT16:
2002 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]2003 shadow_frame.SetVReg(inst->VRegA_22s(inst_data),
2004 shadow_frame.GetVReg(inst->VRegB_22s(inst_data)) +
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]2005 inst->VRegC_22s());
2006 inst = inst->Next_2xx();
2007 break;
2008 case Instruction::RSUB_INT:
2009 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]2010 shadow_frame.SetVReg(inst->VRegA_22s(inst_data),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]2011 inst->VRegC_22s() -
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]2012 shadow_frame.GetVReg(inst->VRegB_22s(inst_data)));
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]2013 inst = inst->Next_2xx();
2014 break;
2015 case Instruction::MUL_INT_LIT16:
2016 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]2017 shadow_frame.SetVReg(inst->VRegA_22s(inst_data),
2018 shadow_frame.GetVReg(inst->VRegB_22s(inst_data)) *
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]2019 inst->VRegC_22s());
2020 inst = inst->Next_2xx();
2021 break;
2022 case Instruction::DIV_INT_LIT16: {
2023 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]2024 bool success = DoIntDivide(shadow_frame, inst->VRegA_22s(inst_data),
2025 shadow_frame.GetVReg(inst->VRegB_22s(inst_data)), inst->VRegC_22s());
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]2026 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx);
2027 break;
2028 }
2029 case Instruction::REM_INT_LIT16: {
2030 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]2031 bool success = DoIntRemainder(shadow_frame, inst->VRegA_22s(inst_data),
2032 shadow_frame.GetVReg(inst->VRegB_22s(inst_data)), inst->VRegC_22s());
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]2033 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx);
2034 break;
2035 }
2036 case Instruction::AND_INT_LIT16:
2037 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]2038 shadow_frame.SetVReg(inst->VRegA_22s(inst_data),
2039 shadow_frame.GetVReg(inst->VRegB_22s(inst_data)) &
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]2040 inst->VRegC_22s());
2041 inst = inst->Next_2xx();
2042 break;
2043 case Instruction::OR_INT_LIT16:
2044 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]2045 shadow_frame.SetVReg(inst->VRegA_22s(inst_data),
2046 shadow_frame.GetVReg(inst->VRegB_22s(inst_data)) |
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]2047 inst->VRegC_22s());
2048 inst = inst->Next_2xx();
2049 break;
2050 case Instruction::XOR_INT_LIT16:
2051 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]2052 shadow_frame.SetVReg(inst->VRegA_22s(inst_data),
2053 shadow_frame.GetVReg(inst->VRegB_22s(inst_data)) ^
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]2054 inst->VRegC_22s());
2055 inst = inst->Next_2xx();
2056 break;
2057 case Instruction::ADD_INT_LIT8:
2058 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]2059 shadow_frame.SetVReg(inst->VRegA_22b(inst_data),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]2060 shadow_frame.GetVReg(inst->VRegB_22b()) +
2061 inst->VRegC_22b());
2062 inst = inst->Next_2xx();
2063 break;
2064 case Instruction::RSUB_INT_LIT8:
2065 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]2066 shadow_frame.SetVReg(inst->VRegA_22b(inst_data),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]2067 inst->VRegC_22b() -
2068 shadow_frame.GetVReg(inst->VRegB_22b()));
2069 inst = inst->Next_2xx();
2070 break;
2071 case Instruction::MUL_INT_LIT8:
2072 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]2073 shadow_frame.SetVReg(inst->VRegA_22b(inst_data),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]2074 shadow_frame.GetVReg(inst->VRegB_22b()) *
2075 inst->VRegC_22b());
2076 inst = inst->Next_2xx();
2077 break;
2078 case Instruction::DIV_INT_LIT8: {
2079 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]2080 bool success = DoIntDivide(shadow_frame, inst->VRegA_22b(inst_data),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]2081 shadow_frame.GetVReg(inst->VRegB_22b()), inst->VRegC_22b());
2082 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx);
2083 break;
2084 }
2085 case Instruction::REM_INT_LIT8: {
2086 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]2087 bool success = DoIntRemainder(shadow_frame, inst->VRegA_22b(inst_data),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]2088 shadow_frame.GetVReg(inst->VRegB_22b()), inst->VRegC_22b());
2089 POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx);
2090 break;
2091 }
2092 case Instruction::AND_INT_LIT8:
2093 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]2094 shadow_frame.SetVReg(inst->VRegA_22b(inst_data),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]2095 shadow_frame.GetVReg(inst->VRegB_22b()) &
2096 inst->VRegC_22b());
2097 inst = inst->Next_2xx();
2098 break;
2099 case Instruction::OR_INT_LIT8:
2100 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]2101 shadow_frame.SetVReg(inst->VRegA_22b(inst_data),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]2102 shadow_frame.GetVReg(inst->VRegB_22b()) |
2103 inst->VRegC_22b());
2104 inst = inst->Next_2xx();
2105 break;
2106 case Instruction::XOR_INT_LIT8:
2107 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]2108 shadow_frame.SetVReg(inst->VRegA_22b(inst_data),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]2109 shadow_frame.GetVReg(inst->VRegB_22b()) ^
2110 inst->VRegC_22b());
2111 inst = inst->Next_2xx();
2112 break;
2113 case Instruction::SHL_INT_LIT8:
2114 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]2115 shadow_frame.SetVReg(inst->VRegA_22b(inst_data),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]2116 shadow_frame.GetVReg(inst->VRegB_22b()) <<
2117 (inst->VRegC_22b() & 0x1f));
2118 inst = inst->Next_2xx();
2119 break;
2120 case Instruction::SHR_INT_LIT8:
2121 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]2122 shadow_frame.SetVReg(inst->VRegA_22b(inst_data),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]2123 shadow_frame.GetVReg(inst->VRegB_22b()) >>
2124 (inst->VRegC_22b() & 0x1f));
2125 inst = inst->Next_2xx();
2126 break;
2127 case Instruction::USHR_INT_LIT8:
2128 PREAMBLE();
Sebastien Hertz3b588e02013-09-11 14:33:18 +0200[diff] [blame]2129 shadow_frame.SetVReg(inst->VRegA_22b(inst_data),
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]2130 static_cast<uint32_t>(shadow_frame.GetVReg(inst->VRegB_22b())) >>
2131 (inst->VRegC_22b() & 0x1f));
2132 inst = inst->Next_2xx();
2133 break;
2134 case Instruction::UNUSED_3E ... Instruction::UNUSED_43:
2135 case Instruction::UNUSED_EB ... Instruction::UNUSED_FF:
2136 case Instruction::UNUSED_79:
2137 case Instruction::UNUSED_7A:
2138 UnexpectedOpcode(inst, mh);
2139 }
2140 }
2141} // NOLINT(readability/fn_size)
2142
2143// Explicit definitions of ExecuteSwitchImpl.
Sebastien Hertzc6714852013-09-30 16:42:32 +0200[diff] [blame]2144template SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) HOT_ATTR
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100[diff] [blame^]2145JValue ExecuteSwitchImpl<true, false>(Thread* self, MethodHelper& mh,
2146 const DexFile::CodeItem* code_item,
2147 ShadowFrame& shadow_frame, JValue result_register);
Sebastien Hertzc6714852013-09-30 16:42:32 +0200[diff] [blame]2148template SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) HOT_ATTR
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100[diff] [blame^]2149JValue ExecuteSwitchImpl<false, false>(Thread* self, MethodHelper& mh,
2150 const DexFile::CodeItem* code_item,
2151 ShadowFrame& shadow_frame, JValue result_register);
2152template SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
2153JValue ExecuteSwitchImpl<true, true>(Thread* self, MethodHelper& mh,
2154 const DexFile::CodeItem* code_item,
2155 ShadowFrame& shadow_frame, JValue result_register);
2156template SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
2157JValue ExecuteSwitchImpl<false, true>(Thread* self, MethodHelper& mh,
2158 const DexFile::CodeItem* code_item,
2159 ShadowFrame& shadow_frame, JValue result_register);
Sebastien Hertz8ece0502013-08-07 11:26:41 +0200[diff] [blame]2160
2161} // namespace interpreter
2162} // namespace art