harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From mcfi...@apache.org
Subject svn commit: r659108 [10/19] - in /harmony/enhanced/drlvm/trunk/vm: em/src/ gc_gen/src/common/ gc_gen/src/mark_compact/ gc_gen/src/mark_sweep/ gc_gen/src/semi_space/ gc_gen/src/trace_forward/ include/open/ interpreter/src/ jitrino/src/codegenerator/ jit...
Date Thu, 22 May 2008 13:34:09 GMT
Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/Inst.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/Inst.h?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/Inst.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/Inst.h Thu May 22 06:33:38 2008
@@ -133,7 +133,7 @@
 
     Operation getOperation() const {return operation;}
 
-    uint32 getId() const {return id;}
+    U_32 getId() const {return id;}
 
     PersistentInstructionId getPersistentInstructionId() const {return pid; }
 
@@ -157,16 +157,16 @@
             dst->setInst(this);
     }
 
-    uint32  getNumSrcOperands() const    {return numSrcs;}
+    U_32  getNumSrcOperands() const    {return numSrcs;}
 
-    Opnd*   getSrc(uint32 srcIndex) const {
+    Opnd*   getSrc(U_32 srcIndex) const {
         assert(srcIndex < numSrcs);
         if (srcIndex >= MAX_INST_SRCS)
             return getSrcExtended(srcIndex);
         return srcs[srcIndex];
     }
 
-    void  setSrc(uint32 srcIndex, Opnd* src) {
+    void  setSrc(U_32 srcIndex, Opnd* src) {
         assert(srcIndex < numSrcs);
         if (srcIndex >= MAX_INST_SRCS)
             setSrcExtended(srcIndex, src);
@@ -366,16 +366,16 @@
     Inst(Opcode op, Modifier modifier, Type::Tag, Opnd* dst, Opnd* src);
     Inst(Opcode op, Modifier modifier, Type::Tag, Opnd* dst, Opnd* src1, Opnd* src2);
     Inst(Opcode op, Modifier modifier, Type::Tag, Opnd* dst, Opnd* src1, Opnd* src2, Opnd *src3);
-    Inst(Opcode op, Modifier modifier, Type::Tag, Opnd* dst, uint32 nSrcs);
+    Inst(Opcode op, Modifier modifier, Type::Tag, Opnd* dst, U_32 nSrcs);
     //
     // fields
     //
     Operation operation;
-    uint32  numSrcs;
+    U_32  numSrcs;
     Opnd*   srcs[MAX_INST_SRCS];
     Opnd*   dst;
     PersistentInstructionId pid;
-    uint32  id;
+    U_32  id;
     
     
     // called from CFG to detect BB->BB block edges
@@ -386,8 +386,8 @@
     //
     // protected accessor methods that deriving classes should override
     //
-    virtual Opnd* getSrcExtended(uint32 srcIndex) const;
-    virtual void  setSrcExtended(uint32 srcIndex, Opnd* src) {assert(0);}
+    virtual Opnd* getSrcExtended(U_32 srcIndex) const;
+    virtual void  setSrcExtended(U_32 srcIndex, Opnd* src) {assert(0);}
     virtual void  handlePrintEscape(::std::ostream&, char code) const;
 private:
     friend class InstFactory;
@@ -396,8 +396,8 @@
 
 class LabelInst : public Inst {
 public:
-    uint32    getLabelId() const            {return labelId;}
-    void      setLabelId(uint32 id_)    {labelId = id_;}
+    U_32    getLabelId() const            {return labelId;}
+    void      setLabelId(U_32 id_)    {labelId = id_;}
     bool      isLabel() const               {return true;}
     virtual bool isDispatchLabel() const    {return false;}
     virtual bool isCatchLabel() const       {return false;}
@@ -406,16 +406,16 @@
     void visit(InstFormatVisitor& visitor)  {visitor.accept(this);}
     virtual void printId(::std::ostream&) const;
 protected:
-    LabelInst(uint32 id)
+    LabelInst(U_32 id)
              : Inst(Op_Label, Modifier(), Type::Void, OpndManager::getNullOpnd()),
                labelId(id), state(NULL) {}
-    LabelInst(Opcode opc, uint32 id)
+    LabelInst(Opcode opc, U_32 id)
              : Inst(opc, Modifier(), Type::Void, OpndManager::getNullOpnd()),
                labelId(id), state(NULL) {}
     virtual void handlePrintEscape(::std::ostream&, char code) const;
 private:
     friend class InstFactory;
-    uint32   labelId;
+    U_32   labelId;
     
     void*    state;     
 };
@@ -427,7 +427,7 @@
     void printId(::std::ostream&) const;
 protected:
     friend class InstFactory;
-    DispatchLabelInst(uint32 labelId) : LabelInst(labelId) {}
+    DispatchLabelInst(U_32 labelId) : LabelInst(labelId) {}
     virtual void handlePrintEscape(::std::ostream&, char code) const;
 };
 
@@ -435,16 +435,16 @@
 public:
     bool      isCatchLabel() const     {return true; }
     void visit(InstFormatVisitor& visitor)  {visitor.accept(this);}
-    uint32    getOrder() const         {return order;}
+    U_32    getOrder() const         {return order;}
     Type*     getExceptionType() const {return exception;}
     void printId(::std::ostream&) const;
 protected:
-    CatchLabelInst(uint32 id, uint32 ord, Type *except)
+    CatchLabelInst(U_32 id, U_32 ord, Type *except)
               : LabelInst(id), order(ord), exception(except) {}
     virtual void handlePrintEscape(::std::ostream&, char code) const;
 private:
     friend class InstFactory;
-    uint32   order;
+    U_32   order;
     Type     *exception;
 };
 
@@ -454,7 +454,7 @@
     void visit(InstFormatVisitor& visitor)  {visitor.accept(this);}
     bool isMethodEntry() const { return true; }
 protected:
-    MethodEntryInst(uint32 id, MethodDesc* md)
+    MethodEntryInst(U_32 id, MethodDesc* md)
         : LabelInst(Op_MethodEntry, id), methodDesc(md){}
     virtual void handlePrintEscape(::std::ostream&, char code) const;
 private:
@@ -512,7 +512,7 @@
     void       replaceTargetLabel(LabelInst* target) {targetLabel = target;}
     LabelInst* getTargetLabel() const      {return targetLabel;}
     void       swapTargets(LabelInst *target);
-    Edge       *getTakenEdge(uint32 condition);
+    Edge       *getTakenEdge(U_32 condition);
 protected:
     virtual void handlePrintEscape(::std::ostream&, char code) const;
     virtual Edge::Kind getEdgeKind(const Edge* edge) const;
@@ -542,7 +542,7 @@
 
 class SwitchInst : public Inst {
 public:
-    LabelInst* getTarget(uint32 i) {
+    LabelInst* getTarget(U_32 i) {
         assert(i < numTargets);
         return targetInsts[i];
     }
@@ -550,8 +550,8 @@
     void visit(InstFormatVisitor& visitor)  {visitor.accept(this);}
     bool isSwitch() const {return true;}
     LabelInst* getDefaultTarget() const {return defaultTargetInst;}
-    uint32     getNumTargets() {return numTargets;}
-    void       replaceTargetLabel(uint32 i, LabelInst* target) {
+    U_32     getNumTargets() {return numTargets;}
+    void       replaceTargetLabel(U_32 i, LabelInst* target) {
         assert(i < numTargets);
         targetInsts[i] = target;
     }
@@ -563,26 +563,26 @@
     virtual void updateControlTransferInst(Node* oldTarget, Node* newTarget); 
 private:
     friend class InstFactory;
-    SwitchInst(Opnd* src, LabelInst** targets, uint32 nTargets, LabelInst* defTarget)
+    SwitchInst(Opnd* src, LabelInst** targets, U_32 nTargets, LabelInst* defTarget)
         : Inst(Op_Switch, Modifier(), Type::Void, OpndManager::getNullOpnd(), src),
           targetInsts(targets), defaultTargetInst(defTarget), numTargets(nTargets) {
     }
     LabelInst** targetInsts;
     LabelInst*  defaultTargetInst;
-    uint32      numTargets;
+    U_32      numTargets;
 };
 
 class ConstInst : public Inst {
 public:
     union ConstValue {
         void*    i;    // I  (can be NULL for ldnull)
-        int32    i4;   // I4
+        I_32    i4;   // I4
         int64    i8;   // I8
         float    s;    // Single
         double   d;    // Double
         struct {
-            int32 dword1;
-            int32 dword2;
+            I_32 dword1;
+            I_32 dword2;
         };
         ConstValue() {dword1=dword2=0;}
     };
@@ -595,7 +595,7 @@
     friend class InstFactory;
     ConstInst(Opnd* d, ConstValue cv)
         : Inst(Op_LdConstant, Modifier(), d->getType()->tag, d) { value = cv; }
-    ConstInst(Opnd* d, int32 i4)
+    ConstInst(Opnd* d, I_32 i4)
         : Inst(Op_LdConstant, Modifier(), Type::Int32, d)  {value.i4 = i4;}
     ConstInst(Opnd* d, int64 i8)
         : Inst(Op_LdConstant, Modifier(), Type::Int64, d)  {value.i8 = i8;}
@@ -613,17 +613,17 @@
 class TokenInst : public Inst {
 public:
     void visit(InstFormatVisitor& visitor)  {visitor.accept(this);}
-    uint32 getToken() const   {return token;}
+    U_32 getToken() const   {return token;}
     MethodDesc*    getEnclosingMethod()     {return enclosingMethod;}
     bool isToken() const                    {return true;}
 protected:
     virtual void handlePrintEscape(::std::ostream&, char code) const;
 private:
     friend class InstFactory;
-    TokenInst(Opcode opc, Modifier mod, Type::Tag type, Opnd* d, uint32 t, MethodDesc* encMethod)
+    TokenInst(Opcode opc, Modifier mod, Type::Tag type, Opnd* d, U_32 t, MethodDesc* encMethod)
         : Inst(opc, mod, type, d), token(t), enclosingMethod(encMethod) {}
 
-    uint32      token;
+    U_32      token;
     MethodDesc* enclosingMethod;
 };
 
@@ -632,18 +632,18 @@
 public:
     void visit(InstFormatVisitor& visitor)  {visitor.accept(this);}
     Class_Handle     getEnclosingClass()  {return enclosingClass;}
-    uint32           getCPIndex() const   {return cp_index;}
-    uint32           getOperation() const {return operation;}
+    U_32           getCPIndex() const   {return cp_index;}
+    U_32           getOperation() const {return operation;}
 private:
     friend class InstFactory;
     LinkingExcInst(Opcode opc, Modifier mod, Type::Tag type, Opnd* d,
-                   Class_Handle encClass, uint32 cp_ndx, uint32 _operation)
+                   Class_Handle encClass, U_32 cp_ndx, U_32 _operation)
         : Inst(opc, mod, type, d),
           enclosingClass(encClass), cp_index(cp_ndx), operation(_operation) {}
 
     Class_Handle     enclosingClass;
-    uint32           cp_index;
-    uint32           operation;
+    U_32           cp_index;
+    U_32           operation;
 };
 
 // for ldvar, ldvara & stvar instructions
@@ -725,7 +725,7 @@
                  Modifier mod,
                  Type::Tag ty,
                  Opnd* dst,
-                 uint32 nSrcs_,
+                 U_32 nSrcs_,
                  Opnd** srcs_)
         : Inst(op, mod, ty, dst, nSrcs_),
           extendedSrcs(srcs_), extendedSrcSpace(nSrcs_)
@@ -736,38 +736,38 @@
         case 1:     srcs[0] = srcs_[0];
         case 0:     break;
         }
-        for (uint32 i=2; i < nSrcs_; i++) {
+        for (U_32 i=2; i < nSrcs_; i++) {
             srcs_[i-MAX_INST_SRCS] = srcs_[i];
             srcs_[i] = 0;
         }
     }
 private:
     friend class InstFactory;
