harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From mcfi...@apache.org
Subject svn commit: r659108 [3/19] - in /harmony/enhanced/drlvm/trunk/vm: em/src/ gc_gen/src/common/ gc_gen/src/mark_compact/ gc_gen/src/mark_sweep/ gc_gen/src/semi_space/ gc_gen/src/trace_forward/ include/open/ interpreter/src/ jitrino/src/codegenerator/ jitr...
Date Thu, 22 May 2008 13:34:09 GMT
Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CallingConvention.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CallingConvention.h?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CallingConvention.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CallingConvention.h Thu May 22 06:33:38 2008
@@ -78,10 +78,10 @@
 
     struct OpndInfo
     {
-        uint32              typeTag;
-        uint32              slotCount;
+        U_32              typeTag;
+        U_32              slotCount;
         bool                isReg;
-        uint32              slots[4];
+        U_32              slots[4];
     };
 
     //--------------------------------------------------------------
@@ -96,7 +96,7 @@
     /** Fills the infos array with information how incoming arguments or return values are passed 
     according to this calling convention 
     */
-    virtual void    getOpndInfo(ArgKind kind, uint32 argCount, OpndInfo * infos) const =0;
+    virtual void    getOpndInfo(ArgKind kind, U_32 argCount, OpndInfo * infos) const =0;
 
     /** Returns a mask describing registers of regKind which are to be preserved by a callee
     */
@@ -113,7 +113,7 @@
     /**
      * Defines stack pointer alignment on method enter.
      */
