Switch-interpreter: Add boolean return value to opcodes.
Currently unused - this is in preparation for future CLs.
The intention is that "return false" must always immediately
propagate all the way to the main loop, which can then use
it to handle abnormal cases in uniform and localized way.
Test: ./art/test.py -b --host --64 --interpreter
Change-Id: I21b0a26b08488add0af4825469f68c6cbf507106
diff --git a/runtime/interpreter/interpreter_switch_impl-inl.h b/runtime/interpreter/interpreter_switch_impl-inl.h
index c584127..2ba5a48 100644
--- a/runtime/interpreter/interpreter_switch_impl-inl.h
+++ b/runtime/interpreter/interpreter_switch_impl-inl.h
@@ -368,106 +368,120 @@
#define BRANCH_INSTRUMENTATION(offset) \
if (!BranchInstrumentation(offset)) { \
- return; \
+ return false; \
}
#define HANDLE_PENDING_EXCEPTION() \
if (!HandlePendingException()) { \
- return; \
+ return false; \
}
#define POSSIBLY_HANDLE_PENDING_EXCEPTION(is_exception_pending, next_function) \
if (!PossiblyHandlePendingException(is_exception_pending, inst->next_function())) { \
- return; \
+ return false; \
}
#define POSSIBLY_HANDLE_PENDING_EXCEPTION_ON_INVOKE_POLYMORPHIC(is_exception_pending) \
if (!PossiblyHandlePendingExceptionOnInvokeImpl(is_exception_pending, inst->Next_4xx())) { \
- return; \
+ return false; \
}
#define POSSIBLY_HANDLE_PENDING_EXCEPTION_ON_INVOKE(is_exception_pending) \
if (!PossiblyHandlePendingExceptionOnInvokeImpl(is_exception_pending, inst->Next_3xx())) { \
- return; \
+ return false; \
}
- ALWAYS_INLINE void NOP() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool NOP() REQUIRES_SHARED(Locks::mutator_lock_) {
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void MOVE() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool MOVE() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVReg(A(), GetVReg(B()));
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void MOVE_FROM16() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool MOVE_FROM16() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVReg(A(), GetVReg(B()));
inst = inst->Next_2xx();
+ return true;
}
- ALWAYS_INLINE void MOVE_16() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool MOVE_16() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVReg(A(), GetVReg(B()));
inst = inst->Next_3xx();
+ return true;
}
- ALWAYS_INLINE void MOVE_WIDE() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool MOVE_WIDE() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVRegLong(A(), GetVRegLong(B()));
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void MOVE_WIDE_FROM16() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool MOVE_WIDE_FROM16() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVRegLong(A(), GetVRegLong(B()));
inst = inst->Next_2xx();
+ return true;
}
- ALWAYS_INLINE void MOVE_WIDE_16() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool MOVE_WIDE_16() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVRegLong(A(), GetVRegLong(B()));
inst = inst->Next_3xx();
+ return true;
}
- ALWAYS_INLINE void MOVE_OBJECT() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool MOVE_OBJECT() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVRegReference(A(), GetVRegReference(B()));
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void MOVE_OBJECT_FROM16() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool MOVE_OBJECT_FROM16() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVRegReference(A(), GetVRegReference(B()));
inst = inst->Next_2xx();
+ return true;
}
- ALWAYS_INLINE void MOVE_OBJECT_16() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool MOVE_OBJECT_16() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVRegReference(A(), GetVRegReference(B()));
inst = inst->Next_3xx();
+ return true;
}
- ALWAYS_INLINE void MOVE_RESULT() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool MOVE_RESULT() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVReg(A(), ResultRegister()->GetI());
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void MOVE_RESULT_WIDE() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool MOVE_RESULT_WIDE() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVRegLong(A(), ResultRegister()->GetJ());
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void MOVE_RESULT_OBJECT() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool MOVE_RESULT_OBJECT() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVRegReference(A(), ResultRegister()->GetL());
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void MOVE_EXCEPTION() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool MOVE_EXCEPTION() REQUIRES_SHARED(Locks::mutator_lock_) {
ObjPtr<mirror::Throwable> exception = self->GetException();
DCHECK(exception != nullptr) << "No pending exception on MOVE_EXCEPTION instruction";
SetVRegReference(A(), exception);
self->ClearException();
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void RETURN_VOID_NO_BARRIER() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool RETURN_VOID_NO_BARRIER() REQUIRES_SHARED(Locks::mutator_lock_) {
JValue result;
self->AllowThreadSuspension();
if (!HandleMonitorChecks()) {
- return;
+ return false;
}
if (UNLIKELY(NeedsMethodExitEvent(instrumentation) &&
!SendMethodExitEvents(self,
@@ -478,7 +492,7 @@
inst->GetDexPc(Insns()),
result))) {
if (!HandlePendingExceptionWithInstrumentation(nullptr)) {
- return;
+ return false;
}
}
if (ctx->interpret_one_instruction) {
@@ -487,14 +501,15 @@
}
ctx->result = result;
exit_interpreter_loop = true;
+ return true;
}
- ALWAYS_INLINE void RETURN_VOID() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool RETURN_VOID() REQUIRES_SHARED(Locks::mutator_lock_) {
QuasiAtomic::ThreadFenceForConstructor();
JValue result;
self->AllowThreadSuspension();
if (!HandleMonitorChecks()) {
- return;
+ return false;
}
if (UNLIKELY(NeedsMethodExitEvent(instrumentation) &&
!SendMethodExitEvents(self,
@@ -505,7 +520,7 @@
inst->GetDexPc(Insns()),
result))) {
if (!HandlePendingExceptionWithInstrumentation(nullptr)) {
- return;
+ return false;
}
}
if (ctx->interpret_one_instruction) {
@@ -514,15 +529,16 @@
}
ctx->result = result;
exit_interpreter_loop = true;
+ return true;
}
- ALWAYS_INLINE void RETURN() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool RETURN() REQUIRES_SHARED(Locks::mutator_lock_) {
JValue result;
result.SetJ(0);
result.SetI(GetVReg(A()));
self->AllowThreadSuspension();
if (!HandleMonitorChecks()) {
- return;
+ return false;
}
if (UNLIKELY(NeedsMethodExitEvent(instrumentation) &&
!SendMethodExitEvents(self,
@@ -533,7 +549,7 @@
inst->GetDexPc(Insns()),
result))) {
if (!HandlePendingExceptionWithInstrumentation(nullptr)) {
- return;
+ return false;
}
}
if (ctx->interpret_one_instruction) {
@@ -542,14 +558,15 @@
}
ctx->result = result;
exit_interpreter_loop = true;
+ return true;
}
- ALWAYS_INLINE void RETURN_WIDE() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool RETURN_WIDE() REQUIRES_SHARED(Locks::mutator_lock_) {
JValue result;
result.SetJ(GetVRegLong(A()));
self->AllowThreadSuspension();
if (!HandleMonitorChecks()) {
- return;
+ return false;
}
if (UNLIKELY(NeedsMethodExitEvent(instrumentation) &&
!SendMethodExitEvents(self,
@@ -560,7 +577,7 @@
inst->GetDexPc(Insns()),
result))) {
if (!HandlePendingExceptionWithInstrumentation(nullptr)) {
- return;
+ return false;
}
}
if (ctx->interpret_one_instruction) {
@@ -569,13 +586,14 @@
}
ctx->result = result;
exit_interpreter_loop = true;
+ return true;
}
- ALWAYS_INLINE void RETURN_OBJECT() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool RETURN_OBJECT() REQUIRES_SHARED(Locks::mutator_lock_) {
JValue result;
self->AllowThreadSuspension();
if (!HandleMonitorChecks()) {
- return;
+ return false;
}
const size_t ref_idx = A();
ObjPtr<mirror::Object> obj_result = GetVRegReference(ref_idx);
@@ -607,7 +625,7 @@
inst->GetDexPc(Insns()),
result))) {
if (!HandlePendingExceptionWithInstrumentation(nullptr)) {
- return;
+ return false;
}
}
// Re-load since it might have moved during the MethodExitEvent.
@@ -618,9 +636,10 @@
}
ctx->result = result;
exit_interpreter_loop = true;
+ return true;
}
- ALWAYS_INLINE void CONST_4() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool CONST_4() REQUIRES_SHARED(Locks::mutator_lock_) {
uint4_t dst = inst->VRegA_11n(inst_data);
int4_t val = inst->VRegB_11n(inst_data);
SetVReg(dst, val);
@@ -628,9 +647,10 @@
SetVRegReference(dst, nullptr);
}
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void CONST_16() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool CONST_16() REQUIRES_SHARED(Locks::mutator_lock_) {
uint8_t dst = A();
int16_t val = B();
SetVReg(dst, val);
@@ -638,9 +658,10 @@
SetVRegReference(dst, nullptr);
}
inst = inst->Next_2xx();
+ return true;
}
- ALWAYS_INLINE void CONST() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool CONST() REQUIRES_SHARED(Locks::mutator_lock_) {
uint8_t dst = A();
int32_t val = B();
SetVReg(dst, val);
@@ -648,9 +669,10 @@
SetVRegReference(dst, nullptr);
}
inst = inst->Next_3xx();
+ return true;
}
- ALWAYS_INLINE void CONST_HIGH16() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool CONST_HIGH16() REQUIRES_SHARED(Locks::mutator_lock_) {
uint8_t dst = A();
int32_t val = static_cast<int32_t>(B() << 16);
SetVReg(dst, val);
@@ -658,29 +680,34 @@
SetVRegReference(dst, nullptr);
}
inst = inst->Next_2xx();
+ return true;
}
- ALWAYS_INLINE void CONST_WIDE_16() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool CONST_WIDE_16() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVRegLong(A(), B());
inst = inst->Next_2xx();
+ return true;
}
- ALWAYS_INLINE void CONST_WIDE_32() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool CONST_WIDE_32() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVRegLong(A(), B());
inst = inst->Next_3xx();
+ return true;
}
- ALWAYS_INLINE void CONST_WIDE() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool CONST_WIDE() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVRegLong(A(), inst->WideVRegB());
inst = inst->Next_51l();
+ return true;
}
- ALWAYS_INLINE void CONST_WIDE_HIGH16() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool CONST_WIDE_HIGH16() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVRegLong(A(), static_cast<uint64_t>(B()) << 48);
inst = inst->Next_2xx();
+ return true;
}
- ALWAYS_INLINE void CONST_STRING() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool CONST_STRING() REQUIRES_SHARED(Locks::mutator_lock_) {
ObjPtr<mirror::String> s = ResolveString(self, shadow_frame, dex::StringIndex(B()));
if (UNLIKELY(s == nullptr)) {
HANDLE_PENDING_EXCEPTION();
@@ -688,9 +715,10 @@
SetVRegReference(A(), s);
inst = inst->Next_2xx();
}
+ return true;
}
- ALWAYS_INLINE void CONST_STRING_JUMBO() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool CONST_STRING_JUMBO() REQUIRES_SHARED(Locks::mutator_lock_) {
ObjPtr<mirror::String> s = ResolveString(self, shadow_frame, dex::StringIndex(B()));
if (UNLIKELY(s == nullptr)) {
HANDLE_PENDING_EXCEPTION();
@@ -698,9 +726,10 @@
SetVRegReference(A(), s);
inst = inst->Next_3xx();
}
+ return true;
}
- ALWAYS_INLINE void CONST_CLASS() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool CONST_CLASS() REQUIRES_SHARED(Locks::mutator_lock_) {
ObjPtr<mirror::Class> c = ResolveVerifyAndClinit(dex::TypeIndex(B()),
shadow_frame.GetMethod(),
self,
@@ -712,9 +741,10 @@
SetVRegReference(A(), c);
inst = inst->Next_2xx();
}
+ return true;
}
- ALWAYS_INLINE void CONST_METHOD_HANDLE() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool CONST_METHOD_HANDLE() REQUIRES_SHARED(Locks::mutator_lock_) {
ClassLinker* cl = Runtime::Current()->GetClassLinker();
ObjPtr<mirror::MethodHandle> mh = cl->ResolveMethodHandle(self,
B(),
@@ -725,9 +755,10 @@
SetVRegReference(A(), mh);
inst = inst->Next_2xx();
}
+ return true;
}
- ALWAYS_INLINE void CONST_METHOD_TYPE() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool CONST_METHOD_TYPE() REQUIRES_SHARED(Locks::mutator_lock_) {
ClassLinker* cl = Runtime::Current()->GetClassLinker();
ObjPtr<mirror::MethodType> mt = cl->ResolveMethodType(self,
dex::ProtoIndex(B()),
@@ -738,11 +769,12 @@
SetVRegReference(A(), mt);
inst = inst->Next_2xx();
}
+ return true;
}
- ALWAYS_INLINE void MONITOR_ENTER() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool MONITOR_ENTER() REQUIRES_SHARED(Locks::mutator_lock_) {
if (!HandleAsyncException()) {
- return;
+ return false;
}
ObjPtr<mirror::Object> obj = GetVRegReference(A());
if (UNLIKELY(obj == nullptr)) {
@@ -752,11 +784,12 @@
DoMonitorEnter<do_assignability_check>(self, &shadow_frame, obj);
POSSIBLY_HANDLE_PENDING_EXCEPTION(self->IsExceptionPending(), Next_1xx);
}
+ return true;
}
- ALWAYS_INLINE void MONITOR_EXIT() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool MONITOR_EXIT() REQUIRES_SHARED(Locks::mutator_lock_) {
if (!HandleAsyncException()) {
- return;
+ return false;
}
ObjPtr<mirror::Object> obj = GetVRegReference(A());
if (UNLIKELY(obj == nullptr)) {
@@ -766,9 +799,10 @@
DoMonitorExit<do_assignability_check>(self, &shadow_frame, obj);
POSSIBLY_HANDLE_PENDING_EXCEPTION(self->IsExceptionPending(), Next_1xx);
}
+ return true;
}
- ALWAYS_INLINE void CHECK_CAST() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool CHECK_CAST() REQUIRES_SHARED(Locks::mutator_lock_) {
ObjPtr<mirror::Class> c = ResolveVerifyAndClinit(dex::TypeIndex(B()),
shadow_frame.GetMethod(),
self,
@@ -785,9 +819,10 @@
inst = inst->Next_2xx();
}
}
+ return true;
}
- ALWAYS_INLINE void INSTANCE_OF() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool INSTANCE_OF() REQUIRES_SHARED(Locks::mutator_lock_) {
ObjPtr<mirror::Class> c = ResolveVerifyAndClinit(dex::TypeIndex(C()),
shadow_frame.GetMethod(),
self,
@@ -800,9 +835,10 @@
SetVReg(A(), (obj != nullptr && obj->InstanceOf(c)) ? 1 : 0);
inst = inst->Next_2xx();
}
+ return true;
}
- ALWAYS_INLINE void ARRAY_LENGTH() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool ARRAY_LENGTH() REQUIRES_SHARED(Locks::mutator_lock_) {
ObjPtr<mirror::Object> array = GetVRegReference(B());
if (UNLIKELY(array == nullptr)) {
ThrowNullPointerExceptionFromInterpreter();
@@ -811,9 +847,10 @@
SetVReg(A(), array->AsArray()->GetLength());
inst = inst->Next_1xx();
}
+ return true;
}
- ALWAYS_INLINE void NEW_INSTANCE() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool NEW_INSTANCE() REQUIRES_SHARED(Locks::mutator_lock_) {
ObjPtr<mirror::Object> obj = nullptr;
ObjPtr<mirror::Class> c = ResolveVerifyAndClinit(dex::TypeIndex(B()),
shadow_frame.GetMethod(),
@@ -842,9 +879,10 @@
SetVRegReference(A(), obj);
inst = inst->Next_2xx();
}
+ return true;
}
- ALWAYS_INLINE void NEW_ARRAY() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool NEW_ARRAY() REQUIRES_SHARED(Locks::mutator_lock_) {
int32_t length = GetVReg(B());
ObjPtr<mirror::Object> obj = AllocArrayFromCode<do_access_check>(
dex::TypeIndex(C()),
@@ -858,23 +896,26 @@
SetVRegReference(A(), obj);
inst = inst->Next_2xx();
}
+ return true;
}
- ALWAYS_INLINE void FILLED_NEW_ARRAY() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void FILLED_NEW_ARRAY_RANGE() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void FILL_ARRAY_DATA() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool FILL_ARRAY_DATA() REQUIRES_SHARED(Locks::mutator_lock_) {
const uint16_t* payload_addr = reinterpret_cast<const uint16_t*>(inst) + B();
const Instruction::ArrayDataPayload* payload =
reinterpret_cast<const Instruction::ArrayDataPayload*>(payload_addr);
@@ -887,11 +928,12 @@
RecordArrayElementsInTransaction(obj->AsArray(), payload->element_count);
}
inst = inst->Next_3xx();
+ return true;
}
- ALWAYS_INLINE void THROW() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool THROW() REQUIRES_SHARED(Locks::mutator_lock_) {
if (!HandleAsyncException()) {
- return;
+ return false;
}
ObjPtr<mirror::Object> exception = GetVRegReference(A());
if (UNLIKELY(exception == nullptr)) {
@@ -906,56 +948,62 @@
self->SetException(exception->AsThrowable());
}
HANDLE_PENDING_EXCEPTION();
+ return true;
}
- ALWAYS_INLINE void GOTO() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool GOTO() REQUIRES_SHARED(Locks::mutator_lock_) {
if (!HandleAsyncException()) {
- return;
+ return false;
}
int8_t offset = A();
BRANCH_INSTRUMENTATION(offset);
inst = inst->RelativeAt(offset);
HandleBackwardBranch(offset);
+ return true;
}
- ALWAYS_INLINE void GOTO_16() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool GOTO_16() REQUIRES_SHARED(Locks::mutator_lock_) {
if (!HandleAsyncException()) {
- return;
+ return false;
}
int16_t offset = A();
BRANCH_INSTRUMENTATION(offset);
inst = inst->RelativeAt(offset);
HandleBackwardBranch(offset);
+ return true;
}
- ALWAYS_INLINE void GOTO_32() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool GOTO_32() REQUIRES_SHARED(Locks::mutator_lock_) {
if (!HandleAsyncException()) {
- return;
+ return false;
}
int32_t offset = A();
BRANCH_INSTRUMENTATION(offset);
inst = inst->RelativeAt(offset);
HandleBackwardBranch(offset);
+ return true;
}
- ALWAYS_INLINE void PACKED_SWITCH() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void SPARSE_SWITCH() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wfloat-equal"
- ALWAYS_INLINE void CMPL_FLOAT() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool CMPL_FLOAT() REQUIRES_SHARED(Locks::mutator_lock_) {
float val1 = GetVRegFloat(B());
float val2 = GetVRegFloat(C());
int32_t result;
@@ -968,9 +1016,10 @@
}
SetVReg(A(), result);
inst = inst->Next_2xx();
+ return true;
}
- ALWAYS_INLINE void CMPG_FLOAT() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool CMPG_FLOAT() REQUIRES_SHARED(Locks::mutator_lock_) {
float val1 = GetVRegFloat(B());
float val2 = GetVRegFloat(C());
int32_t result;
@@ -983,9 +1032,10 @@
}
SetVReg(A(), result);
inst = inst->Next_2xx();
+ return true;
}
- ALWAYS_INLINE void CMPL_DOUBLE() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool CMPL_DOUBLE() REQUIRES_SHARED(Locks::mutator_lock_) {
double val1 = GetVRegDouble(B());
double val2 = GetVRegDouble(C());
int32_t result;
@@ -998,9 +1048,10 @@
}
SetVReg(A(), result);
inst = inst->Next_2xx();
+ return true;
}
- ALWAYS_INLINE void CMPG_DOUBLE() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool CMPG_DOUBLE() REQUIRES_SHARED(Locks::mutator_lock_) {
double val1 = GetVRegDouble(B());
double val2 = GetVRegDouble(C());
int32_t result;
@@ -1013,11 +1064,12 @@
}
SetVReg(A(), result);
inst = inst->Next_2xx();
+ return true;
}
#pragma clang diagnostic pop
- ALWAYS_INLINE void CMP_LONG() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool CMP_LONG() REQUIRES_SHARED(Locks::mutator_lock_) {
int64_t val1 = GetVRegLong(B());
int64_t val2 = GetVRegLong(C());
int32_t result;
@@ -1030,9 +1082,10 @@
}
SetVReg(A(), result);
inst = inst->Next_2xx();
+ return true;
}
- ALWAYS_INLINE void IF_EQ() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool IF_EQ() REQUIRES_SHARED(Locks::mutator_lock_) {
if (GetVReg(A()) == GetVReg(B())) {
int16_t offset = C();
BRANCH_INSTRUMENTATION(offset);
@@ -1042,9 +1095,10 @@
BRANCH_INSTRUMENTATION(2);
inst = inst->Next_2xx();
}
+ return true;
}
- ALWAYS_INLINE void IF_NE() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool IF_NE() REQUIRES_SHARED(Locks::mutator_lock_) {
if (GetVReg(A()) != GetVReg(B())) {
int16_t offset = C();
BRANCH_INSTRUMENTATION(offset);
@@ -1054,9 +1108,10 @@
BRANCH_INSTRUMENTATION(2);
inst = inst->Next_2xx();
}
+ return true;
}
- ALWAYS_INLINE void IF_LT() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool IF_LT() REQUIRES_SHARED(Locks::mutator_lock_) {
if (GetVReg(A()) < GetVReg(B())) {
int16_t offset = C();
BRANCH_INSTRUMENTATION(offset);
@@ -1066,9 +1121,10 @@
BRANCH_INSTRUMENTATION(2);
inst = inst->Next_2xx();
}
+ return true;
}
- ALWAYS_INLINE void IF_GE() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool IF_GE() REQUIRES_SHARED(Locks::mutator_lock_) {
if (GetVReg(A()) >= GetVReg(B())) {
int16_t offset = C();
BRANCH_INSTRUMENTATION(offset);
@@ -1078,9 +1134,10 @@
BRANCH_INSTRUMENTATION(2);
inst = inst->Next_2xx();
}
+ return true;
}
- ALWAYS_INLINE void IF_GT() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool IF_GT() REQUIRES_SHARED(Locks::mutator_lock_) {
if (GetVReg(A()) > GetVReg(B())) {
int16_t offset = C();
BRANCH_INSTRUMENTATION(offset);
@@ -1090,9 +1147,10 @@
BRANCH_INSTRUMENTATION(2);
inst = inst->Next_2xx();
}
+ return true;
}
- ALWAYS_INLINE void IF_LE() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool IF_LE() REQUIRES_SHARED(Locks::mutator_lock_) {
if (GetVReg(A()) <= GetVReg(B())) {
int16_t offset = C();
BRANCH_INSTRUMENTATION(offset);
@@ -1102,9 +1160,10 @@
BRANCH_INSTRUMENTATION(2);
inst = inst->Next_2xx();
}
+ return true;
}
- ALWAYS_INLINE void IF_EQZ() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool IF_EQZ() REQUIRES_SHARED(Locks::mutator_lock_) {
if (GetVReg(A()) == 0) {
int16_t offset = B();
BRANCH_INSTRUMENTATION(offset);
@@ -1114,9 +1173,10 @@
BRANCH_INSTRUMENTATION(2);
inst = inst->Next_2xx();
}
+ return true;
}
- ALWAYS_INLINE void IF_NEZ() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool IF_NEZ() REQUIRES_SHARED(Locks::mutator_lock_) {
if (GetVReg(A()) != 0) {
int16_t offset = B();
BRANCH_INSTRUMENTATION(offset);
@@ -1126,9 +1186,10 @@
BRANCH_INSTRUMENTATION(2);
inst = inst->Next_2xx();
}
+ return true;
}
- ALWAYS_INLINE void IF_LTZ() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool IF_LTZ() REQUIRES_SHARED(Locks::mutator_lock_) {
if (GetVReg(A()) < 0) {
int16_t offset = B();
BRANCH_INSTRUMENTATION(offset);
@@ -1138,9 +1199,10 @@
BRANCH_INSTRUMENTATION(2);
inst = inst->Next_2xx();
}
+ return true;
}
- ALWAYS_INLINE void IF_GEZ() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool IF_GEZ() REQUIRES_SHARED(Locks::mutator_lock_) {
if (GetVReg(A()) >= 0) {
int16_t offset = B();
BRANCH_INSTRUMENTATION(offset);
@@ -1150,9 +1212,10 @@
BRANCH_INSTRUMENTATION(2);
inst = inst->Next_2xx();
}
+ return true;
}
- ALWAYS_INLINE void IF_GTZ() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool IF_GTZ() REQUIRES_SHARED(Locks::mutator_lock_) {
if (GetVReg(A()) > 0) {
int16_t offset = B();
BRANCH_INSTRUMENTATION(offset);
@@ -1162,9 +1225,10 @@
BRANCH_INSTRUMENTATION(2);
inst = inst->Next_2xx();
}
+ return true;
}
- ALWAYS_INLINE void IF_LEZ() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool IF_LEZ() REQUIRES_SHARED(Locks::mutator_lock_) {
if (GetVReg(A()) <= 0) {
int16_t offset = B();
BRANCH_INSTRUMENTATION(offset);
@@ -1174,9 +1238,10 @@
BRANCH_INSTRUMENTATION(2);
inst = inst->Next_2xx();
}
+ return true;
}
- ALWAYS_INLINE void AGET_BOOLEAN() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool AGET_BOOLEAN() REQUIRES_SHARED(Locks::mutator_lock_) {
ObjPtr<mirror::Object> a = GetVRegReference(B());
if (UNLIKELY(a == nullptr)) {
ThrowNullPointerExceptionFromInterpreter();
@@ -1190,9 +1255,10 @@
} else {
HANDLE_PENDING_EXCEPTION();
}
+ return true;
}
- ALWAYS_INLINE void AGET_BYTE() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool AGET_BYTE() REQUIRES_SHARED(Locks::mutator_lock_) {
ObjPtr<mirror::Object> a = GetVRegReference(B());
if (UNLIKELY(a == nullptr)) {
ThrowNullPointerExceptionFromInterpreter();
@@ -1206,9 +1272,10 @@
} else {
HANDLE_PENDING_EXCEPTION();
}
+ return true;
}
- ALWAYS_INLINE void AGET_CHAR() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool AGET_CHAR() REQUIRES_SHARED(Locks::mutator_lock_) {
ObjPtr<mirror::Object> a = GetVRegReference(B());
if (UNLIKELY(a == nullptr)) {
ThrowNullPointerExceptionFromInterpreter();
@@ -1222,9 +1289,10 @@
} else {
HANDLE_PENDING_EXCEPTION();
}
+ return true;
}
- ALWAYS_INLINE void AGET_SHORT() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool AGET_SHORT() REQUIRES_SHARED(Locks::mutator_lock_) {
ObjPtr<mirror::Object> a = GetVRegReference(B());
if (UNLIKELY(a == nullptr)) {
ThrowNullPointerExceptionFromInterpreter();
@@ -1238,9 +1306,10 @@
} else {
HANDLE_PENDING_EXCEPTION();
}
+ return true;
}
- ALWAYS_INLINE void AGET() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool AGET() REQUIRES_SHARED(Locks::mutator_lock_) {
ObjPtr<mirror::Object> a = GetVRegReference(B());
if (UNLIKELY(a == nullptr)) {
ThrowNullPointerExceptionFromInterpreter();
@@ -1255,9 +1324,10 @@
} else {
HANDLE_PENDING_EXCEPTION();
}
+ return true;
}
- ALWAYS_INLINE void AGET_WIDE() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool AGET_WIDE() REQUIRES_SHARED(Locks::mutator_lock_) {
ObjPtr<mirror::Object> a = GetVRegReference(B());
if (UNLIKELY(a == nullptr)) {
ThrowNullPointerExceptionFromInterpreter();
@@ -1272,9 +1342,10 @@
} else {
HANDLE_PENDING_EXCEPTION();
}
+ return true;
}
- ALWAYS_INLINE void AGET_OBJECT() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool AGET_OBJECT() REQUIRES_SHARED(Locks::mutator_lock_) {
ObjPtr<mirror::Object> a = GetVRegReference(B());
if (UNLIKELY(a == nullptr)) {
ThrowNullPointerExceptionFromInterpreter();
@@ -1288,9 +1359,10 @@
} else {
HANDLE_PENDING_EXCEPTION();
}
+ return true;
}
- ALWAYS_INLINE void APUT_BOOLEAN() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool APUT_BOOLEAN() REQUIRES_SHARED(Locks::mutator_lock_) {
ObjPtr<mirror::Object> a = GetVRegReference(B());
if (UNLIKELY(a == nullptr)) {
ThrowNullPointerExceptionFromInterpreter();
@@ -1305,9 +1377,10 @@
} else {
HANDLE_PENDING_EXCEPTION();
}
+ return true;
}
- ALWAYS_INLINE void APUT_BYTE() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool APUT_BYTE() REQUIRES_SHARED(Locks::mutator_lock_) {
ObjPtr<mirror::Object> a = GetVRegReference(B());
if (UNLIKELY(a == nullptr)) {
ThrowNullPointerExceptionFromInterpreter();
@@ -1322,9 +1395,10 @@
} else {
HANDLE_PENDING_EXCEPTION();
}
+ return true;
}
- ALWAYS_INLINE void APUT_CHAR() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool APUT_CHAR() REQUIRES_SHARED(Locks::mutator_lock_) {
ObjPtr<mirror::Object> a = GetVRegReference(B());
if (UNLIKELY(a == nullptr)) {
ThrowNullPointerExceptionFromInterpreter();
@@ -1339,9 +1413,10 @@
} else {
HANDLE_PENDING_EXCEPTION();
}
+ return true;
}
- ALWAYS_INLINE void APUT_SHORT() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool APUT_SHORT() REQUIRES_SHARED(Locks::mutator_lock_) {
ObjPtr<mirror::Object> a = GetVRegReference(B());
if (UNLIKELY(a == nullptr)) {
ThrowNullPointerExceptionFromInterpreter();
@@ -1356,9 +1431,10 @@
} else {
HANDLE_PENDING_EXCEPTION();
}
+ return true;
}
- ALWAYS_INLINE void APUT() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool APUT() REQUIRES_SHARED(Locks::mutator_lock_) {
ObjPtr<mirror::Object> a = GetVRegReference(B());
if (UNLIKELY(a == nullptr)) {
ThrowNullPointerExceptionFromInterpreter();
@@ -1374,9 +1450,10 @@
} else {
HANDLE_PENDING_EXCEPTION();
}
+ return true;
}
- ALWAYS_INLINE void APUT_WIDE() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool APUT_WIDE() REQUIRES_SHARED(Locks::mutator_lock_) {
ObjPtr<mirror::Object> a = GetVRegReference(B());
if (UNLIKELY(a == nullptr)) {
ThrowNullPointerExceptionFromInterpreter();
@@ -1392,9 +1469,10 @@
} else {
HANDLE_PENDING_EXCEPTION();
}
+ return true;
}
- ALWAYS_INLINE void APUT_OBJECT() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool APUT_OBJECT() REQUIRES_SHARED(Locks::mutator_lock_) {
ObjPtr<mirror::Object> a = GetVRegReference(B());
if (UNLIKELY(a == nullptr)) {
ThrowNullPointerExceptionFromInterpreter();
@@ -1409,971 +1487,1149 @@
} else {
HANDLE_PENDING_EXCEPTION();
}
+ return true;
}
- ALWAYS_INLINE void IGET_BOOLEAN() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void IGET_BYTE() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void IGET_CHAR() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void IGET_SHORT() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void IGET() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void IGET_WIDE() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void IGET_OBJECT() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void IGET_QUICK() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool IGET_QUICK() REQUIRES_SHARED(Locks::mutator_lock_) {
bool success = DoIGetQuick<Primitive::kPrimInt>(shadow_frame, inst, inst_data);
POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx);
+ return true;
}
- ALWAYS_INLINE void IGET_WIDE_QUICK() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void IGET_OBJECT_QUICK() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void IGET_BOOLEAN_QUICK() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void IGET_BYTE_QUICK() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void IGET_CHAR_QUICK() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void IGET_SHORT_QUICK() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void SGET_BOOLEAN() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void SGET_BYTE() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void SGET_CHAR() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void SGET_SHORT() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void SGET() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void SGET_WIDE() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void SGET_OBJECT() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void IPUT_BOOLEAN() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void IPUT_BYTE() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void IPUT_CHAR() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void IPUT_SHORT() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void IPUT() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void IPUT_WIDE() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void IPUT_OBJECT() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void IPUT_QUICK() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void IPUT_BOOLEAN_QUICK() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void IPUT_BYTE_QUICK() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void IPUT_CHAR_QUICK() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void IPUT_SHORT_QUICK() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void IPUT_WIDE_QUICK() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void IPUT_OBJECT_QUICK() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void SPUT_BOOLEAN() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void SPUT_BYTE() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void SPUT_CHAR() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void SPUT_SHORT() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void SPUT() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void SPUT_WIDE() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void SPUT_OBJECT() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void INVOKE_VIRTUAL() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void INVOKE_VIRTUAL_RANGE() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void INVOKE_SUPER() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void INVOKE_SUPER_RANGE() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void INVOKE_DIRECT() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void INVOKE_DIRECT_RANGE() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void INVOKE_INTERFACE() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void INVOKE_INTERFACE_RANGE() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void INVOKE_STATIC() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void INVOKE_STATIC_RANGE() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void INVOKE_VIRTUAL_QUICK() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void INVOKE_VIRTUAL_RANGE_QUICK() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void INVOKE_POLYMORPHIC() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void INVOKE_POLYMORPHIC_RANGE() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void INVOKE_CUSTOM() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void INVOKE_CUSTOM_RANGE() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool 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);
+ return true;
}
- ALWAYS_INLINE void NEG_INT() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool NEG_INT() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVReg(A(), -GetVReg(B()));
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void NOT_INT() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool NOT_INT() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVReg(A(), ~GetVReg(B()));
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void NEG_LONG() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool NEG_LONG() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVRegLong(A(), -GetVRegLong(B()));
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void NOT_LONG() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool NOT_LONG() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVRegLong(A(), ~GetVRegLong(B()));
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void NEG_FLOAT() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool NEG_FLOAT() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVRegFloat(A(), -GetVRegFloat(B()));
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void NEG_DOUBLE() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool NEG_DOUBLE() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVRegDouble(A(), -GetVRegDouble(B()));
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void INT_TO_LONG() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool INT_TO_LONG() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVRegLong(A(), GetVReg(B()));
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void INT_TO_FLOAT() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool INT_TO_FLOAT() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVRegFloat(A(), GetVReg(B()));
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void INT_TO_DOUBLE() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool INT_TO_DOUBLE() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVRegDouble(A(), GetVReg(B()));
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void LONG_TO_INT() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool LONG_TO_INT() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVReg(A(), GetVRegLong(B()));
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void LONG_TO_FLOAT() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool LONG_TO_FLOAT() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVRegFloat(A(), GetVRegLong(B()));
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void LONG_TO_DOUBLE() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool LONG_TO_DOUBLE() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVRegDouble(A(), GetVRegLong(B()));
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void FLOAT_TO_INT() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool FLOAT_TO_INT() REQUIRES_SHARED(Locks::mutator_lock_) {
float val = GetVRegFloat(B());
int32_t result = art_float_to_integral<int32_t, float>(val);
SetVReg(A(), result);
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void FLOAT_TO_LONG() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool FLOAT_TO_LONG() REQUIRES_SHARED(Locks::mutator_lock_) {
float val = GetVRegFloat(B());
int64_t result = art_float_to_integral<int64_t, float>(val);
SetVRegLong(A(), result);
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void FLOAT_TO_DOUBLE() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool FLOAT_TO_DOUBLE() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVRegDouble(A(), GetVRegFloat(B()));
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void DOUBLE_TO_INT() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool DOUBLE_TO_INT() REQUIRES_SHARED(Locks::mutator_lock_) {
double val = GetVRegDouble(B());
int32_t result = art_float_to_integral<int32_t, double>(val);
SetVReg(A(), result);
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void DOUBLE_TO_LONG() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool DOUBLE_TO_LONG() REQUIRES_SHARED(Locks::mutator_lock_) {
double val = GetVRegDouble(B());
int64_t result = art_float_to_integral<int64_t, double>(val);
SetVRegLong(A(), result);
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void DOUBLE_TO_FLOAT() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool DOUBLE_TO_FLOAT() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVRegFloat(A(), GetVRegDouble(B()));
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void INT_TO_BYTE() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool INT_TO_BYTE() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVReg(A(), static_cast<int8_t>(GetVReg(B())));
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void INT_TO_CHAR() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool INT_TO_CHAR() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVReg(A(), static_cast<uint16_t>(GetVReg(B())));
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void INT_TO_SHORT() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool INT_TO_SHORT() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVReg(A(), static_cast<int16_t>(GetVReg(B())));
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void ADD_INT() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool ADD_INT() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVReg(A(), SafeAdd(GetVReg(B()), GetVReg(C())));
inst = inst->Next_2xx();
+ return true;
}
- ALWAYS_INLINE void SUB_INT() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool SUB_INT() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVReg(A(), SafeSub(GetVReg(B()), GetVReg(C())));
inst = inst->Next_2xx();
+ return true;
}
- ALWAYS_INLINE void MUL_INT() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool MUL_INT() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVReg(A(), SafeMul(GetVReg(B()), GetVReg(C())));
inst = inst->Next_2xx();
+ return true;
}
- ALWAYS_INLINE void DIV_INT() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool DIV_INT() REQUIRES_SHARED(Locks::mutator_lock_) {
bool success = DoIntDivide(shadow_frame, A(), GetVReg(B()), GetVReg(C()));
POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx);
+ return true;
}
- ALWAYS_INLINE void REM_INT() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool REM_INT() REQUIRES_SHARED(Locks::mutator_lock_) {
bool success = DoIntRemainder(shadow_frame, A(), GetVReg(B()), GetVReg(C()));
POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx);
+ return true;
}
- ALWAYS_INLINE void SHL_INT() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool SHL_INT() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVReg(A(), GetVReg(B()) << (GetVReg(C()) & 0x1f));
inst = inst->Next_2xx();
+ return true;
}
- ALWAYS_INLINE void SHR_INT() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool SHR_INT() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVReg(A(), GetVReg(B()) >> (GetVReg(C()) & 0x1f));
inst = inst->Next_2xx();
+ return true;
}
- ALWAYS_INLINE void USHR_INT() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool USHR_INT() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVReg(A(), static_cast<uint32_t>(GetVReg(B())) >> (GetVReg(C()) & 0x1f));
inst = inst->Next_2xx();
+ return true;
}
- ALWAYS_INLINE void AND_INT() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool AND_INT() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVReg(A(), GetVReg(B()) & GetVReg(C()));
inst = inst->Next_2xx();
+ return true;
}
- ALWAYS_INLINE void OR_INT() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool OR_INT() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVReg(A(), GetVReg(B()) | GetVReg(C()));
inst = inst->Next_2xx();
+ return true;
}
- ALWAYS_INLINE void XOR_INT() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool XOR_INT() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVReg(A(), GetVReg(B()) ^ GetVReg(C()));
inst = inst->Next_2xx();
+ return true;
}
- ALWAYS_INLINE void ADD_LONG() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool ADD_LONG() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVRegLong(A(), SafeAdd(GetVRegLong(B()), GetVRegLong(C())));
inst = inst->Next_2xx();
+ return true;
}
- ALWAYS_INLINE void SUB_LONG() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool SUB_LONG() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVRegLong(A(), SafeSub(GetVRegLong(B()), GetVRegLong(C())));
inst = inst->Next_2xx();
+ return true;
}
- ALWAYS_INLINE void MUL_LONG() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool MUL_LONG() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVRegLong(A(), SafeMul(GetVRegLong(B()), GetVRegLong(C())));
inst = inst->Next_2xx();
+ return true;
}
- ALWAYS_INLINE void DIV_LONG() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool DIV_LONG() REQUIRES_SHARED(Locks::mutator_lock_) {
DoLongDivide(shadow_frame, A(), GetVRegLong(B()), GetVRegLong(C()));
POSSIBLY_HANDLE_PENDING_EXCEPTION(self->IsExceptionPending(), Next_2xx);
+ return true;
}
- ALWAYS_INLINE void REM_LONG() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool REM_LONG() REQUIRES_SHARED(Locks::mutator_lock_) {
DoLongRemainder(shadow_frame, A(), GetVRegLong(B()), GetVRegLong(C()));
POSSIBLY_HANDLE_PENDING_EXCEPTION(self->IsExceptionPending(), Next_2xx);
+ return true;
}
- ALWAYS_INLINE void AND_LONG() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool AND_LONG() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVRegLong(A(), GetVRegLong(B()) & GetVRegLong(C()));
inst = inst->Next_2xx();
+ return true;
}
- ALWAYS_INLINE void OR_LONG() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool OR_LONG() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVRegLong(A(), GetVRegLong(B()) | GetVRegLong(C()));
inst = inst->Next_2xx();
+ return true;
}
- ALWAYS_INLINE void XOR_LONG() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool XOR_LONG() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVRegLong(A(), GetVRegLong(B()) ^ GetVRegLong(C()));
inst = inst->Next_2xx();
+ return true;
}
- ALWAYS_INLINE void SHL_LONG() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool SHL_LONG() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVRegLong(A(), GetVRegLong(B()) << (GetVReg(C()) & 0x3f));
inst = inst->Next_2xx();
+ return true;
}
- ALWAYS_INLINE void SHR_LONG() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool SHR_LONG() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVRegLong(A(), GetVRegLong(B()) >> (GetVReg(C()) & 0x3f));
inst = inst->Next_2xx();
+ return true;
}
- ALWAYS_INLINE void USHR_LONG() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool USHR_LONG() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVRegLong(A(), static_cast<uint64_t>(GetVRegLong(B())) >> (GetVReg(C()) & 0x3f));
inst = inst->Next_2xx();
+ return true;
}
- ALWAYS_INLINE void ADD_FLOAT() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool ADD_FLOAT() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVRegFloat(A(), GetVRegFloat(B()) + GetVRegFloat(C()));
inst = inst->Next_2xx();
+ return true;
}
- ALWAYS_INLINE void SUB_FLOAT() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool SUB_FLOAT() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVRegFloat(A(), GetVRegFloat(B()) - GetVRegFloat(C()));
inst = inst->Next_2xx();
+ return true;
}
- ALWAYS_INLINE void MUL_FLOAT() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool MUL_FLOAT() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVRegFloat(A(), GetVRegFloat(B()) * GetVRegFloat(C()));
inst = inst->Next_2xx();
+ return true;
}
- ALWAYS_INLINE void DIV_FLOAT() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool DIV_FLOAT() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVRegFloat(A(), GetVRegFloat(B()) / GetVRegFloat(C()));
inst = inst->Next_2xx();
+ return true;
}
- ALWAYS_INLINE void REM_FLOAT() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool REM_FLOAT() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVRegFloat(A(), fmodf(GetVRegFloat(B()), GetVRegFloat(C())));
inst = inst->Next_2xx();
+ return true;
}
- ALWAYS_INLINE void ADD_DOUBLE() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool ADD_DOUBLE() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVRegDouble(A(), GetVRegDouble(B()) + GetVRegDouble(C()));
inst = inst->Next_2xx();
+ return true;
}
- ALWAYS_INLINE void SUB_DOUBLE() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool SUB_DOUBLE() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVRegDouble(A(), GetVRegDouble(B()) - GetVRegDouble(C()));
inst = inst->Next_2xx();
+ return true;
}
- ALWAYS_INLINE void MUL_DOUBLE() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool MUL_DOUBLE() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVRegDouble(A(), GetVRegDouble(B()) * GetVRegDouble(C()));
inst = inst->Next_2xx();
+ return true;
}
- ALWAYS_INLINE void DIV_DOUBLE() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool DIV_DOUBLE() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVRegDouble(A(), GetVRegDouble(B()) / GetVRegDouble(C()));
inst = inst->Next_2xx();
+ return true;
}
- ALWAYS_INLINE void REM_DOUBLE() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool REM_DOUBLE() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVRegDouble(A(), fmod(GetVRegDouble(B()), GetVRegDouble(C())));
inst = inst->Next_2xx();
+ return true;
}
- ALWAYS_INLINE void ADD_INT_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool ADD_INT_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
uint4_t vregA = A();
SetVReg(vregA, SafeAdd(GetVReg(vregA), GetVReg(B())));
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void SUB_INT_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool SUB_INT_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
uint4_t vregA = A();
SetVReg(vregA, SafeSub(GetVReg(vregA), GetVReg(B())));
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void MUL_INT_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool MUL_INT_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
uint4_t vregA = A();
SetVReg(vregA, SafeMul(GetVReg(vregA), GetVReg(B())));
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void DIV_INT_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool DIV_INT_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
uint4_t vregA = A();
bool success = DoIntDivide(shadow_frame, vregA, GetVReg(vregA), GetVReg(B()));
POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_1xx);
+ return true;
}
- ALWAYS_INLINE void REM_INT_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool REM_INT_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
uint4_t vregA = A();
bool success = DoIntRemainder(shadow_frame, vregA, GetVReg(vregA), GetVReg(B()));
POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_1xx);
+ return true;
}
- ALWAYS_INLINE void SHL_INT_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool SHL_INT_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
uint4_t vregA = A();
SetVReg(vregA, GetVReg(vregA) << (GetVReg(B()) & 0x1f));
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void SHR_INT_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool SHR_INT_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
uint4_t vregA = A();
SetVReg(vregA, GetVReg(vregA) >> (GetVReg(B()) & 0x1f));
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void USHR_INT_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool USHR_INT_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
uint4_t vregA = A();
SetVReg(vregA, static_cast<uint32_t>(GetVReg(vregA)) >> (GetVReg(B()) & 0x1f));
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void AND_INT_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool AND_INT_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
uint4_t vregA = A();
SetVReg(vregA, GetVReg(vregA) & GetVReg(B()));
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void OR_INT_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool OR_INT_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
uint4_t vregA = A();
SetVReg(vregA, GetVReg(vregA) | GetVReg(B()));
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void XOR_INT_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool XOR_INT_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
uint4_t vregA = A();
SetVReg(vregA, GetVReg(vregA) ^ GetVReg(B()));
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void ADD_LONG_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool ADD_LONG_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
uint4_t vregA = A();
SetVRegLong(vregA, SafeAdd(GetVRegLong(vregA), GetVRegLong(B())));
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void SUB_LONG_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool SUB_LONG_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
uint4_t vregA = A();
SetVRegLong(vregA, SafeSub(GetVRegLong(vregA), GetVRegLong(B())));
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void MUL_LONG_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool MUL_LONG_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
uint4_t vregA = A();
SetVRegLong(vregA, SafeMul(GetVRegLong(vregA), GetVRegLong(B())));
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void DIV_LONG_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool DIV_LONG_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
uint4_t vregA = A();
DoLongDivide(shadow_frame, vregA, GetVRegLong(vregA), GetVRegLong(B()));
POSSIBLY_HANDLE_PENDING_EXCEPTION(self->IsExceptionPending(), Next_1xx);
+ return true;
}
- ALWAYS_INLINE void REM_LONG_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool REM_LONG_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
uint4_t vregA = A();
DoLongRemainder(shadow_frame, vregA, GetVRegLong(vregA), GetVRegLong(B()));
POSSIBLY_HANDLE_PENDING_EXCEPTION(self->IsExceptionPending(), Next_1xx);
+ return true;
}
- ALWAYS_INLINE void AND_LONG_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool AND_LONG_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
uint4_t vregA = A();
SetVRegLong(vregA, GetVRegLong(vregA) & GetVRegLong(B()));
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void OR_LONG_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool OR_LONG_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
uint4_t vregA = A();
SetVRegLong(vregA, GetVRegLong(vregA) | GetVRegLong(B()));
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void XOR_LONG_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool XOR_LONG_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
uint4_t vregA = A();
SetVRegLong(vregA, GetVRegLong(vregA) ^ GetVRegLong(B()));
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void SHL_LONG_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool SHL_LONG_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
uint4_t vregA = A();
SetVRegLong(vregA, GetVRegLong(vregA) << (GetVReg(B()) & 0x3f));
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void SHR_LONG_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool SHR_LONG_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
uint4_t vregA = A();
SetVRegLong(vregA, GetVRegLong(vregA) >> (GetVReg(B()) & 0x3f));
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void USHR_LONG_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool USHR_LONG_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
uint4_t vregA = A();
SetVRegLong(vregA, static_cast<uint64_t>(GetVRegLong(vregA)) >> (GetVReg(B()) & 0x3f));
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void ADD_FLOAT_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool ADD_FLOAT_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
uint4_t vregA = A();
SetVRegFloat(vregA, GetVRegFloat(vregA) + GetVRegFloat(B()));
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void SUB_FLOAT_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool SUB_FLOAT_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
uint4_t vregA = A();
SetVRegFloat(vregA, GetVRegFloat(vregA) - GetVRegFloat(B()));
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void MUL_FLOAT_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool MUL_FLOAT_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
uint4_t vregA = A();
SetVRegFloat(vregA, GetVRegFloat(vregA) * GetVRegFloat(B()));
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void DIV_FLOAT_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool DIV_FLOAT_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
uint4_t vregA = A();
SetVRegFloat(vregA, GetVRegFloat(vregA) / GetVRegFloat(B()));
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void REM_FLOAT_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool REM_FLOAT_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
uint4_t vregA = A();
SetVRegFloat(vregA, fmodf(GetVRegFloat(vregA), GetVRegFloat(B())));
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void ADD_DOUBLE_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool ADD_DOUBLE_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
uint4_t vregA = A();
SetVRegDouble(vregA, GetVRegDouble(vregA) + GetVRegDouble(B()));
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void SUB_DOUBLE_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool SUB_DOUBLE_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
uint4_t vregA = A();
SetVRegDouble(vregA, GetVRegDouble(vregA) - GetVRegDouble(B()));
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void MUL_DOUBLE_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool MUL_DOUBLE_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
uint4_t vregA = A();
SetVRegDouble(vregA, GetVRegDouble(vregA) * GetVRegDouble(B()));
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void DIV_DOUBLE_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool DIV_DOUBLE_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
uint4_t vregA = A();
SetVRegDouble(vregA, GetVRegDouble(vregA) / GetVRegDouble(B()));
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void REM_DOUBLE_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool REM_DOUBLE_2ADDR() REQUIRES_SHARED(Locks::mutator_lock_) {
uint4_t vregA = A();
SetVRegDouble(vregA, fmod(GetVRegDouble(vregA), GetVRegDouble(B())));
inst = inst->Next_1xx();
+ return true;
}
- ALWAYS_INLINE void ADD_INT_LIT16() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool ADD_INT_LIT16() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVReg(A(), SafeAdd(GetVReg(B()), C()));
inst = inst->Next_2xx();
+ return true;
}
- ALWAYS_INLINE void RSUB_INT() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool RSUB_INT() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVReg(A(), SafeSub(C(), GetVReg(B())));
inst = inst->Next_2xx();
+ return true;
}
- ALWAYS_INLINE void MUL_INT_LIT16() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool MUL_INT_LIT16() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVReg(A(), SafeMul(GetVReg(B()), C()));
inst = inst->Next_2xx();
+ return true;
}
- ALWAYS_INLINE void DIV_INT_LIT16() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool DIV_INT_LIT16() REQUIRES_SHARED(Locks::mutator_lock_) {
bool success = DoIntDivide(shadow_frame, A(), GetVReg(B()), C());
POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx);
+ return true;
}
- ALWAYS_INLINE void REM_INT_LIT16() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool REM_INT_LIT16() REQUIRES_SHARED(Locks::mutator_lock_) {
bool success = DoIntRemainder(shadow_frame, A(), GetVReg(B()), C());
POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx);
+ return true;
}
- ALWAYS_INLINE void AND_INT_LIT16() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool AND_INT_LIT16() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVReg(A(), GetVReg(B()) & C());
inst = inst->Next_2xx();
+ return true;
}
- ALWAYS_INLINE void OR_INT_LIT16() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool OR_INT_LIT16() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVReg(A(), GetVReg(B()) | C());
inst = inst->Next_2xx();
+ return true;
}
- ALWAYS_INLINE void XOR_INT_LIT16() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool XOR_INT_LIT16() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVReg(A(), GetVReg(B()) ^ C());
inst = inst->Next_2xx();
+ return true;
}
- ALWAYS_INLINE void ADD_INT_LIT8() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool ADD_INT_LIT8() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVReg(A(), SafeAdd(GetVReg(B()), C()));
inst = inst->Next_2xx();
+ return true;
}
- ALWAYS_INLINE void RSUB_INT_LIT8() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool RSUB_INT_LIT8() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVReg(A(), SafeSub(C(), GetVReg(B())));
inst = inst->Next_2xx();
+ return true;
}
- ALWAYS_INLINE void MUL_INT_LIT8() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool MUL_INT_LIT8() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVReg(A(), SafeMul(GetVReg(B()), C()));
inst = inst->Next_2xx();
+ return true;
}
- ALWAYS_INLINE void DIV_INT_LIT8() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool DIV_INT_LIT8() REQUIRES_SHARED(Locks::mutator_lock_) {
bool success = DoIntDivide(shadow_frame, A(), GetVReg(B()), C());
POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx);
+ return true;
}
- ALWAYS_INLINE void REM_INT_LIT8() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool REM_INT_LIT8() REQUIRES_SHARED(Locks::mutator_lock_) {
bool success = DoIntRemainder(shadow_frame, A(), GetVReg(B()), C());
POSSIBLY_HANDLE_PENDING_EXCEPTION(!success, Next_2xx);
+ return true;
}
- ALWAYS_INLINE void AND_INT_LIT8() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool AND_INT_LIT8() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVReg(A(), GetVReg(B()) & C());
inst = inst->Next_2xx();
+ return true;
}
- ALWAYS_INLINE void OR_INT_LIT8() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool OR_INT_LIT8() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVReg(A(), GetVReg(B()) | C());
inst = inst->Next_2xx();
+ return true;
}
- ALWAYS_INLINE void XOR_INT_LIT8() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool XOR_INT_LIT8() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVReg(A(), GetVReg(B()) ^ C());
inst = inst->Next_2xx();
+ return true;
}
- ALWAYS_INLINE void SHL_INT_LIT8() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool SHL_INT_LIT8() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVReg(A(), GetVReg(B()) << (C() & 0x1f));
inst = inst->Next_2xx();
+ return true;
}
- ALWAYS_INLINE void SHR_INT_LIT8() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool SHR_INT_LIT8() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVReg(A(), GetVReg(B()) >> (C() & 0x1f));
inst = inst->Next_2xx();
+ return true;
}
- ALWAYS_INLINE void USHR_INT_LIT8() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool USHR_INT_LIT8() REQUIRES_SHARED(Locks::mutator_lock_) {
SetVReg(A(), static_cast<uint32_t>(GetVReg(B())) >> (C() & 0x1f));
inst = inst->Next_2xx();
+ return true;
}
- ALWAYS_INLINE void UNUSED_3E() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool UNUSED_3E() REQUIRES_SHARED(Locks::mutator_lock_) {
UnexpectedOpcode(inst, shadow_frame);
+ return true;
}
- ALWAYS_INLINE void UNUSED_3F() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool UNUSED_3F() REQUIRES_SHARED(Locks::mutator_lock_) {
UnexpectedOpcode(inst, shadow_frame);
+ return true;
}
- ALWAYS_INLINE void UNUSED_40() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool UNUSED_40() REQUIRES_SHARED(Locks::mutator_lock_) {
UnexpectedOpcode(inst, shadow_frame);
+ return true;
}
- ALWAYS_INLINE void UNUSED_41() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool UNUSED_41() REQUIRES_SHARED(Locks::mutator_lock_) {
UnexpectedOpcode(inst, shadow_frame);
+ return true;
}
- ALWAYS_INLINE void UNUSED_42() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool UNUSED_42() REQUIRES_SHARED(Locks::mutator_lock_) {
UnexpectedOpcode(inst, shadow_frame);
+ return true;
}
- ALWAYS_INLINE void UNUSED_43() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool UNUSED_43() REQUIRES_SHARED(Locks::mutator_lock_) {
UnexpectedOpcode(inst, shadow_frame);
+ return true;
}
- ALWAYS_INLINE void UNUSED_79() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool UNUSED_79() REQUIRES_SHARED(Locks::mutator_lock_) {
UnexpectedOpcode(inst, shadow_frame);
+ return true;
}
- ALWAYS_INLINE void UNUSED_7A() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool UNUSED_7A() REQUIRES_SHARED(Locks::mutator_lock_) {
UnexpectedOpcode(inst, shadow_frame);
+ return true;
}
- ALWAYS_INLINE void UNUSED_F3() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool UNUSED_F3() REQUIRES_SHARED(Locks::mutator_lock_) {
UnexpectedOpcode(inst, shadow_frame);
+ return true;
}
- ALWAYS_INLINE void UNUSED_F4() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool UNUSED_F4() REQUIRES_SHARED(Locks::mutator_lock_) {
UnexpectedOpcode(inst, shadow_frame);
+ return true;
}
- ALWAYS_INLINE void UNUSED_F5() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool UNUSED_F5() REQUIRES_SHARED(Locks::mutator_lock_) {
UnexpectedOpcode(inst, shadow_frame);
+ return true;
}
- ALWAYS_INLINE void UNUSED_F6() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool UNUSED_F6() REQUIRES_SHARED(Locks::mutator_lock_) {
UnexpectedOpcode(inst, shadow_frame);
+ return true;
}
- ALWAYS_INLINE void UNUSED_F7() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool UNUSED_F7() REQUIRES_SHARED(Locks::mutator_lock_) {
UnexpectedOpcode(inst, shadow_frame);
+ return true;
}
- ALWAYS_INLINE void UNUSED_F8() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool UNUSED_F8() REQUIRES_SHARED(Locks::mutator_lock_) {
UnexpectedOpcode(inst, shadow_frame);
+ return true;
}
- ALWAYS_INLINE void UNUSED_F9() REQUIRES_SHARED(Locks::mutator_lock_) {
+ ALWAYS_INLINE bool UNUSED_F9() REQUIRES_SHARED(Locks::mutator_lock_) {
UnexpectedOpcode(inst, shadow_frame);
+ return true;
}
ALWAYS_INLINE InstructionHandler(SwitchImplContext* ctx,