harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From mcfi...@apache.org
Subject svn commit: r659108 [13/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/inliner.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/inliner.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/inliner.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/inliner.cpp Thu May 22 06:33:38 2008
@@ -173,10 +173,10 @@
     _usesOptimisticBalancedSync = argSource->getBoolArg("sync_optimistic", false) ? argSource->getBoolArg("sync_optcatch", true) : false;
 }
 
-int32 
-Inliner::computeInlineBenefit(Node* node, MethodDesc& methodDesc, InlineNode* parentInlineNode, uint32 loopDepth) 
+I_32 
+Inliner::computeInlineBenefit(Node* node, MethodDesc& methodDesc, InlineNode* parentInlineNode, U_32 loopDepth) 
 {
-    int32 benefit = 0;
+    I_32 benefit = 0;
 
     if (Log::isEnabled()) {
         Log::out() << "Computing Inline benefit for "
@@ -193,7 +193,7 @@
     //
     // Size impact
     //
-    uint32 size = methodDesc.getByteCodeSize();
+    U_32 size = methodDesc.getByteCodeSize();
     Log::out() << "  size is " << (int) size << ::std::endl;
     if(size < _inlineSmallMaxByteSize) {
         // Large bonus for smallest methods
@@ -255,7 +255,7 @@
         assert(call->getNumSrcOperands() >= 2);
         assert(call->getSrc(0)->getType()->tag == Type::Tau);
         assert(call->getSrc(1)->getType()->tag == Type::Tau);
-        for(uint32 i = 2; i < call->getNumSrcOperands(); ++i) {
+        for(U_32 i = 2; i < call->getNumSrcOperands(); ++i) {
             Opnd* arg = call->getSrc(i);
             assert(arg->getType()->tag != Type::Tau);
             if(arg->getInst()->isConst()) {
@@ -290,7 +290,7 @@
         // Remove any loop bonus as this is already accounted for in block count
         benefit -= _inlineLoopBonus*loopDepth;
         // Scale by call site 'hotness'.
-        benefit = (uint32) ((double) benefit * scale);
+        benefit = (U_32) ((double) benefit * scale);
 
         Log::out() << "  HeatThreshold=" << heatThreshold
                                << ", nodeCount=" << nodeCount
@@ -315,18 +315,18 @@
 protected:
     bool leaf;
 
-    void offset(uint32 offset) {};
-    void offset_done(uint32 offset) {};
+    void offset(U_32 offset) {};
+    void offset_done(U_32 offset) {};
     void nop()  {}
     void aconst_null()  {}
-    void iconst(int32)  {}
+    void iconst(I_32)  {}
     void lconst(int64)  {}
     void fconst(float)  {}
     void dconst(double)  {}
     void bipush(int8)  {}
     void sipush(int16)  {}
-    void ldc(uint32)  {}
-    void ldc2(uint32)  {}
+    void ldc(U_32)  {}
+    void ldc2(U_32)  {}
     void iload(uint16 varIndex)  {}
     void lload(uint16 varIndex)  {}
     void fload(uint16 varIndex)  {}
@@ -340,11 +340,11 @@
     void baload()  {}
     void caload()  {}
     void saload()  {}
-    void istore(uint16 varIndex,uint32 off)  {}
-    void lstore(uint16 varIndex,uint32 off)  {}
-    void fstore(uint16 varIndex,uint32 off)  {}
-    void dstore(uint16 varIndex,uint32 off)  {}
-    void astore(uint16 varIndex,uint32 off)  {}
+    void istore(uint16 varIndex,U_32 off)  {}
+    void lstore(uint16 varIndex,U_32 off)  {}
+    void fstore(uint16 varIndex,U_32 off)  {}
+    void dstore(uint16 varIndex,U_32 off)  {}
+    void astore(uint16 varIndex,U_32 off)  {}
     void iastore()  {}
     void lastore()  {}
     void fastore()  {}
@@ -398,7 +398,7 @@
     void lor()  {}
     void ixor()  {}
     void lxor()  {}
-    void iinc(uint16 varIndex,int32 amount)  {}
+    void iinc(uint16 varIndex,I_32 amount)  {}
     void i2l()  {}
     void i2f()  {}
     void i2d()  {}
@@ -419,56 +419,56 @@
     void fcmpg()  {}
     void dcmpl()  {}
     void dcmpg()  {}
-    void ifeq(uint32 targetOffset,uint32 nextOffset)  {}
-    void ifne(uint32 targetOffset,uint32 nextOffset)  {}
-    void iflt(uint32 targetOffset,uint32 nextOffset)  {}
-    void ifge(uint32 targetOffset,uint32 nextOffset)  {}
-    void ifgt(uint32 targetOffset,uint32 nextOffset)  {}
-    void ifle(uint32 targetOffset,uint32 nextOffset)  {}
-    void if_icmpeq(uint32 targetOffset,uint32 nextOffset)  {}
-    void if_icmpne(uint32 targetOffset,uint32 nextOffset)  {}
-    void if_icmplt(uint32 targetOffset,uint32 nextOffset)  {}
-    void if_icmpge(uint32 targetOffset,uint32 nextOffset)  {}
-    void if_icmpgt(uint32 targetOffset,uint32 nextOffset)  {}
-    void if_icmple(uint32 targetOffset,uint32 nextOffset)  {}
-    void if_acmpeq(uint32 targetOffset,uint32 nextOffset)  {}
-    void if_acmpne(uint32 targetOffset,uint32 nextOffset)  {}
-    void goto_(uint32 targetOffset,uint32 nextOffset)  {}
-    void jsr(uint32 offset, uint32 nextOffset)  {}
+    void ifeq(U_32 targetOffset,U_32 nextOffset)  {}
+    void ifne(U_32 targetOffset,U_32 nextOffset)  {}
+    void iflt(U_32 targetOffset,U_32 nextOffset)  {}
+    void ifge(U_32 targetOffset,U_32 nextOffset)  {}
+    void ifgt(U_32 targetOffset,U_32 nextOffset)  {}
+    void ifle(U_32 targetOffset,U_32 nextOffset)  {}
+    void if_icmpeq(U_32 targetOffset,U_32 nextOffset)  {}
+    void if_icmpne(U_32 targetOffset,U_32 nextOffset)  {}
+    void if_icmplt(U_32 targetOffset,U_32 nextOffset)  {}
+    void if_icmpge(U_32 targetOffset,U_32 nextOffset)  {}
+    void if_icmpgt(U_32 targetOffset,U_32 nextOffset)  {}
+    void if_icmple(U_32 targetOffset,U_32 nextOffset)  {}
+    void if_acmpeq(U_32 targetOffset,U_32 nextOffset)  {}
+    void if_acmpne(U_32 targetOffset,U_32 nextOffset)  {}
+    void goto_(U_32 targetOffset,U_32 nextOffset)  {}
+    void jsr(U_32 offset, U_32 nextOffset)  {}
     void ret(uint16 varIndex,const uint8* byteCodes)  {}
     void tableswitch(JavaSwitchTargetsIter*)  {}
     void lookupswitch(JavaLookupSwitchTargetsIter*)  {}
-    void ireturn(uint32 off)  {}
-    void lreturn(uint32 off)  {}
-    void freturn(uint32 off)  {}
-    void dreturn(uint32 off)  {}
-    void areturn(uint32 off)  {}
-    void return_(uint32 off)  {}
-    void getstatic(uint32 constPoolIndex)  {}
-    void putstatic(uint32 constPoolIndex)  {}
-    void getfield(uint32 constPoolIndex)  {}
-    void putfield(uint32 constPoolIndex)  {}
-    void invokevirtual(uint32 constPoolIndex)  { leaf = false; }
-    void invokespecial(uint32 constPoolIndex)  { leaf = false; }
-    void invokestatic(uint32 constPoolIndex)  { leaf = false; }
-    void invokeinterface(uint32 constPoolIndex,uint32 count)  { leaf = false; }
-    void new_(uint32 constPoolIndex)  {}
+    void ireturn(U_32 off)  {}
+    void lreturn(U_32 off)  {}
+    void freturn(U_32 off)  {}
+    void dreturn(U_32 off)  {}
+    void areturn(U_32 off)  {}
+    void return_(U_32 off)  {}
+    void getstatic(U_32 constPoolIndex)  {}
+    void putstatic(U_32 constPoolIndex)  {}
+    void getfield(U_32 constPoolIndex)  {}
+    void putfield(U_32 constPoolIndex)  {}
+    void invokevirtual(U_32 constPoolIndex)  { leaf = false; }
+    void invokespecial(U_32 constPoolIndex)  { leaf = false; }
+    void invokestatic(U_32 constPoolIndex)  { leaf = false; }
+    void invokeinterface(U_32 constPoolIndex,U_32 count)  { leaf = false; }
+    void new_(U_32 constPoolIndex)  {}
     void newarray(uint8 type)  {}
-    void anewarray(uint32 constPoolIndex)  {}
+    void anewarray(U_32 constPoolIndex)  {}
     void arraylength()  {}
     void athrow()  {}
-    void checkcast(uint32 constPoolIndex)  {}
-    int  instanceof(const uint8* bcp, uint32 constPoolIndex, uint32 off)  {return 3;}
+    void checkcast(U_32 constPoolIndex)  {}
+    int  instanceof(const uint8* bcp, U_32 constPoolIndex, U_32 off)  {return 3;}
     void monitorenter()  {}
     void monitorexit()  {}
-    void multianewarray(uint32 constPoolIndex,uint8 dimensions)  {}
-    void ifnull(uint32 targetOffset,uint32 nextOffset)  {}
-    void ifnonnull(uint32 targetOffset,uint32 nextOffset) {}
+    void multianewarray(U_32 constPoolIndex,uint8 dimensions)  {}
+    void ifnull(U_32 targetOffset,U_32 nextOffset)  {}
+    void ifnonnull(U_32 targetOffset,U_32 nextOffset) {}
 };
 
 bool
 Inliner::isLeafMethod(MethodDesc& methodDesc) {
-    uint32 size = methodDesc.getByteCodeSize();
+    U_32 size = methodDesc.getByteCodeSize();
     const U_8* bytecodes = methodDesc.getByteCodes();
     ByteCodeParser parser(bytecodes,size);
     JavaByteCodeLeafSearchCallback leafTester;
@@ -559,7 +559,7 @@
 
 
     // Fuse callsite arguments with incoming parameters
-    uint32 numArgs = callInst->getNumSrcOperands() - 2; // omit taus
+    U_32 numArgs = callInst->getNumSrcOperands() - 2; // omit taus
     Opnd *tauNullChecked = callInst->getSrc(0);
     Opnd *tauTypesChecked = callInst->getSrc(1);
     assert(tauNullChecked->getType()->tag == Type::Tau);
@@ -577,7 +577,7 @@
     Inst* first = (Inst*)entry->getFirstInst();
     Inst* inst;
     Opnd* thisPtr = 0;
-    uint32 j;
+    U_32 j;
     for(j = 0, inst = first->getNextInst(); j < numArgs && inst != NULL;) {
         switch (inst->getOpcode()) {
         case Op_DefArg:
@@ -608,7 +608,7 @@
                 Opnd* src = inst->getSrc(0);
                 if (tauTypesChecked->getInst()->getOpcode() != Op_TauUnsafe) {
                     // it's worth substituting the tau
-                    for (uint32 i=0; i<numArgs; ++i) {
+                    for (U_32 i=0; i<numArgs; ++i) {
                         if (src == callInst->getSrc(i+2)) {
                             // it is a parameter
                             Opnd* dst = inst->getDst();
@@ -655,7 +655,7 @@
         assert(retNode != NULL);
         bool isSsa = inlinedIRM.getInSsa();
         Opnd** phiArgs = isSsa ? new (_toplevelIRM.getMemoryManager()) Opnd*[retNode->getInDegree()] : NULL;
-        uint32 phiCount = 0;
+        U_32 phiCount = 0;
         const Edges& inEdges = retNode->getInEdges();
         Edges::const_iterator eiter;
         for(eiter = inEdges.begin(); eiter != inEdges.end(); ++eiter) {
@@ -906,7 +906,7 @@
     InlineNode* inlineParentNode = 0;
     MethodCallInst* call = 0;
     MethodDesc* methodDesc = 0;
-    uint32 newByteSize = 0;
+    U_32 newByteSize = 0;
     
     //
     // Search priority queue for next inline candidate
@@ -924,7 +924,7 @@
 
         // If candidate would cause top level method to exceed size threshold, throw away.
         
-        uint32 methodByteSize = methodDesc->getByteCodeSize();
+        U_32 methodByteSize = methodDesc->getByteCodeSize();
         methodByteSize = (methodByteSize <= CALL_COST) ? 1 : methodByteSize-CALL_COST;
         newByteSize = _currentByteSize + methodByteSize;
         double factor = ((double) newByteSize) / ((double) _initByteSize);
@@ -968,9 +968,9 @@
     inlineCC.setHIRManager(inlinedIRM);
     
     //prepare type info
-    uint32 nArgs = call->getNumSrcOperands() - 2;
+    U_32 nArgs = call->getNumSrcOperands() - 2;
     Type** types = new (_tmpMM)Type*[nArgs];
-    for (uint32 i = 0; i < nArgs; i++) {
+    for (U_32 i = 0; i < nArgs; i++) {
         types[i] = call->getSrc(i + 2)->getType();
     }
 
@@ -1001,8 +1001,8 @@
 
             Log::out() << "Considering inlining instruction I" << (int)call->getId() << ::std::endl;
             if (usePriorityQueue && canInlineInto(*methodDesc)) {
-                uint32 size = methodDesc->getByteCodeSize();
-                int32 benefit = computeInlineBenefit(node, *methodDesc, inlineNode, ltree->getLoopDepth(node));
+                U_32 size = methodDesc->getByteCodeSize();
+                I_32 benefit = computeInlineBenefit(node, *methodDesc, inlineNode, ltree->getLoopDepth(node));
                 assert(size > 0);
                 Log::out() << "Inline benefit " << methodDesc->getParentType()->getName() << "." << methodDesc->getName() << " == " << (int) benefit << ::std::endl;
                 if(0 < size && benefit > _minBenefitThreshold) {
@@ -1103,7 +1103,7 @@
 
 
 
-uint32
+U_32
 InlineTree::computeCheckSum(InlineNode* node) {
     if(node == NULL)
         return 0;
@@ -1119,7 +1119,7 @@
     sum += hash(desc.getName());
     sum += computeCheckSum(node->getSiblings());
     sum += computeCheckSum(node->getChild());
-    return (uint32) sum;
+    return (U_32) sum;
 }
 
 void Inliner::runInlinerPipeline(CompilationContext& inlineCC, const char* pipeName) {

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/inliner.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/inliner.h?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/inliner.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/inliner.h Thu May 22 06:33:38 2008
@@ -49,11 +49,11 @@
 
 class InliningContext {
 public:
-    InliningContext(uint32 _nArgs, Type** _argTypes) : nArgs(_nArgs), argTypes(_argTypes) {}
-    uint32 getNumArgs() const {return nArgs;}
+    InliningContext(U_32 _nArgs, Type** _argTypes) : nArgs(_nArgs), argTypes(_argTypes) {}
+    U_32 getNumArgs() const {return nArgs;}
     Type** getArgTypes() const {return argTypes;}
 private:
-    uint32 nArgs;
+    U_32 nArgs;
     Type** argTypes;
 };
 
@@ -82,9 +82,9 @@
     }
     InlineNode *getRoot() { return (InlineNode*)root; }
 
-    uint32 computeCheckSum() { return computeCheckSum(getRoot()); }
+    U_32 computeCheckSum() { return computeCheckSum(getRoot()); }
 private:
-    uint32 computeCheckSum(InlineNode* node);
+    U_32 computeCheckSum(InlineNode* node);
 };
 
 class Inliner
@@ -132,9 +132,9 @@
 
     class CallSite {
     public:
-        CallSite(int32 benefit, Node* callNode, InlineNode* inlineNode) : benefit(benefit), callNode(callNode), inlineNode(inlineNode) {}
+        CallSite(I_32 benefit, Node* callNode, InlineNode* inlineNode) : benefit(benefit), callNode(callNode), inlineNode(inlineNode) {}
 
-        int32 benefit;
+        I_32 benefit;
         Node* callNode;
         InlineNode* inlineNode;
     };
@@ -159,7 +159,7 @@
 
     bool isLeafMethod(MethodDesc& methodDesc);
 
-    int32 computeInlineBenefit(Node* node, MethodDesc& methodDesc, InlineNode* parentInlineNode, uint32 loopDepth);
+    I_32 computeInlineBenefit(Node* node, MethodDesc& methodDesc, InlineNode* parentInlineNode, U_32 loopDepth);
 
     MemoryManager& _tmpMM;
     IRManager& _toplevelIRM;
@@ -170,8 +170,8 @@
     bool _hasProfileInfo;
     
     StlPriorityQueue<CallSite, StlVector<CallSite>, CallSiteCompare> _inlineCandidates;
-    uint32 _initByteSize;
-    uint32 _currentByteSize;
+    U_32 _initByteSize;
+    U_32 _currentByteSize;
 
     InlineTree _inlineTree;
 
@@ -179,26 +179,26 @@
     bool _useInliningTranslator;
 
     double _maxInlineGrowthFactor;
-    uint32 _minInlineStop;
-    int32 _minBenefitThreshold;
+    U_32 _minInlineStop;
+    I_32 _minBenefitThreshold;
     
-    uint32 _inlineSmallMaxByteSize;
-    int32 _inlineSmallBonus;
+    U_32 _inlineSmallMaxByteSize;
+    I_32 _inlineSmallBonus;
     
-    uint32 _inlineMediumMaxByteSize;
-    int32 _inlineMediumBonus;
+    U_32 _inlineMediumMaxByteSize;
+    I_32 _inlineMediumBonus;
 
-    uint32 _inlineLargeMinByteSize;
-    int32 _inlineLargePenalty;
+    U_32 _inlineLargeMinByteSize;
+    I_32 _inlineLargePenalty;
 
-    int32 _inlineLoopBonus;
-    int32 _inlineLeafBonus;
-    int32 _inlineSynchBonus;
-    int32 _inlineRecursionPenalty;
-    int32 _inlineExactArgBonus;
-    int32 _inlineExactAllBonus;
+    I_32 _inlineLoopBonus;
+    I_32 _inlineLeafBonus;
+    I_32 _inlineSynchBonus;
+    I_32 _inlineRecursionPenalty;
+    I_32 _inlineExactArgBonus;
+    I_32 _inlineExactAllBonus;
 
-    uint32 _inlineMaxNodeThreshold;
+    U_32 _inlineMaxNodeThreshold;
 
     bool _inlineSkipExceptionPath;
     bool _inlineSkipApiMagicMethods;

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/irmanager.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/irmanager.h?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/irmanager.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/irmanager.h Thu May 22 06:33:38 2008
@@ -154,7 +154,7 @@
     void            setCriticalEdgesSplit() {_lastCriticalEdgeSplitTraversalNum = _flowGraph.getModificationTraversalNum();}
 
     // The minimum Instruction Id in this region.
-    uint32          getMinimumInstId() { return _minRegionInstId; }
+    U_32          getMinimumInstId() { return _minRegionInstId; }
 
     // The DPGO threshold for hotness - blocks with a execution count 
     // greater than this threshold should be considered hot
@@ -193,9 +193,9 @@
     const char*      _inlineOptPath;
     GCBasePointerMap _gcBasePointerMap;
     bool             _inSsa;
-    uint32           _lastSsaFixupTraversalNum;
-    uint32           _lastCriticalEdgeSplitTraversalNum;
-    uint32           _minRegionInstId;
+    U_32           _lastSsaFixupTraversalNum;
+    U_32           _lastCriticalEdgeSplitTraversalNum;
+    U_32           _minRegionInstId;
     double           _heatThreshold;
     bool             _abort;
 

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/lazyexceptionopt.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/lazyexceptionopt.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/lazyexceptionopt.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/lazyexceptionopt.cpp Thu May 22 06:33:38 2008
@@ -77,7 +77,7 @@
 #endif
 
     level++;
-    uint32 opndId = 0;
+    U_32 opndId = 0;
     isArgCheckNull = false;
     isExceptionInit = md.isInstanceInitializer() && 
             md.getParentType()->isLikelyExceptionType();
@@ -161,8 +161,8 @@
         Inst *headInst = (Inst*)node->getFirstInst();
         Opnd* opnd;
         for (Inst* inst=headInst->getNextInst();inst!=NULL;inst=inst->getNextInst()) {
-            uint32 nsrc = inst->getNumSrcOperands();
-            for (uint32 i=0; i<nsrc; i++) {
+            U_32 nsrc = inst->getNumSrcOperands();
+            for (U_32 i=0; i<nsrc; i++) {
                 if (!(opnd=inst->getSrc(i))->isSsaOpnd())  // check ssa operands
                     continue;
                 if (excOpnds.getBit(opndId=opnd->getId())==0) 
@@ -231,7 +231,7 @@
  *         <code>false<code> if an exception object cannot be optimized.
  */
 bool 
-LazyExceptionOpt::addOptCandidates(uint32 id, Inst* inst) {
+LazyExceptionOpt::addOptCandidates(U_32 id, Inst* inst) {
     OptCandidate* oc = NULL;
     ThrowInsts* thrinst = NULL;
     OptCandidates::iterator it;
@@ -286,7 +286,7 @@
                 inst->print(Log::out()); Log::out()  << std::endl;
             }
 #endif
-            uint32 nii_id=((Inst*)(inst->getNode()->getUnconditionalEdgeTarget()->getFirstInst()))->getId();
+            U_32 nii_id=((Inst*)(inst->getNode()->getUnconditionalEdgeTarget()->getFirstInst()))->getId();
             ThrowInsts::iterator it1;
             for (it1 = oc->throwInsts->begin(); it1 !=oc->throwInsts->end(); it1++) {
                 if ((*it1)->getId() != nii_id) {
@@ -449,7 +449,7 @@
     MethodCallInst* iinst;
     Inst* tinst;
     Inst* tlinst;
-    uint32 opcount;
+    U_32 opcount;
     Opnd **opnds = NULL;
 
     if (optCandidates == NULL) {
@@ -496,7 +496,7 @@
             if (opcount >0) {
                 opnds = new (leMemManager) Opnd*[opcount];   //local mem should be used
                 opnds[0] = mpt;
-                for (uint32 i = 0; i < opcount-1; i++)
+                for (U_32 i = 0; i < opcount-1; i++)
                     opnds[i+1] = iinst->getSrc(i+3);
             }
             Inst* mptinst = irManager.getInstFactory().makeLdFunAddr(mpt,iinst->getMethodDesc());
@@ -597,11 +597,11 @@
 
 void 
 LazyExceptionOpt::printInst1(::std::ostream& os, Inst* inst, std::string txt) {
-    uint32 nsrc = inst->getNumSrcOperands();
+    U_32 nsrc = inst->getNumSrcOperands();
     os << txt;
     inst->print(os);
     os << std::endl;
-    for (uint32 i=0; i<nsrc; i++) {
+    for (U_32 i=0; i<nsrc; i++) {
         printInst1(os, inst->getSrc(i)->getInst(),txt+"  ");
     }
 
@@ -615,7 +615,7 @@
  */
 bool 
 LazyExceptionOpt::methodCallHasSideEffect(Inst* inst) {
-    uint32 opcode = inst->getOpcode();
+    U_32 opcode = inst->getOpcode();
     MethodDesc* cmd = NULL;
     Method_Side_Effects mse = MSE_Unknown;
 
@@ -739,7 +739,7 @@
     }
 
     if (mse == MSE_True_Null_Param) {
-        uint32 nsrc=inst->getNumSrcOperands();
+        U_32 nsrc=inst->getNumSrcOperands();
         bool mayBeNull;
         if (nsrc>3) {
 #ifdef _DEBUG
@@ -749,7 +749,7 @@
             }
 #endif
             mayBeNull=false;
-            for (uint32 i=3; i<nsrc; i++) {
+            for (U_32 i=3; i<nsrc; i++) {
                 if (inst->getSrc(i)->getType()->isReference()) {
                     if (mayBeNullArg(inst,i))
                         mayBeNull=true;
@@ -758,7 +758,7 @@
             if (!mayBeNull)
                 return false;
 #ifdef _DEBUG
-            for (uint32 i=0; i<nsrc; i++) {
+            for (U_32 i=0; i<nsrc; i++) {
                 if (Log::isEnabled()) {
                     Log::out() << "        "<<i<<" isRef: "<<
                     inst->getSrc(i)->getType()->isReference()<<" "; 
@@ -789,7 +789,7 @@
  *         <code>false<code> if a callee method argument is not null
  */
 bool 
-LazyExceptionOpt::mayBeNullArg(Inst* call_inst, uint32 arg_n) {
+LazyExceptionOpt::mayBeNullArg(Inst* call_inst, U_32 arg_n) {
     Opnd* arg_opnd = call_inst->getSrc(arg_n);
     Inst* inst=arg_opnd->getInst();
 

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/lazyexceptionopt.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/lazyexceptionopt.h?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/lazyexceptionopt.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/lazyexceptionopt.h Thu May 22 06:33:38 2008
@@ -66,7 +66,7 @@
  * @return <code>true</code> if an information is added; 
  *         <code>false<code> if an exception object cannot be optimized.
  */
-    bool addOptCandidates(uint32 id, Inst* inst);
+    bool addOptCandidates(U_32 id, Inst* inst);
 
 /**
  * Checks if there is a side effect between throw_inst and init_inst instructions.
@@ -146,7 +146,7 @@
  * @return <code>true</code> if a callee method argument may be null
  *         <code>false<code> if a callee method argument is not null
  */
-    bool mayBeNullArg(Inst* call_inst, uint32 arg_n);
+    bool mayBeNullArg(Inst* call_inst, U_32 arg_n);
 
 private:
     /// IR manager recieved by lazyexc optpass.
@@ -165,7 +165,7 @@
     typedef StlList<Inst*> ThrowInsts; 
     /// Information about throwable object used in an optimized method.
     struct OptCandidate {
-        uint32 opndId;
+        U_32 opndId;
         Inst* objInst;
         Inst* initInst;
         ThrowInsts* throwInsts;

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/loop_unroll.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/loop_unroll.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/loop_unroll.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/loop_unroll.cpp Thu May 22 06:33:38 2008
@@ -122,9 +122,9 @@
     bool isDOL() const {return type == DEF_OUT_OF_LOOP;}
     bool isUndefined() const {return type == UNDEF;}
     int getConst() const {assert(getType()==LD_CONST); return val;}
-    void setConst(int32 v) {assert(getType()==LD_CONST); val=v;}
+    void setConst(I_32 v) {assert(getType()==LD_CONST); val=v;}
     int getIncrement() const {assert(getType()==COUNTER); return val;}
-    void setIncrement(int32 v) {assert(getType()==COUNTER); val=v;}
+    void setIncrement(I_32 v) {assert(getType()==COUNTER); val=v;}
     bool isPhiSplit() const {return phiSplit;}
     void markPhiSplit() {assert(isCounter()); phiSplit = true;}
     
@@ -624,7 +624,7 @@
     Node* origCheckNode = info->branchInst->getNode();
     Edge* origLoopExitEdge = info->branchTargetIsExit ? origCheckNode->getTrueEdge() : origCheckNode->getFalseEdge();
     
-    uint32 maxNodeId = cfg.getMaxNodeId()+1; //+1 for a split check node
+    U_32 maxNodeId = cfg.getMaxNodeId()+1; //+1 for a split check node
     StlBitVector nodesInLoop(mm, maxNodeId);
     {
         const Nodes& loopNodes = loopNode->getNodesInLoop();
@@ -639,7 +639,7 @@
     BitSet aFlags(mm, maxNodeId);
     calculateReachableNodesInLoop(loopNode, origHeader, origCheckNode, aFlags);
     StlBitVector bodyANodes(mm, maxNodeId);
-    for (uint32 i=0;i<maxNodeId;i++) bodyANodes.setBit(i, aFlags.getBit(i));
+    for (U_32 i=0;i<maxNodeId;i++) bodyANodes.setBit(i, aFlags.getBit(i));
     
     //STEP 2: make checkNode a separate node, prepare loop region
     bodyANodes.setBit(origCheckNode->getId(), true);
@@ -668,7 +668,7 @@
         // while duplicating a region new nodes could be created and 'nodesInRegion' bitvector param is updated. 
         // BodyA is part of the loop -> if new nodes were created in the loop we must track them.
         nodesInLoop.resize(bodyANodes.size());
-        for (uint32 i=0;i<bodyANodes.size();i++) nodesInLoop.setBit(i, bodyANodes.getBit(i) || nodesInLoop.getBit(i));
+        for (U_32 i=0;i<bodyANodes.size();i++) nodesInLoop.setBit(i, bodyANodes.getBit(i) || nodesInLoop.getBit(i));
 
         Node* bodyA2PreCheckNode = nodeRenameTable.getMapping(preCheckNode);
         assert(bodyA2PreCheckNode->getOutDegree()==1 && bodyA2PreCheckNode->getUnconditionalEdgeTarget() == checkNode);

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/memoryopt.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/memoryopt.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/memoryopt.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/memoryopt.cpp Thu May 22 06:33:38 2008
@@ -97,7 +97,7 @@
 {
     assert(aliasManager);
 
-    uint32 numNodes = df0.getNumNodes();
+    U_32 numNodes = df0.getNumNodes();
     aliasDefSites = new (mm) AliasDefSites(mm, numNodes);
     memPhiSites = new (mm) MemPhiSites(mm, numNodes);
     renameMap = new (mm) AliasRenameMap(mm, aliasManager,
@@ -1825,7 +1825,7 @@
 // a ScopedDomNodeInstWalker, to be applied forwards/pre-order
 class MemoryRenameWalker {
     MemoryOpt *thePass;
-    uint32 timeCount;
+    U_32 timeCount;
 public:
     MemoryRenameWalker(MemoryOpt *thePass0) :
         thePass(thePass0), timeCount(1)
@@ -2248,7 +2248,7 @@
 
 void AliasRenameMap::insert(const AliasRep &rep, Inst *defInst)
 {
-    uint32 timeNow = ++timeCount;
+    U_32 timeNow = ++timeCount;
     AliasBinding newBinding(defInst, timeNow);
 
     if (Log::isEnabled()) {
@@ -2299,7 +2299,7 @@
     // rep and its ancestors which has been set
     AliasBinding bestFound = defMap.lookup(rep);
     Inst *bestInst = bestFound.inst;
-    uint32 bestWhen = bestInst ? bestFound.when : 0;
+    U_32 bestWhen = bestInst ? bestFound.when : 0;
     {    
         
         if (!bestInst) {
@@ -2337,7 +2337,7 @@
             AliasBinding newFound = defMap.lookup(thisAncestor);
             Inst *thisInst = newFound.inst;
             if (thisInst) {
-                uint32 thisWhen = newFound.when;
+                U_32 thisWhen = newFound.when;
                 if (Log::isEnabled()) {
                     Log::out() << "    ";
                     thisAncestor.print(Log::out());
@@ -2380,7 +2380,7 @@
             const AliasRep &desc = *descIter;
             const AliasBinding &descBinding = defMap.lookup(desc);
             Inst *desci = descBinding.inst;
-            uint32 when = descBinding.when;
+            U_32 when = descBinding.when;
             if (when > bestWhen) {             // descendant is newer
                 defs.insert(desci);
             }

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/memoryoptrep.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/memoryoptrep.h?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/memoryoptrep.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/memoryoptrep.h Thu May 22 06:33:38 2008
@@ -131,7 +131,7 @@
 public:
     typedef StlVector<AliasRep> AliasList;
 private:
-    uint32 numAliasReps;
+    U_32 numAliasReps;
     AliasList allAliasReps;
     typedef StlHashMap<AliasRep, StlVectorSet<AliasRep> *> AliasRep2AliasReps;
     AliasRep2AliasReps canon2others;
@@ -206,10 +206,10 @@
 
 class AliasDefSites : public StlHashMap<AliasRep, VarDefSites *> {
     MemoryManager &mm;
-    uint32 numNodes;
+    U_32 numNodes;
 public:
     typedef StlHashMap<AliasRep, VarDefSites *> BaseType;
-    AliasDefSites(MemoryManager &m, uint32 n): BaseType(m), mm(m), numNodes(n) {};
+    AliasDefSites(MemoryManager &m, U_32 n): BaseType(m), mm(m), numNodes(n) {};
     void addAliasDefSite(const AliasRep &rep, Node* node) {
         VarDefSites* aliasSites = (*this)[rep];
         if (!aliasSites) {
@@ -256,8 +256,8 @@
 
 struct AliasBinding {
     Inst *inst;
-    uint32 when;
-    AliasBinding(Inst *inst0=0, uint32 when0=0) : inst(inst0), when(when0) {};
+    U_32 when;
+    AliasBinding(Inst *inst0=0, U_32 when0=0) : inst(inst0), when(when0) {};
 };
 
 bool operator !=(const AliasBinding &a, const AliasBinding &b) {
@@ -266,13 +266,13 @@
     
 class DescendentSet : public StlVectorSet<AliasRep> {
 public:
-    DescendentSet(MemoryManager &m, uint32 depth0) : StlVectorSet<AliasRep>(m), depth(depth0) {};
-    DescendentSet(MemoryManager &m, DescendentSet *other, uint32 depth0)
+    DescendentSet(MemoryManager &m, U_32 depth0) : StlVectorSet<AliasRep>(m), depth(depth0) {};
+    DescendentSet(MemoryManager &m, DescendentSet *other, U_32 depth0)
         : StlVectorSet<AliasRep>(m), depth(depth0)
     {
         insert(other->begin(), other->end());
     }
-    uint32 depth;
+    U_32 depth;
 };
 
 class AliasRenameMap {
@@ -280,8 +280,8 @@
     typedef SparseScopedMap<AliasRep, DescendentSet *> DescendentMap;
     DefMap defMap;
     DescendentMap activeDescendents;
-    uint32 depth;
-    uint32 timeCount;
+    U_32 depth;
+    U_32 timeCount;
     AliasManager *aliasManager;
     MemoryManager &mm;
 public:

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/multiplybyconstant.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/multiplybyconstant.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/multiplybyconstant.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/multiplybyconstant.cpp Thu May 22 06:33:38 2008
@@ -360,7 +360,7 @@
                 assert(ip<len); 
                 int val = data[ip]; ip += 1;
                 Opnd *op = (width32 
-                            ? simp->genLdConstant((int32)(val))->getDst()
+                            ? simp->genLdConstant((I_32)(val))->getDst()
                             : simp->genLdConstant((int64)(val))->getDst());
                 thestack[sp] = op;
                 sp += 1;
@@ -382,7 +382,7 @@
                 assert(ip<len);
                 int val = data[ip]; ip += 1;
                 assert(val <= SMALL_SHIFT_MAXBITS);
-                Opnd *op = simp->genLdConstant((int32)(val))->getDst();
+                Opnd *op = simp->genLdConstant((I_32)(val))->getDst();
                 thestack[sp-2] = simp->genShladd(type, thestack[sp-2], op, thestack[sp-1])->getDst(); 
                 sp -=1; } break;
             case MulOp::neg: assert(sp >= 1); 
@@ -392,7 +392,7 @@
                 assert(sp >= 1); 
                 assert(ip<len);
                 int val = data[ip]; ip += 1;
-                Opnd *op = simp->genLdConstant((int32)(val))->getDst();
+                Opnd *op = simp->genLdConstant((I_32)(val))->getDst();
                 thestack[sp-1] = simp->genShl(type, ShiftMask_None,
                                               thestack[sp-1], op)->getDst();
             } break;
@@ -1005,11 +1005,11 @@
 
 #else // !STANDALONE_TEST
 Opnd *
-Simplifier::planMul32(int32 multiplier, Opnd *opnd)
+Simplifier::planMul32(I_32 multiplier, Opnd *opnd)
 {
     const OptimizerFlags& optimizerFlags = irManager.getOptimizerFlags();
     MulMethod method(!optimizerFlags.ia32_code_gen);
-    planMul<int32, 32>(method, multiplier, 1);
+    planMul<I_32, 32>(method, multiplier, 1);
     if (Log::isEnabled()) {
         Log::out() << "in multiply(" << (int) multiplier << ", ";
         opnd->print(Log::out());

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/opndmap.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/opndmap.h?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/opndmap.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/opndmap.h Thu May 22 06:33:38 2008
@@ -38,8 +38,8 @@
     // priorValues has previous value for each non-0 elt in theList:
     StlVector<ToType> priorValues;
     FromType zero;
-    uint32 resize_when;
-    uint32 resize_by;
+    U_32 resize_when;
+    U_32 resize_by;
 public:
     SparseScopedMap(MemoryManager& mm) :
         theMap(mm), 
@@ -51,9 +51,9 @@
     {};
     SparseScopedMap(size_t n,  
                     MemoryManager& mm,
-                    uint32 init_factor=1,
-                    uint32 resize_factor=4,
-                    uint32 resize_to=7) :
+                    U_32 init_factor=1,
+                    U_32 resize_factor=4,
+                    U_32 resize_to=7) :
         theMap(mm), 
         theList(mm),
         priorValues(mm),
@@ -106,7 +106,7 @@
     SparseOpndMap(MemoryManager& mm) :
         SparseScopedMap<Opnd *, Opnd *>(mm) {};
     SparseOpndMap(size_t n, MemoryManager& mm,
-                  uint32 init_factor, uint32 resize_factor, uint32 resize_to) :
+                  U_32 init_factor, U_32 resize_factor, U_32 resize_to) :
         SparseScopedMap<Opnd *, Opnd *>(n, mm, init_factor, resize_factor,
                                         resize_to) {};
 };

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/optarithmetic.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/optarithmetic.h?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/optarithmetic.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/optarithmetic.h Thu May 22 06:33:38 2008
@@ -34,10 +34,10 @@
 template <typename inttype, int width> inline int popcount(inttype x);
 template <>
 inline
-int popcount<int32, 32> (int32 x)
+int popcount<I_32, 32> (I_32 x)
 {
 #ifdef _USE_ITANIUM_INTRINSICS_
-    uint32 y = x; // avoid sign extension
+    U_32 y = x; // avoid sign extension
     __m64 z = _m_from_int(int(y));
     __m64 r = __m64_popcnt(z);
     return _m_to_int(r);
@@ -156,7 +156,7 @@
 
 template <>
 inline
-int32 leftmost1<int32>(int32 x)
+I_32 leftmost1<I_32>(I_32 x)
 {
     if (x == 1) return 1;
     if (x == 0) return 0;
@@ -194,14 +194,14 @@
 
 template <>
 inline
-int nlz<int32, 32>(int32 x)
+int nlz<I_32, 32>(I_32 x)
 {
     x = x | (x >> 1);
     x = x | (x >> 2);
     x = x | (x >> 4);
     x = x | (x >> 8);
     x = x | (x >> 16);
-    return popcount<int32, 32>(~x);
+    return popcount<I_32, 32>(~x);
 }
 
 template <>
@@ -271,7 +271,7 @@
 template <typename uinttype> inline uinttype isqrt(uinttype n);
 
 template <> inline uint64 isqrt(uint64 n) { return isqrt_iter(n, (uint64) 65536); }
-template <> inline uint32 isqrt(uint32 n) { return isqrt_iter(n, (uint32) 256); }
+template <> inline U_32 isqrt(U_32 n) { return isqrt_iter(n, (U_32) 256); }
 template <> inline uint16 isqrt(uint16 n) { return isqrt_iter(n, (uint16) 16); }
 template <> inline uint8 isqrt(uint8 n) { return isqrt_iter(n, (uint8) 4); }
 

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/optimizer.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/optimizer.h?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/optimizer.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/optimizer.h Thu May 22 06:33:38 2008
@@ -41,18 +41,18 @@
     bool dumpdot;
 
     // Max number of nodes HIR would grow up to during various inlinings
-    uint32 hir_node_threshold;
+    U_32 hir_node_threshold;
     // A share of node limit inlining may use (in percents), the remaining share is for helper inlining
-    uint32 inline_node_quota;
+    U_32 inline_node_quota;
 
     bool cse_final;
 
-    uint32 hash_init_factor;
-    uint32 hash_resize_factor;
-    uint32 hash_resize_to;
-    uint32 hash_node_var_factor;
-    uint32 hash_node_tmp_factor;
-    uint32 hash_node_constant_factor;
+    U_32 hash_init_factor;
+    U_32 hash_resize_factor;
+    U_32 hash_resize_to;
+    U_32 hash_node_var_factor;
+    U_32 hash_node_tmp_factor;
+    U_32 hash_node_constant_factor;
 
     bool sink_constants;
     bool sink_constants1;
@@ -75,7 +75,7 @@
 
 
     //profiler flags
-    uint32 profile_threshold;
+    U_32 profile_threshold;
     bool use_average_threshold;
     bool use_minimum_threshold;
     bool use_fixed_threshold;

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/optpass.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/optpass.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/optpass.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/optpass.cpp Thu May 22 06:33:38 2008
@@ -129,7 +129,7 @@
 void
 OptPass::fixupSsa(IRManager& irm) {
     static CountTime fixupSsaTimer("opt::helper::fixupSsa");
-    static uint32 globalSsaFixupCounter = 0;
+    static U_32 globalSsaFixupCounter = 0;
 
     if(!irm.isSsaUpdated()) {
         AutoTimer tm(fixupSsaTimer);

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/osr.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/osr.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/osr.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/osr.cpp Thu May 22 06:33:38 2008
@@ -54,7 +54,7 @@
 
 DEFINE_SESSION_ACTION(OSRPass, osr, "Operator Strength Reduction")
 
-static uint32 signof(int v){ return (v == 0) ? 0 : (v < 0 ? -1 : 1);}
+static U_32 signof(int v){ return (v == 0) ? 0 : (v < 0 ? -1 : 1);}
 
 
 /* The code below is based on loop_unroll processOpnd function. However it
@@ -158,9 +158,9 @@
             }
         } else if ((info1.isCounter() && info2.isLDConst())
                    || (info2.isCounter() && info1.isLDConst())) {
-            uint32 increment = info1.isCounter() ?
+            U_32 increment = info1.isCounter() ?
                 info1.getIncrement() : info2.getIncrement();
-            uint32 diff = info1.isLDConst()? info1.getConst() : info2.getConst();
+            U_32 diff = info1.isLDConst()? info1.getConst() : info2.getConst();
             bool monotonousFlag = increment == 0 || diff == 0
                 || (opcode == Op_Add && signof(diff) == signof(increment))
                 || (opcode == Op_Sub && signof(diff) != signof(increment));
@@ -446,7 +446,7 @@
     }
 }
 
-void OSR::replaceOperand(uint32 num, Inst* inst, SsaOpnd* opnd,
+void OSR::replaceOperand(U_32 num, Inst* inst, SsaOpnd* opnd,
                          Opnd* iv_lead, Node* iv_lead_node,
                          Type* type, Opcode opcode, SsaOpnd* rc,
                          Operation op){
@@ -484,10 +484,10 @@
         Log::out() << std::endl;
     }
 
-    uint32 numOpnds = inst->getNumSrcOperands();
+    U_32 numOpnds = inst->getNumSrcOperands();
     SsaOpnd* iv_lead = getLeadingOperand(iv);
     Node* iv_lead_node = iv_lead->getInst()->getNode();
-    for (uint32 num = 0; num < numOpnds; num++) {
+    for (U_32 num = 0; num < numOpnds; num++) {
         SsaOpnd* opnd = inst->getSrc(num)->asSsaOpnd();
         replaceOperand(num, inst, opnd, iv_lead, iv_lead_node, type,
                        opcode, rc, op);
@@ -555,9 +555,9 @@
         return instFactory.makeStVar(newSsaVar,
                                      old_inst->getSrc(0)->asSsaOpnd());
     } else {
-        uint32 num = old_inst->getNumSrcOperands();
+        U_32 num = old_inst->getNumSrcOperands();
         Opnd** newOpnds = new(mm) Opnd* [num];
-        for (uint32 i = 0; i < num; i++) {
+        for (U_32 i = 0; i < num; i++) {
             newOpnds[i] = old_inst->getSrc(i)->asSsaOpnd();
         }
         return (PhiInst*)instFactory.makePhi(newSsaVar, num, newOpnds);
@@ -786,7 +786,7 @@
 void OSR::performLFTR(Inst* inst){
     Opcode opcode = inst->getOpcode();
     if (opcode == Op_Cmp || opcode == Op_Branch) {
-        uint32 num = inst->getNumSrcOperands();
+        U_32 num = inst->getNumSrcOperands();
         if (2 == num) {
             iv = 0;
             rc = 0;

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/osr.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/osr.h?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/osr.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/osr.h Thu May 22 06:33:38 2008
@@ -86,11 +86,11 @@
     bool isDOL() const {return type == DEF_OUT_OF_LOOP;} 
     bool isUndefined() const {return type == UNDEF;} 
 
-    uint32 getConst() const {
+    U_32 getConst() const {
         assert(getType() == LD_CONST);
         return val;
     }
-    void setConst(uint32 v) {
+    void setConst(U_32 v) {
         assert(getType() == LD_CONST);
         val = v;
     }
@@ -243,7 +243,7 @@
     void replaceOperands(Type* type, Inst* newDef, SsaOpnd* iv,
              SsaOpnd* rc, Opcode opcode, Operation op);
     void findLeadingOpnd(Inst* newDef, SsaOpnd* opnd);
-    void replaceOperand(uint32 num, Inst* newDef, SsaOpnd* o,
+    void replaceOperand(U_32 num, Inst* newDef, SsaOpnd* o,
             Opnd* lead, Node* leadBlock, Type* type,
             Opcode opcode, SsaOpnd* rc, Operation op);
     Inst *findInsertionPlace(SsaOpnd* opnd2, SsaOpnd* opnd1);

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/reassociate.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/reassociate.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/reassociate.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/reassociate.cpp Thu May 22 06:33:38 2008
@@ -62,15 +62,15 @@
     pass.runPass(true, true);
 }
 
-inline uint32 computePriority(uint32 op_cost, uint32 priority0) {
+inline U_32 computePriority(U_32 op_cost, U_32 priority0) {
     if (priority0 == 0) return 0;
     else return op_cost + priority0;
 }
-inline uint32 computePriority(uint32 op_cost, uint32 priority0, uint32 priority1) {
+inline U_32 computePriority(U_32 op_cost, U_32 priority0, U_32 priority1) {
     if (priority0 == 0) return 0;
     else return op_cost + ::std::max(priority0, priority1);
 }
-inline uint32 computePriority(uint32 op_cost, uint32 priority0, uint32 priority1, uint32 priority2) {
+inline U_32 computePriority(U_32 op_cost, U_32 priority0, U_32 priority1, U_32 priority2) {
     if ((priority0 == 0) && (priority1 == 0) && (priority2 == 0)) return 0;
     else return op_cost + ::std::max(::std::max(priority0, priority1), priority2);
 }
@@ -100,11 +100,11 @@
 }
 
 
-uint32 Reassociate::getPriority(Opnd *opnd)
+U_32 Reassociate::getPriority(Opnd *opnd)
 {
     if (priority.has(opnd)) return priority[opnd];
     Inst *inst = opnd->getInst();
-    uint32 opriority = 0;
+    U_32 opriority = 0;
     Operation operation = inst->getOperation();
     Opcode opc = operation.getOpcode();
     switch (opc) {
@@ -159,24 +159,24 @@
     break;
     default:
     if (operation.isMovable()) {
-        uint32 numOpnds = inst->getNumSrcOperands();
+        U_32 numOpnds = inst->getNumSrcOperands();
         opriority = 0;
 
-        for (uint32 i = 0; i<numOpnds; i++) {
+        for (U_32 i = 0; i<numOpnds; i++) {
                 Opnd *opndi = inst->getSrc(i);
-                uint32 argpriority = getPriority(opndi);
+                U_32 argpriority = getPriority(opndi);
                 opriority = ::std::max(opriority, argpriority);
         }
         opriority = computePriority(costOfMisc, opriority);
     } else {
         Inst *previ = inst->getPrevInst();
-        uint32 ipriority = 1;
+        U_32 ipriority = 1;
         while (!previ->isLabel()) {
         ++ipriority;
         previ = previ->getPrevInst();
         }
         Node *block = previ->asLabelInst()->getNode();
-        uint32 bpriority = cfgRpoNum[block];
+        U_32 bpriority = cfgRpoNum[block];
         opriority = ((bpriority * priorityFactorOfBlock)
                          + ipriority)*priorityFactorOfPosition;
     }
@@ -235,7 +235,7 @@
     StlVector<Node *>::reverse_iterator 
     riter = postOrderNodes.rbegin(),
     rend = postOrderNodes.rend();
-    uint32 i = 0;
+    U_32 i = 0;
     while (riter != rend) {
     Node *node = *riter;
     if (Log::isEnabled()) {
@@ -447,11 +447,11 @@
         Opnd *opnd1 = owd1.opnd;
         Opnd *newOpnd = 0;
         bool newNegated = 0;
-        uint32 priority0 = owd0.priority;
-        uint32 priority1 = owd1.priority;
+        U_32 priority0 = owd0.priority;
+        U_32 priority1 = owd1.priority;
         const char *debug_op = "";
         bool debug_swapped = false;
-        uint32 newPriority = 0;
+        U_32 newPriority = 0;
         if (owd0.negate != owd1.negate) {
             if (owd0.negate) {
                 newOpnd = theSimp->genSub(type, Modifier(Overflow_None)|Modifier(Exception_Never)|Modifier(Strict_No),
@@ -560,10 +560,10 @@
         OpndWithPriority owd0 = opnds[0]; 
         OpndWithPriority owd1 = opnds[1];
         Opnd *opnd0 = owd0.opnd;
-        uint32 priority0 = owd0.priority;
+        U_32 priority0 = owd0.priority;
         bool neg0 = owd0.negate;
         Opnd *opnd1 = owd1.opnd;
-        uint32 priority1 = owd1.priority;
+        U_32 priority1 = owd1.priority;
         bool neg1 = owd1.negate;
 
         if ((opnd0 == opnd1) && (opndsize > 3)
@@ -574,7 +574,7 @@
             OpndWithPriority owd2 = opnds[2]; 
             OpndWithPriority owd3 = opnds[3];
             Opnd *opnd2 = owd2.opnd;
-            uint32 priority2 = owd2.priority;
+            U_32 priority2 = owd2.priority;
 
             Opnd *newOpnd0 = theSimp->genMul(type, Modifier(Overflow_None)|Modifier(Exception_Never)|Modifier(Strict_No),
                                              opnd0, opnd2)->getDst();
@@ -583,9 +583,9 @@
             opnds.pop_front();
             opnds.pop_front();
             opnds.pop_front();
-            uint32 priorityNew0 = computePriority(costOfMul, priority0,
+            U_32 priorityNew0 = computePriority(costOfMul, priority0,
                                                   priority2);
-            uint32 priorityNew1 = computePriority(costOfMul, 
+            U_32 priorityNew1 = computePriority(costOfMul, 
                                                   priorityNew0,
                                                   priorityNew0);
             OpndWithPriority newelt(newOpnd1, priorityNew1, 
@@ -604,7 +604,7 @@
             
             opnds[0] = newelt;
             opndsize -= 3;
-            uint32 i = 1;
+            U_32 i = 1;
             while (i < opndsize) {
                 if (opnds[i].priority < priorityNew1) {
                     opnds[i-1] = opnds[i];
@@ -618,7 +618,7 @@
             Opnd *newOpnd = theSimp->genMul(type, Modifier(Overflow_None)|Modifier(Exception_Never)|Modifier(Strict_No),
                                             opnd0, opnd1)->getDst();
             opnds.pop_front();
-            uint32 priority = computePriority(costOfMul, priority0, priority1);
+            U_32 priority = computePriority(costOfMul, priority0, priority1);
             OpndWithPriority newelt(newOpnd, priority, neg0 ^ neg1);
             
             if (Log::isEnabled()) {
@@ -633,7 +633,7 @@
             
             opnds[0] = newelt;
             opndsize -= 1;
-            uint32 i = 1;
+            U_32 i = 1;
             while (i < opndsize) {
                 if (opnds[i].priority < priority) {
                     opnds[i-1] = opnds[i];
@@ -718,11 +718,11 @@
         Opnd *opnd1 = owd1.opnd;
         Opnd *newOpnd = 0;
         bool newNegated = 0;
-        uint32 priority0 = owd0.priority;
-        uint32 priority1 = owd1.priority;
+        U_32 priority0 = owd0.priority;
+        U_32 priority1 = owd1.priority;
         const char *debug_op = "";
         bool debug_swapped = false;
-        uint32 newPriority = 0;
+        U_32 newPriority = 0;
         if (owd0.negate != owd1.negate) {
             if (owd0.negate) {
                 newOpnd = theSimp->genSub(type, Modifier(Overflow_None)|Modifier(Exception_Never)|Modifier(Strict_No),

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/reassociate.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/reassociate.h?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/reassociate.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/reassociate.h Thu May 22 06:33:38 2008
@@ -48,11 +48,11 @@
 class Simplifier;
 
 struct OpndWithPriority {
-    OpndWithPriority(Opnd *op, uint32 priority0,
+    OpndWithPriority(Opnd *op, U_32 priority0,
                      bool negate0) 
         : opnd(op), priority(priority0), negate(negate0) {};
     Opnd *opnd;
-    uint32 priority;
+    U_32 priority;
     bool negate;
 };
 bool operator < (const OpndWithPriority &a, const OpndWithPriority &b);
@@ -109,22 +109,22 @@
     
 private:
     // we compute Reverse-Postorder numbers for CFGnodes:
-    StlHashMap<Node *, uint32> cfgRpoNum;
+    StlHashMap<Node *, U_32> cfgRpoNum;
 
-    StlHashMap<Opnd *, uint32> priority;
-    uint32 getPriority(Opnd *opnd); // computes if not in the hash map
+    StlHashMap<Opnd *, U_32> priority;
+    U_32 getPriority(Opnd *opnd); // computes if not in the hash map
 
     // build a LdConstant(k), put it in header of FlowGraph
     SsaTmpOpnd *makeLdConst(Type *type, ConstInst::ConstValue k, SsaOpnd *dstOp);
 
-    uint32 costOfAdd, costOfSub, 
+    U_32 costOfAdd, costOfSub, 
         costOfNeg, costOfMul, costOfConv, costOfBoolOp,
     costOfNot, costOfShladd, costOfShift, costOfMisc, 
     priorityFactorOfBlock, priorityFactorOfPosition;
-    uint32 numBlocks;
+    U_32 numBlocks;
     
     bool minDepth;
-    uint32 maxReassocDepth;
+    U_32 maxReassocDepth;
 };
 
 } //namespace Jitrino 

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/simplifier.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/simplifier.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/simplifier.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/simplifier.cpp Thu May 22 06:33:38 2008
@@ -803,7 +803,7 @@
     if (src1 == src2) {
         ConstInst::ConstValue zeroval;
         switch(type->tag) {
-        case Type::Int32: return genLdConstant((int32)0)->getDst();
+        case Type::Int32: return genLdConstant((I_32)0)->getDst();
         case Type::Int64: return genLdConstant((int64)0)->getDst();
         default: assert(0); return NULL;
         }
@@ -922,7 +922,7 @@
         Inst *inst1 = src1->getInst();
         Type::Tag typeTag1 = inst1->getType();
         int64 val64;
-        int32 val32;
+        I_32 val32;
         if (ConstantFolder::isConstant(src1->getInst(), val64) &&
             (inst2->getOpcode() == Op_Conv) &&
             (((typeTag2 == Type::Int8) && (((uint64)val64) <= 0xff)) ||
@@ -943,18 +943,18 @@
         }
     } else if (ConstantFolder::isConstant(src1->getInst(), val32) &&
            (inst2->getOpcode() == Op_Conv) &&
-           (((typeTag2 == Type::Int8) && (((uint32)val32) <= 0xff)) ||
-            ((typeTag2 == Type::Int16) && (((uint32)val32) <= 0xffff)) ||
-            ((typeTag2 == Type::Int32) && (((uint32)val32) <= 0xffffffff)))) {
+           (((typeTag2 == Type::Int8) && (((U_32)val32) <= 0xff)) ||
+            ((typeTag2 == Type::Int16) && (((U_32)val32) <= 0xffff)) ||
+            ((typeTag2 == Type::Int32) && (((U_32)val32) <= 0xffffffff)))) {
         Opnd *src2opnd = inst2->getSrc(0);
         if (src2opnd->getType() == src2->getType()) {
         return genAnd(theType, src1, src2opnd)->getDst();
         }
     } else if (ConstantFolder::isConstant(src2->getInst(), val32) &&
            (inst1->getOpcode() == Op_Conv) &&
-           (((typeTag1 == Type::Int8) && (((uint32)val32) <= 0xff)) ||
-            ((typeTag1 == Type::Int16) && (((uint32)val32) <= 0xffff)) ||
-            ((typeTag1 == Type::Int32) && (((uint32)val32) <= 0xffffffff)))) {
+           (((typeTag1 == Type::Int8) && (((U_32)val32) <= 0xff)) ||
+            ((typeTag1 == Type::Int16) && (((U_32)val32) <= 0xffff)) ||
+            ((typeTag1 == Type::Int32) && (((U_32)val32) <= 0xffffffff)))) {
         Opnd *src1opnd = inst1->getSrc(0);
         if (src1opnd->getType() == src1->getType()) {
         return genAnd(theType, src1opnd, src2)->getDst();
@@ -980,17 +980,17 @@
         }
     } else if (ConstantFolder::isConstant(src1->getInst(), val32) &&
            (inst2->getOpcode() == Op_TauLdInd) &&
-           (((typeTag2 == Type::UInt8) && (((uint32)val32) == 0xff)) ||
-            ((typeTag2 == Type::UInt16) && (((uint32)val32) == 0xffff)) ||
-            ((typeTag2 == Type::UInt32) && (((uint32)val32) == 0xffffffff)))) {
+           (((typeTag2 == Type::UInt8) && (((U_32)val32) == 0xff)) ||
+            ((typeTag2 == Type::UInt16) && (((U_32)val32) == 0xffff)) ||
+            ((typeTag2 == Type::UInt32) && (((U_32)val32) == 0xffffffff)))) {
         if (theType == src2->getType()) {
         return src2;
         }
     } else if (ConstantFolder::isConstant(src2->getInst(), val32) &&
            (inst1->getOpcode() == Op_TauLdInd) &&
-           (((typeTag1 == Type::UInt8) && (((uint32)val32) == 0xff)) ||
-            ((typeTag1 == Type::UInt16) && (((uint32)val32) == 0xffff)) ||
-            ((typeTag1 == Type::UInt32) && (((uint32)val32) == 0xffffffff)))) {
+           (((typeTag1 == Type::UInt8) && (((U_32)val32) == 0xff)) ||
+            ((typeTag1 == Type::UInt16) && (((U_32)val32) == 0xffff)) ||
+            ((typeTag1 == Type::UInt32) && (((U_32)val32) == 0xffffffff)))) {
         if (theType == src1->getType()) {
         return src1;
         }
@@ -1192,14 +1192,14 @@
             case Type::Int32:
             case Type::UInt32:
                 if (src1isConstant) {
-                    int32 multiplier;
+                    I_32 multiplier;
                     bool t = ConstantFolder::isConstant(src1->getInst(), 
                                                         multiplier);
                     if( !t) assert(0);
                     Opnd *product = planMul32(multiplier, src2);
                     return product;
                 } else { // src2isConstant
-                    int32 multiplier;
+                    I_32 multiplier;
                     bool t = ConstantFolder::isConstant(src2->getInst(), 
                                                         multiplier);
                     if( !t) assert(0);
@@ -1295,7 +1295,7 @@
             switch (type->tag) {
             case Type::Int32:
             case Type::UInt32:
-                return genLdConstant((int32) 0)->getDst();
+                return genLdConstant((I_32) 0)->getDst();
             case Type::Int64:
             case Type::UInt64:
                 return genLdConstant((int64) 0)->getDst();
@@ -1330,7 +1330,7 @@
             case Type::UInt32:
                 if (src1isConstant) {
                     TypeManager &tm = irManager.getTypeManager();
-                    int32 multiplier;
+                    I_32 multiplier;
                     bool t = ConstantFolder::isConstant(src1->getInst(), 
                                                         multiplier);
                     if( !t) assert(0);
@@ -1341,7 +1341,7 @@
                                             Modifier(Overflow_None)|Modifier(Exception_Never)|Modifier(Strict_No),
                                             src2)->getDst();
                     Opnd *product = planMul32(multiplier, src2_64);
-                    Opnd *thirtytwo = genLdConstant((int32)(32))->getDst();
+                    Opnd *thirtytwo = genLdConstant((I_32)(32))->getDst();
                     Opnd *shifted = genShr(dstType64, 
                                            Modifier(UnsignedOp)|Modifier(ShiftMask_None),
                                            product, thirtytwo)->getDst();
@@ -1350,7 +1350,7 @@
                                         shifted)->getDst();
                     return res;
                 } else { // src2isConstant
-                    int32 multiplier;
+                    I_32 multiplier;
                     bool t = ConstantFolder::isConstant(src2->getInst(), 
                                                         multiplier);
                     if( !t) assert(0);
@@ -1361,7 +1361,7 @@
                                             Modifier(Overflow_None)|Modifier(Exception_Never)|Modifier(Strict_No),
                                             src1)->getDst();
                     Opnd *product = planMul32(multiplier, src1_64);
-                    Opnd *thirtytwo = genLdConstant((int32)(32))->getDst();
+                    Opnd *thirtytwo = genLdConstant((I_32)(32))->getDst();
                     Opnd *shifted = genShr(dstType64, 
                                            Modifier(UnsignedOp)|Modifier(ShiftMask_None),
                                            product, thirtytwo)->getDst();
@@ -1489,30 +1489,30 @@
             (dstType->tag == Type::Int32) &&
             mod.isSigned()) {
 
-            int32 denom = value2.i4;
+            I_32 denom = value2.i4;
             // note that 0 and 1 were handled above
             if (denom == -1) {
                 // convert to neg
                 Opnd *res = genNeg(dstType, src1)->getDst();
                 return res;
-            } else if (isPowerOf2<int32>(denom)) {
+            } else if (isPowerOf2<I_32>(denom)) {
                 // convert to shift and such
-                int32 absdenom = (denom < 0) ? -denom : denom;
-                int k = whichPowerOf2<int32,32>(absdenom);
-                Opnd *kminus1 = genLdConstant((int32)(k - 1))->getDst();
+                I_32 absdenom = (denom < 0) ? -denom : denom;
+                int k = whichPowerOf2<I_32,32>(absdenom);
+                Opnd *kminus1 = genLdConstant((I_32)(k - 1))->getDst();
                 // make k-1 copies of the sign bit
                 Opnd *shiftTheSign = genShr(dstType, 
                                             Modifier(SignedOp)|Modifier(ShiftMask_None),
                                             src1, kminus1)->getDst();
                 // we 32-k zeros in on left to put copies of sign on right
-                Opnd *t32minusk = genLdConstant((int32)(32-k))->getDst();
+                Opnd *t32minusk = genLdConstant((I_32)(32-k))->getDst();
                 // if (n<0), this is 2^k-1, else 0
                 Opnd *kminus1ones = genShr(dstType, 
                                            Modifier(UnsignedOp)|Modifier(ShiftMask_None),
                                            shiftTheSign, t32minusk)->getDst();
                 Opnd *added = genAdd(dstType, Modifier(Overflow_None)|Modifier(Exception_Never)|Modifier(Strict_No),
                                      src1, kminus1ones)->getDst();
-                Opnd *kOpnd = genLdConstant((int32)k)->getDst();
+                Opnd *kOpnd = genLdConstant((I_32)k)->getDst();
                 Opnd *res = genShr(dstType, Modifier(SignedOp)|Modifier(ShiftMask_None),
                                    added, kOpnd)->getDst();
                 if (denom != absdenom) { // ((denom < 0) && (k < 31))
@@ -1521,8 +1521,8 @@
                 return res;
             } else {
                 // convert to MulHi and such
-                int32 magicNum, shiftBy;
-                getMagic<int32, uint32, 32>(denom, &magicNum, &shiftBy);
+                I_32 magicNum, shiftBy;
+                getMagic<I_32, U_32, 32>(denom, &magicNum, &shiftBy);
                 
                 Opnd *mulRes;
                 if (optimizerFlags.use_mulhi) {
@@ -1537,7 +1537,7 @@
                                           src1)->getDst();
                     Opnd *mulRes64 = genMul(dstType64, Modifier(Overflow_None)|Modifier(Exception_Never)|Modifier(Strict_No), magicOpnd,
                                             src64)->getDst();
-                    Opnd *constant32 = genLdConstant((int32)32)->getDst();
+                    Opnd *constant32 = genLdConstant((I_32)32)->getDst();
                     Opnd *mulRes64h = genShr(dstType64, 
                                              Modifier(SignedOp)|Modifier(ShiftMask_None),
                                              mulRes64,
@@ -1558,7 +1558,7 @@
                 Opnd *shiftByOpnd = genLdConstant(shiftBy)->getDst();
                 mulRes = genShr(dstType, Modifier(SignedOp)|Modifier(ShiftMask_None),
                                 mulRes, shiftByOpnd)->getDst();
-                Opnd *thirtyOne = genLdConstant((int32)31)->getDst();
+                Opnd *thirtyOne = genLdConstant((I_32)31)->getDst();
                 Opnd *oneIfNegative = genShr(dstType,
                                              Modifier(UnsignedOp)|Modifier(ShiftMask_None),
                                              ((denom < 0) 
@@ -1613,7 +1613,7 @@
         if (ConstantFolder::isConstantOne(src2)) {
             ConstInst::ConstValue zeroval;
             switch(dstType->tag) {
-            case Type::Int32: return genLdConstant((int32)0)->getDst();
+            case Type::Int32: return genLdConstant((I_32)0)->getDst();
             case Type::Int64: return genLdConstant((int64)0)->getDst();
             default: assert(0); return NULL;
             }
@@ -1627,22 +1627,22 @@
         Inst *src2inst = src2->getInst();
         ConstInst::ConstValue cv;
         if (ConstantFolder::isConstant(src2inst, cv.i4)) {
-            int32 denom = cv.i4;
+            I_32 denom = cv.i4;
             if ((denom == -1) || (denom == 1)) {
                 //
                 // s1 % +-1 -> 0 
                 //
-                return genLdConstant((int32)0)->getDst();
+                return genLdConstant((I_32)0)->getDst();
             }
-            if (isPowerOf2<int32>(denom)) {
-                int k = whichPowerOf2<int32,32>(denom);
-                int32 maskInt = (((int32)0x1)<<k)-1;
+            if (isPowerOf2<I_32>(denom)) {
+                int k = whichPowerOf2<I_32,32>(denom);
+                I_32 maskInt = (((I_32)0x1)<<k)-1;
                 Opnd *maskOpnd = genLdConstant(maskInt)->getDst();
                 Opnd *maskedOpnd = genAnd(src1->getType(),
                                           src1, maskOpnd)->getDst();
                 Opnd *res = maskedOpnd;
                 if (denom < 0) {
-                    int32 signInt = ((int32)-1) ^ maskInt;
+                    I_32 signInt = ((I_32)-1) ^ maskInt;
                     Opnd *extendedSign 
                         = genLdConstant(signInt)->getDst();
                     res = genOr(src1->getType(), res, extendedSign)->getDst();
@@ -1750,35 +1750,35 @@
         if (dstType == src->getType())
         return src;
     }
-    int32 val32;
+    I_32 val32;
     if (ConstantFolder::isConstant(src0->getInst(), val32) &&
         (((toType == Type::UInt8)
-          && (((uint32)val32) <= 0xff)) ||
+          && (((U_32)val32) <= 0xff)) ||
              ((toType == Type::Int8) 
-          && (((uint32)val32) <= 0x7f)) ||
+          && (((U_32)val32) <= 0x7f)) ||
          ((toType == Type::UInt16)
-          && (((uint32)val32) <= 0xffff)) ||
+          && (((U_32)val32) <= 0xffff)) ||
          ((toType == Type::Int16) 
-          && (((uint32)val32) <= 0x7fff)) ||
+          && (((U_32)val32) <= 0x7fff)) ||
          ((toType == Type::UInt32)
-          && (((uint32)val32) <= 0xffffffff)) ||
+          && (((U_32)val32) <= 0xffffffff)) ||
          ((toType == Type::Int32) 
-          && (((uint32)val32) <= 0x7fffffff)))) {
+          && (((U_32)val32) <= 0x7fffffff)))) {
         if (dstType == src->getType())
         return src;
     } else if (ConstantFolder::isConstant(src1->getInst(), val32) &&
         (((toType == Type::UInt8)
-          && (((uint32)val32) <= 0xff)) ||
+          && (((U_32)val32) <= 0xff)) ||
              ((toType == Type::Int8)
-              && (((uint32)val32) <= 0x7f)) ||
+              && (((U_32)val32) <= 0x7f)) ||
          ((toType == Type::UInt16)
-          && (((uint32)val32) <= 0xffff)) ||
+          && (((U_32)val32) <= 0xffff)) ||
          ((toType == Type::Int16) 
-          && (((uint32)val32) <= 0x7fff)) ||
+          && (((U_32)val32) <= 0x7fff)) ||
          ((toType == Type::UInt32)
-          && (((uint32)val32) <= 0xffffffff)) ||
+          && (((U_32)val32) <= 0xffffffff)) ||
          ((toType == Type::Int32) 
-          && (((uint32)val32) <= 0x7fffffff)))) {
+          && (((U_32)val32) <= 0x7fffffff)))) {
         if (dstType == src->getType())
         return src;
     }
@@ -1915,7 +1915,7 @@
             if (ConstantFolder::isConstantZero(src1) && 
                 ((mod & Cmp_Mask)==Cmp_GT_Un)) {
                 switch (dstType->tag) {
-                case Type::Int32: return genLdConstant((int32)0)->getDst();
+                case Type::Int32: return genLdConstant((I_32)0)->getDst();
                 default:
                     break;
                 }
@@ -1924,7 +1924,7 @@
     } else if (ConstantFolder::isConstantZero(src2) &&
                ((mod & Cmp_Mask) == Cmp_GTE_Un)) {
         switch (dstType->tag) {
-        case Type::Int32: return genLdConstant((int32)1)->getDst();
+        case Type::Int32: return genLdConstant((I_32)1)->getDst();
         default:
             break;
         }
@@ -1933,9 +1933,9 @@
     if ((src1 == src2) && !Type::isFloatingPoint(instType)) {
         switch (mod & Cmp_Mask) {
         case Cmp_EQ: case Cmp_GTE: case Cmp_GTE_Un:
-            return genLdConstant((int32)1)->getDst();
+            return genLdConstant((I_32)1)->getDst();
         case Cmp_NE_Un: case Cmp_GT: case Cmp_GT_Un:
-            return genLdConstant((int32)0)->getDst();
+            return genLdConstant((I_32)0)->getDst();
         default:
             assert(0);
         }
@@ -1977,7 +1977,7 @@
                                         srcInst1->getValue(), 
                                         srcInst2->getValue(), res)) {
                 if (res.i4) {
-                    return genLdConstant((int32)1)->getDst();
+                    return genLdConstant((I_32)1)->getDst();
                 } else {
                     ComparisonModifier mod2 = mod;
                     if (Type::isFloatingPoint(instType)) {
@@ -1992,10 +1992,10 @@
                     if (ConstantFolder::foldCmp(instType, mod2,
                                                 srcInst2->getValue(), 
                                                 srcInst1->getValue(), res)) {
-                        if ((uint32)res.i4) {
-                            return genLdConstant((int32)-1)->getDst();
+                        if ((U_32)res.i4) {
+                            return genLdConstant((I_32)-1)->getDst();
                         } else {
-                            return genLdConstant((int32)0)->getDst();
+                            return genLdConstant((I_32)0)->getDst();
                         }
                     }                    
                 }
@@ -2007,9 +2007,9 @@
     if ((src1 == src2) && !Type::isFloatingPoint(instType)) {
         switch (mod & Cmp_Mask) {
         case Cmp_EQ: case Cmp_GTE: case Cmp_GTE_Un:
-            return genLdConstant((int32)1)->getDst();
+            return genLdConstant((I_32)1)->getDst();
         case Cmp_NE_Un: case Cmp_GT: case Cmp_GT_Un:
-            return genLdConstant((int32)0)->getDst();
+            return genLdConstant((I_32)0)->getDst();
         default:
             assert(0);
         }
@@ -2238,7 +2238,7 @@
     ConstInst::ConstValue valC;
     if (src1->getInst()->getOpcode() == Op_Cmp3) {
         if (ConstantFolder::isConstant(src2->getInst(), valC)) {
-            int32 val = valC.i4;
+            I_32 val = valC.i4;
             if (((val == 0) && (mod == Cmp_GT)) ||
                 ((val == 1) && ((mod == Cmp_GTE) || (mod == Cmp_EQ)))) {
                 // test == 1
@@ -2284,7 +2284,7 @@
         }            
     } else if (src2->getInst()->getOpcode() == Op_Cmp3) {
         if (ConstantFolder::isConstant(src1->getInst(), valC)) {
-            int32 val = valC.i4;
+            I_32 val = valC.i4;
             // val cmp Cmp3
             if ((val == 1) && (mod == Cmp_EQ)) {
                 // 1 == test
@@ -2343,7 +2343,7 @@
 {
     ConstInst::ConstValue valC;
     if (ConstantFolder::isConstant(src1->getInst(), valC)) {
-        int32 val = valC.i4;
+        I_32 val = valC.i4;
         if (((val == 0) && (mod == Cmp_NE_Un)) ||
             ((val == 1) && (mod == Cmp_EQ))) {
             // same test as src1;
@@ -2363,7 +2363,7 @@
             return true;
         }
     } else if (ConstantFolder::isConstant(src2->getInst(), valC)) {
-        int32 val = valC.i4;
+        I_32 val = valC.i4;
         if (((val == 0) && ((mod == Cmp_GT) || (mod == Cmp_NE_Un)
                             || (mod == Cmp_GT_Un))) ||
             ((val == 1) && ((mod == Cmp_GTE) || (mod == Cmp_EQ)
@@ -2793,19 +2793,19 @@
 }
 
 bool
-Simplifier::simplifySwitch(uint32 numLabels,
+Simplifier::simplifySwitch(U_32 numLabels,
                            LabelInst* label[],
                            LabelInst* defaultLabel,
                            Opnd* src) {
     assert(numLabels > 0);
     // check for just 1 target
     LabelInst* label1 = label[0];
-    uint32 i;
+    U_32 i;
     for (i = 1; i<numLabels; i++) {
         if (label[i] != label1) return false; // we have >1 distinct labels
     }
     // have just 1 target;
-    Opnd* numTargets = genLdConstant((int32) numLabels)->getDst();
+    Opnd* numTargets = genLdConstant((I_32) numLabels)->getDst();
     genBranch(Type::Int32, Cmp_GT_Un, label1, numTargets, src);
     return true;
 }
@@ -2846,9 +2846,9 @@
     ConstInst* constIndex = index->getInst()->asConstInst();
     if (constArrayLen && constIndex) {
         // compare the constant size and index
-        int32 result = 0;
-        int32 lenv = constArrayLen->getValue().i4;
-        int32 idxv = constIndex->getValue().i4;
+        I_32 result = 0;
+        I_32 lenv = constArrayLen->getValue().i4;
+        I_32 idxv = constIndex->getValue().i4;
         if (ConstantFolder::foldCmp32(Cmp_GT_Un,
                       lenv, idxv, result)) {
             if (result == 1) {
@@ -2881,9 +2881,9 @@
     ConstInst* constIndex = idx->getInst()->asConstInst();
     if (constLB != NULL && constIndex != NULL) {
         // compare the constant size and index
-        int32 result = 0;
-        int32 lbv = constLB->getValue().i4;
-        int32 idxv = constIndex->getValue().i4;
+        I_32 result = 0;
+        I_32 lbv = constLB->getValue().i4;
+        I_32 idxv = constIndex->getValue().i4;
         if (ConstantFolder::foldCmp32(Cmp_GT,
                                       lbv,
                                       idxv,
@@ -2922,9 +2922,9 @@
     ConstInst* constIndex = idx->getInst()->asConstInst();
     if (constUB != NULL && constIndex != NULL) {
         // compare the constant size and index
-        int32 result = 0;
-        int32 idxv = constIndex->getValue().i4;
-        int32 ubv = constUB->getValue().i4;
+        I_32 result = 0;
+        I_32 idxv = constIndex->getValue().i4;
+        I_32 ubv = constUB->getValue().i4;
         if (ConstantFolder::foldCmp32(Cmp_GT,
                                       ubv,
                                       idxv,
@@ -2959,7 +2959,7 @@
 //
 Opnd*
 Simplifier::simplifyTauCheckZero(Opnd* opnd, bool &alwaysThrows) {
-    int32 value;
+    I_32 value;
     if (ConstantFolder::isConstant(opnd->getInst(), value)) {
         if (value != 0)
             return genTauSafe()->getDst(); // check is safe by construction
@@ -2983,10 +2983,10 @@
 Opnd*
 Simplifier::simplifyTauCheckDivOpnds(Opnd* src1, Opnd* src2, bool &alwaysThrows) {
     // look for anything other than src1=MAXNEGINT, src2=-1
-    int32 value;
+    I_32 value;
     bool elim = false;
     if (ConstantFolder::isConstant(src1->getInst(), value)) {
-        if ((uint32)value != 0x80000000) {
+        if ((U_32)value != 0x80000000) {
             // overflow can't happen
             elim = true;
         } else if (ConstantFolder::isConstant(src2->getInst(), value) &&
@@ -3000,7 +3000,7 @@
         elim = true;
     }
     if (!elim) {
-        // above constant folders return false if opnd is not int32
+        // above constant folders return false if opnd is not I_32
         // try int64 instead
         int64 value64;
         if (ConstantFolder::isConstant(src1->getInst(), value64)) {
@@ -3096,17 +3096,17 @@
     bool srcIsNonNull = (tauCheckedNull->getInst()->getOpcode() != Op_TauUnsafe);
     if (srcIsNonNull &&
         irManager.getTypeManager().isResolvedAndSubClassOf(srcType, type)) {
-        return genLdConstant((int32)1)->getDst();
+        return genLdConstant((I_32)1)->getDst();
     } 
 
     // If src is definitely a null object, then the result is 0.
     if ((!srcIsNonNull) && isNullObject(src)) {
-        return genLdConstant((int32)0)->getDst();
+        return genLdConstant((I_32)0)->getDst();
     }
 
     if (isExactType(src) &&
         !irManager.getTypeManager().isResolvedAndSubClassOf(srcType, type))
-        return genLdConstant((int32)0)->getDst();
+        return genLdConstant((I_32)0)->getDst();
 
     return NULL;
 }
@@ -3473,7 +3473,7 @@
 
 Opnd *
 Simplifier::simplifyLdRef(Modifier mod, Type* dstType,
-                          uint32 token, MethodDesc* enclosingMethod)
+                          U_32 token, MethodDesc* enclosingMethod)
 {
     const OptimizerFlags& optimizerFlags = irManager.getOptimizerFlags();
     if (optimizerFlags.reduce_compref && 
@@ -3567,7 +3567,7 @@
                                    Type* returnType,
                                    Opnd* tauNullCheckedFirstArg,
                                    Opnd* tauTypesChecked,
-                                   uint32 numArgs,
+                                   U_32 numArgs,
                                    Opnd* args[])
 {
     //
@@ -3593,7 +3593,7 @@
                                          Type* returnType,
                                          Opnd* tauNullCheckedFirstArg,
                                          Opnd* tauTypesChecked,
-                                        uint32 numArgs,
+                                        U_32 numArgs,
                                         Opnd** args)
 {
     return simplifyIndirectMemoryCallInst(funPtr, returnType, 
@@ -3606,7 +3606,7 @@
                                            Type* returnType,
                                            Opnd* tauNullCheckedFirstArg,
                                            Opnd* tauTypesChecked,
-                                          uint32 numArgs,
+                                          U_32 numArgs,
                                           Opnd** args)
 {
     // if funptr is a load of a fun slot that does not go through a vtable, then
@@ -3626,10 +3626,10 @@
 Opnd*
 Simplifier::simplifyTauAnd(MultiSrcInst *inst)
 {
-    uint32 nsrcs = inst->getNumSrcOperands();
-    uint32 nsrcs0 = nsrcs;
+    U_32 nsrcs = inst->getNumSrcOperands();
+    U_32 nsrcs0 = nsrcs;
     {
-        for (uint32 i = 0; i < nsrcs; ++i) {
+        for (U_32 i = 0; i < nsrcs; ++i) {
             Opnd *srci = inst->getSrc(i);
             Opcode opcode = srci->getInst()->getOpcode();
             if (opcode == Op_TauUnsafe) {
@@ -3710,12 +3710,12 @@
 Inst*
 Simplifier::caseSwitch(SwitchInst* inst) {
     Opnd* index = inst->getSrc(0);
-    int32 value;
+    I_32 value;
     if(ConstantFolder::isConstant(index->getInst(), value)) {
         foldSwitch(inst, value);
         return NULL;
     } else {
-        uint32 numTarget = inst->getNumTargets();
+        U_32 numTarget = inst->getNumTargets();
         LabelInst** targets = inst->getTargets();
         LabelInst* defaultTarget = inst->getDefaultTarget();
         if(simplifySwitch(numTarget, targets, defaultTarget, index)) {
@@ -3730,7 +3730,7 @@
     Opnd* dst = inst->getDst();
     Type* returnType = dst->isNull()? irManager.getTypeManager().getVoidType() : dst->getType();
     Opnd** args = inst->getArgs();
-    uint32 numArgs = inst->getNumArgs();
+    U_32 numArgs = inst->getNumArgs();
     assert(numArgs >= 2);
     Opnd* tauNullCheckedFirstArg = args[0];
     Opnd* tauTypesChecked = args[1];
@@ -3751,7 +3751,7 @@
     Opnd* dst = inst->getDst();
     Type* returnType = dst->isNull()? irManager.getTypeManager().getVoidType() : dst->getType();
     Opnd** args = inst->getArgs();
-    uint32 numArgs = inst->getNumArgs();
+    U_32 numArgs = inst->getNumArgs();
     assert(numArgs >= 2);
     Opnd* tauNullCheckedFirstArg = args[0];
     Opnd* tauTypesChecked = args[1];
@@ -3801,7 +3801,7 @@
 }
 
 void  
-SimplifierWithInstFactory::foldSwitch(SwitchInst* switchInst, uint32 index) {
+SimplifierWithInstFactory::foldSwitch(SwitchInst* switchInst, U_32 index) {
     FlowGraph::foldSwitch(flowGraph, switchInst,index);
 }
 
@@ -3811,13 +3811,13 @@
     FlowGraph::eliminateCheck(flowGraph, currentCfgNode,checkInst,alwaysThrows);
 }
 
-uint32
+U_32
 SimplifierWithInstFactory::simplifyControlFlowGraph() {
     if (Log::isEnabled()) {
         Log::out() << "Starting simplifyControlFlowGraph" << ::std::endl;
     }
 
-    uint32 numInstOptimized = 0;
+    U_32 numInstOptimized = 0;
     MemoryManager memManager("SimplifierWithInstFactory::simplifyControlFlowGraph");
     BitSet* reachableNodes = new (memManager) BitSet(memManager,flowGraph.getMaxNodeId());
     BitSet* unreachableInsts = 
@@ -4152,7 +4152,7 @@
                                       Type* returnType,
                                       Opnd* tauNullCheckedFirstArg,
                                       Opnd* tauTypesChecked,
-                                     uint32 numArgs,
+                                     U_32 numArgs,
                                       Opnd* args[])
 {
     Opnd* dst;
@@ -4169,7 +4169,7 @@
     return inst;
 }
 Inst*
-SimplifierWithInstFactory::genLdConstant(int32 val) {
+SimplifierWithInstFactory::genLdConstant(I_32 val) {
     Opnd* dst = opndManager.createSsaTmpOpnd(typeManager.getInt32Type());
     Inst* inst = instFactory.makeLdConst(dst, val);
     insertInst(inst);
@@ -4219,7 +4219,7 @@
 
 Inst* 
 SimplifierWithInstFactory::genLdRef(Modifier mod, Type* type, 
-                                    uint32 token,
+                                    U_32 token,
                                     MethodDesc *methodDesc)
 {
     Opnd* dst = opndManager.createSsaTmpOpnd(type);
@@ -4499,7 +4499,7 @@
 
 
 static Class_Handle getClassHandle(Opnd* opnd) {
-    //class handle can be: unmanaged ptr (from magics) or pointer_size_int const (int32 or int64) if loaded as a const
+    //class handle can be: unmanaged ptr (from magics) or pointer_size_int const (I_32 or int64) if loaded as a const
     //assert(opnd->getType()->isUnmanagedPtr() || opnd->getType()->isInt4() || opnd->getType()->isInt8());
     assert(opnd->getType()->isUnmanagedPtr());
     Inst* inst = opnd->getInst();
@@ -4518,7 +4518,7 @@
         case ClassIsArray:
             ch = getClassHandle(inst->getSrc(0));
             if (ch) {
-                res = genLdConstant((int32)VMInterface::isArrayType(ch));
+                res = genLdConstant((I_32)VMInterface::isArrayType(ch));
             }
             break;
         case ClassGetAllocationHandle:
@@ -4533,25 +4533,25 @@
         case ClassGetTypeSize:
             ch = getClassHandle(inst->getSrc(0));
             if (ch) {
-                res = genLdConstant((int32)VMInterface::getObjectSize(ch));
+                res = genLdConstant((I_32)VMInterface::getObjectSize(ch));
             }
             break;
         case ClassGetArrayElemSize:
             ch = getClassHandle(inst->getSrc(0));
             if (ch) {
-                res = genLdConstant((int32)VMInterface::getArrayElemSize(ch));
+                res = genLdConstant((I_32)VMInterface::getArrayElemSize(ch));
             }
             break;
         case ClassIsInterface:
             ch = getClassHandle(inst->getSrc(0));
             if (ch) {
-                res = genLdConstant((int32)VMInterface::isInterfaceType(ch));
+                res = genLdConstant((I_32)VMInterface::isInterfaceType(ch));
             }
             break;
         case ClassIsFinal:
             ch = getClassHandle(inst->getSrc(0));
             if (ch) {
-                res = genLdConstant((int32)VMInterface::isFinalType(ch));
+                res = genLdConstant((I_32)VMInterface::isFinalType(ch));
             }
             break;
         case ClassGetArrayClass:
@@ -4565,7 +4565,7 @@
         case ClassIsFinalizable:
             ch = getClassHandle(inst->getSrc(0));
             if (ch) {
-                res = genLdConstant((int32)VMInterface::isFinalizable(ch));
+                res = genLdConstant((I_32)VMInterface::isFinalizable(ch));
             }
             break;
         case ClassGetFastCheckDepth:
@@ -4573,7 +4573,7 @@
             if (ch) {
                 int depth = 0;
                 if (VMInterface::getClassFastInstanceOfFlag(ch)) {
-                    depth = (int32)VMInterface::getClassDepth(ch);
+                    depth = (I_32)VMInterface::getClassDepth(ch);
                 }
                 res = genLdConstant(depth);
             }



Mime
View raw message