-    Opnd* getSrcExtended(uint32 srcIndex) const {
+    Opnd* getSrcExtended(U_32 srcIndex) const {
         assert(srcIndex < (extendedSrcSpace + MAX_INST_SRCS));
         return extendedSrcs[srcIndex - MAX_INST_SRCS];
     }
-    void  setSrcExtended(uint32 srcIndex, Opnd* src) {
+    void  setSrcExtended(U_32 srcIndex, Opnd* src) {
         assert(srcIndex < (extendedSrcSpace + MAX_INST_SRCS));
         extendedSrcs[srcIndex - MAX_INST_SRCS] = src;
     }
     Opnd**    extendedSrcs;
-    uint32    extendedSrcSpace;
+    U_32    extendedSrcSpace;
 
-    void initSrcs(uint32 nSrcs_, Opnd**srcs_) {
+    void initSrcs(U_32 nSrcs_, Opnd**srcs_) {
         switch (nSrcs_) {
         default:    
         case 2:     srcs[1] = srcs_[1];
         case 1:     srcs[0] = srcs_[0];
         case 0:     break;
         }
-        for (uint32 i=2; i < nSrcs_; i++) {
+        for (U_32 i=2; i < nSrcs_; i++) {
             srcs_[i-MAX_INST_SRCS] = srcs_[i];
             extendedSrcs = srcs_ + MAX_INST_SRCS;
         }
     }
 public:
-    void  setNumSrcs(uint32 nSrcs) {
+    void  setNumSrcs(U_32 nSrcs) {
         assert(nSrcs <= numSrcs);
         numSrcs = nSrcs;
     }
@@ -788,7 +788,7 @@
              Opnd* src1, Opnd* src2, Type* td)
         : MultiSrcInst(op, mod, ty, dst, src1, src2), type(td) {}
     TypeInst(Opcode op, Modifier mod, Type::Tag ty, Opnd* dst,
-             uint32 nArgs, Opnd** args_, Type* td)
+             U_32 nArgs, Opnd** args_, Type* td)
         : MultiSrcInst(op, mod, ty, dst, nArgs, args_), type(td){}
     virtual void handlePrintEscape(::std::ostream&, char code) const;
 private:
@@ -831,7 +831,7 @@
                     Modifier mod,
                     Type::Tag type,
                     Opnd* dst,
-                    uint32 numSrcs,
+                    U_32 numSrcs,
                     Opnd** srcs,
                     FieldDesc* fd)
         : MultiSrcInst(op, mod, type, dst, numSrcs, srcs), fieldDesc(fd) {}
@@ -853,7 +853,7 @@
                Modifier mod,
                Type::Tag type,
                Opnd* dst,
-               uint32 nArgs,
+               U_32 nArgs,
                Opnd ** srcs,
                MethodDesc* md)
         : MultiSrcInst(op, mod, type, dst, nArgs, srcs), methodDesc(md) {}
@@ -887,7 +887,7 @@
     MethodCallInst(Opcode op, Modifier mod,
                    Type::Tag type,
                    Opnd* dst,
-                   uint32 nArgs,
+                   U_32 nArgs,
                    Opnd** args_,
                    MethodDesc* md,
                    MemoryManager& mem_mgr)
@@ -900,8 +900,8 @@
     bool isCall() const {return true; }
     void visit(InstFormatVisitor& visitor)  {visitor.accept(this);}
     Opnd*   getFunPtr()             {return srcs[0];}
-    uint32  getNumArgs() const      {return getNumSrcOperands()-1;}
-    Opnd*   getArg(uint32 argIndex) {return getSrc(argIndex+1);}
+    U_32  getNumArgs() const      {return getNumSrcOperands()-1;}
+    Opnd*   getArg(U_32 argIndex) {return getSrc(argIndex+1);}
     Opnd**  getArgs()               {args[0] = srcs[1]; return args;}
 private:
     friend class InstFactory;
@@ -910,7 +910,7 @@
              Type::Tag type,
              Opnd* dst,
              Opnd* ptr,
-             uint32 nArgs,
+             U_32 nArgs,
              Opnd** args_,
              MemoryManager& mem_mgr)
         : Inst(op, mod, type, dst, nArgs+1)
@@ -922,11 +922,11 @@
         case 0:     srcs[0] = ptr;
         }
     }
-    Opnd* getSrcExtended(uint32 srcIndex) const {
+    Opnd* getSrcExtended(U_32 srcIndex) const {
         assert(srcIndex != 1);
         return args[srcIndex - 1];
     }
-    void  setSrcExtended(uint32 srcIndex, Opnd* src) {
+    void  setSrcExtended(U_32 srcIndex, Opnd* src) {
         assert(srcIndex != 1);
         args[srcIndex - 1] = src;
     }
@@ -946,7 +946,7 @@
                       Modifier mod,
                       Type::Tag type,
                       Opnd* dst,
-                      uint32 nArgs,
+                      U_32 nArgs,
                       Opnd** args_,
                       JitHelperCallId id) : Inst(op, mod, type, dst, nArgs),
                                             jitHelperId(id) {
@@ -958,10 +958,10 @@
         case 0:     break;
         }
     }
-    Opnd* getSrcExtended(uint32 srcIndex) const {
+    Opnd* getSrcExtended(U_32 srcIndex) const {
         return args[srcIndex - MAX_INST_SRCS];
     }
-    void  setSrcExtended(uint32 srcIndex, Opnd* src) {
+    void  setSrcExtended(U_32 srcIndex, Opnd* src) {
         args[srcIndex - MAX_INST_SRCS] = src;
     }
     Opnd**    args;
@@ -982,7 +982,7 @@
                      Modifier mod,
                      Type::Tag type,
                      Opnd* dst,
-                     uint32 nArgs,
+                     U_32 nArgs,
                      Opnd** args_,
                      VM_RT_SUPPORT id) 
                      : Inst(op, mod, type, dst, nArgs), vmHelperId(id)
@@ -995,10 +995,10 @@
         case 0:     break;
         }
     }
-    Opnd* getSrcExtended(uint32 srcIndex) const {
+    Opnd* getSrcExtended(U_32 srcIndex) const {
         return args[srcIndex];
     }
-    void  setSrcExtended(uint32 srcIndex, Opnd* src) {
+    void  setSrcExtended(U_32 srcIndex, Opnd* src) {
         args[srcIndex] = src;
     }
     Opnd**    args;
@@ -1014,7 +1014,7 @@
     bool isPhi() const { return true; }
 private:
     friend class InstFactory;
-    PhiInst(Type::Tag type, Opnd* dst, uint32 nArgs, Opnd** args_ )
+    PhiInst(Type::Tag type, Opnd* dst, U_32 nArgs, Opnd** args_ )
         : MultiSrcInst(Op_Phi, Modifier(), type, dst, nArgs, args_)
     {
     }
@@ -1077,38 +1077,38 @@
     Inst*    makeBranch(ComparisonModifier mod, Type::Tag, Opnd* src1, Opnd* src2, LabelInst* labelInst);
     Inst*    makeBranch(ComparisonModifier mod, Type::Tag, Opnd* src, LabelInst* labelInst);
     Inst*    makeJump(LabelInst* labelInst);
-    Inst*    makeSwitch(Opnd* src, uint32 nLabels, LabelInst** labelInsts, LabelInst* defaultLabel);
+    Inst*    makeSwitch(Opnd* src, U_32 nLabels, LabelInst** labelInsts, LabelInst* defaultLabel);
     Inst*    makeDirectCall(Opnd* dst, 
                             Opnd* tauNullChecked, Opnd* tauTypesChecked,
-                            uint32 numArgs, Opnd** args, 
+                            U_32 numArgs, Opnd** args, 
                             MethodDesc*);
     Inst*    makeTauVirtualCall(Opnd* dst, 
                                 Opnd* tauNullChecked, Opnd *tauTypesChecked,
-                                uint32 numArgs, Opnd** args, 
+                                U_32 numArgs, Opnd** args, 
                                 MethodDesc*);
     Inst*    makeIndirectCall(Opnd* dst, Opnd* funPtr,
                               Opnd* tauNullCheckedFirstArg, Opnd *tauTypesChecked, 
-                              uint32 numArgs, Opnd** args);
+                              U_32 numArgs, Opnd** args);
     Inst*    makeIndirectMemoryCall(Opnd* dst, Opnd* funPtr, 
                                     Opnd *tauNullCheckedFirstArg, 
                                     Opnd *tauTypesChecked,
-                                    uint32 numArgs, Opnd** args);
+                                    U_32 numArgs, Opnd** args);
     Inst*    makeJitHelperCall(Opnd* dst, JitHelperCallId id, 
                                Opnd* tauNullChecked, Opnd* tauTypesChecked, 
-                               uint32 numArgs, Opnd** args);
-    Inst*    makeVMHelperCall(Opnd* dst, VM_RT_SUPPORT id, uint32 numArgs,
+                               U_32 numArgs, Opnd** args);
+    Inst*    makeVMHelperCall(Opnd* dst, VM_RT_SUPPORT id, U_32 numArgs,
                                Opnd** args);
     
 
     Inst*    makeReturn(Opnd* src);
     Inst*    makeReturn();    // void return type
     Inst*    makeCatch(Opnd* dst);
-    Inst*    makeCatchLabel(uint32 labelId, uint32 exceptionOrder, Type* exceptionType);
-    CatchLabelInst*    makeCatchLabel(uint32 exceptionOrder, Type* exceptionType);
+    Inst*    makeCatchLabel(U_32 labelId, U_32 exceptionOrder, Type* exceptionType);
+    CatchLabelInst*    makeCatchLabel(U_32 exceptionOrder, Type* exceptionType);
     Inst*    makeThrow(ThrowModifier mod, Opnd* exceptionObj);
     Inst*    makePseudoThrow();
     Inst*    makeThrowSystemException(CompilationInterface::SystemExceptionId exceptionId);
-    Inst*    makeThrowLinkingException(Class_Handle encClass, uint32 CPIndex, uint32 operation);
+    Inst*    makeThrowLinkingException(Class_Handle encClass, U_32 CPIndex, U_32 operation);
     Inst*    makeLeave(LabelInst* labelInst);
     Inst*    makeEndFinally();
     Inst*    makeEndFilter();
@@ -1119,13 +1119,13 @@
     // load, store, & mov
     Inst*    makeCopy(Opnd* dst, Opnd* src);
     Inst*    makeDefArg(Modifier, Opnd* arg);
-    Inst*    makeLdConst(Opnd* dst, int32 val);
+    Inst*    makeLdConst(Opnd* dst, I_32 val);
     Inst*    makeLdConst(Opnd* dst, int64 val);
     Inst*    makeLdConst(Opnd* dst, float val);
     Inst*    makeLdConst(Opnd* dst, double val);
     Inst*    makeLdConst(Opnd* dst, ConstInst::ConstValue val);
     Inst*    makeLdNull(Opnd* dst);
-    Inst*    makeLdRef(Modifier mod, Opnd* dst, MethodDesc* enclosingMethod, uint32 token);
+    Inst*    makeLdRef(Modifier mod, Opnd* dst, MethodDesc* enclosingMethod, U_32 token);
     Inst*    makeLdVar(Opnd* dst, VarOpnd* var);
     Inst*    makeLdVar(Opnd* dst, SsaVarOpnd* var);
     Inst*    makeLdVarAddr(Opnd* dst, VarOpnd* var);
@@ -1182,7 +1182,7 @@
     // alloc
     Inst*    makeNewObj(Opnd* dst, Type* type);
     Inst*    makeNewArray(Opnd* dst, Opnd* numElems, Type* elemType);
-    Inst*    makeNewMultiArray(Opnd* dst, uint32 dimensions, Opnd** numElems, Type* elemType);
+    Inst*    makeNewMultiArray(Opnd* dst, U_32 dimensions, Opnd** numElems, Type* elemType);
     // sync
     Inst*    makeTauMonitorEnter(Opnd* src, Opnd *tauSrcNonNull);
     Inst*    makeTauMonitorExit(Opnd* src, Opnd *tauSrcNonNull);