-    virtual uint32 getStackAlignment()const { return 0; }
+    virtual U_32 getStackAlignment()const { return 0; }
     
     /**
      * Maps a string representation of CallingConvention to the 
@@ -140,7 +140,7 @@
 public: 
     
     virtual             ~STDCALLCallingConventionIA32() {}
-    virtual void        getOpndInfo(ArgKind kind, uint32 argCount, OpndInfo * infos) const;
+    virtual void        getOpndInfo(ArgKind kind, U_32 argCount, OpndInfo * infos) const;
     virtual Constraint  getCalleeSavedRegs(OpndKind regKind) const;
     virtual bool        calleeRestoresStack() const{ return true; }
     virtual bool        pushLastToFirst() const { return true; }
@@ -152,10 +152,10 @@
 public: 
     
     virtual             ~STDCALLCallingConventionEM64T() {}
-    virtual void        getOpndInfo(ArgKind kind, uint32 argCount, OpndInfo * infos) const;
+    virtual void        getOpndInfo(ArgKind kind, U_32 argCount, OpndInfo * infos) const;
     virtual Constraint  getCalleeSavedRegs(OpndKind regKind) const;
     virtual bool        calleeRestoresStack() const { return false; }
-    virtual uint32      getStackAlignment() const { return STACK_ALIGNMENT; }
+    virtual U_32      getStackAlignment() const { return STACK_ALIGNMENT; }
     virtual bool        pushLastToFirst() const { return true; }
 
 };
@@ -191,9 +191,9 @@
 {   
 public: 
     virtual         ~ManagedCallingConventionIA32() {}
-    virtual void    getOpndInfo(ArgKind kind, uint32 argCount, OpndInfo * infos) const;
+    virtual void    getOpndInfo(ArgKind kind, U_32 argCount, OpndInfo * infos) const;
     virtual bool    pushLastToFirst( ) const { return false; }
-    virtual uint32  getStackAlignment() const { return STACK_ALIGNMENT; }
+    virtual U_32  getStackAlignment() const { return STACK_ALIGNMENT; }
 };
 
 class ManagedCallingConventionEM64T: public STDCALLCallingConventionEM64T
@@ -221,7 +221,7 @@
 {
 public:
     virtual         ~MultiArrayCallingConventionEM64T() {}    
-    virtual void    getOpndInfo(ArgKind kind, uint32 argCount, OpndInfo * infos) const;
+    virtual void    getOpndInfo(ArgKind kind, U_32 argCount, OpndInfo * infos) const;
 };
 
 #ifdef _EM64T_

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeEmitter.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeEmitter.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeEmitter.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeEmitter.cpp Thu May 22 06:33:38 2008
@@ -50,11 +50,11 @@
     }
 
 
-    CodeBlockHeat getCodeSectionHeat(uint32 sectionID)const;
+    CodeBlockHeat getCodeSectionHeat(U_32 sectionID)const;
 
 protected:
-    uint32 getNeedInfo()const{ return NeedInfo_LivenessInfo; }
-    uint32 getSideEffects()const{ return 0; }
+    U_32 getNeedInfo()const{ return NeedInfo_LivenessInfo; }
+    U_32 getSideEffects()const{ return 0; }
 
     void runImpl();
     bool verify(bool force=false);
@@ -144,7 +144,7 @@
 
 class CompiledMethodInfo {
 public:
-    CompiledMethodInfo(MemoryManager& mm, POINTER_SIZE_INT addr, MethodMarkerPseudoInst* outerEntry, uint32 idpth):
+    CompiledMethodInfo(MemoryManager& mm, POINTER_SIZE_INT addr, MethodMarkerPseudoInst* outerEntry, U_32 idpth):
         memoryManager(mm),
         locationMap(memoryManager),
         codeSize(0),
@@ -152,8 +152,8 @@
         outerMethodEntry(outerEntry),
         inlineDepth(idpth)
     {}
-    uint32 getCodeSize() { return codeSize; }
-    uint32 getInlineDepth() { return inlineDepth; }
+    U_32 getCodeSize() { return codeSize; }
+    U_32 getInlineDepth() { return inlineDepth; }
     POINTER_SIZE_INT getCodeAddr() { return codeAddr; }
     MethodMarkerPseudoInst* getOuterMethodEntry() { return outerMethodEntry; }
 
@@ -161,13 +161,13 @@
     friend class CodeEmitter;
     MemoryManager& memoryManager;
     LocationMap locationMap;
-    uint32 codeSize;
+    U_32 codeSize;
     POINTER_SIZE_INT codeAddr;
     MethodMarkerPseudoInst* outerMethodEntry;
     // inlineDepth == 1 means that CompiledMethod is inlined into irManager->getMethodDesc()
-    uint32 inlineDepth;
+    U_32 inlineDepth;
 
-    void addCodeSize(uint32 size) { codeSize += size; }
+    void addCodeSize(U_32 size) { codeSize += size; }
 
     void includeInst(Inst* inst, uint64 bcOffset) {
         if( inst->hasKind(Inst::Kind_PseudoInst)) {
@@ -193,7 +193,7 @@
 //________________________________________________________________________________________
 void CodeEmitter::ConstantAreaLayout::collectItems()
 {
-    for (uint32 i=0, n=irManager->getOpndCount(); i<n; ++i){
+    for (U_32 i=0, n=irManager->getOpndCount(); i<n; ++i){
         Opnd * opnd=irManager->getOpnd(i);
         Opnd::RuntimeInfo * ri=NULL;
         if (opnd->isPlacedIn(OpndKind_Mem)&&opnd->getMemOpndKind()==MemOpndKind_ConstantArea){
@@ -275,8 +275,8 @@
         if (item->hasKind(ConstantAreaItem::Kind_SwitchTableConstantAreaItem)){
             void ** table = (void **)item->getAddress();
             Node** bbs=(Node **)item->getValue();
-            uint32 nbb=(uint32)item->getSize()/sizeof(Node*);
-            for (uint32 ibb=0; ibb<nbb; ibb++){
+            U_32 nbb=(U_32)item->getSize()/sizeof(Node*);
+            for (U_32 ibb=0; ibb<nbb; ibb++){
                 BasicBlock* bb=(BasicBlock*)bbs[ibb];
                 assert(bb!=NULL);
                 assert(std::find(nodes.begin(), nodes.end(), bb)!=nodes.end());
@@ -379,7 +379,7 @@
                 InlineInfoMap::Entry* e = inlineBCMap->newEntry(parentEntry, parentEntry->method, bcOffset);
 
                 //register whole entry chain now
-                inlineBCMap->registerEntry(e, (uint32)nativeInstEndOffset);
+                inlineBCMap->registerEntry(e, (U_32)nativeInstEndOffset);
             }
             if (Log::isEnabled()) {
                 if (!parentEntry) {
@@ -389,7 +389,7 @@
                 Log::out()<<" global-bc-offset="<<globalBCMapOffset<<std::endl;
             }
             if (globalBCMapOffset!=ILLEGAL_BC_MAPPING_VALUE) {
-                bcMap->setEntry((uint32)nativeInstStartOffset, globalBCMapOffset);
+                bcMap->setEntry((U_32)nativeInstStartOffset, globalBCMapOffset);
             }
         }
     }
@@ -438,7 +438,7 @@
     if (force || getVerificationLevel() >= 1)
     {
         irManager->updateLivenessInfo();
-        for (uint32 i=0, n=irManager->getOpndCount(); i<n; i++){
+        for (U_32 i=0, n=irManager->getOpndCount(); i<n; i++){
             Opnd * opnd=irManager->getOpnd(i);
             if (!opnd->hasAssignedPhysicalLocation()){
                 VERIFY_OUT("Unassigned operand: " << opnd << ::std::endl);
@@ -482,12 +482,12 @@
 
         uint8 * blockStartIp = ip;
         assert(fit32(blockStartIp-codeStreamStart));
-        bb->setCodeOffset( (uint32)(blockStartIp-codeStreamStart) );
+        bb->setCodeOffset( (U_32)(blockStartIp-codeStreamStart) );
         for (Inst* inst = (Inst*)bb->getFirstInst(); inst!=NULL; inst = inst->getNextInst()) {
             if( inst->hasKind(Inst::Kind_PseudoInst)) {
                 
                 uint8 * instStartIp = ip;
-                inst->setCodeOffset( (uint32)(instStartIp-blockStartIp) );
+                inst->setCodeOffset( (U_32)(instStartIp-blockStartIp) );
                 continue;
             }
 
@@ -508,7 +508,7 @@
                     // if the inst is the only in the bb)
                     Inst* nopInst = irManager->newInst(Mnemonic_NOP);
                     bb->prependInst(nopInst,inst);
-                    nopInst->setCodeOffset( (uint32)(ip-blockStartIp) );
+                    nopInst->setCodeOffset( (U_32)(ip-blockStartIp) );
                     ip = nopInst->emit(ip);
                     // the last two
                     ip = (uint8*)EncoderBase::nops((char*)ip,2);
@@ -522,10 +522,10 @@
             
             uint8 * instStartIp = ip;
             assert(fit32(instStartIp-blockStartIp));
-            inst->setCodeOffset( (uint32)(instStartIp-blockStartIp) );
+            inst->setCodeOffset( (U_32)(instStartIp-blockStartIp) );
             ip = inst->emit(ip);
         }
-        bb->setCodeSize( (uint32)(ip-blockStartIp) );
+        bb->setCodeSize( (U_32)(ip-blockStartIp) );
     }
 
     //register SOE checks offset to be used in unwind as 0-depth area        
@@ -572,12 +572,12 @@
                     uint8 * instCodeStartAddr = (uint8*)inst->getCodeStartAddr();
                     uint8 * instCodeEndAddr = (uint8*)instCodeStartAddr+inst->getCodeSize();
                     uint8 * targetCodeStartAddr = (uint8*)bbTarget->getCodeStartAddr();
-                    uint32 targetOpndIndex = ((ControlTransferInst*)inst)->getTargetOpndIndex();
+                    U_32 targetOpndIndex = ((ControlTransferInst*)inst)->getTargetOpndIndex();
                     int64 offset=targetCodeStartAddr-instCodeEndAddr;               
                     if (offset >= -128 && offset < 127 && inst->getOpnd(targetOpndIndex)->getSize() != OpndSize_8) {
                         inst->setOpnd(targetOpndIndex, irManager->newImmOpnd(irManager->getTypeFromTag(Type::Int8), offset));
                         uint8 * newInstCodeEndAddr = inst->emit(instCodeStartAddr);
-                        bb->setCodeSize(bb->getCodeSize() + (uint32)(newInstCodeEndAddr - instCodeEndAddr));
+                        bb->setCodeSize(bb->getCodeSize() + (U_32)(newInstCodeEndAddr - instCodeEndAddr));
                         newOpndsCreated = true;
                     } 
                 }
@@ -616,7 +616,7 @@
                 uint8 * instCodeStartAddr=(uint8*)inst->getCodeStartAddr();
                 uint8 * instCodeEndAddr=(uint8*)instCodeStartAddr+inst->getCodeSize();
                 uint8 * targetCodeStartAddr=0;
-                uint32 targetOpndIndex = ((ControlTransferInst*)inst)->getTargetOpndIndex();
+                U_32 targetOpndIndex = ((ControlTransferInst*)inst)->getTargetOpndIndex();
                 MethodDesc * md = NULL;
                 if (inst->hasKind(Inst::Kind_BranchInst)){
                     BasicBlock * bbTarget=(BasicBlock*)((BranchInst*)inst)->getTrueTarget();
@@ -654,7 +654,7 @@
                     uint8* blockStartIp = (uint8*)bb->getCodeStartAddr();
                     // 10 bytes are dumped with 'nops' ahead of the call especially for this MOV
                     uint8* movAddr = instCodeStartAddr-10;
-                    movInst->setCodeOffset((uint32)(movAddr - blockStartIp));
+                    movInst->setCodeOffset((U_32)(movAddr - blockStartIp));
                     uint8* callAddr = movInst->emit(movAddr);
                     assert(callAddr == instCodeStartAddr);
                     // then dump 2 bytes with nops to keep return ip the same for both
@@ -662,7 +662,7 @@
                     EncoderBase::nops((char*)(callAddr), 2);
                     // reemit the call as a register-based at the address 'callAddr+2'
                     inst->emit(callAddr+2);
-                    inst->setCodeOffset( (uint32)(callAddr + 2 - blockStartIp) );
+                    inst->setCodeOffset( (U_32)(callAddr + 2 - blockStartIp) );
                     // the register call is being registered for patching in the same way as immediate calls
                     // code patcher takes care of the correct patching
                     if(md) {
@@ -713,7 +713,7 @@
 
     // we can not guarantee the (callAddr+1) aligned
     // self-jump is a kind of lock for the time of call patching
-    uint32 movSize =
+    U_32 movSize =
 #ifdef _EM64T_
                      10;
 #else
@@ -769,12 +769,12 @@
         EncoderBase::nops((char*)(movAddr), 10);
         // emit the call in immediate form
         args.clear();
-        args.add(EncoderBase::Operand(OpndSize_32, (int32)offset));
+        args.add(EncoderBase::Operand(OpndSize_32, (I_32)offset));
         EncoderBase::encode((char*)callAddr, Mnemonic_CALL, args); // 5 bytes
     } else
 #endif
     { // offset fits into 32 bits
-        *(uint32*)(callAddr+1) = (uint32)offset;
+        *(U_32*)(callAddr+1) = (U_32)offset;
     }
 
     // removing self-jump
@@ -787,7 +787,7 @@
 }
 
 //________________________________________________________________________________________
-CodeBlockHeat CodeEmitter::getCodeSectionHeat(uint32 sectionID)const
+CodeBlockHeat CodeEmitter::getCodeSectionHeat(U_32 sectionID)const
 {
     CodeBlockHeat heat;
     if (irManager->getCompilationContext()->hasDynamicProfileToUse())
@@ -823,9 +823,9 @@
         registerExceptionRegion((void*)regionStart, (void*)regionEnd, regionDispatchNode);
     }
 
-    uint32 handlerInfoCount=(uint32)exceptionHandlerInfos.size();
+    U_32 handlerInfoCount=(U_32)exceptionHandlerInfos.size();
     irManager->getMethodDesc().setNumExceptionHandler(handlerInfoCount);
-    for (uint32 i=0; i<handlerInfoCount; i++){
+    for (U_32 i=0; i<handlerInfoCount; i++){
         const ExceptionHandlerInfo & info=exceptionHandlerInfos[i];
         if (Log::isEnabled()) {
             Log::out() << "Exception Handler Info [ " << i << "]: " << ::std::endl;
@@ -848,8 +848,8 @@
 
 static bool edge_prior_comparator(const Edge* e1, const Edge* e2) {
     assert(e1->isCatchEdge() && e2->isCatchEdge());
-    uint32 p1 = ((CatchEdge*)e1)->getPriority();
-    uint32 p2 = ((CatchEdge*)e2)->getPriority();
+    U_32 p1 = ((CatchEdge*)e1)->getPriority();
+    U_32 p2 = ((CatchEdge*)e2)->getPriority();
     assert(p1!=p2 || e1==e2);
     return p1 < p2 ? true : p1 > p2 ? false : e1 > e2;
 };
@@ -907,7 +907,7 @@
                                             Node* node, bool isForward) {
     assert(node!=NULL);
     assert(traversalInfo[node->getId()]==0); //node is white here
-    uint32 nodeId = node->getId();
+    U_32 nodeId = node->getId();
     traversalInfo[nodeId] = 1; //mark node gray
     // preprocess the node
     if (node->getKind() == Node::Kind_Block) {
@@ -931,7 +931,7 @@
                 methInfo = new(memoryManager) CompiledMethodInfo(memoryManager,
                                                                  (POINTER_SIZE_INT)methMarkerInst->getCodeStartAddr(),
                                                                  oldMethodEntryInst,
-                                                                 (uint32)inlineStack.size());
+                                                                 (U_32)inlineStack.size());
 
                 methodLocationMap[methMarkerInst] = methInfo;
             } else if (inst->getKind() == Inst::Kind_MethodEndPseudoInst) {
@@ -946,14 +946,14 @@
                     if( ! inst->hasKind(Inst::Kind_PseudoInst)) {
                         POINTER_SIZE_INT instAddr = (POINTER_SIZE_INT)inst->getCodeStartAddr();
                         POINTER_SIZE_INT nextAddr = (POINTER_SIZE_INT)inst->getNext()->getCodeStartAddr();
-                        uint32 instSize = inst->getCodeSize();
+                        U_32 instSize = inst->getCodeSize();
                         if (inst->getMnemonic() == Mnemonic_NOP && instAddr+instSize < nextAddr) {
                             // there is a special case when code patching support generates 3 (ia32) or 13 (em64t) nops
                             // before calls for future runtime patching. First nop is generated as a common CFG inst.
                             // The rest ones are generated directly to the memory using encoder.
                             // Taking this into account:
                             assert(nextAddr > instAddr);
-                            instSizeMap[instAddr] = (uint32)(nextAddr-instAddr);
+                            instSizeMap[instAddr] = (U_32)(nextAddr-instAddr);
                         } else {
                             instSizeMap[instAddr] = instSize;
                         }
@@ -1017,8 +1017,8 @@
 
     POINTER_SIZE_INT methodStartAddr = litStart == litEnd ? methInfo->getCodeAddr() : (*litStart).first;
     POINTER_SIZE_INT prevAddr = 0;
-    uint32 methodSize = 0;
-    uint32 locationMapSize = 0;
+    U_32 methodSize = 0;
+    U_32 locationMapSize = 0;
 
     for (lit = litStart; lit != litEnd; lit++) {
 
@@ -1081,7 +1081,7 @@
     // send events according to inlining depth
     // depth == 1 - the first level inlinees
     bool found = false;
-    uint32 depth = 1;
+    U_32 depth = 1;
     do {
         found = false;
         for (i = methodLocationMap.begin(); i != itEnd; i++) {

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeGenerator.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeGenerator.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeGenerator.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeGenerator.cpp Thu May 22 06:33:38 2008
@@ -42,7 +42,7 @@
 {
 
 //___________________________________________________________________________________________________
-void _cdecl die(uint32 retCode, const char * message, ...)
+void _cdecl die(U_32 retCode, const char * message, ...)
 {
     ::std::cerr<<"---------- die called (ret code = "<<retCode<<") --------------------------------------"<<std::endl;
     if (message!=NULL){
@@ -59,8 +59,8 @@
 //___________________________________________________________________________________________________
 class InstructionFormTranslator : public SessionAction {
     void runImpl(){ irManager->translateToNativeForm(); }
-    uint32 getNeedInfo()const{ return 0; }
-    uint32 getSideEffects()const{ return 0; }
+    U_32 getNeedInfo()const{ return 0; }
+    U_32 getSideEffects()const{ return 0; }
 };
 
 static ActionFactory<InstructionFormTranslator> _native("native");
@@ -68,8 +68,8 @@
 //___________________________________________________________________________________________________
 class UserRequestedDie : public SessionAction {
     void runImpl(){ die(10, getArg("msg")); }
-    uint32 getNeedInfo()const{ return 0; }
-    uint32 getSideEffects()const{ return 0; }
+    U_32 getNeedInfo()const{ return 0; }
+    U_32 getSideEffects()const{ return 0; }
     bool isIRDumpEnabled(){ return false; }
 };
 
@@ -80,8 +80,8 @@
     void runImpl(){ 
         irManager->getFlowGraph()->getEntryNode()->prependInst(irManager->newInst(Mnemonic_INT3));
     }
-    uint32 getNeedInfo()const{ return 0; }
-    uint32 getSideEffects()const{ return 0; }
+    U_32 getNeedInfo()const{ return 0; }
+    U_32 getSideEffects()const{ return 0; }
     bool isIRDumpEnabled(){ return false; }
 };
 
@@ -97,7 +97,7 @@
 void CodeGenerator::genCode(::Jitrino::SessionAction* sa, ::Jitrino::MethodCodeSelector& inputProvider) {
     LogStream& irdump  = Log::log(LogStream::IRDUMP);
     LogStream& dotdump = Log::log(LogStream::DOTDUMP);
-    uint32 stageId = Log::getStageId();
+    U_32 stageId = Log::getStageId();
     const char* stageName = sa->getName();
     if (irdump.isEnabled()) {
         Log::printStageBegin(irdump.out(), stageId, "IA32", stageName, stageName);

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeLayout.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeLayout.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeLayout.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeLayout.cpp Thu May 22 06:33:38 2008
@@ -198,8 +198,8 @@
 
 void Linearizer::checkLayout(IRManager* irm) {
 #ifdef _DEBUG
-    uint32 maxNodes = irm->getFlowGraph()->getMaxNodeId();
-    StlVector<uint32> numVisits(irm->getMemoryManager(), maxNodes, 0); 
+    U_32 maxNodes = irm->getFlowGraph()->getMaxNodeId();
+    StlVector<U_32> numVisits(irm->getMemoryManager(), maxNodes, 0); 
     StlVector<bool> isBB(irm->getMemoryManager(), maxNodes, false);
     
     // Find basic blocks
@@ -214,7 +214,7 @@
                 assert(!wasLast);
                 wasLast = true;
             } else {
-                uint32 id = layoutSucc->getId();
+                U_32 id = layoutSucc->getId();
                 numVisits[id]++;
                 assert(numVisits[id] == 1);
             }
@@ -224,8 +224,8 @@
     
     // Check that every basic block has been visited once
     bool wasFirst = false;
-    for (uint32 i = 0; i < maxNodes; i++) {
-        uint32 correctNumVisits = isBB[i] ? 1 : 0;
+    for (U_32 i = 0; i < maxNodes; i++) {
+        U_32 correctNumVisits = isBB[i] ? 1 : 0;
         if (numVisits[i] != correctNumVisits) {
             if (isBB[i] && numVisits[i] == 0 && !wasFirst) {
                 wasFirst = true;

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeLayout.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeLayout.h?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeLayout.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeLayout.h Thu May 22 06:33:38 2008
@@ -33,8 +33,8 @@
 
 class Layouter : public SessionAction {
     void runImpl();
-    uint32 getSideEffects() const {return 0;}
-    uint32 getNeedInfo()const{ return 0;}
+    U_32 getSideEffects() const {return 0;}
+    U_32 getNeedInfo()const{ return 0;}
 };
 
 /**

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeLayoutBottomUp.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeLayoutBottomUp.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeLayoutBottomUp.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeLayoutBottomUp.cpp Thu May 22 06:33:38 2008
@@ -207,7 +207,7 @@
     assert(*chains.begin() ==irManager->getFlowGraph()->getEntryNode());
 
     assert(*chains.begin() == irManager->getFlowGraph()->getEntryNode());
-    for (uint32 i = 0, n = (uint32)chains.size()-1; i<n;i++) {
+    for (U_32 i = 0, n = (U_32)chains.size()-1; i<n;i++) {
         BasicBlock* firstChain = chains[i];
         BasicBlock* secondChain= chains[i+1];
         BasicBlock* lastInFirst = firstChain;

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeSelector.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeSelector.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeSelector.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeSelector.cpp Thu May 22 06:33:38 2008
@@ -50,7 +50,7 @@
                                  CompilationInterface&      compIntfc,
                                  MethodCodeSelector& methodCodeSel,
                                  MemoryManager&          codeSelectorMM, 
-                                 uint32                  nNodes, 
+                                 U_32                  nNodes, 
                                  IRManager&          irM
                                  )
     : numNodes(nNodes), nextNodeId(0), compilationInterface(compIntfc), methodCodeSelector(methodCodeSel),
@@ -60,7 +60,7 @@
 {
     nextNodeId = 0;
     nodes = new (codeSelectorMemManager) Node*[numNodes];
-    uint32 i;
+    U_32 i;
     for (i = 0; i < numNodes; i++) 
         nodes[i] = NULL;
 
@@ -72,10 +72,10 @@
 //_______________________________________________________________________________________________
 /**  Create an exception handling (dispatching) node */
 
