harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From mcfi...@apache.org
Subject svn commit: r659108 [7/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/codegenerator/ipf/IpfCodeSelector.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfCodeSelector.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfCodeSelector.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfCodeSelector.cpp Thu May 22 06:33:38 2008
@@ -43,7 +43,7 @@
 
 //----------------------------------------------------------------------------------------//
 
-void IpfMethodCodeSelector::genVars(uint32 numVars, VarCodeSelector &varCodeSelector) {
+void IpfMethodCodeSelector::genVars(U_32 numVars, VarCodeSelector &varCodeSelector) {
 
     IPF_LOG << endl << "  Select variables" << endl;
     IpfVarCodeSelector ipfVarCodeSelector(cfg, opnds);
@@ -58,7 +58,7 @@
 
 //----------------------------------------------------------------------------------------//
 
-void IpfMethodCodeSelector::genCFG(uint32           numNodes, 
+void IpfMethodCodeSelector::genCFG(U_32           numNodes, 
                                    CFGCodeSelector &codeSelector, 
                                    bool             useProfile) {
 
@@ -85,7 +85,7 @@
 
 //----------------------------------------------------------------------------------------//
 
-uint32 IpfVarCodeSelector::defVar(Type *varType, bool isAddressTaken, bool isPinned) {
+U_32 IpfVarCodeSelector::defVar(Type *varType, bool isAddressTaken, bool isPinned) {
 
     OpndKind  opndKind = IpfInstCodeSelector::toOpndKind(varType->tag);
     DataKind  dataKind = IpfInstCodeSelector::toDataKind(varType->tag);
@@ -106,7 +106,7 @@
 
 //----------------------------------------------------------------------------------------//
 
-void IpfVarCodeSelector::setManagedPointerBase(uint32 managedPtrVarNum, uint32 baseVarNum) {}
+void IpfVarCodeSelector::setManagedPointerBase(U_32 managedPtrVarNum, U_32 baseVarNum) {}
 
 //========================================================================================//
 // IpfCfgCodeSelector
@@ -126,12 +126,12 @@
 
 //----------------------------------------------------------------------------------------//
 
-uint32 IpfCfgCodeSelector::genDispatchNode(uint32 numInEdges, 
-                                           uint32 numOutEdges, 
+U_32 IpfCfgCodeSelector::genDispatchNode(U_32 numInEdges, 
+                                           U_32 numOutEdges, 
                                            const StlVector<MethodDesc*>& inlineInfo,
                                            double cnt) {
 
-    Node *node = new(mm) Node(mm, opndManager->getNextNodeId(), (uint32) cnt, NODE_DISPATCH);
+    Node *node = new(mm) Node(mm, opndManager->getNextNodeId(), (U_32) cnt, NODE_DISPATCH);
     nodes.push_back(node);
 
     IPF_LOG << endl << "    Generate Dispatch node" << node->getId() << endl;
@@ -140,13 +140,13 @@
 
 //----------------------------------------------------------------------------------------//
 
-uint32 IpfCfgCodeSelector::genBlock(uint32            numInEdges, 
-                                    uint32            numOutEdges, 
+U_32 IpfCfgCodeSelector::genBlock(U_32            numInEdges, 
+                                    U_32            numOutEdges, 
                                     BlockKind         blockKind, 
                                     BlockCodeSelector &codeSelector, 
                                     double            cnt) {
 
-    BbNode *node = new(mm) BbNode(mm, opndManager->getNextNodeId(), (uint32)cnt);
+    BbNode *node = new(mm) BbNode(mm, opndManager->getNextNodeId(), (U_32)cnt);
 
     nodes.push_back(node);
     if(blockKind == Prolog) cfg.setEnterNode(node);
@@ -160,11 +160,11 @@
 
 //----------------------------------------------------------------------------------------//
 
-uint32  IpfCfgCodeSelector::genUnwindNode(uint32 numInEdges, 
-                                          uint32 numOutEdges, 
+U_32  IpfCfgCodeSelector::genUnwindNode(U_32 numInEdges, 
+                                          U_32 numOutEdges, 
                                           double cnt) {
 
-    Node *node = new(mm) Node(mm, opndManager->getNextNodeId(), (uint32) cnt, NODE_UNWIND);
+    Node *node = new(mm) Node(mm, opndManager->getNextNodeId(), (U_32) cnt, NODE_UNWIND);
     nodes.push_back(node);
 
     IPF_LOG << endl << "    Generate Unwind node" << node->getId() << endl;
@@ -173,9 +173,9 @@
 
 //----------------------------------------------------------------------------------------//
 
-uint32 IpfCfgCodeSelector::genExitNode(uint32 numInEdges, double cnt) {
+U_32 IpfCfgCodeSelector::genExitNode(U_32 numInEdges, double cnt) {
 
-    BbNode *node = new(mm) BbNode(mm, opndManager->getNextNodeId(), (uint32) cnt);
+    BbNode *node = new(mm) BbNode(mm, opndManager->getNextNodeId(), (U_32) cnt);
     nodes.push_back(node);
     cfg.setExitNode(node);
 
@@ -185,8 +185,8 @@
 
 //----------------------------------------------------------------------------------------//
 
-void IpfCfgCodeSelector::genUnconditionalEdge(uint32 tailNodeId,
-                                              uint32 headNodeId, 
+void IpfCfgCodeSelector::genUnconditionalEdge(U_32 tailNodeId,
+                                              U_32 headNodeId, 
                                               double prob) {
 
     IPF_LOG << "    Generate Unconditional edge node" << nodes[tailNodeId]->getId();
@@ -198,7 +198,7 @@
 
 //----------------------------------------------------------------------------------------//
 
-void IpfCfgCodeSelector::genTrueEdge(uint32 tailNodeId, uint32 headNodeId, double prob) {
+void IpfCfgCodeSelector::genTrueEdge(U_32 tailNodeId, U_32 headNodeId, double prob) {
 
     IPF_LOG << "    Generate True          edge node" << nodes[tailNodeId]->getId();
     IPF_LOG << " -> node" << nodes[headNodeId]->getId() << endl;
@@ -209,7 +209,7 @@
 
 //----------------------------------------------------------------------------------------//
 
-void IpfCfgCodeSelector::genFalseEdge(uint32 tailNodeId, uint32 headNodeId, double prob) {
+void IpfCfgCodeSelector::genFalseEdge(U_32 tailNodeId, U_32 headNodeId, double prob) {
 
     IPF_LOG << "    Generate False         edge node" << nodes[tailNodeId]->getId();
     IPF_LOG << " -> node" << nodes[headNodeId]->getId() << endl;
@@ -220,11 +220,11 @@
 
 //----------------------------------------------------------------------------------------//
 
-void IpfCfgCodeSelector::genSwitchEdges(uint32  tailNodeId, 
-                                        uint32  numTargets, 
-                                        uint32 *targets, 
+void IpfCfgCodeSelector::genSwitchEdges(U_32  tailNodeId, 
+                                        U_32  numTargets, 
+                                        U_32 *targets, 
                                         double *probs, 
-                                        uint32  defaultTarget) {
+                                        U_32  defaultTarget) {
 
     BbNode         *tailNode       = (BbNode *)nodes[tailNodeId];
     InstVector     &insts          = tailNode->getInsts();
@@ -236,7 +236,7 @@
     Edge           *edge           = NULL;
 
     bool   defadded = false;
-    uint32 i        = 0;
+    U_32 i        = 0;
 
     IPF_LOG << "    Generate Switch     tailNodeId=" << tailNodeId 
         << "; defaultTarget=" << defaultTarget << endl;
@@ -269,8 +269,8 @@
 //--------------------------------------------------------------------------------//
 // edge from try region to dispatch node 
 
-void IpfCfgCodeSelector::genExceptionEdge(uint32 tailNodeId, 
-                                          uint32 headNodeId, 
+void IpfCfgCodeSelector::genExceptionEdge(U_32 tailNodeId, 
+                                          U_32 headNodeId, 
                                           double prob) {
 
     Node *tailNode = nodes[tailNodeId];
@@ -285,9 +285,9 @@
 //----------------------------------------------------------------------------------------//
 // edge from dispatch node to exception handler 
 
-void IpfCfgCodeSelector::genCatchEdge(uint32  tailNodeId, 
-                                      uint32  headNodeId, 
-                                      uint32  priority, 
+void IpfCfgCodeSelector::genCatchEdge(U_32  tailNodeId, 
+                                      U_32  headNodeId, 
+                                      U_32  priority, 
                                       Type   *exceptionType, 
                                       double  prob) {
 
@@ -303,8 +303,8 @@
 
 //----------------------------------------------------------------------------------------//
 
-void IpfCfgCodeSelector::genExitEdge(uint32 tailNodeId,
-                                     uint32 headNodeId,
+void IpfCfgCodeSelector::genExitEdge(U_32 tailNodeId,
+                                     U_32 headNodeId,
                                      double prob) {
 
     Node *tailNode=nodes[tailNodeId];
@@ -319,10 +319,10 @@
 
 //----------------------------------------------------------------------------------------//
 
-void IpfCfgCodeSelector::setLoopInfo(uint32 nodeId, 
+void IpfCfgCodeSelector::setLoopInfo(U_32 nodeId, 
                                      bool   isLoopHeader, 
                                      bool   hasContainingLoopHeader, 
-                                     uint32 headerId) {
+                                     U_32 headerId) {
 
     if (hasContainingLoopHeader == false) return;
     
@@ -334,7 +334,7 @@
 
 //----------------------------------------------------------------------------------------//
 
-void IpfCfgCodeSelector::setPersistentId(uint32 nodeId, uint32 persistentId) {}
+void IpfCfgCodeSelector::setPersistentId(U_32 nodeId, U_32 persistentId) {}
 
 } //namespace IPF
 } //namespace Jitrino 

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfEmitter.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfEmitter.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfEmitter.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfEmitter.cpp Thu May 22 06:33:38 2008
@@ -99,7 +99,7 @@
 void Emitter::checkForDualIssueBundles() {
     EmitterBb *bb;
     Bundle *bundle1, *bundle2;
-    uint32 tmpl1, tmpl2;
+    U_32 tmpl1, tmpl2;
     bool header_printed = false;
 
     for (int bbindex=0 ; bbindex<(int)bbs->size() ; bbindex++) {
@@ -159,7 +159,7 @@
 
 //============================================================================//
 
-Bundle::Bundle(Cfg& cfg, uint32 itmp, Inst *i0, Inst *i1, Inst *i2) {
+Bundle::Bundle(Cfg& cfg, U_32 itmp, Inst *i0, Inst *i1, Inst *i2) {
     indxtmpl = itmp;   // !!! THis is not template, but index in Bundle::BundleDesc[] !!!
 
     MemoryManager& mm          = cfg.getMM();
@@ -211,7 +211,7 @@
 void Bundle::emitBundleBranch(void *whereToEmit, int * bundletarget) {
     uint64 * p  = (uint64 *)whereToEmit;
     uint64   s;
-    uint32   itmp = getTmpl();
+    U_32   itmp = getTmpl();
 
     p[0] = 0;
     p[1] = 0;
@@ -275,7 +275,7 @@
 //============================================================================//
 void Bundle::print() {
     Inst * inst = getSlot(0);
-    uint32 tmpl = getTmpl();
+    U_32 tmpl = getTmpl();
 
     IPF_LOG << "(" << tmpl << ")\n";
     IPF_LOG << IrPrinter::toString(inst);
@@ -534,10 +534,10 @@
     OpndVector & opnds = inst->getOpnds();
     if(opnds.size() <= 1) return;
 
-    uint32 dstcount=inst->getNumDst();
+    U_32 dstcount=inst->getNumDst();
     Opnd *opnd;
 
-    for( uint32 i=0 ; i<dstcount ; i++ ) {
+    for( U_32 i=0 ; i<dstcount ; i++ ) {
         opnd = opnds[i+1];
         switch (opnd->getOpndKind()) {
         case OPND_G_REG:
@@ -564,11 +564,11 @@
     OpndVector & opnds = inst->getOpnds();
     if(opnds.size() <= 1) return;
 
-    uint32 dstcount=inst->getNumDst();
-    uint32 opndcount=inst->getNumOpnd();
+    U_32 dstcount=inst->getNumDst();
+    U_32 opndcount=inst->getNumOpnd();
     Opnd *opnd;
 
-    for( uint32 i=1+dstcount ; i<opndcount ; i++ ) {
+    for( U_32 i=1+dstcount ; i<opndcount ; i++ ) {
         opnd = opnds[i];
         switch (opnd->getOpndKind()) {
         case OPND_G_REG:
@@ -632,8 +632,8 @@
     vectorregs * rr = bb->rregs;
     Inst *inst;
     RegistersBitset * regs;
-    uint32 dstcount;
-    uint32 opndcount;
+    U_32 dstcount;
+    U_32 opndcount;
     Opnd         * opnd;
     vectorconst  * consts = bb->consts;
     Constant     * constant;
@@ -671,7 +671,7 @@
         dstcount=inst->getNumDst();
         opndcount=inst->getNumOpnd();
 
-        for( uint32 j=1 ; j<opndcount ; j++ ) {
+        for( U_32 j=1 ; j<opndcount ; j++ ) {
             opnd = opnds[j];
             if (opnd->isImm()) {
                 if ( opnd->getDataKind() == DATA_CONST_REF) {
@@ -1174,9 +1174,9 @@
             bundles = bb->bundles;
             for(int i=0, ii=(int)bundles->size() ; i<ii ; i++ ) {
                 bundle = bundles->at(i);
-                for (uint32 si=0 ; si < IPF_SLOTS_COUNT ; si++) {
+                for (U_32 si=0 ; si < IPF_SLOTS_COUNT ; si++) {
                     inst = bundle->getSlot(si);
-                    inst->setAddr((uint32)(off - bboff) + si);
+                    inst->setAddr((U_32)(off - bboff) + si);
                 }
 
                 if ( isBranchBundle(bundle, codeoff, off, target) ) {
@@ -1349,7 +1349,7 @@
     Inst *inst;
 
     IPF_LOG << ".L" << bbs->at(bbindex)->node->getId() << "\n";
-    for (uint32 i = 0, ii=insts.size() ; i < ii ; i++) {
+    for (U_32 i = 0, ii=insts.size() ; i < ii ; i++) {
         inst = insts[i];
         if( inst==NULL ) {
             IPF_LOG << IrPrinter::toString(inst);

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfInstCodeSelector.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfInstCodeSelector.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfInstCodeSelector.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfInstCodeSelector.cpp Thu May 22 06:33:38 2008
@@ -32,9 +32,9 @@
 #define VTABLEBASE    (opndManager->getVtableBase())
 #define VTABLEBASEIMM (opndManager->getVtableBaseImm())
 
-#define IMM32(o)   ((int32)(((Opnd *)(o))->getValue()))
+#define IMM32(o)   ((I_32)(((Opnd *)(o))->getValue()))
 #define IMM64(o)   ((int64)(((Opnd *)(o))->getValue()))
-#define IMM32U(o)  ((uint32)(((Opnd *)(o))->getValue()))
+#define IMM32U(o)  ((U_32)(((Opnd *)(o))->getValue()))
 #define IMM64U(o)  ((uint64)(((Opnd *)(o))->getValue()))
 
 // FP remainder internal helpers (temp solution to be optimized)
@@ -304,7 +304,7 @@
     if (ipfConstantFolding && ((Opnd *)src_)->isImm()) {
         switch (opType) {
         case NegOp::I4: 
-            dst = opndManager->newImm((int32)0 - IMM32(src_)); break;
+            dst = opndManager->newImm((I_32)0 - IMM32(src_)); break;
         case NegOp::I:
         case NegOp::I8: 
             dst = opndManager->newImm(0 - IMM64(src_)); break;
@@ -610,7 +610,7 @@
     
     if (ipfConstantFolding && ((Opnd *)value)->isImm() && ((Opnd *)shiftAmount)->isImm()) {
         if (opType==IntegerOp::I4) {
-            return opndManager->newImm((uint64)((uint32)((int32)(((Opnd *)value)->getValue()))) >> ((Opnd *)shiftAmount)->getValue());
+            return opndManager->newImm((uint64)((U_32)((I_32)(((Opnd *)value)->getValue()))) >> ((Opnd *)shiftAmount)->getValue());
         } else {
             return opndManager->newImm((uint64)(((Opnd *)value)->getValue()) >> ((Opnd *)shiftAmount)->getValue());
         }
@@ -637,7 +637,7 @@
 
 CG_OpndHandle *IpfInstCodeSelector::shladd(IntegerOp::Types opType,
                                            CG_OpndHandle    *value_,
-                                           uint32           imm,
+                                           U_32           imm,
                                            CG_OpndHandle    *addto_) {
 
     IPF_LOG << "      shladd " << endl;
@@ -745,7 +745,7 @@
 //----------------------------------------------------------------------------//
 // Load 32-bit integer constant
 
-CG_OpndHandle *IpfInstCodeSelector::ldc_i4(int32 val) {
+CG_OpndHandle *IpfInstCodeSelector::ldc_i4(I_32 val) {
 
     IPF_LOG << "      ldc_i4; val=" << val << endl;
     
@@ -791,7 +791,7 @@
 
     union {
         float  fr;
-        uint32 gr;
+        U_32 gr;
     } tmpVal;
     
     tmpVal.fr = val;
@@ -887,7 +887,7 @@
 //----------------------------------------------------------------------------//
 // Load variable
 
-CG_OpndHandle *IpfInstCodeSelector::ldVar(Type *dstType, uint32 varId) {
+CG_OpndHandle *IpfInstCodeSelector::ldVar(Type *dstType, U_32 varId) {
 
     IPF_LOG << "      ldVar; dstType=" << Type::tag2str(dstType->tag) << ", varId=" << varId << endl;
 
@@ -911,7 +911,7 @@
 //----------------------------------------------------------------------------//
 // Store variable
 
-void IpfInstCodeSelector::stVar(CG_OpndHandle *_src, uint32 varId) {
+void IpfInstCodeSelector::stVar(CG_OpndHandle *_src, U_32 varId) {
 
     IPF_LOG << "      stVar" 
         << "; varId=" << varId
@@ -940,7 +940,7 @@
 //----------------------------------------------------------------------------//
 // Define an argument
 
-CG_OpndHandle *IpfInstCodeSelector::defArg(uint32 inArgPosition, Type *type) {
+CG_OpndHandle *IpfInstCodeSelector::defArg(U_32 inArgPosition, Type *type) {
 
 
     OpndKind opndKind = toOpndKind(type->tag);
@@ -1200,7 +1200,7 @@
 //  (p8) br.cond.sptk b1                            // branch to target
 //                                                  // if p8 is false - fall through
 
-void IpfInstCodeSelector::tableSwitch(CG_OpndHandle *src, uint32 nTargets) {
+void IpfInstCodeSelector::tableSwitch(CG_OpndHandle *src, U_32 nTargets) {
 
     IPF_LOG << "      tableSwitch" << endl;
 
@@ -1257,7 +1257,7 @@
 //----------------------------------------------------------------------------//
 // Direct call to the method
 
-CG_OpndHandle *IpfInstCodeSelector::call(uint32        numArgs, 
+CG_OpndHandle *IpfInstCodeSelector::call(U_32        numArgs, 
                                          CG_OpndHandle **args, 
                                          Type          *retType,
                                          MethodDesc    *desc) {
@@ -1268,7 +1268,7 @@
 //----------------------------------------------------------------------------//
 // Direct call to the method 
 
-CG_OpndHandle *IpfInstCodeSelector::tau_call(uint32        numArgs, 
+CG_OpndHandle *IpfInstCodeSelector::tau_call(U_32        numArgs, 
                                              CG_OpndHandle **args, 
                                              Type          *retType,
                                              MethodDesc    *desc,
@@ -1294,7 +1294,7 @@
 //----------------------------------------------------------------------------//
 // Indirect call
 
-CG_OpndHandle *IpfInstCodeSelector::tau_calli(uint32        numArgs, 
+CG_OpndHandle *IpfInstCodeSelector::tau_calli(U_32        numArgs, 
                                               CG_OpndHandle **args, 
                                               Type          *retType, 
                                               CG_OpndHandle *methodPtr,
@@ -1428,8 +1428,8 @@
 // Throw linking exception
 
 void IpfInstCodeSelector::throwLinkingException(Class_Handle encClass,
-                                                uint32       cp_ndx,
-                                                uint32       opcode)
+                                                U_32       cp_ndx,
+                                                U_32       opcode)
 {
 
     IPF_LOG << "      throwLinkingException" << endl;
@@ -1724,7 +1724,7 @@
 // Load string 
 
 CG_OpndHandle *IpfInstCodeSelector::ldString(MethodDesc *enclosingMethod,
-                                             uint32     stringToken,
+                                             U_32     stringToken,
                                              bool       uncompress) {
 
     IPF_LOG << "      ldString" << endl;
@@ -1976,14 +1976,14 @@
 // Create multi-dimensional new array
 
 CG_OpndHandle *IpfInstCodeSelector::newMultiArray(ArrayType      *arrayType, 
-                                                   uint32        numDims, 
+                                                   U_32        numDims, 
                                                    CG_OpndHandle **dims) {
 
     Opnd *helperArgs[2 + numDims];
     
     helperArgs[0] = opndManager->newImm((uint64)arrayType->getRuntimeIdentifier());
     helperArgs[1] = opndManager->newImm(numDims);
-    for (uint32 i = 0; i < numDims; i++) {
+    for (U_32 i = 0; i < numDims; i++) {
         helperArgs[i + 2] = (Opnd *)dims[numDims - 1 - i];
     }
 
@@ -2162,7 +2162,7 @@
 //----------------------------------------------------------------------------//
 // Create direct call to the method 
 
-void IpfInstCodeSelector::directCall(uint32    numArgs, 
+void IpfInstCodeSelector::directCall(U_32    numArgs, 
                                      Opnd      **args, 
                                      RegOpnd   *retOpnd,
                                      Opnd      *methodAddress,
@@ -2184,7 +2184,7 @@
 //----------------------------------------------------------------------------//
 // Create indirect call to the method 
 
-void IpfInstCodeSelector::indirectCall(uint32    numArgs, 
+void IpfInstCodeSelector::indirectCall(U_32    numArgs, 
                                        Opnd      **args, 
                                        RegOpnd   *retOpnd,
                                        RegOpnd   *methodPtr,
@@ -2208,16 +2208,16 @@
 //----------------------------------------------------------------------------//
 // Move out args in regs and stack positions according with IPF software convention
 
-void IpfInstCodeSelector::makeCallArgs(uint32 numArgs, Opnd **args, Inst *callInst, RegOpnd *pred) {
+void IpfInstCodeSelector::makeCallArgs(U_32 numArgs, Opnd **args, Inst *callInst, RegOpnd *pred) {
     
     int16 numFpOutArgs = 0;
-    for(uint32 argPosition=0; argPosition<numArgs; argPosition++) {
+    for(U_32 argPosition=0; argPosition<numArgs; argPosition++) {
         
         Opnd     *opnd    = args[argPosition];
         OpndKind opndKind = OPND_INVALID;
         DataKind dataKind = DATA_INVALID;
         InstCode instCode = INST_INVALID;
-        int32    location = LOCATION_INVALID;
+        I_32    location = LOCATION_INVALID;
         bool     isFp     = opnd->isFloating();
 
         if (opnd->isReg() == true) {                                  // opnd is register
@@ -2705,7 +2705,7 @@
     
     union {
         float  fr;
-        uint32 gr;
+        U_32 gr;
     } fval;
     union {
         double fr;
@@ -2952,7 +2952,7 @@
 
 CG_OpndHandle *IpfInstCodeSelector::ldRef(Type *dstType,
                                           MethodDesc* enclosingMethod,
-                                          uint32 refToken,
+                                          U_32 refToken,
                                           bool uncompress) 
 {
     assert(dstType->isSystemString() || dstType->isSystemClass());

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfIrPrinter.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfIrPrinter.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfIrPrinter.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfIrPrinter.cpp Thu May 22 06:33:38 2008
@@ -90,10 +90,10 @@
     NodeVector &nodes = cfg.search(SEARCH_POST_ORDER);
 
     printHead();
-    for(uint32 i=0; i<nodes.size(); i++) {
+    for(U_32 i=0; i<nodes.size(); i++) {
         printNodeDot(nodes[i]);
         EdgeVector &edges = nodes[i]->getOutEdges();
-        for(uint32 j=0; j<edges.size(); j++) {
+        for(U_32 j=0; j<edges.size(); j++) {
             printEdgeDot(edges[j]);
         }
     }
@@ -157,7 +157,7 @@
 
     if(node->getNodeKind() == NODE_BB) {
         InstVector &insts = ((BbNode *)node)->getInsts();
-        for(uint32 i=0; i<insts.size(); i++) {
+        for(U_32 i=0; i<insts.size(); i++) {
             *ofs << "\\n" << insts[i]->getInstMnemonic();
             CompVector &compList = insts[i]->getComps();
             for(uint16 j=0; j<compList.size(); j++) *ofs << insts[i]->getCompMnemonic(compList[j]);
@@ -198,7 +198,7 @@
     *os << ".L" << node->getId() << ":" << endl;
 
     InstVector &insts = ((BbNode *)node)->getInsts();
-    for(uint32 i=0; i<insts.size(); i++) *os << "  " << toString(insts[i]) << endl;
+    for(U_32 i=0; i<insts.size(); i++) *os << "  " << toString(insts[i]) << endl;
 }
 
 //----------------------------------------------------------------------------------------//
@@ -266,7 +266,7 @@
     // opnd is register 
     if(opnd->isReg()) {
         RegOpnd *reg = (RegOpnd *)opnd;
-        int32   num  = reg->getLocation();
+        I_32   num  = reg->getLocation();
 
         if (num == LOCATION_INVALID) {
             num = reg->getId();

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfOpnd.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfOpnd.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfOpnd.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfOpnd.cpp Thu May 22 06:33:38 2008
@@ -79,7 +79,7 @@
 // Opnd
 //============================================================================//
 
-Opnd::Opnd(uint32 id, OpndKind opndKind, DataKind dataKind, int64 value) :
+Opnd::Opnd(U_32 id, OpndKind opndKind, DataKind dataKind, int64 value) :
     id(id), 
     opndKind(opndKind), 
     dataKind(dataKind), 
@@ -142,7 +142,7 @@
 // RegOpnd
 //============================================================================//
 
-RegOpnd::RegOpnd(MemoryManager &mm, uint32 id, OpndKind opndKind, DataKind dataKind, int32 value) : 
+RegOpnd::RegOpnd(MemoryManager &mm, U_32 id, OpndKind opndKind, DataKind dataKind, I_32 value) : 
     Opnd(id, opndKind, dataKind, value),
     spillCost(0),
     depOpnds(mm),

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfOpndManager.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfOpndManager.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfOpndManager.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfOpndManager.cpp Thu May 22 06:33:38 2008
@@ -60,7 +60,7 @@
 
 //----------------------------------------------------------------------------------------//
 
-int32 RegStack::newInReg(int32 inArgPosition) { 
+I_32 RegStack::newInReg(I_32 inArgPosition) { 
 
     if (inRegSize < inArgPosition+1) inRegSize = inArgPosition+1;
     return G_INARG_BASE + inArgPosition;
@@ -68,7 +68,7 @@
 
 //----------------------------------------------------------------------------------------//
 
-int32 RegStack::newOutReg(int32 outArgPosition) { 
+I_32 RegStack::newOutReg(I_32 outArgPosition) { 
 
     if (outRegSize < outArgPosition+1) {
         outRegSize = outArgPosition+1;
@@ -85,8 +85,8 @@
 
     if (opnd->getOpndKind() != OPND_G_REG) return false; // opnd is not gr - ignore
 
-    int32 firstOutRegArg = G_OUTARG_BASE - outRegSize + 1;
-    int32 location       = opnd->getLocation();
+    I_32 firstOutRegArg = G_OUTARG_BASE - outRegSize + 1;
+    I_32 location       = opnd->getLocation();
     if (location < firstOutRegArg) return false; // location is less then first outArg - ignore
     if (location >= NUM_G_REG)     return false; // location is greater then last outArg - ignore
     return true;                                 // it is out reg arg
@@ -108,21 +108,21 @@
 //----------------------------------------------------------------------------------------//
 // returns location (not offset!) for new in stack opnd
 
-int32 MemStack::newInSlot(int32 inArgPosition) {
+I_32 MemStack::newInSlot(I_32 inArgPosition) {
     
-    int32 offset = (inArgPosition - MAX_REG_ARG) * ARG_SLOT_SIZE;
+    I_32 offset = (inArgPosition - MAX_REG_ARG) * ARG_SLOT_SIZE;
     return S_INARG_BASE + offset;
 }
 
 //----------------------------------------------------------------------------------------//
 // increments locMemSize and returns location (not offset!) for new local stack opnd
 
-int32 MemStack::newLocSlot(DataKind dataKind) {
+I_32 MemStack::newLocSlot(DataKind dataKind) {
     
     if (inBase > 0) IPF_ERR << endl;            // new loc slot makes illegal in arg offsets
 
     int16 size   = IpfType::getSize(dataKind);
-    int32 offset = align(locMemSize, size);     // align memory address to natural boundary
+    I_32 offset = align(locMemSize, size);     // align memory address to natural boundary
     locMemSize = offset + size;                 // increase current local area size
     
     return S_LOCAL_BASE + offset;
@@ -131,12 +131,12 @@
 //----------------------------------------------------------------------------------------//
 // increments outMemSize and returns location (not offset!) for new out stack opnd
 
-int32 MemStack::newOutSlot(int32 outArgPosition) {
+I_32 MemStack::newOutSlot(I_32 outArgPosition) {
 
     if (locBase+inBase > 0) IPF_ERR << endl;    // new out slot makes illegal in arg and local offsets
     
-    int32 offset  = (outArgPosition - MAX_REG_ARG) * ARG_SLOT_SIZE;
-    int32 newSize = offset + ARG_SLOT_SIZE;
+    I_32 offset  = (outArgPosition - MAX_REG_ARG) * ARG_SLOT_SIZE;
+    I_32 newSize = offset + ARG_SLOT_SIZE;
     if(outMemSize < newSize) outMemSize = newSize;
     
     return S_OUTARG_BASE + offset;
@@ -147,7 +147,7 @@
     
 void MemStack::calculateOffset(RegOpnd* opnd) {
     
-    int32 location = opnd->getLocation();
+    I_32 location = opnd->getLocation();
     location = calculateOffset(location);
     opnd->setLocation(location);
 }
@@ -155,7 +155,7 @@
 //----------------------------------------------------------------------------------------//
 // converts area local offset (location) in absolute offset + S_BASE
     
-int32 MemStack::calculateOffset(int32 location) {
+I_32 MemStack::calculateOffset(I_32 location) {
     
     if(location < S_OUTARG_BASE) { // offset has been calculated
         return location;
@@ -179,7 +179,7 @@
 //----------------------------------------------------------------------------------------//
 // return current location in local area
     
-int32 MemStack::getSavedBase() {
+I_32 MemStack::getSavedBase() {
 
     outBase   = outMemSize+locMemSize > 0 ? S_SCRATCH_SIZE : 0;
     locBase   = outBase + align(outMemSize, S_SCRATCH_SIZE);
@@ -188,7 +188,7 @@
 
 //----------------------------------------------------------------------------------------//
 
-int32 MemStack::getMemStackSize() {
+I_32 MemStack::getMemStackSize() {
 
     outBase = outMemSize+locMemSize > 0 ? S_SCRATCH_SIZE : 0;
     locBase = outBase + align(outMemSize, S_SCRATCH_SIZE);
@@ -199,10 +199,10 @@
     
 //----------------------------------------------------------------------------------------//
     
-int32 MemStack::align(int32 val, int32 size) {
+I_32 MemStack::align(I_32 val, I_32 size) {
 
-    int32 mask = -size;
-    int32 buf  = val & mask;
+    I_32 mask = -size;
+    I_32 buf  = val & mask;
     return buf<val ? buf+size : buf;
 }
 
@@ -265,7 +265,7 @@
 
 //----------------------------------------------------------------------------------------//
 
-RegOpnd *OpndManager::newRegOpnd(OpndKind opndKind, DataKind dataKind, int32 location) {
+RegOpnd *OpndManager::newRegOpnd(OpndKind opndKind, DataKind dataKind, I_32 location) {
     return new(mm) RegOpnd(mm, maxOpndId++, opndKind, dataKind, location);
 }
 
@@ -295,9 +295,9 @@
 
 //----------------------------------------------------------------------------------------//
 
-Opnd *OpndManager::newInArg(OpndKind opndKind, DataKind dataKind, uint32 inArgPosition) {
+Opnd *OpndManager::newInArg(OpndKind opndKind, DataKind dataKind, U_32 inArgPosition) {
 
-    int32 location = LOCATION_INVALID;
+    I_32 location = LOCATION_INVALID;
     bool  isFp     = IpfType::isFloating(dataKind);
 
     if (inArgPosition < MAX_REG_ARG) {
@@ -435,13 +435,13 @@
 //----------------------------------------------------------------------------------------//
 // tryes to find available location for the opndKind/dataKind taking in account mask of used regs 
 
-int32 OpndManager::newLocation(OpndKind  opndKind, 
+I_32 OpndManager::newLocation(OpndKind  opndKind, 
                                DataKind  dataKind, 
                                RegBitSet usedMask, 
                                bool      isPreserved) {
     
     RegBitSet &unusedMask = usedMask.flip(); 
-    int32 location = LOCATION_INVALID;
+    I_32 location = LOCATION_INVALID;
     
     if (isPreserved == false) {                             // it is scratch location
         location = newScratchReg(opndKind, unusedMask);     // try to find scratch register
@@ -457,7 +457,7 @@
 //----------------------------------------------------------------------------------------//
 // tryes to find available scratch register for the opndKind taking in account mask of unused regs 
 
-int32 OpndManager::newScratchReg(OpndKind opndKind, RegBitSet &unusedMask) {
+I_32 OpndManager::newScratchReg(OpndKind opndKind, RegBitSet &unusedMask) {
 
     RegBitSet mask;
     int16     maskSize = 0;
@@ -478,7 +478,7 @@
 //----------------------------------------------------------------------------------------//
 // tryes to find available preserved register for the opndKind taking in account mask of unused regs 
 
-int32 OpndManager::newPreservReg(OpndKind opndKind, RegBitSet &unusedMask) {
+I_32 OpndManager::newPreservReg(OpndKind opndKind, RegBitSet &unusedMask) {
 
     RegBitSet mask;
     int16     maskSize = 0;

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfPrologEpilogGenerator.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfPrologEpilogGenerator.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfPrologEpilogGenerator.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfPrologEpilogGenerator.cpp Thu May 22 06:33:38 2008
@@ -130,7 +130,7 @@
 void PrologEpilogGenerator::reassignOutRegArgs() {
     
     // First out arg will have this location 
-    int32 outArgBase = G_INARG_BASE + opndManager->getLocRegSize();
+    I_32 outArgBase = G_INARG_BASE + opndManager->getLocRegSize();
     
     for(RegOpndSetIterator it=outRegArgs.begin(); it!=outRegArgs.end(); it++) {  
         setRegUsage(*it, false);                                     // mark old reg as free
@@ -140,7 +140,7 @@
 
         RegOpnd *arg = *it;
         IPF_LOG << "      " << IrPrinter::toString(arg) << " reassigned on ";
-        int32 outArgNum = G_OUTARG_BASE - arg->getValue();           // calculate real out arg number
+        I_32 outArgNum = G_OUTARG_BASE - arg->getValue();           // calculate real out arg number
         arg->setLocation(outArgBase + outArgNum);                    // calculate and assign new location
         setRegUsage(arg, true);                                      // mark new reg as used
         IPF_LOG << IrPrinter::toString(arg) << endl;  
@@ -289,9 +289,9 @@
 
 void PrologEpilogGenerator::genAlloc() {
 
-    int32 locRegSize = calculateLocRegSize();                  // actual reg usage in local area
-    int32 inRegSize  = opndManager->getInRegSize();            // in regs number
-    int32 outRegSize = opndManager->getOutRegSize();           // out regs number
+    I_32 locRegSize = calculateLocRegSize();                  // actual reg usage in local area
+    I_32 inRegSize  = opndManager->getInRegSize();            // in regs number
+    I_32 outRegSize = opndManager->getOutRegSize();           // out regs number
 
     if (containCall==false && locRegSize<=inRegSize) return;   // method does not need "alloc" inst
 
@@ -462,7 +462,7 @@
 void PrologEpilogGenerator::saveRestoreSp() {
     
     opndManager->initMemStackSize();
-    int32 memStackSize = opndManager->memStackSize;
+    I_32 memStackSize = opndManager->memStackSize;
     if (memStackSize <= S_SCRATCH_SIZE) return;    // method does not need to save SP
     
     Opnd *memStackSizeOpndNeg = opndManager->newImm(-memStackSize);
@@ -475,7 +475,7 @@
 
 RegOpnd* PrologEpilogGenerator::newStorage(DataKind dataKind, uint16 site) {
     
-    int32 location = LOCATION_INVALID;
+    I_32 location = LOCATION_INVALID;
     if (site==SITE_REG) location = opndManager->newLocation(OPND_G_REG, dataKind, usedGrMask, containCall);
     else                location = opndManager->newLocSlot(dataKind);
     
@@ -505,11 +505,11 @@
     
 //----------------------------------------------------------------------------------------//
 
-int32 PrologEpilogGenerator::calculateLocRegSize() {
+I_32 PrologEpilogGenerator::calculateLocRegSize() {
     
     uint16 first      = G_INARG_BASE;                             // first possible loc reg opnd location
     uint16 last       = NUM_G_REG - opndManager->getOutRegSize(); // last possible loc reg opnd location
-    int32  locRegSize = 0; 
+    I_32  locRegSize = 0; 
     
     // find last used gr in local area
     for(uint16 i=first; i<last; i++) {

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfRegisterAllocator.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfRegisterAllocator.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfRegisterAllocator.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfRegisterAllocator.cpp Thu May 22 06:33:38 2008
@@ -72,7 +72,7 @@
         BbNode *node = (BbNode *)nodes[i];
         liveManager.init(node);
 
-        uint32       execCounter = node->getExecCounter();
+        U_32       execCounter = node->getExecCounter();
         InstIterator currInst    = node->getInsts().end()-1;
         InstIterator firstInst   = node->getInsts().begin()-1;
         
@@ -103,7 +103,7 @@
 
 //----------------------------------------------------------------------------------------//
 
-void RegisterAllocator::checkCoalescing(uint32 execCounter, Inst *inst) {
+void RegisterAllocator::checkCoalescing(U_32 execCounter, Inst *inst) {
     
     if (inst->getInstCode() != INST_MOV)          return; // if inst is not "mov" - ignore
 
@@ -201,7 +201,7 @@
     RegOpndSet &depOpnds = target->getDepOpnds();               // target can not be assigned on reg used by depOpnds
     for (RegOpndSet::iterator it=depOpnds.begin(); it!=depOpnds.end(); it++) {
         RegOpnd *opnd = *it;
-        int32 location = opnd->getLocation();                   // get location of dep opnd
+        I_32 location = opnd->getLocation();                   // get location of dep opnd
         if (location >= NUM_G_REG) continue;                    // if opnd is not assigned on reg - continue
         usedMask[location] = true;                              // mark reg busy
     }
@@ -209,7 +209,7 @@
     Int2OpndMap &coalesceCands = target->getCoalesceCands();    // opnds used in inst like: move target = opnd
     for (Int2OpndMap::iterator it=coalesceCands.begin(); it!=coalesceCands.end(); it++) {
         RegOpnd *cls = it->second;
-        int32 location = cls->getValue();                       // get location of coalesce candidate 
+        I_32 location = cls->getValue();                       // get location of coalesce candidate 
         if (location > NUM_G_REG)                   continue;   // opnd is not allocated (or allocated on stack)
         if (isPreserved && !cls->isCrossCallSite()) continue;   // target must be preserved, but cls is scratch
         if (usedMask[location] == true)             continue;   // target can not be allocated on cls location
@@ -217,13 +217,13 @@
         return;
     }
     
-    int32 location = opndManager->newLocation(opndKind, dataKind, usedMask, isPreserved);
+    I_32 location = opndManager->newLocation(opndKind, dataKind, usedMask, isPreserved);
     target->setLocation(location);                              // assign target new location
 }    
 
 //----------------------------------------------------------------------------------------//
 
-void RegisterAllocator::updateAllocSet(Opnd *cand_, uint32 execCounter, QpMask mask) {
+void RegisterAllocator::updateAllocSet(Opnd *cand_, U_32 execCounter, QpMask mask) {
 
     if (cand_->isReg()      == false) return;    // imm - it does not need allocation
     if (cand_->isMem()      == true)  return;    // mem stack - it does not need allocation

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfRuntimeInterface.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfRuntimeInterface.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfRuntimeInterface.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfRuntimeInterface.cpp Thu May 22 06:33:38 2008
@@ -45,13 +45,13 @@
 
     uint64 sp            = jitFrameContext->sp;           // get current frame sp 
     uint64 addr          = sp + stackInfo.savedBase;      // mem stack offset of first saved gr
-    uint32 savedGrMask   = stackInfo.savedGrMask;         // mask of preserved grs saved on stack
-    uint32 savedFrMask   = stackInfo.savedFrMask;         // mask of preserved frs saved on stack
-    uint32 savedBrMask   = stackInfo.savedBrMask;         // mask of preserved frs saved on stack
+    U_32 savedGrMask   = stackInfo.savedGrMask;         // mask of preserved grs saved on stack
+    U_32 savedFrMask   = stackInfo.savedFrMask;         // mask of preserved frs saved on stack
+    U_32 savedBrMask   = stackInfo.savedBrMask;         // mask of preserved frs saved on stack
 
     // Restore preserved general registers
     if(savedGrMask != 0) {
-        for(uint32 i=0; i<32; i++) {
+        for(U_32 i=0; i<32; i++) {
             if((savedGrMask & 1) == 1) {
                 jitFrameContext->p_gr[i] = (uint64 *)addr;
                 addr += 8;
@@ -62,7 +62,7 @@
     
     // Restore preserved floating registers
     if(savedFrMask != 0) {
-        for(uint32 i=0; i<32; i++) {
+        for(U_32 i=0; i<32; i++) {
             if((savedFrMask & 1) == 1) {
                 jitFrameContext->p_fp[i] = (uint64 *)addr;
                 addr += 16;
@@ -73,7 +73,7 @@
 
     // Restore preserved branch registers
     if(savedBrMask != 0) {
-        for(uint32 i=0; i<8; i++) {
+        for(U_32 i=0; i<8; i++) {
             if((savedBrMask & 1) == 1) {
                 jitFrameContext->p_br[i] = (uint64 *)addr;
                 addr += 8;
@@ -86,28 +86,28 @@
     jitFrameContext->sp += stackInfo.memStackSize;
 
     // Restore return pointer
-    int32 rpBak = stackInfo.rpBak;
+    I_32 rpBak = stackInfo.rpBak;
     if(rpBak != LOCATION_INVALID) {
         if(rpBak >= S_BASE) jitFrameContext->p_eip = (uint64 *)(sp + rpBak - S_BASE);
         else                jitFrameContext->p_eip = jitFrameContext->p_gr[rpBak];
     }
 
     // Restore prs
-    int32 prBak = stackInfo.prBak;
+    I_32 prBak = stackInfo.prBak;
     if(prBak != LOCATION_INVALID) {
         if(prBak >= S_BASE) jitFrameContext->preds = *((uint64 *)(sp + prBak - S_BASE));
         else                jitFrameContext->preds = *(jitFrameContext->p_gr[prBak]);
     }
 
     // Restore pfs
-    int32 pfsBak = stackInfo.pfsBak;
+    I_32 pfsBak = stackInfo.pfsBak;
     if(pfsBak != LOCATION_INVALID) {
         if(pfsBak >= S_BASE) jitFrameContext->p_ar_pfs = (uint64 *)(sp + pfsBak - S_BASE);
         else                 jitFrameContext->p_ar_pfs = jitFrameContext->p_gr[pfsBak];
     }
 
     // Restore unat
-    int32 unatBak = stackInfo.unatBak;
+    I_32 unatBak = stackInfo.unatBak;
     if(unatBak != LOCATION_INVALID) {
         if(unatBak >= S_BASE) jitFrameContext->ar_unat = *((uint64 *)(sp + unatBak - S_BASE));
         else                  jitFrameContext->ar_unat = *(jitFrameContext->p_gr[unatBak]);
@@ -136,7 +136,7 @@
     U_8*   infoBlock = methodDesc->getInfoBlock();
     U_8*   gcInfo    = infoBlock + sizeof(StackInfo);
     uint64 currIp    = *context->p_eip;
-    uint32 gcSize    = *((uint32 *)gcInfo);
+    U_32 gcSize    = *((U_32 *)gcInfo);
 
 //    cout << "getGCRootSet for ip " << hex << currIp << dec << " method " << methodDesc->getName() << endl;
     U_8* safePoint = findSafePoint(gcInfo, gcSize, currIp);
@@ -145,7 +145,7 @@
 
 //----------------------------------------------------------------------------------------//
 
-uint32 RuntimeInterface::getInlineDepth(InlineInfoPtr ptr, uint32 offset) {
+U_32 RuntimeInterface::getInlineDepth(InlineInfoPtr ptr, U_32 offset) {
 
     std::cout << "FIXME: IPF::RuntimeInterface::getInlineDepth" << endl;
     return 0;
@@ -154,8 +154,8 @@
 //----------------------------------------------------------------------------------------//
 
 Method_Handle RuntimeInterface::getInlinedMethod(InlineInfoPtr ptr, 
-                                                 uint32        offset, 
-                                                 uint32        inline_depth) {
+                                                 U_32        offset, 
+                                                 U_32        inline_depth) {
 
     std::cout << "FIXME: IPF::RuntimeInterface::getInlinedMethod" << endl;
     return NULL;
@@ -214,17 +214,17 @@
 // GC Root Set 
 //----------------------------------------------------------------------------------------//
 
-U_8* RuntimeInterface::findSafePoint(U_8* info, uint32 size, uint64 currIp)
+U_8* RuntimeInterface::findSafePoint(U_8* info, U_32 size, uint64 currIp)
 {
-    uint32 offset    = ROOT_SET_HEADER_SIZE;
+    U_32 offset    = ROOT_SET_HEADER_SIZE;
     U_8*   safePoint = NULL;
-    uint32 spSize    = 0;
+    U_32 spSize    = 0;
     uint64 spAddress = 0;
 
     while (offset < size) {
         safePoint = info + offset;
-        spSize    = *((uint32 *)safePoint);
-        spAddress = *((uint64 *)(safePoint + sizeof(uint32)));
+        spSize    = *((U_32 *)safePoint);
+        spAddress = *((uint64 *)(safePoint + sizeof(U_32)));
 
         if (spAddress == currIp) return safePoint;
         offset += spSize;
@@ -241,9 +241,9 @@
                                         const JitFrameContext* context,
                                         U_8*                   safePoint)
 {
-    uint32 size   = *((uint32 *)(safePoint));
-    int32* ptr    = (int32 *)(safePoint + SAFE_POINT_HEADER_SIZE);
-    int32* maxPtr = (int32 *)(safePoint + size);
+    U_32 size   = *((U_32 *)(safePoint));
+    I_32* ptr    = (I_32 *)(safePoint + SAFE_POINT_HEADER_SIZE);
+    I_32* maxPtr = (I_32 *)(safePoint + size);
 
     while (ptr < maxPtr) {
         if (isMptr(*ptr)) reportMptr(*(ptr++), *(ptr++));
@@ -253,7 +253,7 @@
 
 //----------------------------------------------------------------------------------------//
 
-void** RuntimeInterface::getContextValue(int32 location) {
+void** RuntimeInterface::getContextValue(I_32 location) {
     
     if (location < 0) {
         location = - (location + 1);              // if location refers mptr - restore it
@@ -261,7 +261,7 @@
 
     void** ptr = NULL;
     if (location >= NUM_G_REG) {                  // this location points in memory stack
-        int32 offset = location - NUM_G_REG;      // calc memory stack offset
+        I_32 offset = location - NUM_G_REG;      // calc memory stack offset
         ptr = (void **)(context->sp + offset);    // get pointer on stack value
     } else {                                      // general register
         ptr = (void **)(context->p_gr[location]); // get pointer on reg value
@@ -271,7 +271,7 @@
 
 //----------------------------------------------------------------------------------------//
 
-void RuntimeInterface::reportMptr(int32 mptr, int32 base) {
+void RuntimeInterface::reportMptr(I_32 mptr, I_32 base) {
 
     void **mptrPtr = getContextValue(mptr);
     void **basePtr = getContextValue(base);
@@ -293,7 +293,7 @@
 
 //----------------------------------------------------------------------------------------//
 
-void RuntimeInterface::reportBase(int32 base) {
+void RuntimeInterface::reportBase(I_32 base) {
 
     void** basePtr = getContextValue(base);   
 //    uint64 *u1 = (uint64 *)basePtr;
@@ -306,7 +306,7 @@
 
 //----------------------------------------------------------------------------------------//
 
-bool RuntimeInterface::isMptr(int32 ptr) { return ptr < 0; }
+bool RuntimeInterface::isMptr(I_32 ptr) { return ptr < 0; }
 
 } // IPF
 } // Jitrino

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfRuntimeSupport.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfRuntimeSupport.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfRuntimeSupport.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfRuntimeSupport.cpp Thu May 22 06:33:38 2008
@@ -93,27 +93,27 @@
 
     IPF_LOG << endl << "  Make Stack Info" << endl;
     StackInfo *stackInfo = makeStackInfo();
-    uint32 stackInfoSize = sizeof(StackInfo);
+    U_32 stackInfoSize = sizeof(StackInfo);
     IPF_LOG << "    stack info size (bytes): " << stackInfoSize << endl;
 
     IPF_LOG << endl << "  Make Root Seet Info" << endl;
     Uint32Vector rootSetInfo(mm);
     makeRootSetInfo(rootSetInfo);
-    uint32 rootSetInfoSize = ROOT_SET_HEADER_SIZE + rootSetInfo.size() * sizeof(uint32);
+    U_32 rootSetInfoSize = ROOT_SET_HEADER_SIZE + rootSetInfo.size() * sizeof(U_32);
     IPF_LOG << "    GC root set info size (bytes): " << rootSetInfoSize << endl;
 
     // create info block
-    uint32 infoBlockSize = stackInfoSize + rootSetInfoSize;
+    U_32 infoBlockSize = stackInfoSize + rootSetInfoSize;
     U_8*   infoBlock     = compilationInterface.allocateInfoBlock(infoBlockSize);
 
     // write stack info
     *((StackInfo *)infoBlock) = *stackInfo;
 
     // write root set info
-    uint32 *gcInfo = (uint32 *)(infoBlock + sizeof(StackInfo));
-    uint32 j       = ROOT_SET_HEADER_SIZE / sizeof(uint32); 
+    U_32 *gcInfo = (U_32 *)(infoBlock + sizeof(StackInfo));
+    U_32 j       = ROOT_SET_HEADER_SIZE / sizeof(U_32); 
     gcInfo[0] = rootSetInfoSize;
-    for (uint32 i=0; i<rootSetInfo.size(); i++, j++) {
+    for (U_32 i=0; i<rootSetInfo.size(); i++, j++) {
         gcInfo[j] = rootSetInfo[i];
     }
 }
@@ -233,15 +233,15 @@
 
 StackInfo* RuntimeSupport::makeStackInfo() {
     
-    int32  rpBak          = opndManager->rpBak;
-    int32  prBak          = opndManager->prBak;
-    int32  pfsBak         = opndManager->pfsBak;
-    int32  unatBak        = opndManager->unatBak;
-    uint32 savedGrMask    = opndManager->savedGrMask;
-    uint32 savedFrMask    = opndManager->savedFrMask;
-    uint32 savedBrMask    = opndManager->savedBrMask;
-    uint32 memStackSize   = opndManager->memStackSize;
-    int32  savedBase      = opndManager->savedBase;
+    I_32  rpBak          = opndManager->rpBak;
+    I_32  prBak          = opndManager->prBak;
+    I_32  pfsBak         = opndManager->pfsBak;
+    I_32  unatBak        = opndManager->unatBak;
+    U_32 savedGrMask    = opndManager->savedGrMask;
+    U_32 savedFrMask    = opndManager->savedFrMask;
+    U_32 savedBrMask    = opndManager->savedBrMask;
+    U_32 memStackSize   = opndManager->memStackSize;
+    I_32  savedBase      = opndManager->savedBase;
 
     if(LOG_ON) {
         if (rpBak!=LOCATION_INVALID   && rpBak>=S_OUTARG_BASE)      { IPF_ERR << " rpBak = " << rpBak << endl; }
@@ -487,8 +487,8 @@
 
 void RuntimeSupport::writeSpInfo(Uint32Vector &info, uint64 spAddr, RegOpndVector &ptrs) {
 
-    uint32 spAddrHight = spAddr;                                // hight part of spAddr
-    uint32 spAddrLow   = spAddr >> 32;                          // low   part of spAddr
+    U_32 spAddrHight = spAddr;                                // hight part of spAddr
+    U_32 spAddrLow   = spAddr >> 32;                          // low   part of spAddr
     uint16 sizePos     = info.size();
 
     info.push_back(0);                                          // push safe point info size (placeholder)
@@ -497,21 +497,21 @@
 
     IPF_LOG << "      address: " << hex << spAddr << dec << "  alive pointers locations:";
     for (uint16 i=0; i<ptrs.size(); i++) {
-        int32 location = toInt32(ptrs[i]);                 // get mptr location
+        I_32 location = toInt32(ptrs[i]);                 // get mptr location
         info.push_back(location);                       // push base location
         IPF_LOG << " " << location;
     }
 
-    info[sizePos] = (info.size() - sizePos) * sizeof(uint32);
+    info[sizePos] = (info.size() - sizePos) * sizeof(U_32);
     IPF_LOG << "  size: " << info[sizePos] << endl;
 }
 
 //----------------------------------------------------------------------------------------//
 // returns opnd location in form to store in info block
 
-int32 RuntimeSupport::toInt32(RegOpnd *opnd) {
+I_32 RuntimeSupport::toInt32(RegOpnd *opnd) {
     
-    int32 location = opnd->getValue();
+    I_32 location = opnd->getValue();
     if (LOG_ON && location >= S_OUTARG_BASE) IPF_ERR << " location = " << location << endl;
     if (opnd->isMem() == true)            location += NUM_G_REG;
     if (opnd->getDataKind() == DATA_MPTR) location = - (location + 1);

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfSpillGen.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfSpillGen.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfSpillGen.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfSpillGen.cpp Thu May 22 06:33:38 2008
@@ -117,7 +117,7 @@
     // Create scratchOpnd
     OpndKind opndKind     = stackOpnd->getOpndKind();
     DataKind dataKind     = stackOpnd->getDataKind();
-    int32    scratchReg   = getAvailableSpillReg(opndKind);
+    I_32    scratchReg   = getAvailableSpillReg(opndKind);
     RegOpnd  *scratchOpnd = opndManager->newRegOpnd(opndKind, dataKind, scratchReg);
     
     // calculate absolute offset and set it as location on stack opnd
@@ -152,7 +152,7 @@
 
 //----------------------------------------------------------------------------------------//
 
-int32 SpillGen::getAvailableSpillReg(OpndKind opndKind) {
+I_32 SpillGen::getAvailableSpillReg(OpndKind opndKind) {
     
     switch(opndKind) {
         case OPND_G_REG: return getAvailableReg(spillGrMask, NUM_G_REG);
@@ -165,7 +165,7 @@
     
 //----------------------------------------------------------------------------------------//
 
-int32 SpillGen::getAvailableReg(RegBitSet &regMask, int16 maskSize) {
+I_32 SpillGen::getAvailableReg(RegBitSet &regMask, int16 maskSize) {
     
     for(int16 i=0; i<maskSize; i++) if(regMask[i] == 1) { regMask[i]=0; return i; }
     IPF_ERR << " No available spill reg" << endl;
@@ -226,7 +226,7 @@
 
 void SpillGen::spillBr(RegOpnd *scratchOpnd) {
     
-    int32 bufReg   = getAvailableSpillReg(OPND_G_REG);
+    I_32 bufReg   = getAvailableSpillReg(OPND_G_REG);
     Opnd  *bufOpnd = opndManager->newRegOpnd(OPND_G_REG, DATA_B, bufReg);
     Inst  *mov     = new(mm) Inst(mm, INST_MOV, p0, bufOpnd, scratchOpnd);
     Inst  *st      = new(mm) Inst(mm, INST_ST, CMPLT_SZ_8, p0, stackAddr, bufOpnd);
@@ -246,7 +246,7 @@
 
 void SpillGen::spillPr(RegOpnd *scratchOpnd) {
     
-    int32 bufReg  = getAvailableSpillReg(OPND_G_REG);
+    I_32 bufReg  = getAvailableSpillReg(OPND_G_REG);
     Opnd *bufOpnd = opndManager->newRegOpnd(OPND_G_REG, DATA_P, bufReg);
     Opnd *imm1    = opndManager->newImm(1);
     Inst *mov1    = new(mm) Inst(mm, INST_MOV, p0, bufOpnd, opndManager->getR0());
@@ -279,7 +279,7 @@
     Inst *ld = new(mm) Inst(mm, INST_LD, completer, p0, scratchOpnd, stackAddr);
     fillCode.push_back(ld);
 
-    // Create sxt instruction for int32 data type
+    // Create sxt instruction for I_32 data type
     if(scratchOpnd->getDataKind() == DATA_I32) {
         Inst *sxt = new(mm) Inst(mm, INST_SXT, CMPLT_XSZ_4, p0, scratchOpnd, scratchOpnd);
         fillCode.push_back(sxt);
@@ -317,7 +317,7 @@
 
 void SpillGen::fillBr(RegOpnd *scratchOpnd) {
     
-    int32 bufReg  = getAvailableSpillReg(OPND_G_REG);
+    I_32 bufReg  = getAvailableSpillReg(OPND_G_REG);
     Opnd *bufOpnd = opndManager->newRegOpnd(OPND_G_REG, DATA_I64, bufReg);
     Inst *ld      = new(mm) Inst(mm, INST_LD, CMPLT_SZ_8, p0, bufOpnd, stackAddr);
     Inst *mov     = new(mm) Inst(mm, INST_MOV, p0, scratchOpnd, bufOpnd);
@@ -336,7 +336,7 @@
 
 void SpillGen::fillPr(RegOpnd *scratchOpnd) {
     
-    int32 bufReg   = getAvailableSpillReg(OPND_G_REG);
+    I_32 bufReg   = getAvailableSpillReg(OPND_G_REG);
     Opnd  *bufOpnd = opndManager->newRegOpnd(OPND_G_REG, DATA_P, bufReg);
     Inst  *ld      = new(mm) Inst(mm, INST_LD, CMPLT_SZ_1, p0, bufOpnd, stackAddr);
     Inst  *cmp     = new(mm) Inst(mm, INST_CMP, CMPLT_CMP_CREL_NE, p0, scratchOpnd, p0, bufOpnd);

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfVerifier.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfVerifier.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfVerifier.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfVerifier.cpp Thu May 22 06:33:38 2008
@@ -306,7 +306,7 @@
         break;
     case INST_FCVT_XUF:
         if (IS_C(2)) return false;
-        for (uint32 i=0 ; IS_C(i) ; i++) {
+        for (U_32 i=0 ; IS_C(i) ; i++) {
             switch (C(i)) {
             case CMPLT_PC_SINGLE:  
             case CMPLT_PC_DOUBLE:  
@@ -323,7 +323,7 @@
         if (IS_FR(1) && IS_FR(2)) return true;
         break;
     case INST_FMA:
-        for (uint32 i=0 ; IS_C(i) ; i++) {
+        for (U_32 i=0 ; IS_C(i) ; i++) {
             switch (C(i)) {
             case CMPLT_PC_SINGLE:  
             case CMPLT_PC_DOUBLE:  
@@ -347,7 +347,7 @@
     case INST_FPMAX:
     case INST_FPAMIN:
     case INST_FPAMAX:
-        for (uint32 i=0 ; IS_C(i) ; i++) {
+        for (U_32 i=0 ; IS_C(i) ; i++) {
             switch (C(i)) {
             case CMPLT_SF0:
             case CMPLT_SF1:
@@ -361,7 +361,7 @@
         if (IS_FR(1) && IS_FR(2) && IS_FR(3)) return true;
         break;
     case INST_FPCMP:
-        for (uint32 i=0 ; IS_C(i) ; i++) {
+        for (U_32 i=0 ; IS_C(i) ; i++) {
             switch (C(i)) {
             case CMPLT_SF0:
             case CMPLT_SF1:
@@ -395,7 +395,7 @@
         if (IS_FR(1) && IS_FR(2) && !IS_O(3) && !IS_C(0)) return true;
         break;
     case INST_FNMA:
-        for ( uint32 i=0 ; IS_C(i) ; i++ ) {
+        for ( U_32 i=0 ; IS_C(i) ; i++ ) {
             switch(C(i)) {
             case CMPLT_PC_SINGLE:
             case CMPLT_PC_DOUBLE:
@@ -412,7 +412,7 @@
         if (IS_FR(1) && IS_FR(2) && IS_FR(3) && IS_FR(4) && !IS_O(5)) return true;
         break;
     case INST_FNORM:
-        for ( uint32 i=0 ; IS_C(i) ; i++ ) {
+        for ( U_32 i=0 ; IS_C(i) ; i++ ) {
             switch(C(i)) {
             case CMPLT_PC_SINGLE:
             case CMPLT_PC_DOUBLE:
@@ -923,7 +923,7 @@
 
 //----------------------------------------------------------------------------//
 bool IpfVerifier::ldx(string * res, Inst * inst, InstCode icode, OpndVector & opnds, CompVector & cmpls) {
-    for (uint32 i=0 ; IS_C(i) ; i++ ) {
+    for (U_32 i=0 ; IS_C(i) ; i++ ) {
         switch (C(i)) {
         case CMPLT_SZ_1:
         case CMPLT_SZ_2:
@@ -968,7 +968,7 @@
 
 //----------------------------------------------------------------------------//
 bool IpfVerifier::ldfx(string * res, Inst * inst, InstCode icode, OpndVector & opnds, CompVector & cmpls) {
-    for (uint32 i=0 ; IS_C(i) ; i++ ) {
+    for (U_32 i=0 ; IS_C(i) ; i++ ) {
         switch (C(i)) {
         case CMPLT_FSZ_E:
         case CMPLT_FSZ_S:
@@ -1012,7 +1012,7 @@
     if (icode==INST_MOV && !IS_O(3) && ((IS_GR(1) && IS_BR(2)) || (IS_BR(1) && IS_GR(2))))
         return true;
     if ((icode==INST_MOV || icode==INST_MOV_RET) && IS_O(3) && IS_BR(1) && IS_GR(2) && IS_IMM13(3)) {
-        for (uint32 i=0 ; IS_C(i) ; i++){
+        for (U_32 i=0 ; IS_C(i) ; i++){
             switch (C(i)) {
             case CMPLT_IH_NOT_IMP:
             case CMPLT_IH_IMP:

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfCfg.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfCfg.h?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfCfg.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfCfg.h Thu May 22 06:33:38 2008
@@ -52,8 +52,8 @@
 class Constant {
 public:
                  Constant(DataKind);
-    void         setOffset(int32 offset_)    { offset = offset_; }
-    int32        getOffset()                 { return offset; }
+    void         setOffset(I_32 offset_)    { offset = offset_; }
+    I_32        getOffset()                 { return offset; }
     void         setAddress(void *address_)  { address = address_; }
     void         *getAddress()               { return address; }
     void         setSize(int16 size_)        { size = size_; }
@@ -63,7 +63,7 @@
 
 protected:
     void         *address;
-    int32        offset;
+    I_32        offset;
     int16        size;
     DataKind     dataKind;
 };
@@ -135,7 +135,7 @@
 
 class Opnd : public CG_OpndHandle {
 public:
-                    Opnd(uint32, OpndKind=OPND_INVALID, DataKind=DATA_INVALID, int64=0);
+                    Opnd(U_32, OpndKind=OPND_INVALID, DataKind=DATA_INVALID, int64=0);
 
     uint16          getId()                         { return id; }
     OpndKind        getOpndKind()                   { return opndKind; }
@@ -172,18 +172,18 @@
 
 class RegOpnd : public Opnd {
 public:
-                RegOpnd(MemoryManager&, uint32, OpndKind, DataKind, int32=LOCATION_INVALID);
+                RegOpnd(MemoryManager&, U_32, OpndKind, DataKind, I_32=LOCATION_INVALID);
     int64       getValue();
-    void        setLocation(int32 value_)             { value = value_; }
-    int32       getLocation()                         { return value; }
+    void        setLocation(I_32 value_)             { value = value_; }
+    I_32       getLocation()                         { return value; }
 
     QpMask      getQpMask()                           { return qpMask; }
     void        andQpMask(QpMask mask)                { qpMask &= mask; }
     void        orQpMask(QpMask mask)                 { qpMask |= mask; }
     bool        isAlive(QpMask mask)                  { return mask & qpMask; }
 
-    void        incSpillCost(uint32 spillCost_)       { spillCost += spillCost_; }
-    uint32      getSpillCost()                        { return spillCost; }
+    void        incSpillCost(U_32 spillCost_)       { spillCost += spillCost_; }
+    U_32      getSpillCost()                        { return spillCost; }
     RegOpndSet  &getDepOpnds()                        { return depOpnds; }
     void        insertDepOpnds(RegOpndSet &opnds)     { depOpnds.insert(opnds.begin(), opnds.end()); }
     void        insertDepOpnd(RegOpnd*);
@@ -191,14 +191,14 @@
     bool        isCrossCallSite()                     { return crossCallSite; }
 
     Int2OpndMap &getCoalesceCands()                   { return coalesceCands; }
-    void        addCoalesceCand(uint32 execCnt, RegOpnd *opnd) { coalesceCands.insert(make_pair(execCnt, opnd)); }
+    void        addCoalesceCand(U_32 execCnt, RegOpnd *opnd) { coalesceCands.insert(make_pair(execCnt, opnd)); }
 
     virtual     ~RegOpnd() {}
 
 protected:
     QpMask      qpMask;             // mask of predicate spaces opnd alive in
     // These fields are for register allocation algorithm
-    uint32      spillCost;          // number of opnd uses
+    U_32      spillCost;          // number of opnd uses
     RegOpndSet  depOpnds;           // opnds which can not be placed in the same reg with the opnd
     bool        crossCallSite;      // opnd live range crosses call site
     Int2OpndMap coalesceCands;      // 
@@ -210,7 +210,7 @@
 
 class ConstantRef : public Opnd {
 public:
-    ConstantRef::ConstantRef(uint32 id, Constant *constant, DataKind dataKind = DATA_CONST_REF) :
+    ConstantRef::ConstantRef(U_32 id, Constant *constant, DataKind dataKind = DATA_CONST_REF) :
         Opnd(id, OPND_IMM, dataKind, LOCATION_INVALID), constant(constant) {}
 
     int64     getValue()     { return (int64)constant->getAddress(); }
@@ -226,7 +226,7 @@
 
 class NodeRef : public Opnd {
 public:
-    NodeRef(uint32 id, BbNode *node = NULL) 
+    NodeRef(U_32 id, BbNode *node = NULL) 
     : Opnd(id, OPND_IMM, DATA_NODE_REF, LOCATION_INVALID), node(node) {}
     
     int64    getValue();
@@ -243,7 +243,7 @@
 
 class MethodRef : public Opnd {
 public:
-    MethodRef(uint32 id, MethodDesc *method = NULL) 
+    MethodRef(U_32 id, MethodDesc *method = NULL) 
     : Opnd(id, OPND_IMM, DATA_METHOD_REF, LOCATION_INVALID), method(method) {}
     
     int64       getValue();
@@ -278,21 +278,21 @@
     CompVector  &getComps()                          { return compList; }
     Completer   getComp(uint16 num)                  { return compList[num]; }
     void        addComp(Completer comp_)             { compList.push_back(comp_); }
-    void        setComp(uint32 num, Completer comp_) { compList[num] = comp_; }
+    void        setComp(U_32 num, Completer comp_) { compList[num] = comp_; }
 
     void        addOpnd(Opnd *opnd_)                 { opndList.push_back(opnd_); }
     void        removeLastOpnd()                     { opndList.pop_back(); }
     OpndVector  &getOpnds()                          { return opndList; }
-    void        setOpnd(uint32 num, Opnd *opnd_)     { opndList[num] = opnd_; }
-    Opnd        *getOpnd(uint32 num)                 { return opndList[num]; }
+    void        setOpnd(U_32 num, Opnd *opnd_)     { opndList[num] = opnd_; }
+    Opnd        *getOpnd(U_32 num)                 { return opndList[num]; }
     uint16      getNumDst()                          { return Encoder::getNumDst(instCode); }
     uint16      getNumOpnd()                         { return Encoder::getNumOpnd(instCode); }
 
     char        *getInstMnemonic()                   { return Encoder::getMnemonic(instCode); }
     char        *getCompMnemonic(Completer comp)     { return Encoder::getMnemonic(comp); }
 
-    uint32      getAddr()                            { return addr; }
-    void        setAddr(uint32 addr_)                { addr = addr_; }
+    U_32      getAddr()                            { return addr; }
+    void        setAddr(U_32 addr_)                { addr = addr_; }
     
     bool        isBr();
     bool        isCall();
@@ -303,7 +303,7 @@
     InstCode    instCode;
     CompVector  compList;
     OpndVector  opndList;
-    uint32      addr;       // addr == <bundle's offset in basic block> + <slot's index>
+    U_32      addr;       // addr == <bundle's offset in basic block> + <slot's index>
 };
 
 //========================================================================================//
@@ -338,13 +338,13 @@
 
 class ExceptionEdge : public Edge {
 public:
-                ExceptionEdge(Node*, Node*, double, Type*, uint32);
+                ExceptionEdge(Node*, Node*, double, Type*, U_32);
     Type        *getExceptionType()  { return exceptionType; }
-    uint32      getPriority()        { return priority; }
+    U_32      getPriority()        { return priority; }
 
 protected:
     Type        *exceptionType;
-    uint32      priority;
+    U_32      priority;
 };
 
 //========================================================================================//
@@ -353,7 +353,7 @@
 
 class Node {
 public:
-                Node(MemoryManager&, uint32, uint32, NodeKind = NODE_INVALID);
+                Node(MemoryManager&, U_32, U_32, NodeKind = NODE_INVALID);
 
     void        remove();
     void        addEdge(Edge *edge);
@@ -366,8 +366,8 @@
     void        mergeOutLiveSets(RegOpndSet &resultSet);
 
     uint16      getId()                             { return id; }
-    void        setExecCounter(uint32 execCounter_) { execCounter = execCounter_; }
-    uint32      getExecCounter()                    { return execCounter; }
+    void        setExecCounter(U_32 execCounter_) { execCounter = execCounter_; }
+    U_32      getExecCounter()                    { return execCounter; }
     void        setNodeKind(NodeKind kind_)         { nodeKind = kind_; }
     NodeKind    getNodeKind()                       { return nodeKind; }
     EdgeVector  &getInEdges()                       { return inEdges; }
@@ -383,7 +383,7 @@
     
 protected:
     uint16      id;               // node unique Id
-    uint32      execCounter;      // profile info (how many times the node executes)
+    U_32      execCounter;      // profile info (how many times the node executes)
     NodeKind    nodeKind;         // 
     EdgeVector  inEdges;          // in edges list
     EdgeVector  outEdges;         // out edges list
@@ -398,7 +398,7 @@
 
 class BbNode : public Node {
 public:
-                BbNode(MemoryManager&, uint32, uint32);
+                BbNode(MemoryManager&, U_32, U_32);
     void        addInst(Inst *inst)                 { insts.push_back(inst); }
     void        removeInst(Inst *inst)              { insts.erase(find(insts.begin(),insts.end(),inst)); } 
     InstVector  &getInsts()                         { return insts; }

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfCodeLayouter.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfCodeLayouter.h?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfCodeLayouter.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfCodeLayouter.h Thu May 22 06:33:38 2008
@@ -57,7 +57,7 @@
     void          pushBack(Chain*, Node*);
     void          pushFront(Chain*, Node*);
     void          layoutNodes();
-    uint32        calculateChainWeight(Chain*);
+    U_32        calculateChainWeight(Chain*);
 
     // set branch targets
     void          setBranchTargets();

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfCodeSelector.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfCodeSelector.h?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfCodeSelector.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfCodeSelector.h Thu May 22 06:33:38 2008
@@ -43,9 +43,9 @@
                          IpfMethodCodeSelector(Cfg&, CompilationInterface&);
     MethodDesc           *getMethodDesc();
 
-    void                 genVars(uint32, VarCodeSelector&);
+    void                 genVars(U_32, VarCodeSelector&);
     void                 setMethodDesc(MethodDesc*);
-    void                 genCFG(uint32, CFGCodeSelector&, bool);
+    void                 genCFG(U_32, CFGCodeSelector&, bool);
 //    void                 setProfileInfo(CodeProfiler*) {}
     virtual              ~IpfMethodCodeSelector() {}
 
@@ -65,8 +65,8 @@
 class IpfVarCodeSelector : public VarCodeSelector::Callback {
 public:
                   IpfVarCodeSelector(Cfg&, OpndVector&);
-    uint32        defVar(Type*, bool, bool);
-    void          setManagedPointerBase(uint32, uint32);
+    U_32        defVar(Type*, bool, bool);
+    void          setManagedPointerBase(U_32, U_32);
 
 protected:
     MemoryManager &mm;
@@ -82,19 +82,19 @@
 class IpfCfgCodeSelector : public CFGCodeSelector::Callback {
 public:
                          IpfCfgCodeSelector(Cfg&, NodeVector&, OpndVector&, CompilationInterface&);
-    uint32               genDispatchNode(uint32, uint32, const StlVector<MethodDesc*>&, double);
-    uint32               genBlock(uint32, uint32, BlockKind, BlockCodeSelector&, double);
-    uint32               genUnwindNode(uint32, uint32, double);
-    uint32               genExitNode(uint32, double);
-    void                 genUnconditionalEdge(uint32, uint32, double);
-    void                 genTrueEdge(uint32, uint32, double);
-    void                 genFalseEdge(uint32, uint32, double);
-    void                 genSwitchEdges(uint32, uint32, uint32*, double*, uint32);
-    void                 genExceptionEdge(uint32, uint32, double);
-    void                 genCatchEdge(uint32, uint32, uint32, Type*, double);
-    void                 genExitEdge(uint32, uint32, double);
-    void                 setLoopInfo(uint32, bool, bool, uint32);
-    void                 setPersistentId(uint32, uint32);
+    U_32               genDispatchNode(U_32, U_32, const StlVector<MethodDesc*>&, double);
+    U_32               genBlock(U_32, U_32, BlockKind, BlockCodeSelector&, double);
+    U_32               genUnwindNode(U_32, U_32, double);
+    U_32               genExitNode(U_32, double);
+    void                 genUnconditionalEdge(U_32, U_32, double);
+    void                 genTrueEdge(U_32, U_32, double);
+    void                 genFalseEdge(U_32, U_32, double);
+    void                 genSwitchEdges(U_32, U_32, U_32*, double*, U_32);
+    void                 genExceptionEdge(U_32, U_32, double);
+    void                 genCatchEdge(U_32, U_32, U_32, Type*, double);
+    void                 genExitEdge(U_32, U_32, double);
+    void                 setLoopInfo(U_32, bool, bool, U_32);
+    void                 setPersistentId(U_32, U_32);
     virtual              ~IpfCfgCodeSelector() {}
 
 protected:
@@ -142,19 +142,19 @@
     CG_OpndHandle *shl   (IntegerOp::Types, CG_OpndHandle*, CG_OpndHandle*);
     CG_OpndHandle *shr   (IntegerOp::Types, CG_OpndHandle*, CG_OpndHandle*);
     CG_OpndHandle *shru  (IntegerOp::Types, CG_OpndHandle*, CG_OpndHandle*);
-    CG_OpndHandle *shladd(IntegerOp::Types, CG_OpndHandle*, uint32, CG_OpndHandle*);
+    CG_OpndHandle *shladd(IntegerOp::Types, CG_OpndHandle*, U_32, CG_OpndHandle*);
 
     CG_OpndHandle *convToInt(ConvertToIntOp::Types, bool, bool, ConvertToIntOp::OverflowMod, Type*, CG_OpndHandle*);
     CG_OpndHandle *convToFp(ConvertToFpOp::Types, Type*, CG_OpndHandle*);
 
-    CG_OpndHandle *ldc_i4(int32);
+    CG_OpndHandle *ldc_i4(I_32);
     CG_OpndHandle *ldc_i8(int64);
     CG_OpndHandle *ldc_s(float);
     CG_OpndHandle *ldc_d(double);
     CG_OpndHandle *ldnull(bool);
-    CG_OpndHandle *ldVar(Type*, uint32);
-    void          stVar(CG_OpndHandle*, uint32);
-    CG_OpndHandle *defArg(uint32, Type*);
+    CG_OpndHandle *ldVar(Type*, U_32);
+    void          stVar(CG_OpndHandle*, U_32);
+    CG_OpndHandle *defArg(U_32, Type*);
 
     CG_OpndHandle *cmp   (CompareOp::Operators, CompareOp::Types, CG_OpndHandle*, CG_OpndHandle*, int);
     CG_OpndHandle *czero (CompareZeroOp::Types, CG_OpndHandle*);
@@ -170,11 +170,11 @@
     void          branch(CompareOp::Operators, CompareOp::Types, CG_OpndHandle*, CG_OpndHandle*);
     void          bzero (CompareZeroOp::Types, CG_OpndHandle*);
     void          bnzero(CompareZeroOp::Types, CG_OpndHandle*);
-    void          tableSwitch(CG_OpndHandle*, uint32);       
+    void          tableSwitch(CG_OpndHandle*, U_32);       
 
-    CG_OpndHandle *call(uint32, CG_OpndHandle**, Type*, MethodDesc*);
-    CG_OpndHandle *tau_call(uint32, CG_OpndHandle**, Type*, MethodDesc*, CG_OpndHandle*, CG_OpndHandle*);
-    CG_OpndHandle *tau_calli(uint32,CG_OpndHandle**, Type*, CG_OpndHandle*, CG_OpndHandle*, CG_OpndHandle*);
+    CG_OpndHandle *call(U_32, CG_OpndHandle**, Type*, MethodDesc*);
+    CG_OpndHandle *tau_call(U_32, CG_OpndHandle**, Type*, MethodDesc*, CG_OpndHandle*, CG_OpndHandle*);
+    CG_OpndHandle *tau_calli(U_32,CG_OpndHandle**, Type*, CG_OpndHandle*, CG_OpndHandle*, CG_OpndHandle*);
     void          ret();
     void          ret(CG_OpndHandle*);
 
@@ -185,7 +185,7 @@
     void          throwException(CG_OpndHandle*, bool);
     void          throwException(ObjectType* excType);// generater code to throw noted type exception
     void          throwSystemException(CompilationInterface::SystemExceptionId);
-    void          throwLinkingException(Class_Handle, uint32, uint32);
+    void          throwLinkingException(Class_Handle, U_32, U_32);
     CG_OpndHandle *catchException(Type*);
 
     CG_OpndHandle *tau_checkNull(CG_OpndHandle *, bool);
@@ -202,7 +202,7 @@
 
     void          tau_stInd(CG_OpndHandle*, CG_OpndHandle*, Type::Tag, bool, CG_OpndHandle*, CG_OpndHandle*, CG_OpndHandle*);
     CG_OpndHandle *tau_ldInd(Type*, CG_OpndHandle*, Type::Tag, bool, bool, CG_OpndHandle*, CG_OpndHandle*);
-    CG_OpndHandle *ldString(MethodDesc*, uint32, bool);
+    CG_OpndHandle *ldString(MethodDesc*, U_32, bool);
     CG_OpndHandle *ldLockAddr(CG_OpndHandle*);
     CG_OpndHandle *tau_ldVirtFunAddr(Type*, CG_OpndHandle*, MethodDesc*, CG_OpndHandle*);
     CG_OpndHandle *tau_ldVTableAddr(Type*, CG_OpndHandle*, CG_OpndHandle*);
@@ -214,7 +214,7 @@
     void          initType(Type*);
     CG_OpndHandle *newObj(ObjectType*); 
     CG_OpndHandle *newArray(ArrayType*, CG_OpndHandle*);
-    CG_OpndHandle *newMultiArray(ArrayType*, uint32, CG_OpndHandle**);
+    CG_OpndHandle *newMultiArray(ArrayType*, U_32, CG_OpndHandle**);
     CG_OpndHandle *ldElemBaseAddr(CG_OpndHandle*);
     CG_OpndHandle *addElemIndex(Type *, CG_OpndHandle *, CG_OpndHandle *);
     CG_OpndHandle *tau_arrayLen(Type*, ArrayType*, Type*, CG_OpndHandle*, CG_OpndHandle*, CG_OpndHandle*);
@@ -238,7 +238,7 @@
     CG_OpndHandle *tauEdge()                       { return opndManager->getTau(); }
     CG_OpndHandle *tauUnsafe()                     { return opndManager->getTau(); }
     CG_OpndHandle *tauSafe()                       { return opndManager->getTau(); }
-    CG_OpndHandle *tauAnd(uint32, CG_OpndHandle**) { return opndManager->getTau(); }
+    CG_OpndHandle *tauAnd(U_32, CG_OpndHandle**) { return opndManager->getTau(); }
     void          opndMaybeGlobal(CG_OpndHandle* opnd)            {}
     void          setCurrentPersistentId(PersistentInstructionId) {}
     void          clearCurrentPersistentId()                      {}
@@ -265,23 +265,23 @@
     CG_OpndHandle *addOffset(Type*, CG_OpndHandle*, CG_OpndHandle*)        { NOT_IMPLEMENTED_C("addOffset") }
     CG_OpndHandle *ldElemAddr(CG_OpndHandle*,CG_OpndHandle*)               { NOT_IMPLEMENTED_C("ldElemAddr") }
     CG_OpndHandle *ldStatic(Type*, FieldDesc*, Type::Tag, bool)            { NOT_IMPLEMENTED_C("ldStatic") }
-    CG_OpndHandle *ldVarAddr(uint32)                                       { NOT_IMPLEMENTED_C("ldVarAddr") }
-    CG_OpndHandle *ldToken(Type*, MethodDesc*, uint32)                     { NOT_IMPLEMENTED_C("ldToken") }
+    CG_OpndHandle *ldVarAddr(U_32)                                       { NOT_IMPLEMENTED_C("ldVarAddr") }
+    CG_OpndHandle *ldToken(Type*, MethodDesc*, U_32)                     { NOT_IMPLEMENTED_C("ldToken") }
     CG_OpndHandle *tau_cast(ObjectType*, CG_OpndHandle*, CG_OpndHandle*)   { NOT_IMPLEMENTED_C("tau_cast") }
     CG_OpndHandle *tau_asType(ObjectType*, CG_OpndHandle*, CG_OpndHandle*) { NOT_IMPLEMENTED_C("tau_asType") }
     CG_OpndHandle *box(ObjectType*, CG_OpndHandle*)                        { NOT_IMPLEMENTED_C("box") }
     CG_OpndHandle *unbox(Type*, CG_OpndHandle*)                            { NOT_IMPLEMENTED_C("unbox") }
     CG_OpndHandle *ldValueObj(Type*, CG_OpndHandle*)                       { NOT_IMPLEMENTED_C("ldValueObj") }
     CG_OpndHandle *tau_ckfinite(CG_OpndHandle*)                            { NOT_IMPLEMENTED_C("tau_ckfinite") }
-    CG_OpndHandle *callhelper(uint32, CG_OpndHandle**, Type*, JitHelperCallOp::Id) { NOT_IMPLEMENTED_C("callhelper") }
-    CG_OpndHandle *tau_callvirt(uint32, CG_OpndHandle**, Type*, MethodDesc*, CG_OpndHandle*, CG_OpndHandle*)  { NOT_IMPLEMENTED_C("tau_callvirt") }
+    CG_OpndHandle *callhelper(U_32, CG_OpndHandle**, Type*, JitHelperCallOp::Id) { NOT_IMPLEMENTED_C("callhelper") }
+    CG_OpndHandle *tau_callvirt(U_32, CG_OpndHandle**, Type*, MethodDesc*, CG_OpndHandle*, CG_OpndHandle*)  { NOT_IMPLEMENTED_C("tau_callvirt") }
     CG_OpndHandle *select(CompareOp::Types, CG_OpndHandle*, CG_OpndHandle*, CG_OpndHandle*) { NOT_IMPLEMENTED_C("select") }
     CG_OpndHandle *cmp3(CompareOp::Operators,CompareOp::Types, CG_OpndHandle*, CG_OpndHandle*) { NOT_IMPLEMENTED_C("cmp3") }
     CG_OpndHandle *tau_optimisticBalancedMonitorEnter(CG_OpndHandle*, CG_OpndHandle*, CG_OpndHandle*) { NOT_IMPLEMENTED_C("tau_optimisticBalancedMonitorEnter") }
     CG_OpndHandle *addOffsetPlusHeapbase(Type*, CG_OpndHandle*, CG_OpndHandle*) { NOT_IMPLEMENTED_C("addOffsetPlusHeapbase") }
     CG_OpndHandle *tau_ldField(Type*, CG_OpndHandle*, Type::Tag, FieldDesc*, bool, CG_OpndHandle*, CG_OpndHandle*) { NOT_IMPLEMENTED_C("tau_ldField") }
     CG_OpndHandle *tau_ldElem(Type*, CG_OpndHandle*, CG_OpndHandle*, bool, CG_OpndHandle*, CG_OpndHandle*) { NOT_IMPLEMENTED_C("tau_ldElem") }
-    void          incCounter(Type*, uint32)                               { NOT_IMPLEMENTED_V("incCounter") }
+    void          incCounter(Type*, U_32)                               { NOT_IMPLEMENTED_V("incCounter") }
     void          incRecursionCount(CG_OpndHandle*, CG_OpndHandle*)       { NOT_IMPLEMENTED_V("incRecursionCount") }
     void          monitorEnterFence(CG_OpndHandle*)                       { NOT_IMPLEMENTED_V("monitorEnterFence") }
     void          monitorExitFence(CG_OpndHandle*)                        { NOT_IMPLEMENTED_V("monitorExitFence") }
@@ -290,7 +290,7 @@
     void          copyValueObj(Type*, CG_OpndHandle*, CG_OpndHandle*)     { NOT_IMPLEMENTED_V("copyValueObj") }
     void          prefetch(CG_OpndHandle*)                                { NOT_IMPLEMENTED_V("prefetch") }
     void          jump()                                                  { NOT_IMPLEMENTED_V("jump") }
-    void          throwLazyException(uint32, CG_OpndHandle**, MethodDesc*) { NOT_IMPLEMENTED_V("throwLazyException") }
+    void          throwLazyException(U_32, CG_OpndHandle**, MethodDesc*) { NOT_IMPLEMENTED_V("throwLazyException") }
     void          tau_stStatic(CG_OpndHandle*, FieldDesc*, Type::Tag, bool, CG_OpndHandle*) { NOT_IMPLEMENTED_V("tau_stStatic") } 
     void          tau_stField(CG_OpndHandle*, CG_OpndHandle*, Type::Tag, FieldDesc*, bool, CG_OpndHandle*, CG_OpndHandle*, CG_OpndHandle*) { NOT_IMPLEMENTED_V("tau_stField") }
     void          tau_stElem(CG_OpndHandle*, CG_OpndHandle*, CG_OpndHandle*, bool, CG_OpndHandle*, CG_OpndHandle*, CG_OpndHandle*) { NOT_IMPLEMENTED_V("tau_stElem") }
@@ -300,7 +300,7 @@
     // TRANSITION
     //---------------------------------------------------------------------------//
 
-    CG_OpndHandle* callvmhelper(uint32, CG_OpndHandle**, Type*
+    CG_OpndHandle* callvmhelper(U_32, CG_OpndHandle**, Type*
                         , VM_RT_SUPPORT) { NOT_IMPLEMENTED_C("unbox") }
 
     CG_OpndHandle* convUPtrToObject(ObjectType*, CG_OpndHandle*)              { NOT_IMPLEMENTED_C("convUPtrToObject") }
@@ -352,9 +352,9 @@
                   CG_OpndHandle *op4=NULL, CG_OpndHandle *op5=NULL, CG_OpndHandle *op6=NULL);
         
     // CG helper methods
-    void      directCall(uint32, Opnd**, RegOpnd*, Opnd*, RegOpnd*, Completer=CMPLT_WH_SPTK);
-    void      indirectCall(uint32, Opnd**, RegOpnd*, RegOpnd*, RegOpnd*, Completer=CMPLT_WH_SPTK);
-    void      makeCallArgs(uint32, Opnd**, Inst*, RegOpnd*);
+    void      directCall(U_32, Opnd**, RegOpnd*, Opnd*, RegOpnd*, Completer=CMPLT_WH_SPTK);
+    void      indirectCall(U_32, Opnd**, RegOpnd*, RegOpnd*, RegOpnd*, Completer=CMPLT_WH_SPTK);
+    void      makeCallArgs(U_32, Opnd**, Inst*, RegOpnd*);
     RegOpnd   *makeConvOpnd(RegOpnd*);
     void      makeRetVal(RegOpnd*, RegOpnd*, RegOpnd*);
 

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfEmitter.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfEmitter.h?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfEmitter.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfEmitter.h Thu May 22 06:33:38 2008
@@ -95,9 +95,9 @@
  * tmpl  = template field encoding
  */
 struct BundleDescription {
-    uint32 slots;
-    uint32 stops;
-    uint32 tmpl;
+    U_32 slots;
+    U_32 stops;
+    U_32 tmpl;
 };
 
 //============================================================================//
@@ -127,12 +127,12 @@
 //============================================================================//
 class Bundle {
   public:
-    Bundle(Cfg& cfg, uint32 tmpl, Inst *, Inst *, Inst *);
+    Bundle(Cfg& cfg, U_32 tmpl, Inst *, Inst *, Inst *);
     
     Inst   * getSlot(int si) { return slot[si]; };
-    uint32   getTmplIndex() { return indxtmpl; };
-    uint32   getTmpl() { return BundleDesc[indxtmpl].tmpl; };
-    bool     hasStop() { uint32 t = getTmpl(); 
+    U_32   getTmplIndex() { return indxtmpl; };
+    U_32   getTmpl() { return BundleDesc[indxtmpl].tmpl; };
+    bool     hasStop() { U_32 t = getTmpl(); 
                          if (t%2==1 || t==0x2 || t==0xa) return true; return false; };
     void     emitBundleGeneral(void *);
     void     emitBundleExtended(void *);
@@ -145,7 +145,7 @@
     static const BundleDescription BundleDesc[TEMPLATES_COUNT];
 
   protected:
-    uint32  indxtmpl;
+    U_32  indxtmpl;
     Inst   *slot[IPF_SLOTS_COUNT];
 };
 
@@ -157,7 +157,7 @@
         branches=new(mm) vector<int>; 
     };
     
-    void addBundle(uint32 itmpl, Inst *i0, Inst *i1, Inst *i2) {
+    void addBundle(U_32 itmpl, Inst *i0, Inst *i1, Inst *i2) {
         push_back(new(mm) Bundle(cfg, itmpl, i0, i1, i2));
         if(Encoder::isBranchInst(i0) || Encoder::isBranchInst(i1) || Encoder::isBranchInst(i2)) {
             branches->push_back(size() - 1);



Mime
View raw message