@@ -1192,10 +1192,10 @@
     Inst*    makeLdLockAddr(Opnd *dst, Opnd *obj);   // result is ref:int16
     Inst*    makeIncRecCount(Opnd *obj, Opnd *oldValue);
     Inst*    makeTauBalancedMonitorEnter(Opnd* dst, Opnd *src, Opnd *lockAddr,
-                                         Opnd *tauSrcNonNull); // result is int32
+                                         Opnd *tauSrcNonNull); // result is I_32
     Inst*    makeBalancedMonitorExit(Opnd* src, Opnd *lockAddr, Opnd *enterDst);
     Inst*    makeTauOptimisticBalancedMonitorEnter(Opnd* dst, Opnd *src, Opnd *lockAddr,
-                                                   Opnd *tauSrcNonNull); // result is int32
+                                                   Opnd *tauSrcNonNull); // result is I_32
     Inst*    makeOptimisticBalancedMonitorExit(Opnd* src, Opnd *lockAddr, Opnd *enterDst);
     Inst*    makeMonitorEnterFence(Opnd* src);  // elided MonitorEnter, just enforce memory model
     Inst*    makeMonitorExitFence(Opnd* src);   // elided MonitorExit, just enforce memory model
@@ -1224,15 +1224,15 @@
     Inst*    makeSizeof(Opnd* dst, Type* type);
     Inst*    makeBox(Opnd* dst, Opnd* val, Type* type);
     Inst*    makeUnbox(Opnd* dst, Opnd* obj, Type* type);
-    Inst*    makeLdToken(Opnd* dst, MethodDesc* enclosingMethod, uint32 metadataToken);
+    Inst*    makeLdToken(Opnd* dst, MethodDesc* enclosingMethod, U_32 metadataToken);
 
 
     // SSA
-    Inst*    makePhi(Opnd* dst, uint32 numOpnds, Opnd** opnds); // array is copied
+    Inst*    makePhi(Opnd* dst, U_32 numOpnds, Opnd** opnds); // array is copied
     Inst*    makeTauPi(Opnd* dst, Opnd* src, Opnd *tau, PiCondition *cond);
 
     // profile counter increment
-    Inst*    makeIncCounter(uint32 val);
+    Inst*    makeIncCounter(U_32 val);
     Inst*    makePrefetch(Opnd* addr); // prefetch
 
     // compressed references
@@ -1250,7 +1250,7 @@
     // new tau methods
     Inst*    makeTauPoint(Opnd *dst);
     Inst*    makeTauEdge(Opnd *dst);
-    Inst*    makeTauAnd(Opnd *dst, uint32 numOpnds, Opnd** opnds); // array is copied
+    Inst*    makeTauAnd(Opnd *dst, U_32 numOpnds, Opnd** opnds); // array is copied
     Inst*    makeTauUnsafe(Opnd *dst);
     Inst*    makeTauSafe(Opnd *dst);
     Inst*    makeTauCheckCast(Opnd *taudst, Opnd* src, Opnd* tauCheckedNull, Type* type);
@@ -1261,13 +1261,13 @@
     //
     //
     //
-    uint32   createLabelNumber()     {return maxNumLabels++; }
-    uint32   getMaxNumLabels()       {return maxNumLabels;   }
-    uint32   getNumInsts()           {return numInsts;       }
+    U_32   createLabelNumber()     {return maxNumLabels++; }
+    U_32   getMaxNumLabels()       {return maxNumLabels;   }
+    U_32   getNumInsts()           {return numInsts;       }
     
 private:
-    uint32   maxNumLabels;        // number of labels generated
-    uint32   numInsts;            // number of instructions generated
+    U_32   maxNumLabels;        // number of labels generated
+    U_32   numInsts;            // number of instructions generated
     MemoryManager& memManager;
 
     //
@@ -1281,9 +1281,9 @@
     //
     // private helpers for making different types of instructions
     //
-    Opnd**  copyOpnds(Opnd** srcs, uint32 numSrcs);
-    Opnd**  copyOpnds(Opnd* src1, Opnd** srcs, uint32 numSrcs);
-    Opnd**  copyOpnds(Opnd* src1, Opnd* src2, Opnd** srcs, uint32 numSrcs);
+    Opnd**  copyOpnds(Opnd** srcs, U_32 numSrcs);
+    Opnd**  copyOpnds(Opnd* src1, Opnd** srcs, U_32 numSrcs);
+    Opnd**  copyOpnds(Opnd* src1, Opnd* src2, Opnd** srcs, U_32 numSrcs);
 
     //
     // methods for copying instructions
@@ -1324,13 +1324,13 @@
 
 private:
     // makes a copy of a LabelInst
-    LabelInst*          makeLabelInst(uint32 labelId);
-    LabelInst*          makeLabelInst(Opcode opc, uint32 labelId);
-    DispatchLabelInst*  makeDispatchLabelInst(uint32 labelId);
-    CatchLabelInst*     makeCatchLabelInst(uint32 lableId,
-                                       uint32 ord,
+    LabelInst*          makeLabelInst(U_32 labelId);
+    LabelInst*          makeLabelInst(Opcode opc, U_32 labelId);
+    DispatchLabelInst*  makeDispatchLabelInst(U_32 labelId);
+    CatchLabelInst*     makeCatchLabelInst(U_32 lableId,
+                                       U_32 ord,
                                        Type *exceptionType);
-    MethodEntryInst*    makeMethodEntryInst(uint32 labelId, MethodDesc*) ;
+    MethodEntryInst*    makeMethodEntryInst(U_32 labelId, MethodDesc*) ;
     MethodMarkerInst*   makeMethodMarkerInst(MethodMarkerInst::Kind, MethodDesc*, 
             Opnd *obj, Opnd *retOpnd);
     MethodMarkerInst*   makeMethodMarkerInst(MethodMarkerInst::Kind, MethodDesc*, Opnd *retOpnd);
@@ -1348,9 +1348,9 @@
                                LabelInst* target);
     SwitchInst* makeSwitchInst(Opnd* src,
                                LabelInst** targets,
-                               uint32 nTargets,
+                               U_32 nTargets,
                                LabelInst* defTarget);
-    ConstInst* makeConstInst(Opnd* dst, int32 i4);
+    ConstInst* makeConstInst(Opnd* dst, I_32 i4);
     ConstInst* makeConstInst(Opnd* dst, int64 i8) ;
     ConstInst* makeConstInst(Opnd* dst, float fs);
     ConstInst* makeConstInst(Opnd* dst, double fd) ;
@@ -1359,9 +1359,9 @@
     //
     // fix parameter names!
     //
-    TokenInst* makeTokenInst(Opcode opc, Modifier mod, Type::Tag, Opnd* dst, uint32 t, MethodDesc* encMethod);
+    TokenInst* makeTokenInst(Opcode opc, Modifier mod, Type::Tag, Opnd* dst, U_32 t, MethodDesc* encMethod);
     LinkingExcInst* makeLinkingExcInst(Opcode opc, Modifier mod, Type::Tag type, Opnd* dst,
-                                       Class_Handle encClass, uint32 CPIndex, uint32 operation);
+                                       Class_Handle encClass, U_32 CPIndex, U_32 operation);
     VarAccessInst* makeVarAccessInst(Opcode, Type::Tag, Opnd* dst, VarOpnd* var);
     VarAccessInst* makeVarAccessInst(Opcode, Type::Tag, VarOpnd* var, Opnd* src);
     VarAccessInst* makeVarAccessInst(Opcode, Type::Tag, Opnd* dst,
@@ -1398,7 +1398,7 @@
                            Modifier mod,
                            Type::Tag,
                            Opnd* dst,
-                           uint32 nArgs,
+                           U_32 nArgs,
                            Opnd** args,
                            Type*);
     FieldAccessInst* makeFieldAccessInst(Opcode, Modifier mod, Type::Tag, Opnd* dst, FieldDesc*);
@@ -1414,7 +1414,7 @@
                                          Modifier mod,
                                          Type::Tag type,
                                          Opnd* dst,
-                                         uint32 nSrcs,
+                                         U_32 nSrcs,
                                          Opnd** srcs,
                                          FieldDesc* fd);
     MethodInst* makeMethodInst(Opcode, Modifier mod, Type::Tag type, Opnd* dst, MethodDesc* md);
@@ -1422,7 +1422,7 @@
                                Modifier mod,
                                Type::Tag,
                                Opnd* dst,
-                               uint32 nArgs,
+                               U_32 nArgs,
                                MethodDesc*);
     MethodInst* makeMethodInst(Opcode,
                                Modifier mod,
@@ -1441,46 +1441,46 @@
                                Modifier mod,
                                Type::Tag,
                                Opnd* dst,
-                               uint32 nArgs,
+                               U_32 nArgs,
                                Opnd** args_,
                                MethodDesc*);
     MethodCallInst* makeMethodCallInst(Opcode,
                                        Modifier mod,
                                        Type::Tag,
                                        Opnd* dst,
-                                       uint32 nArgs,
+                                       U_32 nArgs,
                                        Opnd** args_,
                                        MethodDesc*);
     CallInst* makeCallInst(Opcode op, Modifier mod,
                            Type::Tag,
                            Opnd* dst,
                            Opnd* ptr,
-                           uint32 nArgs,
+                           U_32 nArgs,
                            Opnd** args);
     JitHelperCallInst* makeJitHelperCallInst(Opcode op, 
                                              Modifier mod,
                                              Type::Tag,
                                              Opnd* dst,
-                                             uint32 nArgs,
+                                             U_32 nArgs,
                                              Opnd** args_,
                                              JitHelperCallId id);
     VMHelperCallInst* makeVMHelperCallInst(Opcode op, 
                                            Modifier mod,
                                            Type::Tag,
                                            Opnd* dst,
-                                           uint32 nArgs,
+                                           U_32 nArgs,
                                            Opnd** args_,
                                            VM_RT_SUPPORT id);
 
 
-    PhiInst* makePhiInst(Type::Tag type, Opnd* dst, uint32 nArgs, Opnd** args_);
+    PhiInst* makePhiInst(Type::Tag type, Opnd* dst, U_32 nArgs, Opnd** args_);
 
     MultiSrcInst* makeMultiSrcInst(Opcode, Modifier mod, Type::Tag, Opnd* dst);
     MultiSrcInst* makeMultiSrcInst(Opcode, Modifier mod, Type::Tag, Opnd* dst, Opnd* src);
     MultiSrcInst* makeMultiSrcInst(Opcode, Modifier mod, Type::Tag, Opnd* dst, Opnd* src1, Opnd* src2);
     MultiSrcInst* makeMultiSrcInst(Opcode, Modifier mod, Type::Tag, Opnd* dst, Opnd* src1, Opnd* src2, Opnd* src3);
     MultiSrcInst* makeMultiSrcInst(Opcode, Modifier mod, Type::Tag, Opnd* dst, Opnd* src1, Opnd* src2, Opnd* src3, Opnd* src4);
-    MultiSrcInst* makeMultiSrcInst(Opcode, Modifier mod, Type::Tag, Opnd* dst, uint32 nSrcs, Opnd** srcs);
+    MultiSrcInst* makeMultiSrcInst(Opcode, Modifier mod, Type::Tag, Opnd* dst, U_32 nSrcs, Opnd** srcs);
 };
 
 //

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/Loop.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/Loop.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/Loop.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/Loop.cpp Thu May 22 06:33:38 2008
@@ -87,15 +87,15 @@
 template <class IDFun>
 class LoopMarker {
 public:
-    static uint32 markNodesOfLoop(StlBitVector& nodesInLoop, Node* header, Node* tail);
+    static U_32 markNodesOfLoop(StlBitVector& nodesInLoop, Node* header, Node* tail);
 private:
-    static uint32 backwardMarkNode(StlBitVector& nodesInLoop, Node* node, StlBitVector& visited);
-    static uint32 countInsts(Node* node);
+    static U_32 backwardMarkNode(StlBitVector& nodesInLoop, Node* node, StlBitVector& visited);
+    static U_32 countInsts(Node* node);
 };
 
 template <class IDFun>
