harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From mcfi...@apache.org
Subject svn commit: r659108 [14/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/ jit...
Date Thu, 22 May 2008 13:34:09 GMT
Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/simplifier.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/simplifier.h?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/simplifier.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/simplifier.h Thu May 22 06:33:38 2008
@@ -83,34 +83,34 @@
     // and returns True if branch can be folded away.
     bool canFoldBranch(Type::Tag, ComparisonModifier, Opnd* src1, Opnd* src2,bool& isTaken);
     bool canFoldBranch(Type::Tag, ComparisonModifier, Opnd* src, bool& isTaken);
-    bool simplifySwitch(uint32 numLabels, LabelInst* label[], LabelInst* defaultLabel, Opnd* src);
+    bool simplifySwitch(U_32 numLabels, LabelInst* label[], LabelInst* defaultLabel, Opnd* src);
 
     Opnd* simplifyTauVirtualCall(MethodDesc* methodDesc,
                                  Type* returnType,
                                  Opnd* tauNullCheckedFirstArg,
                                  Opnd* tauTypesChecked,
-                                 uint32 numArgs,
+                                 U_32 numArgs,
                                  Opnd* args[]);
 
     Inst* simplifyIndirectCallInst(Opnd* funPtr,
                                    Type* returnType,
                                    Opnd* tauNullCheckedFirstArg,
                                    Opnd* tauTypesChecked,
-                                   uint32 numArgs,
+                                   U_32 numArgs,
                                    Opnd** args);
 
     Inst* simplifyIndirectMemoryCallInst(Opnd* funPtr,
                                          Type* returnType,
                                          Opnd* tauNullCheckedFirstArg,
                                          Opnd* tauTypesChecked,
-                                         uint32 numArgs,
+                                         U_32 numArgs,
                                          Opnd** args);
 
     Inst* simplifyJitHelperCall(JitHelperCallInst* inst);
 
     // loads
     Opnd* simplifyLdRef(Modifier mod, Type *dstType, 
-                        uint32 token,
+                        U_32 token,
                         MethodDesc* enclosingMethod);
     Opnd* simplifyTauLdInd(Modifier mod, Type *dstType, 
                            Type::Tag type,
@@ -226,10 +226,10 @@
                                 Type* returnType,
                                 Opnd* tauNullCheckedFirstArg,
                                 Opnd* tauTypesChecked,
-                                uint32 numArgs,
+                                U_32 numArgs,
                                 Opnd* args[]) = 0;
     // load, store & move
-    virtual Inst* genLdConstant(int32 val) = 0;
+    virtual Inst* genLdConstant(I_32 val) = 0;
     virtual Inst* genLdConstant(int64 val) = 0;
     virtual Inst* genLdConstant(float val) = 0;
     virtual Inst* genLdConstant(double val) = 0;
@@ -237,7 +237,7 @@
     virtual Inst* genTauLdInd(Modifier mod, Type *dstType, Type::Tag type, Opnd *ptr, 
                               Opnd *tauNonNullBase, Opnd *tauAddressInRange) = 0;
     virtual Inst* genLdRef(Modifier mod, Type *dstType,
-                           uint32 token, MethodDesc *enclosingMethod) = 0;
+                           U_32 token, MethodDesc *enclosingMethod) = 0;
     virtual Inst* genLdFunAddrSlot(MethodDesc*) = 0;
     virtual Inst* genGetVTableAddr(ObjectType* type) = 0;
     // compressed references
@@ -264,10 +264,10 @@
     virtual void genThrowSystemException(CompilationInterface::SystemExceptionId) = 0;
 
     virtual void  foldBranch(BranchInst* branchInst, bool isTaken) = 0;
-    virtual void  foldSwitch(SwitchInst* switchInst, uint32 index) = 0;
+    virtual void  foldSwitch(SwitchInst* switchInst, U_32 index) = 0;
     virtual void  eliminateCheck(Inst* checkInst, bool alwaysThrows) = 0;
 
-    Opnd *planMul32(int32 multiplier, Opnd *opnd);
+    Opnd *planMul32(I_32 multiplier, Opnd *opnd);
     Opnd *planMul64(int64 multiplier, Opnd *opnd);
 public:
     //-------------------------------------------------------------------------
@@ -1051,7 +1051,7 @@
                               Opnd* &newSrc1, Opnd* &newSrc2);
 
     friend struct OpndDepthCompare;
-    uint32 getDepth(Opnd *src);
+    U_32 getDepth(Opnd *src);
 
 protected:
     bool            isLate;
@@ -1075,7 +1075,7 @@
     SimplifierWithInstFactory(IRManager&,bool latePass=false,
                   Reassociate *reassociate0=0);
     virtual Inst* optimizeInst(Inst* inst);
-    uint32 simplifyControlFlowGraph();
+    U_32 simplifyControlFlowGraph();
 protected:
     void insertInst(Inst* inst);
     void insertInstInHeader(Inst* inst);
@@ -1121,10 +1121,10 @@
                                 Type* returnType,
                                 Opnd* tauNullCheckedFirstArg,
                                 Opnd* typesChecked,
-                                uint32 numArgs,
+                                U_32 numArgs,
                                 Opnd* args[]);
 
-    virtual Inst* genLdConstant(int32 val);
+    virtual Inst* genLdConstant(I_32 val);
     virtual Inst* genLdConstant(int64 val);
     virtual Inst* genLdConstant(float val);
     virtual Inst* genLdConstant(double val);
@@ -1133,7 +1133,7 @@
     virtual Inst* genTauLdInd(Modifier mod, Type *dstType, Type::Tag type, Opnd *ptr,
                               Opnd *tauNonNullBase, Opnd *tauAddressInRange);
     virtual Inst* genLdRef(Modifier mod, Type *dstType,
-                           uint32 token, MethodDesc *enclosingMethod);
+                           U_32 token, MethodDesc *enclosingMethod);
 
     virtual Inst* genLdFunAddrSlot(MethodDesc*);
     virtual Inst* genGetVTableAddr(ObjectType* type);
@@ -1160,7 +1160,7 @@
     virtual void genThrowSystemException(CompilationInterface::SystemExceptionId);
 
     virtual void  foldBranch(BranchInst* br, bool isTaken);
