Refactor runtime support.
Change-Id: Id7470a4105838150d5ceb73ab2c8c83e739660df
diff --git a/src/compiler/codegen/GenCommon.cc b/src/compiler/codegen/GenCommon.cc
index 0b0d100..54b8e5f 100644
--- a/src/compiler/codegen/GenCommon.cc
+++ b/src/compiler/codegen/GenCommon.cc
@@ -14,6 +14,8 @@
* limitations under the License.
*/
+#include "oat/runtime/oat_support_entrypoints.h"
+
namespace art {
/*
@@ -490,9 +492,9 @@
cUnit->dex_cache,
*cUnit->dex_file,
type_idx)) {
- funcOffset = OFFSETOF_MEMBER(Thread, pAllocArrayFromCode);
+ funcOffset = ENTRYPOINT_OFFSET(pAllocArrayFromCode);
} else {
- funcOffset= OFFSETOF_MEMBER(Thread, pAllocArrayFromCodeWithAccessCheck);
+ funcOffset= ENTRYPOINT_OFFSET(pAllocArrayFromCodeWithAccessCheck);
}
callRuntimeHelperImmMethodRegLocation(cUnit, funcOffset, type_idx, rlSrc);
RegLocation rlResult = oatGetReturn(cUnit, false);
@@ -516,10 +518,9 @@
cUnit->dex_cache,
*cUnit->dex_file,
typeIdx)) {
- funcOffset = OFFSETOF_MEMBER(Thread, pCheckAndAllocArrayFromCode);
+ funcOffset = ENTRYPOINT_OFFSET(pCheckAndAllocArrayFromCode);
} else {
- funcOffset = OFFSETOF_MEMBER(Thread,
- pCheckAndAllocArrayFromCodeWithAccessCheck);
+ funcOffset = ENTRYPOINT_OFFSET(pCheckAndAllocArrayFromCodeWithAccessCheck);
}
callRuntimeHelperImmMethodImm(cUnit, funcOffset, typeIdx, elems);
oatFreeTemp(cUnit, rARG2);
@@ -666,7 +667,7 @@
LIR* branchOver = opCmpImmBranch(cUnit, kCondNe, rBase, 0, NULL);
loadConstant(cUnit, rARG0, ssbIndex);
callRuntimeHelperImm(cUnit,
- OFFSETOF_MEMBER(Thread, pInitializeStaticStorage),
+ ENTRYPOINT_OFFSET(pInitializeStaticStorage),
ssbIndex);
#if defined(TARGET_MIPS)
// For Arm, rRET0 = rARG0 = rBASE, for Mips, we need to copy
@@ -703,9 +704,9 @@
oatFreeTemp(cUnit, rBase);
} else {
oatFlushAllRegs(cUnit); // Everything to home locations
- int setterOffset = isLongOrDouble ? OFFSETOF_MEMBER(Thread, pSet64Static) :
- (isObject ? OFFSETOF_MEMBER(Thread, pSetObjStatic)
- : OFFSETOF_MEMBER(Thread, pSet32Static));
+ int setterOffset = isLongOrDouble ? ENTRYPOINT_OFFSET(pSet64Static) :
+ (isObject ? ENTRYPOINT_OFFSET(pSetObjStatic)
+ : ENTRYPOINT_OFFSET(pSet32Static));
callRuntimeHelperImmRegLocation(cUnit, setterOffset, fieldIdx, rlSrc);
}
}
@@ -763,7 +764,7 @@
// TUNING: fast path should fall through
LIR* branchOver = opCmpImmBranch(cUnit, kCondNe, rBase, 0, NULL);
callRuntimeHelperImm(cUnit,
- OFFSETOF_MEMBER(Thread, pInitializeStaticStorage),
+ ENTRYPOINT_OFFSET(pInitializeStaticStorage),
ssbIndex);
#if defined(TARGET_MIPS)
// For Arm, rRET0 = rARG0 = rBASE, for Mips, we need to copy
@@ -794,9 +795,9 @@
}
} else {
oatFlushAllRegs(cUnit); // Everything to home locations
- int getterOffset = isLongOrDouble ? OFFSETOF_MEMBER(Thread, pGet64Static) :
- (isObject ? OFFSETOF_MEMBER(Thread, pGetObjStatic)
- : OFFSETOF_MEMBER(Thread, pGet32Static));
+ int getterOffset = isLongOrDouble ? ENTRYPOINT_OFFSET(pGet64Static) :
+ (isObject ? ENTRYPOINT_OFFSET(pGetObjStatic)
+ : ENTRYPOINT_OFFSET(pGet32Static));
callRuntimeHelperImm(cUnit, getterOffset, fieldIdx);
if (isLongOrDouble) {
RegLocation rlResult = oatGetReturnWide(cUnit, rlDest.fp);
@@ -817,7 +818,7 @@
#else
LIR* branchOver = opCmpImmBranch(cUnit, kCondNe, rINVOKE_TGT, 0, NULL);
loadWordDisp(cUnit, rSELF,
- OFFSETOF_MEMBER(Thread, pDebugMe), rINVOKE_TGT);
+ ENTRYPOINT_OFFSET(pDebugMe), rINVOKE_TGT);
LIR* target = newLIR0(cUnit, kPseudoTargetLabel);
branchOver->target = (LIR*)target;
#endif
@@ -825,8 +826,7 @@
void genThrowVerificationError(CompilationUnit* cUnit, MIR* mir)
{
- callRuntimeHelperImmImm(cUnit, OFFSETOF_MEMBER(Thread,
- pThrowVerificationErrorFromCode),
+ callRuntimeHelperImmImm(cUnit, ENTRYPOINT_OFFSET(pThrowVerificationErrorFromCode),
mir->dalvikInsn.vA, mir->dalvikInsn.vB);
}
@@ -843,10 +843,9 @@
oatAppendLIR(cUnit, lab);
#if defined(TARGET_X86)
opThreadMem(cUnit, kOpBlx,
- OFFSETOF_MEMBER(Thread, pTestSuspendFromCode));
+ ENTRYPOINT_OFFSET(pTestSuspendFromCode));
#else
- int rTgt = loadHelper(cUnit, OFFSETOF_MEMBER(Thread,
- pTestSuspendFromCode));
+ int rTgt = loadHelper(cUnit, ENTRYPOINT_OFFSET(pTestSuspendFromCode));
opReg(cUnit, kOpBlx, rTgt);
#endif
opUnconditionalBranch(cUnit, resumeLab);
@@ -889,7 +888,7 @@
int v2 = lab->operands[3];
switch (lab->operands[0]) {
case kThrowNullPointer:
- funcOffset = OFFSETOF_MEMBER(Thread, pThrowNullPointerFromCode);
+ funcOffset = ENTRYPOINT_OFFSET(pThrowNullPointerFromCode);
break;
case kThrowArrayBounds:
if (v2 != rARG0) {
@@ -910,30 +909,25 @@
opRegCopy(cUnit, rARG0, v1);
}
}
- funcOffset = OFFSETOF_MEMBER(Thread, pThrowArrayBoundsFromCode);
+ funcOffset = ENTRYPOINT_OFFSET(pThrowArrayBoundsFromCode);
break;
case kThrowDivZero:
- funcOffset = OFFSETOF_MEMBER(Thread, pThrowDivZeroFromCode);
+ funcOffset = ENTRYPOINT_OFFSET(pThrowDivZeroFromCode);
break;
case kThrowVerificationError:
loadConstant(cUnit, rARG0, v1);
loadConstant(cUnit, rARG1, v2);
funcOffset =
- OFFSETOF_MEMBER(Thread, pThrowVerificationErrorFromCode);
- break;
- case kThrowNegArraySize:
- opRegCopy(cUnit, rARG0, v1);
- funcOffset =
- OFFSETOF_MEMBER(Thread, pThrowNegArraySizeFromCode);
+ ENTRYPOINT_OFFSET(pThrowVerificationErrorFromCode);
break;
case kThrowNoSuchMethod:
opRegCopy(cUnit, rARG0, v1);
funcOffset =
- OFFSETOF_MEMBER(Thread, pThrowNoSuchMethodFromCode);
+ ENTRYPOINT_OFFSET(pThrowNoSuchMethodFromCode);
break;
case kThrowStackOverflow:
funcOffset =
- OFFSETOF_MEMBER(Thread, pThrowStackOverflowFromCode);
+ ENTRYPOINT_OFFSET(pThrowStackOverflowFromCode);
// Restore stack alignment
opRegImm(cUnit, kOpAdd, rSP,
(cUnit->numCoreSpills + cUnit->numFPSpills) * 4);
@@ -1018,9 +1012,9 @@
storeValue(cUnit, rlDest, rlResult);
}
} else {
- int getterOffset = isLongOrDouble ? OFFSETOF_MEMBER(Thread, pGet64Instance) :
- (isObject ? OFFSETOF_MEMBER(Thread, pGetObjInstance)
- : OFFSETOF_MEMBER(Thread, pGet32Instance));
+ int getterOffset = isLongOrDouble ? ENTRYPOINT_OFFSET(pGet64Instance) :
+ (isObject ? ENTRYPOINT_OFFSET(pGetObjInstance)
+ : ENTRYPOINT_OFFSET(pGet32Instance));
callRuntimeHelperImmRegLocation(cUnit, getterOffset, fieldIdx, rlObj);
if (isLongOrDouble) {
RegLocation rlResult = oatGetReturnWide(cUnit, rlDest.fp);
@@ -1074,9 +1068,9 @@
}
}
} else {
- int setterOffset = isLongOrDouble ? OFFSETOF_MEMBER(Thread, pSet64Instance) :
- (isObject ? OFFSETOF_MEMBER(Thread, pSetObjInstance)
- : OFFSETOF_MEMBER(Thread, pSet32Instance));
+ int setterOffset = isLongOrDouble ? ENTRYPOINT_OFFSET(pSet64Instance) :
+ (isObject ? ENTRYPOINT_OFFSET(pSetObjInstance)
+ : ENTRYPOINT_OFFSET(pSet32Instance));
callRuntimeHelperImmRegLocationRegLocation(cUnit, setterOffset,
fieldIdx, rlObj, rlSrc);
}
@@ -1096,8 +1090,7 @@
// Call out to helper which resolves type and verifies access.
// Resolved type returned in rRET0.
callRuntimeHelperImmReg(cUnit,
- OFFSETOF_MEMBER(Thread,
- pInitializeTypeAndVerifyAccessFromCode),
+ ENTRYPOINT_OFFSET(pInitializeTypeAndVerifyAccessFromCode),
type_idx, rlMethod.lowReg);
RegLocation rlResult = oatGetReturn(cUnit, false);
storeValue(cUnit, rlDest, rlResult);
@@ -1127,8 +1120,7 @@
// TUNING: move slow path to end & remove unconditional branch
LIR* target1 = newLIR0(cUnit, kPseudoTargetLabel);
// Call out to helper, which will return resolved type in rARG0
- callRuntimeHelperImmReg(cUnit, OFFSETOF_MEMBER(Thread,
- pInitializeTypeFromCode),
+ callRuntimeHelperImmReg(cUnit, ENTRYPOINT_OFFSET(pInitializeTypeFromCode),
type_idx, rlMethod.lowReg);
RegLocation rlResult = oatGetReturn(cUnit, false);
storeValue(cUnit, rlDest, rlResult);
@@ -1165,8 +1157,7 @@
Method::DexCacheStringsOffset().Int32Value(), rARG0);
// Might call out to helper, which will return resolved string in rRET0
#if !defined(TARGET_X86)
- int rTgt = loadHelper(cUnit, OFFSETOF_MEMBER(Thread,
- pResolveStringFromCode));
+ int rTgt = loadHelper(cUnit, ENTRYPOINT_OFFSET(pResolveStringFromCode));
#endif
loadWordDisp(cUnit, rRET0, offset_of_string, rARG0);
loadConstant(cUnit, rARG1, string_idx);
@@ -1188,8 +1179,7 @@
LIR* target = newLIR0(cUnit, kPseudoTargetLabel);
branch->target = target;
#else
- callRuntimeHelperRegReg(cUnit, OFFSETOF_MEMBER(Thread,
- pResolveStringFromCode),
+ callRuntimeHelperRegReg(cUnit, ENTRYPOINT_OFFSET(pResolveStringFromCode),
rARG2, rARG1);
#endif
genBarrier(cUnit);
@@ -1218,10 +1208,10 @@
int funcOffset;
if (cUnit->compiler->CanAccessInstantiableTypeWithoutChecks(
cUnit->method_idx, cUnit->dex_cache, *cUnit->dex_file, type_idx)) {
- funcOffset = OFFSETOF_MEMBER(Thread, pAllocObjectFromCode);
+ funcOffset = ENTRYPOINT_OFFSET(pAllocObjectFromCode);
} else {
funcOffset =
- OFFSETOF_MEMBER(Thread, pAllocObjectFromCodeWithAccessCheck);
+ ENTRYPOINT_OFFSET(pAllocObjectFromCodeWithAccessCheck);
}
callRuntimeHelperImmMethod(cUnit, funcOffset, type_idx);
RegLocation rlResult = oatGetReturn(cUnit, false);
@@ -1231,7 +1221,7 @@
void genThrow(CompilationUnit* cUnit, MIR* mir, RegLocation rlSrc)
{
oatFlushAllRegs(cUnit);
- callRuntimeHelperRegLocation(cUnit, OFFSETOF_MEMBER(Thread, pDeliverException), rlSrc);
+ callRuntimeHelperRegLocation(cUnit, ENTRYPOINT_OFFSET(pDeliverException), rlSrc);
}
void genInstanceof(CompilationUnit* cUnit, MIR* mir, RegLocation rlDest,
@@ -1250,7 +1240,7 @@
// Check we have access to type_idx and if not throw IllegalAccessError,
// returns Class* in rARG0
callRuntimeHelperImm(cUnit,
- OFFSETOF_MEMBER(Thread, pInitializeTypeAndVerifyAccessFromCode),
+ ENTRYPOINT_OFFSET(pInitializeTypeAndVerifyAccessFromCode),
type_idx);
opRegCopy(cUnit, classReg, rRET0); // Align usage with fast path
loadValueDirectFixed(cUnit, rlSrc, rARG0); // rARG0 <= ref
@@ -1270,8 +1260,7 @@
LIR* hopBranch = opCmpImmBranch(cUnit, kCondNe, classReg, 0, NULL);
// Not resolved
// Call out to helper, which will return resolved type in rRET0
- callRuntimeHelperImm(cUnit, OFFSETOF_MEMBER(Thread,
- pInitializeTypeFromCode),
+ callRuntimeHelperImm(cUnit, ENTRYPOINT_OFFSET(pInitializeTypeFromCode),
type_idx);
opRegCopy(cUnit, rARG2, rRET0); // Align usage with fast path
loadValueDirectFixed(cUnit, rlSrc, rARG0); /* reload Ref */
@@ -1288,8 +1277,7 @@
/* rARG0 is ref, rARG1 is ref->klass_, rARG2 is class */
#if defined(TARGET_ARM)
/* Uses conditional nullification */
- int rTgt = loadHelper(cUnit, OFFSETOF_MEMBER(Thread,
- pInstanceofNonTrivialFromCode));
+ int rTgt = loadHelper(cUnit, ENTRYPOINT_OFFSET(pInstanceofNonTrivialFromCode));
opRegReg(cUnit, kOpCmp, rARG1, rARG2); // Same?
opIT(cUnit, kArmCondEq, "EE"); // if-convert the test
loadConstant(cUnit, rARG0, 1); // .eq case - load true
@@ -1301,15 +1289,14 @@
loadConstant(cUnit, rARG0, 1); // assume true
LIR* branchover = opCmpBranch(cUnit, kCondEq, rARG1, rARG2, NULL);
#if !defined(TARGET_X86)
- int rTgt = loadHelper(cUnit, OFFSETOF_MEMBER(Thread,
- pInstanceofNonTrivialFromCode));
+ int rTgt = loadHelper(cUnit, ENTRYPOINT_OFFSET(pInstanceofNonTrivialFromCode));
opRegCopy(cUnit, rARG0, rARG2); // .ne case - arg0 <= class
opReg(cUnit, kOpBlx, rTgt); // .ne case: helper(class, ref->class)
oatFreeTemp(cUnit, rTgt);
#else
opRegCopy(cUnit, rARG0, rARG2);
opThreadMem(cUnit, kOpBlx,
- OFFSETOF_MEMBER(Thread, pInstanceofNonTrivialFromCode));
+ ENTRYPOINT_OFFSET(pInstanceofNonTrivialFromCode));
#endif
#endif
oatClobberCalleeSave(cUnit);
@@ -1339,8 +1326,7 @@
// returns Class* in rRET0
// InitializeTypeAndVerifyAccess(idx, method)
callRuntimeHelperImmReg(cUnit,
- OFFSETOF_MEMBER(Thread,
- pInitializeTypeAndVerifyAccessFromCode),
+ ENTRYPOINT_OFFSET(pInitializeTypeAndVerifyAccessFromCode),
type_idx, rARG1);
opRegCopy(cUnit, classReg, rRET0); // Align usage with fast path
} else {
@@ -1360,7 +1346,7 @@
// Call out to helper, which will return resolved type in rARG0
// InitializeTypeFromCode(idx, method)
callRuntimeHelperImmReg(cUnit,
- OFFSETOF_MEMBER(Thread, pInitializeTypeFromCode),
+ ENTRYPOINT_OFFSET(pInitializeTypeFromCode),
type_idx, rARG1);
opRegCopy(cUnit, classReg, rARG0); // Align usage with fast path
// Rejoin code paths
@@ -1378,12 +1364,10 @@
/* rARG1 now contains object->klass_ */
#if defined(TARGET_MIPS) || defined(TARGET_X86)
LIR* branch2 = opCmpBranch(cUnit, kCondEq, rARG1, classReg, NULL);
- callRuntimeHelperRegReg(cUnit, OFFSETOF_MEMBER(Thread,
- pCheckCastFromCode),
+ callRuntimeHelperRegReg(cUnit, ENTRYPOINT_OFFSET(pCheckCastFromCode),
rARG1, rARG2);
#else // defined(TARGET_ARM)
- int rTgt = loadHelper(cUnit, OFFSETOF_MEMBER(Thread,
- pCheckCastFromCode));
+ int rTgt = loadHelper(cUnit, ENTRYPOINT_OFFSET(pCheckCastFromCode));
opRegReg(cUnit, kOpCmp, rARG1, classReg);
LIR* branch2 = opCondBranch(cUnit, kCondEq, NULL); /* If eq, trivial yes */
opRegCopy(cUnit, rARG0, rARG1);
@@ -1418,8 +1402,7 @@
genNullCheck(cUnit, rlArray.sRegLow, rARG1, mir);
/* Get the array's class */
loadWordDisp(cUnit, rARG1, Object::ClassOffset().Int32Value(), rARG1);
- callRuntimeHelperRegReg(cUnit, OFFSETOF_MEMBER(Thread,
- pCanPutArrayElementFromCode),
+ callRuntimeHelperRegReg(cUnit, ENTRYPOINT_OFFSET(pCanPutArrayElementFromCode),
rARG0, rARG1);
oatFreeTemp(cUnit, rARG0);
oatFreeTemp(cUnit, rARG1);
@@ -1725,15 +1708,15 @@
switch (mir->dalvikInsn.opcode) {
case Instruction::SHL_LONG:
case Instruction::SHL_LONG_2ADDR:
- funcOffset = OFFSETOF_MEMBER(Thread, pShlLong);
+ funcOffset = ENTRYPOINT_OFFSET(pShlLong);
break;
case Instruction::SHR_LONG:
case Instruction::SHR_LONG_2ADDR:
- funcOffset = OFFSETOF_MEMBER(Thread, pShrLong);
+ funcOffset = ENTRYPOINT_OFFSET(pShrLong);
break;
case Instruction::USHR_LONG:
case Instruction::USHR_LONG_2ADDR:
- funcOffset = OFFSETOF_MEMBER(Thread, pUshrLong);
+ funcOffset = ENTRYPOINT_OFFSET(pUshrLong);
break;
default:
LOG(FATAL) << "Unexpected case";
@@ -1784,7 +1767,7 @@
checkZero = true;
op = kOpDiv;
callOut = true;
- funcOffset = OFFSETOF_MEMBER(Thread, pIdiv);
+ funcOffset = ENTRYPOINT_OFFSET(pIdiv);
retReg = rRET0;
break;
/* NOTE: returns in rARG1 */
@@ -1793,7 +1776,7 @@
checkZero = true;
op = kOpRem;
callOut = true;
- funcOffset = OFFSETOF_MEMBER(Thread, pIdivmod);
+ funcOffset = ENTRYPOINT_OFFSET(pIdivmod);
retReg = rRET1;
break;
case Instruction::AND_INT:
@@ -2108,10 +2091,10 @@
oatClobber(cUnit, rARG0);
if ((dalvikOpcode == Instruction::DIV_INT_LIT8) ||
(dalvikOpcode == Instruction::DIV_INT_LIT16)) {
- funcOffset = OFFSETOF_MEMBER(Thread, pIdiv);
+ funcOffset = ENTRYPOINT_OFFSET(pIdiv);
isDiv = true;
} else {
- funcOffset = OFFSETOF_MEMBER(Thread, pIdivmod);
+ funcOffset = ENTRYPOINT_OFFSET(pIdivmod);
isDiv = false;
}
callRuntimeHelperRegImm(cUnit, funcOffset, rARG0, lit);
@@ -2173,7 +2156,7 @@
#elif defined(TARGET_X86)
callOut = true;
retReg = rRET0;
- funcOffset = OFFSETOF_MEMBER(Thread, pLadd);
+ funcOffset = ENTRYPOINT_OFFSET(pLadd);
#else
firstOp = kOpAdd;
secondOp = kOpAdc;
@@ -2186,7 +2169,7 @@
#elif defined(TARGET_X86)
callOut = true;
retReg = rRET0;
- funcOffset = OFFSETOF_MEMBER(Thread, pLsub);
+ funcOffset = ENTRYPOINT_OFFSET(pLsub);
#endif
firstOp = kOpSub;
secondOp = kOpSbc;
@@ -2195,14 +2178,14 @@
case Instruction::MUL_LONG_2ADDR:
callOut = true;
retReg = rRET0;
- funcOffset = OFFSETOF_MEMBER(Thread, pLmul);
+ funcOffset = ENTRYPOINT_OFFSET(pLmul);
break;
case Instruction::DIV_LONG:
case Instruction::DIV_LONG_2ADDR:
callOut = true;
checkZero = true;
retReg = rRET0;
- funcOffset = OFFSETOF_MEMBER(Thread, pLdivmod);
+ funcOffset = ENTRYPOINT_OFFSET(pLdivmod);
break;
/* NOTE - result is in rARG2/rARG3 instead of rRET0/rRET1 */
// FIXME: is true, or could be made true, or other targets?
@@ -2210,7 +2193,7 @@
case Instruction::REM_LONG_2ADDR:
callOut = true;
checkZero = true;
- funcOffset = OFFSETOF_MEMBER(Thread, pLdivmod);
+ funcOffset = ENTRYPOINT_OFFSET(pLdivmod);
retReg = rARG2;
break;
case Instruction::AND_LONG_2ADDR:
@@ -2218,7 +2201,7 @@
#if defined(TARGET_X86)
callOut = true;
retReg = rRET0;
- funcOffset = OFFSETOF_MEMBER(Thread, pLand);
+ funcOffset = ENTRYPOINT_OFFSET(pLand);
#endif
firstOp = kOpAnd;
secondOp = kOpAnd;
@@ -2228,7 +2211,7 @@
#if defined(TARGET_X86)
callOut = true;
retReg = rRET0;
- funcOffset = OFFSETOF_MEMBER(Thread, pLor);
+ funcOffset = ENTRYPOINT_OFFSET(pLor);
#endif
firstOp = kOpOr;
secondOp = kOpOr;
@@ -2238,7 +2221,7 @@
#if defined(TARGET_X86)
callOut = true;
retReg = rRET0;
- funcOffset = OFFSETOF_MEMBER(Thread, pLxor);
+ funcOffset = ENTRYPOINT_OFFSET(pLxor);
#endif
firstOp = kOpXor;
secondOp = kOpXor;
@@ -2332,23 +2315,23 @@
switch (mir->dalvikInsn.opcode) {
case Instruction::ADD_FLOAT_2ADDR:
case Instruction::ADD_FLOAT:
- funcOffset = OFFSETOF_MEMBER(Thread, pFadd);
+ funcOffset = ENTRYPOINT_OFFSET(pFadd);
break;
case Instruction::SUB_FLOAT_2ADDR:
case Instruction::SUB_FLOAT:
- funcOffset = OFFSETOF_MEMBER(Thread, pFsub);
+ funcOffset = ENTRYPOINT_OFFSET(pFsub);
break;
case Instruction::DIV_FLOAT_2ADDR:
case Instruction::DIV_FLOAT:
- funcOffset = OFFSETOF_MEMBER(Thread, pFdiv);
+ funcOffset = ENTRYPOINT_OFFSET(pFdiv);
break;
case Instruction::MUL_FLOAT_2ADDR:
case Instruction::MUL_FLOAT:
- funcOffset = OFFSETOF_MEMBER(Thread, pFmul);
+ funcOffset = ENTRYPOINT_OFFSET(pFmul);
break;
case Instruction::REM_FLOAT_2ADDR:
case Instruction::REM_FLOAT:
- funcOffset = OFFSETOF_MEMBER(Thread, pFmodf);
+ funcOffset = ENTRYPOINT_OFFSET(pFmodf);
break;
case Instruction::NEG_FLOAT: {
genNegFloat(cUnit, rlDest, rlSrc1);
@@ -2375,23 +2358,23 @@
switch (mir->dalvikInsn.opcode) {
case Instruction::ADD_DOUBLE_2ADDR:
case Instruction::ADD_DOUBLE:
- funcOffset = OFFSETOF_MEMBER(Thread, pDadd);
+ funcOffset = ENTRYPOINT_OFFSET(pDadd);
break;
case Instruction::SUB_DOUBLE_2ADDR:
case Instruction::SUB_DOUBLE:
- funcOffset = OFFSETOF_MEMBER(Thread, pDsub);
+ funcOffset = ENTRYPOINT_OFFSET(pDsub);
break;
case Instruction::DIV_DOUBLE_2ADDR:
case Instruction::DIV_DOUBLE:
- funcOffset = OFFSETOF_MEMBER(Thread, pDdiv);
+ funcOffset = ENTRYPOINT_OFFSET(pDdiv);
break;
case Instruction::MUL_DOUBLE_2ADDR:
case Instruction::MUL_DOUBLE:
- funcOffset = OFFSETOF_MEMBER(Thread, pDmul);
+ funcOffset = ENTRYPOINT_OFFSET(pDmul);
break;
case Instruction::REM_DOUBLE_2ADDR:
case Instruction::REM_DOUBLE:
- funcOffset = OFFSETOF_MEMBER(Thread, pFmod);
+ funcOffset = ENTRYPOINT_OFFSET(pFmod);
break;
case Instruction::NEG_DOUBLE: {
genNegDouble(cUnit, rlDest, rlSrc1);
@@ -2413,34 +2396,34 @@
switch (opcode) {
case Instruction::INT_TO_FLOAT:
- return genConversionCall(cUnit, mir, OFFSETOF_MEMBER(Thread, pI2f),
+ return genConversionCall(cUnit, mir, ENTRYPOINT_OFFSET(pI2f),
1, 1);
case Instruction::FLOAT_TO_INT:
- return genConversionCall(cUnit, mir, OFFSETOF_MEMBER(Thread, pF2iz),
+ return genConversionCall(cUnit, mir, ENTRYPOINT_OFFSET(pF2iz),
1, 1);
case Instruction::DOUBLE_TO_FLOAT:
- return genConversionCall(cUnit, mir, OFFSETOF_MEMBER(Thread, pD2f),
+ return genConversionCall(cUnit, mir, ENTRYPOINT_OFFSET(pD2f),
2, 1);
case Instruction::FLOAT_TO_DOUBLE:
- return genConversionCall(cUnit, mir, OFFSETOF_MEMBER(Thread, pF2d),
+ return genConversionCall(cUnit, mir, ENTRYPOINT_OFFSET(pF2d),
1, 2);
case Instruction::INT_TO_DOUBLE:
- return genConversionCall(cUnit, mir, OFFSETOF_MEMBER(Thread, pI2d),
+ return genConversionCall(cUnit, mir, ENTRYPOINT_OFFSET(pI2d),
1, 2);
case Instruction::DOUBLE_TO_INT:
- return genConversionCall(cUnit, mir, OFFSETOF_MEMBER(Thread, pD2iz),
+ return genConversionCall(cUnit, mir, ENTRYPOINT_OFFSET(pD2iz),
2, 1);
case Instruction::FLOAT_TO_LONG:
- return genConversionCall(cUnit, mir, OFFSETOF_MEMBER(Thread,
- pF2l), 1, 2);
+ return genConversionCall(cUnit, mir, ENTRYPOINT_OFFSET(pF2l),
+ 1, 2);
case Instruction::LONG_TO_FLOAT:
- return genConversionCall(cUnit, mir, OFFSETOF_MEMBER(Thread, pL2f),
+ return genConversionCall(cUnit, mir, ENTRYPOINT_OFFSET(pL2f),
2, 1);
case Instruction::DOUBLE_TO_LONG:
- return genConversionCall(cUnit, mir, OFFSETOF_MEMBER(Thread,
- pD2l), 2, 2);
+ return genConversionCall(cUnit, mir, ENTRYPOINT_OFFSET(pD2l),
+ 2, 2);
case Instruction::LONG_TO_DOUBLE:
- return genConversionCall(cUnit, mir, OFFSETOF_MEMBER(Thread, pL2d),
+ return genConversionCall(cUnit, mir, ENTRYPOINT_OFFSET(pL2d),
2, 2);
default:
return true;
@@ -2492,12 +2475,11 @@
#if defined(TARGET_X86)
UNIMPLEMENTED(FATAL);
#else
- int rTgt = loadHelper(cUnit, OFFSETOF_MEMBER(Thread,
- pTestSuspendFromCode));
+ int rTgt = loadHelper(cUnit, ENTRYPOINT_OFFSET(pTestSuspendFromCode));
opReg(cUnit, kOpBlx, rTgt);
// Refresh rSUSPEND
loadWordDisp(cUnit, rSELF,
- OFFSETOF_MEMBER(Thread, pUpdateDebuggerFromCode),
+ ENTRYPOINT_OFFSET(pUpdateDebuggerFromCode),
rSUSPEND);
#endif
} else {