1 /*
2 * Copyright (C) 2016 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 /*
18 * Mterp entry point and support functions.
19 */
20 #include "mterp.h"
21
22 #include "base/quasi_atomic.h"
23 #include "debugger.h"
24 #include "entrypoints/entrypoint_utils-inl.h"
25 #include "interpreter/interpreter_common.h"
26 #include "interpreter/interpreter_intrinsics.h"
27 #include "interpreter/shadow_frame-inl.h"
28 #include "mirror/string-alloc-inl.h"
29
30 namespace art {
31 namespace interpreter {
32 /*
33 * Verify some constants used by the mterp interpreter.
34 */
CheckMterpAsmConstants()35 void CheckMterpAsmConstants() {
36 /*
37 * If we're using computed goto instruction transitions, make sure
38 * none of the handlers overflows the byte limit. This won't tell
39 * which one did, but if any one is too big the total size will
40 * overflow.
41 */
42 const int width = kMterpHandlerSize;
43 int interp_size = (uintptr_t) artMterpAsmInstructionEnd -
44 (uintptr_t) artMterpAsmInstructionStart;
45 if ((interp_size == 0) || (interp_size != (art::kNumPackedOpcodes * width))) {
46 LOG(FATAL) << "ERROR: unexpected asm interp size " << interp_size
47 << "(did an instruction handler exceed " << width << " bytes?)";
48 }
49 }
50
InitMterpTls(Thread * self)51 void InitMterpTls(Thread* self) {
52 self->SetMterpCurrentIBase(artMterpAsmInstructionStart);
53 }
54
55 /*
56 * Find the matching case. Returns the offset to the handler instructions.
57 *
58 * Returns 3 if we don't find a match (it's the size of the sparse-switch
59 * instruction).
60 */
MterpDoSparseSwitch(const uint16_t * switchData,int32_t testVal)61 extern "C" ssize_t MterpDoSparseSwitch(const uint16_t* switchData, int32_t testVal) {
62 const int kInstrLen = 3;
63 uint16_t size;
64 const int32_t* keys;
65 const int32_t* entries;
66
67 /*
68 * Sparse switch data format:
69 * ushort ident = 0x0200 magic value
70 * ushort size number of entries in the table; > 0
71 * int keys[size] keys, sorted low-to-high; 32-bit aligned
72 * int targets[size] branch targets, relative to switch opcode
73 *
74 * Total size is (2+size*4) 16-bit code units.
75 */
76
77 uint16_t signature = *switchData++;
78 DCHECK_EQ(signature, static_cast<uint16_t>(art::Instruction::kSparseSwitchSignature));
79
80 size = *switchData++;
81
82 /* The keys are guaranteed to be aligned on a 32-bit boundary;
83 * we can treat them as a native int array.
84 */
85 keys = reinterpret_cast<const int32_t*>(switchData);
86
87 /* The entries are guaranteed to be aligned on a 32-bit boundary;
88 * we can treat them as a native int array.
89 */
90 entries = keys + size;
91
92 /*
93 * Binary-search through the array of keys, which are guaranteed to
94 * be sorted low-to-high.
95 */
96 int lo = 0;
97 int hi = size - 1;
98 while (lo <= hi) {
99 int mid = (lo + hi) >> 1;
100
101 int32_t foundVal = keys[mid];
102 if (testVal < foundVal) {
103 hi = mid - 1;
104 } else if (testVal > foundVal) {
105 lo = mid + 1;
106 } else {
107 return entries[mid];
108 }
109 }
110 return kInstrLen;
111 }
112
MterpDoPackedSwitch(const uint16_t * switchData,int32_t testVal)113 extern "C" ssize_t MterpDoPackedSwitch(const uint16_t* switchData, int32_t testVal) {
114 const int kInstrLen = 3;
115
116 /*
117 * Packed switch data format:
118 * ushort ident = 0x0100 magic value
119 * ushort size number of entries in the table
120 * int first_key first (and lowest) switch case value
121 * int targets[size] branch targets, relative to switch opcode
122 *
123 * Total size is (4+size*2) 16-bit code units.
124 */
125 uint16_t signature = *switchData++;
126 DCHECK_EQ(signature, static_cast<uint16_t>(art::Instruction::kPackedSwitchSignature));
127
128 uint16_t size = *switchData++;
129
130 int32_t firstKey = *switchData++;
131 firstKey |= (*switchData++) << 16;
132
133 int index = testVal - firstKey;
134 if (index < 0 || index >= size) {
135 return kInstrLen;
136 }
137
138 /*
139 * The entries are guaranteed to be aligned on a 32-bit boundary;
140 * we can treat them as a native int array.
141 */
142 const int32_t* entries = reinterpret_cast<const int32_t*>(switchData);
143 return entries[index];
144 }
145
CanUseMterp()146 bool CanUseMterp()
147 REQUIRES_SHARED(Locks::mutator_lock_) {
148 const Runtime* const runtime = Runtime::Current();
149 return
150 runtime->IsStarted() &&
151 !runtime->IsAotCompiler() &&
152 !Dbg::IsDebuggerActive() &&
153 !runtime->GetInstrumentation()->IsActive() &&
154 // mterp only knows how to deal with the normal exits. It cannot handle any of the
155 // non-standard force-returns.
156 !runtime->AreNonStandardExitsEnabled() &&
157 // An async exception has been thrown. We need to go to the switch interpreter. MTerp doesn't
158 // know how to deal with these so we could end up never dealing with it if we are in an
159 // infinite loop.
160 !runtime->AreAsyncExceptionsThrown() &&
161 (runtime->GetJit() == nullptr || !runtime->GetJit()->JitAtFirstUse());
162 }
163
164
MterpInvokeVirtual(Thread * self,ShadowFrame * shadow_frame,uint16_t * dex_pc_ptr,uint16_t inst_data)165 extern "C" size_t MterpInvokeVirtual(Thread* self,
166 ShadowFrame* shadow_frame,
167 uint16_t* dex_pc_ptr,
168 uint16_t inst_data)
169 REQUIRES_SHARED(Locks::mutator_lock_) {
170 JValue* result_register = shadow_frame->GetResultRegister();
171 const Instruction* inst = Instruction::At(dex_pc_ptr);
172 return DoInvoke<kVirtual, /*is_range=*/ false, /*do_access_check=*/ false, /*is_mterp=*/ true>(
173 self, *shadow_frame, inst, inst_data, result_register);
174 }
175
MterpInvokeSuper(Thread * self,ShadowFrame * shadow_frame,uint16_t * dex_pc_ptr,uint16_t inst_data)176 extern "C" size_t MterpInvokeSuper(Thread* self,
177 ShadowFrame* shadow_frame,
178 uint16_t* dex_pc_ptr,
179 uint16_t inst_data)
180 REQUIRES_SHARED(Locks::mutator_lock_) {
181 JValue* result_register = shadow_frame->GetResultRegister();
182 const Instruction* inst = Instruction::At(dex_pc_ptr);
183 return DoInvoke<kSuper, /*is_range=*/ false, /*do_access_check=*/ false, /*is_mterp=*/ true>(
184 self, *shadow_frame, inst, inst_data, result_register);
185 }
186
MterpInvokeInterface(Thread * self,ShadowFrame * shadow_frame,uint16_t * dex_pc_ptr,uint16_t inst_data)187 extern "C" size_t MterpInvokeInterface(Thread* self,
188 ShadowFrame* shadow_frame,
189 uint16_t* dex_pc_ptr,
190 uint16_t inst_data)
191 REQUIRES_SHARED(Locks::mutator_lock_) {
192 JValue* result_register = shadow_frame->GetResultRegister();
193 const Instruction* inst = Instruction::At(dex_pc_ptr);
194 return DoInvoke<kInterface, /*is_range=*/ false, /*do_access_check=*/ false, /*is_mterp=*/ true>(
195 self, *shadow_frame, inst, inst_data, result_register);
196 }
197
MterpInvokeDirect(Thread * self,ShadowFrame * shadow_frame,uint16_t * dex_pc_ptr,uint16_t inst_data)198 extern "C" size_t MterpInvokeDirect(Thread* self,
199 ShadowFrame* shadow_frame,
200 uint16_t* dex_pc_ptr,
201 uint16_t inst_data)
202 REQUIRES_SHARED(Locks::mutator_lock_) {
203 JValue* result_register = shadow_frame->GetResultRegister();
204 const Instruction* inst = Instruction::At(dex_pc_ptr);
205 return DoInvoke<kDirect, /*is_range=*/ false, /*do_access_check=*/ false, /*is_mterp=*/ true>(
206 self, *shadow_frame, inst, inst_data, result_register);
207 }
208
MterpInvokeStatic(Thread * self,ShadowFrame * shadow_frame,uint16_t * dex_pc_ptr,uint16_t inst_data)209 extern "C" size_t MterpInvokeStatic(Thread* self,
210 ShadowFrame* shadow_frame,
211 uint16_t* dex_pc_ptr,
212 uint16_t inst_data)
213 REQUIRES_SHARED(Locks::mutator_lock_) {
214 JValue* result_register = shadow_frame->GetResultRegister();
215 const Instruction* inst = Instruction::At(dex_pc_ptr);
216 return DoInvoke<kStatic, /*is_range=*/ false, /*do_access_check=*/ false, /*is_mterp=*/ true>(
217 self, *shadow_frame, inst, inst_data, result_register);
218 }
219
MterpInvokeCustom(Thread * self,ShadowFrame * shadow_frame,uint16_t * dex_pc_ptr,uint16_t inst_data)220 extern "C" size_t MterpInvokeCustom(Thread* self,
221 ShadowFrame* shadow_frame,
222 uint16_t* dex_pc_ptr,
223 uint16_t inst_data)
224 REQUIRES_SHARED(Locks::mutator_lock_) {
225 JValue* result_register = shadow_frame->GetResultRegister();
226 const Instruction* inst = Instruction::At(dex_pc_ptr);
227 return DoInvokeCustom</* is_range= */ false>(
228 self, *shadow_frame, inst, inst_data, result_register);
229 }
230
MterpInvokePolymorphic(Thread * self,ShadowFrame * shadow_frame,uint16_t * dex_pc_ptr,uint16_t inst_data)231 extern "C" size_t MterpInvokePolymorphic(Thread* self,
232 ShadowFrame* shadow_frame,
233 uint16_t* dex_pc_ptr,
234 uint16_t inst_data)
235 REQUIRES_SHARED(Locks::mutator_lock_) {
236 JValue* result_register = shadow_frame->GetResultRegister();
237 const Instruction* inst = Instruction::At(dex_pc_ptr);
238 return DoInvokePolymorphic</* is_range= */ false>(
239 self, *shadow_frame, inst, inst_data, result_register);
240 }
241
MterpInvokeVirtualRange(Thread * self,ShadowFrame * shadow_frame,uint16_t * dex_pc_ptr,uint16_t inst_data)242 extern "C" size_t MterpInvokeVirtualRange(Thread* self,
243 ShadowFrame* shadow_frame,
244 uint16_t* dex_pc_ptr,
245 uint16_t inst_data)
246 REQUIRES_SHARED(Locks::mutator_lock_) {
247 JValue* result_register = shadow_frame->GetResultRegister();
248 const Instruction* inst = Instruction::At(dex_pc_ptr);
249 return DoInvoke<kVirtual, /*is_range=*/ true, /*do_access_check=*/ false, /*is_mterp=*/ true>(
250 self, *shadow_frame, inst, inst_data, result_register);
251 }
252
MterpInvokeSuperRange(Thread * self,ShadowFrame * shadow_frame,uint16_t * dex_pc_ptr,uint16_t inst_data)253 extern "C" size_t MterpInvokeSuperRange(Thread* self,
254 ShadowFrame* shadow_frame,
255 uint16_t* dex_pc_ptr,
256 uint16_t inst_data)
257 REQUIRES_SHARED(Locks::mutator_lock_) {
258 JValue* result_register = shadow_frame->GetResultRegister();
259 const Instruction* inst = Instruction::At(dex_pc_ptr);
260 return DoInvoke<kSuper, /*is_range=*/ true, /*do_access_check=*/ false, /*is_mterp=*/ true>(
261 self, *shadow_frame, inst, inst_data, result_register);
262 }
263
MterpInvokeInterfaceRange(Thread * self,ShadowFrame * shadow_frame,uint16_t * dex_pc_ptr,uint16_t inst_data)264 extern "C" size_t MterpInvokeInterfaceRange(Thread* self,
265 ShadowFrame* shadow_frame,
266 uint16_t* dex_pc_ptr,
267 uint16_t inst_data)
268 REQUIRES_SHARED(Locks::mutator_lock_) {
269 JValue* result_register = shadow_frame->GetResultRegister();
270 const Instruction* inst = Instruction::At(dex_pc_ptr);
271 return DoInvoke<kInterface, /*is_range=*/ true, /*do_access_check=*/ false, /*is_mterp=*/ true>(
272 self, *shadow_frame, inst, inst_data, result_register);
273 }
274
MterpInvokeDirectRange(Thread * self,ShadowFrame * shadow_frame,uint16_t * dex_pc_ptr,uint16_t inst_data)275 extern "C" size_t MterpInvokeDirectRange(Thread* self,
276 ShadowFrame* shadow_frame,
277 uint16_t* dex_pc_ptr,
278 uint16_t inst_data)
279 REQUIRES_SHARED(Locks::mutator_lock_) {
280 JValue* result_register = shadow_frame->GetResultRegister();
281 const Instruction* inst = Instruction::At(dex_pc_ptr);
282 return DoInvoke<kDirect, /*is_range=*/ true, /*do_access_check=*/ false, /*is_mterp=*/ true>(
283 self, *shadow_frame, inst, inst_data, result_register);
284 }
285
MterpInvokeStaticRange(Thread * self,ShadowFrame * shadow_frame,uint16_t * dex_pc_ptr,uint16_t inst_data)286 extern "C" size_t MterpInvokeStaticRange(Thread* self,
287 ShadowFrame* shadow_frame,
288 uint16_t* dex_pc_ptr,
289 uint16_t inst_data)
290 REQUIRES_SHARED(Locks::mutator_lock_) {
291 JValue* result_register = shadow_frame->GetResultRegister();
292 const Instruction* inst = Instruction::At(dex_pc_ptr);
293 return DoInvoke<kStatic, /*is_range=*/ true, /*do_access_check=*/ false, /*is_mterp=*/ true>(
294 self, *shadow_frame, inst, inst_data, result_register);
295 }
296
MterpInvokeCustomRange(Thread * self,ShadowFrame * shadow_frame,uint16_t * dex_pc_ptr,uint16_t inst_data)297 extern "C" size_t MterpInvokeCustomRange(Thread* self,
298 ShadowFrame* shadow_frame,
299 uint16_t* dex_pc_ptr,
300 uint16_t inst_data)
301 REQUIRES_SHARED(Locks::mutator_lock_) {
302 JValue* result_register = shadow_frame->GetResultRegister();
303 const Instruction* inst = Instruction::At(dex_pc_ptr);
304 return DoInvokeCustom</*is_range=*/ true>(self, *shadow_frame, inst, inst_data, result_register);
305 }
306
MterpInvokePolymorphicRange(Thread * self,ShadowFrame * shadow_frame,uint16_t * dex_pc_ptr,uint16_t inst_data)307 extern "C" size_t MterpInvokePolymorphicRange(Thread* self,
308 ShadowFrame* shadow_frame,
309 uint16_t* dex_pc_ptr,
310 uint16_t inst_data)
311 REQUIRES_SHARED(Locks::mutator_lock_) {
312 JValue* result_register = shadow_frame->GetResultRegister();
313 const Instruction* inst = Instruction::At(dex_pc_ptr);
314 return DoInvokePolymorphic</* is_range= */ true>(
315 self, *shadow_frame, inst, inst_data, result_register);
316 }
317
MterpInvokeVirtualQuick(Thread * self,ShadowFrame * shadow_frame,uint16_t * dex_pc_ptr,uint16_t inst_data)318 extern "C" size_t MterpInvokeVirtualQuick(Thread* self,
319 ShadowFrame* shadow_frame,
320 uint16_t* dex_pc_ptr,
321 uint16_t inst_data)
322 REQUIRES_SHARED(Locks::mutator_lock_) {
323 JValue* result_register = shadow_frame->GetResultRegister();
324 const Instruction* inst = Instruction::At(dex_pc_ptr);
325 return DoInvoke<kVirtual, /*is_range=*/ false, /*do_access_check=*/ false, /*is_mterp=*/ true,
326 /*is_quick=*/ true>(self, *shadow_frame, inst, inst_data, result_register);
327 }
328
MterpInvokeVirtualQuickRange(Thread * self,ShadowFrame * shadow_frame,uint16_t * dex_pc_ptr,uint16_t inst_data)329 extern "C" size_t MterpInvokeVirtualQuickRange(Thread* self,
330 ShadowFrame* shadow_frame,
331 uint16_t* dex_pc_ptr,
332 uint16_t inst_data)
333 REQUIRES_SHARED(Locks::mutator_lock_) {
334 JValue* result_register = shadow_frame->GetResultRegister();
335 const Instruction* inst = Instruction::At(dex_pc_ptr);
336 return DoInvoke<kVirtual, /*is_range=*/ true, /*do_access_check=*/ false, /*is_mterp=*/ true,
337 /*is_quick=*/ true>(self, *shadow_frame, inst, inst_data, result_register);
338 }
339
MterpThreadFenceForConstructor()340 extern "C" void MterpThreadFenceForConstructor() {
341 QuasiAtomic::ThreadFenceForConstructor();
342 }
343
MterpConstString(uint32_t index,uint32_t tgt_vreg,ShadowFrame * shadow_frame,Thread * self)344 extern "C" size_t MterpConstString(uint32_t index,
345 uint32_t tgt_vreg,
346 ShadowFrame* shadow_frame,
347 Thread* self)
348 REQUIRES_SHARED(Locks::mutator_lock_) {
349 ObjPtr<mirror::String> s = ResolveString(self, *shadow_frame, dex::StringIndex(index));
350 if (UNLIKELY(s == nullptr)) {
351 return true;
352 }
353 shadow_frame->SetVRegReference(tgt_vreg, s);
354 return false;
355 }
356
MterpConstClass(uint32_t index,uint32_t tgt_vreg,ShadowFrame * shadow_frame,Thread * self)357 extern "C" size_t MterpConstClass(uint32_t index,
358 uint32_t tgt_vreg,
359 ShadowFrame* shadow_frame,
360 Thread* self)
361 REQUIRES_SHARED(Locks::mutator_lock_) {
362 ObjPtr<mirror::Class> c = ResolveVerifyAndClinit(dex::TypeIndex(index),
363 shadow_frame->GetMethod(),
364 self,
365 /* can_run_clinit= */ false,
366 /* verify_access= */ false);
367 if (UNLIKELY(c == nullptr)) {
368 return true;
369 }
370 shadow_frame->SetVRegReference(tgt_vreg, c);
371 return false;
372 }
373
MterpConstMethodHandle(uint32_t index,uint32_t tgt_vreg,ShadowFrame * shadow_frame,Thread * self)374 extern "C" size_t MterpConstMethodHandle(uint32_t index,
375 uint32_t tgt_vreg,
376 ShadowFrame* shadow_frame,
377 Thread* self)
378 REQUIRES_SHARED(Locks::mutator_lock_) {
379 ObjPtr<mirror::MethodHandle> mh = ResolveMethodHandle(self, index, shadow_frame->GetMethod());
380 if (UNLIKELY(mh == nullptr)) {
381 return true;
382 }
383 shadow_frame->SetVRegReference(tgt_vreg, mh);
384 return false;
385 }
386
MterpConstMethodType(uint32_t index,uint32_t tgt_vreg,ShadowFrame * shadow_frame,Thread * self)387 extern "C" size_t MterpConstMethodType(uint32_t index,
388 uint32_t tgt_vreg,
389 ShadowFrame* shadow_frame,
390 Thread* self)
391 REQUIRES_SHARED(Locks::mutator_lock_) {
392 ObjPtr<mirror::MethodType> mt =
393 ResolveMethodType(self, dex::ProtoIndex(index), shadow_frame->GetMethod());
394 if (UNLIKELY(mt == nullptr)) {
395 return true;
396 }
397 shadow_frame->SetVRegReference(tgt_vreg, mt);
398 return false;
399 }
400
MterpCheckCast(uint32_t index,StackReference<mirror::Object> * vreg_addr,art::ArtMethod * method,Thread * self)401 extern "C" size_t MterpCheckCast(uint32_t index,
402 StackReference<mirror::Object>* vreg_addr,
403 art::ArtMethod* method,
404 Thread* self)
405 REQUIRES_SHARED(Locks::mutator_lock_) {
406 ObjPtr<mirror::Class> c = ResolveVerifyAndClinit(dex::TypeIndex(index),
407 method,
408 self,
409 false,
410 false);
411 if (UNLIKELY(c == nullptr)) {
412 return true;
413 }
414 // Must load obj from vreg following ResolveVerifyAndClinit due to moving gc.
415 ObjPtr<mirror::Object> obj = vreg_addr->AsMirrorPtr();
416 if (UNLIKELY(obj != nullptr && !obj->InstanceOf(c))) {
417 ThrowClassCastException(c, obj->GetClass());
418 return true;
419 }
420 return false;
421 }
422
MterpInstanceOf(uint32_t index,StackReference<mirror::Object> * vreg_addr,art::ArtMethod * method,Thread * self)423 extern "C" size_t MterpInstanceOf(uint32_t index,
424 StackReference<mirror::Object>* vreg_addr,
425 art::ArtMethod* method,
426 Thread* self)
427 REQUIRES_SHARED(Locks::mutator_lock_) {
428 ObjPtr<mirror::Class> c = ResolveVerifyAndClinit(dex::TypeIndex(index),
429 method,
430 self,
431 false,
432 false);
433 if (UNLIKELY(c == nullptr)) {
434 return false; // Caller will check for pending exception. Return value unimportant.
435 }
436 // Must load obj from vreg following ResolveVerifyAndClinit due to moving gc.
437 ObjPtr<mirror::Object> obj = vreg_addr->AsMirrorPtr();
438 return (obj != nullptr) && obj->InstanceOf(c);
439 }
440
MterpFillArrayData(mirror::Object * obj,const Instruction::ArrayDataPayload * payload)441 extern "C" size_t MterpFillArrayData(mirror::Object* obj,
442 const Instruction::ArrayDataPayload* payload)
443 REQUIRES_SHARED(Locks::mutator_lock_) {
444 return FillArrayData(obj, payload);
445 }
446
MterpNewInstance(ShadowFrame * shadow_frame,Thread * self,uint32_t inst_data)447 extern "C" size_t MterpNewInstance(ShadowFrame* shadow_frame, Thread* self, uint32_t inst_data)
448 REQUIRES_SHARED(Locks::mutator_lock_) {
449 const Instruction* inst = Instruction::At(shadow_frame->GetDexPCPtr());
450 ObjPtr<mirror::Object> obj = nullptr;
451 ObjPtr<mirror::Class> c = ResolveVerifyAndClinit(dex::TypeIndex(inst->VRegB_21c()),
452 shadow_frame->GetMethod(),
453 self,
454 /* can_run_clinit= */ false,
455 /* verify_access= */ false);
456 if (LIKELY(c != nullptr)) {
457 if (UNLIKELY(c->IsStringClass())) {
458 gc::AllocatorType allocator_type = Runtime::Current()->GetHeap()->GetCurrentAllocator();
459 obj = mirror::String::AllocEmptyString<true>(self, allocator_type);
460 } else {
461 obj = AllocObjectFromCode<true>(c,
462 self,
463 Runtime::Current()->GetHeap()->GetCurrentAllocator());
464 }
465 }
466 if (UNLIKELY(obj == nullptr)) {
467 return false;
468 }
469 obj->GetClass()->AssertInitializedOrInitializingInThread(self);
470 shadow_frame->SetVRegReference(inst->VRegA_21c(inst_data), obj);
471 return true;
472 }
473
MterpIputObjectQuick(ShadowFrame * shadow_frame,uint16_t * dex_pc_ptr,uint32_t inst_data)474 extern "C" size_t MterpIputObjectQuick(ShadowFrame* shadow_frame,
475 uint16_t* dex_pc_ptr,
476 uint32_t inst_data)
477 REQUIRES_SHARED(Locks::mutator_lock_) {
478 const Instruction* inst = Instruction::At(dex_pc_ptr);
479 return DoIPutQuick<Primitive::kPrimNot, false>(*shadow_frame, inst, inst_data);
480 }
481
MterpAputObject(ShadowFrame * shadow_frame,uint16_t * dex_pc_ptr,uint32_t inst_data)482 extern "C" size_t MterpAputObject(ShadowFrame* shadow_frame,
483 uint16_t* dex_pc_ptr,
484 uint32_t inst_data)
485 REQUIRES_SHARED(Locks::mutator_lock_) {
486 const Instruction* inst = Instruction::At(dex_pc_ptr);
487 ObjPtr<mirror::Object> a = shadow_frame->GetVRegReference(inst->VRegB_23x());
488 if (UNLIKELY(a == nullptr)) {
489 return false;
490 }
491 int32_t index = shadow_frame->GetVReg(inst->VRegC_23x());
492 ObjPtr<mirror::Object> val = shadow_frame->GetVRegReference(inst->VRegA_23x(inst_data));
493 ObjPtr<mirror::ObjectArray<mirror::Object>> array = a->AsObjectArray<mirror::Object>();
494 if (array->CheckIsValidIndex(index) && array->CheckAssignable(val)) {
495 array->SetWithoutChecks<false>(index, val);
496 return true;
497 }
498 return false;
499 }
500
MterpFilledNewArray(ShadowFrame * shadow_frame,uint16_t * dex_pc_ptr,Thread * self)501 extern "C" size_t MterpFilledNewArray(ShadowFrame* shadow_frame,
502 uint16_t* dex_pc_ptr,
503 Thread* self)
504 REQUIRES_SHARED(Locks::mutator_lock_) {
505 const Instruction* inst = Instruction::At(dex_pc_ptr);
506 return DoFilledNewArray<false, false, false>(inst, *shadow_frame, self,
507 shadow_frame->GetResultRegister());
508 }
509
MterpFilledNewArrayRange(ShadowFrame * shadow_frame,uint16_t * dex_pc_ptr,Thread * self)510 extern "C" size_t MterpFilledNewArrayRange(ShadowFrame* shadow_frame,
511 uint16_t* dex_pc_ptr,
512 Thread* self)
513 REQUIRES_SHARED(Locks::mutator_lock_) {
514 const Instruction* inst = Instruction::At(dex_pc_ptr);
515 return DoFilledNewArray<true, false, false>(inst, *shadow_frame, self,
516 shadow_frame->GetResultRegister());
517 }
518
MterpNewArray(ShadowFrame * shadow_frame,uint16_t * dex_pc_ptr,uint32_t inst_data,Thread * self)519 extern "C" size_t MterpNewArray(ShadowFrame* shadow_frame,
520 uint16_t* dex_pc_ptr,
521 uint32_t inst_data, Thread* self)
522 REQUIRES_SHARED(Locks::mutator_lock_) {
523 const Instruction* inst = Instruction::At(dex_pc_ptr);
524 int32_t length = shadow_frame->GetVReg(inst->VRegB_22c(inst_data));
525 ObjPtr<mirror::Object> obj = AllocArrayFromCode<false, true>(
526 dex::TypeIndex(inst->VRegC_22c()), length, shadow_frame->GetMethod(), self,
527 Runtime::Current()->GetHeap()->GetCurrentAllocator());
528 if (UNLIKELY(obj == nullptr)) {
529 return false;
530 }
531 shadow_frame->SetVRegReference(inst->VRegA_22c(inst_data), obj);
532 return true;
533 }
534
MterpHandleException(Thread * self,ShadowFrame * shadow_frame)535 extern "C" size_t MterpHandleException(Thread* self, ShadowFrame* shadow_frame)
536 REQUIRES_SHARED(Locks::mutator_lock_) {
537 DCHECK(self->IsExceptionPending());
538 const instrumentation::Instrumentation* const instrumentation =
539 Runtime::Current()->GetInstrumentation();
540 return MoveToExceptionHandler(self, *shadow_frame, instrumentation);
541 }
542
543 struct MterpCheckHelper {
544 DECLARE_RUNTIME_DEBUG_FLAG(kSlowMode);
545 };
546 DEFINE_RUNTIME_DEBUG_FLAG(MterpCheckHelper, kSlowMode);
547
MterpCheckBefore(Thread * self,ShadowFrame * shadow_frame,uint16_t * dex_pc_ptr)548 extern "C" void MterpCheckBefore(Thread* self, ShadowFrame* shadow_frame, uint16_t* dex_pc_ptr)
549 REQUIRES_SHARED(Locks::mutator_lock_) {
550 // Check that we are using the right interpreter.
551 if (kIsDebugBuild && self->UseMterp() != CanUseMterp()) {
552 // The flag might be currently being updated on all threads. Retry with lock.
553 MutexLock tll_mu(self, *Locks::thread_list_lock_);
554 DCHECK_EQ(self->UseMterp(), CanUseMterp());
555 }
556 DCHECK(!Runtime::Current()->IsActiveTransaction());
557 const Instruction* inst = Instruction::At(dex_pc_ptr);
558 uint16_t inst_data = inst->Fetch16(0);
559 if (inst->Opcode(inst_data) == Instruction::MOVE_EXCEPTION) {
560 self->AssertPendingException();
561 } else {
562 self->AssertNoPendingException();
563 }
564 if (kTraceExecutionEnabled) {
565 uint32_t dex_pc = dex_pc_ptr - shadow_frame->GetDexInstructions();
566 TraceExecution(*shadow_frame, inst, dex_pc);
567 }
568 if (kTestExportPC) {
569 // Save invalid dex pc to force segfault if improperly used.
570 shadow_frame->SetDexPCPtr(reinterpret_cast<uint16_t*>(kExportPCPoison));
571 }
572 if (MterpCheckHelper::kSlowMode) {
573 shadow_frame->CheckConsistentVRegs();
574 }
575 }
576
MterpLogDivideByZeroException(Thread * self,ShadowFrame * shadow_frame)577 extern "C" void MterpLogDivideByZeroException(Thread* self, ShadowFrame* shadow_frame)
578 REQUIRES_SHARED(Locks::mutator_lock_) {
579 UNUSED(self);
580 const Instruction* inst = Instruction::At(shadow_frame->GetDexPCPtr());
581 uint16_t inst_data = inst->Fetch16(0);
582 LOG(INFO) << "DivideByZero: " << inst->Opcode(inst_data);
583 }
584
MterpLogArrayIndexException(Thread * self,ShadowFrame * shadow_frame)585 extern "C" void MterpLogArrayIndexException(Thread* self, ShadowFrame* shadow_frame)
586 REQUIRES_SHARED(Locks::mutator_lock_) {
587 UNUSED(self);
588 const Instruction* inst = Instruction::At(shadow_frame->GetDexPCPtr());
589 uint16_t inst_data = inst->Fetch16(0);
590 LOG(INFO) << "ArrayIndex: " << inst->Opcode(inst_data);
591 }
592
MterpLogNegativeArraySizeException(Thread * self,ShadowFrame * shadow_frame)593 extern "C" void MterpLogNegativeArraySizeException(Thread* self, ShadowFrame* shadow_frame)
594 REQUIRES_SHARED(Locks::mutator_lock_) {
595 UNUSED(self);
596 const Instruction* inst = Instruction::At(shadow_frame->GetDexPCPtr());
597 uint16_t inst_data = inst->Fetch16(0);
598 LOG(INFO) << "NegativeArraySize: " << inst->Opcode(inst_data);
599 }
600
MterpLogNoSuchMethodException(Thread * self,ShadowFrame * shadow_frame)601 extern "C" void MterpLogNoSuchMethodException(Thread* self, ShadowFrame* shadow_frame)
602 REQUIRES_SHARED(Locks::mutator_lock_) {
603 UNUSED(self);
604 const Instruction* inst = Instruction::At(shadow_frame->GetDexPCPtr());
605 uint16_t inst_data = inst->Fetch16(0);
606 LOG(INFO) << "NoSuchMethod: " << inst->Opcode(inst_data);
607 }
608
MterpLogExceptionThrownException(Thread * self,ShadowFrame * shadow_frame)609 extern "C" void MterpLogExceptionThrownException(Thread* self, ShadowFrame* shadow_frame)
610 REQUIRES_SHARED(Locks::mutator_lock_) {
611 UNUSED(self);
612 const Instruction* inst = Instruction::At(shadow_frame->GetDexPCPtr());
613 uint16_t inst_data = inst->Fetch16(0);
614 LOG(INFO) << "ExceptionThrown: " << inst->Opcode(inst_data);
615 }
616
MterpLogNullObjectException(Thread * self,ShadowFrame * shadow_frame)617 extern "C" void MterpLogNullObjectException(Thread* self, ShadowFrame* shadow_frame)
618 REQUIRES_SHARED(Locks::mutator_lock_) {
619 UNUSED(self);
620 const Instruction* inst = Instruction::At(shadow_frame->GetDexPCPtr());
621 uint16_t inst_data = inst->Fetch16(0);
622 LOG(INFO) << "NullObject: " << inst->Opcode(inst_data);
623 }
624
MterpLogFallback(Thread * self,ShadowFrame * shadow_frame)625 extern "C" void MterpLogFallback(Thread* self, ShadowFrame* shadow_frame)
626 REQUIRES_SHARED(Locks::mutator_lock_) {
627 UNUSED(self);
628 const Instruction* inst = Instruction::At(shadow_frame->GetDexPCPtr());
629 uint16_t inst_data = inst->Fetch16(0);
630 LOG(INFO) << "Fallback: " << inst->Opcode(inst_data) << ", Suspend Pending?: "
631 << self->IsExceptionPending();
632 }
633
MterpLogOSR(Thread * self,ShadowFrame * shadow_frame,int32_t offset)634 extern "C" void MterpLogOSR(Thread* self, ShadowFrame* shadow_frame, int32_t offset)
635 REQUIRES_SHARED(Locks::mutator_lock_) {
636 UNUSED(self);
637 const Instruction* inst = Instruction::At(shadow_frame->GetDexPCPtr());
638 uint16_t inst_data = inst->Fetch16(0);
639 LOG(INFO) << "OSR: " << inst->Opcode(inst_data) << ", offset = " << offset;
640 }
641
MterpLogSuspendFallback(Thread * self,ShadowFrame * shadow_frame,uint32_t flags)642 extern "C" void MterpLogSuspendFallback(Thread* self, ShadowFrame* shadow_frame, uint32_t flags)
643 REQUIRES_SHARED(Locks::mutator_lock_) {
644 UNUSED(self);
645 const Instruction* inst = Instruction::At(shadow_frame->GetDexPCPtr());
646 uint16_t inst_data = inst->Fetch16(0);
647 if (flags & kCheckpointRequest) {
648 LOG(INFO) << "Checkpoint fallback: " << inst->Opcode(inst_data);
649 } else if (flags & kSuspendRequest) {
650 LOG(INFO) << "Suspend fallback: " << inst->Opcode(inst_data);
651 } else if (flags & kEmptyCheckpointRequest) {
652 LOG(INFO) << "Empty checkpoint fallback: " << inst->Opcode(inst_data);
653 }
654 }
655
MterpSuspendCheck(Thread * self)656 extern "C" size_t MterpSuspendCheck(Thread* self)
657 REQUIRES_SHARED(Locks::mutator_lock_) {
658 self->AllowThreadSuspension();
659 return !self->UseMterp();
660 }
661
662 // Execute single field access instruction (get/put, static/instance).
663 // The template arguments reduce this to fairly small amount of code.
664 // It requires the target object and field to be already resolved.
665 template<typename PrimType, FindFieldType kAccessType>
MterpFieldAccess(Instruction * inst,uint16_t inst_data,ShadowFrame * shadow_frame,ObjPtr<mirror::Object> obj,MemberOffset offset,bool is_volatile)666 ALWAYS_INLINE void MterpFieldAccess(Instruction* inst,
667 uint16_t inst_data,
668 ShadowFrame* shadow_frame,
669 ObjPtr<mirror::Object> obj,
670 MemberOffset offset,
671 bool is_volatile)
672 REQUIRES_SHARED(Locks::mutator_lock_) {
673 static_assert(std::is_integral<PrimType>::value, "Unexpected primitive type");
674 constexpr bool kIsStatic = (kAccessType & FindFieldFlags::StaticBit) != 0;
675 constexpr bool kIsPrimitive = (kAccessType & FindFieldFlags::PrimitiveBit) != 0;
676 constexpr bool kIsRead = (kAccessType & FindFieldFlags::ReadBit) != 0;
677
678 uint16_t vRegA = kIsStatic ? inst->VRegA_21c(inst_data) : inst->VRegA_22c(inst_data);
679 if (kIsPrimitive) {
680 if (kIsRead) {
681 PrimType value = UNLIKELY(is_volatile)
682 ? obj->GetFieldPrimitive<PrimType, /*kIsVolatile=*/ true>(offset)
683 : obj->GetFieldPrimitive<PrimType, /*kIsVolatile=*/ false>(offset);
684 if (sizeof(PrimType) == sizeof(uint64_t)) {
685 shadow_frame->SetVRegLong(vRegA, value); // Set two consecutive registers.
686 } else {
687 shadow_frame->SetVReg(vRegA, static_cast<int32_t>(value)); // Sign/zero extend.
688 }
689 } else { // Write.
690 uint64_t value = (sizeof(PrimType) == sizeof(uint64_t))
691 ? shadow_frame->GetVRegLong(vRegA)
692 : shadow_frame->GetVReg(vRegA);
693 if (UNLIKELY(is_volatile)) {
694 obj->SetFieldPrimitive<PrimType, /*kIsVolatile=*/ true>(offset, value);
695 } else {
696 obj->SetFieldPrimitive<PrimType, /*kIsVolatile=*/ false>(offset, value);
697 }
698 }
699 } else { // Object.
700 if (kIsRead) {
701 ObjPtr<mirror::Object> value = UNLIKELY(is_volatile)
702 ? obj->GetFieldObjectVolatile<mirror::Object>(offset)
703 : obj->GetFieldObject<mirror::Object>(offset);
704 shadow_frame->SetVRegReference(vRegA, value);
705 } else { // Write.
706 ObjPtr<mirror::Object> value = shadow_frame->GetVRegReference(vRegA);
707 if (UNLIKELY(is_volatile)) {
708 obj->SetFieldObjectVolatile</*kTransactionActive=*/ false>(offset, value);
709 } else {
710 obj->SetFieldObject</*kTransactionActive=*/ false>(offset, value);
711 }
712 }
713 }
714 }
715
716 template<typename PrimType, FindFieldType kAccessType>
MterpFieldAccessSlow(Instruction * inst,uint16_t inst_data,ShadowFrame * shadow_frame,Thread * self)717 NO_INLINE bool MterpFieldAccessSlow(Instruction* inst,
718 uint16_t inst_data,
719 ShadowFrame* shadow_frame,
720 Thread* self)
721 REQUIRES_SHARED(Locks::mutator_lock_) {
722 constexpr bool kIsStatic = (kAccessType & FindFieldFlags::StaticBit) != 0;
723 constexpr bool kIsRead = (kAccessType & FindFieldFlags::ReadBit) != 0;
724
725 // Update the dex pc in shadow frame, just in case anything throws.
726 shadow_frame->SetDexPCPtr(reinterpret_cast<uint16_t*>(inst));
727 ArtMethod* referrer = shadow_frame->GetMethod();
728 uint32_t field_idx = kIsStatic ? inst->VRegB_21c() : inst->VRegC_22c();
729 ArtField* field = FindFieldFromCode<kAccessType, /* access_checks= */ false>(
730 field_idx, referrer, self, sizeof(PrimType));
731 if (UNLIKELY(field == nullptr)) {
732 DCHECK(self->IsExceptionPending());
733 return false;
734 }
735 ObjPtr<mirror::Object> obj = kIsStatic
736 ? field->GetDeclaringClass().Ptr()
737 : shadow_frame->GetVRegReference(inst->VRegB_22c(inst_data));
738 if (UNLIKELY(obj == nullptr)) {
739 ThrowNullPointerExceptionForFieldAccess(field, kIsRead);
740 return false;
741 }
742 MterpFieldAccess<PrimType, kAccessType>(
743 inst, inst_data, shadow_frame, obj, field->GetOffset(), field->IsVolatile());
744 return true;
745 }
746
747 // This methods is called from assembly to handle field access instructions.
748 //
749 // This method is fairly hot. It is long, but it has been carefully optimized.
750 // It contains only fully inlined methods -> no spills -> no prologue/epilogue.
751 template<typename PrimType, FindFieldType kAccessType>
MterpFieldAccessFast(Instruction * inst,uint16_t inst_data,ShadowFrame * shadow_frame,Thread * self)752 ALWAYS_INLINE bool MterpFieldAccessFast(Instruction* inst,
753 uint16_t inst_data,
754 ShadowFrame* shadow_frame,
755 Thread* self)
756 REQUIRES_SHARED(Locks::mutator_lock_) {
757 constexpr bool kIsStatic = (kAccessType & FindFieldFlags::StaticBit) != 0;
758
759 // Try to find the field in small thread-local cache first.
760 InterpreterCache* tls_cache = self->GetInterpreterCache();
761 size_t tls_value;
762 if (LIKELY(tls_cache->Get(inst, &tls_value))) {
763 // The meaning of the cache value is opcode-specific.
764 // It is ArtFiled* for static fields and the raw offset for instance fields.
765 size_t offset = kIsStatic
766 ? reinterpret_cast<ArtField*>(tls_value)->GetOffset().SizeValue()
767 : tls_value;
768 if (kIsDebugBuild) {
769 uint32_t field_idx = kIsStatic ? inst->VRegB_21c() : inst->VRegC_22c();
770 ArtField* field = FindFieldFromCode<kAccessType, /* access_checks= */ false>(
771 field_idx, shadow_frame->GetMethod(), self, sizeof(PrimType));
772 DCHECK_EQ(offset, field->GetOffset().SizeValue());
773 }
774 ObjPtr<mirror::Object> obj = kIsStatic
775 ? reinterpret_cast<ArtField*>(tls_value)->GetDeclaringClass()
776 : ObjPtr<mirror::Object>(shadow_frame->GetVRegReference(inst->VRegB_22c(inst_data)));
777 if (LIKELY(obj != nullptr)) {
778 MterpFieldAccess<PrimType, kAccessType>(
779 inst, inst_data, shadow_frame, obj, MemberOffset(offset), /* is_volatile= */ false);
780 return true;
781 }
782 }
783
784 // This effectively inlines the fast path from ArtMethod::GetDexCache.
785 ArtMethod* referrer = shadow_frame->GetMethod();
786 if (LIKELY(!referrer->IsObsolete())) {
787 // Avoid read barriers, since we need only the pointer to the native (non-movable)
788 // DexCache field array which we can get even through from-space objects.
789 ObjPtr<mirror::Class> klass = referrer->GetDeclaringClass<kWithoutReadBarrier>();
790 ObjPtr<mirror::DexCache> dex_cache =
791 klass->GetDexCache<kDefaultVerifyFlags, kWithoutReadBarrier>();
792
793 // Try to find the desired field in DexCache.
794 uint32_t field_idx = kIsStatic ? inst->VRegB_21c() : inst->VRegC_22c();
795 ArtField* field = dex_cache->GetResolvedField(field_idx, kRuntimePointerSize);
796 if (LIKELY(field != nullptr)) {
797 bool initialized = !kIsStatic || field->GetDeclaringClass()->IsInitialized();
798 if (LIKELY(initialized)) {
799 DCHECK_EQ(field, (FindFieldFromCode<kAccessType, /* access_checks= */ false>(
800 field_idx, referrer, self, sizeof(PrimType))));
801 ObjPtr<mirror::Object> obj = kIsStatic
802 ? field->GetDeclaringClass().Ptr()
803 : shadow_frame->GetVRegReference(inst->VRegB_22c(inst_data));
804 if (LIKELY(kIsStatic || obj != nullptr)) {
805 // Only non-volatile fields are allowed in the thread-local cache.
806 if (LIKELY(!field->IsVolatile())) {
807 if (kIsStatic) {
808 tls_cache->Set(inst, reinterpret_cast<uintptr_t>(field));
809 } else {
810 tls_cache->Set(inst, field->GetOffset().SizeValue());
811 }
812 }
813 MterpFieldAccess<PrimType, kAccessType>(
814 inst, inst_data, shadow_frame, obj, field->GetOffset(), field->IsVolatile());
815 return true;
816 }
817 }
818 }
819 }
820
821 // Slow path. Last and with identical arguments so that it becomes single instruction tail call.
822 return MterpFieldAccessSlow<PrimType, kAccessType>(inst, inst_data, shadow_frame, self);
823 }
824
825 #define MTERP_FIELD_ACCESSOR(Name, PrimType, AccessType) \
826 extern "C" bool Name(Instruction* inst, uint16_t inst_data, ShadowFrame* sf, Thread* self) \
827 REQUIRES_SHARED(Locks::mutator_lock_) { \
828 return MterpFieldAccessFast<PrimType, AccessType>(inst, inst_data, sf, self); \
829 }
830
831 #define MTERP_FIELD_ACCESSORS_FOR_TYPE(Sufix, PrimType, Kind) \
832 MTERP_FIELD_ACCESSOR(MterpIGet##Sufix, PrimType, Instance##Kind##Read) \
833 MTERP_FIELD_ACCESSOR(MterpIPut##Sufix, PrimType, Instance##Kind##Write) \
834 MTERP_FIELD_ACCESSOR(MterpSGet##Sufix, PrimType, Static##Kind##Read) \
835 MTERP_FIELD_ACCESSOR(MterpSPut##Sufix, PrimType, Static##Kind##Write)
836
837 MTERP_FIELD_ACCESSORS_FOR_TYPE(I8, int8_t, Primitive)
838 MTERP_FIELD_ACCESSORS_FOR_TYPE(U8, uint8_t, Primitive)
839 MTERP_FIELD_ACCESSORS_FOR_TYPE(I16, int16_t, Primitive)
840 MTERP_FIELD_ACCESSORS_FOR_TYPE(U16, uint16_t, Primitive)
841 MTERP_FIELD_ACCESSORS_FOR_TYPE(U32, uint32_t, Primitive)
842 MTERP_FIELD_ACCESSORS_FOR_TYPE(U64, uint64_t, Primitive)
843 MTERP_FIELD_ACCESSORS_FOR_TYPE(Obj, uint32_t, Object)
844
845 // Check that the primitive type for Obj variant above is correct.
846 // It really must be primitive type for the templates to compile.
847 // In the case of objects, it is only used to get the field size.
848 static_assert(kHeapReferenceSize == sizeof(uint32_t), "Unexpected kHeapReferenceSize");
849
850 #undef MTERP_FIELD_ACCESSORS_FOR_TYPE
851 #undef MTERP_FIELD_ACCESSOR
852
artAGetObjectFromMterp(mirror::Object * arr,int32_t index)853 extern "C" mirror::Object* artAGetObjectFromMterp(mirror::Object* arr,
854 int32_t index)
855 REQUIRES_SHARED(Locks::mutator_lock_) {
856 if (UNLIKELY(arr == nullptr)) {
857 ThrowNullPointerExceptionFromInterpreter();
858 return nullptr;
859 }
860 ObjPtr<mirror::ObjectArray<mirror::Object>> array = arr->AsObjectArray<mirror::Object>();
861 if (LIKELY(array->CheckIsValidIndex(index))) {
862 return array->GetWithoutChecks(index).Ptr();
863 } else {
864 return nullptr;
865 }
866 }
867
artIGetObjectFromMterp(mirror::Object * obj,uint32_t field_offset)868 extern "C" mirror::Object* artIGetObjectFromMterp(mirror::Object* obj,
869 uint32_t field_offset)
870 REQUIRES_SHARED(Locks::mutator_lock_) {
871 if (UNLIKELY(obj == nullptr)) {
872 ThrowNullPointerExceptionFromInterpreter();
873 return nullptr;
874 }
875 return obj->GetFieldObject<mirror::Object>(MemberOffset(field_offset));
876 }
877
878 /*
879 * Create a hotness_countdown based on the current method hotness_count and profiling
880 * mode. In short, determine how many hotness events we hit before reporting back
881 * to the full instrumentation via MterpAddHotnessBatch. Called once on entry to the method,
882 * and regenerated following batch updates.
883 */
MterpSetUpHotnessCountdown(ArtMethod * method,ShadowFrame * shadow_frame,Thread * self)884 extern "C" ssize_t MterpSetUpHotnessCountdown(ArtMethod* method,
885 ShadowFrame* shadow_frame,
886 Thread* self)
887 REQUIRES_SHARED(Locks::mutator_lock_) {
888 uint16_t hotness_count = method->GetCounter();
889 int32_t countdown_value = jit::kJitHotnessDisabled;
890 jit::Jit* jit = Runtime::Current()->GetJit();
891 if (jit != nullptr) {
892 int32_t warm_threshold = jit->WarmMethodThreshold();
893 int32_t hot_threshold = jit->HotMethodThreshold();
894 int32_t osr_threshold = jit->OSRMethodThreshold();
895 if (hotness_count < warm_threshold) {
896 countdown_value = warm_threshold - hotness_count;
897 } else if (hotness_count < hot_threshold) {
898 countdown_value = hot_threshold - hotness_count;
899 } else if (hotness_count < osr_threshold) {
900 countdown_value = osr_threshold - hotness_count;
901 } else {
902 countdown_value = jit::kJitCheckForOSR;
903 }
904 if (jit::Jit::ShouldUsePriorityThreadWeight(self)) {
905 int32_t priority_thread_weight = jit->PriorityThreadWeight();
906 countdown_value = std::min(countdown_value, countdown_value / priority_thread_weight);
907 }
908 }
909 /*
910 * The actual hotness threshold may exceed the range of our int16_t countdown value. This is
911 * not a problem, though. We can just break it down into smaller chunks.
912 */
913 countdown_value = std::min(countdown_value,
914 static_cast<int32_t>(std::numeric_limits<int16_t>::max()));
915 shadow_frame->SetCachedHotnessCountdown(countdown_value);
916 shadow_frame->SetHotnessCountdown(countdown_value);
917 return countdown_value;
918 }
919
920 /*
921 * Report a batch of hotness events to the instrumentation and then return the new
922 * countdown value to the next time we should report.
923 */
MterpAddHotnessBatch(ArtMethod * method,ShadowFrame * shadow_frame,Thread * self)924 extern "C" ssize_t MterpAddHotnessBatch(ArtMethod* method,
925 ShadowFrame* shadow_frame,
926 Thread* self)
927 REQUIRES_SHARED(Locks::mutator_lock_) {
928 jit::Jit* jit = Runtime::Current()->GetJit();
929 if (jit != nullptr) {
930 int16_t count = shadow_frame->GetCachedHotnessCountdown() - shadow_frame->GetHotnessCountdown();
931 jit->AddSamples(self, method, count, /*with_backedges=*/ true);
932 }
933 return MterpSetUpHotnessCountdown(method, shadow_frame, self);
934 }
935
MterpMaybeDoOnStackReplacement(Thread * self,ShadowFrame * shadow_frame,int32_t offset)936 extern "C" size_t MterpMaybeDoOnStackReplacement(Thread* self,
937 ShadowFrame* shadow_frame,
938 int32_t offset)
939 REQUIRES_SHARED(Locks::mutator_lock_) {
940 int16_t osr_countdown = shadow_frame->GetCachedHotnessCountdown() - 1;
941 bool did_osr = false;
942 /*
943 * To reduce the cost of polling the compiler to determine whether the requested OSR
944 * compilation has completed, only check every Nth time. NOTE: the "osr_countdown <= 0"
945 * condition is satisfied either by the decrement below or the initial setting of
946 * the cached countdown field to kJitCheckForOSR, which elsewhere is asserted to be -1.
947 */
948 if (osr_countdown <= 0) {
949 ArtMethod* method = shadow_frame->GetMethod();
950 JValue* result = shadow_frame->GetResultRegister();
951 uint32_t dex_pc = shadow_frame->GetDexPC();
952 jit::Jit* jit = Runtime::Current()->GetJit();
953 osr_countdown = jit::Jit::kJitRecheckOSRThreshold;
954 if (offset <= 0) {
955 // Keep updating hotness in case a compilation request was dropped. Eventually it will retry.
956 jit->AddSamples(self, method, osr_countdown, /*with_backedges=*/ true);
957 }
958 did_osr = jit::Jit::MaybeDoOnStackReplacement(self, method, dex_pc, offset, result);
959 }
960 shadow_frame->SetCachedHotnessCountdown(osr_countdown);
961 return did_osr;
962 }
963
964 } // namespace interpreter
965 } // namespace art
966