-    virtual void  foldSwitch(SwitchInst* switchInst, uint32 index);
+    virtual void  foldSwitch(SwitchInst* switchInst, U_32 index);
     virtual void  eliminateCheck(Inst* checkInst, bool alwaysThrows);
 private:
     Inst*           nextInst;

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/simplifytaus.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/simplifytaus.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/simplifytaus.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/simplifytaus.cpp Thu May 22 06:33:38 2008
@@ -1016,7 +1016,7 @@
         {
             Opnd *opnd = inst->getDst();
 
-            for (uint32 exactTypeCount = 0; exactTypeCount < 2; ++exactTypeCount) {
+            for (U_32 exactTypeCount = 0; exactTypeCount < 2; ++exactTypeCount) {
                 bool exactType = (exactTypeCount != 0);
             
                 StlVectorSet<Type *> *reduceTypes = shouldReduceSsaOpnd(opnd, exactType);
@@ -1099,7 +1099,7 @@
         {
             Opnd *opnd = inst->getDst();
 
-            for (uint32 exactTypeCount = 0; exactTypeCount < 2; ++exactTypeCount) {
+            for (U_32 exactTypeCount = 0; exactTypeCount < 2; ++exactTypeCount) {
                 bool exactType = (exactTypeCount != 0);
 
                 StlVectorSet<Type *> *reduceTypes = shouldReduceSsaOpnd(opnd, exactType);
@@ -1134,9 +1134,9 @@
                         
                         Opnd *newDst = reduceSsaOpnd(inst->getDst(), baseTauOpnd, type, exactType);
                         if (!newDst->getInst()){
-                            uint32 numOpnds = inst->getNumSrcOperands();
+                            U_32 numOpnds = inst->getNumSrcOperands();
                             Opnd** newOpnds = new (mm) Opnd*[numOpnds];
-                            for (uint32 i=0; i<numOpnds; ++i) {
+                            for (U_32 i=0; i<numOpnds; ++i) {
                                 Opnd *oldOpnd = inst->getSrc(i);
                                 Opnd *newOpnd = reduceSsaOpnd(oldOpnd, baseTauOpnd, type, exactType);
                                 newOpnds[i] = newOpnd;
@@ -1178,8 +1178,8 @@
         inst->unlink();
         return;
     }
-    uint32 numSrcs = inst->getNumSrcOperands();
-    for (uint32 i=0; i<numSrcs; ++i) {
+    U_32 numSrcs = inst->getNumSrcOperands();
+    for (U_32 i=0; i<numSrcs; ++i) {
         Opnd *srci = inst->getSrc(i);
         Opnd *found = lookupCopyMapping(srci);
         if (found) {

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/ssa/SSA.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/ssa/SSA.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/ssa/SSA.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/ssa/SSA.cpp Thu May 22 06:33:38 2008
@@ -93,7 +93,7 @@
 class RenameStack : public SparseScopedMap<Opnd *, SsaVarOpnd *> {
 public:
     typedef SparseScopedMap<Opnd *, SsaVarOpnd *> BaseMap;
-    RenameStack(MemoryManager& mm, uint32 n, const OptimizerFlags& optimizerFlags)
+    RenameStack(MemoryManager& mm, U_32 n, const OptimizerFlags& optimizerFlags)
         : BaseMap(n, mm,
                   optimizerFlags.hash_init_factor,
                   optimizerFlags.hash_resize_factor,
@@ -159,8 +159,8 @@
 void SSABuilder::addPhiSrc(PhiInst* i, 
                            SsaVarOpnd* src) {
     assert(i->isPhi());
-    uint32 numOpnds = i->getNumSrcOperands();
-    for (uint32 j = 0; j < numOpnds; j++) {
+    U_32 numOpnds = i->getNumSrcOperands();
+    for (U_32 j = 0; j < numOpnds; j++) {
         // no duplicate SSA opnd
         if (i->getSrc(j) == src) 
             return;
@@ -173,13 +173,13 @@
     MemoryManager &localMemManager;
     SSABuilder *ssaBuilder;
     RenameStack *rs;
-    uint32 n;
+    U_32 n;
     const StlVectorSet<VarOpnd *> *whatVars;
     const OptimizerFlags& optimizerFlags;
 public:
     SsaRenameWalker(SSABuilder *builder0,
                     MemoryManager &localMM,
-                    uint32 num, const OptimizerFlags& _optimizerFlags)
+                    U_32 num, const OptimizerFlags& _optimizerFlags)
         : localMemManager(localMM),
           ssaBuilder(builder0),
           rs(0),
@@ -225,8 +225,8 @@
     for (Inst* i = head->getNextInst(); i != NULL; i = i->getNextInst()) {
         if (!i->isPhi()) {
             // replace src with ssa opnd
-            uint32 nSrcs = i->getNumSrcOperands();
-            for (uint32 j = 0; j < nSrcs; j++) {
+            U_32 nSrcs = i->getNumSrcOperands();
+            for (U_32 j = 0; j < nSrcs; j++) {
                 Opnd *srcj = i->getSrc(j);
                 VarOpnd *srcjVar = (srcj->isSsaVarOpnd()
                                     ? srcj->asSsaVarOpnd()->getVar()
@@ -326,7 +326,7 @@
 #ifdef DEBUG_SSA
                 if (Log::isEnabled()) {
                     cout << "redge";
-//                    cout << (int32)j;
+//                    cout << (I_32)j;
                     cout << " with ssa "; ssa->print(cout); cout << ::std::endl;
                 }
 #endif
@@ -410,7 +410,7 @@
     // rename
     SsaRenameWalker renameWalker(this, ssaMemManager,
                                  optimizerFlags.hash_node_var_factor *
-                                 (uint32) fg->getNodes().size(), optimizerFlags);
+                                 (U_32) fg->getNodes().size(), optimizerFlags);
 
     DomTreeWalk<true, // pre-order
         SsaRenameWalker>(frontier.getDominator(), renameWalker, ssaMemManager);  
@@ -522,8 +522,8 @@
                 continue;
         }
         bool changed=false;
-        uint32 numSrcs = inst->getNumSrcOperands();
-        for (uint32 i=0; i<numSrcs; ++i) {
+        U_32 numSrcs = inst->getNumSrcOperands();
+        for (U_32 i=0; i<numSrcs; ++i) {
             Opnd *thisOpnd = inst->getSrc(i);
 
             if (!(removedVars && removedVars->has(thisOpnd))) {
@@ -651,7 +651,7 @@
         PhiInst *phiInst = phi->asPhiInst();
         assert(phiInst);
 #endif
-        uint32 nSrcs = phi->getNumSrcOperands();
+        U_32 nSrcs = phi->getNumSrcOperands();
         if (nSrcs <= 1) {
             // phi must be trivial
 #ifdef DEBUG_SSA
@@ -727,7 +727,7 @@
         PhiInst *phiInst = phi->asPhiInst();
         assert(phiInst);
 #endif
-        uint32 nSrcs = phi->getNumSrcOperands();
+        U_32 nSrcs = phi->getNumSrcOperands();
         if (nSrcs <= 1) {
             // phi must be trivial
 #ifdef DEBUG_SSA
@@ -797,7 +797,7 @@
         // do renaming to propagate vars to Phis which had vars removed
         SsaRenameWalker renameWalker(this, localMM,
                                      optimizerFlags.hash_node_var_factor *
-                                     (uint32) fg->getNodes().size(), optimizerFlags);
+                                     (U_32) fg->getNodes().size(), optimizerFlags);
 
         // oldChangedVarsSet will be the set for looking up Vars to consider
         StlVectorSet<VarOpnd *> oldChangedVarsSet(localMM);
@@ -863,7 +863,7 @@
         
         SsaRenameWalker renameWalker(this, localMM,
                                      optimizerFlags.hash_node_var_factor *
-                                     (int32) fg->getNodes().size(), optimizerFlags);
+                                     (I_32) fg->getNodes().size(), optimizerFlags);
         DomTreeWalk<true, // pre-order
             SsaRenameWalker>(frontier.getDominator(), renameWalker,
                              localMM);
@@ -951,8 +951,8 @@
     };
 
     void applyToInst(Inst *inst) {
-        uint32 numSrcs = inst->getNumSrcOperands();
-        for (uint32 i=0; i<numSrcs; ++i) {
+        U_32 numSrcs = inst->getNumSrcOperands();
+        for (U_32 i=0; i<numSrcs; ++i) {
             Opnd *thisOpnd = inst->getSrc(i);
             recordOpnd(thisOpnd);
         }
@@ -1008,8 +1008,8 @@
                 }
             }
         }
-        uint32 numSrcs = inst->getNumSrcOperands();
-        for (uint32 i=0; i<numSrcs; ++i) {
+        U_32 numSrcs = inst->getNumSrcOperands();
+        for (U_32 i=0; i<numSrcs; ++i) {
             Opnd *thisOpnd = inst->getSrc(i);
             VarOpnd *varOpnd = needToDeSsaOpnd(thisOpnd);
             if (varOpnd) {
@@ -1102,7 +1102,7 @@
             if (inst->isPhi()) {
                 inst->unlink();
             } else {
-                for (uint32 i = 0; i < inst->getNumSrcOperands(); i++) {
+                for (U_32 i = 0; i < inst->getNumSrcOperands(); i++) {
                     Opnd *opnd = inst->getSrc(i);
                     if (opnd->isSsaVarOpnd()) {
                         SsaVarOpnd *ssa = (SsaVarOpnd *)opnd;
@@ -1138,7 +1138,7 @@
 // rename vars to make un-overlapping live ranges of a variable into
 // different variables.
 void SSABuilder::splitSsaWebs(ControlFlowGraph* fg,OpndManager& opndManager) {
-    uint32 numSsaOpnds = opndManager.getNumSsaOpnds();
+    U_32 numSsaOpnds = opndManager.getNumSsaOpnds();
     MemoryManager localMM("SSABuilder::splitSsaWebs::memManager");
     SsaVarClique *cliques = new (localMM) SsaVarClique[numSsaOpnds];
     
@@ -1153,11 +1153,11 @@
                 // do something
                 VarOpnd *var0 = 0;
                 SsaVarClique *clique = 0;
-                for (uint32 i = 0; i < inst->getNumSrcOperands(); i++) {
+                for (U_32 i = 0; i < inst->getNumSrcOperands(); i++) {
                     Opnd *opnd = inst->getSrc(i);
                     if (opnd->isSsaVarOpnd()) {
                         SsaVarOpnd *ssa = (SsaVarOpnd *)opnd;
-                        uint32 id = ssa->getId();
+                        U_32 id = ssa->getId();
                         if (var0) {
                             assert(ssa->getVar()==var0);
                             cliques[id].link(clique);
@@ -1171,7 +1171,7 @@
                 if (dst->isSsaVarOpnd()) {
                     SsaVarOpnd *ssa = (SsaVarOpnd *)dst;
                     ssa->getVar();
-                    uint32 id = ssa->getId();
+                    U_32 id = ssa->getId();
                     if (var0) {
                         assert(ssa->getVar()==var0);
                         cliques[id].link(clique);
@@ -1184,9 +1184,9 @@
             inst = nextInst;
         }
     }
-    uint32 numvars = opndManager.getNumVarOpnds();
+    U_32 numvars = opndManager.getNumVarOpnds();
     bool *used = new (localMM) bool[numvars];
-    for (uint32 i=0; i<numvars; i++) {
+    for (U_32 i=0; i<numvars; i++) {
         used[i] = false;
     }
 
@@ -1196,17 +1196,17 @@
         for (Inst *inst = headInst->getNextInst(); inst != NULL; ) {
             Inst *nextInst = inst->getNextInst();
 
-            for (uint32 i = 0; i < inst->getNumSrcOperands(); i++) {
+            for (U_32 i = 0; i < inst->getNumSrcOperands(); i++) {
                 Opnd *opnd = inst->getSrc(i);
                 if (opnd->isSsaVarOpnd()) {
                     SsaVarOpnd *ssa = (SsaVarOpnd *)opnd;
                     VarOpnd *var = ssa->getVar();
-                    uint32 id=ssa->getId();
+                    U_32 id=ssa->getId();
                     SsaVarClique *clique = &cliques[id];
                     clique = clique->getRoot();
                     VarOpnd *cvar = clique->var;
                     if (cvar == 0) {
-                        uint32 varId = var->getId();
+                        U_32 varId = var->getId();
                         if (used[varId]) {
                             cvar = opndManager.createVarOpnd(var->getType(),
                                                              var->isPinned());
@@ -1225,13 +1225,13 @@
             if (dst->isSsaVarOpnd()) {
                 SsaVarOpnd *ssa = (SsaVarOpnd *)dst;
                 VarOpnd *var = ssa->getVar();
-                uint32 id=ssa->getId();
+                U_32 id=ssa->getId();
 
                 SsaVarClique *clique = &cliques[id];
                 clique = clique->getRoot();
                 VarOpnd *cvar = clique->var;
                 if (cvar == 0) {
-                    uint32 varId = var->getId();
+                    U_32 varId = var->getId();
                     if (used[varId]) {
                         cvar = opndManager.createVarOpnd(var->getType(),
                                                          var->isPinned());

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/ssa/SSA.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/ssa/SSA.h?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/ssa/SSA.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/ssa/SSA.h Thu May 22 06:33:38 2008
@@ -45,7 +45,7 @@
 // 
 class VarDefSites {
 public:
-    VarDefSites(MemoryManager& m, uint32 max) 
+    VarDefSites(MemoryManager& m, U_32 max) 
     : stack(m), alreadyRecorded(m, max), insertedPhi(m, max) {}
     void addDefSite(Node* node) {
         // avoid pushing the same node twice onto the stack
@@ -76,7 +76,7 @@
 //
 class DefSites {
 public:
-    DefSites(MemoryManager& m, uint32 n) : table(m,32), mm(m), numNodes(n) {}
+    DefSites(MemoryManager& m, U_32 n) : table(m,32), mm(m), numNodes(n) {}
     void addVarDefSite(VarOpnd* var, Node* node) {
         if (var == NULL) return;
 
@@ -91,7 +91,7 @@
 private:
      PtrHashTable<VarDefSites> table;
      MemoryManager&  mm;
-     uint32        numNodes;
+     U_32        numNodes;
 };
 
 class RenameStack;

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/syncopt.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/syncopt.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/syncopt.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/syncopt.cpp Thu May 22 06:33:38 2008
@@ -479,7 +479,7 @@
     }
 
     // must be high-priority catch node
-    uint32 order = catchLabelInst->getOrder();
+    U_32 order = catchLabelInst->getOrder();
     if (order != 0) {
         if (EXTRA_DEBUGGING && Log::isEnabled()) {
             Log::out() << "    case 3" << ::std::endl;
@@ -579,11 +579,11 @@
 
 // synchronization inlining
 struct ObjectSynchronizationInfo {
-    uint32 threadIdReg;      // the register number that holds id of the current thread
-    uint32 syncHeaderOffset; // offset in bytes of the sync header from the start of the object   
-    uint32 syncHeaderWidth;  // width in bytes of the sync header
-    uint32 lockOwnerOffset;  // offset in bytes of the lock owner field from the start of the object
-    uint32 lockOwnerWidth;   // width in bytes of the lock owner field in the sync header
+    U_32 threadIdReg;      // the register number that holds id of the current thread
+    U_32 syncHeaderOffset; // offset in bytes of the sync header from the start of the object   
+    U_32 syncHeaderWidth;  // width in bytes of the sync header
+    U_32 lockOwnerOffset;  // offset in bytes of the lock owner field from the start of the object
+    U_32 lockOwnerWidth;   // width in bytes of the lock owner field in the sync header
     bool   jitClearsCcv;     // whether the JIT needs to clear ar.ccv
 };
 
@@ -660,7 +660,7 @@
         }
     }
 
-    uint32 lockWidth = 2;
+    U_32 lockWidth = 2;
     
     ObjectSynchronizationInfo syncInfo;
     if (mayInlineObjectSynchronization(syncInfo)) 
@@ -778,8 +778,8 @@
 public:
     Opnd *opnd;
     VarOpnd *oldValueVar;
-    uint32 id;
-    static uint32 counter;
+    U_32 id;
+    static U_32 counter;
 
     SyncClique() : UnionFind(), opnd(0), oldValueVar(0), id(++counter) {};
     SyncClique(Opnd *opnd0) : UnionFind(), opnd(opnd0), oldValueVar(0), id(++counter) {};
@@ -799,14 +799,14 @@
     };
 };
 
-uint32 SyncClique::counter = 0;
+U_32 SyncClique::counter = 0;
 #define SYNC_STACK_TOP_DEPTH 20
 
 class SyncOptDfValue {
     enum State { Top, Normal, Bottom } state;
-    uint32 depth; 
+    U_32 depth; 
 public:
-    uint32 getDepth() { return depth; };
+    U_32 getDepth() { return depth; };
     SyncOptDfValue()
         : state(Top), depth(SYNC_STACK_TOP_DEPTH) { };
     SyncOptDfValue(int)
@@ -1004,7 +1004,7 @@
     MemoryManager &mem;
 
     StlVector<SyncClique *> *currentStack;
-    uint32 currentDepth;
+    U_32 currentDepth;
     SyncClique *bottomClique;
 
     StlMap<Inst *, SyncClique *> &monitorCliques;
@@ -1013,7 +1013,7 @@
     StlMap<Inst *, StlVectorSet<SyncClique *> *> &needRecCount;
 public:
     StlVector<SyncClique *> *getStack() { return currentStack; };
-    uint32 getDepth() { return currentDepth; };
+    U_32 getDepth() { return currentDepth; };
     BuildSyncCliquesWalker(MemoryManager &mm,
                            SyncClique *bottomClique0,
                            StlMap<Inst *, SyncClique *> &monitorCliques0,
@@ -1029,7 +1029,7 @@
           needRecCount(needRecCount0)
     {};
     void startNode(StlVector<SyncClique *> *entryStack,
-                   uint32 entryDepth)
+                   U_32 entryDepth)
     {
         currentStack = entryStack;
         currentDepth = entryDepth;
@@ -1084,14 +1084,14 @@
                 assert(currentStack);
                 if (use_IncRecCount) {
                     StlVectorSet<SyncClique *> *openSet = new (mem) StlVectorSet<SyncClique *>(mem);
-                    for (uint32 j=0; j < currentDepth; ++j) {
+                    for (U_32 j=0; j < currentDepth; ++j) {
                         openSet->insert((*currentStack)[j]);
                     }
                     needRecCount[i] = openSet;
                     // leaving a balanced area, cancel all monitors.
                     currentDepth = 0;
                 } else {
-                    for (uint32 i=0; i<currentDepth; ++i) {
+                    for (U_32 i=0; i<currentDepth; ++i) {
                         // invalidate all open monitors
                         if (Log::isEnabled()) {
                             Log::out() << " linking01 ";
@@ -1177,7 +1177,7 @@
                 assert(currentStack);
                 // record cliques which depend on this opnd matching
                 StlVectorSet<SyncClique *> *openSet = new (mem) StlVectorSet<SyncClique *>(mem);
-                for (uint32 j=0; j < currentDepth; ++j) {
+                for (U_32 j=0; j < currentDepth; ++j) {
                     openSet->insert((*currentStack)[j]);
                 }
                 needRecCount[monitorExit] = openSet;
@@ -1258,7 +1258,7 @@
 // The result is the total count of stack elements in entrySolution and exitSolution,
 //    which are also initialized here
 
-uint32 SyncOpt::findBalancedExits_Stage1(bool optimistic, bool use_IncRecCount, uint32 numNodes,
+U_32 SyncOpt::findBalancedExits_Stage1(bool optimistic, bool use_IncRecCount, U_32 numNodes,
                                          SyncOptDfValue *&entrySolution, SyncOptDfValue *&exitSolution)
 {
     SyncOptForwardInstance findBalancedExits(mm, optimistic, use_IncRecCount);
@@ -1267,9 +1267,9 @@
     solve<SyncOptDfValue>(&fg, findBalancedExits, true, // forwards
                           mm, 
                           entrySolution, exitSolution, true); // ignore exception edges
-    uint32 numCliques = 0;
+    U_32 numCliques = 0;
     {
-        for (uint32 i = 0; i<numNodes; i++) {
+        for (U_32 i = 0; i<numNodes; i++) {
             numCliques += entrySolution[i].getDepth();
             numCliques += exitSolution[i].getDepth();
         }
@@ -1277,15 +1277,15 @@
     return numCliques;
 }
 
-void SyncOpt::linkStacks(uint32 depth1, SyncClique *stack1,
-                         uint32 depth2, SyncClique *stack2,
+void SyncOpt::linkStacks(U_32 depth1, SyncClique *stack1,
+                         U_32 depth2, SyncClique *stack2,
                          SyncClique *bottomClique)
 {
     // link 
     //   stack1[depth1-1],..,stack1[0],bot,..
     //   stack2[depth2-1],..,stack2[0],bot,..
-    uint32 mindepth = ::std::min(depth1, depth2);
-    uint32 i = 0;
+    U_32 mindepth = ::std::min(depth1, depth2);
+    U_32 i = 0;
     for ( ; i < mindepth; ++i) {
         if (Log::isEnabled()) {
             Log::out() << " linking02 ";
@@ -1321,9 +1321,9 @@
 // starting with cliques in inStack[0..depthIn-1], walk node with walker
 // and union result with outStack[0..depthOut-1].  stackspace is available for scratch.
 void SyncOpt::findBalancedExits_Stage2a(Node *node,
-                                        uint32 depthIn,
+                                        U_32 depthIn,
                                         SyncClique *inStack,
-                                        uint32 depthOut,
+                                        U_32 depthOut,
                                         SyncClique *outStack,
                                         BuildSyncCliquesWalker &walker,
                                         StlVector<SyncClique *> &stackspace, // scratch area
@@ -1331,7 +1331,7 @@
 {
     if (depthIn > 0) {
         assert(depthIn <= SYNC_STACK_TOP_DEPTH);
-        for (uint32 i=0; i<depthIn; i++) {
+        for (U_32 i=0; i<depthIn; i++) {
             stackspace[i] = &inStack[i];
         }
     }
@@ -1339,7 +1339,7 @@
     if (Log::isEnabled()) {
         Log::out() << "  Before walk, depthIn=" << (int) depthIn 
                    << ", stack = ";
-        for (uint32 i=0; i<depthIn; i++) {
+        for (U_32 i=0; i<depthIn; i++) {
             stackspace[i]->print(Log::out());
             Log::out() << " ";
         }
@@ -1351,7 +1351,7 @@
     WalkInstsInBlock<true, BuildSyncCliquesWalker>(node, walker); // in order
     
     assert(&walker.mem == &mm);
-    uint32 currentDepth = walker.getDepth();
+    U_32 currentDepth = walker.getDepth();
     StlVector<SyncClique *> *currentStack = walker.getStack();
     assert(currentStack);
     
@@ -1361,26 +1361,26 @@
                    << ", currentDepth=" 
                    << (int) currentDepth
                    << ", stack = ";
-        for (uint32 i=0; i<currentDepth; i++) {
+        for (U_32 i=0; i<currentDepth; i++) {
             (*currentStack)[i]->print(Log::out());
             Log::out() << " ";
         }
         Log::out() << ::std::endl;
     }
     
-    uint32 mindepth = ::std::min(currentDepth, depthOut);
+    U_32 mindepth = ::std::min(currentDepth, depthOut);
     if (Log::isEnabled()) {
         Log::out() << "  Linking05 with outstack of depth " 
                    << (int) depthOut
                    << ", outstack = ";
-        for (uint32 i=0; i<currentDepth; i++) {
+        for (U_32 i=0; i<currentDepth; i++) {
             outStack[i].print(Log::out());
             Log::out() << " ";
         }
         Log::out() << ::std::endl;
     }
     {
-        uint32 i = 0;
+        U_32 i = 0;
         for ( ; i < mindepth; ++i) {
             if (Log::isEnabled()) {
                 Log::out() << " linking06 ";
@@ -1439,8 +1439,8 @@
         end = nodes.end();
     for (; iter != end; ++iter) {
         Node *node = *iter;
-        uint32 nodeId = node->getId();
-        uint32 depthIn = entrySolution[nodeId].getDepth();
+        U_32 nodeId = node->getId();
+        U_32 depthIn = entrySolution[nodeId].getDepth();
         if (Log::isEnabled()) {
             Log::out() << "Considering node " << (int) nodeId 
                        << " with depthIn=" << (int) depthIn
@@ -1455,7 +1455,7 @@
         }
         // propagate node solution through node to exits
         
-        uint32 depthOut = exitSolution[nodeId].getDepth();
+        U_32 depthOut = exitSolution[nodeId].getDepth();
         assert(&walker.mem == &mm);
         findBalancedExits_Stage2a(node, 
                                   depthIn, entryCliques[nodeId],
@@ -1491,9 +1491,9 @@
             }
             
             // link with successor inputs
-            uint32 targetId = target->getId();
+            U_32 targetId = target->getId();
             SyncClique *targetStack = entryCliques[targetId];
-            uint32 targetDepth = entrySolution[targetId].getDepth();
+            U_32 targetDepth = entrySolution[targetId].getDepth();
 
             if (Log::isEnabled()) {
                 Log::out() << "Linking09 output of node #" 
@@ -1510,10 +1510,10 @@
     // link any open monitor at the exit node with bottom
     {
         Node *exitNode = fg.getExitNode();
-        uint32 exitId = exitNode->getId();
-        uint32 depthIn = entrySolution[exitId].getDepth();
+        U_32 exitId = exitNode->getId();
+        U_32 depthIn = entrySolution[exitId].getDepth();
         SyncClique *exitStack = entryCliques[exitId];
-        for (uint32 i=0; i< depthIn; ++i) {
+        for (U_32 i=0; i< depthIn; ++i) {
             if (Log::isEnabled()) {
                 Log::out() << " for exit node: i="
                            << (int) i;
@@ -1729,13 +1729,13 @@
             for ( ; newBadExitIter != newBadExitEnd; ++newBadExitIter) {
                 Inst *newBadExit = *newBadExitIter;
                 Node *node = newBadExit->getNode();
-                uint32 nodeId = node->getId();
-                uint32 nodeDepth = exitSolution[nodeId].getDepth();
+                U_32 nodeId = node->getId();
+                U_32 nodeDepth = exitSolution[nodeId].getDepth();
                 
                 Edge *e = (Edge *)node->getExceptionEdge();
                 Node *target = e->getTargetNode();
-                uint32 targetId = target->getId();
-                uint32 targetDepth = entrySolution[targetId].getDepth();
+                U_32 targetId = target->getId();
+                U_32 targetDepth = entrySolution[targetId].getDepth();
                 
                 SyncClique *nodeStack = exitCliques[nodeId];
                 SyncClique *targetStack = entryCliques[targetId];
@@ -1743,7 +1743,7 @@
                     if (targetDepth != nodeDepth) {
                         differs = true;
                     } else {
-                        for (uint32 i = 0; i < targetDepth; ++i) {
+                        for (U_32 i = 0; i < targetDepth; ++i) {
                             if (nodeStack[i].find() != targetStack[i].find()) {
                                 differs = true;
                                 break;
@@ -1786,9 +1786,9 @@
     InstFactory &instFactory = irManager.getInstFactory();
 
     ControlFlowGraph &fg = irManager.getFlowGraph();
-    uint32 numNodes = fg.getMaxNodeId();
+    U_32 numNodes = fg.getMaxNodeId();
     SyncOptDfValue *entrySolution, *exitSolution;
-    uint32 numCliques = findBalancedExits_Stage1(optimistic, use_IncRecCount, numNodes,
+    U_32 numCliques = findBalancedExits_Stage1(optimistic, use_IncRecCount, numNodes,
                                                  entrySolution, exitSolution);
 
     if (Log::isEnabled()) {
@@ -1799,11 +1799,11 @@
     SyncClique *cliquesHeap = new (mm) SyncClique[numCliques];
     SyncClique **entryCliques = new (mm) SyncClique *[numNodes];
     SyncClique **exitCliques = new (mm) SyncClique *[numNodes];
-    uint32 cliqueHeapIndex = 0;
+    U_32 cliqueHeapIndex = 0;
     {
-        for (uint32 i = 0; i<numNodes; i++) {
-            uint32 lin = entrySolution[i].getDepth();
-            uint32 lout = exitSolution[i].getDepth();
+        for (U_32 i = 0; i<numNodes; i++) {
+            U_32 lin = entrySolution[i].getDepth();
+            U_32 lout = exitSolution[i].getDepth();
 
             entryCliques[i] = &cliquesHeap[cliqueHeapIndex];
             cliqueHeapIndex += lin;
@@ -1812,14 +1812,14 @@
 
             if (Log::isEnabled()) {
                 Log::out() << "  node " << (int) i << " has " << (int) lin << " cliques in: [ ";
-                for (uint32 j = 0; j<lin; ++j) { 
+                for (U_32 j = 0; j<lin; ++j) { 
                     entryCliques[i][j].print(Log::out());
                     Log::out() << " ";
                 }
                 Log::out() << "]" << ::std::endl;
                 
                 Log::out() << "  node " << (int) i << " has " << (int) lout << " cliques out: [ ";
-                for (uint32 jout = 0; jout<lout; ++jout) { 
+                for (U_32 jout = 0; jout<lout; ++jout) { 
                     exitCliques[i][jout].print(Log::out());
                     Log::out() << " ";
                 }

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/syncopt.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/syncopt.h?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/syncopt.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/syncopt.h Thu May 22 06:33:38 2008
@@ -91,16 +91,16 @@
 
 private:
     // parts of findBalancedExits pulled out:
-    uint32 findBalancedExits_Stage1(bool optimistic, bool use_IncRecCount, uint32 numNodes,
+    U_32 findBalancedExits_Stage1(bool optimistic, bool use_IncRecCount, U_32 numNodes,
                                     SyncOptDfValue *&entrySolution, 
                                     SyncOptDfValue *&exitSolution);
-    void linkStacks(uint32 depth1, SyncClique *stack1,
-                    uint32 depth2, SyncClique *stack2,
+    void linkStacks(U_32 depth1, SyncClique *stack1,
+                    U_32 depth2, SyncClique *stack2,
                     SyncClique *bottomClique);
     void findBalancedExits_Stage2a(Node *node,
-                                   uint32 depthIn,
+                                   U_32 depthIn,
                                    SyncClique *inStack,
-                                   uint32 depthOut,
+                                   U_32 depthOut,
                                    SyncClique *outStack,
                                    BuildSyncCliquesWalker &walker,
                                    StlVector<SyncClique *>&stackspace,

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/throwopt.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/throwopt.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/throwopt.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/throwopt.cpp Thu May 22 06:33:38 2008
@@ -175,9 +175,9 @@
                         Opnd * dst1 = opndManager.createSsaVarOpnd(var);
                         inst->setDst(dst1);
                         // Create phi instruction to stick source operands on new path.
-                        uint32 num_opnds = inst->getNumSrcOperands();
+                        U_32 num_opnds = inst->getNumSrcOperands();
                         Opnd** opnds = new (irManager.getMemoryManager()) Opnd*[num_opnds];
-                        for (uint32 i = 0; i < num_opnds; ++i) {
+                        for (U_32 i = 0; i < num_opnds; ++i) {
                             opnds[i] = inst->getSrc(i);
                         }
                         Opnd * dst2 = opndManager.createSsaVarOpnd(var);

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/Arena.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/Arena.h?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/Arena.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/Arena.h Thu May 22 06:33:38 2008
@@ -41,7 +41,7 @@
 
 #define ARENA_HEADER_SIZE ((sizeof(struct Arena *)+sizeof(char *)+sizeof(char *) + BITS_TO_CLEAR) & ~BITS_TO_CLEAR);
 
-static const uint32 default_arena_size = 1024;
+static const U_32 default_arena_size = 1024;
 //
 // give empty space of memory, make it into an arena of given size.
 //

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/BitSet.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/BitSet.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/BitSet.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/BitSet.cpp Thu May 22 06:33:38 2008
@@ -35,22 +35,22 @@
 //
 // returns the word containing bitNumber
 //
-static inline uint32 getWordIndex(uint32 bitNumber) {
+static inline U_32 getWordIndex(U_32 bitNumber) {
     return (bitNumber >> WORD_SHIFT_AMOUNT);
 }
 //
 // returns a mask for bitNumber masking 
 //
-static inline uint32 getBitMask(uint32 bitNumber) {
+static inline U_32 getBitMask(U_32 bitNumber) {
     return (0x0001 << (bitNumber & WORD_MASK));
 }
 
-static uint32 getNumWords(uint32 setSize) {
+static U_32 getNumWords(U_32 setSize) {
     return setSize == 0 ? 0 : getWordIndex(setSize-1) + 1;
 }
 
 /*
-static uint32 getNumBytes(uint32 setSize) {
+static U_32 getNumBytes(U_32 setSize) {
     return setSize == 0 ? 0 : (setSize + 7) >> 3;
 }
 */
@@ -58,9 +58,9 @@
 // Constructors
 //
 
-static uint32* stub=(uint32*)0xDEADBEEF;
+static U_32* stub=(U_32*)0xDEADBEEF;
 
-BitSet::BitSet(MemoryManager& memManager, uint32 size)
+BitSet::BitSet(MemoryManager& memManager, U_32 size)
 :words(0), setSize(0), wordsCapacity(0), mm(memManager)
 {
     if (size != 0)
@@ -91,7 +91,7 @@
 }
 
 
-BitSet::BitSet(MemoryManager& memManager, const BitSet& set, uint32 size)
+BitSet::BitSet(MemoryManager& memManager, const BitSet& set, U_32 size)
 :mm(memManager)
 {
     alloc(size);
@@ -113,14 +113,14 @@
 }
 
 
-void BitSet::alloc(uint32 size)
+void BitSet::alloc(U_32 size)
 {
     assert(size != 0);
-    words = new (mm) uint32[wordsCapacity = getNumWords(setSize = size)];
+    words = new (mm) U_32[wordsCapacity = getNumWords(setSize = size)];
 }
 
 
-void BitSet::copy(uint32* src)
+void BitSet::copy(U_32* src)
 {
     for (int i = getNumWords(setSize); --i >= 0;)
         words[i] = src[i];
@@ -129,13 +129,13 @@
 }
 
 
-void BitSet::resize(uint32 newSetSize) {
+void BitSet::resize(U_32 newSetSize) {
     if (newSetSize > setSize ) {
-        uint32 newWordsCapacity = getNumWords(newSetSize);
+        U_32 newWordsCapacity = getNumWords(newSetSize);
         if (newWordsCapacity > wordsCapacity) {
-            uint32 *oldWords = words;
-            words = new (mm) uint32[newWordsCapacity];
-            for (uint32 i=0; i<wordsCapacity; i++) words[i] = oldWords[i];
+            U_32 *oldWords = words;
+            words = new (mm) U_32[newWordsCapacity];
+            for (U_32 i=0; i<wordsCapacity; i++) words[i] = oldWords[i];
             wordsCapacity = newWordsCapacity;
         }
         clearTrailingBits();
@@ -150,20 +150,20 @@
 
 void BitSet::clearTrailingBits() 
 {
-    uint32 mk = getBitMask(setSize) - 1;
-    for (uint32 i = getWordIndex(setSize); i < wordsCapacity; ++i) {
+    U_32 mk = getBitMask(setSize) - 1;
+    for (U_32 i = getWordIndex(setSize); i < wordsCapacity; ++i) {
         words[i] &= mk;
         mk = 0;
     }
 }
 
 
-void BitSet::resizeClear(uint32 newSetSize) {
-    uint32 newWordsCapacity = getNumWords(newSetSize);
+void BitSet::resizeClear(U_32 newSetSize) {
+    U_32 newWordsCapacity = getNumWords(newSetSize);
     if (newWordsCapacity > wordsCapacity) 
-        words = new (mm) uint32[wordsCapacity = newWordsCapacity];
+        words = new (mm) U_32[wordsCapacity = newWordsCapacity];
 
-    for (uint32 i=0; i<wordsCapacity; i++) 
+    for (U_32 i=0; i<wordsCapacity; i++) 
         words[i] = 0;
     setSize = newSetSize;
 }
@@ -173,16 +173,16 @@
 //  Sets all bits to false
 //
 void BitSet::clear() {
-    uint32 numWords = getNumWords(setSize);
-    for (uint32 i=0; i<numWords; i++)   words[i] = 0;
+    U_32 numWords = getNumWords(setSize);
+    for (U_32 i=0; i<numWords; i++)   words[i] = 0;
 }
 //
 //  Sets all bits to true
 //
 void BitSet::setAll() {
     assert(words != 0);
-    uint32 numWords = getNumWords(setSize);
-    for (uint32 i=0; i<numWords; i++)  words[i] = ~((uint32)0);
+    U_32 numWords = getNumWords(setSize);
+    for (U_32 i=0; i<numWords; i++)  words[i] = ~((U_32)0);
     clearTrailingBits();
 }
 //
@@ -190,24 +190,24 @@
 //
 bool BitSet::isEmpty() const {
     assert(words != 0);
-    uint32 numWords = getNumWords(setSize);
-    for (uint32 i=0; i<numWords; i++) if (words[i] != 0) return false;
+    U_32 numWords = getNumWords(setSize);
+    for (U_32 i=0; i<numWords; i++) if (words[i] != 0) return false;
     return true;
 }
 //
 //  Sets 32 bits to values indicated by a bit mask and returns old values
 //
-uint32 BitSet::set32Bits(uint32 firstBitNumber, uint32 value) {
+U_32 BitSet::set32Bits(U_32 firstBitNumber, U_32 value) {
     assert(words != 0 && firstBitNumber < setSize || firstBitNumber % 32 == 0);
-    uint32 wordIndex = getWordIndex(firstBitNumber);
-    uint32 oldValue = words[wordIndex];
+    U_32 wordIndex = getWordIndex(firstBitNumber);
+    U_32 oldValue = words[wordIndex];
     words[wordIndex] = value;
     return oldValue;
 }
 //
 //  Returns values of 32 bits encoded as a bit mask
 //
-uint32 BitSet::get32Bits(uint32 firstBitNumber) {
+U_32 BitSet::get32Bits(U_32 firstBitNumber) {
     assert(words != 0 && firstBitNumber < setSize || firstBitNumber % 32 == 0);
     return words[getWordIndex(firstBitNumber)];
 }
@@ -220,8 +220,8 @@
         if (words == 0)
             alloc(set.setSize);
         assert(setSize == set.setSize);
-        uint32 numWords = getNumWords(setSize);
-        for (uint32 i=0; i<numWords; i++) words[i] = set.words[i];
+        U_32 numWords = getNumWords(setSize);
+        for (U_32 i=0; i<numWords; i++) words[i] = set.words[i];
     }
 }
 //
@@ -233,10 +233,10 @@
     if (words == 0)
         alloc(set.setSize);
     assert(setSize >= set.setSize);
-    uint32 numWords1 = getNumWords(setSize);
-    uint32 numWords2 = getNumWords(set.setSize);
+    U_32 numWords1 = getNumWords(setSize);
+    U_32 numWords2 = getNumWords(set.setSize);
     assert(numWords1 >= numWords2);
-    uint32 i;
+    U_32 i;
     for (i=0; i<numWords2; i++) words[i] = set.words[i];
     for (i=numWords2; i<numWords1; i++) words[i] = 0;
 }
@@ -245,24 +245,24 @@
 //
 void BitSet::unionWith(const BitSet& set) {
     assert(words != 0 && set.words != 0 && setSize == set.setSize);
-    uint32 numWords = getNumWords(setSize);
-    for (uint32 i=0; i<numWords; i++) words[i] |= set.words[i];
+    U_32 numWords = getNumWords(setSize);
+    for (U_32 i=0; i<numWords; i++) words[i] |= set.words[i];
 }
 //
 //  Intersects with another set
 //
 void BitSet::intersectWith(const BitSet& set) {
     assert(words != 0 && set.words != 0 && setSize == set.setSize);
-    uint32 numWords = getNumWords(setSize);
-    for (uint32 i=0; i<numWords; i++) words[i] &= set.words[i];
+    U_32 numWords = getNumWords(setSize);
+    for (U_32 i=0; i<numWords; i++) words[i] &= set.words[i];
 }
 //
 //  Subtracts another set
 //
 void BitSet::subtract(const BitSet& set) {
     assert(words != 0 && set.words != 0 && setSize == set.setSize);
-    uint32 numWords = getNumWords(setSize);
-    for (uint32 i=0; i<numWords; i++) words[i] &= ~(set.words[i]);
+    U_32 numWords = getNumWords(setSize);
+    for (U_32 i=0; i<numWords; i++) words[i] &= ~(set.words[i]);
 }
 //
 //  Checks if this set is equal to another one
@@ -270,8 +270,8 @@
 bool BitSet::isEqual(const BitSet& set) {
     assert(words != 0 && set.words != 0);
     if (setSize != set.setSize) return false;
-    uint32 numWords = getNumWords(setSize);
-    for (uint32 i=0; i<numWords; i++) {
+    U_32 numWords = getNumWords(setSize);
+    for (U_32 i=0; i<numWords; i++) {
         if (words[i] != set.words[i]) return false;
     }
     return true;
@@ -281,8 +281,8 @@
 //
 bool BitSet::isDisjoint(const BitSet& set) {
     assert(words != 0 && set.words != 0 && setSize == set.setSize);
-    uint32 numWords = getNumWords(setSize);
-    for (uint32 i=0; i<numWords; i++) {
+    U_32 numWords = getNumWords(setSize);
+    for (U_32 i=0; i<numWords; i++) {
         if ((words[i] & set.words[i]) != 0) return false;
     }
     return true;
@@ -292,8 +292,8 @@
 //
 bool BitSet::isLessOrEqual(const BitSet& set) {
     assert(words != 0 && set.words != 0 && setSize == set.setSize);
-    uint32 numWords = getNumWords(setSize);
-    for  (uint32 i=0; i<numWords; i++) {
+    U_32 numWords = getNumWords(setSize);
+    for  (U_32 i=0; i<numWords; i++) {
         if ((words[i] & (~set.words[i])) != 0) return false;
     }
     return true;
@@ -301,11 +301,11 @@
 
 void BitSet::visitElems(Visitor& visitor) const {
     assert(words != 0);
-    uint32 bitNumber = 0;
-    uint32 numWords = getNumWords(setSize);
-    for (uint32 i=0; i<numWords; i++) {
-        uint32 word = words[i];
-        for (uint32 mask = 0x0001; mask != 0; mask = mask << 1) {
+    U_32 bitNumber = 0;
+    U_32 numWords = getNumWords(setSize);
+    for (U_32 i=0; i<numWords; i++) {
+        U_32 word = words[i];
+        for (U_32 mask = 0x0001; mask != 0; mask = mask << 1) {
             if ((word & mask) != 0)
                 visitor.visit(bitNumber);
             bitNumber++;

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/BitSet.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/BitSet.h?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/BitSet.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/BitSet.h Thu May 22 06:33:38 2008
@@ -40,7 +40,7 @@
     //
     // Constructors
     //
-    BitSet(MemoryManager&, uint32 size);
+    BitSet(MemoryManager&, U_32 size);
     //
     //  copy constructors
     //
@@ -49,7 +49,7 @@
     //
     //  This constructor is useful when a bit set needs to be expanded into a larger one
     //
-    BitSet(MemoryManager&, const BitSet&, uint32 size);
+    BitSet(MemoryManager&, const BitSet&, U_32 size);
     //
     // assignment operator (resizes the set if necessary)
     //
@@ -57,19 +57,19 @@
     //
     // resizes BitSet. Sets new bits to FALSE
     //
-    void resize(uint32 newSetSize);
+    void resize(U_32 newSetSize);
     //
     // resizes BitSet. Sets all bits to FALSE
     //
-    void resizeClear(uint32 newSetSize);
+    void resizeClear(U_32 newSetSize);
     //
     // returns the size of the set
     //
-    uint32 getSetSize() const {return setSize;}
+    U_32 getSetSize() const {return setSize;}
     //
     // returns the value of the bit
     //
-    bool getBit(uint32 bitNumber) const
+    bool getBit(U_32 bitNumber) const
     {
         assert(words != 0 && bitNumber < setSize);
         return (reinterpret_cast<char*>(words)[bitNumber >> 3] & (1 << (bitNumber & 7))) != 0;
@@ -77,7 +77,7 @@
     //
     // sets a bit to the given value and returns old value of bit
     //
-    bool setBit(uint32 bitNumber, bool value = true)
+    bool setBit(U_32 bitNumber, bool value = true)
     {
         assert(words != 0 && bitNumber < setSize);
         char& wd = reinterpret_cast<char*>(words)[bitNumber >> 3];
@@ -106,11 +106,11 @@
     //
     //  Sets 32 bits to values indicated by a bit mask and returns old values
     //
-    uint32 set32Bits(uint32 firstBitNumber, uint32 value);
+    U_32 set32Bits(U_32 firstBitNumber, U_32 value);
     //
     //  Returns values of 32 bits encoded as a bit mask
     //
-    uint32 get32Bits(uint32 firstBitNumber);
+    U_32 get32Bits(U_32 firstBitNumber);
     //
     //  Copies another set
     //
@@ -161,8 +161,8 @@
     //
     // makes initial allocation
     //
-    void alloc(uint32 size);
-    void copy (uint32* src);
+    void alloc(U_32 size);
+    void copy (U_32* src);
     //
     // zero bits that out of setSize
     //
@@ -170,15 +170,15 @@
     //
     // words containing the set's bits; 
     //
-    uint32* words;
+    U_32* words;
     //
     // size of set (in bits)
     //
-    uint32 setSize;
+    U_32 setSize;
     //
     // number of words reserved
     //
-    uint32 wordsCapacity; 
+    U_32 wordsCapacity; 
     //
     // mem manager used to resize the set
     //
@@ -189,7 +189,7 @@
 class BitSet::Visitor {
 public:
     virtual ~Visitor() {}
-    virtual void visit(uint32 elem) = 0;
+    virtual void visit(U_32 elem) = 0;
 };
 
 
@@ -197,7 +197,7 @@
 public:
     Printer(::std::ostream & _os) : os(_os) {}
     virtual ~Printer() {}
-    void visit(uint32 i) { os << " " << (int) i;}
+    void visit(U_32 i) { os << " " << (int) i;}
 private:
     ::std::ostream & os;
 };
@@ -214,8 +214,8 @@
 
 protected:
 
-    uint32 * ptr, * end;
-    uint32 mask;
+    U_32 * ptr, * end;
+    U_32 mask;
     int idx;
 };
 

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/ControlFlowGraph.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/ControlFlowGraph.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/ControlFlowGraph.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/ControlFlowGraph.cpp Thu May 22 06:33:38 2008
@@ -167,8 +167,8 @@
 }
 
 
-uint32 Node::getInstCount(bool ignoreLabels) const  {
-    uint32 count = 0;
+U_32 Node::getInstCount(bool ignoreLabels) const  {
+    U_32 count = 0;
     CFGInst* first = getFirstInst();
     while (ignoreLabels && first!=NULL && first->isLabel()) {
         first = first->next();
@@ -585,7 +585,7 @@
 }
 
 void ControlFlowGraph::mergeAdjacentNodes(bool skipEntry, bool mergeByDispatch) {
-    for(uint32 idx = 0; idx < nodes.size(); idx++) {
+    for(U_32 idx = 0; idx < nodes.size(); idx++) {
         Node* node = nodes[idx];
         if (node->isBlockNode() && (!skipEntry || node!=entryNode)) { 
             Node* succ = node->getUnconditionalEdgeTarget();
@@ -884,7 +884,7 @@
         if (!loopTree->isValid()) {
             loopTree->rebuild(false);
         }
-        uint32 nNodes = fg->getNodeCount();
+        U_32 nNodes = fg->getNodeCount();
         cyclicFreqs = new (mm) double[nNodes];
         std::fill(cyclicFreqs, cyclicFreqs + nNodes, 1);
     }

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/ControlFlowGraph.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/ControlFlowGraph.h?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/ControlFlowGraph.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/ControlFlowGraph.h Thu May 22 06:33:38 2008
@@ -103,7 +103,7 @@
    *
    * @return The unique edge ID that is constant for lifetime of this edge.
    */
-    uint32 getId() const {return id;}
+    U_32 getId() const {return id;}
 
   /** 
    * Returns the edge kind.
@@ -213,10 +213,10 @@
     *
     * @param[in] _id - a new edge ID 
     */
-    void setId(uint32 _id) {id = _id;}
+    void setId(U_32 _id) {id = _id;}
 
     /// The unique edge ID within CFG.
-    uint32 id;
+    U_32 id;
 
     /// The <code>Source</code> or the <code>Tail</code> node of the edge.
     Node *source;
@@ -455,7 +455,7 @@
    *
    * @return The unique node ID in the containing flow graph.
    */
-    uint32 getId() const {return id;}
+    U_32 getId() const {return id;}
 
   /** 
    * Gets the depth-first numbering of the given node computed during the last 
@@ -469,7 +469,7 @@
    *      <code>isForward</code> parameter is <code>TRUE</code> in the 
    *      <code>orderNodes(isForward)</code> method call.
    */
-    uint32 getDfNum() const {return dfNumber;}
+    U_32 getDfNum() const {return dfNumber;}
     
   /** 
    * Gets the pre-num numbering of the given node computed during the last pass.
@@ -477,7 +477,7 @@
    *
    * @return The pre-num numbering of the given node.
    */
-    uint32 getPreNum() const {return preNumber;}
+    U_32 getPreNum() const {return preNumber;}
     
   /** 
    * Gets the post-num numbering of the given node computed during the last pass.
@@ -485,7 +485,7 @@
    *
    * @return The post-num numbering of the given node.
    */
-    uint32 getPostNum() const {return postNumber;}
+    U_32 getPostNum() const {return postNumber;}
 
     
   /**
@@ -730,14 +730,14 @@
    *
    * @return The number of outgoing edges of the node.
    */
-    uint32 getOutDegree() const {return (uint32)getOutEdges().size();}
+    U_32 getOutDegree() const {return (U_32)getOutEdges().size();}
     
   /** 
    * Gets the number of incoming edges to the node. 
    *
    * @return The number of incoming edges to the node.
    */
-    uint32 getInDegree() const {return (uint32)getInEdges().size();}
+    U_32 getInDegree() const {return (U_32)getInEdges().size();}
 
   /** 
    * Checks whether the node has only one outgoing edge. 
@@ -808,7 +808,7 @@
    *
    * @return  The number of instructions in the node. 
    */
-    uint32 getInstCount(bool ignoreLabels = true) const;
+    U_32 getInstCount(bool ignoreLabels = true) const;
 
   /** 
    * Checks whether not a single instruction is in the node.
@@ -858,7 +858,7 @@
    *
    * @return The traversal number for the node.
    */
-    uint32 getTraversalNum() const {return traversalNumber;}
+    U_32 getTraversalNum() const {return traversalNumber;}
     
   /** 
    * Sets a new traversal number of the node, usually 
@@ -866,7 +866,7 @@
    *
    * @param[in] num - a new traversal number
    */
-    void setTraversalNum(uint32 num) {traversalNumber = num;}
+    void setTraversalNum(U_32 num) {traversalNumber = num;}
 
   /** 
    * Gets the second instruction in the node.
@@ -918,7 +918,7 @@
    * 
    * @param[in] _id - a new node ID 
    */
-    void setId(uint32 _id) {id = _id;}
+    void setId(U_32 _id) {id = _id;}
 
 
   /**
@@ -929,32 +929,32 @@
     void insertInst(CFGInst* prev, CFGInst* newInst);
 
     /// The unique ID of the node in CFG.
-    uint32 id;
+    U_32 id;
     
   /** 
    * The depth-first number of the node in CFG. 
    * It is updated every time CFG is ordered.
    */
-    uint32 dfNumber;
+    U_32 dfNumber;
 
   /** 
    * The pre-number of the node in CFG. 
    * It is updated every time CFG is ordered.
    */
-    uint32 preNumber;
+    U_32 preNumber;
     
   /** 
    * The post-number of the node in CFG. 
    * It is updated every time CFG is ordered.
    */
-    uint32 postNumber;
+    U_32 postNumber;
 
   /** 
    * The number of times the node was traversed by the 
    * ordering algorithms.
    * It is updated every time CFG is ordered.
    */
-    uint32 traversalNumber;
+    U_32 traversalNumber;
 
     /// The type of the node.
     Kind   kind;
@@ -1132,7 +1132,7 @@
    * 
    * @return The maximum node ID.
    */
-    uint32 getMaxNodeId() const {return nodeIDGenerator;}
+    U_32 getMaxNodeId() const {return nodeIDGenerator;}
     
   /** 
    * Creates a new specified node. Add instruction to the node.
@@ -1188,7 +1188,7 @@
    *
    * @return The number of reachable nodes in the graph.
    */
-    uint32 getNodeCount() { if(!hasValidOrdering()) orderNodes(); return nodeCount; }
+    U_32 getNodeCount() { if(!hasValidOrdering()) orderNodes(); return nodeCount; }
     
   /** 
    * Gets the cached postorder collection of nodes in the graph.
@@ -1288,7 +1288,7 @@
    * 
    * @return The maximum edge ID.
    */
-    uint32 getMaxEdgeId() const {return edgeIDGenerator;}
+    U_32 getMaxEdgeId() const {return edgeIDGenerator;}
 
   /** 
    * Removes the edge from CFG. Updates <code>Source</code> and 
@@ -1374,7 +1374,7 @@
    *
    * @return The traversal number
    */
-    uint32 getTraversalNum() const {return traversalNumber;}
+    U_32 getTraversalNum() const {return traversalNumber;}
     
   /** 
    * Sets the traversal number.
@@ -1385,7 +1385,7 @@
    * @param[in] newTraversalNum - a new traversal number
    */
 
-    void setTraversalNum(uint32 newTraversalNum) {traversalNumber = newTraversalNum;}
+    void setTraversalNum(U_32 newTraversalNum) {traversalNumber = newTraversalNum;}
 
   /** 
    * The modification traversal number is the traversal number of the
@@ -1393,7 +1393,7 @@
    * 
    * @return The modification traversal number.
    */
-    uint32 getModificationTraversalNum() const { return lastModifiedTraversalNumber; }
+    U_32 getModificationTraversalNum() const { return lastModifiedTraversalNumber; }
 
   /** 
    * The edge removal traversal number is the modification traversal number of 
@@ -1401,7 +1401,7 @@
    * 
    * @return The edge removal traversal number.
    */
-    uint32 getEdgeRemovalTraversalNum() const { return lastEdgeRemovalTraversalNumber; }
+    U_32 getEdgeRemovalTraversalNum() const { return lastEdgeRemovalTraversalNumber; }
 
   /** 
    * The ordering traversal number is the traversal number after the last depth
@@ -1410,7 +1410,7 @@
    *
    * @return The ordering traversal number.
    */
-    uint32 getOrderingTraversalNum() const { return lastOrderingTraversalNumber; }
+    U_32 getOrderingTraversalNum() const { return lastOrderingTraversalNumber; }
 
   /** 
    * Checks if CFG nodes have valid ordering, that is there was no modification
@@ -1718,7 +1718,7 @@
    
     template <class Container>
     void getNodesDFS(Container* preOrderContainer, Container* postOrderContainer, Node* node, bool isForward=true) {
-        uint32 marked = traversalNumber;
+        U_32 marked = traversalNumber;
         node->setTraversalNum(marked);
         if(isForward) {
             node->dfNumber = currentPreNumber;
@@ -1786,26 +1786,26 @@
     Nodes postOrderCache;
 
     /// The ID generator for nodes, which is incremented every time a new node is added to the graph.
-    uint32 nodeIDGenerator;
+    U_32 nodeIDGenerator;
     /// The ID generator for edges, which is incremented every time a new edge is added to the graph.
-    uint32 edgeIDGenerator;
+    U_32 edgeIDGenerator;
     /// The number of reachable nodes in the graph, which is updated every time the graph is ordered.
-    uint32 nodeCount;
+    U_32 nodeCount;
     /// The last graph traversal number used to track graph modifications.
-    uint32 traversalNumber;
+    U_32 traversalNumber;
     /// The given field is assigned to the <code>traversalNumber</code> value every time the graph is modified.
-    uint32 lastModifiedTraversalNumber;
+    U_32 lastModifiedTraversalNumber;
     /// The given field is assigned to the <code>traversalNumber</code> value every time the graph is ordered.
-    uint32 lastOrderingTraversalNumber;
+    U_32 lastOrderingTraversalNumber;
     /// The given field is assigned to the <code>traversalNumber</code> value every time any edge is removed from the graph.
-    uint32 lastEdgeRemovalTraversalNumber;
+    U_32 lastEdgeRemovalTraversalNumber;
     /// The given field is assigned to the <code>traversalNumber</code> value every time the profile information is recalculated.
-    uint32 lastProfileUpdateTraversalNumber;
+    U_32 lastProfileUpdateTraversalNumber;
 
     /// The temporary field used by ordering algorithms.
-    uint32 currentPreNumber;
+    U_32 currentPreNumber;
     /// The temporary field used by ordering algorithms.
-    uint32 currentPostNumber;
+    U_32 currentPostNumber;
 
     /// Tells whether the graph is annotated with the edge profile.
     bool annotatedWithEdgeProfile;

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/Dominator.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/Dominator.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/Dominator.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/Dominator.cpp Thu May 22 06:33:38 2008
@@ -40,7 +40,7 @@
 
     // Get the nodes of the flowgraph in postorder.
     flowgraph->getNodesPostOrder(nodes, !isPost);
-    uint32 numNodes = (uint32) nodes.size();
+    U_32 numNodes = (U_32) nodes.size();
 #ifdef _DEBUG
     // Start (entry/exit) node should be last.
     Node* start = nodes.back();
@@ -49,7 +49,7 @@
 #endif         
     // Initialize the idom array to UNDEFINED.  Idiom maps the postorder
     // number of a node to the postorder number of its idom.
-    StlVector<uint32> idom(tmm);
+    StlVector<U_32> idom(tmm);
     idom.insert(idom.end(), (unsigned int) numNodes-1, UNDEFINED);
     // Initialize idom[entry] = NONE.
     idom.insert(idom.end(), NONE);
@@ -62,10 +62,10 @@
         Nodes::reverse_iterator i;
         for(i = nodes.rbegin()+1; i != nodes.rend(); ++i) {
             Node* node = *i;
-            uint32 nodeNum = node->getPostNum();
+            U_32 nodeNum = node->getPostNum();
 
             // Compute updated idom from predecessors
-            uint32 newIdom = UNDEFINED;
+            U_32 newIdom = UNDEFINED;
             Edges::const_iterator j;
             for(j = node->getEdges(isPost).begin(); j != node->getEdges(isPost).end(); ++j) {
                 Node* pred = (*j)->getNode(isPost);
@@ -73,7 +73,7 @@
                 if (!ignoreUnreach)
                     assert(pred->getTraversalNum() == flowgraph->getTraversalNum());
                 if (!ignoreUnreach || (ignoreUnreach && (pred->getTraversalNum() == flowgraph->getTraversalNum()))) {
-                    uint32 predNum = pred->getPostNum();
+                    U_32 predNum = pred->getPostNum();
                     // Skip unprocessed preds (only happens on first iteration).
                     if(idom[predNum] != UNDEFINED)
                         // Intersect dominator sets.
@@ -96,8 +96,8 @@
     return new (mm) DominatorTree(mm, flowgraph, nodes, idom, isPost);
 }
 
-uint32 
-DominatorBuilder::intersect(StlVector<uint32>& idom, uint32 finger1, uint32 finger2) {
+U_32 
+DominatorBuilder::intersect(StlVector<U_32>& idom, U_32 finger1, U_32 finger2) {
     // Intersect the dominator sets represented by finger1 and finger2.
     while(finger1 != finger2) {
         while(finger1 < finger2)
@@ -113,13 +113,13 @@
 DominatorTree::DominatorTree(MemoryManager& mm,
                              ControlFlowGraph* fg,
                              Nodes& nodes,
-                             StlVector<uint32>& idom,
+                             StlVector<U_32>& idom,
                              bool isPostDominator)     
                              : flowgraph(fg), traversalNum(fg->getTraversalNum()), 
                                numNodes(fg->getMaxNodeId()), 
                                _isPostDominator(isPostDominator), tree(mm, numNodes, NULL) {
     // Create the dominator tree nodes..
-    uint32 postNum, id=MAX_UINT32;
+    U_32 postNum, id=MAX_UINT32;
     for(postNum = 0; postNum < nodes.size(); ++postNum) {
         Node* node = nodes[postNum];
         id = node->getId();
@@ -134,12 +134,12 @@
         Node* node = nodes[postNum];
         id = node->getId();
         // Assert post-ordering of nodes.
-        assert((uint32) postNum == node->getPostNum());
+        assert((U_32) postNum == node->getPostNum());
         if(idom[postNum] != NONE) {
             // Assert that idoms are acyclic.
             assert(idom[postNum] > postNum);
             Node* parent = nodes[idom[postNum]];
-            uint32 parentId = parent->getId();
+            U_32 parentId = parent->getId();
             assert(tree[parentId] != NULL);
             // Assert that new child (added to beginning) has highest postorder number.
             assert(tree[parentId]->getChild() == NULL || tree[parentId]->getChild()->getNode()->getPostNum() < postNum);
@@ -169,7 +169,7 @@
                          ControlFlowGraph*     fg) 
 : memManager(mm), dom(d), isPostDominator(d.isPostDominator()) {
     // To Do: may want to keep number of nodes in flow graph instead of recomputing every time
-    numNodes = (uint32) fg->getNodeCount();
+    numNodes = (U_32) fg->getNodeCount();
 
     // if flow graph has been modified since dominator was computed, then
     // dominator information needs to be recomputed
@@ -183,7 +183,7 @@
     memset(DF, 0, numNodes*sizeof(List<Node>*));  // initialized with NULL
 }
 
-void DomFrontier::addDF(uint32 entry, Node* n) {
+void DomFrontier::addDF(U_32 entry, Node* n) {
     assert(entry < numNodes);
     // make sure no duplicate entry
     for (List<Node>* l = DF[entry]; l != NULL; l = l->getNext())
@@ -193,7 +193,7 @@
 }
 
 void DomFrontier::computeDomFrontier(Node* node) {
-    uint32 dfnum = node->getDfNum();
+    U_32 dfnum = node->getDfNum();
     // if dom frontiers are not computed yet
     if (beenComputed->getBit(dfnum))
         return;

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/Dominator.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/Dominator.h?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/Dominator.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/Dominator.h Thu May 22 06:33:38 2008
@@ -90,7 +90,7 @@
     }
 
     // Returns the number of nodes in the tree.
-    uint32 getNumNodes() const { return numNodes; }
+    U_32 getNumNodes() const { return numNodes; }
 
     // True if this is a post-dominator tree. 
     bool isPostDominator() const { return _isPostDominator; }
@@ -99,7 +99,7 @@
     bool isValid() { 
         return traversalNum > flowgraph->getModificationTraversalNum(); 
     } 
-    uint32 getTraversalNum() { return traversalNum; }
+    U_32 getTraversalNum() { return traversalNum; }
 
     // True if node has dominator information.  Note, if the dominator tree
     // is not valid overall, it is up to the caller to ensure that an
@@ -110,11 +110,11 @@
 
 private:
     DominatorTree(MemoryManager& mm, ControlFlowGraph* fg, StlVector<Node*>& nodes, 
-        StlVector<uint32>& idom, bool isPostDominator);
+        StlVector<U_32>& idom, bool isPostDominator);
  
     ControlFlowGraph*    flowgraph;
-    uint32               traversalNum;
-    uint32               numNodes;
+    U_32               traversalNum;
+    U_32               numNodes;
     bool                   _isPostDominator;
     StlVector<DominatorNode*> tree;
 };
@@ -130,7 +130,7 @@
     DominatorTree* computeDominators(MemoryManager& mm, ControlFlowGraph* flowgraph, bool isPost=false, bool ignoreUnreach = false);
     DominatorTree* computePostdominators(MemoryManager& mm, ControlFlowGraph* flowgraph, bool ignoreUnreach) { return computeDominators(mm, flowgraph, true, ignoreUnreach); }
 private:
-    uint32 intersect(StlVector<uint32>& idom, uint32 num1, uint32 num2);
+    U_32 intersect(StlVector<U_32>& idom, U_32 num1, U_32 num2);
 };
 
 /**
@@ -143,7 +143,7 @@
 public:
     DomFrontier(MemoryManager& mm, DominatorTree& d, ControlFlowGraph* fg);
     void   printDomFrontier(::std::ostream&, Node* n);
-    uint32 getNumNodes() {return numNodes;}
+    U_32 getNumNodes() {return numNodes;}
     List<Node>* getFrontiersOf(Node* n) {
         assert(n->getDfNum() < numNodes);
         computeDomFrontier(n);
@@ -152,11 +152,11 @@
     DominatorTree& getDominator() {return dom;}
 private:
     void   computeDomFrontier(Node* n);
-    void   addDF(uint32 entry, Node* n);
+    void   addDF(U_32 entry, Node* n);
 
 
     List<Node>** DF;
-    uint32          numNodes;
+    U_32          numNodes;
     BitSet*         beenComputed;
     MemoryManager&  memManager;
     DominatorTree&  dom;

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/Event.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/Event.h?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/Event.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/Event.h Thu May 22 06:33:38 2008
@@ -51,7 +51,7 @@
     //
     // Constructor
     //
-    Event(char *nm) : counter(0), threshold((uint32) -1), 
+    Event(char *nm) : counter(0), threshold((U_32) -1), 
                       state(Inactive), name(nm) {}
     //
     // Increment the event counter by reported number of events
@@ -75,7 +75,7 @@
     //
     // Set overflow threshold
     //
-    void setThreshold(uint32 th) { threshold = th; }
+    void setThreshold(U_32 th) { threshold = th; }
     //
     // Is monitoring active on this event?
     //
@@ -89,7 +89,7 @@
     // monitoring.
     //
     void startMonitor() {
-        assert(threshold != ((uint32) -1));
+        assert(threshold != ((U_32) -1));
         counter = 0;
         state   = Counting;
     }
@@ -140,8 +140,8 @@
 
 private:
     // Fields
-    uint32 counter;     // Counts number of occurrences of the event 
-    uint32 threshold;   // Threshold for overflow
+    U_32 counter;     // Counts number of occurrences of the event 
+    U_32 threshold;   // Threshold for overflow
     State  state;       // Active indicates that the counter is being tracked
     char * name;        // Name for the event counter
 };

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/HashSet.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/HashSet.h?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/HashSet.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/HashSet.h Thu May 22 06:33:38 2008
@@ -57,7 +57,7 @@
     //
     //  Returns number of elements in the set
     //
-    uint32 getSize() const {return (uint32)map.size();}
+    U_32 getSize() const {return (U_32)map.size();}
     //
     //  Returns true if set contains the element, false otherwise
     //
@@ -114,7 +114,7 @@
         //
         MemoryManager memManager("HashSet::intersect.memManager");
         KEY * removeList = (KEY *)memManager.alloc(sizeof(KEY) * map.size());
-        uint32 removeListSize = 0;
+        U_32 removeListSize = 0;
         const_iterator iter = map.begin(),
                        end  = map.end();
         for (; iter != end; iter++) {
@@ -124,7 +124,7 @@
         //
         //  Remove elements that are in removeList
         //
-        for (uint32 i = 0; i < removeListSize; i++)
+        for (U_32 i = 0; i < removeListSize; i++)
             map.erase(removeList[i]);
     }
     //
@@ -175,7 +175,7 @@
     //
     iterator end() {return map.end();}
 private:
-    StlHashMap<uint32,ELEM> map;
+    StlHashMap<U_32,ELEM> map;
 };
 
 } //namespace Jitrino 

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/HashTable.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/HashTable.h?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/HashTable.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/HashTable.h Thu May 22 06:33:38 2008
@@ -52,13 +52,13 @@
 
 class HashTableImpl {
 public:
-    HashTableImpl(MemoryManager& mm, uint32 size) 
+    HashTableImpl(MemoryManager& mm, U_32 size) 
         : memManager(mm), table(0), tableSize(size) {
         table = new (memManager) HashTableLink*[tableSize];
-        for (uint32 i=0; i<tableSize; i++)
+        for (U_32 i=0; i<tableSize; i++)
             table[i] = NULL;
     }
-    HashTableImpl(MemoryManager& mm,uint32 size,HashTableLink** t) 
+    HashTableImpl(MemoryManager& mm,U_32 size,HashTableLink** t) 
         : memManager(mm), table(t), tableSize(size) {
         removeAll();
     }
@@ -73,7 +73,7 @@
     void  insert(void* key, void* value) {
         HashTableLink* entry = lookupEntry(key);
         if (entry == NULL) {
-            uint32 idx = getTableIndex(key);
+            U_32 idx = getTableIndex(key);
             HashTableLink* link = createLink(key,value);
             link->next = table[idx];
             table[idx] = link;
@@ -82,7 +82,7 @@
         }
     }
     void    remove(void* key) {
-        uint32 idx = getTableIndex(key);
+        U_32 idx = getTableIndex(key);
         HashTableLink* prev = NULL;
         for (HashTableLink* e = table[idx]; e != NULL; prev = e, e = e->next) {
             if (equals(e->keyPtr,key)) {
@@ -96,7 +96,7 @@
         }
     }
     void    removeAll() {
-        for (uint32 i=0; i<tableSize; i++) {
+        for (U_32 i=0; i<tableSize; i++) {
             HashTableLink* link;
             if ((link = table[i]) == NULL)
                 continue;
@@ -132,7 +132,7 @@
         }
         return NULL;
     }
-    uint32 getTableIndex(void* key) const {
+    U_32 getTableIndex(void* key) const {
         return getHashCode(key) % tableSize;
     }
     virtual HashTableLink*  createLink(void* key,void* elem) {
@@ -142,7 +142,7 @@
         delete link;
     }
     virtual bool    equals(void* key1,void* key2) const = 0;
-    virtual uint32  getHashCode(void* key) const = 0;
+    virtual U_32  getHashCode(void* key) const = 0;
 
     friend class HashTableIterImpl;
     //
@@ -150,12 +150,12 @@
     //
     MemoryManager&  memManager;
     HashTableLink** table;
-    uint32          tableSize;
+    U_32          tableSize;
 
 public:
-    static uint32 numLookup;
-    static uint32 numLookupEntry;
-    static uint32 numFound;
+    static U_32 numLookup;
+    static U_32 numLookupEntry;
+    static U_32 numFound;
 };
 
 //
@@ -192,7 +192,7 @@
     }
 
     HashTableImpl* hashTable;
-    uint32         nextEntry;
+    U_32         nextEntry;
     HashTableLink* nextElem;
 };
 
@@ -207,7 +207,7 @@
 template <class KEY>
 class KeyLinkHashTable : HashTableImpl {
 public:
-    KeyLinkHashTable(MemoryManager& mm,uint32 size) : HashTableImpl(mm,size) {}
+    KeyLinkHashTable(MemoryManager& mm,U_32 size) : HashTableImpl(mm,size) {}
     virtual ~KeyLinkHashTable() {}
     void*   lookup(KEY* key) const {return HashTableImpl::lookup(key);}
     void    insert(KEY* key,void* value) {HashTableImpl::insert(key,value);}
@@ -226,18 +226,18 @@
     virtual bool equals(void* key1,void* key2) const {
         return ((KEY*)key1)->equals((KEY*)key2);
     }
-    virtual uint32 getHashCode(void* key) const {
+    virtual U_32 getHashCode(void* key) const {
         return ((KEY*)key)->getHashCode();
     }
 };
 
-template<class KEY,uint32 NUM_LINKS>
+template<class KEY,U_32 NUM_LINKS>
 class FixedKeyLinkHashTable : public KeyLinkHashTable<KEY> {
 public:
-    FixedKeyLinkHashTable(MemoryManager& mm,uint32 size) 
+    FixedKeyLinkHashTable(MemoryManager& mm,U_32 size) 
         : KeyLinkHashTable<KEY>(mm,size) {
         freeList = &links[0];
-        for (uint32 i=0; i<NUM_LINKS-1; i++) {
+        for (U_32 i=0; i<NUM_LINKS-1; i++) {
             // initialize 
             links[i].next = &links[i+1];
         }
@@ -301,8 +301,8 @@
     bool    equals(const DoublePtrKey* key) const {
         return (key1 == key->key1 && key2 == key->key2);
     }
-    uint32  getHashCode() const {
-        return ((uint32)(((POINTER_SIZE_INT)key1)>>3) ^ (uint32)(((POINTER_SIZE_INT)key2)>>3));
+    U_32  getHashCode() const {
+        return ((U_32)(((POINTER_SIZE_INT)key1)>>3) ^ (U_32)(((POINTER_SIZE_INT)key2)>>3));
     }
     void* key1;
     void* key2;
@@ -310,7 +310,7 @@
 
 class DoubleKeyHashTable : KeyLinkHashTable<DoublePtrKey> {
 public:
-    DoubleKeyHashTable(MemoryManager& mm,uint32 size) 
+    DoubleKeyHashTable(MemoryManager& mm,U_32 size) 
         : KeyLinkHashTable<DoublePtrKey>(mm,size) {}
     virtual ~DoubleKeyHashTable() {}
     void*   lookup(void* key1,void* key2) const {
@@ -336,44 +336,44 @@
 template <class KEY, class VALUE>
 class HashTable : public HashTableImpl {
 public:
-    HashTable(MemoryManager& mm,uint32 sz) : HashTableImpl(mm,sz) {}
+    HashTable(MemoryManager& mm,U_32 sz) : HashTableImpl(mm,sz) {}
     VALUE* lookup(KEY* key) const {return (VALUE*)HashTableImpl::lookup(key);}
     void   insert(KEY* key, VALUE* value) {HashTableImpl::insert(key,value);}
     void   remove(KEY* key) {HashTableImpl::remove(key);}
 protected:
     virtual bool   keyEquals(KEY* key1, KEY* key2) const = 0;
-    virtual uint32 getKeyHashCode(KEY* key) const = 0;
+    virtual U_32 getKeyHashCode(KEY* key) const = 0;
 private:
     bool   equals(void* key1, void* key2) const {return keyEquals((KEY*)key1,(KEY*)key2);}
-    uint32 getHashCode(void* key) const {return getKeyHashCode((KEY*)key);}
+    U_32 getHashCode(void* key) const {return getKeyHashCode((KEY*)key);}
 };
 
 template <class KEY, class VALUE>
 class ConstHashTable : public HashTableImpl {
 public:
-    ConstHashTable(MemoryManager& mm,uint32 sz) : HashTableImpl(mm,sz) {}
+    ConstHashTable(MemoryManager& mm,U_32 sz) : HashTableImpl(mm,sz) {}
     const VALUE* lookup(const KEY* key) const {return (const VALUE*)HashTableImpl::lookup((void *)key);}
     void   insert(const KEY* key, const VALUE* value) {HashTableImpl::insert((void *)key,(void *)value);}
     void   remove(const KEY* key) {HashTableImpl::remove((void *)key);}
 protected:
     virtual bool   keyEquals(const KEY* key1, const KEY* key2) const = 0;
-    virtual uint32 getKeyHashCode(const KEY* key) const = 0;
+    virtual U_32 getKeyHashCode(const KEY* key) const = 0;
 private:
     bool   equals(void* key1, void* key2) const {return keyEquals((const KEY*)key1,(const KEY*)key2);}
-    uint32 getHashCode(void* key) const {return getKeyHashCode((const KEY*)key);}
+    U_32 getHashCode(void* key) const {return getKeyHashCode((const KEY*)key);}
 };
 
 template <class ELEM_TYPE>
 class PtrHashTable : public HashTable<void,ELEM_TYPE> {
 public:
-    PtrHashTable(MemoryManager& mm,uint32 size) : HashTable<void,ELEM_TYPE>(mm,size) {}
+    PtrHashTable(MemoryManager& mm,U_32 size) : HashTable<void,ELEM_TYPE>(mm,size) {}
 protected:
     virtual bool keyEquals(void* key1,void* key2) const {
         return key1 == key2;
     }
-    virtual uint32 getKeyHashCode(void* key) const {
+    virtual U_32 getKeyHashCode(void* key) const {
         // return hash of address bits
-        return ((uint32)(((POINTER_SIZE_INT)key) >> sizeof(void*)));
+        return ((U_32)(((POINTER_SIZE_INT)key) >> sizeof(void*)));
     }
 };
 

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/LoopTree.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/LoopTree.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/LoopTree.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/LoopTree.cpp Thu May 22 06:33:38 2008
@@ -173,7 +173,7 @@
     backwardMarkNode(header, dom);
     
     //restore traversal nums
-    uint32 fgTraversalNum = loopTree->fg->getTraversalNum();
+    U_32 fgTraversalNum = loopTree->fg->getTraversalNum();
     for (Nodes::const_iterator it = nodesInLoop.begin(), end = nodesInLoop.end(); it!=end; ++it) {
         Node* node = *it;
         assert(node->getTraversalNum() == fgTraversalNum + 1);
@@ -203,7 +203,7 @@
     Node* block = fg->createNode(header->getKind());
     
     if (coalesceCallback!=NULL) {
-        coalesceCallback->coalesce(header, block, (uint32)edges.size());
+        coalesceCallback->coalesce(header, block, (U_32)edges.size());
     }
     //retarget all edges
     for (Edges::const_iterator ite = edges.begin(), ende = edges.end(); ite!=ende; ++ite) {
@@ -257,7 +257,7 @@
     headerMap.clear();
     ((LoopNode*)root)->clear();
 
-    uint32 numBlocks = fg->getNodeCount();
+    U_32 numBlocks = fg->getNodeCount();
     headerMap.resize(numBlocks); 
 
     formLoopHierarchy(headers);
@@ -276,7 +276,7 @@
 
 LoopNode* LoopTree::getLoopNode(const Node* node, bool containingLoop) const {
     assert(isValid());
-    uint32 df = node->getDfNum();
+    U_32 df = node->getDfNum();
     if (df >= headerMap.size()) {
         return NULL; //invalid DF can be caused by unreachable node
     }
@@ -295,7 +295,7 @@
     return header;
 }
 
-uint32 LoopTree::getLoopDepth(const Node* node) const {
+U_32 LoopTree::getLoopDepth(const Node* node) const {
     LoopNode* header = getLoopNode(node, false);
     return header == 0 ? 0 : header->getDepth();
 }

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/LoopTree.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/LoopTree.h?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/LoopTree.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/LoopTree.h Thu May 22 06:33:38 2008
@@ -35,7 +35,7 @@
 class EdgeCoalescerCallback {
 public:
     virtual ~EdgeCoalescerCallback(){};
-    virtual void coalesce(Node* header, Node* newPreHeader, uint32 numEdges) = 0;
+    virtual void coalesce(Node* header, Node* newPreHeader, U_32 numEdges) = 0;
 };
 
 class LoopNode : public TreeNode {
@@ -89,7 +89,7 @@
     
     LoopNode* getLoopNode(const Node* node, bool containingLoop) const;
 
-    uint32 getLoopDepth(const Node* node) const;
+    U_32 getLoopDepth(const Node* node) const;
         
     // true if edge is exit from any loop
     bool isLoopExit(const Edge* e) const;
@@ -98,14 +98,14 @@
     
     bool isValid() const {  return traversalNum > fg->getModificationTraversalNum(); }
 
-    uint32 getTraversalNum() { return traversalNum; }
+    U_32 getTraversalNum() { return traversalNum; }
 
     EdgeCoalescerCallback* getCoalesceCallback() const {return coalesceCallback;}
     void setCoalesceCallback(EdgeCoalescerCallback* callback) {coalesceCallback = callback;}
    
     bool isNormalized() const { return normalized;}
 
-    uint32 getMaxLoopDepth() const {return getHeight()-1;}
+    U_32 getMaxLoopDepth() const {return getHeight()-1;}
 private:
 
     void findLoopHeaders(Nodes& headers);
@@ -117,7 +117,7 @@
 
     MemoryManager& mm;
     ControlFlowGraph* fg;
-    uint32 traversalNum;
+    U_32 traversalNum;
 
     //nodes by dfn
     // loop header by node->dfn. 

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/MapSet.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/MapSet.h?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/MapSet.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/MapSet.h Thu May 22 06:33:38 2008
@@ -66,7 +66,7 @@
     //
     //  Returns number of elements in the set
     //
-    uint32 getSize() const {return (uint32) size();}
+    U_32 getSize() const {return (U_32) size();}
     //
     //  Returns true if set contains the element, false otherwise
     //
@@ -122,7 +122,7 @@
         //
         MemoryManager memManager("MapSet::intersect.memManager");
         KEY * removeList = (KEY *)memManager.alloc(sizeof(KEY) * size());
-        uint32 removeListSize = 0;
+        U_32 removeListSize = 0;
         const_iterator iter = begin(),
                        setend  = end();
         for (; iter != setend; iter++) {
@@ -132,7 +132,7 @@
         //
         //  Remove elements that are in removeList
         //
-        for (uint32 i = 0; i < removeListSize; i++)
+        for (U_32 i = 0; i < removeListSize; i++)
             erase(removeList[i]);
     }
     //

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/MemoryAttribute.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/MemoryAttribute.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/MemoryAttribute.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/shared/MemoryAttribute.cpp Thu May 22 06:33:38 2008
@@ -85,8 +85,8 @@
     //  two stack areas do not overlap
     //
     assert(size != 0 && mc.size != 0);
-    uint32 offset = id.stackOffset;
-    uint32 mcOffset = mc.id.stackOffset;
+    U_32 offset = id.stackOffset;
+    U_32 mcOffset = mc.id.stackOffset;
     return (offset == mcOffset) ||
            (offset > mcOffset && offset < mcOffset + mc.size) ||
            (offset < mcOffset && offset + size > mcOffset);
@@ -117,13 +117,13 @@
 //
 //  Get 32-bit id
 //
-uint32 MemoryAttribute::Context::getId() const {
+U_32 MemoryAttribute::Context::getId() const {
     switch (getIdKind()) {
     case StackId: return id.stackOffset;
     case FieldId: return id.fieldDesc->getId(); 
     case MethodId: return id.methodDesc->getId();
     case CounterId: return id.counterId;
-    case NoId: return (uint32)id.all;
+    case NoId: return (U_32)id.all;
     default:
         assert(0);
     }



Mime
View raw message