You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@harmony.apache.org by mc...@apache.org on 2008/05/22 15:34:09 UTC
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...
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;