harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From mcfi...@apache.org
Subject 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...
Date Thu, 22 May 2008 13:34:09 GMT
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);
 



Mime
View raw message