-uint32 LoopMarker<IDFun>::countInsts(Node* node) {
-    uint32 count = 0;
+U_32 LoopMarker<IDFun>::countInsts(Node* node) {
+    U_32 count = 0;
     Inst* first = (Inst*)node->getFirstInst();
     if (first != NULL) {
         for(Inst* inst = first->getNextInst(); inst != NULL; inst = inst->getNextInst())
@@ -105,14 +105,14 @@
 }
 
 template <class IDFun>
-uint32 LoopMarker<IDFun>::backwardMarkNode(StlBitVector& nodesInLoop, 
+U_32 LoopMarker<IDFun>::backwardMarkNode(StlBitVector& nodesInLoop, 
                                 Node* node, 
                                 StlBitVector& visited) {
     static IDFun getId;
     if(visited.setBit(node->getId()))
         return 0;
 
-    uint32 count = countInsts(node);
+    U_32 count = countInsts(node);
     nodesInLoop.setBit(getId(node));
 
     const Edges& inEdges = node->getInEdges();
@@ -128,16 +128,16 @@
 // traverse graph backward starting from tail until header is reached
 //
 template <class IDFun>
-uint32 LoopMarker<IDFun>::markNodesOfLoop(StlBitVector& nodesInLoop,
+U_32 LoopMarker<IDFun>::markNodesOfLoop(StlBitVector& nodesInLoop,
                                Node* header,
                                Node* tail) {
     static IDFun getId;
-    uint32 maxSize = ::std::max(getId(header), getId(tail));
+    U_32 maxSize = ::std::max(getId(header), getId(tail));
     MemoryManager tmm("LoopBuilder::markNodesOfLoop.tmm");
     StlBitVector visited(tmm, maxSize);
 
     // mark header is visited
-    uint32 count = countInsts(header);
+    U_32 count = countInsts(header);
     nodesInLoop.setBit(getId(header));
     visited.setBit(header->getId());
 
@@ -286,8 +286,8 @@
         return true;
 
     // Check for variant src.
-    uint32 n = inst->getNumSrcOperands();
-    for(uint32 i = 0; i < n; ++i) {
+    U_32 n = inst->getNumSrcOperands();
+    for(U_32 i = 0; i < n; ++i) {
         Opnd* src = inst->getSrc(i);
         if (variantOpnds.find(src) != variantOpnds.end())
             return true;
@@ -427,12 +427,12 @@
             preheader = header->getInEdges().back()->getSourceNode();
 
         // Temporary memory for peeling
-        uint32 maxSize = fg.getMaxNodeId();
+        U_32 maxSize = fg.getMaxNodeId();
         MemoryManager tmm("LoopBuilder::peelLoops.tmm");
         
         // Compute nodes in loop
         StlBitVector nodesInLoop(tmm, maxSize);
-        uint32 loopSize = LoopMarker<IdentifyByID>::markNodesOfLoop(nodesInLoop, header, tail);
+        U_32 loopSize = LoopMarker<IdentifyByID>::markNodesOfLoop(nodesInLoop, header, tail);
 
         // Operand renaming table for duplicated nodes
         OpndRenameTable* duplicateTable = new (tmm) OpndRenameTable(tmm);
@@ -796,7 +796,7 @@
 public:
     EdgeCoalescerCallbackImpl(IRManager& _irm) : ssaAffected(false), irm(_irm){}
     
-    virtual void coalesce(Node* header, Node* newPreHeader, uint32 numEdges) {
+    virtual void coalesce(Node* header, Node* newPreHeader, U_32 numEdges) {
         InstFactory& instFactory = irm.getInstFactory();
         OpndManager& opndManager = irm.getOpndManager();
         Inst* labelInst = (Inst*)header->getFirstInst();
@@ -814,8 +814,8 @@
                 Inst *newInst = instFactory.makePhi(newDst, 0, 0);
                 PhiInst *newPhiInst = newInst->asPhiInst();
                 assert(newPhiInst);
-                uint32 n = phi->getNumSrcOperands();
-                for (uint32 i=0; i<n; i++) {
+                U_32 n = phi->getNumSrcOperands();
+                for (U_32 i=0; i<n; i++) {
                     instFactory.appendSrc(newPhiInst, phi->getSrc(i));
                 }
                 PhiInst *phiInst = phi->asPhiInst();

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/Loop.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/Loop.h?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/Loop.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/Loop.h Thu May 22 06:33:38 2008
@@ -41,9 +41,9 @@
     bool old_static_peeling;
     bool aggressive_peeling;
     bool peel_upto_branch;
-    uint32 peeling_threshold; 
+    U_32 peeling_threshold; 
     bool fullpeel;
-    uint32 fullpeel_max_inst;
+    U_32 fullpeel_max_inst;
     bool peel_upto_branch_no_instanceof;
 };
 
@@ -65,11 +65,11 @@
     
     class IdentifyByID {
     public:
-        uint32 operator() (Node* node) { return node->getId(); }
+        U_32 operator() (Node* node) { return node->getId(); }
     };
     class IdentifyByDFN {
     public:
-        uint32 operator() (Node* node) { return node->getDfNum(); }
+        U_32 operator() (Node* node) { return node->getDfNum(); }
     };
 
     void        peelLoops(StlVector<Edge*>& backEdges);
@@ -77,7 +77,7 @@
     bool        isVariantInst(Inst* inst, StlHashSet<Opnd*>& variantOpnds);
     bool        isVariantOperation(Operation operation);
     bool        isInversionCandidate(Node* currentHeader, Node* proposedHeader, StlBitVector& nodesInLoop, Node*& next, Node*& exit);
-    uint32      markNodesOfLoop(StlBitVector& nodesInLoop,Node* header,Node* tail);
+    U_32      markNodesOfLoop(StlBitVector& nodesInLoop,Node* header,Node* tail);
     LoopNode*   findEnclosingLoop(LoopNode* loop, Node* header);
 
 

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/LoopUtils.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/LoopUtils.h?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/LoopUtils.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/LoopUtils.h Thu May 22 06:33:38 2008
@@ -204,15 +204,15 @@
 public:    
     virtual bool isConstant() const { return true; }
 
-    int32 getValue() const { return value; }
+    I_32 getValue() const { return value; }
 
 protected:
-    ConstOpndLoopInfo(InductionDetector* id, SsaOpnd* opnd, int32 val):
+    ConstOpndLoopInfo(InductionDetector* id, SsaOpnd* opnd, I_32 val):
         InvariantOpndLoopInfo(id, opnd), value(val) {}
     virtual ~ConstOpndLoopInfo() {}
 
 private:
-    int32 value;
+    I_32 value;
 };
 
 // TODO: Should be able to detect linear induction.
@@ -239,7 +239,7 @@
         return new (memoryManager) InvariantOpndLoopInfo(this, opnd); 
     }
     
-    ConstOpndLoopInfo* createConstOpnd(SsaOpnd* opnd, int32 val) {
+    ConstOpndLoopInfo* createConstOpnd(SsaOpnd* opnd, I_32 val) {
         return new (memoryManager) ConstOpndLoopInfo(this, opnd, val);
     }
 

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/Opcode.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/Opcode.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/Opcode.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/Opcode.cpp Thu May 22 06:33:38 2008
@@ -237,13 +237,13 @@
     { Op_TauIsNonNull,          true, MB::CSEable,       MK::None,                             "tauisnonnull ",        "tauisnonnull      %0 -) %l",        }, // temporary declaration that source null
 };                                                             
 
-unsigned short Modifier::encode(Opcode opcode, uint32 numbits) const
+unsigned short Modifier::encode(Opcode opcode, U_32 numbits) const
 {
     assert((opcode >= 0) && (opcode < NumOpcodes));
     Modifier::Kind::Enum kinds = opcodeTable[opcode].modifierKind;
     if (kinds == 0) return 0;
-    uint32 encoded = 0;
-    uint32 bitsused = 0;
+    U_32 encoded = 0;
+    U_32 bitsused = 0;
     if ((kinds & Modifier::Kind::Overflow) != 0) addEncoding(encoded, bitsused, Overflow_Mask, Overflow_None, Overflow_Unsigned, OverflowModifier_IsShiftedBy, OverflowModifier_BitsToEncode);
     if ((kinds & Modifier::Kind::Signed) != 0) addEncoding(encoded, bitsused, Signed_Mask, SignedOp, UnsignedOp, SignedModifier_IsShiftedBy, SignedModifier_BitsToEncode);
     if ((kinds & Modifier::Kind::Comparison) != 0) addEncoding(encoded, bitsused, Cmp_Mask, Cmp_EQ, Cmp_NonZero, ComparisonModifier_IsShiftedBy, ComparisonModifier_BitsToEncode);
@@ -260,7 +260,7 @@
     if ((kinds & Modifier::Kind::NewModifier2) != 0) addEncoding(encoded, bitsused, NewModifier2_Mask, NewModifier2_Value1, NewModifier2_Value3, NewModifier2_IsShiftedBy, NewModifier2_BitsToEncode);
     assert(bitsused <= numbits);
     unsigned short usencoded = (unsigned short) encoded;
-    assert(encoded == (uint32) usencoded);
+    assert(encoded == (U_32) usencoded);
     if (0 && Log::isEnabled()) {
         Log::out() << ::std::endl << "Modifier " << ::std::hex << (int) value << " and Opcode " 
                    << (int) opcode << " encoded as " << (int) usencoded << ::std::dec << ::std::endl;
@@ -268,12 +268,12 @@
     return (unsigned short) usencoded;
 }
 
-Modifier::Modifier(Opcode opcode, uint32 encoding) : value(0)
+Modifier::Modifier(Opcode opcode, U_32 encoding) : value(0)
 {
     assert((opcode >= 0) && (opcode < NumOpcodes));
     Modifier::Kind::Enum kinds = opcodeTable[opcode].modifierKind;
     if (kinds == 0) return;
-    uint32 bitsused = 0;
+    U_32 bitsused = 0;
     if ((kinds & Modifier::Kind::Overflow) != 0) addDecoding(encoding, bitsused, Overflow_Mask, Overflow_None, Overflow_Unsigned, OverflowModifier_IsShiftedBy, OverflowModifier_BitsToEncode);
     if ((kinds & Modifier::Kind::Signed) != 0) addDecoding(encoding, bitsused, Signed_Mask, SignedOp, UnsignedOp, SignedModifier_IsShiftedBy, SignedModifier_BitsToEncode);
     if ((kinds & Modifier::Kind::Comparison) != 0) addDecoding(encoding, bitsused, Cmp_Mask, Cmp_EQ, Cmp_NonZero, ComparisonModifier_IsShiftedBy, ComparisonModifier_BitsToEncode);
@@ -294,32 +294,32 @@
         Log::out() << ::std::endl << "Opcode " << ::std::hex << (int) opcode << " and bits " << (int) encoding 
                    << " decoded to Modifier " << (int) value << ::std::dec << ::std::endl;
     }
-    assert(((uint32)encode(opcode, OPERATION_MODIFIER_BITS)) == encoding);
+    assert(((U_32)encode(opcode, OPERATION_MODIFIER_BITS)) == encoding);
 }
 
 
-void Modifier::addEncoding(uint32 &encoded, uint32 &bitsused, uint32 mask, 
-                           uint32 minval, uint32 maxval, 
-                           uint32 isshiftedby,
-                           uint32 bitstoencode) const
+void Modifier::addEncoding(U_32 &encoded, U_32 &bitsused, U_32 mask, 
+                           U_32 minval, U_32 maxval, 
+                           U_32 isshiftedby,
+                           U_32 bitstoencode) const
 {
-    uint32 thisval = value & mask;
+    U_32 thisval = value & mask;
 
     assert((minval <= thisval) && (thisval <= maxval));
-    uint32 encodedval = ((thisval - minval) >> isshiftedby) << bitsused;
+    U_32 encodedval = ((thisval - minval) >> isshiftedby) << bitsused;
     encoded = encoded | encodedval ;
     bitsused = bitsused + bitstoencode;
 }
 
-void Modifier::addDecoding(uint32 &encoding, uint32 &bitsused, uint32 mask, 
-                           uint32 minval, uint32 maxval, 
-                           uint32 isshiftedby,
-                           uint32 bitstoencode)
+void Modifier::addDecoding(U_32 &encoding, U_32 &bitsused, U_32 mask, 
+                           U_32 minval, U_32 maxval, 
+                           U_32 isshiftedby,
+                           U_32 bitstoencode)
 {
-    uint32 maskedbits = (1 << bitstoencode)-1;
-    uint32 shifted = ((encoding >> bitsused) & maskedbits) << isshiftedby;
-    uint32 decoded = shifted + minval;
-    uint32 masked = decoded & mask;
+    U_32 maskedbits = (1 << bitstoencode)-1;
+    U_32 shifted = ((encoding >> bitsused) & maskedbits) << isshiftedby;
+    U_32 decoded = shifted + minval;
+    U_32 masked = decoded & mask;
     assert(masked != 0);
     value |= masked;
     bitsused = bitsused + bitstoencode;

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/Opcode.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/Opcode.h?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/Opcode.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/Opcode.h Thu May 22 06:33:38 2008
@@ -485,7 +485,7 @@
 };
 
 class Modifier {
-    uint32 value;
+    U_32 value;
 public:
     struct Kind {
         enum Enum {
@@ -520,55 +520,55 @@
     };
     
     Modifier() : value(0) { };
-    Modifier(uint32 mask, uint32 value0) : value(value0) {
+    Modifier(U_32 mask, U_32 value0) : value(value0) {
         assert((mask & value) == value);
         assert(value0 != 0);
     };
-    Modifier(enum OverflowModifier mod) : value((uint32)mod) { 
+    Modifier(enum OverflowModifier mod) : value((U_32)mod) { 
         assert((Overflow_None <= value) && (value <= Overflow_Unsigned));
     }
-    Modifier(enum SignedModifier mod) : value((uint32)mod) { 
+    Modifier(enum SignedModifier mod) : value((U_32)mod) { 
         assert((SignedOp <= value) && (value <= UnsignedOp));
     }
-    Modifier(enum ComparisonModifier mod) : value((uint32)mod) { 
+    Modifier(enum ComparisonModifier mod) : value((U_32)mod) { 
         assert((Cmp_EQ <= value) && (value <= Cmp_NonZero));
     }
-    Modifier(enum ShiftMaskModifier mod) : value((uint32)mod) { 
+    Modifier(enum ShiftMaskModifier mod) : value((U_32)mod) { 
         assert((ShiftMask_None <= value) && (value <= ShiftMask_Masked));
     }
-    Modifier(enum StrictModifier mod) : value((uint32)mod) { 
+    Modifier(enum StrictModifier mod) : value((U_32)mod) { 
         assert((Strict_No <= value) && (value <= Strict_Yes));
     }
-    Modifier(enum DefArgModifier mod) : value((uint32)mod) { 
+    Modifier(enum DefArgModifier mod) : value((U_32)mod) { 
         assert((DefArgNoModifier <= value) && (value <= DefArgBothModifiers));
     }
-    Modifier(enum StoreModifier mod) : value((uint32)mod) { 
+    Modifier(enum StoreModifier mod) : value((U_32)mod) { 
         assert((Store_NoWriteBarrier <= value) && (value <= Store_WriteBarrier));
     }
-    Modifier(enum ExceptionModifier mod) : value((uint32)mod) { 
+    Modifier(enum ExceptionModifier mod) : value((U_32)mod) { 
         assert((Exception_Sometimes <= value) && (value <= Exception_Never));
     }
-    Modifier(enum SrcNonNullModifier mod) : value((uint32)mod) { 
+    Modifier(enum SrcNonNullModifier mod) : value((U_32)mod) { 
         assert((SrcNonNull_No <= value) && (value <= SrcNonNull_Yes));
     }
-    Modifier(enum AutoCompressModifier mod) : value((uint32)mod) { 
+    Modifier(enum AutoCompressModifier mod) : value((U_32)mod) { 
         assert((AutoCompress_Yes <= value) && (value <= AutoCompress_No));
     }
-    Modifier(enum SpeculativeModifier mod) : value((uint32)mod) {
+    Modifier(enum SpeculativeModifier mod) : value((U_32)mod) {
         assert((Speculative_Yes <= value) && (value <= Speculative_No));
     }
-    Modifier(enum ThrowModifier mod) : value((uint32)mod) { 
+    Modifier(enum ThrowModifier mod) : value((U_32)mod) { 
         assert((Throw_NoModifier <= value) && (value <= Throw_CreateStackTrace));
     }
-    Modifier(enum NewModifier1 mod) : value((uint32)mod) { 
+    Modifier(enum NewModifier1 mod) : value((U_32)mod) { 
         assert((NewModifier1_Value1 <= value) && (value <= NewModifier1_Value2));
     }
-    Modifier(enum NewModifier2 mod) : value((uint32)mod) { 
+    Modifier(enum NewModifier2 mod) : value((U_32)mod) { 
         assert((NewModifier2_Value1 <= value) && (value <= NewModifier2_Value3));
     }
     Modifier operator|(const Modifier &other) const {
         assert((value & other.value) == 0);
-        uint32 newvalue = value | other.value;
+        U_32 newvalue = value | other.value;
         return Modifier(newvalue, newvalue);
     };
     enum OverflowModifier getOverflowModifier() const { 
@@ -579,7 +579,7 @@
     void setOverflowModifier(enum OverflowModifier newmod) {
         assert(hasOverflowModifier());
         assert((newmod & Overflow_Mask) == newmod);
-        uint32 newval = value & (~Overflow_Mask);
+        U_32 newval = value & (~Overflow_Mask);
         value = newval | newmod;
     }
     bool hasSignedModifier() const { return ((value & Signed_Mask) != 0); };
@@ -590,7 +590,7 @@
     void setSignedModifier(enum SignedModifier newmod) {
         assert(hasSignedModifier());
         assert((newmod & Signed_Mask) == newmod);
-        uint32 newval = value & (~Signed_Mask);
+        U_32 newval = value & (~Signed_Mask);
         value = newval | newmod;
     }
     bool hasComparisonModifier() const { return ((value & Cmp_Mask) != 0); };
@@ -601,7 +601,7 @@
     void setComparisonModifier(enum ComparisonModifier newmod) {
         assert(hasComparisonModifier());
         assert((newmod & Cmp_Mask) == newmod);
-        uint32 newval = value & (~Cmp_Mask);
+        U_32 newval = value & (~Cmp_Mask);
         value = newval | newmod;
     }
     bool hasShiftMaskModifier() const { return ((value & ShiftMask_Mask) != 0); };
@@ -612,7 +612,7 @@
     void setShiftMaskModifier(enum ShiftMaskModifier newmod) {
         assert(hasShiftMaskModifier());
         assert((newmod & ShiftMask_Mask) == newmod);
-        uint32 newval = value & (~ShiftMask_Mask);
+        U_32 newval = value & (~ShiftMask_Mask);
         value = newval | newmod;
     }
     bool hasStrictModifier() const { return ((value & Strict_Mask) != 0); };
@@ -623,7 +623,7 @@
     void setStrictModifier(enum StrictModifier newmod) {
         assert(hasStrictModifier());
         assert((newmod & Strict_Mask) == newmod);
-        uint32 newval = value & (~Strict_Mask);
+        U_32 newval = value & (~Strict_Mask);
         value = newval | newmod;
     }
     bool hasDefArgModifier() const { return ((value & DefArg_Mask) != 0); };
@@ -634,7 +634,7 @@
     void setDefArgModifier(enum DefArgModifier newmod) {
         assert(hasDefArgModifier());
         assert((newmod & DefArg_Mask) == newmod);
-        uint32 newval = value & (~DefArg_Mask);
+        U_32 newval = value & (~DefArg_Mask);
         value = newval | newmod;
     }
     bool hasSrcNonNullModifier() const { return ((value & SrcNonNull_Mask) != 0); };
@@ -645,7 +645,7 @@
     void setSrcNonNullModifier(enum SrcNonNullModifier newmod) {
         assert(hasSrcNonNullModifier());
         assert((newmod & SrcNonNull_Mask) == newmod);
-        uint32 newval = value & (~SrcNonNull_Mask);
+        U_32 newval = value & (~SrcNonNull_Mask);
         value = newval | newmod;
     }
     bool hasStoreModifier() const { return ((value & Store_Mask) != 0); };
@@ -656,7 +656,7 @@
     void setStoreModifier(enum StoreModifier newmod) {
         assert(hasStoreModifier());
         assert((newmod & Store_Mask) == newmod);
-        uint32 newval = value & (~Store_Mask);
+        U_32 newval = value & (~Store_Mask);
         value = newval | newmod;
     }
     bool hasExceptionModifier() const { return ((value & Exception_Mask) != 0); };
@@ -667,7 +667,7 @@
     void setExceptionModifier(enum ExceptionModifier newmod) {
         assert(hasExceptionModifier());
         assert((newmod & Exception_Mask) == newmod);
-        uint32 newval = value & (~Exception_Mask);
+        U_32 newval = value & (~Exception_Mask);
         value = newval | newmod;
     }
     bool hasAutoCompressModifier() const { return ((value & AutoCompress_Mask) != 0); };
@@ -678,7 +678,7 @@
     void setAutoCompressModifier(enum AutoCompressModifier newmod) {
         assert(hasAutoCompressModifier());
         assert((newmod & AutoCompress_Mask) == newmod);
-        uint32 newval = value & (~AutoCompress_Mask);
+        U_32 newval = value & (~AutoCompress_Mask);
         value = newval | newmod;
     }
     bool hasSpeculativeModifier() const { return ((value & Speculative_Mask) != 0); };
@@ -687,7 +687,7 @@
     };
     void setSpeculativeModifier(enum SpeculativeModifier newmod) {
         assert(hasSpeculativeModifier());
-        uint32 newval = value & (~Speculative_Mask);
+        U_32 newval = value & (~Speculative_Mask);
         value = newval | newmod;
     }
     bool hasThrowModifier() const { return ((value & Throw_Mask) != 0); };
@@ -698,7 +698,7 @@
     void setThrowModifier(enum ThrowModifier newmod) {
         assert(hasThrowModifier());
         assert((newmod & Throw_Mask) == newmod);
-        uint32 newval = value & (~Throw_Mask);
+        U_32 newval = value & (~Throw_Mask);
         value = newval | newmod;
     }
     bool hasNewModifier1() const { return ((value & NewModifier1_Mask) != 0); };
@@ -709,7 +709,7 @@
     void setNewModifier1(enum NewModifier1 newmod) {
         assert(hasNewModifier1());
         assert((newmod & NewModifier1_Mask) == newmod);
-        uint32 newval = value & (~NewModifier1_Mask);
+        U_32 newval = value & (~NewModifier1_Mask);
         value = newval | newmod;
     }
     bool hasNewModifier2() const { return ((value & NewModifier2_Mask) != 0); };
@@ -720,7 +720,7 @@
     void setNewModifier2(enum NewModifier2 newmod) {
         assert(hasNewModifier2());
         assert((newmod & NewModifier2_Mask) == newmod);
-        uint32 newval = value & (~NewModifier2_Mask);
+        U_32 newval = value & (~NewModifier2_Mask);
         value = newval | newmod;
     }
     bool isSigned() const { 
@@ -743,17 +743,17 @@
 
 protected:
     friend class Operation;
-    unsigned short encode(Opcode opcode, uint32 bits) const;
+    unsigned short encode(Opcode opcode, U_32 bits) const;
 
-    Modifier(Opcode opcode, uint32 encoding);
+    Modifier(Opcode opcode, U_32 encoding);
     
 private:
-    void addEncoding(uint32 &encoded, uint32 &bitsused, uint32 mask, 
-                     uint32 minval, uint32 maxval, uint32 isshiftedby,
-                     uint32 bitstoencode) const;
-    void addDecoding(uint32 &encoding, uint32 &bitsused, uint32 mask, 
-                     uint32 minval, uint32 maxval, uint32 isshiftedby,
-                     uint32 bitstoencode);
+    void addEncoding(U_32 &encoded, U_32 &bitsused, U_32 mask, 
+                     U_32 minval, U_32 maxval, U_32 isshiftedby,
+                     U_32 bitstoencode) const;
+    void addDecoding(U_32 &encoding, U_32 &bitsused, U_32 mask, 
+                     U_32 minval, U_32 maxval, U_32 isshiftedby,
+                     U_32 bitstoencode);
 };
 
 #define OPERATION_OPCODE_BITS 8
@@ -931,11 +931,11 @@
         setModifier(mod);
     };
 
-    uint32 encodeForHashing() const { 
+    U_32 encodeForHashing() const { 
         if (Type::isReference((Type::Tag)typetag)) {
             return ((opcode << (OPERATION_MODIFIER_BITS+OPERATION_TYPE_BITS))
                     | (modifiers << OPERATION_TYPE_BITS)
-                    | (uint32)Type::SystemObject);
+                    | (U_32)Type::SystemObject);
         } else {
             return ((opcode << (OPERATION_MODIFIER_BITS+OPERATION_TYPE_BITS))
                     | (modifiers << OPERATION_TYPE_BITS)

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/Opnd.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/Opnd.h?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/Opnd.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/Opnd.h Thu May 22 06:33:38 2008
@@ -49,11 +49,11 @@
 class OpndBase {    // rename to Opnd
 public:
     virtual ~OpndBase() {}
-    uint32  getId() const                 {return id;}
+    U_32  getId() const                 {return id;}
     Type*   getType() const               {return type;}
     void    setType(Type *t)              {type = t;}
-    void    setProperties(uint32 v)       {properties = v;}
-    uint32  getProperties() const         {return properties;}
+    void    setProperties(U_32 v)       {properties = v;}
+    U_32  getProperties() const         {return properties;}
     //
     // methods for dynamic type checking and casting
     //
@@ -88,19 +88,19 @@
     //
     // Constructor
     //
-    OpndBase(Type* t,uint32 i) : properties(0), type(t), id(i) {}
+    OpndBase(Type* t,U_32 i) : properties(0), type(t), id(i) {}
     //
     // default constructor creates a null opnd
     //
     OpndBase() : properties(0), type(NULL), id(0) {}
 private:
     friend class OpndManager;
-    uint32    properties;
+    U_32    properties;
     Type*     type;
     //
     // used by code generator to map to back end operand
     //
-    uint32    id;
+    U_32    id;
 };
 
 class Opnd : public OpndBase {
@@ -117,7 +117,7 @@
     virtual void    print(::std::ostream&) const;
 protected:
     friend class OpndManager;
-    Opnd(Type* t,uint32 i) : OpndBase(t,i), isGlobalFlag(false), inst(NULL) {}
+    Opnd(Type* t,U_32 i) : OpndBase(t,i), isGlobalFlag(false), inst(NULL) {}
     Opnd() : OpndBase(), isGlobalFlag(false), inst(NULL) {}
     bool    isGlobalFlag;
     //
@@ -132,7 +132,7 @@
     virtual bool isSsaOpnd() const    {return true;}
 protected:
     friend class OpndManager;
-    SsaOpnd(Type* t,uint32 i) : Opnd(t,i) 
+    SsaOpnd(Type* t,U_32 i) : Opnd(t,i) 
         {}
 
 };
@@ -143,7 +143,7 @@
     virtual bool isSsaTmpOpnd() const    {return true;}
 private:
     friend class OpndManager;
-    SsaTmpOpnd(Type* t,uint32 i) : SsaOpnd(t,i) {}
+    SsaTmpOpnd(Type* t,U_32 i) : SsaOpnd(t,i) {}
 };
 
 class PiOpnd : public SsaOpnd {
@@ -156,7 +156,7 @@
     virtual void    print(::std::ostream&) const;
 private:
     friend class OpndManager;
-    PiOpnd(Opnd *orgOpnd0, uint32 i) : 
+    PiOpnd(Opnd *orgOpnd0, U_32 i) : 
         SsaOpnd(orgOpnd0->getType(),i), 
         orgOpnd(orgOpnd0)
         {};
@@ -172,8 +172,8 @@
     bool            isAddrTaken() const    {return isAddrTakenFlag;}
     void            setAddrTaken()         {isAddrTakenFlag = true;}
     bool            isPinned() const       {return isPinnedFlag;}
-    uint32          getNumLoads() const    {return numLoads;}
-    uint32          getNumStores() const   {return numStores;}
+    U_32          getNumLoads() const    {return numLoads;}
+    U_32          getNumStores() const   {return numStores;}
     VarOpnd*        getNextVarOpnd()       {return nextVarInMethod;}
     VarOpnd*        getPrevVarOpnd()       {return prevVarInMethod;}
     void            addVarAccessInst(VarAccessInst*);
@@ -187,7 +187,7 @@
     virtual void    printWithType(::std::ostream& os) const;
 private:
     friend class OpndManager;
-    VarOpnd(Type* t,uint32 i,VarOpnd* next,bool isPinned) 
+    VarOpnd(Type* t,U_32 i,VarOpnd* next,bool isPinned) 
         : Opnd(t,i), nextVarInMethod(0), prevVarInMethod(0),varAccessInsts(NULL)
     {
         isPinnedFlag = isPinned;
@@ -210,8 +210,8 @@
     bool            isDeadFlag;
     bool            isPinnedFlag;
     bool            isAddrTakenFlag;
-    uint32          numLoads;
-    uint32          numStores;
+    U_32          numLoads;
+    U_32          numStores;
     VarOpnd*        nextVarInMethod;
     VarOpnd*        prevVarInMethod;
     VarAccessInst*  varAccessInsts;     // ldvar, stvars that access this var
@@ -237,7 +237,7 @@
     };
 private:
     friend class OpndManager;
-    SsaVarOpnd(uint32 i, VarOpnd* v) : SsaOpnd(v->getType(),i), var(v) {}
+    SsaVarOpnd(U_32 i, VarOpnd* v) : SsaOpnd(v->getType(),i), var(v) {}
     VarOpnd* var;
 };
 
@@ -288,10 +288,10 @@
     }
     static Opnd*  getNullOpnd()    {return &_nullOpnd;}
     VarOpnd*      getVarOpnds()    {return varOpnds;}
-    uint32        getNumVarOpnds() {return nextVarId;}
-    uint32        getNumSsaOpnds() {return nextSsaOpndId;}
-    uint32        getNumArgs()     {return numArgs;}
-    uint32        getNumPiOpnds() {return nextPiOpndId;}
+    U_32        getNumVarOpnds() {return nextVarId;}
+    U_32        getNumSsaOpnds() {return nextSsaOpndId;}
+    U_32        getNumArgs()     {return numArgs;}
+    U_32        getNumPiOpnds() {return nextPiOpndId;}
 
     void          deleteVar(VarOpnd *var);
 private:
@@ -299,10 +299,10 @@
     // private fields
     //
     static NullOpnd  _nullOpnd;
-    uint32          nextSsaOpndId;
-    uint32          nextPiOpndId;
-    uint32          nextVarId;
-    uint32          numArgs;
+    U_32          nextSsaOpndId;
+    U_32          nextPiOpndId;
+    U_32          nextVarId;
+    U_32          numArgs;
     VarOpnd*        varOpnds;
     TypeManager&    typeManager;
     MemoryManager&  memManager;
@@ -310,7 +310,7 @@
 
 class OpndRenameTable : public HashTable<Opnd,Opnd> {
 public:
-    OpndRenameTable(MemoryManager& mm, uint32 size = 16, bool renameSSA = true): 
+    OpndRenameTable(MemoryManager& mm, U_32 size = 16, bool renameSSA = true): 
         HashTable<Opnd,Opnd>(mm,size) {renameSsaOpnd = renameSSA;}
     
     virtual ~OpndRenameTable() {}    
@@ -332,7 +332,7 @@
     virtual bool keyEquals(Opnd* key1,Opnd* key2) const {
         return key1 == key2;
     }
-    virtual uint32 getKeyHashCode(Opnd* key) const {
+    virtual U_32 getKeyHashCode(Opnd* key) const {
         // return hash of address bits
         return (key ? key->getId() : 0);
     }

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/abcd/abcd.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/abcd/abcd.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/abcd/abcd.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/abcd/abcd.cpp Thu May 22 06:33:38 2008
@@ -435,8 +435,8 @@
     void operator()(Node *node, Inst *i) {
         if (i->getOpcode() == Op_Phi) {
             const Edges& edges2 = node->getInEdges();
-            uint32 numEdges = (uint32) edges2.size();
-            uint32 numOps = i->getNumSrcOperands();
+            U_32 numEdges = (U_32) edges2.size();
+            U_32 numOps = i->getNumSrcOperands();
             if( !(numOps == numEdges) ) assert(0);
         }
     }
@@ -542,7 +542,7 @@
     OpndManager &opndManager = irManager.getOpndManager();
     TypeManager &typeManager = irManager.getTypeManager();
 
-    uint32 n = (uint32) reasons.size();
+    U_32 n = (U_32) reasons.size();
     assert(derefVarVersions.size() == n);
     Opnd **newPhiOpnds = new (mm) Opnd*[n];
 
@@ -552,7 +552,7 @@
     SsaVarOpnd *tauPhiDstOpnd = opndManager.createSsaVarOpnd(tauBaseVar);
     SsaTmpOpnd *tauResOpnd = opndManager.createSsaTmpOpnd(typeManager.getTauType());
 
-    for (uint32 i=0; i<n; ++i) {
+    for (U_32 i=0; i<n; ++i) {
         AbcdReasons *reason = reasons[i];
         Opnd *derefVarVersion = derefVarVersions[i];
         Inst *derefVarInst = derefVarVersion->getInst();
@@ -621,7 +621,7 @@
     OpndManager &opndManager = irManager.getOpndManager();
     TypeManager &typeManager = irManager.getTypeManager();
 
-    uint32 numReasons = (uint32) reason->facts.size();
+    U_32 numReasons = (U_32) reason->facts.size();
     assert(numReasons < 100);
     if (numReasons == 1) {
         SsaTmpOpnd *reasonOpnd = *(reason->facts.begin());
@@ -633,7 +633,7 @@
         // need to build a tauAnd
         Opnd **newAndOpnds = new (mm) Opnd*[numReasons];
         StlSet<SsaTmpOpnd*>::iterator iter = reason->facts.begin();
-        for (uint32 i = 0; i < numReasons;  ++i, ++iter) {
+        for (U_32 i = 0; i < numReasons;  ++i, ++iter) {
             newAndOpnds[i] = *iter;
         }
         SsaTmpOpnd *tauDst = opndManager.createSsaTmpOpnd(typeManager.getTauType());
@@ -697,8 +697,8 @@
         copy->insertBefore(inst);
         FlowGraph::eliminateCheck(irManager.getFlowGraph(),block, inst, false);
     } else {
-        uint32 numOpnds = inst->getNumSrcOperands();
-        for (uint32 i=0; i<numOpnds; i++) {
+        U_32 numOpnds = inst->getNumSrcOperands();
+        for (U_32 i=0; i<numOpnds; i++) {
             Opnd *opnd0 = inst->getSrc(i);
             Opnd *opnd = opnd0;
             Opnd *newOpnd = opnd0;

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/abcd/abcdbounds.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/abcd/abcdbounds.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/abcd/abcdbounds.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/abcd/abcdbounds.cpp Thu May 22 06:33:38 2008
@@ -434,11 +434,11 @@
             Inst *shiftByInst = shiftByOp->getInst();
             ConstInst *shiftByConstInst = shiftByInst->asConstInst();
             if (shiftByConstInst != 0) {
-                uint32 shiftBy;
+                U_32 shiftBy;
                 if (shiftByConstInst->getType() == Type::Int32) {
-                    shiftBy = (uint32)shiftByConstInst->getValue().i4;
+                    shiftBy = (U_32)shiftByConstInst->getValue().i4;
                 } else if (shiftByConstInst->getType() == Type::Int64) {
-                    shiftBy = (uint32)shiftByConstInst->getValue().i8;
+                    shiftBy = (U_32)shiftByConstInst->getValue().i8;
                 } else {
                     return ConstBound();
                 }
@@ -449,13 +449,13 @@
                     switch (typetag) {
                     case Type::Int32: 
                         {
-                            int32 bound = outputBound.getInt32();
+                            I_32 bound = outputBound.getInt32();
                             if (the_inst->getShiftMaskModifier() == ShiftMask_Masked)
                                 shiftBy = shiftBy & 31;
-                            int32 input = bound << shiftBy;
+                            I_32 input = bound << shiftBy;
                             if (!isLB) {
                                 if (shiftBy < 31) {
-                                    input = input + ((int32(1) << shiftBy) - 1);
+                                    input = input + ((I_32(1) << shiftBy) - 1);
                                 } else {
                                     input = 0xffffffff;
                                 }
@@ -533,7 +533,7 @@
     switch (cinst0->getType()) {
     case Type::Int8: case Type::Int16: case Type::Int32:
         {
-            int32 c = cv.i4;
+            I_32 c = cv.i4;
             res = PiBound(newtype, int64(c));
             return true;
         }
@@ -545,7 +545,7 @@
         }
     case Type::UInt8: case Type::UInt16: case Type::UInt32:
         {
-            uint32 c = (uint32) cv.i4;
+            U_32 c = (U_32) cv.i4;
             res = PiBound(newtype, int64(uint64(c)));
             return true;
         }
@@ -688,8 +688,8 @@
                 ConstInst *cinst1 = inst1->asConstInst();
                 assert(cinst1);
                 ConstInst::ConstValue cv = cinst1->getValue();
-                int32 c = cv.i4;
-                int32 negc = -c;
+                I_32 c = cv.i4;
+                I_32 negc = -c;
                 if (neg_overflowed(negc,c)) { // overflowed
                     instr = 0;
                 } else {

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/abcd/abcdbounds.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/abcd/abcdbounds.h?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/abcd/abcdbounds.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/abcd/abcdbounds.h Thu May 22 06:33:38 2008
@@ -131,7 +131,7 @@
                 Const_IsNull} flag;
 public:
     ConstBound() : the_const(0), flag(Const_IsNull) {};
-    ConstBound(int32 c) : the_const(c), flag(Const_IsConst) {};
+    ConstBound(I_32 c) : the_const(c), flag(Const_IsConst) {};
     ConstBound(int64 c) : the_const(c), flag(Const_IsConst) {};
     ConstBound(bool positive) : the_const(0), 
                                 flag(positive ? Const_PlusInfinity
@@ -143,7 +143,7 @@
     bool isPlusInfinity() const { return (flag == Const_PlusInfinity); };
     bool isMinusInfinity() const { return (flag == Const_MinusInfinity); };
     int64 getInt64() const { return the_const; };
-    int32 getInt32() const { return (int32)the_const; };
+    I_32 getInt32() const { return (I_32)the_const; };
     bool operator ==(const ConstBound &other) const {
         if (flag == other.flag) {
             if (flag == Const_IsConst) {
@@ -485,7 +485,7 @@
 class PiBoundIter {
     bool isLb;
     Inst *instr;  // set to 0 when invalid
-    uint32 idx;
+    U_32 idx;
     PiBound current;
     MemoryManager &mm;
     AbcdReasons *why;

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/abcd/abcdsolver.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/abcd/abcdsolver.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/abcd/abcdsolver.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/abcd/abcdsolver.cpp Thu May 22 06:33:38 2008
@@ -134,7 +134,7 @@
             }
             return ProofLattice::ProvenReduced;
         } else if ((var1 == var2) && 
-                   (c >= ConstBound(int32(0)))) { // reached source:
+                   (c >= ConstBound(I_32(0)))) { // reached source:
             if (Log::isEnabled()) {
                 Log::out() << "Case 4: => TRUE" << ::std::endl;
             }                
@@ -420,7 +420,7 @@
                             0,
                             why)) {
                 
-                uint32 elemSize = 16;
+                U_32 elemSize = 16;
                 uint64 overflowSize = ((uint64)1 << 31) / elemSize;
                 
                 if (demandProve(false, // upper bound
@@ -529,7 +529,7 @@
                 theInst->print(Log::out());
                 Log::out() << " to eliminate mask" << ::std::endl;
             }
-            int32 mask;
+            I_32 mask;
             switch (theInst->getType()) {
             case Type::Int32:
                 mask = 31; break;
@@ -544,7 +544,7 @@
                                 : 0);
             if (mask > 0) {
                 VarBound shiftByVar = VarBound(shiftByOp);
-                ConstBound zerob(int32(0));
+                ConstBound zerob(I_32(0));
                 ProofLattice res1 = prove(true, // lower bound
                                           VarBound(),
                                           shiftByVar,
@@ -622,7 +622,7 @@
                     // for var+constOpnd, bounds on var are [lb-constOpnd, ub-constOpnd],
                     // for var-constOpnd, bounds on var are [lb+constOpnd, ub+constOpnd]
                     // for constOpnd-var, bounds on var are [constOpnd-ub, constOpnd-lb]
-                    // (with values in int32, but calculations performed in int64)
+                    // (with values in I_32, but calculations performed in int64)
                     ConstInst *constInst = constOpnd->getInst()->asConstInst();
                     assert(constInst);
 #ifndef NDEBUG
@@ -634,9 +634,9 @@
                            ((constInstType == Type::UInt8)||
                             (constInstType == Type::UInt16)||(constInstType == Type::UInt32)));
                     ConstInst::ConstValue constValue = constInst->getValue();
-                    int32 constValue32 = constValue.i4;
+                    I_32 constValue32 = constValue.i4;
                     int64 varlb, varub;
-                    int64 constValue64 = isSigned ? (int64)constValue32 : (int64)(uint64)(uint32)constValue32;
+                    int64 constValue64 = isSigned ? (int64)constValue32 : (int64)(uint64)(U_32)constValue32;
                     if (negateConstant) { 
                         varlb = lb + constValue64 + 1; // tweak by 1 in case I have a fencepost problem
                         varub = ub + constValue64 - 1;
@@ -779,7 +779,7 @@
                             (constInstType == Type::UInt16)||(constInstType == Type::UInt32)));
 #endif
                     ConstInst::ConstValue constValue = constInst->getValue();
-                    int32 constValue32 = constValue.i4;
+                    I_32 constValue32 = constValue.i4;
                     int64 varlb, varub;
                     if (isSigned) {
                         if (constValue32 < 0) {
@@ -793,7 +793,7 @@
                     } else {
                         assert(constValue32 > 0); // inst should have been simplified otherwise
                         varlb = 0;
-                        varub = ub/(uint32)constValue32;
+                        varub = ub/(U_32)constValue32;
                     }
                     VarBound varBound = VarBound(varOpnd);
                     lb = ::std::max(varlb, lb);
@@ -1273,7 +1273,7 @@
                     
                     VarBound var3 = pred.getVar();
                     int64 d1 = pred.getConst();
-                    int32 d = (int32)d1;
+                    I_32 d = (I_32)d1;
                     assert(d1 == int64(d)); // check for overflow
                     ConstBound db(d);
                     

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/abcd/classic_abcd.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/abcd/classic_abcd.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/abcd/classic_abcd.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/abcd/classic_abcd.cpp Thu May 22 06:33:38 2008
@@ -53,7 +53,7 @@
 public:
     IOpndProxy(Opnd* opnd);
 
-    IOpndProxy(int32 c, uint32 id);
+    IOpndProxy(I_32 c, U_32 id);
 
     virtual void printName(std::ostream& os) const
     {
@@ -66,17 +66,17 @@
 
     Opnd* getOrg() const { assert(_opnd); return _opnd; }
 
-    static uint32 getProxyIdByOpnd(Opnd* opnd);
+    static U_32 getProxyIdByOpnd(Opnd* opnd);
 private:
     Opnd* _opnd;
 
     /* ids of PiOpnd, SsaOpnd, VarOpnd may alias their IDs,
      * encoding all in one ID with unaliasing
      */
-    static const uint32 min_var_opnd = 0;
-    static const uint32 min_ssa_opnd = MAX_UINT32 / 4;
-    static const uint32 min_pi_opnd = (min_ssa_opnd) * 2;
-    static const uint32 min_const_opnd = (min_ssa_opnd) * 3;
+    static const U_32 min_var_opnd = 0;
+    static const U_32 min_ssa_opnd = MAX_UINT32 / 4;
+    static const U_32 min_pi_opnd = (min_ssa_opnd) * 2;
+    static const U_32 min_const_opnd = (min_ssa_opnd) * 3;
 };
 //------------------------------------------------------------------------------
 
@@ -88,7 +88,7 @@
 }
 
 bool inInt32(int64 c) {
-    return (int64)(int32)c == c;
+    return (int64)(I_32)c == c;
 }
 
 bool inInt32Type(Type t) {
@@ -115,7 +115,7 @@
             return;
         }
         if ( inInt32(value) ) {
-            setConstant((int32)value);
+            setConstant((I_32)value);
         }else{
             setUnconstrained(true);
         }
@@ -123,7 +123,7 @@
 }
 //------------------------------------------------------------------------------
 
-IOpndProxy::IOpndProxy(int32 c, uint32 id) : 
+IOpndProxy::IOpndProxy(I_32 c, U_32 id) : 
     IOpnd(0, false /* is_phi */, true /* is_constant */),
     _opnd(NULL)
 {
@@ -131,9 +131,9 @@
     setConstant(c);
 }
 
-uint32 IOpndProxy::getProxyIdByOpnd(Opnd* opnd)
+U_32 IOpndProxy::getProxyIdByOpnd(Opnd* opnd)
 {
-    uint32 id = opnd->getId();
+    U_32 id = opnd->getId();
     if ( opnd->isVarOpnd() ) {
         id += min_var_opnd;
     }else if ( opnd->isPiOpnd() ) { 
@@ -183,7 +183,7 @@
     IOpndProxy* addOldOrCreateOpnd(Opnd* opnd);
 
     InequalityGraph* _igraph;
-    uint32 _const_id_counter;
+    U_32 _const_id_counter;
 
     // operands are mapped to their renaming Pi instructions during the walk
     // (applyToInst), and then this mapping is used to create edges between
@@ -224,7 +224,7 @@
 void BuildInequalityGraphWalker::addAllSrcOpndsForPhi(Inst* inst)
 {
     assert(inst->getOpcode() == Op_Phi);
-    for (uint32 j = 0; j < inst->getNumSrcOperands(); j++) {
+    for (U_32 j = 0; j < inst->getNumSrcOperands(); j++) {
         IOpndProxy* proxy_src = addOldOrCreateOpnd(inst->getSrc(j));
         addDistance(findProxy(inst->getDst()), proxy_src, 0, false /*negate*/);
     }
@@ -401,7 +401,7 @@
     assert(dst && src);
     // This prevention to put some edges is *not* an optimization of any kind.
     // Operands can be marked unconstrained by various reasons, for example:
-    // because the constant value does not fit into int32 (which is critical for
+    // because the constant value does not fit into I_32 (which is critical for
     // array access)
     if ( !src->isUnconstrained() ) {
         if ( !inInt32(constant) ) {
@@ -410,7 +410,7 @@
         if ( negate ) {
             constant = (-1) * constant;
         }
-        _igraph->addEdge(src->getID(), dst->getID(), (int32)constant);
+        _igraph->addEdge(src->getID(), dst->getID(), (I_32)constant);
         return true;
     }
     return false;
@@ -424,7 +424,7 @@
     if ( from->isUnconstrained() || !inInt32(c) ) {
         return;
     }
-    _igraph->addEdgeSingleState(from->getID(), to->getID(), (int32)c, lower_problem);
+    _igraph->addEdgeSingleState(from->getID(), to->getID(), (I_32)c, lower_problem);
 }
 //------------------------------------------------------------------------------
 
@@ -468,7 +468,7 @@
     } else if ( non_inf_bound.isConst() ) {
         MemoryManager& mm = _igraph->getMemoryManager();
         IOpndProxy* c_opnd = new (mm) 
-            IOpndProxy((int32)non_inf_bound.getConst(), _const_id_counter++);
+            IOpndProxy((I_32)non_inf_bound.getConst(), _const_id_counter++);
         _igraph->addOpnd(c_opnd);
         addDistanceSingleProblem(dst /* to */, c_opnd, 0, lower_problem);
     }
@@ -524,8 +524,8 @@
     if ( map.count(inst) == 0 ) {
         map[inst] = type;
     }else{
-        int32 new_rtype = (int32)map[inst];
-        new_rtype |= (int32)type;
+        I_32 new_rtype = (I_32)map[inst];
+        new_rtype |= (I_32)type;
         map[inst] = (RedundancyType)new_rtype;
     }
 }
@@ -630,7 +630,7 @@
 
     insertPi.removePi();
 
-    uint32 checks_eliminated = 0;
+    U_32 checks_eliminated = 0;
 
     for(InstRedundancyMap::const_iterator i = _redundantChecks.begin();
         i != _redundantChecks.end(); ++i) {

Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/abcd/classic_abcd_solver.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/abcd/classic_abcd_solver.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/abcd/classic_abcd_solver.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/optimizer/abcd/classic_abcd_solver.cpp Thu May 22 06:33:38 2008
@@ -49,7 +49,7 @@
     }
 }
 
-void TwoStateOpndToEdgeListMap::addEdge(uint32 opnd_id, IneqEdge* edge)
+void TwoStateOpndToEdgeListMap::addEdge(U_32 opnd_id, IneqEdge* edge)
 {
     MapIdTo2stList::iterator it = _map.find(opnd_id);
     if ( it == _map.end() ) {
@@ -62,7 +62,7 @@
 }
 
 void TwoStateOpndToEdgeListMap::addEdgeSingleState
-    (uint32 opnd_id, IneqEdge *edge, bool is_lower)
+    (U_32 opnd_id, IneqEdge *edge, bool is_lower)
 {
     MapIdTo2stList::iterator it = _map.find(opnd_id);
     if ( it == _map.end() ) {
@@ -75,7 +75,7 @@
 }
 
 TwoStateEdgeList::iterator
-    TwoStateOpndToEdgeListMap::eListBegin(uint32 opnd_id) const
+    TwoStateOpndToEdgeListMap::eListBegin(U_32 opnd_id) const
 {
     MapIdTo2stList::const_iterator it = _map.find(opnd_id);
     if ( it == _map.end() ) {
@@ -85,7 +85,7 @@
 }
 
 TwoStateEdgeList::iterator
-    TwoStateOpndToEdgeListMap::eListEnd(uint32 opnd_id) const
+    TwoStateOpndToEdgeListMap::eListEnd(U_32 opnd_id) const
 {
     MapIdTo2stList::const_iterator it = _map.find(opnd_id);
     if ( it == _map.end() ) {
@@ -125,7 +125,7 @@
     return _opnd_to_outedges_map_2st.eListEnd(opnd->getID());
 }
 
-void InequalityGraph::addEdge(IOpnd* from, IOpnd* to, int32 distance)
+void InequalityGraph::addEdge(IOpnd* from, IOpnd* to, I_32 distance)
 {
     assert(!has_other_opnd_with_same_id(_id_to_opnd_map, from));
     assert(!has_other_opnd_with_same_id(_id_to_opnd_map, to));
@@ -147,14 +147,14 @@
     _opnd_to_outedges_map_2st.setState(is_lower);
 }
 
-void InequalityGraph::addEdge(uint32 id_from, uint32 id_to, int32 distance)
+void InequalityGraph::addEdge(U_32 id_from, U_32 id_to, I_32 distance)
 {
     IOpnd* from = getOpndById(id_from);
     IOpnd* to = getOpndById(id_to);
     addEdge(from, to, distance);
 }
 
-IOpnd* InequalityGraph::getOpndById(uint32 id) const
+IOpnd* InequalityGraph::getOpndById(U_32 id) const
 {
     IdToOpndMap::const_iterator it = _id_to_opnd_map.find(id);
     assert(it != _id_to_opnd_map.end());
@@ -162,7 +162,7 @@
 }
 
 void InequalityGraph::addEdgeSingleState
-     (uint32 id_from, uint32 id_to, int32 distance, bool is_lower)
+     (U_32 id_from, U_32 id_to, I_32 distance, bool is_lower)
 {
     IOpnd* from = getOpndById(id_from);
     IOpnd* to = getOpndById(id_to);
@@ -170,7 +170,7 @@
 }
 
 void InequalityGraph::addEdgeSingleState
-     (IOpnd* from, IOpnd* to, int32 distance, bool is_lower)
+     (IOpnd* from, IOpnd* to, I_32 distance, bool is_lower)
 {
     assert(!has_other_opnd_with_same_id(_id_to_opnd_map, from));
     assert(!has_other_opnd_with_same_id(_id_to_opnd_map, to));
@@ -294,7 +294,7 @@
     }
 }
 
-IOpnd* InequalityGraph::findOpnd(uint32 id) const
+IOpnd* InequalityGraph::findOpnd(U_32 id) const
 {
     IdToOpndMap::const_iterator it = _id_to_opnd_map.find(id);
     if ( it == _id_to_opnd_map.end() ) {
@@ -310,7 +310,7 @@
     return new (_mem_mgr) TrueReducedFalseChart(this);
 }
 
-Bound* BoundAllocator::newBound(int32 val, const BoundState& bs)
+Bound* BoundAllocator::newBound(I_32 val, const BoundState& bs)
 {
     return new (_mem_mgr) Bound(val, bs);
 }
@@ -327,7 +327,7 @@
                     bound->getBoundState());
 }
 
-Bound* BoundAllocator::create_dec_const(Bound* bound, int32 cnst)
+Bound* BoundAllocator::create_dec_const(Bound* bound, I_32 cnst)
 {
     return newBound(bound->_bound - cnst, bound->getBoundState());
 }
@@ -359,7 +359,7 @@
         Bound::leq(bound1, bound2) && Bound::leq(bound2, bound1);
 }
 
-bool Bound::leq_int32(Bound* bound1, int32 value) 
+bool Bound::leq_int32(Bound* bound1, I_32 value) 
 { 
     assert(bound1);
     return bound1->isUpper() ? 
@@ -367,7 +367,7 @@
         bound1->_bound >= value;
 }
 
-bool Bound::int32_leq(int32 value, Bound* bound1) 
+bool Bound::int32_leq(I_32 value, Bound* bound1) 
 { 
     assert(bound1);
     return bound1->isUpper() ? 
@@ -376,10 +376,10 @@
 }
 
 // returns (dst_val - src_val <= bound)
-bool Bound::const_distance_leq(int32 src_val, int32 dst_val, Bound* bound)
+bool Bound::const_distance_leq(I_32 src_val, I_32 dst_val, Bound* bound)
 {
     assert(bound);
-    int32 distance = dst_val - src_val;
+    I_32 distance = dst_val - src_val;
     assert(distance + src_val == dst_val);
     return Bound::int32_leq(distance, bound);
 }
@@ -632,7 +632,7 @@
 //------------------------------------------------------------------------------
 
 bool ClassicAbcdSolver::demandProve
-     (IOpnd* source, IOpnd* dest, int32 bound_int, bool prove_upper_bound)
+     (IOpnd* source, IOpnd* dest, I_32 bound_int, bool prove_upper_bound)
 {
     assert(source && dest);
     _source_opnd = source;
@@ -666,7 +666,7 @@
 
 void ClassicAbcdSolver::updateMemDistanceWithPredecessors (IOpnd* dest, 
                                                            Bound* bound, 
-                                                           uint32 prn_level, 
+                                                           U_32 prn_level, 
                                                       meet_func_t meet_f)
 {
     InequalityGraph::edge_iterator in_it = _igraph.inEdgesBegin(dest);
@@ -711,7 +711,7 @@
 // prove that distance between '_source_opnd' and 'dest' is <= bound
 //
 ProveResult ClassicAbcdSolver::prove(IOpnd* dest, Bound* bound, 
-        uint32 prn_level)
+        U_32 prn_level)
 {
     Printer prn(prn_level, Log::out());
     if ( Log::isEnabled() ) {
@@ -801,7 +801,7 @@
 void ClassicAbcdSolver::Printer::prnLevel()
 {
     if (Log::isEnabled()) {
-        for (uint32 i = 0; i < _level; i++) {
+        for (U_32 i = 0; i < _level; i++) {
             _os << "    ";
         }
     }
@@ -1081,7 +1081,7 @@
 
 void printExampleGraph()
 {
-    uint32 opnd_id = 0;
+    U_32 opnd_id = 0;
     IOpnd op0(opnd_id++), op1(opnd_id++, true), op2(opnd_id++, true, true);
 
     op2.setConstant(25);
@@ -1183,7 +1183,7 @@
 }
 
 void verifyNodesRange
-     (const uint32* ids_gold, uint32 id_count,
+     (const U_32* ids_gold, U_32 id_count,
       const InequalityGraph::edge_iterator& begin_range,
       const InequalityGraph::edge_iterator& end_range, bool check_src_nodes)
 {
@@ -1191,13 +1191,13 @@
     //    it is far from optimal asymptotically
     InequalityGraph::edge_iterator it = begin_range;
     InequalityGraph::edge_iterator end = end_range;
-    uint32 found_count = 0;
+    U_32 found_count = 0;
     for (; it != end; it.next()) {
         IneqEdge* edge = it.get();
         IOpnd* op = check_src_nodes ? edge->getSrc() : edge->getDst();
-        uint32 op_id = op->getID();
+        U_32 op_id = op->getID();
         bool found = false;
-        for (uint32 i = 0; i < id_count; i++) {
+        for (U_32 i = 0; i < id_count; i++) {
             if ( op_id == ids_gold[i] ) {
                 found = true;
                 found_count++;
@@ -1210,7 +1210,7 @@
 }
 
 void assertInNodesEqual(InequalityGraph& g,
-     IOpnd& opnd, const uint32* ids_gold, uint32 id_count)
+     IOpnd& opnd, const U_32* ids_gold, U_32 id_count)
 {
     const InequalityGraph::edge_iterator in_iter = g.inEdgesBegin(&opnd),
           in_end = g.inEdgesEnd(&opnd);
@@ -1219,7 +1219,7 @@
 }
 
 void assertOutNodesEqual(InequalityGraph& g,
-     IOpnd& opnd, const uint32* ids_gold, uint32 id_count)
+     IOpnd& opnd, const U_32* ids_gold, U_32 id_count)
 {
     const InequalityGraph::edge_iterator out_iter = g.outEdgesBegin(&opnd),
           out_end = g.outEdgesEnd(&opnd);
@@ -1249,7 +1249,7 @@
     {
         TwoStateEdgeList::iterator it = edges_map_2st.eListBegin(1),
             it_end = edges_map_2st.eListEnd(1);
-        uint32 found = 0;
+        U_32 found = 0;
         for (; it != it_end; it.next() ) {
             UNUSED IneqEdge* e = it.get();
             assert(e == &e1 || e == &e2 || e == &e3);
@@ -1262,7 +1262,7 @@
     {
         TwoStateEdgeList::iterator it = edges_map_2st.eListBegin(1),
             it_end = edges_map_2st.eListEnd(1);
-        uint32 found = 0;
+        U_32 found = 0;
         for (; it != it_end; it.next() ) {
             UNUSED IneqEdge* e = it.get();
             assert(e == &e1 || e == &e2);
@@ -1305,31 +1305,31 @@
 
     g.setState(true /* is_lower */);
     {
-        const uint32 i1_in_gold[] = {0, 3, length.getID()};
+        const U_32 i1_in_gold[] = {0, 3, length.getID()};
         assertInNodesEqual(g, i1, i1_in_gold, 3);
-        const uint32 i1_out_gold[] = {2};
+        const U_32 i1_out_gold[] = {2};
         assertOutNodesEqual(g, i1, i1_out_gold, 1);
-        const uint32 i2_in_gold[] = {1, length.getID()};
+        const U_32 i2_in_gold[] = {1, length.getID()};
         assertInNodesEqual(g, i2, i2_in_gold, 2);
-        const uint32 i3_out_gold[] = {1};
+        const U_32 i3_out_gold[] = {1};
         assertOutNodesEqual(g, i3, i3_out_gold, 1);
     }
 
     g.setState(false /* is_lower */);
     {
-        const uint32 i1_in_gold[] = {0, 3};
+        const U_32 i1_in_gold[] = {0, 3};
         assertInNodesEqual(g, i1, i1_in_gold, 2);
-        const uint32 i1_out_gold[] = {2};
+        const U_32 i1_out_gold[] = {2};
         assertOutNodesEqual(g, i1, i1_out_gold, 1);
-        const uint32 i2_in_gold[] = {1, length.getID(), 3};
+        const U_32 i2_in_gold[] = {1, length.getID(), 3};
         assertInNodesEqual(g, i2, i2_in_gold, 3);
-        const uint32 i3_out_gold[] = {1, 2};
+        const U_32 i3_out_gold[] = {1, 2};
         assertOutNodesEqual(g, i3, i3_out_gold, 2);
     }
 
     g.setState(true /* is_lower */);
     {
-        const uint32 i3_out_gold[] = {1};
+        const U_32 i3_out_gold[] = {1};
         assertOutNodesEqual(g, i3, i3_out_gold, 1);
     }
     std::ofstream f;



Mime
View raw message