You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@harmony.apache.org by mc...@apache.org on 2008/05/22 15:34:09 UTC
svn commit: r659108 [9/19] - in /harmony/enhanced/drlvm/trunk/vm: em/src/
gc_gen/src/common/ gc_gen/src/mark_compact/ gc_gen/src/mark_sweep/
gc_gen/src/semi_space/ gc_gen/src/trace_forward/ include/open/
interpreter/src/ jitrino/src/codegenerator/ jitr...
Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/IRBuilder.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/IRBuilder.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/IRBuilder.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/IRBuilder.cpp Thu May 22 06:33:38 2008
@@ -139,13 +139,13 @@
irBuilder.genBranch(instType, mod, label, src1);
}
virtual Inst* genDirectCall(MethodDesc* methodDesc,Type* returnType,Opnd* tauNullCheckedFirstArg,
- Opnd* tauTypesChecked,uint32 numArgs,Opnd* args[])
+ Opnd* tauTypesChecked,U_32 numArgs,Opnd* args[])
{
irBuilder.genDirectCall(methodDesc, returnType, tauNullCheckedFirstArg, tauTypesChecked, numArgs, args);
return (Inst*)irBuilder.getCurrentLabel()->getNode()->getLastInst();
}
// load, store & mov
- virtual Inst* genLdConstant(int32 val) {
+ virtual Inst* genLdConstant(I_32 val) {
return irBuilder.genLdConstant(val)->getInst();
}
virtual Inst* genLdConstant(int64 val) {
@@ -166,7 +166,7 @@
return irBuilder.genTauLdInd(mod, dstType, ldType, src, tauNonNullBase, tauAddressInRange)->getInst();
}
- virtual Inst* genLdRef(Modifier mod, Type* dstType, uint32 token, MethodDesc *enclosingMethod) {
+ virtual Inst* genLdRef(Modifier mod, Type* dstType, U_32 token, MethodDesc *enclosingMethod) {
return irBuilder.genLdRef(mod, dstType, token, enclosingMethod)->getInst();
}
virtual Inst* genLdFunAddrSlot(MethodDesc* methodDesc) {
@@ -223,7 +223,7 @@
virtual void foldBranch(BranchInst* br, bool isTaken) {
assert(0);
}
- virtual void foldSwitch(SwitchInst* sw, uint32 index) {
+ virtual void foldSwitch(SwitchInst* sw, U_32 index) {
assert(0);
}
virtual void eliminateCheck(Inst* checkInst, bool alwaysThrows) {
@@ -370,8 +370,8 @@
return currentLabel;
}
-void IRBuilder::createLabels(uint32 numLabels, LabelInst** labels) {
- for (uint32 i=0; i<numLabels; i++) {
+void IRBuilder::createLabels(U_32 numLabels, LabelInst** labels) {
+ for (U_32 i=0; i<numLabels; i++) {
labels[i] = (LabelInst*)instFactory->makeLabel();
}
}
@@ -394,7 +394,7 @@
src1 = propagateCopy(src1);
src2 = propagateCopy(src2);
Operation operation(Op_Add, dstType->tag, mod);
- uint32 hashcode = operation.encodeForHashing();
+ U_32 hashcode = operation.encodeForHashing();
Opnd* dst = lookupHash(hashcode, src1, src2);
if (dst) return dst;
@@ -415,7 +415,7 @@
src1 = propagateCopy(src1);
src2 = propagateCopy(src2);
Operation operation(Op_Mul, dstType->tag, mod);
- uint32 hashcode = operation.encodeForHashing();
+ U_32 hashcode = operation.encodeForHashing();
Opnd* dst = lookupHash(hashcode, src1, src2);
if (dst) return dst;
@@ -435,7 +435,7 @@
src1 = propagateCopy(src1);
src2 = propagateCopy(src2);
Operation operation(Op_Sub, dstType->tag, mod);
- uint32 hashcode = operation.encodeForHashing();
+ U_32 hashcode = operation.encodeForHashing();
Opnd* dst = lookupHash(hashcode, src1, src2);
if (dst) return dst;
@@ -460,7 +460,7 @@
else
tauDivOk = genTauSafe(); // safe by construction
Operation operation(Op_TauDiv, dstType->tag, mod);
- uint32 hashcode = operation.encodeForHashing();
+ U_32 hashcode = operation.encodeForHashing();
Opnd* dst = lookupHash(hashcode, src1, src2); // tauDivOk is not needed in hash
if (dst) return dst;
@@ -483,7 +483,7 @@
src2 = propagateCopy(src2);
Operation operation(Op_TauDiv, dstType->tag, mod);
- uint32 hashcode = operation.encodeForHashing();
+ U_32 hashcode = operation.encodeForHashing();
Opnd* dst = lookupHash(hashcode, src1, src2); // tauDivOk is not needed in hash
if (dst) return dst;
@@ -516,7 +516,7 @@
src2 = propagateCopy(src2);
Operation operation(Op_TauRem, dstType->tag, mod);
- uint32 hashcode = operation.encodeForHashing();
+ U_32 hashcode = operation.encodeForHashing();
Opnd* dst = lookupHash(hashcode, src1, src2); // tauDivOk is not needed in hash
if (dst) return dst;
@@ -547,7 +547,7 @@
src2 = propagateCopy(src2);
Operation operation(Op_TauRem, dstType->tag, mod);
- uint32 hashcode = operation.encodeForHashing();
+ U_32 hashcode = operation.encodeForHashing();
Opnd* dst = lookupHash(hashcode, src1, src2); // tauDivOk is not needed in hash
if (dst) return dst;
@@ -579,7 +579,7 @@
IRBuilder::genNeg(Type* dstType, Opnd* src) {
src = propagateCopy(src);
Operation operation(Op_Neg, dstType->tag, Modifier());
- uint32 hashcode = operation.encodeForHashing();
+ U_32 hashcode = operation.encodeForHashing();
Opnd* dst = lookupHash(hashcode, src);
if (dst) return dst;
@@ -599,7 +599,7 @@
src1 = propagateCopy(src1);
src2 = propagateCopy(src2);
Operation operation(Op_MulHi, dstType->tag, mod);
- uint32 hashcode = operation.encodeForHashing();
+ U_32 hashcode = operation.encodeForHashing();
Opnd* dst = lookupHash(hashcode, src1, src2);
if (dst) return dst;
@@ -623,7 +623,7 @@
src2 = propagateCopy(src2);
Operation operation(Op_Min, dstType->tag, Modifier());
- uint32 hashcode = operation.encodeForHashing();
+ U_32 hashcode = operation.encodeForHashing();
Opnd* dst = lookupHash(hashcode, src1, src2);
if (dst) return dst;
@@ -706,7 +706,7 @@
src1 = propagateCopy(src1);
src2 = propagateCopy(src2);
Operation operation(Op_Max, dstType->tag, Modifier());
- uint32 hashcode = operation.encodeForHashing();
+ U_32 hashcode = operation.encodeForHashing();
Opnd* dst = lookupHash(hashcode, src1, src2);
if (dst) return dst;
@@ -778,7 +778,7 @@
src1 = propagateCopy(src1);
Operation operation(Op_Abs, dstType->tag, Modifier());
- uint32 hashcode = operation.encodeForHashing();
+ U_32 hashcode = operation.encodeForHashing();
Opnd* dst = lookupHash(hashcode, src1);
if (dst) return dst;
@@ -801,7 +801,7 @@
case Type::Int64:
{
Opnd *zero = ((typeTag == Type::Int32)
- ? genLdConstant((int32)0)
+ ? genLdConstant((I_32)0)
: genLdConstant((int64)0));
Opnd *cmpRes = genCmp(cmpDstType, typeTag,
Cmp_GT, zero, src1);
@@ -931,7 +931,7 @@
{
src = propagateCopy(src);
Operation operation(Op_Conv, toType, ovfMod);
- uint32 hashcode = operation.encodeForHashing();
+ U_32 hashcode = operation.encodeForHashing();
Opnd* dst = lookupHash(hashcode, src->getId());
if (dst) return dst;
@@ -957,7 +957,7 @@
|| (dstType->isObject() && src->getType()->isUnmanagedPtr()));
src = propagateCopy(src);
Operation operation(Op_ConvUnmanaged, toType, ovfMod);
- uint32 hashcode = operation.encodeForHashing();
+ U_32 hashcode = operation.encodeForHashing();
Opnd* dst = lookupHash(hashcode, src->getId());
if (dst) return dst;
@@ -983,7 +983,7 @@
assert(src->getType()->isInteger() && (dstType->isInteger() || dstType->isUnmanagedPtr()));
src = propagateCopy(src);
Operation operation(Op_ConvZE, toType, ovfMod);
- uint32 hashcode = operation.encodeForHashing();
+ U_32 hashcode = operation.encodeForHashing();
Opnd* dst = lookupHash(hashcode, src->getId());
if (dst) return dst;
@@ -1031,7 +1031,7 @@
shiftAmount = propagateCopy(shiftAmount);
Operation operation(Op_Shladd, dstType->tag, mod);
- uint32 hashcode = operation.encodeForHashing();
+ U_32 hashcode = operation.encodeForHashing();
Opnd* dst = lookupHash(hashcode, value, shiftAmount);
if (dst) return dst;
@@ -1055,7 +1055,7 @@
shiftAmount = propagateCopy(shiftAmount);
Operation operation(Op_Shr, dstType->tag, mods);
- uint32 hashcode = operation.encodeForHashing();
+ U_32 hashcode = operation.encodeForHashing();
Opnd* dst = lookupHash(hashcode, value, shiftAmount);
if (dst) return dst;
@@ -1081,7 +1081,7 @@
src2 = propagateCopy(src2);
Operation operation(Op_Cmp, instType, mod);
- uint32 hashcode = operation.encodeForHashing();
+ U_32 hashcode = operation.encodeForHashing();
Opnd* dst = lookupHash(hashcode, src1, src2);
if (dst) return dst;
@@ -1113,7 +1113,7 @@
src1 = propagateCopy(src1);
src2 = propagateCopy(src2);
Operation operation(Op_Cmp3, instType, mod);
- uint32 hashcode = operation.encodeForHashing();
+ U_32 hashcode = operation.encodeForHashing();
Opnd* dst = lookupHash(hashcode, src1, src2);
if (dst) return dst;
@@ -1182,7 +1182,7 @@
}
void
-IRBuilder::genSwitch(uint32 nLabels,
+IRBuilder::genSwitch(U_32 nLabels,
LabelInst* labelInsts[],
LabelInst* defaultLabel,
Opnd* src) {
@@ -1207,7 +1207,7 @@
}
void
-IRBuilder::genThrowLinkingException(Class_Handle encClass, uint32 CPIndex, uint32 operation) {
+IRBuilder::genThrowLinkingException(Class_Handle encClass, U_32 CPIndex, U_32 operation) {
appendInst(instFactory->makeThrowLinkingException(encClass, CPIndex, operation));
}
@@ -1261,11 +1261,11 @@
Opnd* IRBuilder::genIndirectCallWithResolve(Type* returnType,
Opnd* tauNullCheckedFirstArg,
Opnd* tauTypesChecked,
- uint32 numArgs,
+ U_32 numArgs,
Opnd* args[],
ObjectType* ch,
JavaByteCodes bc,
- uint32 cpIndex,
+ U_32 cpIndex,
MethodSignature* sig
)
{
@@ -1280,7 +1280,7 @@
MemoryManager& mm = irManager->getMemoryManager();
Opnd* clsOpnd = createTypeOpnd(ch);
Opnd* idxOpnd = genLdConstant((int)cpIndex);
- uint32 numHelperArgs = 0;
+ U_32 numHelperArgs = 0;
Opnd** helperArgs = new(mm)Opnd*[3];
helperArgs[0] = clsOpnd;
helperArgs[1] = idxOpnd;
@@ -1319,7 +1319,7 @@
Type* returnType,
Opnd* tauNullCheckedFirstArg,
Opnd* tauTypesChecked,
- uint32 numArgs,
+ U_32 numArgs,
Opnd* args[])
{
if (!tauNullCheckedFirstArg)
@@ -1336,7 +1336,7 @@
tauNullCheckedFirstArg, tauTypesChecked,
numArgs, args);
}
- for (uint32 i=0; i<numArgs; i++) {
+ for (U_32 i=0; i<numArgs; i++) {
args[i] = propagateCopy(args[i]);
}
Opnd* dst = createOpnd(returnType);
@@ -1353,7 +1353,7 @@
Type* returnType,
Opnd* tauNullCheckedFirstArg,
Opnd* tauTypesChecked,
- uint32 numArgs,
+ U_32 numArgs,
Opnd* args[])
{
if(!methodDesc->isVirtual())
@@ -1361,7 +1361,7 @@
return genDirectCall(methodDesc, returnType,
tauNullCheckedFirstArg, tauTypesChecked,
numArgs, args);
- for (uint32 i=0; i<numArgs; i++) {
+ for (U_32 i=0; i<numArgs; i++) {
args[i] = propagateCopy(args[i]);
}
// callvirt can throw a null pointer exception
@@ -1406,9 +1406,9 @@
Opnd*
IRBuilder::genJitHelperCall(JitHelperCallId helperId,
Type* returnType,
- uint32 numArgs,
+ U_32 numArgs,
Opnd* args[]) {
- for (uint32 i=0; i<numArgs; i++) {
+ for (U_32 i=0; i<numArgs; i++) {
args[i] = propagateCopy(args[i]);
}
Opnd * dst = createOpnd(returnType);
@@ -1421,9 +1421,9 @@
Type* returnType,
Opnd* tauNullCheckedRefArgs,
Opnd* tauTypesChecked,
- uint32 numArgs,
+ U_32 numArgs,
Opnd* args[]) {
- for (uint32 i=0; i<numArgs; i++) {
+ for (U_32 i=0; i<numArgs; i++) {
args[i] = propagateCopy(args[i]);
}
Opnd * dst = createOpnd(returnType);
@@ -1434,9 +1434,9 @@
Opnd*
IRBuilder::genVMHelperCall(VM_RT_SUPPORT helperId,
Type* returnType,
- uint32 numArgs,
+ U_32 numArgs,
Opnd* args[]) {
- for (uint32 i=0; i<numArgs; i++) {
+ for (U_32 i=0; i<numArgs; i++) {
args[i] = propagateCopy(args[i]);
}
Opnd * dst = createOpnd(returnType);
@@ -1465,10 +1465,10 @@
Opnd* funAddr,
Opnd* tauNullCheckedFirstArg,
Opnd* tauTypesChecked,
- uint32 numArgs,
+ U_32 numArgs,
Opnd* args[])
{
- for (uint32 i=0; i<numArgs; i++) {
+ for (U_32 i=0; i<numArgs; i++) {
args[i] = propagateCopy(args[i]);
}
Opnd* dst = createOpnd(returnType);
@@ -1492,10 +1492,10 @@
Opnd* funAddr,
Opnd* tauNullCheckedFirstArg,
Opnd* tauTypesChecked,
- uint32 numArgs,
+ U_32 numArgs,
Opnd* args[])
{
- for (uint32 i=0; i<numArgs; i++) {
+ for (U_32 i=0; i<numArgs; i++) {
args[i] = propagateCopy(args[i]);
}
@@ -1589,8 +1589,8 @@
// Phi-node instruction
Opnd*
-IRBuilder::genPhi(uint32 numArgs, Opnd* args[]) {
- for (uint32 i=0; i<numArgs; i++) {
+IRBuilder::genPhi(U_32 numArgs, Opnd* args[]) {
+ for (U_32 i=0; i<numArgs; i++) {
args[i] = propagateCopy(args[i]);
}
Opnd* dst = createOpnd(args[0]->getType());
@@ -1610,34 +1610,34 @@
// load instructions
Opnd*
-IRBuilder::genLdConstant(int32 val) {
+IRBuilder::genLdConstant(I_32 val) {
Operation operation(Op_LdConstant, Type::Int32, Modifier());
- uint32 hashcode = operation.encodeForHashing();
- Opnd* dst = lookupHash(hashcode, (uint32) val);
+ U_32 hashcode = operation.encodeForHashing();
+ Opnd* dst = lookupHash(hashcode, (U_32) val);
if (dst) return dst;
dst = createOpnd(typeManager->getInt32Type());
appendInst(instFactory->makeLdConst(dst, val));
- insertHash(hashcode, (uint32) val, dst->getInst());
+ insertHash(hashcode, (U_32) val, dst->getInst());
return dst;
}
Opnd*
IRBuilder::genLdConstant(int64 val) {
Operation operation(Op_LdConstant, Type::Int64, Modifier());
- uint32 hashcode = operation.encodeForHashing();
- Opnd* dst = lookupHash(hashcode, (uint32) (val >> 32), (uint32) (val & 0xffffffff));
+ U_32 hashcode = operation.encodeForHashing();
+ Opnd* dst = lookupHash(hashcode, (U_32) (val >> 32), (U_32) (val & 0xffffffff));
if (dst) return dst;
dst = createOpnd(typeManager->getInt64Type());
appendInst(instFactory->makeLdConst(dst, val));
- insertHash(hashcode, (uint32) (val >> 32), (uint32) (val & 0xffffffff), dst->getInst());
+ insertHash(hashcode, (U_32) (val >> 32), (U_32) (val & 0xffffffff), dst->getInst());
return dst;
}
Opnd* IRBuilder::genLdConstant(float val) {
ConstInst::ConstValue cv;
cv.s = val;
- uint32 word1 = cv.dword1;
- uint32 word2 = cv.dword2;
+ U_32 word1 = cv.dword1;
+ U_32 word2 = cv.dword2;
Operation operation(Op_LdConstant, Type::Single, Modifier());
- uint32 hashcode = operation.encodeForHashing();
+ U_32 hashcode = operation.encodeForHashing();
Opnd* dst = lookupHash(hashcode, word1, word2);
if (dst) return dst;
dst = createOpnd(typeManager->getSingleType());
@@ -1649,10 +1649,10 @@
IRBuilder::genLdConstant(double val) {
ConstInst::ConstValue cv;
cv.d = val;
- uint32 word1 = cv.dword1;
- uint32 word2 = cv.dword2;
+ U_32 word1 = cv.dword1;
+ U_32 word2 = cv.dword2;
Operation operation(Op_LdConstant, Type::Double, Modifier());
- uint32 hashcode = operation.encodeForHashing();
+ U_32 hashcode = operation.encodeForHashing();
Opnd* dst = lookupHash(hashcode, word1, word2);
if (dst) return dst;
dst = createOpnd(typeManager->getDoubleType());
@@ -1662,10 +1662,10 @@
}
Opnd*
IRBuilder::genLdConstant(Type *ptrtype, ConstInst::ConstValue val) {
- uint32 word1 = val.dword1;
- uint32 word2 = val.dword2;
+ U_32 word1 = val.dword1;
+ U_32 word2 = val.dword2;
Operation operation(Op_LdConstant, ptrtype->tag, Modifier());
- uint32 hashcode = operation.encodeForHashing();
+ U_32 hashcode = operation.encodeForHashing();
Opnd* dst = lookupHash(hashcode, word1, word2);
if (dst) return dst;
dst = createOpnd(ptrtype);
@@ -1677,10 +1677,10 @@
IRBuilder::genLdFloatConstant(double val) {
ConstInst::ConstValue cv;
cv.d = val;
- uint32 word1 = cv.dword1;
- uint32 word2 = cv.dword2;
+ U_32 word1 = cv.dword1;
+ U_32 word2 = cv.dword2;
Operation operation(Op_LdConstant, Type::Float, Modifier());
- uint32 hashcode = operation.encodeForHashing();
+ U_32 hashcode = operation.encodeForHashing();
Opnd* dst = lookupHash(hashcode, word1, word2);
if (dst) return dst;
dst = createOpnd(typeManager->getFloatType());
@@ -1694,10 +1694,10 @@
cv.dword1 = 0;
cv.dword2 = 0;
cv.s = val;
- uint32 word1 = cv.dword1;
- uint32 word2 = cv.dword2;
+ U_32 word1 = cv.dword1;
+ U_32 word2 = cv.dword2;
Operation operation(Op_LdConstant, Type::Float, Modifier());
- uint32 hashcode = operation.encodeForHashing();
+ U_32 hashcode = operation.encodeForHashing();
Opnd* dst = lookupHash(hashcode, word1, word2);
if (dst) return dst;
dst = createOpnd(typeManager->getFloatType());
@@ -1708,7 +1708,7 @@
Opnd*
IRBuilder::genLdNull() {
Operation operation(Op_LdConstant, Type::NullObject, Modifier());
- uint32 hashcode = operation.encodeForHashing();
+ U_32 hashcode = operation.encodeForHashing();
Opnd* dst = lookupHash(hashcode);
if (dst) return dst;
dst = createOpnd(typeManager->getNullObjectType());
@@ -1718,7 +1718,7 @@
}
Opnd*
-IRBuilder::genLdRef(MethodDesc* enclosingMethod, uint32 stringToken, Type* type) {
+IRBuilder::genLdRef(MethodDesc* enclosingMethod, U_32 stringToken, Type* type) {
bool uncompress = irBuilderFlags.compressedReferences;
Modifier mod = uncompress ? AutoCompress_Yes : AutoCompress_No;
@@ -1729,7 +1729,7 @@
}
Opnd*
-IRBuilder::genLdToken(MethodDesc* enclosingMethod, uint32 metadataToken) {
+IRBuilder::genLdToken(MethodDesc* enclosingMethod, U_32 metadataToken) {
Opnd* dst = createOpnd(typeManager->getSystemObjectType());
appendInst(instFactory->makeLdToken(dst, enclosingMethod, metadataToken));
return dst;
@@ -1795,7 +1795,7 @@
Opnd*
IRBuilder::genLdRef(Modifier mod, Type* type,
- uint32 token, MethodDesc *enclosingMethod)
+ U_32 token, MethodDesc *enclosingMethod)
{
Opnd* dst = createOpnd(type);
appendInst(instFactory->makeLdRef(mod, dst, enclosingMethod, token));
@@ -1830,7 +1830,7 @@
}
Opnd*
-IRBuilder::genLdFieldWithResolve(Type* type, Opnd* base, ObjectType* enclClass, uint32 cpIndex) {
+IRBuilder::genLdFieldWithResolve(Type* type, Opnd* base, ObjectType* enclClass, U_32 cpIndex) {
base = propagateCopy(base);
Opnd *tauNullCheck = genTauCheckNull(base);
Opnd *tauAddressInRange = genTauSafe();
@@ -1864,7 +1864,7 @@
}
Opnd*
-IRBuilder::genLdStaticWithResolve(Type* type, ObjectType* enclClass, uint32 cpIdx) {
+IRBuilder::genLdStaticWithResolve(Type* type, ObjectType* enclClass, U_32 cpIdx) {
bool uncompress = false;
if (irBuilderFlags.compressedReferences && type->isObject()) {
assert(!type->isCompressedReference());
@@ -1970,7 +1970,7 @@
}
Opnd*
-IRBuilder::genLdFieldAddrWithResolve(Type* type, Opnd* base, ObjectType* enclClass, uint32 cpIndex, bool putfield) {
+IRBuilder::genLdFieldAddrWithResolve(Type* type, Opnd* base, ObjectType* enclClass, U_32 cpIndex, bool putfield) {
base = propagateCopy(base);
genTauCheckNull(base);
@@ -2025,7 +2025,7 @@
}
Opnd*
-IRBuilder::genLdStaticAddrWithResolve(Type* type, ObjectType* enclClass, uint32 cpIndex, bool putfield) {
+IRBuilder::genLdStaticAddrWithResolve(Type* type, ObjectType* enclClass, U_32 cpIndex, bool putfield) {
JavaByteCodes opcode = putfield ? OPCODE_PUTSTATIC : OPCODE_GETSTATIC;
Opnd* dst = lookupHash(Op_VMHelperCall, opcode, cpIndex);
if (dst) return dst;
@@ -2620,7 +2620,7 @@
void
-IRBuilder::genStFieldWithResolve(Type* type, Opnd* base, ObjectType* enclClass, uint32 cpIdx, Opnd* src) {
+IRBuilder::genStFieldWithResolve(Type* type, Opnd* base, ObjectType* enclClass, U_32 cpIdx, Opnd* src) {
base = propagateCopy(base);
src = propagateCopy(src);
Opnd *tauBaseNonNull = genTauCheckNull(base);
@@ -2643,7 +2643,7 @@
void
-IRBuilder::genStStaticWithResolve(Type* type, ObjectType* enclClass, uint32 cpIdx, Opnd* src) {
+IRBuilder::genStStaticWithResolve(Type* type, ObjectType* enclClass, U_32 cpIdx, Opnd* src) {
src = propagateCopy(src);
Opnd *tauOk = genTauSafe(); // address is always ok
Opnd *tauTypeIsOk = type->isObject() ? genTauHasType(src, type) : genTauSafe();
@@ -2772,7 +2772,7 @@
}
Opnd*
-IRBuilder::genNewObjWithResolve(ObjectType* enclClass, uint32 cpIndex) {
+IRBuilder::genNewObjWithResolve(ObjectType* enclClass, U_32 cpIndex) {
Opnd* clsOpnd = createTypeOpnd(enclClass);
Opnd* idxOpnd = genLdConstant((int)cpIndex);
Opnd** args = new (irManager->getMemoryManager()) Opnd*[2];
@@ -2783,7 +2783,7 @@
}
Opnd*
-IRBuilder::genNewArrayWithResolve(NamedType* elemType, Opnd* numElems, ObjectType* enclClass, uint32 cpIndex) {
+IRBuilder::genNewArrayWithResolve(NamedType* elemType, Opnd* numElems, ObjectType* enclClass, U_32 cpIndex) {
numElems = propagateCopy(numElems);
Opnd* clsOpnd = createTypeOpnd(enclClass);
Opnd* idxOpnd = genLdConstant((int)cpIndex);
@@ -2806,11 +2806,11 @@
Opnd*
IRBuilder::genMultianewarray(NamedType* arrayType,
- uint32 dimensions,
+ U_32 dimensions,
Opnd** numElems) {
NamedType* elemType = arrayType;
// create an array of arrays type
- for (uint32 i=0; i<dimensions; i++) {
+ for (U_32 i=0; i<dimensions; i++) {
elemType = ((ArrayType*)elemType)->getElementType();
}
Opnd* dst = createOpnd(arrayType);
@@ -2821,8 +2821,8 @@
Opnd*
IRBuilder::genMultianewarrayWithResolve(NamedType* arrayType,
ObjectType* enclClass,
- uint32 cpIndex,
- uint32 dimensions,
+ U_32 cpIndex,
+ U_32 dimensions,
Opnd** numElems)
{
Opnd* enclClsOpnd = createTypeOpnd(enclClass);
@@ -2839,10 +2839,10 @@
args2[0]=clsOpnd;
args2[1]=genLdConstant((int)dimensions);
// create an array of arrays type
- for (uint32 i=0; i<dimensions; i++) {
+ for (U_32 i=0; i<dimensions; i++) {
args2[i+2]=numElems[dimensions-1-i];
}
- Opnd* dst = genVMHelperCall(VM_RT_MULTIANEWARRAY_RESOLVED, arrayType, (uint32)nArgs2, args2);
+ Opnd* dst = genVMHelperCall(VM_RT_MULTIANEWARRAY_RESOLVED, arrayType, (U_32)nArgs2, args2);
return dst;
}
@@ -2972,7 +2972,7 @@
// type checking
// CastException (succeeds if argument is null, returns casted object)
Opnd*
-IRBuilder::genCastWithResolve(Opnd* src, Type* type, ObjectType* enclClass, uint32 cpIndex) {
+IRBuilder::genCastWithResolve(Opnd* src, Type* type, ObjectType* enclClass, U_32 cpIndex) {
src = propagateCopy(src);
Opnd* dst = lookupHash(Op_VMHelperCall, OPCODE_CHECKCAST, src->getId(), cpIndex);
if (dst) return dst;
@@ -3054,7 +3054,7 @@
}
Opnd*
-IRBuilder::genInstanceOfWithResolve(Opnd* src, ObjectType* enclClass, uint32 cpIndex) {
+IRBuilder::genInstanceOfWithResolve(Opnd* src, ObjectType* enclClass, U_32 cpIndex) {
src = propagateCopy(src);
Opnd* dst = lookupHash(Op_VMHelperCall, OPCODE_INSTANCEOF, src->getId(), cpIndex);
@@ -3340,7 +3340,7 @@
// Methods for CSE hashing
//
//-----------------------------------------------------------------------------
-Opnd* IRBuilder::lookupHash(uint32 opc) {
+Opnd* IRBuilder::lookupHash(U_32 opc) {
if (! irBuilderFlags.doCSE)
return NULL;
Inst* inst = cseHashTable->lookup(opc);
@@ -3350,7 +3350,7 @@
return NULL;
}
-Opnd* IRBuilder::lookupHash(uint32 opc, uint32 op) {
+Opnd* IRBuilder::lookupHash(U_32 opc, U_32 op) {
if (! irBuilderFlags.doCSE)
return NULL;
Inst* inst = cseHashTable->lookup(opc, op);
@@ -3360,7 +3360,7 @@
return NULL;
}
-Opnd* IRBuilder::lookupHash(uint32 opc, uint32 op1, uint32 op2) {
+Opnd* IRBuilder::lookupHash(U_32 opc, U_32 op1, U_32 op2) {
if (! irBuilderFlags.doCSE)
return NULL;
Inst* inst = cseHashTable->lookup(opc, op1, op2);
@@ -3370,7 +3370,7 @@
return NULL;
}
-Opnd* IRBuilder::lookupHash(uint32 opc, uint32 op1, uint32 op2, uint32 op3) {
+Opnd* IRBuilder::lookupHash(U_32 opc, U_32 op1, U_32 op2, U_32 op3) {
if (! irBuilderFlags.doCSE)
return NULL;
Inst* inst = cseHashTable->lookup(opc, op1, op2, op3);
@@ -3380,25 +3380,25 @@
return NULL;
}
-void IRBuilder::insertHash(uint32 opc, Inst* inst) {
+void IRBuilder::insertHash(U_32 opc, Inst* inst) {
if (! irBuilderFlags.doCSE)
return;
cseHashTable->insert(opc, inst);
}
-void IRBuilder::insertHash(uint32 opc, uint32 op1, Inst* inst) {
+void IRBuilder::insertHash(U_32 opc, U_32 op1, Inst* inst) {
if (! irBuilderFlags.doCSE)
return;
cseHashTable->insert(opc, op1, inst);
}
-void IRBuilder::insertHash(uint32 opc, uint32 op1, uint32 op2, Inst* inst) {
+void IRBuilder::insertHash(U_32 opc, U_32 op1, U_32 op2, Inst* inst) {
if (! irBuilderFlags.doCSE)
return;
cseHashTable->insert(opc, op1, op2, inst);
}
-void IRBuilder::insertHash(uint32 opc, uint32 op1, uint32 op2, uint32 op3,
+void IRBuilder::insertHash(U_32 opc, U_32 op1, U_32 op2, U_32 op3,
Inst* inst) {
if (! irBuilderFlags.doCSE)
return;
@@ -3460,7 +3460,7 @@
Opnd*
IRBuilder::genTauStaticCast(Opnd *src, Opnd *tauCheckedCast, Type *castType) {
Operation operation(Op_TauStaticCast, castType->tag, Modifier());
- uint32 hashcode = operation.encodeForHashing();
+ U_32 hashcode = operation.encodeForHashing();
Opnd* dst = lookupHash(hashcode, src->getId(), tauCheckedCast->getId(), castType->getId());
if (dst) return dst;
@@ -3469,7 +3469,7 @@
insertHash(hashcode, src->getId(), tauCheckedCast->getId(), castType->getId(), dst->getInst());
Operation hasTypeOperation(Op_TauHasType, castType->tag, Modifier());
- uint32 hasTypeHashcode = hasTypeOperation.encodeForHashing();
+ U_32 hasTypeHashcode = hasTypeOperation.encodeForHashing();
insertHash(hasTypeHashcode, src->getId(), castType->getId(), tauCheckedCast->getId(),
dst->getInst());
return dst;
@@ -3478,7 +3478,7 @@
Opnd*
IRBuilder::genTauHasType(Opnd *src, Type *castType) {
Operation operation(Op_TauHasType, castType->tag, Modifier());
- uint32 hashcode = operation.encodeForHashing();
+ U_32 hashcode = operation.encodeForHashing();
Opnd* dst = lookupHash(hashcode, src->getId(), castType->getId());
if (dst) return dst;
@@ -3505,7 +3505,7 @@
Opnd*
IRBuilder::genTauHasExactType(Opnd *src, Type *castType) {
Operation operation(Op_TauHasExactType, castType->tag, Modifier());
- uint32 hashcode = operation.encodeForHashing();
+ U_32 hashcode = operation.encodeForHashing();
Opnd* dst = lookupHash(hashcode, src->getId(), castType->getId());
if (dst) return dst;
@@ -3518,7 +3518,7 @@
Opnd*
IRBuilder::genTauIsNonNull(Opnd *src) {
- uint32 hashcode = Op_TauCheckNull;
+ U_32 hashcode = Op_TauCheckNull;
Opnd* dst = lookupHash(hashcode, src->getId());
if (dst) return dst;
Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/IRBuilder.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/IRBuilder.h?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/IRBuilder.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/IRBuilder.h Thu May 22 06:33:38 2008
@@ -118,7 +118,7 @@
void genBranch(Type::Tag instType, ComparisonModifier mod, LabelInst* label, Opnd* src1, Opnd* src2); // TR //SI
void genBranch(Type::Tag instType, ComparisonModifier mod, LabelInst* label, Opnd* src); // TR //SI
void genJump(LabelInst* label); //TR
- void genSwitch(uint32 numLabels, LabelInst* label[], LabelInst* defaultLabel, Opnd* src);//TR
+ void genSwitch(U_32 numLabels, LabelInst* label[], LabelInst* defaultLabel, Opnd* src);//TR
// Calls
@@ -127,11 +127,11 @@
Opnd* genIndirectCallWithResolve(Type* returnType,
Opnd* tauNullCheckedFirstArg,
Opnd* tauTypesChecked,
- uint32 numArgs,
+ U_32 numArgs,
Opnd* args[],
ObjectType* ch,
JavaByteCodes bc,
- uint32 cpIndex,
+ U_32 cpIndex,
MethodSignature* sig
);
@@ -139,37 +139,37 @@
Type* returnType,
Opnd* tauNullCheckedFirstArg, // 0 for unsafe
Opnd* tauTypesChecked, // 0 to let IRBuilder find taus
- uint32 numArgs,
+ U_32 numArgs,
Opnd* args[]);
Opnd* genTauVirtualCall(MethodDesc* methodDesc,//TR
Type* returnType,
Opnd* tauNullCheckedFirstArg, // 0 to let IRBuilder add check
Opnd* tauTypesChecked, // 0 to let IRBuilder find it
- uint32 numArgs,
+ U_32 numArgs,
Opnd* args[]);
Opnd* genIndirectCall( Type* returnType, //TR
Opnd* funAddr,
Opnd* tauNullCheckedFirstArg, // 0 for unsafe
Opnd* tauTypesChecked, // 0 to let IRBuilder find it
- uint32 numArgs,
+ U_32 numArgs,
Opnd* args[]);
Opnd* genJitHelperCall(JitHelperCallId helperId,
Type* returnType,
- uint32 numArgs,
+ U_32 numArgs,
Opnd* args[]);
Opnd* genJitHelperCall(JitHelperCallId helperId,
Type* returnType,
Opnd* tauNullCheckedRefArgs,
Opnd* tauTypesChecked,
- uint32 numArgs,
+ U_32 numArgs,
Opnd* args[]);
Opnd* genVMHelperCall(VM_RT_SUPPORT helperId,
Type* returnType,
- uint32 numArgs,
+ U_32 numArgs,
Opnd* args[]);
@@ -179,7 +179,7 @@
void genThrow(ThrowModifier mod, Opnd* exceptionObj);//TR
void genPseudoThrow();//TR
void genThrowSystemException(CompilationInterface::SystemExceptionId);//SI
- void genThrowLinkingException(Class_Handle encClass, uint32 CPIndex, uint32 operation);//SI
+ void genThrowLinkingException(Class_Handle encClass, U_32 CPIndex, U_32 operation);//SI
void genLeave(LabelInst* label);//TR
void genEndFinally(); // TR
void genEndFilter(); // TR
@@ -188,7 +188,7 @@
void genRet(Opnd *src);//TR
Opnd* genSaveRet();//TR
// load, store & move
- Opnd* genLdConstant(int32 val); //TR //SI
+ Opnd* genLdConstant(I_32 val); //TR //SI
Opnd* genLdConstant(int64 val); //TR //SI
Opnd* genLdConstant(float val); //TR //SI
Opnd* genLdConstant(double val); //TR //SI
@@ -197,7 +197,7 @@
Opnd* genLdFloatConstant(double val);//TR
Opnd* genLdNull();//TR
- Opnd* genLdRef(MethodDesc* enclosingMethod, uint32 stringToken, Type* type);//TR
+ Opnd* genLdRef(MethodDesc* enclosingMethod, U_32 stringToken, Type* type);//TR
Opnd* genLdVar(Type* dstType, VarOpnd* var);//TR
Opnd* genLdVarAddr(VarOpnd* var);//TR
Opnd* genLdInd(Type*, Opnd* ptr); // for use by front-ends, but not simplifier//TR
@@ -207,16 +207,16 @@
Opnd* genLdElem(Type* elemType, Opnd* array, Opnd* index,
Opnd* tauNullCheck, Opnd* tauAddressInRange);
Opnd* genLdFieldAddr(Type* fieldType, Opnd* base, FieldDesc* fieldDesc); //TR
- Opnd* genLdFieldAddrWithResolve(Type* fieldType, Opnd* base, ObjectType* enclClass, uint32 cpIndex, bool putfield); //TR
+ Opnd* genLdFieldAddrWithResolve(Type* fieldType, Opnd* base, ObjectType* enclClass, U_32 cpIndex, bool putfield); //TR
Opnd* genLdStaticAddr(Type* fieldType, FieldDesc* fieldDesc);//TR
- Opnd* genLdStaticAddrWithResolve(Type* fieldType, ObjectType* enclClass, uint32 cpIndex, bool putfield);//TR
+ Opnd* genLdStaticAddrWithResolve(Type* fieldType, ObjectType* enclClass, U_32 cpIndex, bool putfield);//TR
Opnd* genLdElemAddr(Type* elemType, Opnd* array, Opnd* index);//TR
Opnd* genLdVirtFunAddr(Opnd* base, MethodDesc* methodDesc);//TR
Opnd* genLdFunAddr(MethodDesc* methodDesc);//TR
Opnd* genArrayLen(Type* dstType, Type::Tag type, Opnd* array); // TR
- Opnd* genLdFieldWithResolve(Type*, Opnd* base, ObjectType* enclClass, uint32 cpIdx); //TR
- Opnd* genLdStaticWithResolve(Type*, ObjectType* enclClass, uint32 cpIdx);//TR
+ Opnd* genLdFieldWithResolve(Type*, Opnd* base, ObjectType* enclClass, U_32 cpIdx); //TR
+ Opnd* genLdStaticWithResolve(Type*, ObjectType* enclClass, U_32 cpIdx);//TR
// store instructions
void genStVar(VarOpnd* var, Opnd* src);//TR
@@ -227,8 +227,8 @@
Opnd* tauNullCheck, Opnd* tauBaseTypeCheck, Opnd* tauAddressInRange);
void genStInd(Type*, Opnd* ptr, Opnd* src);//TR
- void genStFieldWithResolve(Type*, Opnd* base, ObjectType* enclClass, uint32 cpIdx, Opnd* src);//TR
- void genStStaticWithResolve(Type*, ObjectType* enclClass, uint32 cpIdx, Opnd* src);//TR
+ void genStFieldWithResolve(Type*, Opnd* base, ObjectType* enclClass, U_32 cpIdx, Opnd* src);//TR
+ void genStStaticWithResolve(Type*, ObjectType* enclClass, U_32 cpIdx, Opnd* src);//TR
// checks
Opnd* genTauCheckNull(Opnd* base);
@@ -236,12 +236,12 @@
Opnd* genCheckFinite(Type* dstType, Opnd* src); // TR
// allocation
Opnd* genNewObj(Type* type);//TR
- Opnd* genNewObjWithResolve(ObjectType* enclClass, uint32 cpIndex);//TR
+ Opnd* genNewObjWithResolve(ObjectType* enclClass, U_32 cpIndex);//TR
Opnd* genNewArray(NamedType* elemType, Opnd* numElems);//TR
- Opnd* genNewArrayWithResolve(NamedType* elemType, Opnd* numElems, ObjectType* enclClass, uint32 cpIndex);//TR
- Opnd* genMultianewarray(NamedType* arrayType, uint32 dimensions, Opnd** numElems);//TR
- Opnd* genMultianewarrayWithResolve(NamedType* arrayType, ObjectType* enclClass, uint32 cpIndex, uint32 dimensions, Opnd** numElems);//TR
- //Opnd* genMultianewarrayWithResolve(NamedType* arrayType, uint32 dimensions, Opnd** numElems);//TR
+ Opnd* genNewArrayWithResolve(NamedType* elemType, Opnd* numElems, ObjectType* enclClass, U_32 cpIndex);//TR
+ Opnd* genMultianewarray(NamedType* arrayType, U_32 dimensions, Opnd** numElems);//TR
+ Opnd* genMultianewarrayWithResolve(NamedType* arrayType, ObjectType* enclClass, U_32 cpIndex, U_32 dimensions, Opnd** numElems);//TR
+ //Opnd* genMultianewarrayWithResolve(NamedType* arrayType, U_32 dimensions, Opnd** numElems);//TR
// sync
void genMonitorEnter(Opnd* src); // also inserts nullcheck of src//TR
void genMonitorExit(Opnd* src); // also inserts nullcheck of src//TR
@@ -251,17 +251,17 @@
// lowered parts of monitor enter/exit;
// these assume src is already checked and is not null
Opnd* genLdLockAddr(Type *dstType, Opnd *obj); // result is ref:int16//TR
- Opnd* genBalancedMonitorEnter(Type *dstType, Opnd* src, Opnd *lockAddr); // result is int32 // TR
+ Opnd* genBalancedMonitorEnter(Type *dstType, Opnd* src, Opnd *lockAddr); // result is I_32 // TR
void genBalancedMonitorExit(Opnd* src, Opnd *lockAddr, Opnd *oldValue); // TR
// type checking
// CastException (succeeds if argument is null, returns casted object)
Opnd* genCast(Opnd* src, Type* type); // TR
- Opnd* genCastWithResolve(Opnd* src, Type* type, ObjectType* enclClass, uint32 cpIndex); // TR
+ Opnd* genCastWithResolve(Opnd* src, Type* type, ObjectType* enclClass, U_32 cpIndex); // TR
// returns trueResult if src is an instance of type, 0 otherwise
Opnd* genAsType(Opnd* src, Type* type); // TR
// returns 1 if src is not null and an instance of type, 0 otherwise
Opnd* genInstanceOf(Opnd* src, Type* type); //TR
- Opnd* genInstanceOfWithResolve(Opnd* src, ObjectType* enclClass, uint32 cpIndex); //TR
+ Opnd* genInstanceOfWithResolve(Opnd* src, ObjectType* enclClass, U_32 cpIndex); //TR
void genInitType(NamedType* type); //TR
// labels
void genLabel(LabelInst* labelInst); //TR
@@ -279,7 +279,7 @@
Opnd* genRefAnyVal(Type* type, Opnd* typedRef);//TR
Opnd* genUnbox(Type* type, Opnd* obj);//TR
Opnd* genBox(Type* type, Opnd* val); // TR
- Opnd* genLdToken(MethodDesc* enclosingMethod, uint32 metadataToken);//TR
+ Opnd* genLdToken(MethodDesc* enclosingMethod, U_32 metadataToken);//TR
// block instructions
void genCopyBlock(Opnd* dstAddr, Opnd* srcAddr, Opnd* size); // TR
void genInitBlock(Opnd* dstAddr, Opnd* val, Opnd* size); //TR
@@ -294,12 +294,12 @@
Opnd* genArgDef(Modifier, Type*); // TR
VarOpnd* genVarDef(Type*, bool isPinned);//TR
// Phi-node instruction
- Opnd* genPhi(uint32 numArgs, Opnd* args[]);//TR
+ Opnd* genPhi(U_32 numArgs, Opnd* args[]);//TR
// label manipulation for translators
LabelInst* createLabel();
// this should really be genBlocks
- void createLabels(uint32 numLabels, LabelInst** labels);
+ void createLabels(U_32 numLabels, LabelInst** labels);
void killCSE();
LabelInst* getCurrentLabel() {return currentLabel;}
@@ -313,7 +313,7 @@
// Control flow
// load, store & move
Opnd* genLdRef(Modifier mod, Type *dstType,//TR //SI
- uint32 token, MethodDesc *enclosingMethod); // for simplifier use
+ U_32 token, MethodDesc *enclosingMethod); // for simplifier use
Opnd* genTauLdInd(Modifier mod, Type *dstType, Type::Tag ldType, Opnd *ptr, //SI
Opnd *tauNonNullBase, Opnd *tauAddressInRange); // for simplifier use
Opnd* genLdFunAddrSlot(MethodDesc* methodDesc); //SI
@@ -331,7 +331,7 @@
Opnd* funAddr,
Opnd* tauNullCheckedFirstArg, // 0 to let IRBuilder add check
Opnd* tauTypesChecked, // 0 to let IRBuilder find it
- uint32 numArgs,
+ U_32 numArgs,
Opnd* args[]);
Opnd* genLdElemAddrNoChecks(Type *elemType, Opnd* array, Opnd* index);
@@ -355,7 +355,7 @@
Opnd* genTauArrayLen(Type* dstType, Type::Tag type, Opnd* array,
Opnd *tauNullChecked, Opnd *tauBaseTypeChecked);
Opnd* genTauBalancedMonitorEnter(Type *dstType, Opnd* src, Opnd *lockAddr,
- Opnd *tauNullChecked); // result is int32
+ Opnd *tauNullChecked); // result is I_32
Opnd* genTauCheckFinite(Opnd* src);
// tau operations
Opnd* genTauSafe();
@@ -384,12 +384,12 @@
// these assume src is already checked and is not null
void genIncRecCount(Opnd *obj, Opnd *oldLock); // result is ref:int16
Opnd* genTauOptimisticBalancedMonitorEnter(Type *dstType, Opnd* src, Opnd *lockAddr,
- Opnd *tauNullChecked); // result is int32
+ Opnd *tauNullChecked); // result is I_32
void genOptimisticBalancedMonitorExit(Opnd* src, Opnd *lockAddr, Opnd *oldValue);
void genMonitorEnterFence(Opnd *src);
void genMonitorExitFence(Opnd *src);
// checks
- void genSourceLineNumber(uint32 fileId, uint32 lineNumber);
+ void genSourceLineNumber(U_32 fileId, U_32 lineNumber);
private:
@@ -407,23 +407,23 @@
Opnd* createOpnd(Type*);
PiOpnd* createPiOpnd(Opnd *org);
Opnd* createTypeOpnd(ObjectType* type);
- Opnd* lookupHash(uint32 opc);
- Opnd* lookupHash(uint32 opc, uint32 op);
- Opnd* lookupHash(uint32 opc, uint32 op1, uint32 op2);
- Opnd* lookupHash(uint32 opc, uint32 op1, uint32 op2, uint32 op3);
- Opnd* lookupHash(uint32 opc, Opnd* op) { return lookupHash(opc, op->getId()); };
- Opnd* lookupHash(uint32 opc, Opnd* op1, Opnd* op2) { return lookupHash(opc, op1->getId(), op2->getId()); };
- Opnd* lookupHash(uint32 opc, Opnd* op1, Opnd* op2, Opnd* op3) { return lookupHash(opc, op1->getId(), op2->getId(), op3->getId()); };
- void insertHash(uint32 opc, Inst*);
- void insertHash(uint32 opc, uint32 op, Inst*);
- void insertHash(uint32 opc, uint32 op1, uint32 op2, Inst*);
- void insertHash(uint32 opc, uint32 op1, uint32 op2, uint32 op3, Inst*);
- void insertHash(uint32 opc, Opnd* op, Inst*i) { insertHash(opc, op->getId(), i); };
- void insertHash(uint32 opc, Opnd* op1, Opnd* op2, Inst*i) { insertHash(opc, op1->getId(), op2->getId(), i); };
- void insertHash(uint32 opc, Opnd* op1, Opnd* op2, Opnd* op3, Inst*i) { insertHash(opc, op1->getId(), op2->getId(), op3->getId(), i); };
+ Opnd* lookupHash(U_32 opc);
+ Opnd* lookupHash(U_32 opc, U_32 op);
+ Opnd* lookupHash(U_32 opc, U_32 op1, U_32 op2);
+ Opnd* lookupHash(U_32 opc, U_32 op1, U_32 op2, U_32 op3);
+ Opnd* lookupHash(U_32 opc, Opnd* op) { return lookupHash(opc, op->getId()); };
+ Opnd* lookupHash(U_32 opc, Opnd* op1, Opnd* op2) { return lookupHash(opc, op1->getId(), op2->getId()); };
+ Opnd* lookupHash(U_32 opc, Opnd* op1, Opnd* op2, Opnd* op3) { return lookupHash(opc, op1->getId(), op2->getId(), op3->getId()); };
+ void insertHash(U_32 opc, Inst*);
+ void insertHash(U_32 opc, U_32 op, Inst*);
+ void insertHash(U_32 opc, U_32 op1, U_32 op2, Inst*);
+ void insertHash(U_32 opc, U_32 op1, U_32 op2, U_32 op3, Inst*);
+ void insertHash(U_32 opc, Opnd* op, Inst*i) { insertHash(opc, op->getId(), i); };
+ void insertHash(U_32 opc, Opnd* op1, Opnd* op2, Inst*i) { insertHash(opc, op1->getId(), op2->getId(), i); };
+ void insertHash(U_32 opc, Opnd* op1, Opnd* op2, Opnd* op3, Inst*i) { insertHash(opc, op1->getId(), op2->getId(), op3->getId(), i); };
void invalid(); // called when the builder detects invalid IR
- void setBcOffset(uint32 bcOffset) { offset = bcOffset;}
- uint32 getBcOffset() const { return offset; };
+ void setBcOffset(U_32 bcOffset) { offset = bcOffset;}
+ U_32 getBcOffset() const { return offset; };
friend class JavaByteCodeTranslator;
@@ -454,7 +454,7 @@
Opnd* tauMethodSafeOpnd;
// current bc offset
- uint32 offset;
+ U_32 offset;
};
} //namespace Jitrino
Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/Inst.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/Inst.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/Inst.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/Inst.cpp Thu May 22 06:33:38 2008
@@ -56,13 +56,13 @@
srcs[1] = src2;
}
-Inst::Inst(Opcode opcode, Modifier mod, Type::Tag type, Opnd* dst_, uint32 nSrcs)
+Inst::Inst(Opcode opcode, Modifier mod, Type::Tag type, Opnd* dst_, U_32 nSrcs)
: operation(opcode, type, mod), numSrcs(nSrcs), dst(0)
{
setDst(dst_);
}
-Opnd* Inst::getSrcExtended(uint32 srcIndex) const {
+Opnd* Inst::getSrcExtended(U_32 srcIndex) const {
assert(0);
return NULL;
}
@@ -156,7 +156,7 @@
// the following utility for conditional branches will return the taken edge based on the
// incoming condition. This will ignore exception edges
-Edge* BranchInst::getTakenEdge(uint32 result) {
+Edge* BranchInst::getTakenEdge(U_32 result) {
// find the node for this branch instruction
Node *node = getNode();
assert(node->getFirstInst()->isLabel());
@@ -196,7 +196,7 @@
case 's': // src operands
{
bool comma = false;
- for (uint32 i=0; i<numSrcs; i++) {
+ for (U_32 i=0; i<numSrcs; i++) {
if (comma)
os << ", ";
getSrc(i)->print(os);
@@ -207,7 +207,7 @@
case 'a': // arguments to a virtual or indirect call
{
bool comma = false;
- for (uint32 i=3; i<numSrcs; i++) {
+ for (U_32 i=3; i<numSrcs; i++) {
if (comma)
os << ", ";
getSrc(i)->print(os);
@@ -223,7 +223,7 @@
os<<"bcmap:unknown ";
}
} else {
- int32 bcOffset = (int32)getBCOffset();
+ I_32 bcOffset = (I_32)getBCOffset();
os<<"bcmap:"<<bcOffset<<" ";
}
}
@@ -231,7 +231,7 @@
case 'p': // arguments to a more direct call
{
bool comma = false;
- for (uint32 i=2; i<numSrcs; i++) {
+ for (U_32 i=2; i<numSrcs; i++) {
if (comma)
os << ", ";
getSrc(i)->print(os);
@@ -533,8 +533,8 @@
assert(newTarget->isBlockNode());
replaceDefaultTargetLabel(newLabel);
}
- uint32 n = getNumTargets();
- for (uint32 i = 0; i < n; i++) {
+ U_32 n = getNumTargets();
+ for (U_32 i = 0; i < n; i++) {
if (getTarget(i) == oldLabel) {
assert(newTarget->isBlockNode());
replaceTargetLabel(i, newLabel);
@@ -559,7 +559,7 @@
case 'l': // target labels
{
bool comma = false;
- for (uint32 i=0; i<numTargets; i++) {
+ for (U_32 i=0; i<numTargets; i++) {
if (comma)
os << ", ";
comma = true;
@@ -808,10 +808,10 @@
OpndManager& opndManager,
OpndRenameTable& table) {
Opnd* src = table.rename(inst->getSrc(0));
- uint32 numTargets = inst->getNumTargets();
+ U_32 numTargets = inst->getNumTargets();
LabelInst** targets = inst->getTargets();
LabelInst** newTargets = new (memManager) LabelInst*[numTargets];
- for(uint32 i = 0; i < numTargets; ++i)
+ for(U_32 i = 0; i < numTargets; ++i)
newTargets[i] = targets[i];
SwitchInst *newInst = makeSwitchInst(src, newTargets, numTargets, inst->getDefaultTarget());
newInst->setPersistentInstructionId(inst->getPersistentInstructionId());
@@ -928,7 +928,7 @@
Modifier mod = inst->getModifier();
Type::Tag tag = inst->getType();
Opnd* dst = table.duplicate(opndManager, inst->getDst());
- uint32 numSrcs = inst->getNumSrcOperands();
+ U_32 numSrcs = inst->getNumSrcOperands();
TypeInst *newInst = NULL;
switch(inst->getNumSrcOperands()) {
case 0:
@@ -943,7 +943,7 @@
break;
default:
Opnd** opnds = new (memManager) Opnd*[numSrcs];
- for (uint32 i=0; i<numSrcs; i++)
+ for (U_32 i=0; i<numSrcs; i++)
opnds[i] = table.rename(inst->getSrc(i));
newInst = makeTypeInst(opc, mod, tag, dst, numSrcs, opnds, inst->getTypeInfo());
break;
@@ -958,7 +958,7 @@
Modifier mod = inst->getModifier();
Type::Tag tag = inst->getType();
Opnd* dst = table.duplicate(opndManager, inst->getDst());
- uint32 numSrcs = inst->getNumSrcOperands();
+ U_32 numSrcs = inst->getNumSrcOperands();
FieldAccessInst *newInst = NULL;
switch(inst->getNumSrcOperands()) {
case 0:
@@ -974,7 +974,7 @@
break;
default:
Opnd** opnds = new (memManager) Opnd*[numSrcs];
- for (uint32 i=0; i<numSrcs; i++)
+ for (U_32 i=0; i<numSrcs; i++)
opnds[i] = table.rename(inst->getSrc(i));
newInst = makeFieldAccessInst(opc, mod, tag, dst, numSrcs, opnds, inst->fieldDesc);
break;
@@ -991,7 +991,7 @@
Modifier mod = inst->getModifier();
Type::Tag tag = inst->getType();
Opnd* dst = table.duplicate(opndManager, inst->getDst());
- uint32 numSrcs = inst->getNumSrcOperands();
+ U_32 numSrcs = inst->getNumSrcOperands();
MethodInst *newInst = NULL;
switch(inst->getNumSrcOperands()) {
case 0:
@@ -1003,7 +1003,7 @@
break;
default:
Opnd** opnds = new (memManager) Opnd*[numSrcs];
- for (uint32 i=0; i<numSrcs; i++)
+ for (U_32 i=0; i<numSrcs; i++)
opnds[i] = table.rename(inst->getSrc(i));
newInst = makeMethodInst(opc, mod, tag, dst, numSrcs, opnds, inst->methodDesc);
break;
@@ -1016,9 +1016,9 @@
InstFactory::makeClone(MethodCallInst* inst,
OpndManager& opndManager,
OpndRenameTable& table) {
- uint32 nsrcs = inst->getNumSrcOperands();
+ U_32 nsrcs = inst->getNumSrcOperands();
Opnd** newArgs = new (memManager) Opnd*[nsrcs];
- for (uint32 i=0; i<nsrcs; i++)
+ for (U_32 i=0; i<nsrcs; i++)
newArgs[i] = table.rename(inst->getSrc(i));
MethodCallInst *newInst
= makeMethodCallInst(inst->getOpcode(),
@@ -1036,9 +1036,9 @@
InstFactory::makeClone(CallInst* inst,
OpndManager& opndManager,
OpndRenameTable& table) {
- uint32 numArgs = inst->getNumArgs();
+ U_32 numArgs = inst->getNumArgs();
Opnd** newArgs = new (memManager) Opnd*[numArgs];
- for (uint32 i=0; i<numArgs; i++)
+ for (U_32 i=0; i<numArgs; i++)
newArgs[i] = table.rename(inst->getArg(i));
CallInst *newInst = makeCallInst(inst->getOpcode(),
@@ -1057,9 +1057,9 @@
OpndManager& opndManager,
OpndRenameTable& table)
{
- uint32 nsrcs = inst->getNumSrcOperands();
+ U_32 nsrcs = inst->getNumSrcOperands();
Opnd** newArgs = new (memManager) Opnd*[nsrcs];
- for (uint32 i=0; i<nsrcs; i++){
+ for (U_32 i=0; i<nsrcs; i++){
newArgs[i] = table.rename(inst->getSrc(i));
}
JitHelperCallInst *newInst = makeJitHelperCallInst(inst->getOpcode(),
@@ -1078,9 +1078,9 @@
OpndManager& opndManager,
OpndRenameTable& table)
{
- uint32 nsrcs = inst->getNumSrcOperands();
+ U_32 nsrcs = inst->getNumSrcOperands();
Opnd** newArgs = new (memManager) Opnd*[nsrcs];
- for (uint32 i=0; i<nsrcs; i++){
+ for (U_32 i=0; i<nsrcs; i++){
newArgs[i] = table.rename(inst->getSrc(i));
}
VMHelperCallInst *newInst = makeVMHelperCallInst(inst->getOpcode(),
@@ -1096,9 +1096,9 @@
PhiInst*
InstFactory::makeClone(PhiInst* inst, OpndManager& opndManager, OpndRenameTable& table) {
- uint32 numArgs = inst->getNumSrcOperands();
+ U_32 numArgs = inst->getNumSrcOperands();
Opnd** newArgs = new (memManager) Opnd*[numArgs];
- for (uint32 i=0; i<numArgs; i++)
+ for (U_32 i=0; i<numArgs; i++)
newArgs[i] = table.rename(inst->getSrc(i));
PhiInst *newInst = makePhiInst(inst->getType(),
@@ -1115,7 +1115,7 @@
Modifier mod = inst->getModifier();
Type::Tag tag = inst->getType();
Opnd* dst = table.duplicate(opndManager, inst->getDst());
- uint32 numSrcs = inst->getNumSrcOperands();
+ U_32 numSrcs = inst->getNumSrcOperands();
MultiSrcInst *newInst;
switch(numSrcs) {
case 0:
@@ -1129,7 +1129,7 @@
break;
default:
Opnd** opnds = new (memManager) Opnd*[numSrcs];
- for (uint32 i=0; i<numSrcs; i++)
+ for (U_32 i=0; i<numSrcs; i++)
opnds[i] = table.rename(inst->getSrc(i));
newInst = makeMultiSrcInst(opc, mod, tag, dst, numSrcs, opnds);
break;
@@ -1147,50 +1147,50 @@
}
Opnd**
-InstFactory::copyOpnds(Opnd** srcs, uint32 numSrcs) {
+InstFactory::copyOpnds(Opnd** srcs, U_32 numSrcs) {
Opnd** newSrcs = new (memManager) Opnd*[numSrcs];
- for (uint32 i=0; i<numSrcs; i++)
+ for (U_32 i=0; i<numSrcs; i++)
newSrcs[i] = srcs[i];
return newSrcs;
}
Opnd**
-InstFactory::copyOpnds(Opnd* src1, Opnd** srcs, uint32 numSrcs) {
+InstFactory::copyOpnds(Opnd* src1, Opnd** srcs, U_32 numSrcs) {
Opnd** newSrcs = new (memManager) Opnd*[numSrcs+1];
newSrcs[0] = src1;
- for (uint32 i=0; i<numSrcs; i++)
+ for (U_32 i=0; i<numSrcs; i++)
newSrcs[i+1] = srcs[i];
return newSrcs;
}
Opnd**
-InstFactory::copyOpnds(Opnd* src1, Opnd* src2, Opnd** srcs, uint32 numSrcs) {
+InstFactory::copyOpnds(Opnd* src1, Opnd* src2, Opnd** srcs, U_32 numSrcs) {
Opnd** newSrcs = new (memManager) Opnd*[numSrcs+2];
newSrcs[0] = src1;
newSrcs[1] = src2;
- for (uint32 i=0; i<numSrcs; i++)
+ for (U_32 i=0; i<numSrcs; i++)
newSrcs[i+2] = srcs[i];
return newSrcs;
}
void
InstFactory::appendSrc(MultiSrcInst *inst, Opnd *opnd) {
- uint32 oldNumSrcs = inst->numSrcs;
- uint32 newNumSrcs = inst->numSrcs+1;
+ U_32 oldNumSrcs = inst->numSrcs;
+ U_32 newNumSrcs = inst->numSrcs+1;
if (newNumSrcs > MAX_INST_SRCS) {
// an extended source
- uint32 oldExtendedSrcs = oldNumSrcs - MAX_INST_SRCS;
- uint32 newExtendedSrcs = newNumSrcs - MAX_INST_SRCS;
+ U_32 oldExtendedSrcs = oldNumSrcs - MAX_INST_SRCS;
+ U_32 newExtendedSrcs = newNumSrcs - MAX_INST_SRCS;
if (newExtendedSrcs <= inst->extendedSrcSpace) {
// fits in existing memory
inst->extendedSrcs[oldExtendedSrcs] = opnd;
} else {
// need to allocate more memory
- uint32 newSpace = newExtendedSrcs * 2;
+ U_32 newSpace = newExtendedSrcs * 2;
Opnd** opnds = new (memManager) Opnd*[newSpace];
Opnd** oldOpnds = inst->extendedSrcs;
// copy existing opnds
- uint32 j;
+ U_32 j;
for (j = 0; j < oldExtendedSrcs; j++)
opnds[j] = oldOpnds[j];
opnds[j++] = opnd;
@@ -1233,27 +1233,27 @@
return inst;
}
LabelInst*
-InstFactory::makeLabelInst(uint32 labelId) {
+InstFactory::makeLabelInst(U_32 labelId) {
LabelInst* inst = new (memManager) LabelInst(labelId);
inst->id = numInsts++;
return inst;
}
LabelInst*
-InstFactory::makeLabelInst(Opcode opc, uint32 labelId) {
+InstFactory::makeLabelInst(Opcode opc, U_32 labelId) {
LabelInst* inst = new (memManager) LabelInst(opc, labelId);
inst->id = numInsts++;
return inst;
}
DispatchLabelInst*
-InstFactory::makeDispatchLabelInst(uint32 labelId) {
+InstFactory::makeDispatchLabelInst(U_32 labelId) {
DispatchLabelInst* inst = new (memManager) DispatchLabelInst(labelId);
inst->id = numInsts++;
return inst;
}
CatchLabelInst *
-InstFactory::makeCatchLabelInst(uint32 labelId,
- uint32 ord,
+InstFactory::makeCatchLabelInst(U_32 labelId,
+ U_32 ord,
Type *exceptionType) {
CatchLabelInst* inst = new (memManager) CatchLabelInst(labelId, ord, exceptionType);
inst->id = numInsts++;
@@ -1261,7 +1261,7 @@
}
MethodEntryInst*
-InstFactory::makeMethodEntryInst(uint32 labelId, MethodDesc* md) {
+InstFactory::makeMethodEntryInst(U_32 labelId, MethodDesc* md) {
MethodEntryInst* inst = new (memManager) MethodEntryInst(labelId, md);
inst->id = numInsts++;
return inst;
@@ -1328,14 +1328,14 @@
}
SwitchInst*
-InstFactory::makeSwitchInst(Opnd* src, LabelInst** targets, uint32 nTargets,
+InstFactory::makeSwitchInst(Opnd* src, LabelInst** targets, U_32 nTargets,
LabelInst* defTarget) {
SwitchInst* inst = new (memManager) SwitchInst(src, targets, nTargets, defTarget);
inst->id = numInsts++;
return inst;
}
ConstInst*
-InstFactory::makeConstInst(Opnd* dst, int32 i4) {
+InstFactory::makeConstInst(Opnd* dst, I_32 i4) {
ConstInst* inst = new (memManager) ConstInst(dst, i4);
inst->id = numInsts++;
return inst;
@@ -1371,14 +1371,14 @@
return inst;
}
TokenInst*
-InstFactory::makeTokenInst(Opcode opc, Modifier mod, Type::Tag type, Opnd* dst, uint32 t, MethodDesc* encMethod) {
+InstFactory::makeTokenInst(Opcode opc, Modifier mod, Type::Tag type, Opnd* dst, U_32 t, MethodDesc* encMethod) {
TokenInst* inst = new (memManager) TokenInst(opc, mod, type, dst, t, encMethod);
inst->id = numInsts++;
return inst;
}
LinkingExcInst*
InstFactory::makeLinkingExcInst(Opcode opc, Modifier mod, Type::Tag type, Opnd* dst,
- Class_Handle encClass, uint32 CPIndex, uint32 operation) {
+ Class_Handle encClass, U_32 CPIndex, U_32 operation) {
LinkingExcInst* inst =
new (memManager) LinkingExcInst(opc, mod, type, dst, encClass, CPIndex, operation);
inst->id = numInsts++;
@@ -1448,7 +1448,7 @@
}
TypeInst*
InstFactory::makeTypeInst(Opcode op, Modifier mod, Type::Tag ty, Opnd* dst,
- uint32 nArgs, Opnd** args_, Type* td) {
+ U_32 nArgs, Opnd** args_, Type* td) {
TypeInst* inst = new (memManager) TypeInst(op, mod, ty, dst, nArgs, args_, td);
inst->id = numInsts++;
return inst;
@@ -1491,7 +1491,7 @@
Modifier mod,
Type::Tag type,
Opnd* dst,
- uint32 numSrcs,
+ U_32 numSrcs,
Opnd** srcs,
FieldDesc* fd) {
srcs = copyOpnds(srcs, numSrcs);
@@ -1524,7 +1524,7 @@
Modifier mod,
Type::Tag type,
Opnd* dst,
- uint32 nArgs,
+ U_32 nArgs,
MethodDesc* md) {
MethodInst* inst = new (memManager) MethodInst(op, mod, type, dst, nArgs, 0, md);
inst->id = numInsts++;
@@ -1535,7 +1535,7 @@
Modifier mod,
Type::Tag type,
Opnd* dst,
- uint32 numSrcs,
+ U_32 numSrcs,
Opnd** srcs,
MethodDesc* md) {
srcs = copyOpnds(srcs, numSrcs);
@@ -1547,7 +1547,7 @@
InstFactory::makeMethodCallInst(Opcode op, Modifier mod,
Type::Tag type,
Opnd* dst,
- uint32 numArgs,
+ U_32 numArgs,
Opnd** args,
MethodDesc* md) {
MethodCallInst* inst = new (memManager) MethodCallInst(op, mod, type, dst, numArgs, args, md, memManager);
@@ -1560,7 +1560,7 @@
Type::Tag type,
Opnd* dst,
Opnd* funptr,
- uint32 numArgs,
+ U_32 numArgs,
Opnd** args) {
CallInst* inst = new (memManager) CallInst(op, mod, type, dst, funptr, numArgs, args, memManager);
inst->id = numInsts++;
@@ -1572,7 +1572,7 @@
Modifier mod,
Type::Tag type,
Opnd* dst,
- uint32 nArgs,
+ U_32 nArgs,
Opnd** args_,
JitHelperCallId id) {
JitHelperCallInst * inst =
@@ -1586,7 +1586,7 @@
Modifier mod,
Type::Tag type,
Opnd* dst,
- uint32 nArgs,
+ U_32 nArgs,
Opnd** args_,
VM_RT_SUPPORT id) {
VMHelperCallInst * inst =
@@ -1596,9 +1596,9 @@
}
PhiInst*
-InstFactory::makePhiInst(Type::Tag type, Opnd* dst, uint32 nArgs, Opnd** args_) {
+InstFactory::makePhiInst(Type::Tag type, Opnd* dst, U_32 nArgs, Opnd** args_) {
#ifdef BRM_CHECK_TYPES
- for (uint32 i=0; i<nArgs; ++i) {
+ for (U_32 i=0; i<nArgs; ++i) {
assert(args_[i]->getType() == dst->getType());
}
#endif
@@ -1669,7 +1669,7 @@
Modifier mod,
Type::Tag ty,
Opnd* dst,
- uint32 nSrcs,
+ U_32 nSrcs,
Opnd** srcs) {
MultiSrcInst* inst = new (memManager) MultiSrcInst(opc, mod, ty, dst, nSrcs, srcs);
inst->id = numInsts++;
@@ -1836,14 +1836,14 @@
}
Inst*
-InstFactory::makeCatchLabel(uint32 labelId,
- uint32 exceptionOrder,
+InstFactory::makeCatchLabel(U_32 labelId,
+ U_32 exceptionOrder,
Type* handlerExceptionType) {
return makeCatchLabelInst(labelId, exceptionOrder, handlerExceptionType);
}
CatchLabelInst*
-InstFactory::makeCatchLabel(uint32 exceptionOrder,
+InstFactory::makeCatchLabel(U_32 exceptionOrder,
Type* handlerExceptionType) {
return makeCatchLabelInst(createLabelNumber(), exceptionOrder, handlerExceptionType);
}
@@ -1873,9 +1873,9 @@
return makeBranchInst(Op_JSR, labelInst);
}
-Inst* InstFactory::makeSwitch(Opnd* src, uint32 nLabels, LabelInst** labelInsts, LabelInst* defaultLabel) {
+Inst* InstFactory::makeSwitch(Opnd* src, U_32 nLabels, LabelInst** labelInsts, LabelInst* defaultLabel) {
LabelInst** newLabelInsts = new (memManager) LabelInst*[nLabels];
- for (uint32 i=0; i<nLabels; i++)
+ for (U_32 i=0; i<nLabels; i++)
newLabelInsts[i] = labelInsts[i];
return makeSwitchInst(src, newLabelInsts, nLabels, defaultLabel);
}
@@ -1908,10 +1908,10 @@
Inst* InstFactory::makeThrowSystemException(CompilationInterface::SystemExceptionId exceptionId) {
MethodDesc* enclosingMethod = 0;
return makeTokenInst(Op_ThrowSystemException, Modifier(), Type::Void,
- OpndManager::getNullOpnd(), (uint32) exceptionId, enclosingMethod);
+ OpndManager::getNullOpnd(), (U_32) exceptionId, enclosingMethod);
}
-Inst* InstFactory::makeThrowLinkingException(Class_Handle encClass, uint32 CPIndex, uint32 operation) {
+Inst* InstFactory::makeThrowLinkingException(Class_Handle encClass, U_32 CPIndex, U_32 operation) {
return makeLinkingExcInst(Op_ThrowLinkingException, Modifier(), Type::Void,
OpndManager::getNullOpnd(), encClass, CPIndex, operation);
}
@@ -1936,7 +1936,7 @@
InstFactory::makeDirectCall(Opnd* dst,
Opnd* tauNullChecked,
Opnd* tauTypesChecked,
- uint32 numArgs,
+ U_32 numArgs,
Opnd** args,
MethodDesc* methodDesc) {
assert(tauNullChecked->getType()->tag == Type::Tau);
@@ -1951,7 +1951,7 @@
InstFactory::makeTauVirtualCall(Opnd* dst,
Opnd *tauNullChecked,
Opnd *tauTypesChecked,
- uint32 numArgs,
+ U_32 numArgs,
Opnd** args,
MethodDesc* methodDesc) {
assert(tauNullChecked->getType()->tag == Type::Tau);
@@ -1967,7 +1967,7 @@
Opnd* funAddr,
Opnd* tauNullCheckedFirstArg,
Opnd* tauTypesChecked,
- uint32 numArgs,
+ U_32 numArgs,
Opnd** args) {
assert(tauNullCheckedFirstArg->getType()->tag == Type::Tau);
assert(tauTypesChecked->getType()->tag == Type::Tau);
@@ -1985,7 +1985,7 @@
Opnd* funAddr,
Opnd* tauNullCheckedFirstArg,
Opnd* tauTypesChecked,
- uint32 numArgs,
+ U_32 numArgs,
Opnd** args) {
assert(tauNullCheckedFirstArg->getType()->tag == Type::Tau);
assert(tauTypesChecked->getType()->tag == Type::Tau);
@@ -2001,7 +2001,7 @@
Inst*
InstFactory::makeJitHelperCall(Opnd* dst, JitHelperCallId id,
Opnd* tauNullChecked, Opnd* tauTypesChecked,
- uint32 numArgs, Opnd** args)
+ U_32 numArgs, Opnd** args)
{
Type::Tag returnType = dst->isNull()? Type::Void : dst->getType()->tag;
if (id == ArrayCopyDirect || id == ArrayCopyReverse) // these three need taus
@@ -2025,7 +2025,7 @@
}
Inst*
-InstFactory::makeVMHelperCall(Opnd* dst, VM_RT_SUPPORT id, uint32 numArgs, Opnd** args) {
+InstFactory::makeVMHelperCall(Opnd* dst, VM_RT_SUPPORT id, U_32 numArgs, Opnd** args) {
Type::Tag returnType = dst->isNull()? Type::Void : dst->getType()->tag;
args = copyOpnds(args, numArgs);
return makeVMHelperCallInst(Op_VMHelperCall, Modifier(Exception_Sometimes), returnType, dst, numArgs, args, id);
@@ -2034,9 +2034,9 @@
// load, store, & move
Inst*
-InstFactory::makePhi(Opnd* dst, uint32 numOpnds, Opnd** opnds) {
+InstFactory::makePhi(Opnd* dst, U_32 numOpnds, Opnd** opnds) {
#ifdef BRM_CHECK_TYPES
- for (uint32 i=0; i<numOpnds; ++i) {
+ for (U_32 i=0; i<numOpnds; ++i) {
assert(opnds[i]->getType() == dst->getType());
}
#endif
@@ -2352,7 +2352,7 @@
Inst*
InstFactory::makeNewMultiArray(Opnd* dst,
- uint32 dimensions,
+ U_32 dimensions,
Opnd** numElems,
Type* elemType) {
Opnd** newNumElems = copyOpnds(numElems, dimensions);
@@ -2433,11 +2433,11 @@
return makeInst(Op_MonitorExitFence, Modifier(), Type::Void, OpndManager::getNullOpnd(), src);
}
-Inst* InstFactory::makeLdToken(Opnd* dst, MethodDesc* enclosingMethod, uint32 metadataToken) {
+Inst* InstFactory::makeLdToken(Opnd* dst, MethodDesc* enclosingMethod, U_32 metadataToken) {
return makeTokenInst(Op_LdToken, Modifier(), Type::Object, dst, metadataToken, enclosingMethod);
}
-Inst* InstFactory::makeLdRef(Modifier mod, Opnd* dst, MethodDesc* enclosingMethod, uint32 token) {
+Inst* InstFactory::makeLdRef(Modifier mod, Opnd* dst, MethodDesc* enclosingMethod, U_32 token) {
return makeTokenInst(Op_LdRef, mod, dst->getType()->tag, dst, token, enclosingMethod);
}
@@ -2546,7 +2546,7 @@
tauIsArray);
}
-Inst* InstFactory::makeLdConst(Opnd* dst, int32 val) {
+Inst* InstFactory::makeLdConst(Opnd* dst, I_32 val) {
return makeConstInst(dst, val);
}
@@ -2570,7 +2570,7 @@
return makeConstInst(dst);
}
-Inst* InstFactory::makeIncCounter(uint32 val) {
+Inst* InstFactory::makeIncCounter(U_32 val) {
return makeTokenInst(Op_IncCounter, Modifier(), Type::Void, OpndManager::getNullOpnd(), val, NULL);
}
@@ -2584,7 +2584,7 @@
return makeInst(Op_TauEdge, Modifier(), Type::Tau, dst);
}
-Inst* InstFactory::makeTauAnd(Opnd *dst, uint32 numOpnds, Opnd** opnds) {
+Inst* InstFactory::makeTauAnd(Opnd *dst, U_32 numOpnds, Opnd** opnds) {
assert(dst->getType()->tag == Type::Tau);
assert(numOpnds > 0);