harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From mcfi...@apache.org
Subject svn commit: r659108 [6/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/Ia32Printer.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32Printer.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32Printer.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32Printer.cpp Thu May 22 06:33:38 2008
@@ -52,7 +52,7 @@
     logs.close();
 }
 //_____________________________________________________________________________________________
-void Printer::print(uint32 indent)
+void Printer::print(U_32 indent)
 {
     printHeader(indent);
     printBody(indent);
@@ -60,7 +60,7 @@
 }
 
 //_____________________________________________________________________________________________
-void Printer::printHeader(uint32 indent)
+void Printer::printHeader(U_32 indent)
 {
     assert(irManager!=NULL);
     ::std::ostream& os = getStream();
@@ -72,7 +72,7 @@
 }
 
 //_____________________________________________________________________________________________
-void Printer::printEnd(uint32 indent)
+void Printer::printEnd(U_32 indent)
 {
     ::std::ostream& os = getStream();
     os << ::std::endl;
@@ -80,7 +80,7 @@
 }
 
 //_____________________________________________________________________________________________
-void Printer::printBody(uint32 indent)
+void Printer::printBody(U_32 indent)
 {
     ::std::ostream& os = getStream();
     os << "Printer::printBody is stub implementation"<< ::std::endl;
@@ -91,19 +91,19 @@
 // class IRPrinter
 //========================================================================================
 //_____________________________________________________________________________________________
-void IRPrinter::print(uint32 indent)
+void IRPrinter::print(U_32 indent)
 {
     Printer::print();
 }
 
 //_____________________________________________________________________________________________
-void IRPrinter::printBody(uint32 indent)
+void IRPrinter::printBody(U_32 indent)
 {
     printCFG(indent);
 }
 
 //_____________________________________________________________________________________________
-void IRPrinter::printCFG(uint32 indent)
+void IRPrinter::printCFG(U_32 indent)
 {
     assert(irManager!=NULL);
     std::ostream& os = getStream();
@@ -146,7 +146,7 @@
 }
 
 //_____________________________________________________________________________________________
-void IRPrinter::printNodeHeader(const Node * node, uint32 indent)
+void IRPrinter::printNodeHeader(const Node * node, U_32 indent)
 {
     std::ostream& os = getStream();
     printIndent(indent);
@@ -227,12 +227,12 @@
 }
 
 //_____________________________________________________________________________________________
-void IRPrinter::printNodeInstList(const Node* bb, uint32 indent)
+void IRPrinter::printNodeInstList(const Node* bb, U_32 indent)
 {
     ::std::ostream& os = getStream();
     for (Inst * inst = (Inst*)bb->getFirstInst(); inst != NULL; inst = inst->getNextInst()) {
         Inst::Kind kind=inst->getKind();
-        if ((kind & instFilter)==(uint32)kind){
+        if ((kind & instFilter)==(U_32)kind){
             printIndent(indent+1); 
             if (irManager->getCodeStartAddr()!=NULL){
                 os<<(void*)inst->getCodeStartAddr()<<' ';
@@ -244,7 +244,7 @@
 }
 
 //_____________________________________________________________________________________________
-void IRPrinter::printNode(const Node * node, uint32 indent)
+void IRPrinter::printNode(const Node * node, U_32 indent)
 {
     std::ostream& os = getStream();
     printNodeHeader(node, indent);
@@ -280,12 +280,12 @@
 }
 
 //_____________________________________________________________________________________________
-uint32 IRPrinter::printInstOpnds(const Inst * inst, uint32 orf)
+U_32 IRPrinter::printInstOpnds(const Inst * inst, U_32 orf)
 {
     ::std::ostream& os = getStream();
     if (!(orf&Inst::OpndRole_ForIterator))
         return 0;
-    uint32 printedOpnds=0;
+    U_32 printedOpnds=0;
     bool explicitOnly=(orf&Inst::OpndRole_ForIterator)==Inst::OpndRole_Explicit;
 
     Inst::Opnds opnds(inst, orf);
@@ -308,7 +308,7 @@
     os<<"I"<<inst->getId()<<": ";
 
     if (opndRolesFilter & Inst::OpndRole_Def){
-        uint32 printedOpndsTotal=0, printedOpnds=0;
+        U_32 printedOpndsTotal=0, printedOpnds=0;
         if (inst->getForm()==Inst::Form_Extended)
             printedOpnds=printInstOpnds(inst, (Inst::OpndRole_Def|Inst::OpndRole_Explicit)&opndRolesFilter);
         if (printedOpnds){ os<<" "; printedOpndsTotal+=printedOpnds; }
@@ -348,7 +348,7 @@
     }
 
     os<<" ";
-    uint32 printedOpndsTotal=0, printedOpnds=0;
+    U_32 printedOpndsTotal=0, printedOpnds=0;
     printedOpnds=printInstOpnds(inst, ((inst->getForm()==Inst::Form_Extended?Inst::OpndRole_Use:Inst::OpndRole_UseDef)|Inst::OpndRole_Explicit)&opndRolesFilter);
     if (printedOpnds){ os<<" "; printedOpndsTotal+=printedOpnds; }
     printedOpnds=printInstOpnds(inst, (Inst::OpndRole_Use|Inst::OpndRole_Auxilary)&opndRolesFilter);
@@ -369,12 +369,12 @@
     if (inst->hasKind(Inst::Kind_GCInfoPseudoInst)) {
         const GCInfoPseudoInst* gcInst = (GCInfoPseudoInst*)inst;
         Opnd * const * uses = gcInst->getOpnds();
-        const StlVector<int32>& offsets = gcInst->offsets;
+        const StlVector<I_32>& offsets = gcInst->offsets;
         os<<"[phase:"<<gcInst->desc<<"]";
         os<<"(";
         assert(!offsets.empty());
-        for (uint32 i = 0, n = (uint32)offsets.size(); i<n; i++) {
-                int32 offset = offsets[i];
+        for (U_32 i = 0, n = (U_32)offsets.size(); i<n; i++) {
+                I_32 offset = offsets[i];
                 Opnd* opnd = uses[i];
                 if (i>0) {
                     os<<",";
@@ -387,7 +387,7 @@
 
 
 //_________________________________________________________________________________________________
-void IRPrinter::printOpndRoles(uint32 roles)
+void IRPrinter::printOpndRoles(U_32 roles)
 {
     ::std::ostream& os=getStream();
     if (roles&Inst::OpndRole_Explicit)          os<<"E"; 
@@ -411,15 +411,15 @@
 }
 
 //_________________________________________________________________________________________________
-uint32 IRPrinter::getOpndNameLength(Opnd * opnd)
+U_32 IRPrinter::getOpndNameLength(Opnd * opnd)
 {
-    uint32 id=opnd->getFirstId();
-    uint32 idLength=id<10?1:id<100?2:id<1000?3:id<10000?4:5;
+    U_32 id=opnd->getFirstId();
+    U_32 idLength=id<10?1:id<100?2:id<1000?3:id<10000?4:5;
     return 1+idLength;
 }
 
 //_____________________________________________________________________________________________
-void IRPrinter::printOpnd(const Inst * inst, uint32 idx, bool isLiveBefore, bool isLiveAfter)
+void IRPrinter::printOpnd(const Inst * inst, U_32 idx, bool isLiveBefore, bool isLiveAfter)
 {
     printOpnd(inst->getOpnd(idx), inst->getOpndRoles(idx), isLiveBefore, isLiveAfter);
 }
@@ -533,13 +533,13 @@
         default:
             assert(0);
     }
-    uint32 additionalOffset=info->getAdditionalOffset();
+    U_32 additionalOffset=info->getAdditionalOffset();
     if (additionalOffset>0)
         os<<"+"<<additionalOffset;
 }
 
 //_____________________________________________________________________________________________
-void IRPrinter::printOpnd(const Opnd * opnd, uint32 roles, bool isLiveBefore, bool isLiveAfter)
+void IRPrinter::printOpnd(const Opnd * opnd, U_32 roles, bool isLiveBefore, bool isLiveAfter)
 {
     ::std::ostream& os = getStream();
 
@@ -555,10 +555,10 @@
                 os<<"(";printRegName(opnd->getSegReg());os<<":";
             }
             os<<"[";
-            uint32 oldOpndFlavor=opndFlavor;
+            U_32 oldOpndFlavor=opndFlavor;
             opndFlavor&=~OpndFlavor_Type;
             bool append=false;
-            for (uint32 i=0; i<MemOpndSubOpndKind_Count; i++){
+            for (U_32 i=0; i<MemOpndSubOpndKind_Count; i++){
                 Opnd * subOpnd=opnd->getMemOpndSubOpnd((MemOpndSubOpndKind)i);
                 if (subOpnd){
                     if (append){
@@ -605,7 +605,7 @@
 // class IRLivenessPrinter
 //========================================================================================
 //_____________________________________________________________________________________________
-void IRLivenessPrinter::printNode(const Node * node, uint32 indent)
+void IRLivenessPrinter::printNode(const Node * node, U_32 indent)
 {
     assert(irManager!=NULL);
     ::std::ostream& os = getStream();
@@ -632,7 +632,7 @@
         os<<"Null";
         return;
     }
-    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 (ls->getBit(opnd->getId())){
             printOpndName(opnd); os<<"("<<opnd->getId()<<")"<<" ";
@@ -644,11 +644,11 @@
 // class IROpndPrinter
 //========================================================================================
 //_____________________________________________________________________________________________
-void IROpndPrinter::printBody(uint32 indent)
+void IROpndPrinter::printBody(U_32 indent)
 {
     assert(irManager!=NULL);
     ::std::ostream& os = getStream();
-    for (uint32 i=0, n=irManager->getOpndCount(); i<n; i++){
+    for (U_32 i=0, n=irManager->getOpndCount(); i<n; i++){
         printIndent(indent);
         Opnd * opnd=irManager->getOpnd(i);
         printOpnd(opnd);
@@ -672,7 +672,7 @@
 }
 
 //_____________________________________________________________________________________________
-void IROpndPrinter::printHeader(uint32 indent)
+void IROpndPrinter::printHeader(U_32 indent)
 {
     assert(irManager!=NULL);
     ::std::ostream& os = getStream();
@@ -689,7 +689,7 @@
 //========================================================================================
 
 //_____________________________________________________________________________________________
-void IRInstConstraintPrinter::printOpnd(const Inst * inst, uint32 idx, bool isLiveBefore, bool isLiveAfter)
+void IRInstConstraintPrinter::printOpnd(const Inst * inst, U_32 idx, bool isLiveBefore, bool isLiveAfter)
 {
     ::std::ostream& os = getStream();
     Opnd * opnd=inst->getOpnd(idx);
@@ -714,7 +714,7 @@
     }
     os<<getOpndSizeString(c.getSize())<<":";
     bool written=false;
-    uint32 kind=c.getKind();
+    U_32 kind=c.getKind();
     if (kind & OpndKind_Imm){
         if (written) os<<"|";
         os << "Imm";
@@ -732,8 +732,8 @@
         os <<"{";
         {
             bool written=false;
-            uint32 mask=c.getMask();
-            for (uint32 i=1, idx=0; i; i<<=1, idx++){
+            U_32 mask=c.getMask();
+            for (U_32 i=1, idx=0; i; i<<=1, idx++){
                 if (mask&i){
                     const char * regName=getRegNameString(getRegName((OpndKind)(kind&OpndKind_Reg), c.getSize(), idx));
                     if (regName!=NULL){
@@ -757,7 +757,7 @@
 }
 
 //_________________________________________________________________________________________________
-void OpcodeDescriptionPrinter::printOpndRoles(uint32 roles)
+void OpcodeDescriptionPrinter::printOpndRoles(U_32 roles)
 {
     ::std::ostream& os=getStream();
     if (roles&Inst::OpndRole_Def)   os<<"D";
@@ -768,8 +768,8 @@
 void OpcodeDescriptionPrinter::printOpndRolesDescription(const Encoder::OpndRolesDescription * ord)
 {
     ::std::ostream& os=getStream();
-    os<<"count: "<<(uint32)ord->count<<" (D:"<<ord->defCount<<",U:"<<ord->useCount<<"); roles: "; 
-    for (uint32 i=0; i<ord->count; i++){
+    os<<"count: "<<(U_32)ord->count<<" (D:"<<ord->defCount<<",U:"<<ord->useCount<<"); roles: "; 
+    for (U_32 i=0; i<ord->count; i++){
         if (i>0)
             os<<',';
         printOpndRoles(Encoder::getOpndRoles(*ord, i));
@@ -777,19 +777,19 @@
 }
 
 //_________________________________________________________________________________________________
-void OpcodeDescriptionPrinter::printOpcodeDescription(const Encoder::OpcodeDescription * od, uint32 indent)
+void OpcodeDescriptionPrinter::printOpcodeDescription(const Encoder::OpcodeDescription * od, U_32 indent)
 {
     assert( false );
 }
 
 //_________________________________________________________________________________________________
-void OpcodeDescriptionPrinter::printOpcodeGroup(const Encoder::OpcodeGroup* ogd, uint32 indent)
+void OpcodeDescriptionPrinter::printOpcodeGroup(const Encoder::OpcodeGroup* ogd, U_32 indent)
 {
     assert( false );
 }
 
 //_________________________________________________________________________________________________
-void OpcodeDescriptionPrinter::print(uint32 indent)
+void OpcodeDescriptionPrinter::print(U_32 indent)
 {
     assert( false );
 }
@@ -831,7 +831,7 @@
         out << "\\l|\\" << std::endl;
         for (Inst * inst = (Inst*)node->getFirstInst(); inst != NULL; inst = inst->getNextInst()) {
             Inst::Kind kind=inst->getKind();
-            if ((kind & instFilter)==(uint32)kind){
+            if ((kind & instFilter)==(U_32)kind){
                 printInst(inst);
                 uint16 bcOffset = inst->getBCOffset();
                 if (bcOffset != ILLEGAL_BC_MAPPING_VALUE) out<<" bcOff: "<< bcOffset << " ";
@@ -906,7 +906,7 @@
 }
 
 //_________________________________________________________________________________________________
-void IRDotPrinter::printHeader(uint32 indent)
+void IRDotPrinter::printHeader(U_32 indent)
 {
     assert(irManager!=NULL);
     getStream() << "digraph dotgraph {" << ::std::endl
@@ -928,7 +928,7 @@
 }
 
 //_________________________________________________________________________________________________
-void IRDotPrinter::printEnd(uint32 indent)
+void IRDotPrinter::printEnd(U_32 indent)
 {
     getStream() << "}" << ::std::endl;
 }
@@ -947,7 +947,7 @@
         out<<"liveness_"; printNodeName(node); 
         out << " [label=\""; printNodeName(node); out<<":";
         if (ls){
-            for (uint32 i = 0; i < ls->getSetSize(); i++) {
+            for (U_32 i = 0; i < ls->getSetSize(); i++) {
                 if (ls->getBit(i))
                     out << " " << i;
             }
@@ -1035,7 +1035,7 @@
 }
 
 //_________________________________________________________________________________________________
-void IRDotPrinter::printBody(uint32 indent)
+void IRDotPrinter::printBody(U_32 indent)
 {
     assert(irManager!=NULL);
 
@@ -1049,7 +1049,7 @@
 }
 
 //_________________________________________________________________________________________________
-void IRDotPrinter::printCFG(uint32 indent)
+void IRDotPrinter::printCFG(U_32 indent)
 {
     assert(irManager!=NULL);
     const Nodes& nodes = irManager->getFlowGraph()->getNodes();
@@ -1082,7 +1082,7 @@
 }
 
 //_________________________________________________________________________________________________
-void IRDotPrinter::print(uint32 indent)
+void IRDotPrinter::print(U_32 indent)
 {
     IRPrinter::print();
 }
@@ -1094,7 +1094,7 @@
 //========================================================================================
 
 //_________________________________________________________________________________________________
-void IRLivenessDotPrinter::printBody(uint32 indent)
+void IRLivenessDotPrinter::printBody(U_32 indent)
 {
     assert(irManager!=NULL);
     setOpndFlavor(OpndFlavor_Location);
@@ -1105,8 +1105,8 @@
 char * IRLivenessDotPrinter::getRegString(char * str, Constraint c, StlVector<Opnd *> opnds)
 {
     char * retStr=NULL;
-    uint32 si=0;
-    for (uint32 i=0, n=(uint32)opnds.size(); i<n; i++){
+    U_32 si=0;
+    for (U_32 i=0, n=(U_32)opnds.size(); i<n; i++){
         Opnd * o=opnds[i];
         if (o->isPlacedIn(c)){
             retStr=str;
@@ -1114,7 +1114,7 @@
             str[si++]=(char)('0'+getRegIndex(r));
         }else
             str[si++]='_';
-        for (uint32 j=0, l=getOpndNameLength(o)-1; j<l; j++) 
+        for (U_32 j=0, l=getOpndNameLength(o)-1; j<l; j++) 
             str[si++]='_';
     }
     str[si++]=0;
@@ -1156,7 +1156,7 @@
         if (irManager->hasLivenessInfo()){
 
             StlVector<BitSet *> liveSets(mm);
-            StlVector<uint32> regUsages(mm);
+            StlVector<U_32> regUsages(mm);
             BitSet * lsAll=new (mm) BitSet(mm, irManager->getOpndCount());
 
             BitSet * lsCurrent=new (mm) BitSet(mm, irManager->getOpndCount());
@@ -1166,7 +1166,7 @@
             ls->copyFrom(*lsCurrent);
             liveSets.push_back(ls);
 
-            uint32 regUsage=0, regUsageAll=0;
+            U_32 regUsage=0, regUsageAll=0;
             irManager->getRegUsageAtExit(node, OpndKind_GPReg, regUsage);
             regUsageAll|=regUsage;
             regUsages.push_back(regUsage);
@@ -1200,7 +1200,7 @@
 
             StlVector<Opnd *> opndsAll(mm);
 
-            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 (lsAll->getBit(opnd->getId())) {
                     opndsAll.push_back(opnd);
@@ -1214,8 +1214,8 @@
 
             out<<"Operand Ids:\\l\\"<<::std::endl;
 
-            uint32 regKindCount=0;
-            for (uint32 i=0; i<IRMaxRegKinds; i++){
+            U_32 regKindCount=0;
+            for (U_32 i=0; i<IRMaxRegKinds; i++){
                 if (regStrings[i]!=NULL){
                     regKindCount++;
                     out<<getOpndKindString((OpndKind)i) << "\\l\\" << ::std::endl;
@@ -1227,17 +1227,17 @@
             }
 
             out << "|\\" << std::endl;
-            for (uint32 i=0, n=(uint32)opndsAll.size(); i<n; i++){
+            for (U_32 i=0, n=(U_32)opndsAll.size(); i<n; i++){
                 out<<opndsAll[i]->getFirstId()<<'_';
             }
             out << "\\l\\" << std::endl;
 
-            for (uint32 i=0; i<IRMaxRegKinds; i++){
+            for (U_32 i=0; i<IRMaxRegKinds; i++){
                 if (regStrings[i]!=NULL)
                     out << regStrings[i] << "\\l\\" << ::std::endl;
             }
 
-            uint32 idx=(uint32)liveSets.size()-1;
+            U_32 idx=(U_32)liveSets.size()-1;
 
             for (Inst * inst = (Inst*)bb->getFirstInst(); inst != NULL; inst = inst->getNextInst(), idx--) {
                 printLivenessForInst(opndsAll, liveSets[idx], liveSets[idx-1]); // output at entry
@@ -1248,12 +1248,12 @@
                 out << "|\\" << ::std::endl;
 
                 out << "01234567" << "\\l\\" << std::endl;
-                for (uint32 i=1; i<regKindCount; i++)
+                for (U_32 i=1; i<regKindCount; i++)
                     out << "\\l\\" << std::endl;
 
-                for (int32 i=(int32)regUsages.size()-1; i>=0; i--) {
-                    uint32 regUsage=regUsages[i];
-                    for (uint32 m=1; m!=0x100; m<<=1)
+                for (I_32 i=(I_32)regUsages.size()-1; i>=0; i--) {
+                    U_32 regUsage=regUsages[i];
+                    for (U_32 m=1; m!=0x100; m<<=1)
                         out << (m&regUsage?'.':'_');
                     out << "\\l\\" << std::endl;
                 }
@@ -1283,7 +1283,7 @@
 void IRLivenessDotPrinter::printLivenessForInst(const StlVector<Opnd*> opnds, const BitSet * ls0, const BitSet * ls1)
 {
     ::std::ostream& out=getStream();
-    for (uint32 i=0, n=(uint32)opnds.size(); i<n; i++){
+    for (U_32 i=0, n=(U_32)opnds.size(); i<n; i++){
         Opnd * opnd=opnds[i];
         bool isLiveBefore=ls0!=NULL && ls0->getBit(opnd->getId());
         bool isLiveAfter=ls1!=NULL && ls1->getBit(opnd->getId());
@@ -1295,7 +1295,7 @@
             out<<'\'';
         else
             out<<'_';
-        for (uint32 j=0, l=getOpndNameLength(opnd)-1; j<l; j++) 
+        for (U_32 j=0, l=getOpndNameLength(opnd)-1; j<l; j++) 
             out<<'_';
     }
 }
@@ -1305,15 +1305,15 @@
 //_________________________________________________________________________________________________
 void dumpIR(
             const IRManager * irManager,
-            uint32 stageId,
+            U_32 stageId,
             const char * readablePrefix,
             const char * readableStageName,
             const char * stageTagName,
             const char * subKind1, 
             const char * subKind2,
-            uint32 instFilter, 
-            uint32 opndFlavor,
-            uint32 opndRolesFilter
+            U_32 instFilter, 
+            U_32 opndFlavor,
+            U_32 opndRolesFilter
             )
 {
     std::ostream& out = Log::log(LogStream::IRDUMP).out();
@@ -1357,15 +1357,15 @@
 //_________________________________________________________________________________________________
 void printDot(
             const IRManager * irManager,
-            uint32 stageId,
+            U_32 stageId,
             const char * readablePrefix,
             const char * readableStageName,
             const char * stageTagName,
             const char * subKind1, 
             const char * subKind2,
-            uint32 instFilter, 
-            uint32 opndFlavor,
-            uint32 opndRolesFilter
+            U_32 instFilter, 
+            U_32 opndFlavor,
+            U_32 opndRolesFilter
             )
 {
     char title[128];
@@ -1403,23 +1403,23 @@
 }
 
 //_________________________________________________________________________________________________
-void printRuntimeArgs(::std::ostream& os, uint32 opndCount, CallingConvention::OpndInfo * infos, JitFrameContext * context)
+void printRuntimeArgs(::std::ostream& os, U_32 opndCount, CallingConvention::OpndInfo * infos, JitFrameContext * context)
 {
     MemoryManager mm("printRuntimeOpndInternalHelper");
     TypeManager tm(mm); tm.init();
     os<<opndCount<<" args: ";
-    for (uint32 i=0; i<opndCount; i++){
+    for (U_32 i=0; i<opndCount; i++){
         CallingConvention::OpndInfo & info=infos[i];
-        uint32 cb=0;
-        uint8 arg[4*sizeof(uint32)]; 
-        for (uint32 j=0; j<info.slotCount; j++){
+        U_32 cb=0;
+        uint8 arg[4*sizeof(U_32)]; 
+        for (U_32 j=0; j<info.slotCount; j++){
             if (!info.isReg){
 #ifdef _EM64T_
                 *(POINTER_SIZE_INT*)(arg+cb)=((POINTER_SIZE_INT*)context->rsp)[info.slots[j]];
 #else
-                *(uint32*)(arg+cb)=((uint32*)context->esp)[info.slots[j]];
+                *(U_32*)(arg+cb)=((U_32*)context->esp)[info.slots[j]];
 #endif
-                cb+=sizeof(uint32);
+                cb+=sizeof(U_32);
             }else{
                 assert(info.isReg);
                 //assert(0);                    
@@ -1459,10 +1459,10 @@
                 os<<*(uint16*)p<<*(char*)p;
                 break;
             case Type::Int32:
-                os<<*(int32*)p;
+                os<<*(I_32*)p;
                 break;
             case Type::UInt32:
-                os<<*(uint32*)p;
+                os<<*(U_32*)p;
                 break;
             case Type::Int64:   
                 os<<*(int64*)p;
@@ -1527,11 +1527,11 @@
 void printRuntimeObjectContent_Array(::std::ostream& os, TypeManager & tm, Type * type, const void * p)
 {
     ArrayType * arrayType=(ArrayType *)type;
-    uint32 lengthOffset=arrayType->getArrayLengthOffset();
-    uint32 length=*(uint32*)(((uint8*)p)+lengthOffset);
+    U_32 lengthOffset=arrayType->getArrayLengthOffset();
+    U_32 length=*(U_32*)(((uint8*)p)+lengthOffset);
     os<<"{"<<length<<" elems: ";
     if (length>0){
-        uint32 elemOffset=arrayType->getArrayElemOffset();
+        U_32 elemOffset=arrayType->getArrayElemOffset();
         printRuntimeOpnd(os, tm, arrayType->getElementType()->tag, (const void*)(((uint8*)p)+elemOffset));
         if (length>1)
             os<<", ...";
@@ -1546,16 +1546,16 @@
     os<<"\"...\"";
     return;
 #else
-    uint32 stringLengthOffset=8;
-    uint32 stringOffsetOffset=12;
-    uint32 stringBufferOffset=16;
-    uint32 bufferLengthOffset=8;
-    uint32 bufferElemsOffset=12;
+    U_32 stringLengthOffset=8;
+    U_32 stringOffsetOffset=12;
+    U_32 stringBufferOffset=16;
+    U_32 bufferLengthOffset=8;
+    U_32 bufferElemsOffset=12;
     
     uint8 * string=(uint8*)p;
 
-    uint32  stringLength=*(uint32*)(string+stringLengthOffset);
-    uint32  stringOffset=*(uint32*)(string+stringOffsetOffset);
+    U_32  stringLength=*(U_32*)(string+stringLengthOffset);
+    U_32  stringOffset=*(U_32*)(string+stringOffsetOffset);
     uint8 * buffer=*(uint8**)(string+stringBufferOffset);
 
     if (buffer==NULL){
@@ -1566,7 +1566,7 @@
         return;
     }
 
-    uint32 bufferLength=*(uint32*)(buffer+bufferLengthOffset);
+    U_32 bufferLength=*(U_32*)(buffer+bufferLengthOffset);
 
     uint16 * bufferElems=(uint16*)(buffer+bufferElemsOffset);
 
@@ -1576,7 +1576,7 @@
     }
 
     os<<"\"";
-    for (uint32 i=stringOffset, n=stringOffset+stringLength; i<n; i++)
+    for (U_32 i=stringOffset, n=stringOffset+stringLength; i<n; i++)
         os<<(char)bufferElems[i];
     os<<"\"";
 #endif

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32Printer.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32Printer.h?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32Printer.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32Printer.h Thu May 22 06:33:38 2008
@@ -65,16 +65,16 @@
     void close();
 
     /** print everything supposed to be printed to the current output */
-    virtual void print(uint32 indent=0);
+    virtual void print(U_32 indent=0);
     
-    virtual void printHeader(uint32 indent=0);
-    virtual void printEnd(uint32 indent=0);
-    virtual void printBody(uint32 indent=0);
+    virtual void printHeader(U_32 indent=0);
+    virtual void printEnd(U_32 indent=0);
+    virtual void printBody(U_32 indent=0);
 
     /** Prints indent tabs */
-    virtual void printIndent(uint32 indent)
+    virtual void printIndent(U_32 indent)
         { while (indent--) getStream()<<'\t';  }
-    static void printIndent(::std::ostream& os, uint32 indent)
+    static void printIndent(::std::ostream& os, U_32 indent)
         { Printer p; p.setStream(os); p.printIndent(indent); }
 
     /** returns the current output desitnation */
@@ -113,23 +113,23 @@
     static void printRegName(::std::ostream& os, const RegName regName)
     { OpcodeDescriptionPrinter p; p.setStream(os); p.printRegName(regName); }
 
-    virtual void printOpndRoles(uint32 roles);
-    static void printOpndRoles(::std::ostream& os, uint32 roles)
+    virtual void printOpndRoles(U_32 roles);
+    static void printOpndRoles(::std::ostream& os, U_32 roles)
     { OpcodeDescriptionPrinter p; p.setStream(os); p.printOpndRoles(roles); }
 
     virtual void printOpndRolesDescription(const Encoder::OpndRolesDescription * ord);
     static void printOpndRolesDescription(::std::ostream& os, Encoder::OpndRolesDescription * ord)
     { OpcodeDescriptionPrinter p; p.setStream(os); p.printOpndRolesDescription(ord); }
 
-    virtual void printOpcodeDescription(const Encoder::OpcodeDescription * od, uint32 indent=0);
-    static void printOpcodeDescription(::std::ostream& os, Encoder::OpcodeDescription * od, uint32 indent=0)
+    virtual void printOpcodeDescription(const Encoder::OpcodeDescription * od, U_32 indent=0);
+    static void printOpcodeDescription(::std::ostream& os, Encoder::OpcodeDescription * od, U_32 indent=0)
     { OpcodeDescriptionPrinter p; p.setStream(os); p.printOpcodeDescription(od, indent); }
 
-    virtual void printOpcodeGroup(const Encoder::OpcodeGroup* og, uint32 indent=0);
-    static void printOpcodeGroup(::std::ostream& os, Encoder::OpcodeGroup* og, uint32 indent=0)
+    virtual void printOpcodeGroup(const Encoder::OpcodeGroup* og, U_32 indent=0);
+    static void printOpcodeGroup(::std::ostream& os, Encoder::OpcodeGroup* og, U_32 indent=0)
     { OpcodeDescriptionPrinter p; p.setStream(os); p.printOpcodeGroup(og, indent); }
 
-    virtual void print(uint32 indent=0);
+    virtual void print(U_32 indent=0);
 };
 
 //========================================================================================
@@ -151,23 +151,23 @@
     };
 
     IRPrinter(const IRManager * irm=0, const char * _title=0)
-        :OpcodeDescriptionPrinter(irm, _title), instFilter((uint32)Inst::Kind_Inst), 
-        opndFlavor((uint32)OpndFlavor_All), opndRolesFilter((uint32)(Inst::OpndRole_InstLevel|Inst::OpndRole_Use|Inst::OpndRole_Def))
+        :OpcodeDescriptionPrinter(irm, _title), instFilter((U_32)Inst::Kind_Inst), 
+        opndFlavor((U_32)OpndFlavor_All), opndRolesFilter((U_32)(Inst::OpndRole_InstLevel|Inst::OpndRole_Use|Inst::OpndRole_Def))
     {}
 
-    IRPrinter & setInstFilter(uint32 kinds){ instFilter=kinds; return *this; }
-    IRPrinter & setOpndFlavor(uint32 f){ opndFlavor=f; return *this; }
-    IRPrinter & setOpndRolesFilter(uint32 orf){ opndRolesFilter=orf; return *this; }
+    IRPrinter & setInstFilter(U_32 kinds){ instFilter=kinds; return *this; }
+    IRPrinter & setOpndFlavor(U_32 f){ opndFlavor=f; return *this; }
+    IRPrinter & setOpndRolesFilter(U_32 orf){ opndRolesFilter=orf; return *this; }
 
     virtual void printNodeName(const Node * node);
     static void printNodeName(::std::ostream& os, const Node * node)
     { IRPrinter p; p.setStream(os); p.printNodeName(node); }
 
-    virtual void printNodeHeader(const Node * node, uint32 indent=0);
-    virtual void printNodeInstList(const Node* bb, uint32 indent=0);
+    virtual void printNodeHeader(const Node * node, U_32 indent=0);
+    virtual void printNodeInstList(const Node* bb, U_32 indent=0);
 
-    virtual void printNode(const Node * node, uint32 indent=0);
-    static void printNode(::std::ostream& os, const Node * node, uint32 indent=0)
+    virtual void printNode(const Node * node, U_32 indent=0);
+    static void printNode(::std::ostream& os, const Node * node, U_32 indent=0)
     { IRPrinter p; p.setStream(os); p.printNode(node, indent); }
 
     virtual void printEdge(const Edge * edge);
@@ -176,27 +176,27 @@
 
     virtual void printInst(const Inst * inst);
     static void printInst(::std::ostream& os, const Inst * inst, 
-        uint32 opndRolesFilter=Inst::OpndRole_Explicit|Inst::OpndRole_Auxilary|Inst::OpndRole_Use|Inst::OpndRole_Def,
-        uint32 opndFlavor=OpndFlavor_Default
+        U_32 opndRolesFilter=Inst::OpndRole_Explicit|Inst::OpndRole_Auxilary|Inst::OpndRole_Use|Inst::OpndRole_Def,
+        U_32 opndFlavor=OpndFlavor_Default
     )
     { IRPrinter p; p.setStream(os); p.setOpndRolesFilter(opndRolesFilter); p.setOpndFlavor(opndFlavor); p.printInst(inst); }
 
-    virtual uint32 printInstOpnds(const Inst * inst, uint32 opndRolesFilter);
+    virtual U_32 printInstOpnds(const Inst * inst, U_32 opndRolesFilter);
 
-    virtual void printOpndRoles(uint32 roles);
-    static void printOpndRoles(::std::ostream& os, uint32 roles)
+    virtual void printOpndRoles(U_32 roles);
+    static void printOpndRoles(::std::ostream& os, U_32 roles)
     { IRPrinter p; p.setStream(os); p.printOpndRoles(roles); }
 
     void printOpndName(const Opnd * opnd);
     static void printOpndName(::std::ostream& os, const Opnd * opnd)
     { IRPrinter p; p.setStream(os); p.printOpndName(opnd); }
 
-    virtual uint32 getOpndNameLength(Opnd * opnd);
+    virtual U_32 getOpndNameLength(Opnd * opnd);
 
-    virtual void printOpnd(const Inst * inst, uint32 idx, bool isLiveBefore=false, bool isLiveAfter=false);
+    virtual void printOpnd(const Inst * inst, U_32 idx, bool isLiveBefore=false, bool isLiveAfter=false);
 
-    virtual void printOpnd(const Opnd * opnd, uint32 roles=0, bool isLiveBefore=false, bool isLiveAfter=false);
-    static void printOpnd(::std::ostream& os, const Opnd * opnd, uint32 of=OpndFlavor_Default)
+    virtual void printOpnd(const Opnd * opnd, U_32 roles=0, bool isLiveBefore=false, bool isLiveAfter=false);
+    static void printOpnd(::std::ostream& os, const Opnd * opnd, U_32 of=OpndFlavor_Default)
     { IRPrinter p; p.setStream(os); p.setOpndFlavor(of); p.printOpnd(opnd); }
 
     virtual void printRuntimeInfo(const Opnd::RuntimeInfo * ri);
@@ -207,17 +207,17 @@
     static void printType(::std::ostream& os, const Type * type)
     { IRPrinter p; p.setStream(os); p.printType(type); }
 
-    virtual void printCFG(uint32 indent=0);
+    virtual void printCFG(U_32 indent=0);
 
-    virtual void printBody(uint32 indent=0);
-    virtual void print(uint32 indent=0);
+    virtual void printBody(U_32 indent=0);
+    virtual void print(U_32 indent=0);
 
     static const char * getPseudoInstPrintName(Inst::Kind k);
 
 protected:
-    uint32      instFilter;
-    uint32      opndFlavor;
-    uint32      opndRolesFilter;
+    U_32      instFilter;
+    U_32      opndFlavor;
+    U_32      opndRolesFilter;
 };
 
 inline ::std::ostream& operator << (::std::ostream& os, Opnd * opnd){ IRPrinter::printOpnd(os, opnd); return os; }
@@ -231,8 +231,8 @@
     IROpndPrinter(const IRManager * irm=0, const char * _title=0)
         :IRPrinter(irm, _title){}
 
-    void printBody(uint32 indent=0);
-    void printHeader(uint32 indent=0);
+    void printBody(U_32 indent=0);
+    void printHeader(U_32 indent=0);
 };
 
 //========================================================================================
@@ -243,7 +243,7 @@
 public:
     IRLivenessPrinter(const IRManager * irm=0, const char * _title=0)
         :IRPrinter(irm, _title){}
-    void printNode(const Node * node, uint32 indent=0);
+    void printNode(const Node * node, U_32 indent=0);
 
     virtual void printLiveSet(const BitSet * ls);
     static void printLiveSet(::std::ostream& os, const IRManager& irm, const BitSet * ls)
@@ -259,7 +259,7 @@
     IRInstConstraintPrinter(const IRManager * irm=0, const char * _title=0)
         :IRPrinter(irm, _title){}
 
-    virtual void printOpnd(const Inst * inst, uint32 opndIdx, bool isLiveBefore=false, bool isLiveAfter=false);
+    virtual void printOpnd(const Inst * inst, U_32 opndIdx, bool isLiveBefore=false, bool isLiveAfter=false);
 };
 
 //========================================================================================
@@ -283,12 +283,12 @@
     virtual void printTraversalOrder(CGNode::OrderType orderType);
     virtual void printLiveness();
 
-    virtual void printCFG(uint32 indent=0);
+    virtual void printCFG(U_32 indent=0);
 
-    virtual void printHeader(uint32 indent=0);
-    virtual void printEnd(uint32 indent=0);
-    virtual void printBody(uint32 indent=0);
-    virtual void print(uint32 indent=0);
+    virtual void printHeader(U_32 indent=0);
+    virtual void printEnd(U_32 indent=0);
+    virtual void printBody(U_32 indent=0);
+    virtual void print(U_32 indent=0);
     
 };
 
@@ -307,7 +307,7 @@
 
     virtual void printNode(const Node * node);
 
-    virtual void printBody(uint32 indent=0);
+    virtual void printBody(U_32 indent=0);
 
 private:
     void printLivenessForInst(const StlVector<Opnd*> opnds, const BitSet * ls0, const BitSet * ls1);
@@ -321,31 +321,31 @@
 //========================================================================================
 void dumpIR(
             const IRManager * irManager,
-            uint32 stageId,
+            U_32 stageId,
             const char * readablePrefix,
             const char * readableStageName,
             const char * stageTagName,
             const char * subKind1, 
             const char * subKind2=0,
-            uint32 instFilter=Inst::Kind_Inst, 
-            uint32 opndFlavor=IRPrinter::OpndFlavor_All,
-            uint32 opndRolesFilter=Inst::OpndRole_Explicit|Inst::OpndRole_Auxilary|Inst::OpndRole_Implicit|Inst::OpndRole_Use|Inst::OpndRole_Def
+            U_32 instFilter=Inst::Kind_Inst, 
+            U_32 opndFlavor=IRPrinter::OpndFlavor_All,
+            U_32 opndRolesFilter=Inst::OpndRole_Explicit|Inst::OpndRole_Auxilary|Inst::OpndRole_Implicit|Inst::OpndRole_Use|Inst::OpndRole_Def
             );
 
 void printDot(
             const IRManager * irManager,
-            uint32 stageId,
+            U_32 stageId,
             const char * readablePrefix,
             const char * readableStageName,
             const char * stageTagName,
             const char * subKind1, 
             const char * subKind2=0,
-            uint32 instFilter=Inst::Kind_Inst, 
-            uint32 opndFlavor=IRPrinter::OpndFlavor_All,
-            uint32 opndRolesFilter=Inst::OpndRole_Explicit|Inst::OpndRole_Auxilary|Inst::OpndRole_Implicit|Inst::OpndRole_Use|Inst::OpndRole_Def
+            U_32 instFilter=Inst::Kind_Inst, 
+            U_32 opndFlavor=IRPrinter::OpndFlavor_All,
+            U_32 opndRolesFilter=Inst::OpndRole_Explicit|Inst::OpndRole_Auxilary|Inst::OpndRole_Implicit|Inst::OpndRole_Use|Inst::OpndRole_Def
             );
 
-void printRuntimeArgs(::std::ostream& os, uint32 opndCount, CallingConvention::OpndInfo * infos, JitFrameContext * context);
+void printRuntimeArgs(::std::ostream& os, U_32 opndCount, CallingConvention::OpndInfo * infos, JitFrameContext * context);
 void printRuntimeOpnd(::std::ostream& os, TypeManager & tm, Type::Tag typeTag, const void * p);
 void printRuntimeObjectOpnd(::std::ostream& os, TypeManager & tm, const void * p);
 void printRuntimeObjectContent(::std::ostream& os, TypeManager & tm, Type * type, const void * p);

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32RCE.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32RCE.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32RCE.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32RCE.cpp Thu May 22 06:33:38 2008
@@ -45,19 +45,19 @@
  *  For example:
  *  
  *  Original code piece:
- *      I29: t50.:int32 (ID:v15(EFLGS):uint32) =AND .t28:int32,t49(1):int32 
- *      I30: (AD:v1:int32) =CopyPseudoInst (AU:t48:int32) 
- *      I31: (AD:v2:int32) =CopyPseudoInst (AU:t25:int32) 
+ *      I29: t50.:I_32 (ID:v15(EFLGS):U_32) =AND .t28:I_32,t49(1):I_32 
+ *      I30: (AD:v1:I_32) =CopyPseudoInst (AU:t48:I_32) 
+ *      I31: (AD:v2:I_32) =CopyPseudoInst (AU:t25:I_32) 
  *      I32: (AD:v3:int8[]) =CopyPseudoInst (AU:t38:int8[]) 
- *      I33: (ID:v15(EFLGS):uint32) =CMP .t50:int32,t51(0):int32 
- *      I34: JNZ BB_12 t52(0):intptr (IU:v15(EFLGS):uint32) 
+ *      I33: (ID:v15(EFLGS):U_32) =CMP .t50:I_32,t51(0):I_32 
+ *      I34: JNZ BB_12 t52(0):intptr (IU:v15(EFLGS):U_32) 
  *
  *  After optimization:
- *      I29: t50:int32 (ID:v15(EFLGS):uint32) =AND .t28:int32,t49(1):int32 
- *      I30: (AD:v1:int32) =CopyPseudoInst (AU:t48:int32) 
- *      I31: (AD:v2:int32) =CopyPseudoInst (AU:t25:int32) 
+ *      I29: t50:I_32 (ID:v15(EFLGS):U_32) =AND .t28:I_32,t49(1):I_32 
+ *      I30: (AD:v1:I_32) =CopyPseudoInst (AU:t48:I_32) 
+ *      I31: (AD:v2:I_32) =CopyPseudoInst (AU:t25:I_32) 
  *      I32: (AD:v3:int8[]) =CopyPseudoInst (AU:t38:int8[]) 
- *      I34: JNZ BB_12 t52(0):intptr (IU:v15(EFLGS):uint32) 
+ *      I34: JNZ BB_12 t52(0):intptr (IU:v15(EFLGS):U_32) 
  *
  *  The implementation of this transformer is located in Ia32RCE.cpp
  *
@@ -120,7 +120,7 @@
                             continue;
                         }
                         cmpInst = inst;
-                        uint32 defCount = inst->getOpndCount(Inst::OpndRole_InstLevel|Inst::OpndRole_Def);
+                        U_32 defCount = inst->getOpndCount(Inst::OpndRole_InstLevel|Inst::OpndRole_Def);
                         if(inst->getOpnd(defCount+1)->isPlacedIn(OpndKind_Imm)) {
                             //try to change conditional instruction to make combination available to optimize
                             cmpOp = inst->getOpnd(defCount);
@@ -219,7 +219,7 @@
      *  compared with zero by cmpInst
      *  Required: Native form of insts
      */
-    uint32 cmpOpCount = cmpInst->getOpndCount(Inst::OpndRole_InstLevel|Inst::OpndRole_UseDef);
+    U_32 cmpOpCount = cmpInst->getOpndCount(Inst::OpndRole_InstLevel|Inst::OpndRole_UseDef);
     if ((cmpOp == inst->getOpnd(0)) && cmpInst->getOpnd(cmpOpCount -1)->isPlacedIn(OpndKind_Imm) && (cmpInst->getOpnd(cmpOpCount -1)->getImmValue() == 0)) {
             return true;
     }

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

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32RegAlloc2.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32RegAlloc2.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32RegAlloc2.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32RegAlloc2.cpp Thu May 22 06:33:38 2008
@@ -71,7 +71,7 @@
 
 struct RegAlloc2 : public SessionAction
 {
-    typedef uint32 RegMask;     // used to represent set of registers
+    typedef U_32 RegMask;     // used to represent set of registers
     typedef size_t Instnb;      // used to describe instruction number
 
     typedef Interval::Span Span;        // interval of instructions not crossed basic block boundary
@@ -120,8 +120,8 @@
 
     RegAlloc2 ()                    :mm("RegAlloc2"), registers(mm), opandmap(mm) {}
 
-    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);
@@ -500,7 +500,7 @@
     opandmap.clear();
     opandmap.reserve(opandcount);
 
-    for (uint32 i = 0; i != opandcount; ++i)
+    for (U_32 i = 0; i != opandcount; ++i)
     {
         Opnd*  opnd  = irManager->getOpnd(i);
         Opand* opand = 0;
@@ -531,7 +531,7 @@
 
     //irManager->indexInsts();
 
-    BitSet lives(mm, (uint32)opandcount);
+    BitSet lives(mm, (U_32)opandcount);
 
     const Nodes& nodes = irManager->getFlowGraph()->getNodesPostOrder();
     for (Nodes::const_iterator it = nodes.begin(), end = nodes.end(); it!=end; ++it) {
@@ -545,7 +545,7 @@
             if (inst == 0)
                 continue;
 
-            uint32 instIndex=inst->getIndex();
+            U_32 instIndex=inst->getIndex();
             Opand * opand;
 
         //  start with the operands at the block bottom

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32RegAlloc3.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32RegAlloc3.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32RegAlloc3.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32RegAlloc3.cpp Thu May 22 06:33:38 2008
@@ -78,7 +78,7 @@
     unsigned coalesceCount;
 
     class BoolMatrix;
-    typedef uint32 RegMask;     // used to represent set of registers
+    typedef U_32 RegMask;     // used to represent set of registers
 
     static void merge (Constraint& c, RegMask mk)   {c.setMask(c.getMask() | mk);}
 
@@ -106,7 +106,7 @@
     struct Oprole
     {
         Inst* inst;
-        uint32 role;
+        U_32 role;
     };
     typedef StlVector<Oprole> Oproles;
 
@@ -151,8 +151,8 @@
 
     RegAlloc3 ()                    : mm("RegAlloc3"), registers(mm), graph(mm), nstack(mm) {}
 
-    uint32 getNeedInfo () const     {return NeedInfo_LivenessInfo;}
-    uint32 getSideEffects () const  {return coalesceCount == 0 ? 0 : SideEffect_InvalidatesLivenessInfo;}
+    U_32 getNeedInfo () const     {return NeedInfo_LivenessInfo;}
+    U_32 getSideEffects () const  {return coalesceCount == 0 ? 0 : SideEffect_InvalidatesLivenessInfo;}
 
     void runImpl();
     void SpillGen ();
@@ -771,7 +771,7 @@
     Inst::Opnds opnds(inst, Inst::OpndRole_All);
     for (Inst::Opnds::iterator it = opnds.begin(); it != opnds.end(); it = opnds.next(it))
     {
-        uint32 role = inst->getOpndRoles(it);
+        U_32 role = inst->getOpndRoles(it);
         Opnd*  opnd = inst->getOpnd(it);
 
     //  For each operand def, look at the all live operand

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32RegAllocCheck.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32RegAllocCheck.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32RegAllocCheck.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32RegAllocCheck.cpp Thu May 22 06:33:38 2008
@@ -98,7 +98,7 @@
 
 static RegName regName (int x)
 {
-    uint32 k = x / IRMaxRegNamesSameKind;
+    U_32 k = x / IRMaxRegNamesSameKind;
     return getRegName((OpndKind)k, Constraint::getDefaultSize(k), x % IRMaxRegNamesSameKind);
 }
 
@@ -122,7 +122,7 @@
 {
     lastbb = 0;
 
-    BitSet lives(mm, (uint32)opandcount);
+    BitSet lives(mm, (U_32)opandcount);
     irm.getLiveAtExit(bblock, lives);
 
     Opnd* regdefs[MaxRegs],
@@ -158,7 +158,7 @@
 
     for (Inst* inst = (Inst*)bblock->getLastInst(); inst != 0; inst = inst->getPrevInst())
     {
-        const uint32 props = inst->getProperties();
+        const U_32 props = inst->getProperties();
 
     //  In general, operands can be stored in arbitrary order
         Inst::Opnds opnds(inst, Inst::OpndRole_All);
@@ -166,7 +166,7 @@
             opnd = opnds.getOpnd(it);
             if ((ridx = regIdx(opnd)) < MaxRegs)
             {
-                const uint32 roles = inst->getOpndRoles(it);
+                const U_32 roles = inst->getOpndRoles(it);
 
                 if ((roles & Inst::OpndRole_Def) != 0)
                 {
@@ -240,7 +240,7 @@
 {
     for (size_t i = 0; i != opandcount; ++i)
     {
-        Opnd* opnd = irm.getOpnd((uint32)i);
+        Opnd* opnd = irm.getOpnd((U_32)i);
         if (!opnd->hasAssignedPhysicalLocation())
         {
             header() << "Not assigned opand " << *opnd << endl;
@@ -257,7 +257,7 @@
     {
         Opnd* opnd;
         Inst::Opnds opnds(inst, Inst::OpndRole_AllDefs);
-        uint32 mask = 0;
+        U_32 mask = 0;
         for (Inst::Opnds::iterator it = opnds.begin(); it != opnds.end(); it = opnds.next(it))
         {
             opnd = opnds.getOpnd(it);

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32RegAllocCheck.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32RegAllocCheck.h?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32RegAllocCheck.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32RegAllocCheck.h Thu May 22 06:33:38 2008
@@ -58,7 +58,7 @@
 
 protected:
 
-    typedef uint32 RegMask;
+    typedef U_32 RegMask;
 
     const IRManager& irm;
     MemoryManager     mm;

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32RuntimeInterface.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32RuntimeInterface.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32RuntimeInterface.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32RuntimeInterface.cpp Thu May 22 06:33:38 2008
@@ -67,7 +67,7 @@
     return (void *)(context->rsp + stackInfo.getStackDepth() + (int)stackInfo.getOffsetOfThis());
 #else
     stackInfo.read(methodDesc, *context->p_eip, isFirst);
-    assert(isFirst || (uint32)context->p_eip+4 == context->esp);
+    assert(isFirst || (U_32)context->p_eip+4 == context->esp);
     //assert(stackInfo.getStackDepth()==0 || !isFirst);
     return (void *)(context->esp + stackInfo.getStackDepth() + stackInfo.getOffsetOfThis());
 #endif
@@ -98,7 +98,7 @@
 
     POINTER_SIZE_INT nativeOffset = (POINTER_SIZE_INT)native_pc - (POINTER_SIZE_INT)method->getCodeBlockAddress(0);
     assert(nativeOffset<=1024*1024*1024);//extra check: we do not generate such a large methods..
-    uint16 bcOffset = BcMap::get_bc_offset_for_native_offset((uint32)nativeOffset, infoBlock + stackInfoSize + gcMapSize);
+    uint16 bcOffset = BcMap::get_bc_offset_for_native_offset((U_32)nativeOffset, infoBlock + stackInfoSize + gcMapSize);
     if (bcOffset != ILLEGAL_BC_MAPPING_VALUE) {
         *bc_pc = bcOffset;
         return true;
@@ -115,7 +115,7 @@
     POINTER_SIZE_INT stackInfoSize = stackInfo.readByteSize(infoBlock);
     POINTER_SIZE_INT gcMapSize = GCMap::readByteSize(infoBlock + stackInfoSize);
 
-    uint32 nativeOffset = BcMap::get_native_offset_for_bc_offset(bc_pc, infoBlock + stackInfoSize + gcMapSize);
+    U_32 nativeOffset = BcMap::get_native_offset_for_bc_offset(bc_pc, infoBlock + stackInfoSize + gcMapSize);
     if (nativeOffset!= MAX_UINT32) {
         *native_pc =  (POINTER_SIZE_INT)(method->getCodeBlockAddress(0) + nativeOffset);
         return true;
@@ -126,19 +126,19 @@
     return false;
 }
 
-uint32  RuntimeInterface::getInlineDepth(InlineInfoPtr ptr, uint32 offset) {
+U_32  RuntimeInterface::getInlineDepth(InlineInfoPtr ptr, U_32 offset) {
     const InlineInfoMap::Entry* e = InlineInfoMap::getEntryWithMaxDepth(ptr, offset);
     // real instructions are recorded at an extra nested level to enclosing method
     // but we need to count method marker entries only
     return e == NULL ? 0 : e->getInlineDepth() - 1;
 }
 
-Method_Handle   RuntimeInterface::getInlinedMethod(InlineInfoPtr ptr, uint32 offset, uint32 inline_depth) {
+Method_Handle   RuntimeInterface::getInlinedMethod(InlineInfoPtr ptr, U_32 offset, U_32 inline_depth) {
     const InlineInfoMap::Entry* e = InlineInfoMap::getEntry(ptr, offset, inline_depth);
     return e == NULL  ? 0 : e->method;
 }
 
-uint16 RuntimeInterface::getInlinedBc(InlineInfoPtr ptr, uint32 offset, uint32 inline_depth) {
+uint16 RuntimeInterface::getInlinedBc(InlineInfoPtr ptr, U_32 offset, U_32 inline_depth) {
     const InlineInfoMap::Entry* e = InlineInfoMap::getEntryWithMaxDepth(ptr, offset);
     assert(inline_depth);
 
@@ -149,7 +149,7 @@
     // In both cases needed bcOffset is stored in child entry
     const InlineInfoMap::Entry* childCallee = e;
     while (e) {
-        uint32 depth = e->getInlineDepth();
+        U_32 depth = e->getInlineDepth();
         if (depth == inline_depth)
         {
             return childCallee->bcOffset;

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32RuntimeInterface.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32RuntimeInterface.h?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32RuntimeInterface.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32RuntimeInterface.h Thu May 22 06:33:38 2008
@@ -58,9 +58,9 @@
     virtual bool getBcLocationForNative(MethodDesc* method, POINTER_SIZE_INT native_pc, uint16 *bc_pc);
     virtual bool getNativeLocationForBc(MethodDesc* method,  uint16 bc_pc, POINTER_SIZE_INT *native_pc);
 
-    virtual uint32          getInlineDepth(InlineInfoPtr ptr, uint32 offset);
-    virtual Method_Handle   getInlinedMethod(InlineInfoPtr ptr, uint32 offset, uint32 inline_depth);
-    virtual uint16  getInlinedBc(InlineInfoPtr ptr, uint32 offset, uint32 inline_depth);
+    virtual U_32          getInlineDepth(InlineInfoPtr ptr, U_32 offset);
+    virtual Method_Handle   getInlinedMethod(InlineInfoPtr ptr, U_32 offset, U_32 inline_depth);
+    virtual uint16  getInlinedBc(InlineInfoPtr ptr, U_32 offset, U_32 inline_depth);
 
 };
 

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32SpillGen.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32SpillGen.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32SpillGen.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32SpillGen.cpp Thu May 22 06:33:38 2008
@@ -47,7 +47,7 @@
 //  Inter-blocks data
 //  -----------------
 
-    typedef uint32 RegMask;
+    typedef U_32 RegMask;
     typedef StlVector<Opnd*> Opnds;
 
     MemoryManager mm;           // this is private MemoryManager, not irm.getMemoryManager()
@@ -203,8 +203,8 @@
                                     , lives_start(0), lives_exit(0)
                                     {}
 
-    uint32 getNeedInfo () const     {return NeedInfo_LivenessInfo;}
-    uint32 getSideEffects () const  {return SideEffect_InvalidatesLivenessInfo;}
+    U_32 getNeedInfo () const     {return NeedInfo_LivenessInfo;}
+    U_32 getSideEffects () const  {return SideEffect_InvalidatesLivenessInfo;}
 
     void runImpl();
     bool verify(bool force=false);
@@ -593,7 +593,7 @@
     emitted = 0;
 
     opndcount = irManager->getOpndCount();
-    lives_exit = new (mm) BitSet(mm, (uint32)opndcount); 
+    lives_exit = new (mm) BitSet(mm, (U_32)opndcount); 
 
     actsmap.resize(opndcount);
     for (size_t i = 0; i < opndcount; ++i)
@@ -610,7 +610,7 @@
             }
 
             lives_start = irManager->getLiveAtEntry(bblock);
-            lives_exit->resize((uint32)opndcount);
+            lives_exit->resize((U_32)opndcount);
             irManager->getLiveAtExit(bblock, *lives_exit);
 
             size_t bfails = 0;
@@ -643,7 +643,7 @@
                 {
                     size_t oldcount = opndcount;
                     opndcount = irManager->getOpndCount();
-                    lives_exit->resize((uint32)opndcount);
+                    lives_exit->resize((U_32)opndcount);
                     irManager->fixLivenessInfo();
 
                     actsmap.resize(opndcount);
@@ -777,7 +777,7 @@
         {
             opnd = inst->getOpnd(it);
 
-            uint32 roles = inst->getOpndRoles(it);
+            U_32 roles = inst->getOpndRoles(it);
 
             OpRole oprole = 0;
 

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32StackInfo.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32StackInfo.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32StackInfo.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32StackInfo.cpp Thu May 22 06:33:38 2008
@@ -52,8 +52,8 @@
         stackInfo->registerInsts(*irManager);
         stackInfo->setMethodExitString(*irManager);
     }
-    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; }
 };
 
@@ -63,11 +63,11 @@
 #define CALL_MIN_SIZE 2
 #define CALL_MAX_SIZE 6
 
-POINTER_SIZE_INT hashFunc(POINTER_SIZE_INT key, uint32 hashTableSize) {
+POINTER_SIZE_INT hashFunc(POINTER_SIZE_INT key, U_32 hashTableSize) {
     return (key % hashTableSize);
 }
 
-    StackDepthInfo hashGet(DepthEntry** entries, POINTER_SIZE_INT key, uint32 hashTableSize) {
+    StackDepthInfo hashGet(DepthEntry** entries, POINTER_SIZE_INT key, U_32 hashTableSize) {
         DepthEntry * e = entries[hashFunc(key,hashTableSize)];
         assert(e);
         for(;e !=NULL;) {
@@ -80,7 +80,7 @@
         return e->info;
     }
 
-    void hashSet(DepthEntry** entries, POINTER_SIZE_INT eip, uint32 hashTableSize,StackDepthInfo info, MemoryManager& mm) {
+    void hashSet(DepthEntry** entries, POINTER_SIZE_INT eip, U_32 hashTableSize,StackDepthInfo info, MemoryManager& mm) {
         POINTER_SIZE_INT key = hashFunc(eip,hashTableSize);
         DepthEntry * e = entries[key];
         if(!e) {
@@ -119,13 +119,13 @@
     data+=sizeof(StackInfo);
     MemoryManager mm("DepthInfo");
     EntryPtr * entries = new(mm) EntryPtr[hashTableSize];
-    for(uint32 i = 0; i< hashTableSize; i++)
+    for(U_32 i = 0; i< hashTableSize; i++)
         entries[i] = NULL;
     for(DepthMap::iterator dmit = stackDepthInfo->begin(); dmit != stackDepthInfo->end(); dmit++) {
         hashSet(entries, dmit->first, hashTableSize, dmit->second, mm);
     }
     U_8* next = data + hashTableSize * sizeof(POINTER_SIZE_INT);
-    for(uint32 i = 0; i< hashTableSize; i++) {
+    for(U_32 i = 0; i< hashTableSize; i++) {
         DepthEntry * e = entries[i];
         POINTER_SIZE_INT serializedEntryAddr = 0;
         if(entries[i]) {
@@ -143,7 +143,7 @@
     assert(getByteSize() == (POINTER_SIZE_INT) (((U_8*)next) - bytes));
 }
 
-DepthEntry * getHashEntry(U_8* data, POINTER_SIZE_INT eip, uint32 size) 
+DepthEntry * getHashEntry(U_8* data, POINTER_SIZE_INT eip, U_32 size) 
 {
     if(!size)
         return NULL;
@@ -186,7 +186,7 @@
             stackDepth = 0; //0 depth -> stack overflow error
         } else {
             DepthEntry * entry = NULL;
-            uint32 i = CALL_MIN_SIZE;
+            U_32 i = CALL_MIN_SIZE;
             for (; i<= CALL_MAX_SIZE; i++) {
                 entry = getHashEntry(data, eip + i, hashTableSize);
                 if(entry)
@@ -269,7 +269,7 @@
 
     context->esp += stackDepth;
 
-    uint32 offset = context->esp;
+    U_32 offset = context->esp;
     context->p_eip = (POINTER_SIZE_INT *) offset;
 
     offset += icalleeOffset;
@@ -370,13 +370,13 @@
 #ifdef _EM64T_
         if ((md.isSynchronized() || md.isParentClassIsLikelyExceptionType())) {
             EntryPointPseudoInst * entryPointInst = irm.getEntryPointInst();
-            offsetOfThis = (uint32)entryPointInst->thisOpnd->getMemOpndSubOpnd(MemOpndSubOpndKind_Displacement)->getImmValue();
+            offsetOfThis = (U_32)entryPointInst->thisOpnd->getMemOpndSubOpnd(MemOpndSubOpndKind_Displacement)->getImmValue();
         } else {
             offsetOfThis = 0;
         }
 #else
         EntryPointPseudoInst * entryPointInst = irm.getEntryPointInst();
-        offsetOfThis = (uint32)entryPointInst->getOpnd(0)->getMemOpndSubOpnd(MemOpndSubOpndKind_Displacement)->getImmValue();
+        offsetOfThis = (U_32)entryPointInst->getOpnd(0)->getMemOpndSubOpnd(MemOpndSubOpndKind_Displacement)->getImmValue();
 #endif
     }
     const Nodes& nodes = irm.getFlowGraph()->getNodes();
@@ -393,7 +393,7 @@
             }
         }
     }
-    hashTableSize = (uint32)stackDepthInfo->size();
+    hashTableSize = (U_32)stackDepthInfo->size();
 }
 
 void StackInfo::setMethodExitString(IRManager& irm)

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32StackInfo.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32StackInfo.h?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32StackInfo.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32StackInfo.h Thu May 22 06:33:38 2008
@@ -39,12 +39,12 @@
      */
     
     struct StackDepthInfo {
-        uint32 calleeSaveRegs;
-        uint32 stackDepth;
-        uint32 callSize;
+        U_32 calleeSaveRegs;
+        U_32 stackDepth;
+        U_32 callSize;
 
-        StackDepthInfo(uint32 sd=0) : calleeSaveRegs(0), stackDepth(sd), callSize(0) {}
-        StackDepthInfo(uint32 e, uint32 sd=0, uint32 cz=0) : calleeSaveRegs(e), stackDepth(sd), callSize(cz) {}
+        StackDepthInfo(U_32 sd=0) : calleeSaveRegs(0), stackDepth(sd), callSize(0) {}
+        StackDepthInfo(U_32 e, U_32 sd=0, U_32 cz=0) : calleeSaveRegs(e), stackDepth(sd), callSize(cz) {}
     };
 
     struct DepthEntry {
@@ -149,29 +149,29 @@
         return stackDepth;
     }
 
-    uint32 getFrameSize() const {return frameSize;}
+    U_32 getFrameSize() const {return frameSize;}
 
-    int32 getRetEIPOffset() const {return eipOffset;}
+    I_32 getRetEIPOffset() const {return eipOffset;}
     
-    uint32 getIntCalleeMask() const {return icalleeMask;}
+    U_32 getIntCalleeMask() const {return icalleeMask;}
     
-    int32 getIntCalleeOffset() const {return icalleeOffset;}
+    I_32 getIntCalleeOffset() const {return icalleeOffset;}
     
-    uint32 getFPCalleeMask() const {return fcallee;}
+    U_32 getFPCalleeMask() const {return fcallee;}
     
-    int32 getFPCalleeOffset() const {return foffset;}
+    I_32 getFPCalleeOffset() const {return foffset;}
 
-    uint32 getApplCalleeMask() const {return acallee;}
+    U_32 getApplCalleeMask() const {return acallee;}
     
-    int32 getApplCalleeOffset() const {return aoffset;}
+    I_32 getApplCalleeOffset() const {return aoffset;}
 
-    int32 getLocalOffset() const {return localOffset;}
+    I_32 getLocalOffset() const {return localOffset;}
 
-    uint32 getOffsetOfThis() const {return offsetOfThis;}
+    U_32 getOffsetOfThis() const {return offsetOfThis;}
 
-    uint32 getSOECheckAreaOffset() const {return soeCheckAreaOffset;}
+    U_32 getSOECheckAreaOffset() const {return soeCheckAreaOffset;}
 
-    void setSOECheckAreaOffset(uint32 v) {soeCheckAreaOffset = v;}
+    void setSOECheckAreaOffset(U_32 v) {soeCheckAreaOffset = v;}
 
     /** returns byte size of StackInfo data
     */
@@ -186,30 +186,30 @@
 
 private:
     POINTER_SIZE_INT byteSize;
-    uint32  hashTableSize;
-    int32   frameSize;
+    U_32  hashTableSize;
+    I_32   frameSize;
     
     const char * itraceMethodExitString;
 
-    int32   eipOffset;
+    I_32   eipOffset;
 
-    uint32  icalleeMask;
-    int32   icalleeOffset;
+    U_32  icalleeMask;
+    I_32   icalleeOffset;
 
-    uint32  fcallee;
-    int32   foffset;
+    U_32  fcallee;
+    I_32   foffset;
 
-    uint32  acallee;
-    int32   aoffset;
+    U_32  acallee;
+    I_32   aoffset;
 
-    int32   localOffset;
+    I_32   localOffset;
     
     DepthMap * stackDepthInfo;
 
-    uint32 calleeSaveRegsMask;
-    int32  stackDepth;
-    uint32 offsetOfThis;
-    uint32 soeCheckAreaOffset;
+    U_32 calleeSaveRegsMask;
+    I_32  stackDepth;
+    U_32 offsetOfThis;
+    U_32 soeCheckAreaOffset;
 
     friend class StackLayouter;
 };

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32StackLayout.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32StackLayout.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32StackLayout.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32StackLayout.cpp Thu May 22 06:33:38 2008
@@ -88,8 +88,8 @@
     StackInfo * getStackInfo() { return stackInfo; }
     void runImpl();
 
-    uint32 getNeedInfo()const{ return 0; }
-    uint32 getSideEffects()const{ return 0; }
+    U_32 getNeedInfo()const{ return 0; }
+    U_32 getSideEffects()const{ return 0; }
 
 protected:
     void checkUnassignedOpnds();
@@ -104,36 +104,36 @@
     */
     void createEpilog();
 
-    int32 getLocalBase(){ return  localBase; }
-    int32 getLocalEnd(){ return  localEnd; }
-    int32 getApplCalleeBase(){ return  acalleeBase; }
-    int32 getApplCalleeEnd(){ return  acalleeEnd; }
-    int32 getFloatCalleeBase(){ return  fcalleeBase; }
-    int32 getFloatCalleeEnd(){ return  fcalleeEnd; }
-    int32 getIntCalleeBase(){ return  icalleeBase; }
-    int32 getIntCalleeEnd(){ return  icalleeEnd; }
-    int32 getRetEIPBase(){ return  retEIPBase; } 
-    int32 getRetEIPEnd(){ return  retEIPEnd; }
-    int32 getInArgBase(){ return  inargBase; } 
-    int32 getInArgEnd(){ return  inargEnd; }
-    int32 getFrameSize(){ return  frameSize; }
-    uint32 getOutArgSize(){ return  outArgSize; }
-
-    int32 localBase;
-    int32 localEnd;
-    int32 fcalleeBase;
-    int32 fcalleeEnd;
-    int32 acalleeBase;
-    int32 acalleeEnd;
-    int32 icalleeBase;
-    int32 icalleeEnd;
-
-    int32 retEIPBase;
-    int32 retEIPEnd;
-    int32 inargBase;
-    int32 inargEnd;
-    int32 frameSize;
-    uint32 outArgSize;
+    I_32 getLocalBase(){ return  localBase; }
+    I_32 getLocalEnd(){ return  localEnd; }
+    I_32 getApplCalleeBase(){ return  acalleeBase; }
+    I_32 getApplCalleeEnd(){ return  acalleeEnd; }
+    I_32 getFloatCalleeBase(){ return  fcalleeBase; }
+    I_32 getFloatCalleeEnd(){ return  fcalleeEnd; }
+    I_32 getIntCalleeBase(){ return  icalleeBase; }
+    I_32 getIntCalleeEnd(){ return  icalleeEnd; }
+    I_32 getRetEIPBase(){ return  retEIPBase; } 
+    I_32 getRetEIPEnd(){ return  retEIPEnd; }
+    I_32 getInArgBase(){ return  inargBase; } 
+    I_32 getInArgEnd(){ return  inargEnd; }
+    I_32 getFrameSize(){ return  frameSize; }
+    U_32 getOutArgSize(){ return  outArgSize; }
+
+    I_32 localBase;
+    I_32 localEnd;
+    I_32 fcalleeBase;
+    I_32 fcalleeEnd;
+    I_32 acalleeBase;
+    I_32 acalleeEnd;
+    I_32 icalleeBase;
+    I_32 icalleeEnd;
+
+    I_32 retEIPBase;
+    I_32 retEIPEnd;
+    I_32 inargBase;
+    I_32 inargEnd;
+    I_32 frameSize;
+    U_32 outArgSize;
     StackInfo * stackInfo;
 
     MemoryManager memoryManager;
@@ -209,22 +209,22 @@
 
 #define MAX_STACK_FOR_SOE_HANDLERS 0x2000
 
-static void insertSOECheck(IRManager& irm, uint32 maxStackUsedByMethod) {
+static void insertSOECheck(IRManager& irm, U_32 maxStackUsedByMethod) {
 #ifdef _EM64T_
     //SOE checking is not finished on EM64T
     //TODO: work on stack alignment & SOE checkers
     if (true) return; 
 #endif
-    uint32 stackToCheck = maxStackUsedByMethod + (hasSOEHandlers(irm) ? MAX_STACK_FOR_SOE_HANDLERS : 0);
+    U_32 stackToCheck = maxStackUsedByMethod + (hasSOEHandlers(irm) ? MAX_STACK_FOR_SOE_HANDLERS : 0);
     if (stackToCheck == 0) {
         return;
     }
-    static const uint32 PAGE_SIZE=0x1000;
+    static const U_32 PAGE_SIZE=0x1000;
     
-    uint32 nPagesToCheck = stackToCheck / PAGE_SIZE;
+    U_32 nPagesToCheck = stackToCheck / PAGE_SIZE;
     Inst* prevInst = irm.getEntryPointInst();
-    for(uint32 i=0;i<=nPagesToCheck; i++) {
-        uint32 offset = i < nPagesToCheck ? PAGE_SIZE * (i+1) : stackToCheck;
+    for(U_32 i=0;i<=nPagesToCheck; i++) {
+        U_32 offset = i < nPagesToCheck ? PAGE_SIZE * (i+1) : stackToCheck;
         Opnd* guardedMemOpnd = irm.newMemOpnd(irm.getTypeFromTag(Type::IntPtr), MemOpndKind_Heap, irm.getRegOpnd(STACK_REG), -(int)offset);
         Inst* guardInst = irm.newInst(Mnemonic_TEST, guardedMemOpnd, irm.getRegOpnd(STACK_REG));
         guardInst->insertAfter(prevInst);
@@ -245,7 +245,7 @@
     irManager->calculateTotalRegUsage(OpndKind_GPReg);
     createProlog();
     createEpilog();
-    uint32 maxStackDepth = irManager->calculateStackDepth();
+    U_32 maxStackDepth = irManager->calculateStackDepth();
     insertSOECheck(*irManager, maxStackDepth);
     irManager->layoutAliasOpnds();
 
@@ -264,7 +264,7 @@
 
 void StackLayouter::checkUnassignedOpnds()
 {
-    for (uint32 i=0, n=irManager->getOpndCount(); i<n; i++) {
+    for (U_32 i=0, n=irManager->getOpndCount(); i<n; i++) {
 #ifdef _DEBUG
         Opnd * opnd = irManager->getOpnd(i);
         assert(!opnd->getRefCount() || opnd->hasAssignedPhysicalLocation());
@@ -274,11 +274,11 @@
 
 void StackLayouter::createProlog()
 {
-    const uint32 slotSize = sizeof(POINTER_SIZE_INT); 
+    const U_32 slotSize = sizeof(POINTER_SIZE_INT); 
     EntryPointPseudoInst* entryPointInst = NULL;
     const CallingConventionClient* cClient = NULL;
     const CallingConvention* cConvention = NULL;
-    uint32 stackSizeAlignment = 0; 
+    U_32 stackSizeAlignment = 0; 
     int offset = 0;
     
     entryPointInst = irManager->getEntryPointInst();
@@ -290,7 +290,7 @@
         ? STACK_ALIGN16 : cConvention->getStackAlignment();
 
     // Create or reset displacements for stack memory operands.
-    for (uint32 i = 0; i < irManager->getOpndCount(); i++) {
+    for (U_32 i = 0; i < irManager->getOpndCount(); i++) {
         Opnd * opnd = irManager->getOpnd(i);
         if (opnd->getRefCount() && opnd->getMemOpndKind() == MemOpndKind_StackAutoLayout) {
             Opnd * dispOpnd=opnd->getMemOpndSubOpnd(MemOpndSubOpndKind_Displacement);
@@ -313,7 +313,7 @@
         const StlVector<CallingConventionClient::StackOpndInfo>& stackOpndInfos = 
             cClient->getStackOpndInfos(Inst::OpndRole_Def);
 
-        for (uint32 i = 0, n = (uint32)stackOpndInfos.size(); i < n; i++) {
+        for (U_32 i = 0, n = (U_32)stackOpndInfos.size(); i < n; i++) {
             uint64 argOffset = stackOpndInfos[i].offset;
             Opnd * opnd = entryPointInst->getOpnd(stackOpndInfos[i].opndIndex);
             Opnd * disp = opnd->getMemOpndSubOpnd(MemOpndSubOpndKind_Displacement);
@@ -323,17 +323,17 @@
     inargEnd = offset;
     icalleeEnd = offset = 0;
 
-    uint32 calleeSavedRegs = cConvention->getCalleeSavedRegs(OpndKind_GPReg).getMask();
-    uint32 usageRegMask = irManager->getTotalRegUsage(OpndKind_GPReg);
+    U_32 calleeSavedRegs = cConvention->getCalleeSavedRegs(OpndKind_GPReg).getMask();
+    U_32 usageRegMask = irManager->getTotalRegUsage(OpndKind_GPReg);
     Inst * lastPush = NULL;
     
     // Push callee-save registers onto stack.
 #ifdef _EM64T_
-    for (uint32 reg = RegName_R15; reg >= RegName_RAX; reg--) {
+    for (U_32 reg = RegName_R15; reg >= RegName_RAX; reg--) {
 #else
-    for (uint32 reg = RegName_EDI; reg >= RegName_EAX; reg--) {
+    for (U_32 reg = RegName_EDI; reg >= RegName_EAX; reg--) {
 #endif
-        uint32 mask = getRegMask((RegName)reg);
+        U_32 mask = getRegMask((RegName)reg);
         if ((mask & calleeSavedRegs) && (usageRegMask & mask)) {
             Inst * inst = irManager->newInst(Mnemonic_PUSH, irManager->getRegOpnd((RegName)reg));
             if (!lastPush) {
@@ -363,7 +363,7 @@
 
     // Assign displacements for local variable operands.
     for (int j = 0; j <= alignmentSequenceSize; j++) {
-        for (uint32 i = 0; i < irManager->getOpndCount(); i++) {
+        for (U_32 i = 0; i < irManager->getOpndCount(); i++) {
             Opnd * opnd = irManager->getOpnd(i);
             Opnd::MemOpndAlignment currentAlignment = alignmentSequence[j];
             if(opnd->getRefCount() != 0 
@@ -373,14 +373,14 @@
                 if (dispOpnd->getImmValue() == 0) {
                     if (relations[opnd->getId()].outerOpnd == NULL) {
                         if (currentAlignment == Opnd::MemOpndAlignment_Any) {
-                            uint32 cb = getByteSize(opnd->getSize());
+                            U_32 cb = getByteSize(opnd->getSize());
                             cb = (cb + (slotSize - 1)) & ~(slotSize - 1);
                             offset -= cb;
                         } else {
                             // Make sure 
                             assert((stackSizeAlignment % currentAlignment) == 0);
                             // It just doesn't make sense to align on less than operand size.
-                            assert((uint32)currentAlignment >= getByteSize(opnd->getSize()));
+                            assert((U_32)currentAlignment >= getByteSize(opnd->getSize()));
                             offset -= currentAlignment;
                         }
                         dispOpnd->assignImmValue(offset);
@@ -408,9 +408,9 @@
 
 void StackLayouter::createEpilog()
 { // Predeccessors of en and irManager->isEpilog(en->pred)
-    uint32 calleeSavedRegs = irManager->getCallingConvention()->getCalleeSavedRegs(OpndKind_GPReg).getMask();
+    U_32 calleeSavedRegs = irManager->getCallingConvention()->getCalleeSavedRegs(OpndKind_GPReg).getMask();
     const Edges& inEdges = irManager->getFlowGraph()->getExitNode()->getInEdges();
-    uint32 usageRegMask = irManager->getTotalRegUsage(OpndKind_GPReg);
+    U_32 usageRegMask = irManager->getTotalRegUsage(OpndKind_GPReg);
     for (Edges::const_iterator ite = inEdges.begin(), ende = inEdges.end(); ite!=ende; ++ite) {
         Edge* edge = *ite;
         if (irManager->isEpilog(edge->getSourceNode())) {
@@ -423,11 +423,11 @@
                 newIns->insertBefore(retInst);
             }
 #ifdef _EM64T_
-            for (uint32 reg = RegName_R15; reg >= RegName_RAX ; reg--) {//pop callee-save registers
+            for (U_32 reg = RegName_R15; reg >= RegName_RAX ; reg--) {//pop callee-save registers
 #else
-            for (uint32 reg = RegName_EDI; reg >= RegName_EAX ; reg--) {//pop callee-save registers
+            for (U_32 reg = RegName_EDI; reg >= RegName_EAX ; reg--) {//pop callee-save registers
 #endif
-                uint32 mask = getRegMask((RegName)reg);
+                U_32 mask = getRegMask((RegName)reg);
                 if ((mask & calleeSavedRegs) &&  (usageRegMask & mask)) {
                     Inst* newIns = irManager->newInst(Mnemonic_POP, irManager->getRegOpnd((RegName)reg));
                     newIns->insertBefore(retInst);

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32WebMaker.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32WebMaker.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32WebMaker.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32WebMaker.cpp Thu May 22 06:33:38 2008
@@ -101,8 +101,8 @@
 
     WebMaker ()                     :mm("WebMaker"), opndxs(mm), nodexs(mm) {}
 
-    uint32 getNeedInfo () const     {return NeedInfo_LivenessInfo;}
-    uint32 getSideEffects () const  {return splitcount == 0 ? 0 : SideEffect_InvalidatesLivenessInfo;}
+    U_32 getNeedInfo () const     {return NeedInfo_LivenessInfo;}
+    U_32 getSideEffects () const  {return splitcount == 0 ? 0 : SideEffect_InvalidatesLivenessInfo;}
 
     void runImpl();
     void calculateConstraints();
@@ -164,32 +164,32 @@
 {
 public:
 
-    InstOpnds (const Inst* inst, uint32 roles = Inst::OpndRole_All, bool forw = true);
+    InstOpnds (const Inst* inst, U_32 roles = Inst::OpndRole_All, bool forw = true);
 
     bool hasMore () const           {return opnd != 0;}
     void next ()                    {move();}
     Opnd*  getOpnd () const         {return opnd;}
-    uint32 getRole () const         {return role;}
+    U_32 getRole () const         {return role;}
 
 protected:
 
     bool move ();
 
     const Inst*  inst;
-    const uint32 roles;
+    const U_32 roles;
     const unsigned main_count;
 
     unsigned state,
              main_idx,
               sub_idx;
 
-    uint32 role;
+    U_32 role;
     Opnd* opnd;
     Opnd* main_opnd;
 };
 
 
-InstOpnds::InstOpnds (const Inst* i, uint32 r, bool forw)
+InstOpnds::InstOpnds (const Inst* i, U_32 r, bool forw)
 :inst(i), roles(r), main_count(i->getOpndCount())
 {
     if (main_count == 0)
@@ -366,7 +366,7 @@
         if (nodep->isBlockNode())
         {
             for (Inst* instp = (Inst*)nodep->getFirstInst(); instp!=NULL; instp = instp->getNextInst()) {
-                const uint32 iprops = instp->getProperties();
+                const U_32 iprops = instp->getProperties();
                 Inst::Opnds defs(instp, Inst::OpndRole_AllDefs);
                 unsigned itx = 0;
                 for (Inst::Opnds::iterator it = defs.begin(); it != defs.end(); it = defs.next(it), ++itx)
@@ -377,8 +377,8 @@
                     Opndx* opndxp = opndxs.at(opndp->getId());
                     if (opndxp != 0)
                     {
-                        const uint32 oprole = const_cast<const Inst*>(instp)->getOpndRoles(itx);
-                        //const uint32 oprole = inops.getRole();
+                        const U_32 oprole = const_cast<const Inst*>(instp)->getOpndRoles(itx);
+                        //const U_32 oprole = inops.getRole();
                         const bool isdef = ((oprole & Inst::OpndRole_UseDef) == Inst::OpndRole_Def)
                                         && ((iprops & Inst::Properties_Conditional) == 0 );
                         if (isdef)
@@ -466,7 +466,7 @@
             opndxp->copdefp = 0;
         }
     
-    BitSet wrkbs(mm, (uint32)globcount);
+    BitSet wrkbs(mm, (U_32)globcount);
     bool   wrkbsvalid;
     size_t passnb = 0;
     const Nodes& postOrder = irManager->getFlowGraph()->getNodesPostOrder();
@@ -558,7 +558,7 @@
             
             for (Inst* instp = (Inst*)nodep->getFirstInst(); instp != 0; instp = instp->getNextInst()) 
             {
-                const uint32 iprops = instp->getProperties();
+                const U_32 iprops = instp->getProperties();
 
                 for (InstOpnds inops(instp, Inst::OpndRole_All, false); inops.hasMore(); inops.next())
                 {
@@ -567,7 +567,7 @@
                     if (opndxp != 0)
                     {
                         OpDef* opdefp = 0;
-                        const uint32 oprole = inops.getRole();
+                        const U_32 oprole = inops.getRole();
                         const bool isdef = ((oprole & Inst::OpndRole_UseDef) == Inst::OpndRole_Def)
                                         && ((iprops & Inst::Properties_Conditional) == 0 );
                         DBGOUT(" B#" << instp->getBasicBlock()->getId() << " " << *instp;)

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32i586InstsExpansion.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32i586InstsExpansion.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32i586InstsExpansion.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32i586InstsExpansion.cpp Thu May 22 06:33:38 2008
@@ -47,8 +47,8 @@
     void lowerToX87();
     void lowerToSSE();
 
-    uint32 getNeedInfo()const{ return 0; }
-    uint32 getSideEffects()const{ return hasSideEffects ? SideEffect_InvalidatesLivenessInfo: 0; }
+    U_32 getNeedInfo()const{ return 0; }
+    U_32 getSideEffects()const{ return hasSideEffects ? SideEffect_InvalidatesLivenessInfo: 0; }
     bool isIRDumpEnabled(){ return hasSideEffects;}
 
     bool hasSideEffects;

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfCfg.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfCfg.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfCfg.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfCfg.cpp Thu May 22 06:33:38 2008
@@ -88,7 +88,7 @@
                              Node   *target, 
                              double  prob, 
                              Type   *exceptionType, 
-                             uint32  priority) :
+                             U_32  priority) :
     Edge(source, target, prob, EDGE_EXCEPTION), 
     exceptionType(exceptionType),
     priority(priority) {
@@ -98,7 +98,7 @@
 // Node
 //========================================================================================//
 
-Node::Node(MemoryManager &mm, uint32 id, uint32 execCounter, NodeKind kind) : 
+Node::Node(MemoryManager &mm, U_32 id, U_32 execCounter, NodeKind kind) : 
     id(id), 
     execCounter(execCounter),
     nodeKind(kind),  
@@ -202,7 +202,7 @@
 // BbNode
 //========================================================================================//
 
-BbNode::BbNode(MemoryManager &mm, uint32 id, uint32 execCounter) : 
+BbNode::BbNode(MemoryManager &mm, U_32 id, U_32 execCounter) : 
     Node(mm, id, execCounter, NODE_BB),
     insts(mm),
     layoutSucc(NULL),
@@ -253,7 +253,7 @@
     visitedNodes.insert(node);                       // mark node visited
 
     EdgeVector& inEdges = node->getInEdges();        // get inEdges
-    for (uint32 i=0; i<inEdges.size(); i++) {        // iterate through inEdges
+    for (U_32 i=0; i<inEdges.size(); i++) {        // iterate through inEdges
         Node *pred = inEdges[i]->getSource();        // get pred node
         if (visitedNodes.count(pred) == 1) continue; // if it is already visited - ignore
         makeDirectOrdered(pred, visitedNodes);       // we have found unvisited pred - reenter
@@ -269,7 +269,7 @@
     visitedNodes.insert(node);                        // mark node visited
 
     EdgeVector& outEdges = node->getOutEdges();       // get outEdges
-    for (uint32 i=0; i<outEdges.size(); i++) {        // iterate through outEdges
+    for (U_32 i=0; i<outEdges.size(); i++) {        // iterate through outEdges
         Node *succ = outEdges[i]->getTarget();        // get succ node
         if (visitedNodes.count(succ) == 1) continue;  // if it is already visited - ignore
         makePostOrdered(succ, visitedNodes);          // we have found unvisited succ - reenter

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfCodeLayouter.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfCodeLayouter.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfCodeLayouter.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfCodeLayouter.cpp Thu May 22 06:33:38 2008
@@ -357,7 +357,7 @@
     // sort chains 
     ChainMap order(mm);
     for (ChainListIterator it=chains.begin(); it!=chains.end(); it++) {
-        uint32 weight = calculateChainWeight(*it);  // calculate chain weight
+        U_32 weight = calculateChainWeight(*it);  // calculate chain weight
         order.insert( make_pair(weight, *it) );     // insert pair weight->chain in map
     }
 
@@ -381,11 +381,11 @@
 //----------------------------------------------------------------------------------------//
 // chain weight is exec counters summ of all nodes in the chain
 
-uint32 CodeLayouter::calculateChainWeight(Chain *chain) {
+U_32 CodeLayouter::calculateChainWeight(Chain *chain) {
 
     if (chain->front() == cfg.getEnterNode()) return UINT_MAX;  // enter node always goes first
     
-    uint32 weight = 0;
+    U_32 weight = 0;
     for (ChainIterator it=chain->begin(); it!=chain->end(); it++) {
         if ((*it)->isBb() == false) continue;
         BbNode *node = (BbNode *) *it;



Mime
View raw message