-uint32 CfgCodeSelector::genDispatchNode(uint32 numInEdges,uint32 numOutEdges, const StlVector<MethodDesc*>& inlineEndMarkers, double cnt) 
+U_32 CfgCodeSelector::genDispatchNode(U_32 numInEdges,U_32 numOutEdges, const StlVector<MethodDesc*>& inlineEndMarkers, double cnt) 
 {
     assert(nextNodeId < numNodes);
-    uint32 nodeId = nextNodeId++;
+    U_32 nodeId = nextNodeId++;
     Node* node = irManager.getFlowGraph()->createDispatchNode();
     node->setExecCount(cnt);
     nodes[nodeId] = node;
@@ -90,14 +90,14 @@
 //_______________________________________________________________________________________________
 /**  Create a basic block */
 
-uint32 CfgCodeSelector::genBlock(uint32              numInEdges,
-                                    uint32              numOutEdges,
+U_32 CfgCodeSelector::genBlock(U_32              numInEdges,
+                                    U_32              numOutEdges,
                                     BlockKind           blockKind,
                                     BlockCodeSelector&  codeSelector,
                                     double              cnt) 
 {
     assert(nextNodeId < numNodes);
-    uint32 nodeId = nextNodeId++;
+    U_32 nodeId = nextNodeId++;
     Node* bb = irManager.getFlowGraph()->createBlockNode();
     bb->setExecCount(cnt);
     nodes[nodeId] = bb;
@@ -130,7 +130,7 @@
 
     if (instCodeSelector.endsWithSwitch()) {
         // Generate an additional node that contains switch dispatch
-        uint32      numTargets = instCodeSelector.getSwitchNumTargets(); 
+        U_32      numTargets = instCodeSelector.getSwitchNumTargets(); 
         Opnd * switchSrc = instCodeSelector.getSwitchSrc();
         genSwitchBlock(bb, numTargets, switchSrc);
     }
@@ -145,12 +145,12 @@
     We create it using code selector memory manager and insert it into its own CFG.
 */
 
-uint32  CfgCodeSelector::genUnwindNode(uint32 numInEdges, 
-                                          uint32 numOutEdges,
+U_32  CfgCodeSelector::genUnwindNode(U_32 numInEdges, 
+                                          U_32 numOutEdges,
                                           double cnt) 
 {
     assert(nextNodeId < numNodes);
-    uint32 nodeId = nextNodeId++;
+    U_32 nodeId = nextNodeId++;
     ControlFlowGraph* fg = irManager.getFlowGraph();
     Node* unwindNode = fg->createDispatchNode();
     fg->setUnwindNode(unwindNode);
@@ -162,10 +162,10 @@
 //_______________________________________________________________________________________________
 /**  Create exit node */
 
-uint32 CfgCodeSelector::genExitNode(uint32 numInEdges, double cnt) 
+U_32 CfgCodeSelector::genExitNode(U_32 numInEdges, double cnt) 
 {
     assert(nextNodeId < numNodes);
-    uint32 nodeId = nextNodeId++;
+    U_32 nodeId = nextNodeId++;
     ControlFlowGraph* fg = irManager.getFlowGraph();
     Node* exitNode = fg->createExitNode();
     exitNode->setExecCount(cnt);
@@ -178,7 +178,7 @@
 /**  Create a block for a switch statement */
 
 void CfgCodeSelector::genSwitchBlock(Node *originalBlock,
-                                        uint32         numTargets, 
+                                        U_32         numTargets, 
                                         Opnd *      switchSrc) 
 {
     Node *bb = irManager.getFlowGraph()->createBlockNode();
@@ -194,7 +194,7 @@
 //_______________________________________________________________________________________________
 /**  Create true edge (i.e., edge that corresponds to a taken conditional branch) */
 
-void CfgCodeSelector::genTrueEdge(uint32 tailNodeId,uint32 headNodeId, double prob) 
+void CfgCodeSelector::genTrueEdge(U_32 tailNodeId,U_32 headNodeId, double prob) 
 {
     Node* tailNode= nodes[tailNodeId];
     Node * headNode = nodes[headNodeId];
@@ -215,7 +215,7 @@
 //_______________________________________________________________________________________________
 /**  Create false edge (i.e., edge that corresponds to a fallthrough after untaken conditional branch) */
 
-void CfgCodeSelector::genFalseEdge(uint32 tailNodeId,uint32 headNodeId, double prob) 
+void CfgCodeSelector::genFalseEdge(U_32 tailNodeId,U_32 headNodeId, double prob) 
 {
     Node* tailNode = nodes[tailNodeId];
     Node* headNode = nodes[headNodeId];
@@ -236,7 +236,7 @@
 //_______________________________________________________________________________________________
 /**  Create unconditional edge (i.e., edge that corresponds to fallthrough) */
 
-void CfgCodeSelector::genUnconditionalEdge(uint32 tailNodeId,uint32 headNodeId, double prob) 
+void CfgCodeSelector::genUnconditionalEdge(U_32 tailNodeId,U_32 headNodeId, double prob) 
 {
     Node * tailNode = nodes[tailNodeId];
     Node * headNode = nodes[headNodeId];
@@ -255,9 +255,9 @@
 //_______________________________________________________________________________________________
 /**  Create switch edges */
 
-void CfgCodeSelector::genSwitchEdges(uint32 tailNodeId, uint32 numTargets, 
-                                        uint32 *targets, double *probs, 
-                                        uint32 defaultTarget) 
+void CfgCodeSelector::genSwitchEdges(U_32 tailNodeId, U_32 numTargets, 
+                                        U_32 *targets, double *probs, 
+                                        U_32 defaultTarget) 
 {
     // 
     //  Switch structure:
@@ -278,8 +278,8 @@
 
     double    defaultEdgeProb = 1.0;
     defaultEdgeProb = 1.0;
-    for (uint32 i = 0; i < numTargets; i++) {
-        uint32 targetId = targets[i];
+    for (U_32 i = 0; i < numTargets; i++) {
+        U_32 targetId = targets[i];
         if ( targetId == defaultTarget) {
             defaultEdgeProb = probs[i];
             break;
@@ -301,7 +301,7 @@
         origBlock->getOutEdges().front()->setEdgeProb(1.0 - defaultEdgeProb);
     }
     //  Generate edges from switchBlock to switch targets
-    for (uint32 i = 0; i < numTargets; i++) {
+    for (U_32 i = 0; i < numTargets; i++) {
         Node * targetNode = nodes[targets[i]];
         // Avoid generating duplicate edges. Jump table however needs all entries
         if (! switchBlock->isConnectedTo(true, targetNode)) {
@@ -314,7 +314,7 @@
 //_______________________________________________________________________________________________
 /**  Create an edge to the exception dispatch node or unwind node  */
 
-void CfgCodeSelector::genExceptionEdge(uint32 tailNodeId, uint32 headNodeId, double prob) 
+void CfgCodeSelector::genExceptionEdge(U_32 tailNodeId, U_32 headNodeId, double prob) 
 {
     Node * headNode = nodes[headNodeId];
     Node * tailNode = nodes[tailNodeId];
@@ -325,9 +325,9 @@
 //_______________________________________________________________________________________________
 /**  Create catch edge */
 
-void CfgCodeSelector::genCatchEdge(uint32 tailNodeId, 
-                                      uint32 headNodeId,
-                                      uint32 priority,
+void CfgCodeSelector::genCatchEdge(U_32 tailNodeId, 
+                                      U_32 headNodeId,
+                                      U_32 priority,
                                       Type*  exceptionType, 
                                       double prob) 
 {
@@ -358,14 +358,14 @@
 ///////////////////////////////////////////////////////////////////////////////////
 
 //_______________________________________________________________________________________________
-uint32 VarGenerator::defVar(Type* varType, bool isAddressTaken, bool isPinned) 
+U_32 VarGenerator::defVar(Type* varType, bool isAddressTaken, bool isPinned) 
 {
     Opnd * opnd=irManager.newOpnd(varType);
     return opnd->getId(); 
 }
 
 //_______________________________________________________________________________________________
-void VarGenerator::setManagedPointerBase(uint32 managedPtrVarNum, uint32 baseVarNum) 
+void VarGenerator::setManagedPointerBase(U_32 managedPtrVarNum, U_32 baseVarNum) 
 {
 }
 
@@ -379,7 +379,7 @@
 //_______________________________________________________________________________________________
 /**  Generate variable operands */
 
-void MethodCodeSelector::genVars(uint32           numVars, VarCodeSelector& varCodeSelector) 
+void MethodCodeSelector::genVars(U_32           numVars, VarCodeSelector& varCodeSelector) 
 {
     numVarOpnds = numVars;
     VarGenerator varCodeSelectorCallback(irManager,*this);
@@ -494,7 +494,7 @@
 }
 
 
-void MethodCodeSelector::genCFG(uint32 numNodes, CFGCodeSelector& codeSelector, 
+void MethodCodeSelector::genCFG(U_32 numNodes, CFGCodeSelector& codeSelector, 
                                    bool useEdgeProfile) 
 {
     ControlFlowGraph* fg = irManager.getFlowGraph();

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeSelector.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeSelector.h?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeSelector.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeSelector.h Thu May 22 06:33:38 2008
@@ -80,26 +80,26 @@
     //
     CfgCodeSelector(::Jitrino::SessionAction* sa, CompilationInterface& compIntfc,
                          MethodCodeSelector& methodCodeSel, 
-                         MemoryManager& codeSelectorMM, uint32 nNodes, 
+                         MemoryManager& codeSelectorMM, U_32 nNodes, 
                          IRManager& irM);
 
-    uint32  genDispatchNode(uint32 numInEdges, uint32 numOutEdges, const StlVector<MethodDesc*>& inlineEndMarkers, double cnt);
-    uint32  genBlock(uint32 numInEdges, uint32 numOutEdges, BlockKind blockKind,
+    U_32  genDispatchNode(U_32 numInEdges, U_32 numOutEdges, const StlVector<MethodDesc*>& inlineEndMarkers, double cnt);
+    U_32  genBlock(U_32 numInEdges, U_32 numOutEdges, BlockKind blockKind,
                      BlockCodeSelector& codeSelector, double cnt);
-    uint32  genUnwindNode(uint32 numInEdges, uint32 numOutEdges,double cnt);
-    uint32  genExitNode(uint32 numInEdges, double cnt);
-    void    genUnconditionalEdge(uint32 tailNodeId,uint32 headNodeId, double prob);
-    void    genTrueEdge(uint32 tailNodeId,uint32 headNodeId, double prob);
+    U_32  genUnwindNode(U_32 numInEdges, U_32 numOutEdges,double cnt);
+    U_32  genExitNode(U_32 numInEdges, double cnt);
+    void    genUnconditionalEdge(U_32 tailNodeId,U_32 headNodeId, double prob);
+    void    genTrueEdge(U_32 tailNodeId,U_32 headNodeId, double prob);
     void    genTrueEdge(Node* tailNode, Node* headNode, double prob);
-    void    genFalseEdge(uint32 tailNodeId,uint32 headNodeId, double prob);
+    void    genFalseEdge(U_32 tailNodeId,U_32 headNodeId, double prob);
     void    genFalseEdge(Node* tailNode, Node* headNode, double prob);
-    void    genSwitchEdges(uint32 tailNodeId, uint32 numTargets, uint32 *targets, 
-                           double *probs, uint32 defaultTarget);
-    void    genExceptionEdge(uint32 tailNodeId, uint32 headNodeId, double prob);
-    void    genCatchEdge(uint32 headNodeId,uint32 tailNodeId,
-                         uint32 priority,Type* exceptionType, double prob);
+    void    genSwitchEdges(U_32 tailNodeId, U_32 numTargets, U_32 *targets, 
+                           double *probs, U_32 defaultTarget);
+    void    genExceptionEdge(U_32 tailNodeId, U_32 headNodeId, double prob);
+    void    genCatchEdge(U_32 headNodeId,U_32 tailNodeId,
+                         U_32 priority,Type* exceptionType, double prob);
     
-    void    setPersistentId(uint32 nodeId, uint32 persistentId) {
+    void    setPersistentId(U_32 nodeId, U_32 persistentId) {
         ((CGNode*)nodes[nodeId])->setPersistentId(persistentId);
     }
 
@@ -127,7 +127,7 @@
     //
     //    Methods
     //
-    void    genSwitchBlock(Node *originalBlock, uint32 numTargets, 
+    void    genSwitchBlock(Node *originalBlock, U_32 numTargets, 
                            Opnd *switchSrc);
     void    genEpilogNode();
     Inst *  findExceptionInst(Node* block);
@@ -136,8 +136,8 @@
     //  Fields
     //
     Node**                  nodes;
-    uint32                  numNodes;
-    uint32                  nextNodeId;
+    U_32                  numNodes;
+    U_32                  nextNodeId;
     CompilationInterface&   compilationInterface;
     MethodCodeSelector&     methodCodeSelector;
     MemoryManager&          irMemManager;           // for data live after code selection
@@ -173,9 +173,9 @@
                             IRManager&          irM);
      
 
-      void                genVars(uint32 numVars, ::Jitrino::VarCodeSelector& varCodeSelector);
+      void                genVars(U_32 numVars, ::Jitrino::VarCodeSelector& varCodeSelector);
     void                setMethodDesc(MethodDesc * desc) {methodDesc = desc;}
-    void                genCFG(uint32 numNodes, ::Jitrino::CFGCodeSelector& codeSelector, bool useDynamicProfile);
+    void                genCFG(U_32 numNodes, ::Jitrino::CFGCodeSelector& codeSelector, bool useDynamicProfile);
     
     MethodDesc *        getMethodDesc() {return methodDesc;}
 private:
@@ -220,10 +220,10 @@
     VarGenerator(IRManager& irM, MethodCodeSelector& methodCodeSel) 
      : nextVarId(0), irManager(irM), methodCodeSelector(methodCodeSel) {
     }
-    uint32    defVar(Type* varType, bool isAddressTaken, bool isPinned);
-    void      setManagedPointerBase(uint32 managedPtrVarNum, uint32 baseVarNum);
+    U_32    defVar(Type* varType, bool isAddressTaken, bool isPinned);
+    void      setManagedPointerBase(U_32 managedPtrVarNum, U_32 baseVarNum);
 private:
-    uint32                  nextVarId;
+    U_32                  nextVarId;
     IRManager&              irManager;
     MethodCodeSelector&     methodCodeSelector;
 };

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32ComplexAddrFormLoader.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32ComplexAddrFormLoader.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32ComplexAddrFormLoader.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32ComplexAddrFormLoader.cpp Thu May 22 06:33:38 2008
@@ -53,7 +53,7 @@
     bool checkIsScale(Inst * inst);
     void walkThroughOpnds(SubOpndsTable& table);
 private:
-    uint32 refCountThreshold;
+    U_32 refCountThreshold;
 };
 
 static ActionFactory<ComplexAddrFormLoader> _cafl("cafl");
@@ -67,9 +67,9 @@
     }
 
     StlMap<Opnd *, bool> memOpnds(irManager->getMemoryManager());
-    uint32 opndCount = irManager->getOpndCount();
+    U_32 opndCount = irManager->getOpndCount();
     irManager->calculateOpndStatistics();
-    for (uint32 i = 0; i < opndCount; i++) {
+    for (U_32 i = 0; i < opndCount; i++) {
         Opnd * opnd = irManager->getOpnd(i);
         if(opnd->isPlacedIn(OpndKind_Mem)) {
             Opnd * baseOp = opnd->getMemOpndSubOpnd(MemOpndSubOpndKind_Base);
@@ -177,7 +177,7 @@
         return;
     } 
 
-    uint32 defCount = instUp->getOpndCount(Inst::OpndRole_InstLevel|Inst::OpndRole_Def);
+    U_32 defCount = instUp->getOpndCount(Inst::OpndRole_InstLevel|Inst::OpndRole_Def);
     if(instUp->getMnemonic()==Mnemonic_ADD) {
         Opnd * src1 = instUp->getOpnd(defCount);
         Opnd * src2 = instUp->getOpnd(defCount+1);

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32Constraint.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32Constraint.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32Constraint.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32Constraint.cpp Thu May 22 06:33:38 2008
@@ -35,7 +35,7 @@
 const char * Constraint::parse(const char * str)
 {
     Constraint szc, kc;
-    for (uint32 i=0, j=0; i<0x100 && *str;){
+    for (U_32 i=0, j=0; i<0x100 && *str;){
         const char * tokenEnd=str; char token[0x100];
         for (j=0; j<0x100 && *tokenEnd && (isalpha(*tokenEnd)||isdigit(*tokenEnd)); tokenEnd++, j++)
             token[j]=*tokenEnd;
@@ -78,7 +78,7 @@
 }
 
 //_________________________________________________________________________________________________
-OpndSize Constraint::getDefaultSize(uint32 k)
+OpndSize Constraint::getDefaultSize(U_32 k)
 {
     OpndKind regKind=(OpndKind)(k & OpndKind_Reg);
     if (regKind){
@@ -99,7 +99,7 @@
 }
 
 //_________________________________________________________________________________________________
-Constraint Constraint::getAliasConstraint(OpndSize s, uint32 offset)const
+Constraint Constraint::getAliasConstraint(OpndSize s, U_32 offset)const
 {
     OpndSize sz=(OpndSize)size;
     if (s==OpndSize_Default){
@@ -112,8 +112,8 @@
     if (sz>s)
         return Constraint();
 
-    uint32 newKind=kind, newMask=0;
-    uint32 newRegKind=newKind & OpndKind_Reg;
+    U_32 newKind=kind, newMask=0;
+    U_32 newRegKind=newKind & OpndKind_Reg;
     OpndSize maxSubregisterSize =
 #ifdef _EM64T_
                                     OpndSize_32;
@@ -138,7 +138,7 @@
 }
 
 //_________________________________________________________________________________________________
-RegName Constraint::getAliasRegName(RegName regName, OpndSize sz, uint32 offset)
+RegName Constraint::getAliasRegName(RegName regName, OpndSize sz, U_32 offset)
 {
     if (regName==RegName_Null)
         return RegName_Null;
@@ -158,7 +158,7 @@
     if (regKind==OpndKind_GPReg){
 #ifndef _EM64T_
         if (sz==OpndSize_8 && (s==OpndSize_16 || s==OpndSize_32)){
-            uint32 idx=getRegIndex(regName);
+            U_32 idx=getRegIndex(regName);
             if (idx>4)
                 return RegName_Null;
             return getRegName(regKind, sz, idx);
@@ -178,7 +178,7 @@
 }
 
 //_________________________________________________________________________________________________
-RegName Constraint::getAliasRegName(RegName regName, uint32 offset)const
+RegName Constraint::getAliasRegName(RegName regName, U_32 offset)const
 {
     RegName rn=getAliasRegName(regName, (OpndSize)size, offset);
     return contains(rn)?rn:RegName_Null;

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32Constraint.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32Constraint.h?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32Constraint.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32Constraint.h Thu May 22 06:33:38 2008
@@ -91,7 +91,7 @@
 
     For OpndKind_Reg and sub-kinds initializes the mask field to 0xffff
     */
-    Constraint(OpndKind k, OpndSize s, uint32 m)
+    Constraint(OpndKind k, OpndSize s, U_32 m)
         :mask(m), size(s), kind(k)
     {   assert(k!=OpndKind_Null && size!=OpndSize_Null); assert(mask==0||(OpndKind_Reg&k)!=0);  }
 
@@ -113,14 +113,14 @@
 
     //----------------------------------------------------------------------
     /** returns the kind field of the constraint */
-    uint32 getKind()const{ return kind; }
+    U_32 getKind()const{ return kind; }
     /** returns the size field of the constraint */
     OpndSize getSize()const{ return (OpndSize)size; }
     /** returns the mask field of the constraint */
-    uint32 getMask()const{ return mask; }
+    U_32 getMask()const{ return mask; }
 
     /** sets the mask field of the constraint */
-    void setMask(uint32 m){ mask=m; }
+    void setMask(U_32 m){ mask=m; }
 
     /** resets the constraint to the Null value */
     void makeNull(){ fullValue = 0; }
@@ -147,7 +147,7 @@
     bool isNull()const{ return kind==OpndKind_Null; }
 
     /** Returns the default size for the OpndKind combination k */
-    static OpndSize getDefaultSize(uint32 k);
+    static OpndSize getDefaultSize(U_32 k);
 
     /** Returns true if 'this' can be merged (via unionWith) with c 
     
@@ -157,11 +157,11 @@
     */
     bool        canBeMergedWith(Constraint c)
     {
-        uint32 filter = (uint32)OpndKind_Reg << 24;
-        uint32 thisTmp = fullValue & filter, cTmp = c.fullValue & filter, rTmp = thisTmp & cTmp; 
+        U_32 filter = (U_32)OpndKind_Reg << 24;
+        U_32 thisTmp = fullValue & filter, cTmp = c.fullValue & filter, rTmp = thisTmp & cTmp; 
         if (rTmp!=thisTmp && rTmp!=cTmp)
             return false;
-        filter = (uint32)OpndSize_Any << 16;
+        filter = (U_32)OpndSize_Any << 16;
         thisTmp = fullValue & filter, cTmp = c.fullValue & filter, rTmp = thisTmp & cTmp; 
         return rTmp==thisTmp || rTmp==cTmp;
     }
@@ -201,7 +201,7 @@
     /** Returns the constraint for an outer aliased operand
     s must be greater than or equal to the constraint's size
     */
-    Constraint getAliasConstraint(OpndSize s, uint32 offset=0)const;
+    Constraint getAliasConstraint(OpndSize s, U_32 offset=0)const;
 
 
     /** Returns the regname for an aliased regname
@@ -209,18 +209,18 @@
     e.g. for eax it can return eax, ax, ah, al, depending on the constraint
     The constraint's size must be less than or equal to regName's size
     */
-    static RegName      getAliasRegName(RegName regName, OpndSize s, uint32 offset=0);
-    RegName     getAliasRegName(RegName regName, uint32 offset=0)const;
+    static RegName      getAliasRegName(RegName regName, OpndSize s, U_32 offset=0);
+    RegName     getAliasRegName(RegName regName, U_32 offset=0)const;
 
     //----------------------------------------------------------------------
 private:
     union{
         struct {
-            uint32  mask:16;
-            uint32  size:8;
-            uint32  kind:8;
+            U_32  mask:16;
+            U_32  size:8;
+            U_32  kind:8;
         };
-        uint32  fullValue;
+        U_32  fullValue;
     };
     
     friend struct DefaultConstraintInitializer;

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32ConstraintsResolver.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32ConstraintsResolver.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32ConstraintsResolver.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32ConstraintsResolver.cpp Thu May 22 06:33:38 2008
@@ -123,8 +123,8 @@
     /** runImpl is required override, calls ConstraintsResolverImpl.runImpl */
     void runImpl();
     /** This transformer requires up-to-date liveness info */
-    uint32 getNeedInfo()const{ return NeedInfo_LivenessInfo; }
-    uint32 getSideEffects()const{ return 0; }
+    U_32 getNeedInfo()const{ return NeedInfo_LivenessInfo; }
+    U_32 getSideEffects()const{ return 0; }
 
 };
 
@@ -238,11 +238,11 @@
     liveAtDispatchBlockEntry.resizeClear(originalOpndCount);
 
     opndReplaceWorkset.resize(originalOpndCount);
-    for (uint32 i=0; i<originalOpndCount; i++)
+    for (U_32 i=0; i<originalOpndCount; i++)
         opndReplaceWorkset[i]=NULL;
 
     opndUsage.resize(originalOpndCount);
-    for (uint32 i=0; i<originalOpndCount; i++)
+    for (U_32 i=0; i<originalOpndCount; i++)
         opndUsage[i]=0;
 
 
@@ -282,8 +282,8 @@
         Node* node = *it;
         if (node->isBlockNode()){
             double bbecv = getBasicBlockPriority(node);
-            uint32 ibb=0;
-            for (uint32 nbb=(uint32)basicBlocks.size(); ibb<nbb; ++ibb){
+            U_32 ibb=0;
+            for (U_32 nbb=(U_32)basicBlocks.size(); ibb<nbb; ++ibb){
                 if (bbecv > getBasicBlockPriority(basicBlocks[ibb]))
                     break;
             }
@@ -310,7 +310,7 @@
 // Reset calculated constraints to null constraints
     irManager.resetOpndConstraints();
 // For all operands in the CFG
-    for (uint32 i=0; i<originalOpndCount; i++){ 
+    for (U_32 i=0; i<originalOpndCount; i++){ 
         Opnd * opnd=irManager.getOpnd(i);
 
         Constraint c=opnd->getConstraint(Opnd::ConstraintKind_Initial);
@@ -339,9 +339,9 @@
 {
     if (cnew.isNull())
         return true;
-    uint32 newMask = cnew.getMask(), oldMask = cold.getMask();
+    U_32 newMask = cnew.getMask(), oldMask = cold.getMask();
     if ((newMask & oldMask) != oldMask){
-        uint32 newMaskCount = countOnes(newMask);
+        U_32 newMaskCount = countOnes(newMask);
         return 
             (newMaskCount == 0 && normedBBExecCount < splitThresholdForNoRegs) ||
             (newMaskCount <= 1 && normedBBExecCount < splitThresholdFor1Reg) ||
@@ -547,7 +547,7 @@
 
     // if we come to bb entry with some replacement for an operand and the operand is live at the entry
     // insert copying from the original operand to the replacement operand
-    uint32 execCount = (uint32)bb->getExecCount();
+    U_32 execCount = (U_32)bb->getExecCount();
     BitSet * ls = irManager.getLiveAtEntry(bb);
     BitSet::IterB ib(*ls);
     for (int i = ib.getNext(); i != -1; i = ib.getNext()){
@@ -570,7 +570,7 @@
 void ConstraintsResolverImpl::resolveConstraints()
 {   
     // for all basic blocks in the array
-    for (uint32 ibb=0, nbb=(uint32)basicBlocks.size(); ibb<nbb; ++ibb){
+    for (U_32 ibb=0, nbb=(U_32)basicBlocks.size(); ibb<nbb; ++ibb){
         resolveConstraints(basicBlocks[ibb]);
     }
 }   

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32ConstraintsResolver.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32ConstraintsResolver.h?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32ConstraintsResolver.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32ConstraintsResolver.h Thu May 22 06:33:38 2008
@@ -235,7 +235,7 @@
     Nodes                       basicBlocks;
 
     /** result of irManager.getOpndCount before the pass */ 
-    uint32                      originalOpndCount;
+    U_32                      originalOpndCount;
 
     /** Current live set, updated as usual for each instruction in resolveConstraints(Inst*) */ 
     BitSet                      liveOpnds;
@@ -260,7 +260,7 @@
     StlVector<Opnd*>            opndReplaceWorkset;
 
 
-    StlVector<uint32>           opndUsage;
+    StlVector<U_32>           opndUsage;
 
     unsigned callSplitThresholdForNoRegs;
     unsigned callSplitThresholdFor1Reg;

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CopyExpansion.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CopyExpansion.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CopyExpansion.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CopyExpansion.cpp Thu May 22 06:33:38 2008
@@ -71,8 +71,8 @@
     struct CandidateInst
     {   
         Inst * inst;
-        uint32 execCount;
-        CandidateInst(Inst * i = NULL, uint32 ec = 0)
+        U_32 execCount;
+        CandidateInst(Inst * i = NULL, U_32 ec = 0)
             :inst(i), execCount(ec){}
 
         static bool less (const CandidateInst& x, const CandidateInst& y)   
@@ -83,21 +83,21 @@
 
     typedef StlVector<CandidateInst> CandidateInsts;
 
-    uint32 initIntervals();
+    U_32 initIntervals();
     bool isCandidate(const Inst * inst) const;
     void collectCandidates();
     void collectIntervals();
     void addReplacement(Opnd * dst, Opnd * src);
     void removeInsts();
     void replaceOpnds();
-    void printCandidates(::std::ostream& os, uint32 detailLevel = 0)const;
+    void printCandidates(::std::ostream& os, U_32 detailLevel = 0)const;
 
     IRManager &     irManager;
     MemoryManager   memoryManager;
     CandidateInsts  candidateInsts;
     Intervals       intervals;
     OpndVector      opndReplacements;
-    uint32          replacementsAdded;
+    U_32          replacementsAdded;
     bool            emptyBlocks;
 };
 
@@ -124,12 +124,12 @@
 }
 
 //_________________________________________________________________________________________________
-uint32 SimpleStackOpndCoalescer::initIntervals()
+U_32 SimpleStackOpndCoalescer::initIntervals()
 {
-    uint32 candidateOpndCount = 0;
-    uint32 opndCount = irManager.getOpndCount();
+    U_32 candidateOpndCount = 0;
+    U_32 opndCount = irManager.getOpndCount();
     intervals.resize(opndCount);
-    for (uint32 i = 0; i < opndCount; i++){
+    for (U_32 i = 0; i < opndCount; i++){
         Opnd * opnd = irManager.getOpnd(i);
         if (opnd->isPlacedIn(OpndKind_Mem) && opnd->getMemOpndKind() == MemOpndKind_StackAutoLayout){
             intervals[i] = new (memoryManager) Interval(memoryManager);
@@ -151,7 +151,7 @@
         if (node->isBlockNode()){
             for (Inst*  inst  = (Inst*)node->getFirstInst(); inst!=NULL; inst=inst->getNextInst()){
                 if (isCandidate(inst)){
-                    uint32 execCount = (uint32)node->getExecCount();
+                    U_32 execCount = (U_32)node->getExecCount();
                     if (execCount < 1) 
                         execCount = 1;
                     candidateInsts.push_back(CandidateInst(inst, execCount));
@@ -164,12 +164,12 @@
 }
 
 //_________________________________________________________________________________________________
-void SimpleStackOpndCoalescer::printCandidates(::std::ostream& os, uint32 detailLevel)const
+void SimpleStackOpndCoalescer::printCandidates(::std::ostream& os, U_32 detailLevel)const
 {
     os << irManager.getMethodDesc().getParentType()->getName() << "." << irManager.getMethodDesc().getName()
         << ": " << candidateInsts.size() << ::std::endl;
     if (detailLevel > 0){
-        for (uint32 i = 0; i < candidateInsts.size(); i++){
+        for (U_32 i = 0; i < candidateInsts.size(); i++){
             if (detailLevel > 1)
                 IRPrinter::printInst(os, candidateInsts[i].inst);
             Inst * inst = candidateInsts[i].inst;
@@ -211,7 +211,7 @@
 void SimpleStackOpndCoalescer::collectIntervals()
 {
     irManager.indexInsts();
-    uint32 opndCount = irManager.getOpndCount();
+    U_32 opndCount = irManager.getOpndCount();
 
     Interval * interval;
 
@@ -224,7 +224,7 @@
             if (inst == 0)
                 continue;
 
-            uint32 instIndex=inst->getIndex();
+            U_32 instIndex=inst->getIndex();
 
             BitSet lives(memoryManager, opndCount);
 
@@ -240,7 +240,7 @@
                 Inst::Opnds defs(inst, Inst::OpndRole_All);
                 for (Inst::Opnds::iterator it = defs.begin(); it != defs.end(); it = defs.next(it)){
                     Opnd * opnd = inst->getOpnd(it);
-                    uint32 opndId = opnd->getId();
+                    U_32 opndId = opnd->getId();
                     if ( (interval = intervals[opndId]) != NULL ){
                         if (inst->isLiveRangeEnd(it))
                             intervals[opndId]->stop(instIndex + 1);
@@ -260,7 +260,7 @@
         }
     }
     
-    for (uint32 i = 0; i < opndCount; i++){
+    for (U_32 i = 0; i < opndCount; i++){
         if ( (interval = intervals[i]) != NULL )
             interval->finish();
     }
@@ -283,7 +283,7 @@
 {
     if (dstOpnd != srcOpnd){
         intervals[srcOpnd->getId()]->unionWith(intervals[dstOpnd->getId()]);
-        for (uint32 i = 0, n = irManager.getOpndCount(); i < n; i++){
+        for (U_32 i = 0, n = irManager.getOpndCount(); i < n; i++){
             if (opndReplacements[i] == dstOpnd){
                 if (srcOpnd->getId() != i)
                     opndReplacements[i] = srcOpnd;
@@ -299,7 +299,7 @@
 //_________________________________________________________________________________________________
 void SimpleStackOpndCoalescer::removeInsts()
 {
-    uint32 opndCount = irManager.getOpndCount();
+    U_32 opndCount = irManager.getOpndCount();
     
     // Exclude aliased memory locations from the optimization
     // example: if for "mov arg1, arg0"  both args are on stack but arg0 is placed in incoming args stack area 
@@ -312,9 +312,9 @@
 
     replacementsAdded = 0;
     opndReplacements.resize(opndCount);
-    for (uint32 i = 0; i < opndCount; i++)
+    for (U_32 i = 0; i < opndCount; i++)
         opndReplacements[i] = NULL;
-    for (uint32 i = 0; i < candidateInsts.size(); i++){
+    for (U_32 i = 0; i < candidateInsts.size(); i++){
         int adj;
         Inst * inst = candidateInsts[i].inst;
         if (Log::isEnabled()) {
@@ -351,9 +351,9 @@
 */
 class CopyExpansion : public SessionAction {
     void runImpl();
-    void restoreRegUsage(Node * bb, Inst * toInst, uint32& gpRegUsageMask, uint32& appRegUsageMask);
-    uint32 getNeedInfo()const{ return NeedInfo_LivenessInfo; }
-    uint32 getSideEffects()const{ return SideEffect_InvalidatesLivenessInfo; }
+    void restoreRegUsage(Node * bb, Inst * toInst, U_32& gpRegUsageMask, U_32& appRegUsageMask);
+    U_32 getNeedInfo()const{ return NeedInfo_LivenessInfo; }
+    U_32 getSideEffects()const{ return SideEffect_InvalidatesLivenessInfo; }
 };
 
 
@@ -380,8 +380,8 @@
     for (Nodes::const_iterator it = nodes.begin(),end = nodes.end();it!=end; ++it) {
         Node* node = *it;
         if (node->isBlockNode()){
-            uint32 flagsRegUsageMask = 0;
-            uint32 gpRegUsageMask = 0;
+            U_32 flagsRegUsageMask = 0;
+            U_32 gpRegUsageMask = 0;
             bool calculatingRegUsage = false;
             for (Inst * inst=(Inst*)node->getLastInst(), * nextInst=NULL; inst!=NULL; inst=nextInst){
                 nextInst=inst->getPrevInst();
@@ -460,7 +460,7 @@
 }
 
 //_________________________________________________________________________________________________
-void CopyExpansion::restoreRegUsage(Node* bb, Inst * toInst, uint32& gpRegUsageMask, uint32& appRegUsageMask)
+void CopyExpansion::restoreRegUsage(Node* bb, Inst * toInst, U_32& gpRegUsageMask, U_32& appRegUsageMask)
 {
     assert(bb->isBlockNode());
     if (bb->isEmpty()) {

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32DCE.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32DCE.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32DCE.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32DCE.cpp Thu May 22 06:33:38 2008
@@ -32,8 +32,8 @@
 class DCE : public SessionAction {
 public:
     void runImpl();
-    uint32 getSideEffects() const {return 0;}
-    uint32 getNeedInfo()const {return 0;}
+    U_32 getSideEffects() const {return 0;}
+    U_32 getNeedInfo()const {return 0;}
 };
 
 static ActionFactory<DCE> _dce("cg_dce");

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32EarlyPropagation.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32EarlyPropagation.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32EarlyPropagation.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32EarlyPropagation.cpp Thu May 22 06:33:38 2008
@@ -45,16 +45,16 @@
 
     struct OpndInfo
     {
-        uint32 defCount;
+        U_32 defCount;
         Inst * sourceInst;
-        uint32 sourceOpndId;
-        uint32 sourceOpndDefCountAtCopy;
+        U_32 sourceOpndId;
+        U_32 sourceOpndDefCountAtCopy;
         OpndInfo()
             :defCount(0), sourceInst(NULL), sourceOpndId(EmptyUint32), sourceOpndDefCountAtCopy(0){}
     };
     
     void runImpl();
-    uint32 getNeedInfo()const{ return 0; }
+    U_32 getNeedInfo()const{ return 0; }
 };
 
 static ActionFactory<EarlyPropagation> _early_prop("early_prop");
@@ -71,7 +71,7 @@
 void EarlyPropagation::runImpl()
 { 
         irManager->updateLoopInfo();
-        uint32 opndCount=irManager->getOpndCount();
+        U_32 opndCount=irManager->getOpndCount();
 
         MemoryManager mm("early_prop");
         OpndInfo * opndInfos = new(mm) OpndInfo[opndCount];
@@ -89,7 +89,7 @@
             Node * loopHeader = lt->getLoopHeader(node, false);
             if (currentLoopHeader != loopHeader){
                 currentLoopHeader = loopHeader;
-                for (uint32 i = 0; i < opndCount; ++i)
+                for (U_32 i = 0; i < opndCount; ++i)
                     if (opndInfos[i].sourceOpndId != EmptyUint32)
                         opndInfos[i].defCount++;
             }
@@ -99,11 +99,11 @@
                 Inst::Opnds opnds(inst, Inst::OpndRole_All);
                 for (Inst::Opnds::iterator it = opnds.begin(); it != opnds.end(); it = opnds.next(it)){
                     Opnd * opnd=inst->getOpnd(it);
-                    uint32 roles=inst->getOpndRoles(it);
-                    uint32 opndId = opnd->getId();
+                    U_32 roles=inst->getOpndRoles(it);
+                    U_32 opndId = opnd->getId();
                     OpndInfo& opndInfo = opndInfos[opndId];
 
-                    uint32 mask = 0;
+                    U_32 mask = 0;
 
                     if (roles & Inst::OpndRole_Def){
                         ++opndInfo.defCount;
@@ -150,7 +150,7 @@
                 if (isCopy){ // CopyPseudoInst or mov
                     Opnd * defOpnd = inst->getOpnd(0);
                     Opnd * srcOpnd = inst->getOpnd(1);
-                    uint32 defOpndId = defOpnd->getId();
+                    U_32 defOpndId = defOpnd->getId();
                     OpndInfo * opndInfo = opndInfos + defOpndId;
                     bool instHandled=false;
                     bool typeConvOk = isTypeConversionAllowed(srcOpnd, defOpnd);
@@ -175,7 +175,7 @@
             Opnd ** replacements = new(mm) Opnd* [opndCount];
             memset(replacements, 0, sizeof(Opnd*) * opndCount);
             bool hasReplacements = false;
-            for (uint32 i = 0; i < opndCount; ++i){
+            for (U_32 i = 0; i < opndCount; ++i){
                 if (opndInfos[i].sourceOpndId != EmptyUint32){
                     Inst * inst = opndInfos[i].sourceInst;
                     if (inst !=NULL){

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32Encoder.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32Encoder.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32Encoder.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32Encoder.cpp Thu May 22 06:33:38 2008
@@ -115,12 +115,12 @@
     return Constraint();
 }
 
-uint32 Encoder::getMnemonicProperties(Mnemonic mn)
+U_32 Encoder::getMnemonicProperties(Mnemonic mn)
 {
     return getMnemonicProperties(*getMnemonicDesc(mn));
 };
 
-uint32 Encoder::getMnemonicProperties(const MnemonicDesc& mdesc)
+U_32 Encoder::getMnemonicProperties(const MnemonicDesc& mdesc)
 {
     return (mdesc.flags & MF_CONDITIONAL ? Inst::Properties_Conditional:0) | 
             (mdesc.flags & MF_SYMMETRIC ? Inst::Properties_Symmetric : 0) |
@@ -129,7 +129,7 @@
 };
 
 //_________________________________________________________________________________________________
-bool Encoder::matches(Constraint co, Constraint ci, uint32 opndRoles,
+bool Encoder::matches(Constraint co, Constraint ci, U_32 opndRoles,
                       bool allowAliases)
 {
     return co.isNull() || !(ci&co).isNull() || 
@@ -144,7 +144,7 @@
     assert(m != Mnemonic_Null && m < Mnemonic_Count);
     const OpcodeGroupsHolder& mi = getOpcodeGroups()[m];
     // first, find better matching for already assigned operands
-    for (uint32 i=0; i<mi.count; i++) {
+    for (U_32 i=0; i<mi.count; i++) {
         const OpcodeGroup* og=mi.opgroups+i;
         if (matches(og, fi, false)) {
             return og;
@@ -152,7 +152,7 @@
     }
 
     // now find any matching suitable for the type constraint (initial)
-    for (uint32 i=0; i<mi.count; i++) {
+    for (U_32 i=0; i<mi.count; i++) {
         const OpcodeGroup* og=mi.opgroups+i;
         if (matches(og, fi, true)) {
             return og;
@@ -176,8 +176,8 @@
             return false;
         }
     }
-    for (uint32 i = 0, n = fi.opndCount; i < n; i++) {
-        uint32 idx = fi.isExtended ? og->extendedToNativeMap[i] : i;
+    for (U_32 i = 0, n = fi.opndCount; i < n; i++) {
+        U_32 idx = fi.isExtended ? og->extendedToNativeMap[i] : i;
         Constraint co=fi.opndConstraints[idx];
         if (any) {
             co = Constraint(OpndKind_Any, co.getSize());
@@ -190,9 +190,9 @@
 
 //_________________________________________________________________________________________________
 bool 
-Encoder::isOpndAllowed(const Encoder::OpcodeGroup * og, uint32 i, Constraint co, bool isExtended, bool any)
+Encoder::isOpndAllowed(const Encoder::OpcodeGroup * og, U_32 i, Constraint co, bool isExtended, bool any)
 {
-        uint32 idx = isExtended ? og->extendedToNativeMap[i] : i;
+        U_32 idx = isExtended ? og->extendedToNativeMap[i] : i;
         assert(idx<IRMaxNativeOpnds);
 
         Constraint ci=og->opndConstraints[idx];
@@ -212,7 +212,7 @@
     EncoderBase::Operands args;
 
     Opnd * const * opnds = inst->getOpnds();
-    const uint32 * roles = inst->getOpndRoles();
+    const U_32 * roles = inst->getOpndRoles();
 
     for( int idx=0, n=inst->getOpndCount(); idx<n; idx++ ) { 
         if (!(roles[idx] & Inst::OpndRole_Explicit)) continue;
@@ -385,7 +385,7 @@
             //
 
             if (canBeIncluded(og, od)) {
-                for (uint32 j=0; j<og.opndRoles.count; j++) {
+                for (U_32 j=0; j<og.opndRoles.count; j++) {
                     og.opndConstraints[j].unionWith(od.opndConstraints[j]);
                 }
                 break;
@@ -399,7 +399,7 @@
             OpcodeGroup& og = mitem->opgroups[mitem->count];
             initOG(og, mdesc);
             og.opndRoles = od.opndRoles;
-            for (uint32 j=0; j<og.opndRoles.count; j++) {
+            for (U_32 j=0; j<og.opndRoles.count; j++) {
                 og.opndConstraints[j].unionWith(od.opndConstraints[j]);
             }
             ++mitem->count;
@@ -464,22 +464,22 @@
 
 void Encoder::finalizeOG(OpcodeGroup& og) {
 
-    uint32 etmIdx = 0;
-    for (uint32 i = 0; i < og.opndRoles.count; i++) {
+    U_32 etmIdx = 0;
+    for (U_32 i = 0; i < og.opndRoles.count; i++) {
         if (getOpndRoles(og.opndRoles, i) & Inst::OpndRole_Def){
             og.extendedToNativeMap[etmIdx++] = i;
         }
         }
     assert(etmIdx == og.opndRoles.defCount);
-    for (uint32 i = 0; i < og.opndRoles.count; i++) {
+    for (U_32 i = 0; i < og.opndRoles.count; i++) {
         if (getOpndRoles(og.opndRoles, i) & Inst::OpndRole_Use) {
             og.extendedToNativeMap[etmIdx++] = i;
     }
         }
-    assert(etmIdx == (uint32)(og.opndRoles.defCount + og.opndRoles.useCount));
+    assert(etmIdx == (U_32)(og.opndRoles.defCount + og.opndRoles.useCount));
 
-    uint32 memOpnds = 0;
-    for (uint32 i = 0; i < og.opndRoles.count; i++) {
+    U_32 memOpnds = 0;
+    for (U_32 i = 0; i < og.opndRoles.count; i++) {
         if (og.opndConstraints[i].getKind() & OpndKind_Mem)
             memOpnds++;
     }

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32Encoder.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32Encoder.h?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32Encoder.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32Encoder.h Thu May 22 06:33:38 2008
@@ -50,12 +50,12 @@
     /** struct OpcodeGroupDescription contains the description of an opcode group */
     struct OpcodeGroup {
         Mnemonic                    mnemonic;
-        uint32                      properties;
+        U_32                      properties;
         OpndRolesDescription        opndRoles;
         Constraint                  opndConstraints[IRMaxNativeOpnds];
         OpndRolesDesc               implicitOpndRoles;
         RegName                     implicitOpndRegNames[3];
-        uint32                      extendedToNativeMap[IRMaxExtendedOpnds];
+        U_32                      extendedToNativeMap[IRMaxExtendedOpnds];
         const char *                printMnemonic;
     };
 
@@ -68,10 +68,10 @@
         const OpcodeGroup * opcodeGroup;
     };
 
-    static bool matches(Constraint co, Constraint ci, uint32 opndRoles, bool allowAliases);
+    static bool matches(Constraint co, Constraint ci, U_32 opndRoles, bool allowAliases);
     static const OpcodeGroup* findOpcodeGroup(const FindInfo& fi);
     static bool matches(const OpcodeGroup* og, const FindInfo& fi, bool any);
-    static bool isOpndAllowed(const Encoder::OpcodeGroup * og, uint32 i, Constraint co, bool isExtended, bool any);
+    static bool isOpndAllowed(const Encoder::OpcodeGroup * og, U_32 i, Constraint co, bool isExtended, bool any);
 
     /**
      * Retunrs an empty opcode group.
@@ -91,10 +91,10 @@
         Constraint constraints[MemOpndSubOpndKind_Count];
     };
 
-    static const MemOpndConstraints * getMemOpndConstraints(uint32 idx)
+    static const MemOpndConstraints * getMemOpndConstraints(U_32 idx)
     { assert(idx<lengthof(memOpndConstraints)); return memOpndConstraints+idx; }
 
-    static Constraint getMemOpndSubOpndConstraint(Constraint memOpndConstraint, uint32 subOpndIndex) {
+    static Constraint getMemOpndSubOpndConstraint(Constraint memOpndConstraint, U_32 subOpndIndex) {
         return getMemOpndConstraints(0)->constraints[subOpndIndex];
     }
 
@@ -108,12 +108,12 @@
     /**
      * Returns properties (see Inst::Properties) for a given mnemonic.
      */
-    static uint32 getMnemonicProperties(Mnemonic mn);
+    static U_32 getMnemonicProperties(Mnemonic mn);
 
     /**
      * Returns properties (see Inst::Properties) for a given MnemonicDesc.
      */
-    static uint32 getMnemonicProperties(const MnemonicDesc& mdesc);
+    static U_32 getMnemonicProperties(const MnemonicDesc& mdesc);
 private:
     /**
      * Empty opcode group.

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32GCMap.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32GCMap.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32GCMap.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32GCMap.cpp Thu May 22 06:33:38 2008
@@ -186,7 +186,7 @@
         }
         //ok register this opnd
         MPtrPair* pair = GCSafePointsInfo::findPairByMPtrOpnd(pairs, opnd);
-        int32 offset = pair == NULL ? 0 : pair->getOffset();
+        I_32 offset = pair == NULL ? 0 : pair->getOffset();
         bool isObject = offset == 0;
 #ifdef _EM64T_
         bool isCompressed = (opnd->getType()->tag <= Type::CompressedVTablePtr && opnd->getType()->tag >= Type::CompressedSystemObject);
@@ -195,9 +195,9 @@
         RegName reg = opnd->getRegName();
         if (reg != RegName_Null) {
 #ifdef _EM64T_
-            gcOpnd = new (mm) GCSafePointOpnd(isObject, TRUE, uint32(reg), offset, isCompressed);
+            gcOpnd = new (mm) GCSafePointOpnd(isObject, TRUE, U_32(reg), offset, isCompressed);
 #else
-            gcOpnd = new (mm) GCSafePointOpnd(isObject, TRUE, uint32(reg), offset);
+            gcOpnd = new (mm) GCSafePointOpnd(isObject, TRUE, U_32(reg), offset);
 #endif
         } else if (opnd->getMemOpndKind() == MemOpndKind_StackAutoLayout) {
             const Opnd* displOpnd = opnd->getMemOpndSubOpnd(MemOpndSubOpndKind_Displacement);
@@ -330,10 +330,10 @@
     POINTER_SIZE_INT nOpnds = image[1];
     gcOpnds.reserve(nOpnds);
     POINTER_SIZE_INT offs = 2;
-    for (uint32 i = 0; i< nOpnds; i++, offs+=3) {
-        GCSafePointOpnd* gcOpnd= new (mm) GCSafePointOpnd(uint32(image[offs]), int(image[offs+1]), int32(image[offs+2]));
+    for (U_32 i = 0; i< nOpnds; i++, offs+=3) {
+        GCSafePointOpnd* gcOpnd= new (mm) GCSafePointOpnd(U_32(image[offs]), int(image[offs+1]), I_32(image[offs+2]));
 #ifdef GCMAP_TRACK_IDS
-        gcOpnd->firstId = uint32(image[offs+3]);
+        gcOpnd->firstId = U_32(image[offs+3]);
         offs++;
 #endif
         gcOpnds.push_back(gcOpnd);
@@ -357,7 +357,7 @@
     POINTER_SIZE_INT offs=0;
     data[offs++] = ip;
     data[offs++] = (POINTER_SIZE_INT)gcOpnds.size();
-    for (uint32 i = 0, n = (uint32)gcOpnds.size(); i<n; i++, offs+=3) {
+    for (U_32 i = 0, n = (U_32)gcOpnds.size(); i<n; i++, offs+=3) {
         GCSafePointOpnd* gcOpnd = gcOpnds[i];
         data[offs] = gcOpnd->flags;
         data[offs+1] = gcOpnd->val;
@@ -413,7 +413,7 @@
     //In this case it's impossible to derive valid base for mptr with unknown offset.
 
     //1. Derive all offsets. Use GCSafePointOpnd.mptrOffset to store the result.
-    for (uint32 i=0, n = (uint32)gcOpnds.size(); i<n; i++) {
+    for (U_32 i=0, n = (U_32)gcOpnds.size(); i<n; i++) {
         GCSafePointOpnd* gcOpnd = gcOpnds[i];
         POINTER_SIZE_INT valPtrAddr = getOpndSaveAddr(context, stackInfo, gcOpnd);
         if (gcOpnd->isObject() || gcOpnd->getMPtrOffset()!=MPTR_OFFSET_UNKNOWN) {
@@ -427,7 +427,7 @@
         POINTER_SIZE_INT basePtrAddr = 0;
 #endif
         POINTER_SIZE_INT baseAddr = 0;
-        for (uint32 j=0; j<n; j++) {
+        for (U_32 j=0; j<n; j++) {
             GCSafePointOpnd* tmpOpnd = gcOpnds[j];   
             if (tmpOpnd->isObject()) {
                 POINTER_SIZE_INT tmpPtrAddr = getOpndSaveAddr(context, stackInfo, tmpOpnd);
@@ -453,7 +453,7 @@
     }
 
     //2. Report the results
-    for (uint32 i=0, n = (uint32)gcOpnds.size(); i<n; i++) {
+    for (U_32 i=0, n = (U_32)gcOpnds.size(); i<n; i++) {
         GCSafePointOpnd* gcOpnd = gcOpnds[i];
         POINTER_SIZE_INT valPtrAddr = getOpndSaveAddr(context, stackInfo, gcOpnd);
         if (gcOpnd->isObject()) {
@@ -462,7 +462,7 @@
 #endif
 #ifdef _EM64T_
             if(gcOpnd->isCompressed())
-                gcInterface->enumerateCompressedRootReference((uint32*)valPtrAddr);
+                gcInterface->enumerateCompressedRootReference((U_32*)valPtrAddr);
             else
 #endif
                 gcInterface->enumerateRootReference((void**)valPtrAddr);
@@ -521,7 +521,7 @@
     AutoTimer tm(enumerateTimer);
 
     // Compute stack information
-    uint32 stackInfoSize = (uint32)StackInfo::getByteSize(methodDesc);
+    U_32 stackInfoSize = (U_32)StackInfo::getByteSize(methodDesc);
     U_8* infoBlock = methodDesc->getInfoBlock();
     U_8* gcBlock = infoBlock + stackInfoSize;
 #ifdef _EM64T_
@@ -567,9 +567,9 @@
         inlineInfo->write(compIntf.allocateJITDataBlock(inlineInfo->getImageSize(), 8));
     }
 
-    uint32 stackInfoSize = (uint32)stackInfo->getByteSize();
-    uint32 gcInfoSize = (uint32)gcMap->getByteSize();
-    uint32 bcMapSize = (uint32)bcMap->getByteSize(); // we should write at least the size of map  in the info block
+    U_32 stackInfoSize = (U_32)stackInfo->getByteSize();
+    U_32 gcInfoSize = (U_32)gcMap->getByteSize();
+    U_32 bcMapSize = (U_32)bcMap->getByteSize(); // we should write at least the size of map  in the info block
     assert(bcMapSize >= 4);   // minimum size for empty  BCMap for all platforms
 
     U_8* infoBlock = compIntf.allocateInfoBlock(stackInfoSize + gcInfoSize + bcMapSize);

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32GCMap.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32GCMap.h?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32GCMap.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32GCMap.h Thu May 22 06:33:38 2008
@@ -84,7 +84,7 @@
 
         POINTER_SIZE_INT getUint32Size() const;
         void write(POINTER_SIZE_INT* image) const;
-        uint32 getNumOpnds() const {return (uint32)gcOpnds.size();}
+        U_32 getNumOpnds() const {return (U_32)gcOpnds.size();}
         static POINTER_SIZE_INT getIP(const POINTER_SIZE_INT* image);
 
         void enumerate(GCInterface* gcInterface, const JitFrameContext* c, const StackInfo& stackInfo) const;
@@ -104,15 +104,15 @@
 
     class GCSafePointOpnd {
         friend class GCSafePoint;
-        static const uint32 OBJ_MASK  = 0x1;
-        static const uint32 REG_MASK  = 0x2;
+        static const U_32 OBJ_MASK  = 0x1;
+        static const U_32 REG_MASK  = 0x2;
 #ifdef _EM64T_
-        static const uint32 COMPRESSED_MASK  = 0x4;
+        static const U_32 COMPRESSED_MASK  = 0x4;
 #endif
 
 #ifdef GCMAP_TRACK_IDS
         // flags + val + mptrOffset + firstId
-        static const uint32 IMAGE_SIZE_UINT32 = 4; //do not use sizeof due to the potential struct layout problems
+        static const U_32 IMAGE_SIZE_UINT32 = 4; //do not use sizeof due to the potential struct layout problems
 #else 
         // flags + val + mptrOffset 
         static const POINTER_SIZE_INT IMAGE_SIZE_UINT32 = 3;
@@ -121,10 +121,10 @@
     public:
         
 #ifdef _EM64T_
-        GCSafePointOpnd(bool isObject, bool isOnRegister, int32 _val, int32 _mptrOffset, bool isCompressed=false) : val(_val), mptrOffset(_mptrOffset) {
+        GCSafePointOpnd(bool isObject, bool isOnRegister, I_32 _val, I_32 _mptrOffset, bool isCompressed=false) : val(_val), mptrOffset(_mptrOffset) {
             flags = flags | (isCompressed ? COMPRESSED_MASK: 0);
 #else
-        GCSafePointOpnd(bool isObject, bool isOnRegister, int32 _val, int32 _mptrOffset) : val(_val), mptrOffset(_mptrOffset) {
+        GCSafePointOpnd(bool isObject, bool isOnRegister, I_32 _val, I_32 _mptrOffset) : val(_val), mptrOffset(_mptrOffset) {
 #endif
             flags = isObject ? OBJ_MASK : 0;
             flags = flags | (isOnRegister ? REG_MASK: 0);
@@ -143,37 +143,37 @@
         bool isCompressed() const { return (flags & COMPRESSED_MASK)!=0;}
 #endif      
         RegName getRegName() const { assert(isOnRegister()); return RegName(val);}
-        int32 getDistFromInstESP() const { assert(isOnStack()); return val;}
+        I_32 getDistFromInstESP() const { assert(isOnStack()); return val;}
 
-        int32 getMPtrOffset() const {return mptrOffset;}
+        I_32 getMPtrOffset() const {return mptrOffset;}
         void getMPtrOffset(int newOffset) {mptrOffset = newOffset;}
 
 #ifdef GCMAP_TRACK_IDS
-        uint32 firstId;
+        U_32 firstId;
 #endif
 
     private:
-        GCSafePointOpnd(uint32 _flags, int32 _val, int32 _mptrOffset) : flags(_flags), val(_val), mptrOffset(_mptrOffset) {}
+        GCSafePointOpnd(U_32 _flags, I_32 _val, I_32 _mptrOffset) : flags(_flags), val(_val), mptrOffset(_mptrOffset) {}
 
         //first bit is location, second is type
-        uint32 flags;        
+        U_32 flags;        
         //opnd placement ->Register or offset
-        int32 val; 
-        int32 mptrOffset;
+        I_32 val; 
+        I_32 mptrOffset;
     };
 
 
     class GCMapCreator : public SessionAction {
         void runImpl();
-        uint32 getNeedInfo()const{ return NeedInfo_LivenessInfo;}
-        uint32 getSideEffects() {return Log::isEnabled();}
+        U_32 getNeedInfo()const{ return NeedInfo_LivenessInfo;}
+        U_32 getSideEffects() {return Log::isEnabled();}
         bool isIRDumpEnabled(){ return true;}
     };        
 
     class InfoBlockWriter : public SessionAction {
         void runImpl();
-        uint32 getNeedInfo()const{ return 0; }
-        uint32 getSideEffects()const{ return 0; }
+        U_32 getNeedInfo()const{ return 0; }
+        U_32 getSideEffects()const{ return 0; }
         bool isIRDumpEnabled(){ return false; }
     };
 



Mime
View raw message