| /* |
| * Copyright (C) 2012 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #ifndef ART_RUNTIME_INTERPRETER_INTERPRETER_SWITCH_IMPL_INL_H_ |
| #define ART_RUNTIME_INTERPRETER_INTERPRETER_SWITCH_IMPL_INL_H_ |
| |
| #include "interpreter_switch_impl.h" |
| |
| #include "base/enums.h" |
| #include "base/memory_tool.h" |
| #include "base/quasi_atomic.h" |
| #include "dex/dex_file_types.h" |
| #include "dex/dex_instruction_list.h" |
| #include "experimental_flags.h" |
| #include "interpreter_common.h" |
| #include "jit/jit.h" |
| #include "jvalue-inl.h" |
| #include "mirror/string-alloc-inl.h" |
| #include "nth_caller_visitor.h" |
| #include "safe_math.h" |
| #include "shadow_frame-inl.h" |
| #include "thread.h" |
| |
| namespace art { |
| namespace interpreter { |
| |
| // Short-lived helper class which executes single DEX bytecode. It is inlined by compiler. |
| // |
| // The function names must match the names from dex_instruction_list.h and have no arguments. |
| // |
| // Any relevant execution information is stored in the fields - it should be kept to minimum. |
| // |
| // Helper methods may return boolean value - in which case 'false' always means |
| // "stop executing current opcode" (which does not necessarily exit the interpreter loop). |
| // |
| template<bool do_access_check, bool transaction_active> |
| class InstructionHandler { |
| public: |
| ALWAYS_INLINE WARN_UNUSED bool CheckForceReturn() |
| REQUIRES_SHARED(Locks::mutator_lock_) { |
| if (UNLIKELY(shadow_frame.GetForcePopFrame())) { |
| DCHECK(PrevFrameWillRetry(self, shadow_frame)) |
| << "Pop frame forced without previous frame ready to retry instruction!"; |
| DCHECK(Runtime::Current()->AreNonStandardExitsEnabled()); |
| if (UNLIKELY(NeedsMethodExitEvent(instrumentation))) { |
| SendMethodExitEvents(self, |
| instrumentation, |
| shadow_frame, |
| shadow_frame.GetThisObject(Accessor().InsSize()), |
| shadow_frame.GetMethod(), |
| inst->GetDexPc(Insns()), |
| JValue()); |
| } |
| ctx->result = JValue(); /* Handled in caller. */ |
| exit_interpreter_loop = true; |
| return false; |
| } |
| return true; |
| } |
| |
| NO_INLINE WARN_UNUSED bool HandlePendingExceptionWithInstrumentationImpl( |
| const instrumentation::Instrumentation* instr) |
| REQUIRES_SHARED(Locks::mutator_lock_) { |
| DCHECK(self->IsExceptionPending()); |
| self->AllowThreadSuspension(); |
| if (!CheckForceReturn()) { |
| return false; |
| } |
| if (!MoveToExceptionHandler(self, shadow_frame, instr)) { |
| /* Structured locking is to be enforced for abnormal termination, too. */ |
| DoMonitorCheckOnExit<do_assignability_check>(self, &shadow_frame); |
| if (ctx->interpret_one_instruction) { |
| /* Signal mterp to return to caller */ |
| shadow_frame.SetDexPC(dex::kDexNoIndex); |
| } |
| ctx->result = JValue(); /* Handled in caller. */ |
| exit_interpreter_loop = true; |
| return false; // Return to caller. |
| } |
| if (!CheckForceReturn()) { |
| return false; |
| } |
| int32_t displacement = |
| static_cast<int32_t>(shadow_frame.GetDexPC()) - static_cast<int32_t>(dex_pc); |
| inst = inst->RelativeAt(displacement); |
| return false; // Stop executing this opcode and continue in the exception handler. |
| } |
| |
| // Forwards the call to the NO_INLINE HandlePendingExceptionWithInstrumentationImpl. |
| ALWAYS_INLINE WARN_UNUSED bool HandlePendingExceptionWithInstrumentation( |
| const instrumentation::Instrumentation* instr) |
| REQUIRES_SHARED(Locks::mutator_lock_) { |
| // We need to help the compiler a bit to make the NO_INLINE call efficient. |
| // * All handler fields should be in registers, so we do not want to take the object |
| // address (for 'this' argument). Make a copy of the handler just for the slow path. |
| // * The modifiable fields should also be in registers, so we don't want to store their |
| // address even in the handler copy. Make a copy of them just for the call as well. |
| const Instruction* inst_copy = inst; |
| bool exit_loop_copy = exit_interpreter_loop; |
| InstructionHandler<do_access_check, transaction_active> handler_copy( |
| ctx, instrumentation, self, shadow_frame, dex_pc, inst_copy, inst_data, exit_loop_copy); |
| bool result = handler_copy.HandlePendingExceptionWithInstrumentationImpl(instr); |
| inst = inst_copy; |
| exit_interpreter_loop = exit_loop_copy; |
| return result; |
| } |
| |
| ALWAYS_INLINE WARN_UNUSED bool HandlePendingException() |
| REQUIRES_SHARED(Locks::mutator_lock_) { |
| return HandlePendingExceptionWithInstrumentation(instrumentation); |
| } |
| |
| ALWAYS_INLINE WARN_UNUSED bool PossiblyHandlePendingExceptionOnInvokeImpl( |
| bool is_exception_pending, |
| const Instruction* next_inst) |
| REQUIRES_SHARED(Locks::mutator_lock_) { |
| if (UNLIKELY(shadow_frame.GetForceRetryInstruction())) { |
| /* Don't need to do anything except clear the flag and exception. We leave the */ |
| /* instruction the same so it will be re-executed on the next go-around. */ |
| DCHECK(inst->IsInvoke()); |
| shadow_frame.SetForceRetryInstruction(false); |
| if (UNLIKELY(is_exception_pending)) { |
| DCHECK(self->IsExceptionPending()); |
| if (kIsDebugBuild) { |
| LOG(WARNING) << "Suppressing exception for instruction-retry: " |
| << self->GetException()->Dump(); |
| } |
| self->ClearException(); |
| } |
| } else if (UNLIKELY(is_exception_pending)) { |
| /* Should have succeeded. */ |
| DCHECK(!shadow_frame.GetForceRetryInstruction()); |
| if (!HandlePendingException()) { |
| return false; |
| } |
| } else { |
| inst = next_inst; |
| } |
| return true; |
| } |
| |
| ALWAYS_INLINE WARN_UNUSED bool PossiblyHandlePendingException( |
| bool is_exception_pending, |
| const Instruction* next_inst) |
| REQUIRES_SHARED(Locks::mutator_lock_) { |
| /* Should only be on invoke instructions. */ |
| DCHECK(!shadow_frame.GetForceRetryInstruction()); |
| if (UNLIKELY(is_exception_pending)) { |
| if (!HandlePendingException()) { |
| return false; |
| } |
| } else { |
| inst = next_inst; |
| } |
| return true; |
| } |
| |
| ALWAYS_INLINE WARN_UNUSED bool HandleMonitorChecks() |
| REQUIRES_SHARED(Locks::mutator_lock_) { |
| if (!DoMonitorCheckOnExit<do_assignability_check>(self, &shadow_frame)) { |
| if (!HandlePendingException()) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| // Code to run before each dex instruction. |
| ALWAYS_INLINE WARN_UNUSED bool Preamble() |
| REQUIRES_SHARED(Locks::mutator_lock_) { |
| /* We need to put this before & after the instrumentation to avoid having to put in a */ |
| /* post-script macro. */ |
| if (!CheckForceReturn()) { |
| return false; |
| } |
| if (UNLIKELY(instrumentation->HasDexPcListeners())) { |
| uint8_t opcode = inst->Opcode(inst_data); |
| bool is_move_result_object = (opcode == Instruction::MOVE_RESULT_OBJECT); |
| JValue* save_ref = is_move_result_object ? &ctx->result_register : nullptr; |
| if (UNLIKELY(!DoDexPcMoveEvent(self, |
| Accessor(), |
| shadow_frame, |
| dex_pc, |
| instrumentation, |
| save_ref))) { |
| if (!HandlePendingException()) { |
| return false; |
| } |
| } |
| if (!CheckForceReturn()) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| ALWAYS_INLINE WARN_UNUSED bool BranchInstrumentation(int32_t offset) |
| REQUIRES_SHARED(Locks::mutator_lock_) { |
| if (UNLIKELY(instrumentation->HasBranchListeners())) { |
| instrumentation->Branch(self, shadow_frame.GetMethod(), dex_pc, offset); |
| } |
| JValue result; |
| if (jit::Jit::MaybeDoOnStackReplacement(self, |
| shadow_frame.GetMethod(), |
| dex_pc, |
| offset, |
| &result)) { |
| if (ctx->interpret_one_instruction) { |
| /* OSR has completed execution of the method. Signal mterp to return to caller */ |
| shadow_frame.SetDexPC(dex::kDexNoIndex); |
| } |
| ctx->result = result; |
| exit_interpreter_loop = true; |
| return false; |
| } |
| return true; |
| } |
| |
| ALWAYS_INLINE void HotnessUpdate() |
| REQUIRES_SHARED(Locks::mutator_lock_) { |
| jit::Jit* jit = Runtime::Current()->GetJit(); |
| if (jit != nullptr) { |
| jit->AddSamples(self, shadow_frame.GetMethod(), 1, /*with_backedges=*/ true); |
| } |
| } |
| |
| ALWAYS_INLINE WARN_UNUSED bool HandleAsyncException() |
| REQUIRES_SHARED(Locks::mutator_lock_) { |
| if (UNLIKELY(self->ObserveAsyncException())) { |
| if (!HandlePendingException()) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| ALWAYS_INLINE void HandleBackwardBranch(int32_t offset) |
| REQUIRES_SHARED(Locks::mutator_lock_) { |
| if (IsBackwardBranch(offset)) { |
| HotnessUpdate(); |
| /* Record new dex pc early to have consistent suspend point at loop header. */ |
| shadow_frame.SetDexPC(inst->GetDexPc(Insns())); |
| self->AllowThreadSuspension(); |
| } |
| } |
| |
| // Unlike most other events the DexPcMovedEvent can be sent when there is a pending exception (if |
| // the next instruction is MOVE_EXCEPTION). This means it needs to be handled carefully to be able |
| // to detect exceptions thrown by the DexPcMovedEvent itself. These exceptions could be thrown by |
| // jvmti-agents while handling breakpoint or single step events. We had to move this into its own |
| // function because it was making ExecuteSwitchImpl have too large a stack. |
| NO_INLINE static bool DoDexPcMoveEvent(Thread* self, |
| const CodeItemDataAccessor& accessor, |
| const ShadowFrame& shadow_frame, |
| uint32_t dex_pc, |
| const instrumentation::Instrumentation* instrumentation, |
| JValue* save_ref) |
| REQUIRES_SHARED(Locks::mutator_lock_) { |
| DCHECK(instrumentation->HasDexPcListeners()); |
| StackHandleScope<2> hs(self); |
| Handle<mirror::Throwable> thr(hs.NewHandle(self->GetException())); |
| mirror::Object* null_obj = nullptr; |
| HandleWrapper<mirror::Object> h( |
| hs.NewHandleWrapper(LIKELY(save_ref == nullptr) ? &null_obj : save_ref->GetGCRoot())); |
| self->ClearException(); |
| instrumentation->DexPcMovedEvent(self, |
| shadow_frame.GetThisObject(accessor.InsSize()), |
| shadow_frame.GetMethod(), |
| dex_pc); |
| if (UNLIKELY(self->IsExceptionPending())) { |
| // We got a new exception in the dex-pc-moved event. |
| // We just let this exception replace the old one. |
| // TODO It would be good to add the old exception to the |
| // suppressed exceptions of the new one if possible. |
| return false; |
| } else { |
| if (UNLIKELY(!thr.IsNull())) { |
| self->SetException(thr.Get()); |
| } |
| return true; |
| } |
| } |
| |
| static bool NeedsMethodExitEvent(const instrumentation::Instrumentation* ins) |
| REQUIRES_SHARED(Locks::mutator_lock_) { |
| return ins->HasMethodExitListeners() || ins->HasWatchedFramePopListeners(); |
| } |
| |
| // Sends the normal method exit event. |
| // Returns true if the events succeeded and false if there is a pending exception. |
| NO_INLINE static bool SendMethodExitEvents( |
| Thread* self, |
| const instrumentation::Instrumentation* instrumentation, |
| const ShadowFrame& frame, |
| ObjPtr<mirror::Object> thiz, |
| ArtMethod* method, |
| uint32_t dex_pc, |
| const JValue& result) |
| REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool had_event = false; |
| // We don't send method-exit if it's a pop-frame. We still send frame_popped though. |
| if (UNLIKELY(instrumentation->HasMethodExitListeners() && !frame.GetForcePopFrame())) { |
| had_event = true; |
| instrumentation->MethodExitEvent(self, thiz.Ptr(), method, dex_pc, result); |
| } |
| if (UNLIKELY(frame.NeedsNotifyPop() && instrumentation->HasWatchedFramePopListeners())) { |
| had_event = true; |
| instrumentation->WatchedFramePopped(self, frame); |
| } |
| if (UNLIKELY(had_event)) { |
| return !self->IsExceptionPending(); |
| } else { |
| return true; |
| } |
| } |
| |
| #define BRANCH_INSTRUMENTATION(offset) \ |
| if (!BranchInstrumentation(offset)) { \ |
| return; \ |
| } |
| |
| #define HANDLE_PENDING_EXCEPTION() \ |
| if (!HandlePendingException()) { \ |
| return; \ |
| } |
| |
| #define POSSIBLY_HANDLE_PENDING_EXCEPTION(is_exception_pending, next_function) \ |
| if (!PossiblyHandlePendingException(is_exception_pending, inst->next_function())) { \ |
| return; \ |
| } |
| |
| #define POSSIBLY_HANDLE_PENDING_EXCEPTION_ON_INVOKE_POLYMORPHIC(is_exception_pending) \ |
| if (!PossiblyHandlePendingExceptionOnInvokeImpl(is_exception_pending, inst->Next_4xx())) { \ |
| return; \ |
| } |
| |
| #define POSSIBLY_HANDLE_PENDING_EXCEPTION_ON_INVOKE(is_exception_pending) \ |
| if (!PossiblyHandlePendingExceptionOnInvokeImpl(is_exception_pending, inst->Next_3xx())) { \ |
| return; \ |
| } |
| |
| ALWAYS_INLINE void NOP() REQUIRES_SHARED(Locks::mutator_lock_) { |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void MOVE() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVReg(inst->VRegA_12x(inst_data), |
| shadow_frame.GetVReg(inst->VRegB_12x(inst_data))); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void MOVE_FROM16() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVReg(inst->VRegA_22x(inst_data), |
| shadow_frame.GetVReg(inst->VRegB_22x())); |
| inst = inst->Next_2xx(); |
| } |
| |
| ALWAYS_INLINE void MOVE_16() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVReg(inst->VRegA_32x(), |
| shadow_frame.GetVReg(inst->VRegB_32x())); |
| inst = inst->Next_3xx(); |
| } |
| |
| ALWAYS_INLINE void MOVE_WIDE() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVRegLong(inst->VRegA_12x(inst_data), |
| shadow_frame.GetVRegLong(inst->VRegB_12x(inst_data))); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void MOVE_WIDE_FROM16() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVRegLong(inst->VRegA_22x(inst_data), |
| shadow_frame.GetVRegLong(inst->VRegB_22x())); |
| inst = inst->Next_2xx(); |
| } |
| |
| ALWAYS_INLINE void MOVE_WIDE_16() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVRegLong(inst->VRegA_32x(), |
| shadow_frame.GetVRegLong(inst->VRegB_32x())); |
| inst = inst->Next_3xx(); |
| } |
| |
| ALWAYS_INLINE void MOVE_OBJECT() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVRegReference(inst->VRegA_12x(inst_data), |
| shadow_frame.GetVRegReference(inst->VRegB_12x(inst_data))); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void MOVE_OBJECT_FROM16() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVRegReference(inst->VRegA_22x(inst_data), |
| shadow_frame.GetVRegReference(inst->VRegB_22x())); |
| inst = inst->Next_2xx(); |
| } |
| |
| ALWAYS_INLINE void MOVE_OBJECT_16() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVRegReference(inst->VRegA_32x(), |
| shadow_frame.GetVRegReference(inst->VRegB_32x())); |
| inst = inst->Next_3xx(); |
| } |
| |
| ALWAYS_INLINE void MOVE_RESULT() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVReg(inst->VRegA_11x(inst_data), ResultRegister()->GetI()); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void MOVE_RESULT_WIDE() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVRegLong(inst->VRegA_11x(inst_data), ResultRegister()->GetJ()); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void MOVE_RESULT_OBJECT() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVRegReference(inst->VRegA_11x(inst_data), ResultRegister()->GetL()); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void MOVE_EXCEPTION() REQUIRES_SHARED(Locks::mutator_lock_) { |
| ObjPtr<mirror::Throwable> exception = self->GetException(); |
| DCHECK(exception != nullptr) << "No pending exception on MOVE_EXCEPTION instruction"; |
| shadow_frame.SetVRegReference(inst->VRegA_11x(inst_data), exception); |
| self->ClearException(); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void RETURN_VOID_NO_BARRIER() REQUIRES_SHARED(Locks::mutator_lock_) { |
| JValue result; |
| self->AllowThreadSuspension(); |
| if (!HandleMonitorChecks()) { |
| return; |
| } |
| if (UNLIKELY(NeedsMethodExitEvent(instrumentation) && |
| !SendMethodExitEvents(self, |
| instrumentation, |
| shadow_frame, |
| shadow_frame.GetThisObject(Accessor().InsSize()), |
| shadow_frame.GetMethod(), |
| inst->GetDexPc(Insns()), |
| result))) { |
| if (!HandlePendingExceptionWithInstrumentation(nullptr)) { |
| return; |
| } |
| } |
| if (ctx->interpret_one_instruction) { |
| /* Signal mterp to return to caller */ |
| shadow_frame.SetDexPC(dex::kDexNoIndex); |
| } |
| ctx->result = result; |
| exit_interpreter_loop = true; |
| } |
| |
| ALWAYS_INLINE void RETURN_VOID() REQUIRES_SHARED(Locks::mutator_lock_) { |
| QuasiAtomic::ThreadFenceForConstructor(); |
| JValue result; |
| self->AllowThreadSuspension(); |
| if (!HandleMonitorChecks()) { |
| return; |
| } |
| if (UNLIKELY(NeedsMethodExitEvent(instrumentation) && |
| !SendMethodExitEvents(self, |
| instrumentation, |
| shadow_frame, |
| shadow_frame.GetThisObject(Accessor().InsSize()), |
| shadow_frame.GetMethod(), |
| inst->GetDexPc(Insns()), |
| result))) { |
| if (!HandlePendingExceptionWithInstrumentation(nullptr)) { |
| return; |
| } |
| } |
| if (ctx->interpret_one_instruction) { |
| /* Signal mterp to return to caller */ |
| shadow_frame.SetDexPC(dex::kDexNoIndex); |
| } |
| ctx->result = result; |
| exit_interpreter_loop = true; |
| } |
| |
| ALWAYS_INLINE void RETURN() REQUIRES_SHARED(Locks::mutator_lock_) { |
| JValue result; |
| result.SetJ(0); |
| result.SetI(shadow_frame.GetVReg(inst->VRegA_11x(inst_data))); |
| self->AllowThreadSuspension(); |
| if (!HandleMonitorChecks()) { |
| return; |
| } |
| if (UNLIKELY(NeedsMethodExitEvent(instrumentation) && |
| !SendMethodExitEvents(self, |
| instrumentation, |
| shadow_frame, |
| shadow_frame.GetThisObject(Accessor().InsSize()), |
| shadow_frame.GetMethod(), |
| inst->GetDexPc(Insns()), |
| result))) { |
| if (!HandlePendingExceptionWithInstrumentation(nullptr)) { |
| return; |
| } |
| } |
| if (ctx->interpret_one_instruction) { |
| /* Signal mterp to return to caller */ |
| shadow_frame.SetDexPC(dex::kDexNoIndex); |
| } |
| ctx->result = result; |
| exit_interpreter_loop = true; |
| } |
| |
| ALWAYS_INLINE void RETURN_WIDE() REQUIRES_SHARED(Locks::mutator_lock_) { |
| JValue result; |
| result.SetJ(shadow_frame.GetVRegLong(inst->VRegA_11x(inst_data))); |
| self->AllowThreadSuspension(); |
| if (!HandleMonitorChecks()) { |
| return; |
| } |
| if (UNLIKELY(NeedsMethodExitEvent(instrumentation) && |
| !SendMethodExitEvents(self, |
| instrumentation, |
| shadow_frame, |
| shadow_frame.GetThisObject(Accessor().InsSize()), |
| shadow_frame.GetMethod(), |
| inst->GetDexPc(Insns()), |
| result))) { |
| if (!HandlePendingExceptionWithInstrumentation(nullptr)) { |
| return; |
| } |
| } |
| if (ctx->interpret_one_instruction) { |
| /* Signal mterp to return to caller */ |
| shadow_frame.SetDexPC(dex::kDexNoIndex); |
| } |
| ctx->result = result; |
| exit_interpreter_loop = true; |
| } |
| |
| ALWAYS_INLINE void RETURN_OBJECT() REQUIRES_SHARED(Locks::mutator_lock_) { |
| JValue result; |
| self->AllowThreadSuspension(); |
| if (!HandleMonitorChecks()) { |
| return; |
| } |
| const size_t ref_idx = inst->VRegA_11x(inst_data); |
| ObjPtr<mirror::Object> obj_result = shadow_frame.GetVRegReference(ref_idx); |
| if (do_assignability_check && obj_result != nullptr) { |
| ObjPtr<mirror::Class> return_type = shadow_frame.GetMethod()->ResolveReturnType(); |
| // Re-load since it might have moved. |
| obj_result = shadow_frame.GetVRegReference(ref_idx); |
| if (return_type == nullptr) { |
| // Return the pending exception. |
| HANDLE_PENDING_EXCEPTION(); |
| } |
| if (!obj_result->VerifierInstanceOf(return_type)) { |
| // This should never happen. |
| std::string temp1, temp2; |
| self->ThrowNewExceptionF("Ljava/lang/InternalError;", |
| "Returning '%s' that is not instance of return type '%s'", |
| obj_result->GetClass()->GetDescriptor(&temp1), |
| return_type->GetDescriptor(&temp2)); |
| HANDLE_PENDING_EXCEPTION(); |
| } |
| } |
| result.SetL(obj_result); |
| if (UNLIKELY(NeedsMethodExitEvent(instrumentation) && |
| !SendMethodExitEvents(self, |
| instrumentation, |
| shadow_frame, |
| shadow_frame.GetThisObject(Accessor().InsSize()), |
| shadow_frame.GetMethod(), |
| inst->GetDexPc(Insns()), |
| result))) { |
| if (!HandlePendingExceptionWithInstrumentation(nullptr)) { |
| return; |
| } |
| } |
| // Re-load since it might have moved during the MethodExitEvent. |
| result.SetL(shadow_frame.GetVRegReference(ref_idx)); |
| if (ctx->interpret_one_instruction) { |
| /* Signal mterp to return to caller */ |
| shadow_frame.SetDexPC(dex::kDexNoIndex); |
| } |
| ctx->result = result; |
| exit_interpreter_loop = true; |
| } |
| |
| ALWAYS_INLINE void CONST_4() REQUIRES_SHARED(Locks::mutator_lock_) { |
| uint4_t dst = inst->VRegA_11n(inst_data); |
| int4_t val = inst->VRegB_11n(inst_data); |
| shadow_frame.SetVReg(dst, val); |
| if (val == 0) { |
| shadow_frame.SetVRegReference(dst, nullptr); |
| } |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void CONST_16() REQUIRES_SHARED(Locks::mutator_lock_) { |
| uint8_t dst = inst->VRegA_21s(inst_data); |
| int16_t val = inst->VRegB_21s(); |
| shadow_frame.SetVReg(dst, val); |
| if (val == 0) { |
| shadow_frame.SetVRegReference(dst, nullptr); |
| } |
| inst = inst->Next_2xx(); |
| } |
| |
| ALWAYS_INLINE void CONST() REQUIRES_SHARED(Locks::mutator_lock_) { |
| uint8_t dst = inst->VRegA_31i(inst_data); |
| int32_t val = inst->VRegB_31i(); |
| shadow_frame.SetVReg(dst, val); |
| if (val == 0) { |
| shadow_frame.SetVRegReference(dst, nullptr); |
| } |
| inst = inst->Next_3xx(); |
| } |
| |
| ALWAYS_INLINE void CONST_HIGH16() REQUIRES_SHARED(Locks::mutator_lock_) { |
| uint8_t dst = inst->VRegA_21h(inst_data); |
| int32_t val = static_cast<int32_t>(inst->VRegB_21h() << 16); |
| shadow_frame.SetVReg(dst, val); |
| if (val == 0) { |
| shadow_frame.SetVRegReference(dst, nullptr); |
| } |
| inst = inst->Next_2xx(); |
| } |
| |
| ALWAYS_INLINE void CONST_WIDE_16() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVRegLong(inst->VRegA_21s(inst_data), inst->VRegB_21s()); |
| inst = inst->Next_2xx(); |
| } |
| |
| ALWAYS_INLINE void CONST_WIDE_32() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVRegLong(inst->VRegA_31i(inst_data), inst->VRegB_31i()); |
| inst = inst->Next_3xx(); |
| } |
| |
| ALWAYS_INLINE void CONST_WIDE() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVRegLong(inst->VRegA_51l(inst_data), inst->VRegB_51l()); |
| inst = inst->Next_51l(); |
| } |
| |
| ALWAYS_INLINE void CONST_WIDE_HIGH16() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVRegLong(inst->VRegA_21h(inst_data), |
| static_cast<uint64_t>(inst->VRegB_21h()) << 48); |
| inst = inst->Next_2xx(); |
| } |
| |
| ALWAYS_INLINE void CONST_STRING() REQUIRES_SHARED(Locks::mutator_lock_) { |
| ObjPtr<mirror::String> s = ResolveString(self, |
| shadow_frame, |
| dex::StringIndex(inst->VRegB_21c())); |
| if (UNLIKELY(s == nullptr)) { |
| HANDLE_PENDING_EXCEPTION(); |
| } else { |
| shadow_frame.SetVRegReference(inst->VRegA_21c(inst_data), s); |
| inst = inst->Next_2xx(); |
| } |
| } |
| |
| ALWAYS_INLINE void CONST_STRING_JUMBO() REQUIRES_SHARED(Locks::mutator_lock_) { |
| ObjPtr<mirror::String> s = ResolveString(self, |
| shadow_frame, |
| dex::StringIndex(inst->VRegB_31c())); |
| if (UNLIKELY(s == nullptr)) { |
| HANDLE_PENDING_EXCEPTION(); |
| } else { |
| shadow_frame.SetVRegReference(inst->VRegA_31c(inst_data), s); |
| inst = inst->Next_3xx(); |
| } |
| } |
| |
| ALWAYS_INLINE void CONST_CLASS() REQUIRES_SHARED(Locks::mutator_lock_) { |
| ObjPtr<mirror::Class> c = ResolveVerifyAndClinit(dex::TypeIndex(inst->VRegB_21c()), |
| shadow_frame.GetMethod(), |
| self, |
| false, |
| do_access_check); |
| if (UNLIKELY(c == nullptr)) { |
| HANDLE_PENDING_EXCEPTION(); |
| } else { |
| shadow_frame.SetVRegReference(inst->VRegA_21c(inst_data), c); |
| inst = inst->Next_2xx(); |
| } |
| } |
| |
| ALWAYS_INLINE void CONST_METHOD_HANDLE() REQUIRES_SHARED(Locks::mutator_lock_) { |
| ClassLinker* cl = Runtime::Current()->GetClassLinker(); |
| ObjPtr<mirror::MethodHandle> mh = cl->ResolveMethodHandle(self, |
| inst->VRegB_21c(), |
| shadow_frame.GetMethod()); |
| if (UNLIKELY(mh == nullptr)) { |
| HANDLE_PENDING_EXCEPTION(); |
| } else { |
| shadow_frame.SetVRegReference(inst->VRegA_21c(inst_data), mh); |
| inst = inst->Next_2xx(); |
| } |
| } |
| |
| ALWAYS_INLINE void CONST_METHOD_TYPE() REQUIRES_SHARED(Locks::mutator_lock_) { |
| ClassLinker* cl = Runtime::Current()->GetClassLinker(); |
| ObjPtr<mirror::MethodType> mt = cl->ResolveMethodType(self, |
| dex::ProtoIndex(inst->VRegB_21c()), |
| shadow_frame.GetMethod()); |
| if (UNLIKELY(mt == nullptr)) { |
| HANDLE_PENDING_EXCEPTION(); |
| } else { |
| shadow_frame.SetVRegReference(inst->VRegA_21c(inst_data), mt); |
| inst = inst->Next_2xx(); |
| } |
| } |
| |
| ALWAYS_INLINE void MONITOR_ENTER() REQUIRES_SHARED(Locks::mutator_lock_) { |
| if (!HandleAsyncException()) { |
| return; |
| } |
| ObjPtr<mirror::Object> obj = shadow_frame.GetVRegReference(inst->VRegA_11x(inst_data)); |
| if (UNLIKELY(obj == nullptr)) { |
| ThrowNullPointerExceptionFromInterpreter(); |
| HANDLE_PENDING_EXCEPTION(); |
| } else { |
| DoMonitorEnter<do_assignability_check>(self, &shadow_frame, obj); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(self->IsExceptionPending(), Next_1xx); |
| } |
| } |
| |
| ALWAYS_INLINE void MONITOR_EXIT() REQUIRES_SHARED(Locks::mutator_lock_) { |
| if (!HandleAsyncException()) { |
| return; |
| } |
| ObjPtr<mirror::Object> obj = shadow_frame.GetVRegReference(inst->VRegA_11x(inst_data)); |
| if (UNLIKELY(obj == nullptr)) { |
| ThrowNullPointerExceptionFromInterpreter(); |
| HANDLE_PENDING_EXCEPTION(); |
| } else { |
| DoMonitorExit<do_assignability_check>(self, &shadow_frame, obj); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(self->IsExceptionPending(), Next_1xx); |
| } |
| } |
| |
| ALWAYS_INLINE void CHECK_CAST() REQUIRES_SHARED(Locks::mutator_lock_) { |
| ObjPtr<mirror::Class> c = ResolveVerifyAndClinit(dex::TypeIndex(inst->VRegB_21c()), |
| shadow_frame.GetMethod(), |
| self, |
| false, |
| do_access_check); |
| if (UNLIKELY(c == nullptr)) { |
| HANDLE_PENDING_EXCEPTION(); |
| } else { |
| ObjPtr<mirror::Object> obj = shadow_frame.GetVRegReference(inst->VRegA_21c(inst_data)); |
| if (UNLIKELY(obj != nullptr && !obj->InstanceOf(c))) { |
| ThrowClassCastException(c, obj->GetClass()); |
| HANDLE_PENDING_EXCEPTION(); |
| } else { |
| inst = inst->Next_2xx(); |
| } |
| } |
| } |
| |
| ALWAYS_INLINE void INSTANCE_OF() REQUIRES_SHARED(Locks::mutator_lock_) { |
| ObjPtr<mirror::Class> c = ResolveVerifyAndClinit(dex::TypeIndex(inst->VRegC_22c()), |
| shadow_frame.GetMethod(), |
| self, |
| false, |
| do_access_check); |
| if (UNLIKELY(c == nullptr)) { |
| HANDLE_PENDING_EXCEPTION(); |
| } else { |
| ObjPtr<mirror::Object> obj = shadow_frame.GetVRegReference(inst->VRegB_22c(inst_data)); |
| shadow_frame.SetVReg(inst->VRegA_22c(inst_data), |
| (obj != nullptr && obj->InstanceOf(c)) ? 1 : 0); |
| inst = inst->Next_2xx(); |
| } |
| } |
| |
| ALWAYS_INLINE void ARRAY_LENGTH() REQUIRES_SHARED(Locks::mutator_lock_) { |
| ObjPtr<mirror::Object> array = shadow_frame.GetVRegReference(inst->VRegB_12x(inst_data)); |
| if (UNLIKELY(array == nullptr)) { |
| ThrowNullPointerExceptionFromInterpreter(); |
| HANDLE_PENDING_EXCEPTION(); |
| } else { |
| shadow_frame.SetVReg(inst->VRegA_12x(inst_data), array->AsArray()->GetLength()); |
| inst = inst->Next_1xx(); |
| } |
| } |
| |
| ALWAYS_INLINE void NEW_INSTANCE() REQUIRES_SHARED(Locks::mutator_lock_) { |
| ObjPtr<mirror::Object> obj = nullptr; |
| ObjPtr<mirror::Class> c = ResolveVerifyAndClinit(dex::TypeIndex(inst->VRegB_21c()), |
| shadow_frame.GetMethod(), |
| self, |
| false, |
| do_access_check); |
| if (LIKELY(c != nullptr)) { |
| if (UNLIKELY(c->IsStringClass())) { |
| gc::AllocatorType allocator_type = Runtime::Current()->GetHeap()->GetCurrentAllocator(); |
| obj = mirror::String::AllocEmptyString<true>(self, allocator_type); |
| } else { |
| obj = AllocObjectFromCode<true>( |
| c.Ptr(), |
| self, |
| Runtime::Current()->GetHeap()->GetCurrentAllocator()); |
| } |
| } |
| if (UNLIKELY(obj == nullptr)) { |
| HANDLE_PENDING_EXCEPTION(); |
| } else { |
| obj->GetClass()->AssertInitializedOrInitializingInThread(self); |
| // Don't allow finalizable objects to be allocated during a transaction since these can't |
| // be finalized without a started runtime. |
| if (transaction_active && obj->GetClass()->IsFinalizable()) { |
| AbortTransactionF(self, "Allocating finalizable object in transaction: %s", |
| obj->PrettyTypeOf().c_str()); |
| HANDLE_PENDING_EXCEPTION(); |
| } |
| shadow_frame.SetVRegReference(inst->VRegA_21c(inst_data), obj); |
| inst = inst->Next_2xx(); |
| } |
| } |
| |
| ALWAYS_INLINE void NEW_ARRAY() REQUIRES_SHARED(Locks::mutator_lock_) { |
| int32_t length = shadow_frame.GetVReg(inst->VRegB_22c(inst_data)); |
| ObjPtr<mirror::Object> obj = AllocArrayFromCode<do_access_check, true>( |
| dex::TypeIndex(inst->VRegC_22c()), |
| length, |
| shadow_frame.GetMethod(), |
| self, |
| Runtime::Current()->GetHeap()->GetCurrentAllocator()); |
| if (UNLIKELY(obj == nullptr)) { |
| HANDLE_PENDING_EXCEPTION(); |
| } else { |
| shadow_frame.SetVRegReference(inst->VRegA_22c(inst_data), obj); |
| inst = inst->Next_2xx(); |
| } |
| } |
| |
| ALWAYS_INLINE void FILLED_NEW_ARRAY() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = |
| DoFilledNewArray<false, do_access_check, transaction_active>(inst, shadow_frame, self, |
| ResultRegister()); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_3xx); |
| } |
| |
| ALWAYS_INLINE void FILLED_NEW_ARRAY_RANGE() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = |
| DoFilledNewArray<true, do_access_check, transaction_active>(inst, shadow_frame, |
| self, ResultRegister()); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_3xx); |
| } |
| |
| ALWAYS_INLINE void FILL_ARRAY_DATA() REQUIRES_SHARED(Locks::mutator_lock_) { |
| const uint16_t* payload_addr = reinterpret_cast<const uint16_t*>(inst) + inst->VRegB_31t(); |
| const Instruction::ArrayDataPayload* payload = |
| reinterpret_cast<const Instruction::ArrayDataPayload*>(payload_addr); |
| ObjPtr<mirror::Object> obj = shadow_frame.GetVRegReference(inst->VRegA_31t(inst_data)); |
| bool success = FillArrayData(obj, payload); |
| if (!success) { |
| HANDLE_PENDING_EXCEPTION(); |
| } |
| if (transaction_active) { |
| RecordArrayElementsInTransaction(obj->AsArray(), payload->element_count); |
| } |
| inst = inst->Next_3xx(); |
| } |
| |
| ALWAYS_INLINE void THROW() REQUIRES_SHARED(Locks::mutator_lock_) { |
| if (!HandleAsyncException()) { |
| return; |
| } |
| ObjPtr<mirror::Object> exception = |
| shadow_frame.GetVRegReference(inst->VRegA_11x(inst_data)); |
| if (UNLIKELY(exception == nullptr)) { |
| ThrowNullPointerException("throw with null exception"); |
| } else if (do_assignability_check && !exception->GetClass()->IsThrowableClass()) { |
| // This should never happen. |
| std::string temp; |
| self->ThrowNewExceptionF("Ljava/lang/InternalError;", |
| "Throwing '%s' that is not instance of Throwable", |
| exception->GetClass()->GetDescriptor(&temp)); |
| } else { |
| self->SetException(exception->AsThrowable()); |
| } |
| HANDLE_PENDING_EXCEPTION(); |
| } |
| |
| ALWAYS_INLINE void GOTO() REQUIRES_SHARED(Locks::mutator_lock_) { |
| if (!HandleAsyncException()) { |
| return; |
| } |
| int8_t offset = inst->VRegA_10t(inst_data); |
| BRANCH_INSTRUMENTATION(offset); |
| inst = inst->RelativeAt(offset); |
| HandleBackwardBranch(offset); |
| } |
| |
| ALWAYS_INLINE void GOTO_16() REQUIRES_SHARED(Locks::mutator_lock_) { |
| if (!HandleAsyncException()) { |
| return; |
| } |
| int16_t offset = inst->VRegA_20t(); |
| BRANCH_INSTRUMENTATION(offset); |
| inst = inst->RelativeAt(offset); |
| HandleBackwardBranch(offset); |
| } |
| |
| ALWAYS_INLINE void GOTO_32() REQUIRES_SHARED(Locks::mutator_lock_) { |
| if (!HandleAsyncException()) { |
| return; |
| } |
| int32_t offset = inst->VRegA_30t(); |
| BRANCH_INSTRUMENTATION(offset); |
| inst = inst->RelativeAt(offset); |
| HandleBackwardBranch(offset); |
| } |
| |
| ALWAYS_INLINE void PACKED_SWITCH() REQUIRES_SHARED(Locks::mutator_lock_) { |
| int32_t offset = DoPackedSwitch(inst, shadow_frame, inst_data); |
| BRANCH_INSTRUMENTATION(offset); |
| inst = inst->RelativeAt(offset); |
| HandleBackwardBranch(offset); |
| } |
| |
| ALWAYS_INLINE void SPARSE_SWITCH() REQUIRES_SHARED(Locks::mutator_lock_) { |
| int32_t offset = DoSparseSwitch(inst, shadow_frame, inst_data); |
| BRANCH_INSTRUMENTATION(offset); |
| inst = inst->RelativeAt(offset); |
| HandleBackwardBranch(offset); |
| } |
| |
| #pragma clang diagnostic push |
| #pragma clang diagnostic ignored "-Wfloat-equal" |
| |
| |
| ALWAYS_INLINE void CMPL_FLOAT() REQUIRES_SHARED(Locks::mutator_lock_) { |
| float val1 = shadow_frame.GetVRegFloat(inst->VRegB_23x()); |
| float val2 = shadow_frame.GetVRegFloat(inst->VRegC_23x()); |
| int32_t result; |
| if (val1 > val2) { |
| result = 1; |
| } else if (val1 == val2) { |
| result = 0; |
| } else { |
| result = -1; |
| } |
| shadow_frame.SetVReg(inst->VRegA_23x(inst_data), result); |
| inst = inst->Next_2xx(); |
| } |
| |
| ALWAYS_INLINE void CMPG_FLOAT() REQUIRES_SHARED(Locks::mutator_lock_) { |
| float val1 = shadow_frame.GetVRegFloat(inst->VRegB_23x()); |
| float val2 = shadow_frame.GetVRegFloat(inst->VRegC_23x()); |
| int32_t result; |
| if (val1 < val2) { |
| result = -1; |
| } else if (val1 == val2) { |
| result = 0; |
| } else { |
| result = 1; |
| } |
| shadow_frame.SetVReg(inst->VRegA_23x(inst_data), result); |
| inst = inst->Next_2xx(); |
| } |
| |
| ALWAYS_INLINE void CMPL_DOUBLE() REQUIRES_SHARED(Locks::mutator_lock_) { |
| double val1 = shadow_frame.GetVRegDouble(inst->VRegB_23x()); |
| double val2 = shadow_frame.GetVRegDouble(inst->VRegC_23x()); |
| int32_t result; |
| if (val1 > val2) { |
| result = 1; |
| } else if (val1 == val2) { |
| result = 0; |
| } else { |
| result = -1; |
| } |
| shadow_frame.SetVReg(inst->VRegA_23x(inst_data), result); |
| inst = inst->Next_2xx(); |
| } |
| |
| |
| ALWAYS_INLINE void CMPG_DOUBLE() REQUIRES_SHARED(Locks::mutator_lock_) { |
| double val1 = shadow_frame.GetVRegDouble(inst->VRegB_23x()); |
| double val2 = shadow_frame.GetVRegDouble(inst->VRegC_23x()); |
| int32_t result; |
| if (val1 < val2) { |
| result = -1; |
| } else if (val1 == val2) { |
| result = 0; |
| } else { |
| result = 1; |
| } |
| shadow_frame.SetVReg(inst->VRegA_23x(inst_data), result); |
| inst = inst->Next_2xx(); |
| } |
| |
| #pragma clang diagnostic pop |
| |
| |
| ALWAYS_INLINE void CMP_LONG() REQUIRES_SHARED(Locks::mutator_lock_) { |
| int64_t val1 = shadow_frame.GetVRegLong(inst->VRegB_23x()); |
| int64_t val2 = shadow_frame.GetVRegLong(inst->VRegC_23x()); |
| int32_t result; |
| if (val1 > val2) { |
| result = 1; |
| } else if (val1 == val2) { |
| result = 0; |
| } else { |
| result = -1; |
| } |
| shadow_frame.SetVReg(inst->VRegA_23x(inst_data), result); |
| inst = inst->Next_2xx(); |
| } |
| |
| ALWAYS_INLINE void IF_EQ() REQUIRES_SHARED(Locks::mutator_lock_) { |
| if (shadow_frame.GetVReg(inst->VRegA_22t(inst_data)) == |
| shadow_frame.GetVReg(inst->VRegB_22t(inst_data))) { |
| int16_t offset = inst->VRegC_22t(); |
| BRANCH_INSTRUMENTATION(offset); |
| inst = inst->RelativeAt(offset); |
| HandleBackwardBranch(offset); |
| } else { |
| BRANCH_INSTRUMENTATION(2); |
| inst = inst->Next_2xx(); |
| } |
| } |
| |
| ALWAYS_INLINE void IF_NE() REQUIRES_SHARED(Locks::mutator_lock_) { |
| if (shadow_frame.GetVReg(inst->VRegA_22t(inst_data)) != |
| shadow_frame.GetVReg(inst->VRegB_22t(inst_data))) { |
| int16_t offset = inst->VRegC_22t(); |
| BRANCH_INSTRUMENTATION(offset); |
| inst = inst->RelativeAt(offset); |
| HandleBackwardBranch(offset); |
| } else { |
| BRANCH_INSTRUMENTATION(2); |
| inst = inst->Next_2xx(); |
| } |
| } |
| |
| ALWAYS_INLINE void IF_LT() REQUIRES_SHARED(Locks::mutator_lock_) { |
| if (shadow_frame.GetVReg(inst->VRegA_22t(inst_data)) < |
| shadow_frame.GetVReg(inst->VRegB_22t(inst_data))) { |
| int16_t offset = inst->VRegC_22t(); |
| BRANCH_INSTRUMENTATION(offset); |
| inst = inst->RelativeAt(offset); |
| HandleBackwardBranch(offset); |
| } else { |
| BRANCH_INSTRUMENTATION(2); |
| inst = inst->Next_2xx(); |
| } |
| } |
| |
| ALWAYS_INLINE void IF_GE() REQUIRES_SHARED(Locks::mutator_lock_) { |
| if (shadow_frame.GetVReg(inst->VRegA_22t(inst_data)) >= |
| shadow_frame.GetVReg(inst->VRegB_22t(inst_data))) { |
| int16_t offset = inst->VRegC_22t(); |
| BRANCH_INSTRUMENTATION(offset); |
| inst = inst->RelativeAt(offset); |
| HandleBackwardBranch(offset); |
| } else { |
| BRANCH_INSTRUMENTATION(2); |
| inst = inst->Next_2xx(); |
| } |
| } |
| |
| ALWAYS_INLINE void IF_GT() REQUIRES_SHARED(Locks::mutator_lock_) { |
| if (shadow_frame.GetVReg(inst->VRegA_22t(inst_data)) > |
| shadow_frame.GetVReg(inst->VRegB_22t(inst_data))) { |
| int16_t offset = inst->VRegC_22t(); |
| BRANCH_INSTRUMENTATION(offset); |
| inst = inst->RelativeAt(offset); |
| HandleBackwardBranch(offset); |
| } else { |
| BRANCH_INSTRUMENTATION(2); |
| inst = inst->Next_2xx(); |
| } |
| } |
| |
| ALWAYS_INLINE void IF_LE() REQUIRES_SHARED(Locks::mutator_lock_) { |
| if (shadow_frame.GetVReg(inst->VRegA_22t(inst_data)) <= |
| shadow_frame.GetVReg(inst->VRegB_22t(inst_data))) { |
| int16_t offset = inst->VRegC_22t(); |
| BRANCH_INSTRUMENTATION(offset); |
| inst = inst->RelativeAt(offset); |
| HandleBackwardBranch(offset); |
| } else { |
| BRANCH_INSTRUMENTATION(2); |
| inst = inst->Next_2xx(); |
| } |
| } |
| |
| ALWAYS_INLINE void IF_EQZ() REQUIRES_SHARED(Locks::mutator_lock_) { |
| if (shadow_frame.GetVReg(inst->VRegA_21t(inst_data)) == 0) { |
| int16_t offset = inst->VRegB_21t(); |
| BRANCH_INSTRUMENTATION(offset); |
| inst = inst->RelativeAt(offset); |
| HandleBackwardBranch(offset); |
| } else { |
| BRANCH_INSTRUMENTATION(2); |
| inst = inst->Next_2xx(); |
| } |
| } |
| |
| ALWAYS_INLINE void IF_NEZ() REQUIRES_SHARED(Locks::mutator_lock_) { |
| if (shadow_frame.GetVReg(inst->VRegA_21t(inst_data)) != 0) { |
| int16_t offset = inst->VRegB_21t(); |
| BRANCH_INSTRUMENTATION(offset); |
| inst = inst->RelativeAt(offset); |
| HandleBackwardBranch(offset); |
| } else { |
| BRANCH_INSTRUMENTATION(2); |
| inst = inst->Next_2xx(); |
| } |
| } |
| |
| ALWAYS_INLINE void IF_LTZ() REQUIRES_SHARED(Locks::mutator_lock_) { |
| if (shadow_frame.GetVReg(inst->VRegA_21t(inst_data)) < 0) { |
| int16_t offset = inst->VRegB_21t(); |
| BRANCH_INSTRUMENTATION(offset); |
| inst = inst->RelativeAt(offset); |
| HandleBackwardBranch(offset); |
| } else { |
| BRANCH_INSTRUMENTATION(2); |
| inst = inst->Next_2xx(); |
| } |
| } |
| |
| ALWAYS_INLINE void IF_GEZ() REQUIRES_SHARED(Locks::mutator_lock_) { |
| if (shadow_frame.GetVReg(inst->VRegA_21t(inst_data)) >= 0) { |
| int16_t offset = inst->VRegB_21t(); |
| BRANCH_INSTRUMENTATION(offset); |
| inst = inst->RelativeAt(offset); |
| HandleBackwardBranch(offset); |
| } else { |
| BRANCH_INSTRUMENTATION(2); |
| inst = inst->Next_2xx(); |
| } |
| } |
| |
| ALWAYS_INLINE void IF_GTZ() REQUIRES_SHARED(Locks::mutator_lock_) { |
| if (shadow_frame.GetVReg(inst->VRegA_21t(inst_data)) > 0) { |
| int16_t offset = inst->VRegB_21t(); |
| BRANCH_INSTRUMENTATION(offset); |
| inst = inst->RelativeAt(offset); |
| HandleBackwardBranch(offset); |
| } else { |
| BRANCH_INSTRUMENTATION(2); |
| inst = inst->Next_2xx(); |
| } |
| } |
| |
| ALWAYS_INLINE void IF_LEZ() REQUIRES_SHARED(Locks::mutator_lock_) { |
| if (shadow_frame.GetVReg(inst->VRegA_21t(inst_data)) <= 0) { |
| int16_t offset = inst->VRegB_21t(); |
| BRANCH_INSTRUMENTATION(offset); |
| inst = inst->RelativeAt(offset); |
| HandleBackwardBranch(offset); |
| } else { |
| BRANCH_INSTRUMENTATION(2); |
| inst = inst->Next_2xx(); |
| } |
| } |
| |
| ALWAYS_INLINE void AGET_BOOLEAN() REQUIRES_SHARED(Locks::mutator_lock_) { |
| ObjPtr<mirror::Object> a = shadow_frame.GetVRegReference(inst->VRegB_23x()); |
| if (UNLIKELY(a == nullptr)) { |
| ThrowNullPointerExceptionFromInterpreter(); |
| HANDLE_PENDING_EXCEPTION(); |
| } |
| int32_t index = shadow_frame.GetVReg(inst->VRegC_23x()); |
| ObjPtr<mirror::BooleanArray> array = a->AsBooleanArray(); |
| if (array->CheckIsValidIndex(index)) { |
| shadow_frame.SetVReg(inst->VRegA_23x(inst_data), array->GetWithoutChecks(index)); |
| inst = inst->Next_2xx(); |
| } else { |
| HANDLE_PENDING_EXCEPTION(); |
| } |
| } |
| |
| ALWAYS_INLINE void AGET_BYTE() REQUIRES_SHARED(Locks::mutator_lock_) { |
| ObjPtr<mirror::Object> a = shadow_frame.GetVRegReference(inst->VRegB_23x()); |
| if (UNLIKELY(a == nullptr)) { |
| ThrowNullPointerExceptionFromInterpreter(); |
| HANDLE_PENDING_EXCEPTION(); |
| } |
| int32_t index = shadow_frame.GetVReg(inst->VRegC_23x()); |
| ObjPtr<mirror::ByteArray> array = a->AsByteArray(); |
| if (array->CheckIsValidIndex(index)) { |
| shadow_frame.SetVReg(inst->VRegA_23x(inst_data), array->GetWithoutChecks(index)); |
| inst = inst->Next_2xx(); |
| } else { |
| HANDLE_PENDING_EXCEPTION(); |
| } |
| } |
| |
| ALWAYS_INLINE void AGET_CHAR() REQUIRES_SHARED(Locks::mutator_lock_) { |
| ObjPtr<mirror::Object> a = shadow_frame.GetVRegReference(inst->VRegB_23x()); |
| if (UNLIKELY(a == nullptr)) { |
| ThrowNullPointerExceptionFromInterpreter(); |
| HANDLE_PENDING_EXCEPTION(); |
| } |
| int32_t index = shadow_frame.GetVReg(inst->VRegC_23x()); |
| ObjPtr<mirror::CharArray> array = a->AsCharArray(); |
| if (array->CheckIsValidIndex(index)) { |
| shadow_frame.SetVReg(inst->VRegA_23x(inst_data), array->GetWithoutChecks(index)); |
| inst = inst->Next_2xx(); |
| } else { |
| HANDLE_PENDING_EXCEPTION(); |
| } |
| } |
| |
| ALWAYS_INLINE void AGET_SHORT() REQUIRES_SHARED(Locks::mutator_lock_) { |
| ObjPtr<mirror::Object> a = shadow_frame.GetVRegReference(inst->VRegB_23x()); |
| if (UNLIKELY(a == nullptr)) { |
| ThrowNullPointerExceptionFromInterpreter(); |
| HANDLE_PENDING_EXCEPTION(); |
| } |
| int32_t index = shadow_frame.GetVReg(inst->VRegC_23x()); |
| ObjPtr<mirror::ShortArray> array = a->AsShortArray(); |
| if (array->CheckIsValidIndex(index)) { |
| shadow_frame.SetVReg(inst->VRegA_23x(inst_data), array->GetWithoutChecks(index)); |
| inst = inst->Next_2xx(); |
| } else { |
| HANDLE_PENDING_EXCEPTION(); |
| } |
| } |
| |
| ALWAYS_INLINE void AGET() REQUIRES_SHARED(Locks::mutator_lock_) { |
| ObjPtr<mirror::Object> a = shadow_frame.GetVRegReference(inst->VRegB_23x()); |
| if (UNLIKELY(a == nullptr)) { |
| ThrowNullPointerExceptionFromInterpreter(); |
| HANDLE_PENDING_EXCEPTION(); |
| } |
| int32_t index = shadow_frame.GetVReg(inst->VRegC_23x()); |
| DCHECK(a->IsIntArray() || a->IsFloatArray()) << a->PrettyTypeOf(); |
| ObjPtr<mirror::IntArray> array = ObjPtr<mirror::IntArray>::DownCast(a); |
| if (array->CheckIsValidIndex(index)) { |
| shadow_frame.SetVReg(inst->VRegA_23x(inst_data), array->GetWithoutChecks(index)); |
| inst = inst->Next_2xx(); |
| } else { |
| HANDLE_PENDING_EXCEPTION(); |
| } |
| } |
| |
| ALWAYS_INLINE void AGET_WIDE() REQUIRES_SHARED(Locks::mutator_lock_) { |
| ObjPtr<mirror::Object> a = shadow_frame.GetVRegReference(inst->VRegB_23x()); |
| if (UNLIKELY(a == nullptr)) { |
| ThrowNullPointerExceptionFromInterpreter(); |
| HANDLE_PENDING_EXCEPTION(); |
| } |
| int32_t index = shadow_frame.GetVReg(inst->VRegC_23x()); |
| DCHECK(a->IsLongArray() || a->IsDoubleArray()) << a->PrettyTypeOf(); |
| ObjPtr<mirror::LongArray> array = ObjPtr<mirror::LongArray>::DownCast(a); |
| if (array->CheckIsValidIndex(index)) { |
| shadow_frame.SetVRegLong(inst->VRegA_23x(inst_data), array->GetWithoutChecks(index)); |
| inst = inst->Next_2xx(); |
| } else { |
| HANDLE_PENDING_EXCEPTION(); |
| } |
| } |
| |
| ALWAYS_INLINE void AGET_OBJECT() REQUIRES_SHARED(Locks::mutator_lock_) { |
| ObjPtr<mirror::Object> a = shadow_frame.GetVRegReference(inst->VRegB_23x()); |
| if (UNLIKELY(a == nullptr)) { |
| ThrowNullPointerExceptionFromInterpreter(); |
| HANDLE_PENDING_EXCEPTION(); |
| } |
| int32_t index = shadow_frame.GetVReg(inst->VRegC_23x()); |
| ObjPtr<mirror::ObjectArray<mirror::Object>> array = a->AsObjectArray<mirror::Object>(); |
| if (array->CheckIsValidIndex(index)) { |
| shadow_frame.SetVRegReference(inst->VRegA_23x(inst_data), array->GetWithoutChecks(index)); |
| inst = inst->Next_2xx(); |
| } else { |
| HANDLE_PENDING_EXCEPTION(); |
| } |
| } |
| |
| ALWAYS_INLINE void APUT_BOOLEAN() REQUIRES_SHARED(Locks::mutator_lock_) { |
| ObjPtr<mirror::Object> a = shadow_frame.GetVRegReference(inst->VRegB_23x()); |
| if (UNLIKELY(a == nullptr)) { |
| ThrowNullPointerExceptionFromInterpreter(); |
| HANDLE_PENDING_EXCEPTION(); |
| } |
| uint8_t val = shadow_frame.GetVReg(inst->VRegA_23x(inst_data)); |
| int32_t index = shadow_frame.GetVReg(inst->VRegC_23x()); |
| ObjPtr<mirror::BooleanArray> array = a->AsBooleanArray(); |
| if (array->CheckIsValidIndex(index)) { |
| array->SetWithoutChecks<transaction_active>(index, val); |
| inst = inst->Next_2xx(); |
| } else { |
| HANDLE_PENDING_EXCEPTION(); |
| } |
| } |
| |
| ALWAYS_INLINE void APUT_BYTE() REQUIRES_SHARED(Locks::mutator_lock_) { |
| ObjPtr<mirror::Object> a = shadow_frame.GetVRegReference(inst->VRegB_23x()); |
| if (UNLIKELY(a == nullptr)) { |
| ThrowNullPointerExceptionFromInterpreter(); |
| HANDLE_PENDING_EXCEPTION(); |
| } |
| int8_t val = shadow_frame.GetVReg(inst->VRegA_23x(inst_data)); |
| int32_t index = shadow_frame.GetVReg(inst->VRegC_23x()); |
| ObjPtr<mirror::ByteArray> array = a->AsByteArray(); |
| if (array->CheckIsValidIndex(index)) { |
| array->SetWithoutChecks<transaction_active>(index, val); |
| inst = inst->Next_2xx(); |
| } else { |
| HANDLE_PENDING_EXCEPTION(); |
| } |
| } |
| |
| ALWAYS_INLINE void APUT_CHAR() REQUIRES_SHARED(Locks::mutator_lock_) { |
| ObjPtr<mirror::Object> a = shadow_frame.GetVRegReference(inst->VRegB_23x()); |
| if (UNLIKELY(a == nullptr)) { |
| ThrowNullPointerExceptionFromInterpreter(); |
| HANDLE_PENDING_EXCEPTION(); |
| } |
| uint16_t val = shadow_frame.GetVReg(inst->VRegA_23x(inst_data)); |
| int32_t index = shadow_frame.GetVReg(inst->VRegC_23x()); |
| ObjPtr<mirror::CharArray> array = a->AsCharArray(); |
| if (array->CheckIsValidIndex(index)) { |
| array->SetWithoutChecks<transaction_active>(index, val); |
| inst = inst->Next_2xx(); |
| } else { |
| HANDLE_PENDING_EXCEPTION(); |
| } |
| } |
| |
| ALWAYS_INLINE void APUT_SHORT() REQUIRES_SHARED(Locks::mutator_lock_) { |
| ObjPtr<mirror::Object> a = shadow_frame.GetVRegReference(inst->VRegB_23x()); |
| if (UNLIKELY(a == nullptr)) { |
| ThrowNullPointerExceptionFromInterpreter(); |
| HANDLE_PENDING_EXCEPTION(); |
| } |
| int16_t val = shadow_frame.GetVReg(inst->VRegA_23x(inst_data)); |
| int32_t index = shadow_frame.GetVReg(inst->VRegC_23x()); |
| ObjPtr<mirror::ShortArray> array = a->AsShortArray(); |
| if (array->CheckIsValidIndex(index)) { |
| array->SetWithoutChecks<transaction_active>(index, val); |
| inst = inst->Next_2xx(); |
| } else { |
| HANDLE_PENDING_EXCEPTION(); |
| } |
| } |
| |
| ALWAYS_INLINE void APUT() REQUIRES_SHARED(Locks::mutator_lock_) { |
| ObjPtr<mirror::Object> a = shadow_frame.GetVRegReference(inst->VRegB_23x()); |
| if (UNLIKELY(a == nullptr)) { |
| ThrowNullPointerExceptionFromInterpreter(); |
| HANDLE_PENDING_EXCEPTION(); |
| } |
| int32_t val = shadow_frame.GetVReg(inst->VRegA_23x(inst_data)); |
| int32_t index = shadow_frame.GetVReg(inst->VRegC_23x()); |
| DCHECK(a->IsIntArray() || a->IsFloatArray()) << a->PrettyTypeOf(); |
| ObjPtr<mirror::IntArray> array = ObjPtr<mirror::IntArray>::DownCast(a); |
| if (array->CheckIsValidIndex(index)) { |
| array->SetWithoutChecks<transaction_active>(index, val); |
| inst = inst->Next_2xx(); |
| } else { |
| HANDLE_PENDING_EXCEPTION(); |
| } |
| } |
| |
| ALWAYS_INLINE void APUT_WIDE() REQUIRES_SHARED(Locks::mutator_lock_) { |
| ObjPtr<mirror::Object> a = shadow_frame.GetVRegReference(inst->VRegB_23x()); |
| if (UNLIKELY(a == nullptr)) { |
| ThrowNullPointerExceptionFromInterpreter(); |
| HANDLE_PENDING_EXCEPTION(); |
| } |
| int64_t val = shadow_frame.GetVRegLong(inst->VRegA_23x(inst_data)); |
| int32_t index = shadow_frame.GetVReg(inst->VRegC_23x()); |
| DCHECK(a->IsLongArray() || a->IsDoubleArray()) << a->PrettyTypeOf(); |
| ObjPtr<mirror::LongArray> array = ObjPtr<mirror::LongArray>::DownCast(a); |
| if (array->CheckIsValidIndex(index)) { |
| array->SetWithoutChecks<transaction_active>(index, val); |
| inst = inst->Next_2xx(); |
| } else { |
| HANDLE_PENDING_EXCEPTION(); |
| } |
| } |
| |
| ALWAYS_INLINE void APUT_OBJECT() REQUIRES_SHARED(Locks::mutator_lock_) { |
| ObjPtr<mirror::Object> a = shadow_frame.GetVRegReference(inst->VRegB_23x()); |
| if (UNLIKELY(a == nullptr)) { |
| ThrowNullPointerExceptionFromInterpreter(); |
| HANDLE_PENDING_EXCEPTION(); |
| } |
| int32_t index = shadow_frame.GetVReg(inst->VRegC_23x()); |
| ObjPtr<mirror::Object> val = shadow_frame.GetVRegReference(inst->VRegA_23x(inst_data)); |
| ObjPtr<mirror::ObjectArray<mirror::Object>> array = a->AsObjectArray<mirror::Object>(); |
| if (array->CheckIsValidIndex(index) && array->CheckAssignable(val)) { |
| array->SetWithoutChecks<transaction_active>(index, val); |
| inst = inst->Next_2xx(); |
| } else { |
| HANDLE_PENDING_EXCEPTION(); |
| } |
| } |
| |
| ALWAYS_INLINE void IGET_BOOLEAN() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoFieldGet<InstancePrimitiveRead, Primitive::kPrimBoolean, do_access_check>( |
| self, shadow_frame, inst, inst_data); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); |
| } |
| |
| ALWAYS_INLINE void IGET_BYTE() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoFieldGet<InstancePrimitiveRead, Primitive::kPrimByte, do_access_check>( |
| self, shadow_frame, inst, inst_data); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); |
| } |
| |
| ALWAYS_INLINE void IGET_CHAR() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoFieldGet<InstancePrimitiveRead, Primitive::kPrimChar, do_access_check>( |
| self, shadow_frame, inst, inst_data); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); |
| } |
| |
| ALWAYS_INLINE void IGET_SHORT() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoFieldGet<InstancePrimitiveRead, Primitive::kPrimShort, do_access_check>( |
| self, shadow_frame, inst, inst_data); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); |
| } |
| |
| ALWAYS_INLINE void IGET() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoFieldGet<InstancePrimitiveRead, Primitive::kPrimInt, do_access_check>( |
| self, shadow_frame, inst, inst_data); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); |
| } |
| |
| ALWAYS_INLINE void IGET_WIDE() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoFieldGet<InstancePrimitiveRead, Primitive::kPrimLong, do_access_check>( |
| self, shadow_frame, inst, inst_data); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); |
| } |
| |
| ALWAYS_INLINE void IGET_OBJECT() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoFieldGet<InstanceObjectRead, Primitive::kPrimNot, do_access_check>( |
| self, shadow_frame, inst, inst_data); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); |
| } |
| |
| ALWAYS_INLINE void IGET_QUICK() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoIGetQuick<Primitive::kPrimInt>(shadow_frame, inst, inst_data); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); |
| } |
| |
| ALWAYS_INLINE void IGET_WIDE_QUICK() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoIGetQuick<Primitive::kPrimLong>(shadow_frame, inst, inst_data); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); |
| } |
| |
| ALWAYS_INLINE void IGET_OBJECT_QUICK() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoIGetQuick<Primitive::kPrimNot>(shadow_frame, inst, inst_data); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); |
| } |
| |
| ALWAYS_INLINE void IGET_BOOLEAN_QUICK() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoIGetQuick<Primitive::kPrimBoolean>(shadow_frame, inst, inst_data); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); |
| } |
| |
| ALWAYS_INLINE void IGET_BYTE_QUICK() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoIGetQuick<Primitive::kPrimByte>(shadow_frame, inst, inst_data); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); |
| } |
| |
| ALWAYS_INLINE void IGET_CHAR_QUICK() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoIGetQuick<Primitive::kPrimChar>(shadow_frame, inst, inst_data); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); |
| } |
| |
| ALWAYS_INLINE void IGET_SHORT_QUICK() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoIGetQuick<Primitive::kPrimShort>(shadow_frame, inst, inst_data); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); |
| } |
| |
| ALWAYS_INLINE void SGET_BOOLEAN() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoFieldGet<StaticPrimitiveRead, Primitive::kPrimBoolean, do_access_check, |
| transaction_active>(self, shadow_frame, inst, inst_data); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); |
| } |
| |
| ALWAYS_INLINE void SGET_BYTE() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoFieldGet<StaticPrimitiveRead, Primitive::kPrimByte, do_access_check, |
| transaction_active>(self, shadow_frame, inst, inst_data); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); |
| } |
| |
| ALWAYS_INLINE void SGET_CHAR() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoFieldGet<StaticPrimitiveRead, Primitive::kPrimChar, do_access_check, |
| transaction_active>(self, shadow_frame, inst, inst_data); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); |
| } |
| |
| ALWAYS_INLINE void SGET_SHORT() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoFieldGet<StaticPrimitiveRead, Primitive::kPrimShort, do_access_check, |
| transaction_active>(self, shadow_frame, inst, inst_data); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); |
| } |
| |
| ALWAYS_INLINE void SGET() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoFieldGet<StaticPrimitiveRead, Primitive::kPrimInt, do_access_check, |
| transaction_active>(self, shadow_frame, inst, inst_data); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); |
| } |
| |
| ALWAYS_INLINE void SGET_WIDE() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoFieldGet<StaticPrimitiveRead, Primitive::kPrimLong, do_access_check, |
| transaction_active>(self, shadow_frame, inst, inst_data); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); |
| } |
| |
| ALWAYS_INLINE void SGET_OBJECT() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoFieldGet<StaticObjectRead, Primitive::kPrimNot, do_access_check, |
| transaction_active>(self, shadow_frame, inst, inst_data); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); |
| } |
| |
| ALWAYS_INLINE void IPUT_BOOLEAN() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoFieldPut<InstancePrimitiveWrite, Primitive::kPrimBoolean, do_access_check, |
| transaction_active>(self, shadow_frame, inst, inst_data); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); |
| } |
| |
| ALWAYS_INLINE void IPUT_BYTE() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoFieldPut<InstancePrimitiveWrite, Primitive::kPrimByte, do_access_check, |
| transaction_active>(self, shadow_frame, inst, inst_data); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); |
| } |
| |
| ALWAYS_INLINE void IPUT_CHAR() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoFieldPut<InstancePrimitiveWrite, Primitive::kPrimChar, do_access_check, |
| transaction_active>(self, shadow_frame, inst, inst_data); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); |
| } |
| |
| ALWAYS_INLINE void IPUT_SHORT() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoFieldPut<InstancePrimitiveWrite, Primitive::kPrimShort, do_access_check, |
| transaction_active>(self, shadow_frame, inst, inst_data); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); |
| } |
| |
| ALWAYS_INLINE void IPUT() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoFieldPut<InstancePrimitiveWrite, Primitive::kPrimInt, do_access_check, |
| transaction_active>(self, shadow_frame, inst, inst_data); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); |
| } |
| |
| ALWAYS_INLINE void IPUT_WIDE() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoFieldPut<InstancePrimitiveWrite, Primitive::kPrimLong, do_access_check, |
| transaction_active>(self, shadow_frame, inst, inst_data); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); |
| } |
| |
| ALWAYS_INLINE void IPUT_OBJECT() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoFieldPut<InstanceObjectWrite, Primitive::kPrimNot, do_access_check, |
| transaction_active>(self, shadow_frame, inst, inst_data); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); |
| } |
| |
| ALWAYS_INLINE void IPUT_QUICK() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoIPutQuick<Primitive::kPrimInt, transaction_active>( |
| shadow_frame, inst, inst_data); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); |
| } |
| |
| ALWAYS_INLINE void IPUT_BOOLEAN_QUICK() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoIPutQuick<Primitive::kPrimBoolean, transaction_active>( |
| shadow_frame, inst, inst_data); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); |
| } |
| |
| ALWAYS_INLINE void IPUT_BYTE_QUICK() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoIPutQuick<Primitive::kPrimByte, transaction_active>( |
| shadow_frame, inst, inst_data); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); |
| } |
| |
| ALWAYS_INLINE void IPUT_CHAR_QUICK() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoIPutQuick<Primitive::kPrimChar, transaction_active>( |
| shadow_frame, inst, inst_data); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); |
| } |
| |
| ALWAYS_INLINE void IPUT_SHORT_QUICK() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoIPutQuick<Primitive::kPrimShort, transaction_active>( |
| shadow_frame, inst, inst_data); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); |
| } |
| |
| ALWAYS_INLINE void IPUT_WIDE_QUICK() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoIPutQuick<Primitive::kPrimLong, transaction_active>( |
| shadow_frame, inst, inst_data); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); |
| } |
| |
| ALWAYS_INLINE void IPUT_OBJECT_QUICK() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoIPutQuick<Primitive::kPrimNot, transaction_active>( |
| shadow_frame, inst, inst_data); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); |
| } |
| |
| ALWAYS_INLINE void SPUT_BOOLEAN() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoFieldPut<StaticPrimitiveWrite, Primitive::kPrimBoolean, do_access_check, |
| transaction_active>(self, shadow_frame, inst, inst_data); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); |
| } |
| |
| ALWAYS_INLINE void SPUT_BYTE() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoFieldPut<StaticPrimitiveWrite, Primitive::kPrimByte, do_access_check, |
| transaction_active>(self, shadow_frame, inst, inst_data); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); |
| } |
| |
| ALWAYS_INLINE void SPUT_CHAR() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoFieldPut<StaticPrimitiveWrite, Primitive::kPrimChar, do_access_check, |
| transaction_active>(self, shadow_frame, inst, inst_data); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); |
| } |
| |
| ALWAYS_INLINE void SPUT_SHORT() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoFieldPut<StaticPrimitiveWrite, Primitive::kPrimShort, do_access_check, |
| transaction_active>(self, shadow_frame, inst, inst_data); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); |
| } |
| |
| ALWAYS_INLINE void SPUT() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoFieldPut<StaticPrimitiveWrite, Primitive::kPrimInt, do_access_check, |
| transaction_active>(self, shadow_frame, inst, inst_data); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); |
| } |
| |
| ALWAYS_INLINE void SPUT_WIDE() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoFieldPut<StaticPrimitiveWrite, Primitive::kPrimLong, do_access_check, |
| transaction_active>(self, shadow_frame, inst, inst_data); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); |
| } |
| |
| ALWAYS_INLINE void SPUT_OBJECT() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoFieldPut<StaticObjectWrite, Primitive::kPrimNot, do_access_check, |
| transaction_active>(self, shadow_frame, inst, inst_data); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); |
| } |
| |
| ALWAYS_INLINE void INVOKE_VIRTUAL() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoInvoke<kVirtual, false, do_access_check, /*is_mterp=*/ false>( |
| self, shadow_frame, inst, inst_data, ResultRegister()); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION_ON_INVOKE(!success); |
| } |
| |
| ALWAYS_INLINE void INVOKE_VIRTUAL_RANGE() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoInvoke<kVirtual, true, do_access_check, /*is_mterp=*/ false>( |
| self, shadow_frame, inst, inst_data, ResultRegister()); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION_ON_INVOKE(!success); |
| } |
| |
| ALWAYS_INLINE void INVOKE_SUPER() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoInvoke<kSuper, false, do_access_check, /*is_mterp=*/ false>( |
| self, shadow_frame, inst, inst_data, ResultRegister()); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION_ON_INVOKE(!success); |
| } |
| |
| ALWAYS_INLINE void INVOKE_SUPER_RANGE() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoInvoke<kSuper, true, do_access_check, /*is_mterp=*/ false>( |
| self, shadow_frame, inst, inst_data, ResultRegister()); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION_ON_INVOKE(!success); |
| } |
| |
| ALWAYS_INLINE void INVOKE_DIRECT() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoInvoke<kDirect, false, do_access_check, /*is_mterp=*/ false>( |
| self, shadow_frame, inst, inst_data, ResultRegister()); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION_ON_INVOKE(!success); |
| } |
| |
| ALWAYS_INLINE void INVOKE_DIRECT_RANGE() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoInvoke<kDirect, true, do_access_check, /*is_mterp=*/ false>( |
| self, shadow_frame, inst, inst_data, ResultRegister()); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION_ON_INVOKE(!success); |
| } |
| |
| ALWAYS_INLINE void INVOKE_INTERFACE() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoInvoke<kInterface, false, do_access_check, /*is_mterp=*/ false>( |
| self, shadow_frame, inst, inst_data, ResultRegister()); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION_ON_INVOKE(!success); |
| } |
| |
| ALWAYS_INLINE void INVOKE_INTERFACE_RANGE() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoInvoke<kInterface, true, do_access_check, /*is_mterp=*/ false>( |
| self, shadow_frame, inst, inst_data, ResultRegister()); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION_ON_INVOKE(!success); |
| } |
| |
| ALWAYS_INLINE void INVOKE_STATIC() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoInvoke<kStatic, false, do_access_check, /*is_mterp=*/ false>( |
| self, shadow_frame, inst, inst_data, ResultRegister()); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION_ON_INVOKE(!success); |
| } |
| |
| ALWAYS_INLINE void INVOKE_STATIC_RANGE() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoInvoke<kStatic, true, do_access_check, /*is_mterp=*/ false>( |
| self, shadow_frame, inst, inst_data, ResultRegister()); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION_ON_INVOKE(!success); |
| } |
| |
| ALWAYS_INLINE void INVOKE_VIRTUAL_QUICK() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoInvoke<kVirtual, false, do_access_check, /*is_mterp=*/ false, |
| /*is_quick=*/ true>(self, shadow_frame, inst, inst_data, ResultRegister()); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION_ON_INVOKE(!success); |
| } |
| |
| ALWAYS_INLINE void INVOKE_VIRTUAL_RANGE_QUICK() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoInvoke<kVirtual, true, do_access_check, /*is_mterp=*/ false, |
| /*is_quick=*/ true>(self, shadow_frame, inst, inst_data, ResultRegister()); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION_ON_INVOKE(!success); |
| } |
| |
| ALWAYS_INLINE void INVOKE_POLYMORPHIC() REQUIRES_SHARED(Locks::mutator_lock_) { |
| DCHECK(Runtime::Current()->IsMethodHandlesEnabled()); |
| bool success = DoInvokePolymorphic</* is_range= */ false>( |
| self, shadow_frame, inst, inst_data, ResultRegister()); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION_ON_INVOKE_POLYMORPHIC(!success); |
| } |
| |
| ALWAYS_INLINE void INVOKE_POLYMORPHIC_RANGE() REQUIRES_SHARED(Locks::mutator_lock_) { |
| DCHECK(Runtime::Current()->IsMethodHandlesEnabled()); |
| bool success = DoInvokePolymorphic</* is_range= */ true>( |
| self, shadow_frame, inst, inst_data, ResultRegister()); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION_ON_INVOKE_POLYMORPHIC(!success); |
| } |
| |
| ALWAYS_INLINE void INVOKE_CUSTOM() REQUIRES_SHARED(Locks::mutator_lock_) { |
| DCHECK(Runtime::Current()->IsMethodHandlesEnabled()); |
| bool success = DoInvokeCustom</* is_range= */ false>( |
| self, shadow_frame, inst, inst_data, ResultRegister()); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION_ON_INVOKE(!success); |
| } |
| |
| ALWAYS_INLINE void INVOKE_CUSTOM_RANGE() REQUIRES_SHARED(Locks::mutator_lock_) { |
| DCHECK(Runtime::Current()->IsMethodHandlesEnabled()); |
| bool success = DoInvokeCustom</* is_range= */ true>( |
| self, shadow_frame, inst, inst_data, ResultRegister()); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION_ON_INVOKE(!success); |
| } |
| |
| ALWAYS_INLINE void NEG_INT() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVReg( |
| inst->VRegA_12x(inst_data), -shadow_frame.GetVReg(inst->VRegB_12x(inst_data))); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void NOT_INT() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVReg( |
| inst->VRegA_12x(inst_data), ~shadow_frame.GetVReg(inst->VRegB_12x(inst_data))); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void NEG_LONG() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVRegLong( |
| inst->VRegA_12x(inst_data), -shadow_frame.GetVRegLong(inst->VRegB_12x(inst_data))); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void NOT_LONG() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVRegLong( |
| inst->VRegA_12x(inst_data), ~shadow_frame.GetVRegLong(inst->VRegB_12x(inst_data))); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void NEG_FLOAT() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVRegFloat( |
| inst->VRegA_12x(inst_data), -shadow_frame.GetVRegFloat(inst->VRegB_12x(inst_data))); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void NEG_DOUBLE() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVRegDouble( |
| inst->VRegA_12x(inst_data), -shadow_frame.GetVRegDouble(inst->VRegB_12x(inst_data))); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void INT_TO_LONG() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVRegLong(inst->VRegA_12x(inst_data), |
| shadow_frame.GetVReg(inst->VRegB_12x(inst_data))); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void INT_TO_FLOAT() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVRegFloat(inst->VRegA_12x(inst_data), |
| shadow_frame.GetVReg(inst->VRegB_12x(inst_data))); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void INT_TO_DOUBLE() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVRegDouble(inst->VRegA_12x(inst_data), |
| shadow_frame.GetVReg(inst->VRegB_12x(inst_data))); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void LONG_TO_INT() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVReg(inst->VRegA_12x(inst_data), |
| shadow_frame.GetVRegLong(inst->VRegB_12x(inst_data))); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void LONG_TO_FLOAT() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVRegFloat(inst->VRegA_12x(inst_data), |
| shadow_frame.GetVRegLong(inst->VRegB_12x(inst_data))); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void LONG_TO_DOUBLE() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVRegDouble(inst->VRegA_12x(inst_data), |
| shadow_frame.GetVRegLong(inst->VRegB_12x(inst_data))); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void FLOAT_TO_INT() REQUIRES_SHARED(Locks::mutator_lock_) { |
| float val = shadow_frame.GetVRegFloat(inst->VRegB_12x(inst_data)); |
| int32_t result = art_float_to_integral<int32_t, float>(val); |
| shadow_frame.SetVReg(inst->VRegA_12x(inst_data), result); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void FLOAT_TO_LONG() REQUIRES_SHARED(Locks::mutator_lock_) { |
| float val = shadow_frame.GetVRegFloat(inst->VRegB_12x(inst_data)); |
| int64_t result = art_float_to_integral<int64_t, float>(val); |
| shadow_frame.SetVRegLong(inst->VRegA_12x(inst_data), result); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void FLOAT_TO_DOUBLE() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVRegDouble(inst->VRegA_12x(inst_data), |
| shadow_frame.GetVRegFloat(inst->VRegB_12x(inst_data))); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void DOUBLE_TO_INT() REQUIRES_SHARED(Locks::mutator_lock_) { |
| double val = shadow_frame.GetVRegDouble(inst->VRegB_12x(inst_data)); |
| int32_t result = art_float_to_integral<int32_t, double>(val); |
| shadow_frame.SetVReg(inst->VRegA_12x(inst_data), result); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void DOUBLE_TO_LONG() REQUIRES_SHARED(Locks::mutator_lock_) { |
| double val = shadow_frame.GetVRegDouble(inst->VRegB_12x(inst_data)); |
| int64_t result = art_float_to_integral<int64_t, double>(val); |
| shadow_frame.SetVRegLong(inst->VRegA_12x(inst_data), result); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void DOUBLE_TO_FLOAT() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVRegFloat(inst->VRegA_12x(inst_data), |
| shadow_frame.GetVRegDouble(inst->VRegB_12x(inst_data))); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void INT_TO_BYTE() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVReg(inst->VRegA_12x(inst_data), static_cast<int8_t>( |
| shadow_frame.GetVReg(inst->VRegB_12x(inst_data)))); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void INT_TO_CHAR() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVReg(inst->VRegA_12x(inst_data), static_cast<uint16_t>( |
| shadow_frame.GetVReg(inst->VRegB_12x(inst_data)))); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void INT_TO_SHORT() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVReg(inst->VRegA_12x(inst_data), static_cast<int16_t>( |
| shadow_frame.GetVReg(inst->VRegB_12x(inst_data)))); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void ADD_INT() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVReg(inst->VRegA_23x(inst_data), |
| SafeAdd(shadow_frame.GetVReg(inst->VRegB_23x()), |
| shadow_frame.GetVReg(inst->VRegC_23x()))); |
| inst = inst->Next_2xx(); |
| } |
| |
| ALWAYS_INLINE void SUB_INT() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVReg(inst->VRegA_23x(inst_data), |
| SafeSub(shadow_frame.GetVReg(inst->VRegB_23x()), |
| shadow_frame.GetVReg(inst->VRegC_23x()))); |
| inst = inst->Next_2xx(); |
| } |
| |
| ALWAYS_INLINE void MUL_INT() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVReg(inst->VRegA_23x(inst_data), |
| SafeMul(shadow_frame.GetVReg(inst->VRegB_23x()), |
| shadow_frame.GetVReg(inst->VRegC_23x()))); |
| inst = inst->Next_2xx(); |
| } |
| |
| ALWAYS_INLINE void DIV_INT() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoIntDivide(shadow_frame, inst->VRegA_23x(inst_data), |
| shadow_frame.GetVReg(inst->VRegB_23x()), |
| shadow_frame.GetVReg(inst->VRegC_23x())); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); |
| } |
| |
| ALWAYS_INLINE void REM_INT() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoIntRemainder(shadow_frame, inst->VRegA_23x(inst_data), |
| shadow_frame.GetVReg(inst->VRegB_23x()), |
| shadow_frame.GetVReg(inst->VRegC_23x())); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); |
| } |
| |
| ALWAYS_INLINE void SHL_INT() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVReg(inst->VRegA_23x(inst_data), |
| shadow_frame.GetVReg(inst->VRegB_23x()) << |
| (shadow_frame.GetVReg(inst->VRegC_23x()) & 0x1f)); |
| inst = inst->Next_2xx(); |
| } |
| |
| ALWAYS_INLINE void SHR_INT() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVReg(inst->VRegA_23x(inst_data), |
| shadow_frame.GetVReg(inst->VRegB_23x()) >> |
| (shadow_frame.GetVReg(inst->VRegC_23x()) & 0x1f)); |
| inst = inst->Next_2xx(); |
| } |
| |
| ALWAYS_INLINE void USHR_INT() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVReg(inst->VRegA_23x(inst_data), |
| static_cast<uint32_t>(shadow_frame.GetVReg(inst->VRegB_23x())) >> |
| (shadow_frame.GetVReg(inst->VRegC_23x()) & 0x1f)); |
| inst = inst->Next_2xx(); |
| } |
| |
| ALWAYS_INLINE void AND_INT() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVReg(inst->VRegA_23x(inst_data), |
| shadow_frame.GetVReg(inst->VRegB_23x()) & |
| shadow_frame.GetVReg(inst->VRegC_23x())); |
| inst = inst->Next_2xx(); |
| } |
| |
| ALWAYS_INLINE void OR_INT() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVReg(inst->VRegA_23x(inst_data), |
| shadow_frame.GetVReg(inst->VRegB_23x()) | |
| shadow_frame.GetVReg(inst->VRegC_23x())); |
| inst = inst->Next_2xx(); |
| } |
| |
| ALWAYS_INLINE void XOR_INT() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVReg(inst->VRegA_23x(inst_data), |
| shadow_frame.GetVReg(inst->VRegB_23x()) ^ |
| shadow_frame.GetVReg(inst->VRegC_23x())); |
| inst = inst->Next_2xx(); |
| } |
| |
| ALWAYS_INLINE void ADD_LONG() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVRegLong(inst->VRegA_23x(inst_data), |
| SafeAdd(shadow_frame.GetVRegLong(inst->VRegB_23x()), |
| shadow_frame.GetVRegLong(inst->VRegC_23x()))); |
| inst = inst->Next_2xx(); |
| } |
| |
| ALWAYS_INLINE void SUB_LONG() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVRegLong(inst->VRegA_23x(inst_data), |
| SafeSub(shadow_frame.GetVRegLong(inst->VRegB_23x()), |
| shadow_frame.GetVRegLong(inst->VRegC_23x()))); |
| inst = inst->Next_2xx(); |
| } |
| |
| ALWAYS_INLINE void MUL_LONG() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVRegLong(inst->VRegA_23x(inst_data), |
| SafeMul(shadow_frame.GetVRegLong(inst->VRegB_23x()), |
| shadow_frame.GetVRegLong(inst->VRegC_23x()))); |
| inst = inst->Next_2xx(); |
| } |
| |
| ALWAYS_INLINE void DIV_LONG() REQUIRES_SHARED(Locks::mutator_lock_) { |
| DoLongDivide(shadow_frame, inst->VRegA_23x(inst_data), |
| shadow_frame.GetVRegLong(inst->VRegB_23x()), |
| shadow_frame.GetVRegLong(inst->VRegC_23x())); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(self->IsExceptionPending(), Next_2xx); |
| } |
| |
| ALWAYS_INLINE void REM_LONG() REQUIRES_SHARED(Locks::mutator_lock_) { |
| DoLongRemainder(shadow_frame, inst->VRegA_23x(inst_data), |
| shadow_frame.GetVRegLong(inst->VRegB_23x()), |
| shadow_frame.GetVRegLong(inst->VRegC_23x())); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(self->IsExceptionPending(), Next_2xx); |
| } |
| |
| ALWAYS_INLINE void AND_LONG() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVRegLong(inst->VRegA_23x(inst_data), |
| shadow_frame.GetVRegLong(inst->VRegB_23x()) & |
| shadow_frame.GetVRegLong(inst->VRegC_23x())); |
| inst = inst->Next_2xx(); |
| } |
| |
| ALWAYS_INLINE void OR_LONG() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVRegLong(inst->VRegA_23x(inst_data), |
| shadow_frame.GetVRegLong(inst->VRegB_23x()) | |
| shadow_frame.GetVRegLong(inst->VRegC_23x())); |
| inst = inst->Next_2xx(); |
| } |
| |
| ALWAYS_INLINE void XOR_LONG() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVRegLong(inst->VRegA_23x(inst_data), |
| shadow_frame.GetVRegLong(inst->VRegB_23x()) ^ |
| shadow_frame.GetVRegLong(inst->VRegC_23x())); |
| inst = inst->Next_2xx(); |
| } |
| |
| ALWAYS_INLINE void SHL_LONG() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVRegLong(inst->VRegA_23x(inst_data), |
| shadow_frame.GetVRegLong(inst->VRegB_23x()) << |
| (shadow_frame.GetVReg(inst->VRegC_23x()) & 0x3f)); |
| inst = inst->Next_2xx(); |
| } |
| |
| ALWAYS_INLINE void SHR_LONG() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVRegLong(inst->VRegA_23x(inst_data), |
| shadow_frame.GetVRegLong(inst->VRegB_23x()) >> |
| (shadow_frame.GetVReg(inst->VRegC_23x()) & 0x3f)); |
| inst = inst->Next_2xx(); |
| } |
| |
| ALWAYS_INLINE void USHR_LONG() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVRegLong(inst->VRegA_23x(inst_data), |
| static_cast<uint64_t>(shadow_frame.GetVRegLong(inst->VRegB_23x())) >> |
| (shadow_frame.GetVReg(inst->VRegC_23x()) & 0x3f)); |
| inst = inst->Next_2xx(); |
| } |
| |
| ALWAYS_INLINE void ADD_FLOAT() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVRegFloat(inst->VRegA_23x(inst_data), |
| shadow_frame.GetVRegFloat(inst->VRegB_23x()) + |
| shadow_frame.GetVRegFloat(inst->VRegC_23x())); |
| inst = inst->Next_2xx(); |
| } |
| |
| ALWAYS_INLINE void SUB_FLOAT() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVRegFloat(inst->VRegA_23x(inst_data), |
| shadow_frame.GetVRegFloat(inst->VRegB_23x()) - |
| shadow_frame.GetVRegFloat(inst->VRegC_23x())); |
| inst = inst->Next_2xx(); |
| } |
| |
| ALWAYS_INLINE void MUL_FLOAT() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVRegFloat(inst->VRegA_23x(inst_data), |
| shadow_frame.GetVRegFloat(inst->VRegB_23x()) * |
| shadow_frame.GetVRegFloat(inst->VRegC_23x())); |
| inst = inst->Next_2xx(); |
| } |
| |
| ALWAYS_INLINE void DIV_FLOAT() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVRegFloat(inst->VRegA_23x(inst_data), |
| shadow_frame.GetVRegFloat(inst->VRegB_23x()) / |
| shadow_frame.GetVRegFloat(inst->VRegC_23x())); |
| inst = inst->Next_2xx(); |
| } |
| |
| ALWAYS_INLINE void REM_FLOAT() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVRegFloat(inst->VRegA_23x(inst_data), |
| fmodf(shadow_frame.GetVRegFloat(inst->VRegB_23x()), |
| shadow_frame.GetVRegFloat(inst->VRegC_23x()))); |
| inst = inst->Next_2xx(); |
| } |
| |
| ALWAYS_INLINE void ADD_DOUBLE() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVRegDouble(inst->VRegA_23x(inst_data), |
| shadow_frame.GetVRegDouble(inst->VRegB_23x()) + |
| shadow_frame.GetVRegDouble(inst->VRegC_23x())); |
| inst = inst->Next_2xx(); |
| } |
| |
| ALWAYS_INLINE void SUB_DOUBLE() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVRegDouble(inst->VRegA_23x(inst_data), |
| shadow_frame.GetVRegDouble(inst->VRegB_23x()) - |
| shadow_frame.GetVRegDouble(inst->VRegC_23x())); |
| inst = inst->Next_2xx(); |
| } |
| |
| ALWAYS_INLINE void MUL_DOUBLE() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVRegDouble(inst->VRegA_23x(inst_data), |
| shadow_frame.GetVRegDouble(inst->VRegB_23x()) * |
| shadow_frame.GetVRegDouble(inst->VRegC_23x())); |
| inst = inst->Next_2xx(); |
| } |
| |
| ALWAYS_INLINE void DIV_DOUBLE() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVRegDouble(inst->VRegA_23x(inst_data), |
| shadow_frame.GetVRegDouble(inst->VRegB_23x()) / |
| shadow_frame.GetVRegDouble(inst->VRegC_23x())); |
| inst = inst->Next_2xx(); |
| } |
| |
| ALWAYS_INLINE void REM_DOUBLE() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVRegDouble(inst->VRegA_23x(inst_data), |
| fmod(shadow_frame.GetVRegDouble(inst->VRegB_23x()), |
| shadow_frame.GetVRegDouble(inst->VRegC_23x()))); |
| inst = inst->Next_2xx(); |
| } |
| |
| ALWAYS_INLINE void ADD_INT_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) { |
| uint4_t vregA = inst->VRegA_12x(inst_data); |
| shadow_frame.SetVReg(vregA, SafeAdd(shadow_frame.GetVReg(vregA), |
| shadow_frame.GetVReg(inst->VRegB_12x(inst_data)))); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void SUB_INT_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) { |
| uint4_t vregA = inst->VRegA_12x(inst_data); |
| shadow_frame.SetVReg(vregA, |
| SafeSub(shadow_frame.GetVReg(vregA), |
| shadow_frame.GetVReg(inst->VRegB_12x(inst_data)))); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void MUL_INT_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) { |
| uint4_t vregA = inst->VRegA_12x(inst_data); |
| shadow_frame.SetVReg(vregA, |
| SafeMul(shadow_frame.GetVReg(vregA), |
| shadow_frame.GetVReg(inst->VRegB_12x(inst_data)))); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void DIV_INT_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) { |
| uint4_t vregA = inst->VRegA_12x(inst_data); |
| bool success = DoIntDivide(shadow_frame, vregA, shadow_frame.GetVReg(vregA), |
| shadow_frame.GetVReg(inst->VRegB_12x(inst_data))); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_1xx); |
| } |
| |
| ALWAYS_INLINE void REM_INT_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) { |
| uint4_t vregA = inst->VRegA_12x(inst_data); |
| bool success = DoIntRemainder(shadow_frame, vregA, shadow_frame.GetVReg(vregA), |
| shadow_frame.GetVReg(inst->VRegB_12x(inst_data))); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_1xx); |
| } |
| |
| ALWAYS_INLINE void SHL_INT_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) { |
| uint4_t vregA = inst->VRegA_12x(inst_data); |
| shadow_frame.SetVReg(vregA, |
| shadow_frame.GetVReg(vregA) << |
| (shadow_frame.GetVReg(inst->VRegB_12x(inst_data)) & 0x1f)); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void SHR_INT_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) { |
| uint4_t vregA = inst->VRegA_12x(inst_data); |
| shadow_frame.SetVReg(vregA, |
| shadow_frame.GetVReg(vregA) >> |
| (shadow_frame.GetVReg(inst->VRegB_12x(inst_data)) & 0x1f)); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void USHR_INT_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) { |
| uint4_t vregA = inst->VRegA_12x(inst_data); |
| shadow_frame.SetVReg(vregA, |
| static_cast<uint32_t>(shadow_frame.GetVReg(vregA)) >> |
| (shadow_frame.GetVReg(inst->VRegB_12x(inst_data)) & 0x1f)); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void AND_INT_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) { |
| uint4_t vregA = inst->VRegA_12x(inst_data); |
| shadow_frame.SetVReg(vregA, |
| shadow_frame.GetVReg(vregA) & |
| shadow_frame.GetVReg(inst->VRegB_12x(inst_data))); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void OR_INT_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) { |
| uint4_t vregA = inst->VRegA_12x(inst_data); |
| shadow_frame.SetVReg(vregA, |
| shadow_frame.GetVReg(vregA) | |
| shadow_frame.GetVReg(inst->VRegB_12x(inst_data))); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void XOR_INT_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) { |
| uint4_t vregA = inst->VRegA_12x(inst_data); |
| shadow_frame.SetVReg(vregA, |
| shadow_frame.GetVReg(vregA) ^ |
| shadow_frame.GetVReg(inst->VRegB_12x(inst_data))); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void ADD_LONG_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) { |
| uint4_t vregA = inst->VRegA_12x(inst_data); |
| shadow_frame.SetVRegLong(vregA, |
| SafeAdd(shadow_frame.GetVRegLong(vregA), |
| shadow_frame.GetVRegLong(inst->VRegB_12x(inst_data)))); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void SUB_LONG_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) { |
| uint4_t vregA = inst->VRegA_12x(inst_data); |
| shadow_frame.SetVRegLong(vregA, |
| SafeSub(shadow_frame.GetVRegLong(vregA), |
| shadow_frame.GetVRegLong(inst->VRegB_12x(inst_data)))); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void MUL_LONG_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) { |
| uint4_t vregA = inst->VRegA_12x(inst_data); |
| shadow_frame.SetVRegLong(vregA, |
| SafeMul(shadow_frame.GetVRegLong(vregA), |
| shadow_frame.GetVRegLong(inst->VRegB_12x(inst_data)))); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void DIV_LONG_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) { |
| uint4_t vregA = inst->VRegA_12x(inst_data); |
| DoLongDivide(shadow_frame, vregA, shadow_frame.GetVRegLong(vregA), |
| shadow_frame.GetVRegLong(inst->VRegB_12x(inst_data))); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(self->IsExceptionPending(), Next_1xx); |
| } |
| |
| ALWAYS_INLINE void REM_LONG_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) { |
| uint4_t vregA = inst->VRegA_12x(inst_data); |
| DoLongRemainder(shadow_frame, vregA, shadow_frame.GetVRegLong(vregA), |
| shadow_frame.GetVRegLong(inst->VRegB_12x(inst_data))); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(self->IsExceptionPending(), Next_1xx); |
| } |
| |
| ALWAYS_INLINE void AND_LONG_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) { |
| uint4_t vregA = inst->VRegA_12x(inst_data); |
| shadow_frame.SetVRegLong(vregA, |
| shadow_frame.GetVRegLong(vregA) & |
| shadow_frame.GetVRegLong(inst->VRegB_12x(inst_data))); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void OR_LONG_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) { |
| uint4_t vregA = inst->VRegA_12x(inst_data); |
| shadow_frame.SetVRegLong(vregA, |
| shadow_frame.GetVRegLong(vregA) | |
| shadow_frame.GetVRegLong(inst->VRegB_12x(inst_data))); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void XOR_LONG_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) { |
| uint4_t vregA = inst->VRegA_12x(inst_data); |
| shadow_frame.SetVRegLong(vregA, |
| shadow_frame.GetVRegLong(vregA) ^ |
| shadow_frame.GetVRegLong(inst->VRegB_12x(inst_data))); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void SHL_LONG_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) { |
| uint4_t vregA = inst->VRegA_12x(inst_data); |
| shadow_frame.SetVRegLong(vregA, |
| shadow_frame.GetVRegLong(vregA) << |
| (shadow_frame.GetVReg(inst->VRegB_12x(inst_data)) & 0x3f)); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void SHR_LONG_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) { |
| uint4_t vregA = inst->VRegA_12x(inst_data); |
| shadow_frame.SetVRegLong(vregA, |
| shadow_frame.GetVRegLong(vregA) >> |
| (shadow_frame.GetVReg(inst->VRegB_12x(inst_data)) & 0x3f)); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void USHR_LONG_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) { |
| uint4_t vregA = inst->VRegA_12x(inst_data); |
| shadow_frame.SetVRegLong(vregA, |
| static_cast<uint64_t>(shadow_frame.GetVRegLong(vregA)) >> |
| (shadow_frame.GetVReg(inst->VRegB_12x(inst_data)) & 0x3f)); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void ADD_FLOAT_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) { |
| uint4_t vregA = inst->VRegA_12x(inst_data); |
| shadow_frame.SetVRegFloat(vregA, |
| shadow_frame.GetVRegFloat(vregA) + |
| shadow_frame.GetVRegFloat(inst->VRegB_12x(inst_data))); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void SUB_FLOAT_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) { |
| uint4_t vregA = inst->VRegA_12x(inst_data); |
| shadow_frame.SetVRegFloat(vregA, |
| shadow_frame.GetVRegFloat(vregA) - |
| shadow_frame.GetVRegFloat(inst->VRegB_12x(inst_data))); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void MUL_FLOAT_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) { |
| uint4_t vregA = inst->VRegA_12x(inst_data); |
| shadow_frame.SetVRegFloat(vregA, |
| shadow_frame.GetVRegFloat(vregA) * |
| shadow_frame.GetVRegFloat(inst->VRegB_12x(inst_data))); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void DIV_FLOAT_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) { |
| uint4_t vregA = inst->VRegA_12x(inst_data); |
| shadow_frame.SetVRegFloat(vregA, |
| shadow_frame.GetVRegFloat(vregA) / |
| shadow_frame.GetVRegFloat(inst->VRegB_12x(inst_data))); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void REM_FLOAT_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) { |
| uint4_t vregA = inst->VRegA_12x(inst_data); |
| shadow_frame.SetVRegFloat(vregA, |
| fmodf(shadow_frame.GetVRegFloat(vregA), |
| shadow_frame.GetVRegFloat(inst->VRegB_12x(inst_data)))); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void ADD_DOUBLE_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) { |
| uint4_t vregA = inst->VRegA_12x(inst_data); |
| shadow_frame.SetVRegDouble(vregA, |
| shadow_frame.GetVRegDouble(vregA) + |
| shadow_frame.GetVRegDouble(inst->VRegB_12x(inst_data))); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void SUB_DOUBLE_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) { |
| uint4_t vregA = inst->VRegA_12x(inst_data); |
| shadow_frame.SetVRegDouble(vregA, |
| shadow_frame.GetVRegDouble(vregA) - |
| shadow_frame.GetVRegDouble(inst->VRegB_12x(inst_data))); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void MUL_DOUBLE_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) { |
| uint4_t vregA = inst->VRegA_12x(inst_data); |
| shadow_frame.SetVRegDouble(vregA, |
| shadow_frame.GetVRegDouble(vregA) * |
| shadow_frame.GetVRegDouble(inst->VRegB_12x(inst_data))); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void DIV_DOUBLE_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) { |
| uint4_t vregA = inst->VRegA_12x(inst_data); |
| shadow_frame.SetVRegDouble(vregA, |
| shadow_frame.GetVRegDouble(vregA) / |
| shadow_frame.GetVRegDouble(inst->VRegB_12x(inst_data))); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void REM_DOUBLE_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) { |
| uint4_t vregA = inst->VRegA_12x(inst_data); |
| shadow_frame.SetVRegDouble(vregA, |
| fmod(shadow_frame.GetVRegDouble(vregA), |
| shadow_frame.GetVRegDouble(inst->VRegB_12x(inst_data)))); |
| inst = inst->Next_1xx(); |
| } |
| |
| ALWAYS_INLINE void ADD_INT_LIT16() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVReg(inst->VRegA_22s(inst_data), |
| SafeAdd(shadow_frame.GetVReg(inst->VRegB_22s(inst_data)), |
| inst->VRegC_22s())); |
| inst = inst->Next_2xx(); |
| } |
| |
| ALWAYS_INLINE void RSUB_INT() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVReg(inst->VRegA_22s(inst_data), |
| SafeSub(inst->VRegC_22s(), |
| shadow_frame.GetVReg(inst->VRegB_22s(inst_data)))); |
| inst = inst->Next_2xx(); |
| } |
| |
| ALWAYS_INLINE void MUL_INT_LIT16() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVReg(inst->VRegA_22s(inst_data), |
| SafeMul(shadow_frame.GetVReg(inst->VRegB_22s(inst_data)), |
| inst->VRegC_22s())); |
| inst = inst->Next_2xx(); |
| } |
| |
| ALWAYS_INLINE void DIV_INT_LIT16() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoIntDivide(shadow_frame, inst->VRegA_22s(inst_data), |
| shadow_frame.GetVReg(inst->VRegB_22s(inst_data)), |
| inst->VRegC_22s()); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); |
| } |
| |
| ALWAYS_INLINE void REM_INT_LIT16() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoIntRemainder(shadow_frame, inst->VRegA_22s(inst_data), |
| shadow_frame.GetVReg(inst->VRegB_22s(inst_data)), |
| inst->VRegC_22s()); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); |
| } |
| |
| ALWAYS_INLINE void AND_INT_LIT16() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVReg(inst->VRegA_22s(inst_data), |
| shadow_frame.GetVReg(inst->VRegB_22s(inst_data)) & |
| inst->VRegC_22s()); |
| inst = inst->Next_2xx(); |
| } |
| |
| ALWAYS_INLINE void OR_INT_LIT16() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVReg(inst->VRegA_22s(inst_data), |
| shadow_frame.GetVReg(inst->VRegB_22s(inst_data)) | |
| inst->VRegC_22s()); |
| inst = inst->Next_2xx(); |
| } |
| |
| ALWAYS_INLINE void XOR_INT_LIT16() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVReg(inst->VRegA_22s(inst_data), |
| shadow_frame.GetVReg(inst->VRegB_22s(inst_data)) ^ |
| inst->VRegC_22s()); |
| inst = inst->Next_2xx(); |
| } |
| |
| ALWAYS_INLINE void ADD_INT_LIT8() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVReg(inst->VRegA_22b(inst_data), |
| SafeAdd(shadow_frame.GetVReg(inst->VRegB_22b()), inst->VRegC_22b())); |
| inst = inst->Next_2xx(); |
| } |
| |
| ALWAYS_INLINE void RSUB_INT_LIT8() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVReg(inst->VRegA_22b(inst_data), |
| SafeSub(inst->VRegC_22b(), shadow_frame.GetVReg(inst->VRegB_22b()))); |
| inst = inst->Next_2xx(); |
| } |
| |
| ALWAYS_INLINE void MUL_INT_LIT8() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVReg(inst->VRegA_22b(inst_data), |
| SafeMul(shadow_frame.GetVReg(inst->VRegB_22b()), inst->VRegC_22b())); |
| inst = inst->Next_2xx(); |
| } |
| |
| ALWAYS_INLINE void DIV_INT_LIT8() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoIntDivide(shadow_frame, inst->VRegA_22b(inst_data), |
| shadow_frame.GetVReg(inst->VRegB_22b()), inst->VRegC_22b()); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); |
| } |
| |
| ALWAYS_INLINE void REM_INT_LIT8() REQUIRES_SHARED(Locks::mutator_lock_) { |
| bool success = DoIntRemainder(shadow_frame, inst->VRegA_22b(inst_data), |
| shadow_frame.GetVReg(inst->VRegB_22b()), inst->VRegC_22b()); |
| POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx); |
| } |
| |
| ALWAYS_INLINE void AND_INT_LIT8() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVReg(inst->VRegA_22b(inst_data), |
| shadow_frame.GetVReg(inst->VRegB_22b()) & |
| inst->VRegC_22b()); |
| inst = inst->Next_2xx(); |
| } |
| |
| ALWAYS_INLINE void OR_INT_LIT8() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVReg(inst->VRegA_22b(inst_data), |
| shadow_frame.GetVReg(inst->VRegB_22b()) | |
| inst->VRegC_22b()); |
| inst = inst->Next_2xx(); |
| } |
| |
| ALWAYS_INLINE void XOR_INT_LIT8() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVReg(inst->VRegA_22b(inst_data), |
| shadow_frame.GetVReg(inst->VRegB_22b()) ^ |
| inst->VRegC_22b()); |
| inst = inst->Next_2xx(); |
| } |
| |
| ALWAYS_INLINE void SHL_INT_LIT8() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVReg(inst->VRegA_22b(inst_data), |
| shadow_frame.GetVReg(inst->VRegB_22b()) << |
| (inst->VRegC_22b() & 0x1f)); |
| inst = inst->Next_2xx(); |
| } |
| |
| ALWAYS_INLINE void SHR_INT_LIT8() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVReg(inst->VRegA_22b(inst_data), |
| shadow_frame.GetVReg(inst->VRegB_22b()) >> |
| (inst->VRegC_22b() & 0x1f)); |
| inst = inst->Next_2xx(); |
| } |
| |
| ALWAYS_INLINE void USHR_INT_LIT8() REQUIRES_SHARED(Locks::mutator_lock_) { |
| shadow_frame.SetVReg(inst->VRegA_22b(inst_data), |
| static_cast<uint32_t>(shadow_frame.GetVReg(inst->VRegB_22b())) >> |
| (inst->VRegC_22b() & 0x1f)); |
| inst = inst->Next_2xx(); |
| } |
| |
| ALWAYS_INLINE void UNUSED_3E() REQUIRES_SHARED(Locks::mutator_lock_) { |
| UnexpectedOpcode(inst, shadow_frame); |
| } |
| |
| ALWAYS_INLINE void UNUSED_3F() REQUIRES_SHARED(Locks::mutator_lock_) { |
| UnexpectedOpcode(inst, shadow_frame); |
| } |
| |
| ALWAYS_INLINE void UNUSED_40() REQUIRES_SHARED(Locks::mutator_lock_) { |
| UnexpectedOpcode(inst, shadow_frame); |
| } |
| |
| ALWAYS_INLINE void UNUSED_41() REQUIRES_SHARED(Locks::mutator_lock_) { |
| UnexpectedOpcode(inst, shadow_frame); |
| } |
| |
| ALWAYS_INLINE void UNUSED_42() REQUIRES_SHARED(Locks::mutator_lock_) { |
| UnexpectedOpcode(inst, shadow_frame); |
| } |
| |
| ALWAYS_INLINE void UNUSED_43() REQUIRES_SHARED(Locks::mutator_lock_) { |
| UnexpectedOpcode(inst, shadow_frame); |
| } |
| |
| ALWAYS_INLINE void UNUSED_79() REQUIRES_SHARED(Locks::mutator_lock_) { |
| UnexpectedOpcode(inst, shadow_frame); |
| } |
| |
| ALWAYS_INLINE void UNUSED_7A() REQUIRES_SHARED(Locks::mutator_lock_) { |
| UnexpectedOpcode(inst, shadow_frame); |
| } |
| |
| ALWAYS_INLINE void UNUSED_F3() REQUIRES_SHARED(Locks::mutator_lock_) { |
| UnexpectedOpcode(inst, shadow_frame); |
| } |
| |
| ALWAYS_INLINE void UNUSED_F4() REQUIRES_SHARED(Locks::mutator_lock_) { |
| UnexpectedOpcode(inst, shadow_frame); |
| } |
| |
| ALWAYS_INLINE void UNUSED_F5() REQUIRES_SHARED(Locks::mutator_lock_) { |
| UnexpectedOpcode(inst, shadow_frame); |
| } |
| |
| ALWAYS_INLINE void UNUSED_F6() REQUIRES_SHARED(Locks::mutator_lock_) { |
| UnexpectedOpcode(inst, shadow_frame); |
| } |
| |
| ALWAYS_INLINE void UNUSED_F7() REQUIRES_SHARED(Locks::mutator_lock_) { |
| UnexpectedOpcode(inst, shadow_frame); |
| } |
| |
| ALWAYS_INLINE void UNUSED_F8() REQUIRES_SHARED(Locks::mutator_lock_) { |
| UnexpectedOpcode(inst, shadow_frame); |
| } |
| |
| ALWAYS_INLINE void UNUSED_F9() REQUIRES_SHARED(Locks::mutator_lock_) { |
| UnexpectedOpcode(inst, shadow_frame); |
| } |
| |
| ALWAYS_INLINE InstructionHandler(SwitchImplContext* ctx, |
| const instrumentation::Instrumentation* instrumentation, |
| Thread* self, |
| ShadowFrame& shadow_frame, |
| uint16_t dex_pc, |
| const Instruction*& inst, |
| uint16_t inst_data, |
| bool& exit_interpreter_loop) |
| : ctx(ctx), |
| instrumentation(instrumentation), |
| self(self), |
| shadow_frame(shadow_frame), |
| dex_pc(dex_pc), |
| inst(inst), |
| inst_data(inst_data), |
| exit_interpreter_loop(exit_interpreter_loop) { |
| } |
| |
| private: |
| static constexpr bool do_assignability_check = do_access_check; |
| |
| const CodeItemDataAccessor& Accessor() { return ctx->accessor; } |
| const uint16_t* Insns() { return ctx->accessor.Insns(); } |
| JValue* ResultRegister() { return &ctx->result_register; } |
| |
| SwitchImplContext* const ctx; |
| const instrumentation::Instrumentation* const instrumentation; |
| Thread* const self; |
| ShadowFrame& shadow_frame; |
| uint32_t const dex_pc; |
| const Instruction*& inst; |
| uint16_t const inst_data; |
| bool& exit_interpreter_loop; |
| }; |
| |
| #undef BRANCH_INSTRUMENTATION |
| #undef POSSIBLY_HANDLE_PENDING_EXCEPTION |
| #undef POSSIBLY_HANDLE_PENDING_EXCEPTION_ON_INVOKE |
| #undef POSSIBLY_HANDLE_PENDING_EXCEPTION_ON_INVOKE_POLYMORPHIC |
| #undef HANDLE_PENDING_EXCEPTION |
| |
| // TODO On ASAN builds this function gets a huge stack frame. Since normally we run in the mterp |
| // this shouldn't cause any problems for stack overflow detection. Remove this once b/117341496 is |
| // fixed. |
| template<bool do_access_check, bool transaction_active> |
| ATTRIBUTE_NO_SANITIZE_ADDRESS void ExecuteSwitchImplCpp(SwitchImplContext* ctx) { |
| Thread* self = ctx->self; |
| const CodeItemDataAccessor& accessor = ctx->accessor; |
| ShadowFrame& shadow_frame = ctx->shadow_frame; |
| if (UNLIKELY(!shadow_frame.HasReferenceArray())) { |
| LOG(FATAL) << "Invalid shadow frame for interpreter use"; |
| ctx->result = JValue(); |
| return; |
| } |
| self->VerifyStack(); |
| |
| uint32_t dex_pc = shadow_frame.GetDexPC(); |
| const auto* const instrumentation = Runtime::Current()->GetInstrumentation(); |
| const uint16_t* const insns = accessor.Insns(); |
| const Instruction* inst = Instruction::At(insns + dex_pc); |
| uint16_t inst_data; |
| |
| DCHECK(!shadow_frame.GetForceRetryInstruction()) |
| << "Entered interpreter from invoke without retry instruction being handled!"; |
| |
| bool const interpret_one_instruction = ctx->interpret_one_instruction; |
| while (true) { |
| dex_pc = inst->GetDexPc(insns); |
| shadow_frame.SetDexPC(dex_pc); |
| TraceExecution(shadow_frame, inst, dex_pc); |
| inst_data = inst->Fetch16(0); |
| { |
| bool exit_loop = false; |
| InstructionHandler<do_access_check, transaction_active> handler( |
| ctx, instrumentation, self, shadow_frame, dex_pc, inst, inst_data, exit_loop); |
| if (!handler.Preamble()) { |
| if (UNLIKELY(exit_loop)) { |
| return; |
| } |
| if (UNLIKELY(interpret_one_instruction)) { |
| break; |
| } |
| continue; |
| } |
| } |
| switch (inst->Opcode(inst_data)) { |
| #define OPCODE_CASE(OPCODE, OPCODE_NAME, pname, f, i, a, e, v) \ |
| case OPCODE: { \ |
| bool exit_loop = false; \ |
| InstructionHandler<do_access_check, transaction_active> handler( \ |
| ctx, instrumentation, self, shadow_frame, dex_pc, inst, inst_data, exit_loop); \ |
| handler.OPCODE_NAME(); \ |
| /* TODO: Advance 'inst' here, instead of explicitly in each handler */ \ |
| if (UNLIKELY(exit_loop)) { \ |
| return; \ |
| } \ |
| break; \ |
| } |
| DEX_INSTRUCTION_LIST(OPCODE_CASE) |
| #undef OPCODE_CASE |
| } |
| if (UNLIKELY(interpret_one_instruction)) { |
| break; |
| } |
| } |
| // Record where we stopped. |
| shadow_frame.SetDexPC(inst->GetDexPc(insns)); |
| ctx->result = ctx->result_register; |
| return; |
| } // NOLINT(readability/fn_size) |
| |
| } // namespace interpreter |
| } // namespace art |
| |
| #endif // ART_RUNTIME_INTERPRETER_INTERPRETER_SWITCH_IMPL_INL_H_ |