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 [7/19] - in /harmony/enhanced/drlvm/trunk/vm: em/src/
gc_gen/src/common/ gc_gen/src/mark_compact/ gc_gen/src/mark_sweep/
gc_gen/src/semi_space/ gc_gen/src/trace_forward/ include/open/
interpreter/src/ jitrino/src/codegenerator/ jitr...
Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfCodeSelector.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfCodeSelector.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfCodeSelector.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfCodeSelector.cpp Thu May 22 06:33:38 2008
@@ -43,7 +43,7 @@
//----------------------------------------------------------------------------------------//
-void IpfMethodCodeSelector::genVars(uint32 numVars, VarCodeSelector &varCodeSelector) {
+void IpfMethodCodeSelector::genVars(U_32 numVars, VarCodeSelector &varCodeSelector) {
IPF_LOG << endl << " Select variables" << endl;
IpfVarCodeSelector ipfVarCodeSelector(cfg, opnds);
@@ -58,7 +58,7 @@
//----------------------------------------------------------------------------------------//
-void IpfMethodCodeSelector::genCFG(uint32 numNodes,
+void IpfMethodCodeSelector::genCFG(U_32 numNodes,
CFGCodeSelector &codeSelector,
bool useProfile) {
@@ -85,7 +85,7 @@
//----------------------------------------------------------------------------------------//
-uint32 IpfVarCodeSelector::defVar(Type *varType, bool isAddressTaken, bool isPinned) {
+U_32 IpfVarCodeSelector::defVar(Type *varType, bool isAddressTaken, bool isPinned) {
OpndKind opndKind = IpfInstCodeSelector::toOpndKind(varType->tag);
DataKind dataKind = IpfInstCodeSelector::toDataKind(varType->tag);
@@ -106,7 +106,7 @@
//----------------------------------------------------------------------------------------//
-void IpfVarCodeSelector::setManagedPointerBase(uint32 managedPtrVarNum, uint32 baseVarNum) {}
+void IpfVarCodeSelector::setManagedPointerBase(U_32 managedPtrVarNum, U_32 baseVarNum) {}
//========================================================================================//
// IpfCfgCodeSelector
@@ -126,12 +126,12 @@
//----------------------------------------------------------------------------------------//
-uint32 IpfCfgCodeSelector::genDispatchNode(uint32 numInEdges,
- uint32 numOutEdges,
+U_32 IpfCfgCodeSelector::genDispatchNode(U_32 numInEdges,
+ U_32 numOutEdges,
const StlVector<MethodDesc*>& inlineInfo,
double cnt) {
- Node *node = new(mm) Node(mm, opndManager->getNextNodeId(), (uint32) cnt, NODE_DISPATCH);
+ Node *node = new(mm) Node(mm, opndManager->getNextNodeId(), (U_32) cnt, NODE_DISPATCH);
nodes.push_back(node);
IPF_LOG << endl << " Generate Dispatch node" << node->getId() << endl;
@@ -140,13 +140,13 @@
//----------------------------------------------------------------------------------------//
-uint32 IpfCfgCodeSelector::genBlock(uint32 numInEdges,
- uint32 numOutEdges,
+U_32 IpfCfgCodeSelector::genBlock(U_32 numInEdges,
+ U_32 numOutEdges,
BlockKind blockKind,
BlockCodeSelector &codeSelector,
double cnt) {
- BbNode *node = new(mm) BbNode(mm, opndManager->getNextNodeId(), (uint32)cnt);
+ BbNode *node = new(mm) BbNode(mm, opndManager->getNextNodeId(), (U_32)cnt);
nodes.push_back(node);
if(blockKind == Prolog) cfg.setEnterNode(node);
@@ -160,11 +160,11 @@
//----------------------------------------------------------------------------------------//
-uint32 IpfCfgCodeSelector::genUnwindNode(uint32 numInEdges,
- uint32 numOutEdges,
+U_32 IpfCfgCodeSelector::genUnwindNode(U_32 numInEdges,
+ U_32 numOutEdges,
double cnt) {
- Node *node = new(mm) Node(mm, opndManager->getNextNodeId(), (uint32) cnt, NODE_UNWIND);
+ Node *node = new(mm) Node(mm, opndManager->getNextNodeId(), (U_32) cnt, NODE_UNWIND);
nodes.push_back(node);
IPF_LOG << endl << " Generate Unwind node" << node->getId() << endl;
@@ -173,9 +173,9 @@
//----------------------------------------------------------------------------------------//
-uint32 IpfCfgCodeSelector::genExitNode(uint32 numInEdges, double cnt) {
+U_32 IpfCfgCodeSelector::genExitNode(U_32 numInEdges, double cnt) {
- BbNode *node = new(mm) BbNode(mm, opndManager->getNextNodeId(), (uint32) cnt);
+ BbNode *node = new(mm) BbNode(mm, opndManager->getNextNodeId(), (U_32) cnt);
nodes.push_back(node);
cfg.setExitNode(node);
@@ -185,8 +185,8 @@
//----------------------------------------------------------------------------------------//
-void IpfCfgCodeSelector::genUnconditionalEdge(uint32 tailNodeId,
- uint32 headNodeId,
+void IpfCfgCodeSelector::genUnconditionalEdge(U_32 tailNodeId,
+ U_32 headNodeId,
double prob) {
IPF_LOG << " Generate Unconditional edge node" << nodes[tailNodeId]->getId();
@@ -198,7 +198,7 @@
//----------------------------------------------------------------------------------------//
-void IpfCfgCodeSelector::genTrueEdge(uint32 tailNodeId, uint32 headNodeId, double prob) {
+void IpfCfgCodeSelector::genTrueEdge(U_32 tailNodeId, U_32 headNodeId, double prob) {
IPF_LOG << " Generate True edge node" << nodes[tailNodeId]->getId();
IPF_LOG << " -> node" << nodes[headNodeId]->getId() << endl;
@@ -209,7 +209,7 @@
//----------------------------------------------------------------------------------------//
-void IpfCfgCodeSelector::genFalseEdge(uint32 tailNodeId, uint32 headNodeId, double prob) {
+void IpfCfgCodeSelector::genFalseEdge(U_32 tailNodeId, U_32 headNodeId, double prob) {
IPF_LOG << " Generate False edge node" << nodes[tailNodeId]->getId();
IPF_LOG << " -> node" << nodes[headNodeId]->getId() << endl;
@@ -220,11 +220,11 @@
//----------------------------------------------------------------------------------------//
-void IpfCfgCodeSelector::genSwitchEdges(uint32 tailNodeId,
- uint32 numTargets,
- uint32 *targets,
+void IpfCfgCodeSelector::genSwitchEdges(U_32 tailNodeId,
+ U_32 numTargets,
+ U_32 *targets,
double *probs,
- uint32 defaultTarget) {
+ U_32 defaultTarget) {
BbNode *tailNode = (BbNode *)nodes[tailNodeId];
InstVector &insts = tailNode->getInsts();
@@ -236,7 +236,7 @@
Edge *edge = NULL;
bool defadded = false;
- uint32 i = 0;
+ U_32 i = 0;
IPF_LOG << " Generate Switch tailNodeId=" << tailNodeId
<< "; defaultTarget=" << defaultTarget << endl;
@@ -269,8 +269,8 @@
//--------------------------------------------------------------------------------//
// edge from try region to dispatch node
-void IpfCfgCodeSelector::genExceptionEdge(uint32 tailNodeId,
- uint32 headNodeId,
+void IpfCfgCodeSelector::genExceptionEdge(U_32 tailNodeId,
+ U_32 headNodeId,
double prob) {
Node *tailNode = nodes[tailNodeId];
@@ -285,9 +285,9 @@
//----------------------------------------------------------------------------------------//
// edge from dispatch node to exception handler
-void IpfCfgCodeSelector::genCatchEdge(uint32 tailNodeId,
- uint32 headNodeId,
- uint32 priority,
+void IpfCfgCodeSelector::genCatchEdge(U_32 tailNodeId,
+ U_32 headNodeId,
+ U_32 priority,
Type *exceptionType,
double prob) {
@@ -303,8 +303,8 @@
//----------------------------------------------------------------------------------------//
-void IpfCfgCodeSelector::genExitEdge(uint32 tailNodeId,
- uint32 headNodeId,
+void IpfCfgCodeSelector::genExitEdge(U_32 tailNodeId,
+ U_32 headNodeId,
double prob) {
Node *tailNode=nodes[tailNodeId];
@@ -319,10 +319,10 @@
//----------------------------------------------------------------------------------------//
-void IpfCfgCodeSelector::setLoopInfo(uint32 nodeId,
+void IpfCfgCodeSelector::setLoopInfo(U_32 nodeId,
bool isLoopHeader,
bool hasContainingLoopHeader,
- uint32 headerId) {
+ U_32 headerId) {
if (hasContainingLoopHeader == false) return;
@@ -334,7 +334,7 @@
//----------------------------------------------------------------------------------------//
-void IpfCfgCodeSelector::setPersistentId(uint32 nodeId, uint32 persistentId) {}
+void IpfCfgCodeSelector::setPersistentId(U_32 nodeId, U_32 persistentId) {}
} //namespace IPF
} //namespace Jitrino
Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfEmitter.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfEmitter.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfEmitter.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfEmitter.cpp Thu May 22 06:33:38 2008
@@ -99,7 +99,7 @@
void Emitter::checkForDualIssueBundles() {
EmitterBb *bb;
Bundle *bundle1, *bundle2;
- uint32 tmpl1, tmpl2;
+ U_32 tmpl1, tmpl2;
bool header_printed = false;
for (int bbindex=0 ; bbindex<(int)bbs->size() ; bbindex++) {
@@ -159,7 +159,7 @@
//============================================================================//
-Bundle::Bundle(Cfg& cfg, uint32 itmp, Inst *i0, Inst *i1, Inst *i2) {
+Bundle::Bundle(Cfg& cfg, U_32 itmp, Inst *i0, Inst *i1, Inst *i2) {
indxtmpl = itmp; // !!! THis is not template, but index in Bundle::BundleDesc[] !!!
MemoryManager& mm = cfg.getMM();
@@ -211,7 +211,7 @@
void Bundle::emitBundleBranch(void *whereToEmit, int * bundletarget) {
uint64 * p = (uint64 *)whereToEmit;
uint64 s;
- uint32 itmp = getTmpl();
+ U_32 itmp = getTmpl();
p[0] = 0;
p[1] = 0;
@@ -275,7 +275,7 @@
//============================================================================//
void Bundle::print() {
Inst * inst = getSlot(0);
- uint32 tmpl = getTmpl();
+ U_32 tmpl = getTmpl();
IPF_LOG << "(" << tmpl << ")\n";
IPF_LOG << IrPrinter::toString(inst);
@@ -534,10 +534,10 @@
OpndVector & opnds = inst->getOpnds();
if(opnds.size() <= 1) return;
- uint32 dstcount=inst->getNumDst();
+ U_32 dstcount=inst->getNumDst();
Opnd *opnd;
- for( uint32 i=0 ; i<dstcount ; i++ ) {
+ for( U_32 i=0 ; i<dstcount ; i++ ) {
opnd = opnds[i+1];
switch (opnd->getOpndKind()) {
case OPND_G_REG:
@@ -564,11 +564,11 @@
OpndVector & opnds = inst->getOpnds();
if(opnds.size() <= 1) return;
- uint32 dstcount=inst->getNumDst();
- uint32 opndcount=inst->getNumOpnd();
+ U_32 dstcount=inst->getNumDst();
+ U_32 opndcount=inst->getNumOpnd();
Opnd *opnd;
- for( uint32 i=1+dstcount ; i<opndcount ; i++ ) {
+ for( U_32 i=1+dstcount ; i<opndcount ; i++ ) {
opnd = opnds[i];
switch (opnd->getOpndKind()) {
case OPND_G_REG:
@@ -632,8 +632,8 @@
vectorregs * rr = bb->rregs;
Inst *inst;
RegistersBitset * regs;
- uint32 dstcount;
- uint32 opndcount;
+ U_32 dstcount;
+ U_32 opndcount;
Opnd * opnd;
vectorconst * consts = bb->consts;
Constant * constant;
@@ -671,7 +671,7 @@
dstcount=inst->getNumDst();
opndcount=inst->getNumOpnd();
- for( uint32 j=1 ; j<opndcount ; j++ ) {
+ for( U_32 j=1 ; j<opndcount ; j++ ) {
opnd = opnds[j];
if (opnd->isImm()) {
if ( opnd->getDataKind() == DATA_CONST_REF) {
@@ -1174,9 +1174,9 @@
bundles = bb->bundles;
for(int i=0, ii=(int)bundles->size() ; i<ii ; i++ ) {
bundle = bundles->at(i);
- for (uint32 si=0 ; si < IPF_SLOTS_COUNT ; si++) {
+ for (U_32 si=0 ; si < IPF_SLOTS_COUNT ; si++) {
inst = bundle->getSlot(si);
- inst->setAddr((uint32)(off - bboff) + si);
+ inst->setAddr((U_32)(off - bboff) + si);
}
if ( isBranchBundle(bundle, codeoff, off, target) ) {
@@ -1349,7 +1349,7 @@
Inst *inst;
IPF_LOG << ".L" << bbs->at(bbindex)->node->getId() << "\n";
- for (uint32 i = 0, ii=insts.size() ; i < ii ; i++) {
+ for (U_32 i = 0, ii=insts.size() ; i < ii ; i++) {
inst = insts[i];
if( inst==NULL ) {
IPF_LOG << IrPrinter::toString(inst);
Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfInstCodeSelector.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfInstCodeSelector.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfInstCodeSelector.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfInstCodeSelector.cpp Thu May 22 06:33:38 2008
@@ -32,9 +32,9 @@
#define VTABLEBASE (opndManager->getVtableBase())
#define VTABLEBASEIMM (opndManager->getVtableBaseImm())
-#define IMM32(o) ((int32)(((Opnd *)(o))->getValue()))
+#define IMM32(o) ((I_32)(((Opnd *)(o))->getValue()))
#define IMM64(o) ((int64)(((Opnd *)(o))->getValue()))
-#define IMM32U(o) ((uint32)(((Opnd *)(o))->getValue()))
+#define IMM32U(o) ((U_32)(((Opnd *)(o))->getValue()))
#define IMM64U(o) ((uint64)(((Opnd *)(o))->getValue()))
// FP remainder internal helpers (temp solution to be optimized)
@@ -304,7 +304,7 @@
if (ipfConstantFolding && ((Opnd *)src_)->isImm()) {
switch (opType) {
case NegOp::I4:
- dst = opndManager->newImm((int32)0 - IMM32(src_)); break;
+ dst = opndManager->newImm((I_32)0 - IMM32(src_)); break;
case NegOp::I:
case NegOp::I8:
dst = opndManager->newImm(0 - IMM64(src_)); break;
@@ -610,7 +610,7 @@
if (ipfConstantFolding && ((Opnd *)value)->isImm() && ((Opnd *)shiftAmount)->isImm()) {
if (opType==IntegerOp::I4) {
- return opndManager->newImm((uint64)((uint32)((int32)(((Opnd *)value)->getValue()))) >> ((Opnd *)shiftAmount)->getValue());
+ return opndManager->newImm((uint64)((U_32)((I_32)(((Opnd *)value)->getValue()))) >> ((Opnd *)shiftAmount)->getValue());
} else {
return opndManager->newImm((uint64)(((Opnd *)value)->getValue()) >> ((Opnd *)shiftAmount)->getValue());
}
@@ -637,7 +637,7 @@
CG_OpndHandle *IpfInstCodeSelector::shladd(IntegerOp::Types opType,
CG_OpndHandle *value_,
- uint32 imm,
+ U_32 imm,
CG_OpndHandle *addto_) {
IPF_LOG << " shladd " << endl;
@@ -745,7 +745,7 @@
//----------------------------------------------------------------------------//
// Load 32-bit integer constant
-CG_OpndHandle *IpfInstCodeSelector::ldc_i4(int32 val) {
+CG_OpndHandle *IpfInstCodeSelector::ldc_i4(I_32 val) {
IPF_LOG << " ldc_i4; val=" << val << endl;
@@ -791,7 +791,7 @@
union {
float fr;
- uint32 gr;
+ U_32 gr;
} tmpVal;
tmpVal.fr = val;
@@ -887,7 +887,7 @@
//----------------------------------------------------------------------------//
// Load variable
-CG_OpndHandle *IpfInstCodeSelector::ldVar(Type *dstType, uint32 varId) {
+CG_OpndHandle *IpfInstCodeSelector::ldVar(Type *dstType, U_32 varId) {
IPF_LOG << " ldVar; dstType=" << Type::tag2str(dstType->tag) << ", varId=" << varId << endl;
@@ -911,7 +911,7 @@
//----------------------------------------------------------------------------//
// Store variable
-void IpfInstCodeSelector::stVar(CG_OpndHandle *_src, uint32 varId) {
+void IpfInstCodeSelector::stVar(CG_OpndHandle *_src, U_32 varId) {
IPF_LOG << " stVar"
<< "; varId=" << varId
@@ -940,7 +940,7 @@
//----------------------------------------------------------------------------//
// Define an argument
-CG_OpndHandle *IpfInstCodeSelector::defArg(uint32 inArgPosition, Type *type) {
+CG_OpndHandle *IpfInstCodeSelector::defArg(U_32 inArgPosition, Type *type) {
OpndKind opndKind = toOpndKind(type->tag);
@@ -1200,7 +1200,7 @@
// (p8) br.cond.sptk b1 // branch to target
// // if p8 is false - fall through
-void IpfInstCodeSelector::tableSwitch(CG_OpndHandle *src, uint32 nTargets) {
+void IpfInstCodeSelector::tableSwitch(CG_OpndHandle *src, U_32 nTargets) {
IPF_LOG << " tableSwitch" << endl;
@@ -1257,7 +1257,7 @@
//----------------------------------------------------------------------------//
// Direct call to the method
-CG_OpndHandle *IpfInstCodeSelector::call(uint32 numArgs,
+CG_OpndHandle *IpfInstCodeSelector::call(U_32 numArgs,
CG_OpndHandle **args,
Type *retType,
MethodDesc *desc) {
@@ -1268,7 +1268,7 @@
//----------------------------------------------------------------------------//
// Direct call to the method
-CG_OpndHandle *IpfInstCodeSelector::tau_call(uint32 numArgs,
+CG_OpndHandle *IpfInstCodeSelector::tau_call(U_32 numArgs,
CG_OpndHandle **args,
Type *retType,
MethodDesc *desc,
@@ -1294,7 +1294,7 @@
//----------------------------------------------------------------------------//
// Indirect call
-CG_OpndHandle *IpfInstCodeSelector::tau_calli(uint32 numArgs,
+CG_OpndHandle *IpfInstCodeSelector::tau_calli(U_32 numArgs,
CG_OpndHandle **args,
Type *retType,
CG_OpndHandle *methodPtr,
@@ -1428,8 +1428,8 @@
// Throw linking exception
void IpfInstCodeSelector::throwLinkingException(Class_Handle encClass,
- uint32 cp_ndx,
- uint32 opcode)
+ U_32 cp_ndx,
+ U_32 opcode)
{
IPF_LOG << " throwLinkingException" << endl;
@@ -1724,7 +1724,7 @@
// Load string
CG_OpndHandle *IpfInstCodeSelector::ldString(MethodDesc *enclosingMethod,
- uint32 stringToken,
+ U_32 stringToken,
bool uncompress) {
IPF_LOG << " ldString" << endl;
@@ -1976,14 +1976,14 @@
// Create multi-dimensional new array
CG_OpndHandle *IpfInstCodeSelector::newMultiArray(ArrayType *arrayType,
- uint32 numDims,
+ U_32 numDims,
CG_OpndHandle **dims) {
Opnd *helperArgs[2 + numDims];
helperArgs[0] = opndManager->newImm((uint64)arrayType->getRuntimeIdentifier());
helperArgs[1] = opndManager->newImm(numDims);
- for (uint32 i = 0; i < numDims; i++) {
+ for (U_32 i = 0; i < numDims; i++) {
helperArgs[i + 2] = (Opnd *)dims[numDims - 1 - i];
}
@@ -2162,7 +2162,7 @@
//----------------------------------------------------------------------------//
// Create direct call to the method
-void IpfInstCodeSelector::directCall(uint32 numArgs,
+void IpfInstCodeSelector::directCall(U_32 numArgs,
Opnd **args,
RegOpnd *retOpnd,
Opnd *methodAddress,
@@ -2184,7 +2184,7 @@
//----------------------------------------------------------------------------//
// Create indirect call to the method
-void IpfInstCodeSelector::indirectCall(uint32 numArgs,
+void IpfInstCodeSelector::indirectCall(U_32 numArgs,
Opnd **args,
RegOpnd *retOpnd,
RegOpnd *methodPtr,
@@ -2208,16 +2208,16 @@
//----------------------------------------------------------------------------//
// Move out args in regs and stack positions according with IPF software convention
-void IpfInstCodeSelector::makeCallArgs(uint32 numArgs, Opnd **args, Inst *callInst, RegOpnd *pred) {
+void IpfInstCodeSelector::makeCallArgs(U_32 numArgs, Opnd **args, Inst *callInst, RegOpnd *pred) {
int16 numFpOutArgs = 0;
- for(uint32 argPosition=0; argPosition<numArgs; argPosition++) {
+ for(U_32 argPosition=0; argPosition<numArgs; argPosition++) {
Opnd *opnd = args[argPosition];
OpndKind opndKind = OPND_INVALID;
DataKind dataKind = DATA_INVALID;
InstCode instCode = INST_INVALID;
- int32 location = LOCATION_INVALID;
+ I_32 location = LOCATION_INVALID;
bool isFp = opnd->isFloating();
if (opnd->isReg() == true) { // opnd is register
@@ -2705,7 +2705,7 @@
union {
float fr;
- uint32 gr;
+ U_32 gr;
} fval;
union {
double fr;
@@ -2952,7 +2952,7 @@
CG_OpndHandle *IpfInstCodeSelector::ldRef(Type *dstType,
MethodDesc* enclosingMethod,
- uint32 refToken,
+ U_32 refToken,
bool uncompress)
{
assert(dstType->isSystemString() || dstType->isSystemClass());
Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfIrPrinter.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfIrPrinter.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfIrPrinter.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfIrPrinter.cpp Thu May 22 06:33:38 2008
@@ -90,10 +90,10 @@
NodeVector &nodes = cfg.search(SEARCH_POST_ORDER);
printHead();
- for(uint32 i=0; i<nodes.size(); i++) {
+ for(U_32 i=0; i<nodes.size(); i++) {
printNodeDot(nodes[i]);
EdgeVector &edges = nodes[i]->getOutEdges();
- for(uint32 j=0; j<edges.size(); j++) {
+ for(U_32 j=0; j<edges.size(); j++) {
printEdgeDot(edges[j]);
}
}
@@ -157,7 +157,7 @@
if(node->getNodeKind() == NODE_BB) {
InstVector &insts = ((BbNode *)node)->getInsts();
- for(uint32 i=0; i<insts.size(); i++) {
+ for(U_32 i=0; i<insts.size(); i++) {
*ofs << "\\n" << insts[i]->getInstMnemonic();
CompVector &compList = insts[i]->getComps();
for(uint16 j=0; j<compList.size(); j++) *ofs << insts[i]->getCompMnemonic(compList[j]);
@@ -198,7 +198,7 @@
*os << ".L" << node->getId() << ":" << endl;
InstVector &insts = ((BbNode *)node)->getInsts();
- for(uint32 i=0; i<insts.size(); i++) *os << " " << toString(insts[i]) << endl;
+ for(U_32 i=0; i<insts.size(); i++) *os << " " << toString(insts[i]) << endl;
}
//----------------------------------------------------------------------------------------//
@@ -266,7 +266,7 @@
// opnd is register
if(opnd->isReg()) {
RegOpnd *reg = (RegOpnd *)opnd;
- int32 num = reg->getLocation();
+ I_32 num = reg->getLocation();
if (num == LOCATION_INVALID) {
num = reg->getId();
Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfOpnd.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfOpnd.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfOpnd.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfOpnd.cpp Thu May 22 06:33:38 2008
@@ -79,7 +79,7 @@
// Opnd
//============================================================================//
-Opnd::Opnd(uint32 id, OpndKind opndKind, DataKind dataKind, int64 value) :
+Opnd::Opnd(U_32 id, OpndKind opndKind, DataKind dataKind, int64 value) :
id(id),
opndKind(opndKind),
dataKind(dataKind),
@@ -142,7 +142,7 @@
// RegOpnd
//============================================================================//
-RegOpnd::RegOpnd(MemoryManager &mm, uint32 id, OpndKind opndKind, DataKind dataKind, int32 value) :
+RegOpnd::RegOpnd(MemoryManager &mm, U_32 id, OpndKind opndKind, DataKind dataKind, I_32 value) :
Opnd(id, opndKind, dataKind, value),
spillCost(0),
depOpnds(mm),
Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfOpndManager.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfOpndManager.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfOpndManager.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfOpndManager.cpp Thu May 22 06:33:38 2008
@@ -60,7 +60,7 @@
//----------------------------------------------------------------------------------------//
-int32 RegStack::newInReg(int32 inArgPosition) {
+I_32 RegStack::newInReg(I_32 inArgPosition) {
if (inRegSize < inArgPosition+1) inRegSize = inArgPosition+1;
return G_INARG_BASE + inArgPosition;
@@ -68,7 +68,7 @@
//----------------------------------------------------------------------------------------//
-int32 RegStack::newOutReg(int32 outArgPosition) {
+I_32 RegStack::newOutReg(I_32 outArgPosition) {
if (outRegSize < outArgPosition+1) {
outRegSize = outArgPosition+1;
@@ -85,8 +85,8 @@
if (opnd->getOpndKind() != OPND_G_REG) return false; // opnd is not gr - ignore
- int32 firstOutRegArg = G_OUTARG_BASE - outRegSize + 1;
- int32 location = opnd->getLocation();
+ I_32 firstOutRegArg = G_OUTARG_BASE - outRegSize + 1;
+ I_32 location = opnd->getLocation();
if (location < firstOutRegArg) return false; // location is less then first outArg - ignore
if (location >= NUM_G_REG) return false; // location is greater then last outArg - ignore
return true; // it is out reg arg
@@ -108,21 +108,21 @@
//----------------------------------------------------------------------------------------//
// returns location (not offset!) for new in stack opnd
-int32 MemStack::newInSlot(int32 inArgPosition) {
+I_32 MemStack::newInSlot(I_32 inArgPosition) {
- int32 offset = (inArgPosition - MAX_REG_ARG) * ARG_SLOT_SIZE;
+ I_32 offset = (inArgPosition - MAX_REG_ARG) * ARG_SLOT_SIZE;
return S_INARG_BASE + offset;
}
//----------------------------------------------------------------------------------------//
// increments locMemSize and returns location (not offset!) for new local stack opnd
-int32 MemStack::newLocSlot(DataKind dataKind) {
+I_32 MemStack::newLocSlot(DataKind dataKind) {
if (inBase > 0) IPF_ERR << endl; // new loc slot makes illegal in arg offsets
int16 size = IpfType::getSize(dataKind);
- int32 offset = align(locMemSize, size); // align memory address to natural boundary
+ I_32 offset = align(locMemSize, size); // align memory address to natural boundary
locMemSize = offset + size; // increase current local area size
return S_LOCAL_BASE + offset;
@@ -131,12 +131,12 @@
//----------------------------------------------------------------------------------------//
// increments outMemSize and returns location (not offset!) for new out stack opnd
-int32 MemStack::newOutSlot(int32 outArgPosition) {
+I_32 MemStack::newOutSlot(I_32 outArgPosition) {
if (locBase+inBase > 0) IPF_ERR << endl; // new out slot makes illegal in arg and local offsets
- int32 offset = (outArgPosition - MAX_REG_ARG) * ARG_SLOT_SIZE;
- int32 newSize = offset + ARG_SLOT_SIZE;
+ I_32 offset = (outArgPosition - MAX_REG_ARG) * ARG_SLOT_SIZE;
+ I_32 newSize = offset + ARG_SLOT_SIZE;
if(outMemSize < newSize) outMemSize = newSize;
return S_OUTARG_BASE + offset;
@@ -147,7 +147,7 @@
void MemStack::calculateOffset(RegOpnd* opnd) {
- int32 location = opnd->getLocation();
+ I_32 location = opnd->getLocation();
location = calculateOffset(location);
opnd->setLocation(location);
}
@@ -155,7 +155,7 @@
//----------------------------------------------------------------------------------------//
// converts area local offset (location) in absolute offset + S_BASE
-int32 MemStack::calculateOffset(int32 location) {
+I_32 MemStack::calculateOffset(I_32 location) {
if(location < S_OUTARG_BASE) { // offset has been calculated
return location;
@@ -179,7 +179,7 @@
//----------------------------------------------------------------------------------------//
// return current location in local area
-int32 MemStack::getSavedBase() {
+I_32 MemStack::getSavedBase() {
outBase = outMemSize+locMemSize > 0 ? S_SCRATCH_SIZE : 0;
locBase = outBase + align(outMemSize, S_SCRATCH_SIZE);
@@ -188,7 +188,7 @@
//----------------------------------------------------------------------------------------//
-int32 MemStack::getMemStackSize() {
+I_32 MemStack::getMemStackSize() {
outBase = outMemSize+locMemSize > 0 ? S_SCRATCH_SIZE : 0;
locBase = outBase + align(outMemSize, S_SCRATCH_SIZE);
@@ -199,10 +199,10 @@
//----------------------------------------------------------------------------------------//
-int32 MemStack::align(int32 val, int32 size) {
+I_32 MemStack::align(I_32 val, I_32 size) {
- int32 mask = -size;
- int32 buf = val & mask;
+ I_32 mask = -size;
+ I_32 buf = val & mask;
return buf<val ? buf+size : buf;
}
@@ -265,7 +265,7 @@
//----------------------------------------------------------------------------------------//
-RegOpnd *OpndManager::newRegOpnd(OpndKind opndKind, DataKind dataKind, int32 location) {
+RegOpnd *OpndManager::newRegOpnd(OpndKind opndKind, DataKind dataKind, I_32 location) {
return new(mm) RegOpnd(mm, maxOpndId++, opndKind, dataKind, location);
}
@@ -295,9 +295,9 @@
//----------------------------------------------------------------------------------------//
-Opnd *OpndManager::newInArg(OpndKind opndKind, DataKind dataKind, uint32 inArgPosition) {
+Opnd *OpndManager::newInArg(OpndKind opndKind, DataKind dataKind, U_32 inArgPosition) {
- int32 location = LOCATION_INVALID;
+ I_32 location = LOCATION_INVALID;
bool isFp = IpfType::isFloating(dataKind);
if (inArgPosition < MAX_REG_ARG) {
@@ -435,13 +435,13 @@
//----------------------------------------------------------------------------------------//
// tryes to find available location for the opndKind/dataKind taking in account mask of used regs
-int32 OpndManager::newLocation(OpndKind opndKind,
+I_32 OpndManager::newLocation(OpndKind opndKind,
DataKind dataKind,
RegBitSet usedMask,
bool isPreserved) {
RegBitSet &unusedMask = usedMask.flip();
- int32 location = LOCATION_INVALID;
+ I_32 location = LOCATION_INVALID;
if (isPreserved == false) { // it is scratch location
location = newScratchReg(opndKind, unusedMask); // try to find scratch register
@@ -457,7 +457,7 @@
//----------------------------------------------------------------------------------------//
// tryes to find available scratch register for the opndKind taking in account mask of unused regs
-int32 OpndManager::newScratchReg(OpndKind opndKind, RegBitSet &unusedMask) {
+I_32 OpndManager::newScratchReg(OpndKind opndKind, RegBitSet &unusedMask) {
RegBitSet mask;
int16 maskSize = 0;
@@ -478,7 +478,7 @@
//----------------------------------------------------------------------------------------//
// tryes to find available preserved register for the opndKind taking in account mask of unused regs
-int32 OpndManager::newPreservReg(OpndKind opndKind, RegBitSet &unusedMask) {
+I_32 OpndManager::newPreservReg(OpndKind opndKind, RegBitSet &unusedMask) {
RegBitSet mask;
int16 maskSize = 0;
Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfPrologEpilogGenerator.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfPrologEpilogGenerator.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfPrologEpilogGenerator.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfPrologEpilogGenerator.cpp Thu May 22 06:33:38 2008
@@ -130,7 +130,7 @@
void PrologEpilogGenerator::reassignOutRegArgs() {
// First out arg will have this location
- int32 outArgBase = G_INARG_BASE + opndManager->getLocRegSize();
+ I_32 outArgBase = G_INARG_BASE + opndManager->getLocRegSize();
for(RegOpndSetIterator it=outRegArgs.begin(); it!=outRegArgs.end(); it++) {
setRegUsage(*it, false); // mark old reg as free
@@ -140,7 +140,7 @@
RegOpnd *arg = *it;
IPF_LOG << " " << IrPrinter::toString(arg) << " reassigned on ";
- int32 outArgNum = G_OUTARG_BASE - arg->getValue(); // calculate real out arg number
+ I_32 outArgNum = G_OUTARG_BASE - arg->getValue(); // calculate real out arg number
arg->setLocation(outArgBase + outArgNum); // calculate and assign new location
setRegUsage(arg, true); // mark new reg as used
IPF_LOG << IrPrinter::toString(arg) << endl;
@@ -289,9 +289,9 @@
void PrologEpilogGenerator::genAlloc() {
- int32 locRegSize = calculateLocRegSize(); // actual reg usage in local area
- int32 inRegSize = opndManager->getInRegSize(); // in regs number
- int32 outRegSize = opndManager->getOutRegSize(); // out regs number
+ I_32 locRegSize = calculateLocRegSize(); // actual reg usage in local area
+ I_32 inRegSize = opndManager->getInRegSize(); // in regs number
+ I_32 outRegSize = opndManager->getOutRegSize(); // out regs number
if (containCall==false && locRegSize<=inRegSize) return; // method does not need "alloc" inst
@@ -462,7 +462,7 @@
void PrologEpilogGenerator::saveRestoreSp() {
opndManager->initMemStackSize();
- int32 memStackSize = opndManager->memStackSize;
+ I_32 memStackSize = opndManager->memStackSize;
if (memStackSize <= S_SCRATCH_SIZE) return; // method does not need to save SP
Opnd *memStackSizeOpndNeg = opndManager->newImm(-memStackSize);
@@ -475,7 +475,7 @@
RegOpnd* PrologEpilogGenerator::newStorage(DataKind dataKind, uint16 site) {
- int32 location = LOCATION_INVALID;
+ I_32 location = LOCATION_INVALID;
if (site==SITE_REG) location = opndManager->newLocation(OPND_G_REG, dataKind, usedGrMask, containCall);
else location = opndManager->newLocSlot(dataKind);
@@ -505,11 +505,11 @@
//----------------------------------------------------------------------------------------//
-int32 PrologEpilogGenerator::calculateLocRegSize() {
+I_32 PrologEpilogGenerator::calculateLocRegSize() {
uint16 first = G_INARG_BASE; // first possible loc reg opnd location
uint16 last = NUM_G_REG - opndManager->getOutRegSize(); // last possible loc reg opnd location
- int32 locRegSize = 0;
+ I_32 locRegSize = 0;
// find last used gr in local area
for(uint16 i=first; i<last; i++) {
Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfRegisterAllocator.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfRegisterAllocator.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfRegisterAllocator.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfRegisterAllocator.cpp Thu May 22 06:33:38 2008
@@ -72,7 +72,7 @@
BbNode *node = (BbNode *)nodes[i];
liveManager.init(node);
- uint32 execCounter = node->getExecCounter();
+ U_32 execCounter = node->getExecCounter();
InstIterator currInst = node->getInsts().end()-1;
InstIterator firstInst = node->getInsts().begin()-1;
@@ -103,7 +103,7 @@
//----------------------------------------------------------------------------------------//
-void RegisterAllocator::checkCoalescing(uint32 execCounter, Inst *inst) {
+void RegisterAllocator::checkCoalescing(U_32 execCounter, Inst *inst) {
if (inst->getInstCode() != INST_MOV) return; // if inst is not "mov" - ignore
@@ -201,7 +201,7 @@
RegOpndSet &depOpnds = target->getDepOpnds(); // target can not be assigned on reg used by depOpnds
for (RegOpndSet::iterator it=depOpnds.begin(); it!=depOpnds.end(); it++) {
RegOpnd *opnd = *it;
- int32 location = opnd->getLocation(); // get location of dep opnd
+ I_32 location = opnd->getLocation(); // get location of dep opnd
if (location >= NUM_G_REG) continue; // if opnd is not assigned on reg - continue
usedMask[location] = true; // mark reg busy
}
@@ -209,7 +209,7 @@
Int2OpndMap &coalesceCands = target->getCoalesceCands(); // opnds used in inst like: move target = opnd
for (Int2OpndMap::iterator it=coalesceCands.begin(); it!=coalesceCands.end(); it++) {
RegOpnd *cls = it->second;
- int32 location = cls->getValue(); // get location of coalesce candidate
+ I_32 location = cls->getValue(); // get location of coalesce candidate
if (location > NUM_G_REG) continue; // opnd is not allocated (or allocated on stack)
if (isPreserved && !cls->isCrossCallSite()) continue; // target must be preserved, but cls is scratch
if (usedMask[location] == true) continue; // target can not be allocated on cls location
@@ -217,13 +217,13 @@
return;
}
- int32 location = opndManager->newLocation(opndKind, dataKind, usedMask, isPreserved);
+ I_32 location = opndManager->newLocation(opndKind, dataKind, usedMask, isPreserved);
target->setLocation(location); // assign target new location
}
//----------------------------------------------------------------------------------------//
-void RegisterAllocator::updateAllocSet(Opnd *cand_, uint32 execCounter, QpMask mask) {
+void RegisterAllocator::updateAllocSet(Opnd *cand_, U_32 execCounter, QpMask mask) {
if (cand_->isReg() == false) return; // imm - it does not need allocation
if (cand_->isMem() == true) return; // mem stack - it does not need allocation
Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfRuntimeInterface.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfRuntimeInterface.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfRuntimeInterface.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfRuntimeInterface.cpp Thu May 22 06:33:38 2008
@@ -45,13 +45,13 @@
uint64 sp = jitFrameContext->sp; // get current frame sp
uint64 addr = sp + stackInfo.savedBase; // mem stack offset of first saved gr
- uint32 savedGrMask = stackInfo.savedGrMask; // mask of preserved grs saved on stack
- uint32 savedFrMask = stackInfo.savedFrMask; // mask of preserved frs saved on stack
- uint32 savedBrMask = stackInfo.savedBrMask; // mask of preserved frs saved on stack
+ U_32 savedGrMask = stackInfo.savedGrMask; // mask of preserved grs saved on stack
+ U_32 savedFrMask = stackInfo.savedFrMask; // mask of preserved frs saved on stack
+ U_32 savedBrMask = stackInfo.savedBrMask; // mask of preserved frs saved on stack
// Restore preserved general registers
if(savedGrMask != 0) {
- for(uint32 i=0; i<32; i++) {
+ for(U_32 i=0; i<32; i++) {
if((savedGrMask & 1) == 1) {
jitFrameContext->p_gr[i] = (uint64 *)addr;
addr += 8;
@@ -62,7 +62,7 @@
// Restore preserved floating registers
if(savedFrMask != 0) {
- for(uint32 i=0; i<32; i++) {
+ for(U_32 i=0; i<32; i++) {
if((savedFrMask & 1) == 1) {
jitFrameContext->p_fp[i] = (uint64 *)addr;
addr += 16;
@@ -73,7 +73,7 @@
// Restore preserved branch registers
if(savedBrMask != 0) {
- for(uint32 i=0; i<8; i++) {
+ for(U_32 i=0; i<8; i++) {
if((savedBrMask & 1) == 1) {
jitFrameContext->p_br[i] = (uint64 *)addr;
addr += 8;
@@ -86,28 +86,28 @@
jitFrameContext->sp += stackInfo.memStackSize;
// Restore return pointer
- int32 rpBak = stackInfo.rpBak;
+ I_32 rpBak = stackInfo.rpBak;
if(rpBak != LOCATION_INVALID) {
if(rpBak >= S_BASE) jitFrameContext->p_eip = (uint64 *)(sp + rpBak - S_BASE);
else jitFrameContext->p_eip = jitFrameContext->p_gr[rpBak];
}
// Restore prs
- int32 prBak = stackInfo.prBak;
+ I_32 prBak = stackInfo.prBak;
if(prBak != LOCATION_INVALID) {
if(prBak >= S_BASE) jitFrameContext->preds = *((uint64 *)(sp + prBak - S_BASE));
else jitFrameContext->preds = *(jitFrameContext->p_gr[prBak]);
}
// Restore pfs
- int32 pfsBak = stackInfo.pfsBak;
+ I_32 pfsBak = stackInfo.pfsBak;
if(pfsBak != LOCATION_INVALID) {
if(pfsBak >= S_BASE) jitFrameContext->p_ar_pfs = (uint64 *)(sp + pfsBak - S_BASE);
else jitFrameContext->p_ar_pfs = jitFrameContext->p_gr[pfsBak];
}
// Restore unat
- int32 unatBak = stackInfo.unatBak;
+ I_32 unatBak = stackInfo.unatBak;
if(unatBak != LOCATION_INVALID) {
if(unatBak >= S_BASE) jitFrameContext->ar_unat = *((uint64 *)(sp + unatBak - S_BASE));
else jitFrameContext->ar_unat = *(jitFrameContext->p_gr[unatBak]);
@@ -136,7 +136,7 @@
U_8* infoBlock = methodDesc->getInfoBlock();
U_8* gcInfo = infoBlock + sizeof(StackInfo);
uint64 currIp = *context->p_eip;
- uint32 gcSize = *((uint32 *)gcInfo);
+ U_32 gcSize = *((U_32 *)gcInfo);
// cout << "getGCRootSet for ip " << hex << currIp << dec << " method " << methodDesc->getName() << endl;
U_8* safePoint = findSafePoint(gcInfo, gcSize, currIp);
@@ -145,7 +145,7 @@
//----------------------------------------------------------------------------------------//
-uint32 RuntimeInterface::getInlineDepth(InlineInfoPtr ptr, uint32 offset) {
+U_32 RuntimeInterface::getInlineDepth(InlineInfoPtr ptr, U_32 offset) {
std::cout << "FIXME: IPF::RuntimeInterface::getInlineDepth" << endl;
return 0;
@@ -154,8 +154,8 @@
//----------------------------------------------------------------------------------------//
Method_Handle RuntimeInterface::getInlinedMethod(InlineInfoPtr ptr,
- uint32 offset,
- uint32 inline_depth) {
+ U_32 offset,
+ U_32 inline_depth) {
std::cout << "FIXME: IPF::RuntimeInterface::getInlinedMethod" << endl;
return NULL;
@@ -214,17 +214,17 @@
// GC Root Set
//----------------------------------------------------------------------------------------//
-U_8* RuntimeInterface::findSafePoint(U_8* info, uint32 size, uint64 currIp)
+U_8* RuntimeInterface::findSafePoint(U_8* info, U_32 size, uint64 currIp)
{
- uint32 offset = ROOT_SET_HEADER_SIZE;
+ U_32 offset = ROOT_SET_HEADER_SIZE;
U_8* safePoint = NULL;
- uint32 spSize = 0;
+ U_32 spSize = 0;
uint64 spAddress = 0;
while (offset < size) {
safePoint = info + offset;
- spSize = *((uint32 *)safePoint);
- spAddress = *((uint64 *)(safePoint + sizeof(uint32)));
+ spSize = *((U_32 *)safePoint);
+ spAddress = *((uint64 *)(safePoint + sizeof(U_32)));
if (spAddress == currIp) return safePoint;
offset += spSize;
@@ -241,9 +241,9 @@
const JitFrameContext* context,
U_8* safePoint)
{
- uint32 size = *((uint32 *)(safePoint));
- int32* ptr = (int32 *)(safePoint + SAFE_POINT_HEADER_SIZE);
- int32* maxPtr = (int32 *)(safePoint + size);
+ U_32 size = *((U_32 *)(safePoint));
+ I_32* ptr = (I_32 *)(safePoint + SAFE_POINT_HEADER_SIZE);
+ I_32* maxPtr = (I_32 *)(safePoint + size);
while (ptr < maxPtr) {
if (isMptr(*ptr)) reportMptr(*(ptr++), *(ptr++));
@@ -253,7 +253,7 @@
//----------------------------------------------------------------------------------------//
-void** RuntimeInterface::getContextValue(int32 location) {
+void** RuntimeInterface::getContextValue(I_32 location) {
if (location < 0) {
location = - (location + 1); // if location refers mptr - restore it
@@ -261,7 +261,7 @@
void** ptr = NULL;
if (location >= NUM_G_REG) { // this location points in memory stack
- int32 offset = location - NUM_G_REG; // calc memory stack offset
+ I_32 offset = location - NUM_G_REG; // calc memory stack offset
ptr = (void **)(context->sp + offset); // get pointer on stack value
} else { // general register
ptr = (void **)(context->p_gr[location]); // get pointer on reg value
@@ -271,7 +271,7 @@
//----------------------------------------------------------------------------------------//
-void RuntimeInterface::reportMptr(int32 mptr, int32 base) {
+void RuntimeInterface::reportMptr(I_32 mptr, I_32 base) {
void **mptrPtr = getContextValue(mptr);
void **basePtr = getContextValue(base);
@@ -293,7 +293,7 @@
//----------------------------------------------------------------------------------------//
-void RuntimeInterface::reportBase(int32 base) {
+void RuntimeInterface::reportBase(I_32 base) {
void** basePtr = getContextValue(base);
// uint64 *u1 = (uint64 *)basePtr;
@@ -306,7 +306,7 @@
//----------------------------------------------------------------------------------------//
-bool RuntimeInterface::isMptr(int32 ptr) { return ptr < 0; }
+bool RuntimeInterface::isMptr(I_32 ptr) { return ptr < 0; }
} // IPF
} // Jitrino
Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfRuntimeSupport.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfRuntimeSupport.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfRuntimeSupport.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfRuntimeSupport.cpp Thu May 22 06:33:38 2008
@@ -93,27 +93,27 @@
IPF_LOG << endl << " Make Stack Info" << endl;
StackInfo *stackInfo = makeStackInfo();
- uint32 stackInfoSize = sizeof(StackInfo);
+ U_32 stackInfoSize = sizeof(StackInfo);
IPF_LOG << " stack info size (bytes): " << stackInfoSize << endl;
IPF_LOG << endl << " Make Root Seet Info" << endl;
Uint32Vector rootSetInfo(mm);
makeRootSetInfo(rootSetInfo);
- uint32 rootSetInfoSize = ROOT_SET_HEADER_SIZE + rootSetInfo.size() * sizeof(uint32);
+ U_32 rootSetInfoSize = ROOT_SET_HEADER_SIZE + rootSetInfo.size() * sizeof(U_32);
IPF_LOG << " GC root set info size (bytes): " << rootSetInfoSize << endl;
// create info block
- uint32 infoBlockSize = stackInfoSize + rootSetInfoSize;
+ U_32 infoBlockSize = stackInfoSize + rootSetInfoSize;
U_8* infoBlock = compilationInterface.allocateInfoBlock(infoBlockSize);
// write stack info
*((StackInfo *)infoBlock) = *stackInfo;
// write root set info
- uint32 *gcInfo = (uint32 *)(infoBlock + sizeof(StackInfo));
- uint32 j = ROOT_SET_HEADER_SIZE / sizeof(uint32);
+ U_32 *gcInfo = (U_32 *)(infoBlock + sizeof(StackInfo));
+ U_32 j = ROOT_SET_HEADER_SIZE / sizeof(U_32);
gcInfo[0] = rootSetInfoSize;
- for (uint32 i=0; i<rootSetInfo.size(); i++, j++) {
+ for (U_32 i=0; i<rootSetInfo.size(); i++, j++) {
gcInfo[j] = rootSetInfo[i];
}
}
@@ -233,15 +233,15 @@
StackInfo* RuntimeSupport::makeStackInfo() {
- int32 rpBak = opndManager->rpBak;
- int32 prBak = opndManager->prBak;
- int32 pfsBak = opndManager->pfsBak;
- int32 unatBak = opndManager->unatBak;
- uint32 savedGrMask = opndManager->savedGrMask;
- uint32 savedFrMask = opndManager->savedFrMask;
- uint32 savedBrMask = opndManager->savedBrMask;
- uint32 memStackSize = opndManager->memStackSize;
- int32 savedBase = opndManager->savedBase;
+ I_32 rpBak = opndManager->rpBak;
+ I_32 prBak = opndManager->prBak;
+ I_32 pfsBak = opndManager->pfsBak;
+ I_32 unatBak = opndManager->unatBak;
+ U_32 savedGrMask = opndManager->savedGrMask;
+ U_32 savedFrMask = opndManager->savedFrMask;
+ U_32 savedBrMask = opndManager->savedBrMask;
+ U_32 memStackSize = opndManager->memStackSize;
+ I_32 savedBase = opndManager->savedBase;
if(LOG_ON) {
if (rpBak!=LOCATION_INVALID && rpBak>=S_OUTARG_BASE) { IPF_ERR << " rpBak = " << rpBak << endl; }
@@ -487,8 +487,8 @@
void RuntimeSupport::writeSpInfo(Uint32Vector &info, uint64 spAddr, RegOpndVector &ptrs) {
- uint32 spAddrHight = spAddr; // hight part of spAddr
- uint32 spAddrLow = spAddr >> 32; // low part of spAddr
+ U_32 spAddrHight = spAddr; // hight part of spAddr
+ U_32 spAddrLow = spAddr >> 32; // low part of spAddr
uint16 sizePos = info.size();
info.push_back(0); // push safe point info size (placeholder)
@@ -497,21 +497,21 @@
IPF_LOG << " address: " << hex << spAddr << dec << " alive pointers locations:";
for (uint16 i=0; i<ptrs.size(); i++) {
- int32 location = toInt32(ptrs[i]); // get mptr location
+ I_32 location = toInt32(ptrs[i]); // get mptr location
info.push_back(location); // push base location
IPF_LOG << " " << location;
}
- info[sizePos] = (info.size() - sizePos) * sizeof(uint32);
+ info[sizePos] = (info.size() - sizePos) * sizeof(U_32);
IPF_LOG << " size: " << info[sizePos] << endl;
}
//----------------------------------------------------------------------------------------//
// returns opnd location in form to store in info block
-int32 RuntimeSupport::toInt32(RegOpnd *opnd) {
+I_32 RuntimeSupport::toInt32(RegOpnd *opnd) {
- int32 location = opnd->getValue();
+ I_32 location = opnd->getValue();
if (LOG_ON && location >= S_OUTARG_BASE) IPF_ERR << " location = " << location << endl;
if (opnd->isMem() == true) location += NUM_G_REG;
if (opnd->getDataKind() == DATA_MPTR) location = - (location + 1);
Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfSpillGen.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfSpillGen.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfSpillGen.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfSpillGen.cpp Thu May 22 06:33:38 2008
@@ -117,7 +117,7 @@
// Create scratchOpnd
OpndKind opndKind = stackOpnd->getOpndKind();
DataKind dataKind = stackOpnd->getDataKind();
- int32 scratchReg = getAvailableSpillReg(opndKind);
+ I_32 scratchReg = getAvailableSpillReg(opndKind);
RegOpnd *scratchOpnd = opndManager->newRegOpnd(opndKind, dataKind, scratchReg);
// calculate absolute offset and set it as location on stack opnd
@@ -152,7 +152,7 @@
//----------------------------------------------------------------------------------------//
-int32 SpillGen::getAvailableSpillReg(OpndKind opndKind) {
+I_32 SpillGen::getAvailableSpillReg(OpndKind opndKind) {
switch(opndKind) {
case OPND_G_REG: return getAvailableReg(spillGrMask, NUM_G_REG);
@@ -165,7 +165,7 @@
//----------------------------------------------------------------------------------------//
-int32 SpillGen::getAvailableReg(RegBitSet ®Mask, int16 maskSize) {
+I_32 SpillGen::getAvailableReg(RegBitSet ®Mask, int16 maskSize) {
for(int16 i=0; i<maskSize; i++) if(regMask[i] == 1) { regMask[i]=0; return i; }
IPF_ERR << " No available spill reg" << endl;
@@ -226,7 +226,7 @@
void SpillGen::spillBr(RegOpnd *scratchOpnd) {
- int32 bufReg = getAvailableSpillReg(OPND_G_REG);
+ I_32 bufReg = getAvailableSpillReg(OPND_G_REG);
Opnd *bufOpnd = opndManager->newRegOpnd(OPND_G_REG, DATA_B, bufReg);
Inst *mov = new(mm) Inst(mm, INST_MOV, p0, bufOpnd, scratchOpnd);
Inst *st = new(mm) Inst(mm, INST_ST, CMPLT_SZ_8, p0, stackAddr, bufOpnd);
@@ -246,7 +246,7 @@
void SpillGen::spillPr(RegOpnd *scratchOpnd) {
- int32 bufReg = getAvailableSpillReg(OPND_G_REG);
+ I_32 bufReg = getAvailableSpillReg(OPND_G_REG);
Opnd *bufOpnd = opndManager->newRegOpnd(OPND_G_REG, DATA_P, bufReg);
Opnd *imm1 = opndManager->newImm(1);
Inst *mov1 = new(mm) Inst(mm, INST_MOV, p0, bufOpnd, opndManager->getR0());
@@ -279,7 +279,7 @@
Inst *ld = new(mm) Inst(mm, INST_LD, completer, p0, scratchOpnd, stackAddr);
fillCode.push_back(ld);
- // Create sxt instruction for int32 data type
+ // Create sxt instruction for I_32 data type
if(scratchOpnd->getDataKind() == DATA_I32) {
Inst *sxt = new(mm) Inst(mm, INST_SXT, CMPLT_XSZ_4, p0, scratchOpnd, scratchOpnd);
fillCode.push_back(sxt);
@@ -317,7 +317,7 @@
void SpillGen::fillBr(RegOpnd *scratchOpnd) {
- int32 bufReg = getAvailableSpillReg(OPND_G_REG);
+ I_32 bufReg = getAvailableSpillReg(OPND_G_REG);
Opnd *bufOpnd = opndManager->newRegOpnd(OPND_G_REG, DATA_I64, bufReg);
Inst *ld = new(mm) Inst(mm, INST_LD, CMPLT_SZ_8, p0, bufOpnd, stackAddr);
Inst *mov = new(mm) Inst(mm, INST_MOV, p0, scratchOpnd, bufOpnd);
@@ -336,7 +336,7 @@
void SpillGen::fillPr(RegOpnd *scratchOpnd) {
- int32 bufReg = getAvailableSpillReg(OPND_G_REG);
+ I_32 bufReg = getAvailableSpillReg(OPND_G_REG);
Opnd *bufOpnd = opndManager->newRegOpnd(OPND_G_REG, DATA_P, bufReg);
Inst *ld = new(mm) Inst(mm, INST_LD, CMPLT_SZ_1, p0, bufOpnd, stackAddr);
Inst *cmp = new(mm) Inst(mm, INST_CMP, CMPLT_CMP_CREL_NE, p0, scratchOpnd, p0, bufOpnd);
Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfVerifier.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfVerifier.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfVerifier.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/IpfVerifier.cpp Thu May 22 06:33:38 2008
@@ -306,7 +306,7 @@
break;
case INST_FCVT_XUF:
if (IS_C(2)) return false;
- for (uint32 i=0 ; IS_C(i) ; i++) {
+ for (U_32 i=0 ; IS_C(i) ; i++) {
switch (C(i)) {
case CMPLT_PC_SINGLE:
case CMPLT_PC_DOUBLE:
@@ -323,7 +323,7 @@
if (IS_FR(1) && IS_FR(2)) return true;
break;
case INST_FMA:
- for (uint32 i=0 ; IS_C(i) ; i++) {
+ for (U_32 i=0 ; IS_C(i) ; i++) {
switch (C(i)) {
case CMPLT_PC_SINGLE:
case CMPLT_PC_DOUBLE:
@@ -347,7 +347,7 @@
case INST_FPMAX:
case INST_FPAMIN:
case INST_FPAMAX:
- for (uint32 i=0 ; IS_C(i) ; i++) {
+ for (U_32 i=0 ; IS_C(i) ; i++) {
switch (C(i)) {
case CMPLT_SF0:
case CMPLT_SF1:
@@ -361,7 +361,7 @@
if (IS_FR(1) && IS_FR(2) && IS_FR(3)) return true;
break;
case INST_FPCMP:
- for (uint32 i=0 ; IS_C(i) ; i++) {
+ for (U_32 i=0 ; IS_C(i) ; i++) {
switch (C(i)) {
case CMPLT_SF0:
case CMPLT_SF1:
@@ -395,7 +395,7 @@
if (IS_FR(1) && IS_FR(2) && !IS_O(3) && !IS_C(0)) return true;
break;
case INST_FNMA:
- for ( uint32 i=0 ; IS_C(i) ; i++ ) {
+ for ( U_32 i=0 ; IS_C(i) ; i++ ) {
switch(C(i)) {
case CMPLT_PC_SINGLE:
case CMPLT_PC_DOUBLE:
@@ -412,7 +412,7 @@
if (IS_FR(1) && IS_FR(2) && IS_FR(3) && IS_FR(4) && !IS_O(5)) return true;
break;
case INST_FNORM:
- for ( uint32 i=0 ; IS_C(i) ; i++ ) {
+ for ( U_32 i=0 ; IS_C(i) ; i++ ) {
switch(C(i)) {
case CMPLT_PC_SINGLE:
case CMPLT_PC_DOUBLE:
@@ -923,7 +923,7 @@
//----------------------------------------------------------------------------//
bool IpfVerifier::ldx(string * res, Inst * inst, InstCode icode, OpndVector & opnds, CompVector & cmpls) {
- for (uint32 i=0 ; IS_C(i) ; i++ ) {
+ for (U_32 i=0 ; IS_C(i) ; i++ ) {
switch (C(i)) {
case CMPLT_SZ_1:
case CMPLT_SZ_2:
@@ -968,7 +968,7 @@
//----------------------------------------------------------------------------//
bool IpfVerifier::ldfx(string * res, Inst * inst, InstCode icode, OpndVector & opnds, CompVector & cmpls) {
- for (uint32 i=0 ; IS_C(i) ; i++ ) {
+ for (U_32 i=0 ; IS_C(i) ; i++ ) {
switch (C(i)) {
case CMPLT_FSZ_E:
case CMPLT_FSZ_S:
@@ -1012,7 +1012,7 @@
if (icode==INST_MOV && !IS_O(3) && ((IS_GR(1) && IS_BR(2)) || (IS_BR(1) && IS_GR(2))))
return true;
if ((icode==INST_MOV || icode==INST_MOV_RET) && IS_O(3) && IS_BR(1) && IS_GR(2) && IS_IMM13(3)) {
- for (uint32 i=0 ; IS_C(i) ; i++){
+ for (U_32 i=0 ; IS_C(i) ; i++){
switch (C(i)) {
case CMPLT_IH_NOT_IMP:
case CMPLT_IH_IMP:
Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfCfg.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfCfg.h?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfCfg.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfCfg.h Thu May 22 06:33:38 2008
@@ -52,8 +52,8 @@
class Constant {
public:
Constant(DataKind);
- void setOffset(int32 offset_) { offset = offset_; }
- int32 getOffset() { return offset; }
+ void setOffset(I_32 offset_) { offset = offset_; }
+ I_32 getOffset() { return offset; }
void setAddress(void *address_) { address = address_; }
void *getAddress() { return address; }
void setSize(int16 size_) { size = size_; }
@@ -63,7 +63,7 @@
protected:
void *address;
- int32 offset;
+ I_32 offset;
int16 size;
DataKind dataKind;
};
@@ -135,7 +135,7 @@
class Opnd : public CG_OpndHandle {
public:
- Opnd(uint32, OpndKind=OPND_INVALID, DataKind=DATA_INVALID, int64=0);
+ Opnd(U_32, OpndKind=OPND_INVALID, DataKind=DATA_INVALID, int64=0);
uint16 getId() { return id; }
OpndKind getOpndKind() { return opndKind; }
@@ -172,18 +172,18 @@
class RegOpnd : public Opnd {
public:
- RegOpnd(MemoryManager&, uint32, OpndKind, DataKind, int32=LOCATION_INVALID);
+ RegOpnd(MemoryManager&, U_32, OpndKind, DataKind, I_32=LOCATION_INVALID);
int64 getValue();
- void setLocation(int32 value_) { value = value_; }
- int32 getLocation() { return value; }
+ void setLocation(I_32 value_) { value = value_; }
+ I_32 getLocation() { return value; }
QpMask getQpMask() { return qpMask; }
void andQpMask(QpMask mask) { qpMask &= mask; }
void orQpMask(QpMask mask) { qpMask |= mask; }
bool isAlive(QpMask mask) { return mask & qpMask; }
- void incSpillCost(uint32 spillCost_) { spillCost += spillCost_; }
- uint32 getSpillCost() { return spillCost; }
+ void incSpillCost(U_32 spillCost_) { spillCost += spillCost_; }
+ U_32 getSpillCost() { return spillCost; }
RegOpndSet &getDepOpnds() { return depOpnds; }
void insertDepOpnds(RegOpndSet &opnds) { depOpnds.insert(opnds.begin(), opnds.end()); }
void insertDepOpnd(RegOpnd*);
@@ -191,14 +191,14 @@
bool isCrossCallSite() { return crossCallSite; }
Int2OpndMap &getCoalesceCands() { return coalesceCands; }
- void addCoalesceCand(uint32 execCnt, RegOpnd *opnd) { coalesceCands.insert(make_pair(execCnt, opnd)); }
+ void addCoalesceCand(U_32 execCnt, RegOpnd *opnd) { coalesceCands.insert(make_pair(execCnt, opnd)); }
virtual ~RegOpnd() {}
protected:
QpMask qpMask; // mask of predicate spaces opnd alive in
// These fields are for register allocation algorithm
- uint32 spillCost; // number of opnd uses
+ U_32 spillCost; // number of opnd uses
RegOpndSet depOpnds; // opnds which can not be placed in the same reg with the opnd
bool crossCallSite; // opnd live range crosses call site
Int2OpndMap coalesceCands; //
@@ -210,7 +210,7 @@
class ConstantRef : public Opnd {
public:
- ConstantRef::ConstantRef(uint32 id, Constant *constant, DataKind dataKind = DATA_CONST_REF) :
+ ConstantRef::ConstantRef(U_32 id, Constant *constant, DataKind dataKind = DATA_CONST_REF) :
Opnd(id, OPND_IMM, dataKind, LOCATION_INVALID), constant(constant) {}
int64 getValue() { return (int64)constant->getAddress(); }
@@ -226,7 +226,7 @@
class NodeRef : public Opnd {
public:
- NodeRef(uint32 id, BbNode *node = NULL)
+ NodeRef(U_32 id, BbNode *node = NULL)
: Opnd(id, OPND_IMM, DATA_NODE_REF, LOCATION_INVALID), node(node) {}
int64 getValue();
@@ -243,7 +243,7 @@
class MethodRef : public Opnd {
public:
- MethodRef(uint32 id, MethodDesc *method = NULL)
+ MethodRef(U_32 id, MethodDesc *method = NULL)
: Opnd(id, OPND_IMM, DATA_METHOD_REF, LOCATION_INVALID), method(method) {}
int64 getValue();
@@ -278,21 +278,21 @@
CompVector &getComps() { return compList; }
Completer getComp(uint16 num) { return compList[num]; }
void addComp(Completer comp_) { compList.push_back(comp_); }
- void setComp(uint32 num, Completer comp_) { compList[num] = comp_; }
+ void setComp(U_32 num, Completer comp_) { compList[num] = comp_; }
void addOpnd(Opnd *opnd_) { opndList.push_back(opnd_); }
void removeLastOpnd() { opndList.pop_back(); }
OpndVector &getOpnds() { return opndList; }
- void setOpnd(uint32 num, Opnd *opnd_) { opndList[num] = opnd_; }
- Opnd *getOpnd(uint32 num) { return opndList[num]; }
+ void setOpnd(U_32 num, Opnd *opnd_) { opndList[num] = opnd_; }
+ Opnd *getOpnd(U_32 num) { return opndList[num]; }
uint16 getNumDst() { return Encoder::getNumDst(instCode); }
uint16 getNumOpnd() { return Encoder::getNumOpnd(instCode); }
char *getInstMnemonic() { return Encoder::getMnemonic(instCode); }
char *getCompMnemonic(Completer comp) { return Encoder::getMnemonic(comp); }
- uint32 getAddr() { return addr; }
- void setAddr(uint32 addr_) { addr = addr_; }
+ U_32 getAddr() { return addr; }
+ void setAddr(U_32 addr_) { addr = addr_; }
bool isBr();
bool isCall();
@@ -303,7 +303,7 @@
InstCode instCode;
CompVector compList;
OpndVector opndList;
- uint32 addr; // addr == <bundle's offset in basic block> + <slot's index>
+ U_32 addr; // addr == <bundle's offset in basic block> + <slot's index>
};
//========================================================================================//
@@ -338,13 +338,13 @@
class ExceptionEdge : public Edge {
public:
- ExceptionEdge(Node*, Node*, double, Type*, uint32);
+ ExceptionEdge(Node*, Node*, double, Type*, U_32);
Type *getExceptionType() { return exceptionType; }
- uint32 getPriority() { return priority; }
+ U_32 getPriority() { return priority; }
protected:
Type *exceptionType;
- uint32 priority;
+ U_32 priority;
};
//========================================================================================//
@@ -353,7 +353,7 @@
class Node {
public:
- Node(MemoryManager&, uint32, uint32, NodeKind = NODE_INVALID);
+ Node(MemoryManager&, U_32, U_32, NodeKind = NODE_INVALID);
void remove();
void addEdge(Edge *edge);
@@ -366,8 +366,8 @@
void mergeOutLiveSets(RegOpndSet &resultSet);
uint16 getId() { return id; }
- void setExecCounter(uint32 execCounter_) { execCounter = execCounter_; }
- uint32 getExecCounter() { return execCounter; }
+ void setExecCounter(U_32 execCounter_) { execCounter = execCounter_; }
+ U_32 getExecCounter() { return execCounter; }
void setNodeKind(NodeKind kind_) { nodeKind = kind_; }
NodeKind getNodeKind() { return nodeKind; }
EdgeVector &getInEdges() { return inEdges; }
@@ -383,7 +383,7 @@
protected:
uint16 id; // node unique Id
- uint32 execCounter; // profile info (how many times the node executes)
+ U_32 execCounter; // profile info (how many times the node executes)
NodeKind nodeKind; //
EdgeVector inEdges; // in edges list
EdgeVector outEdges; // out edges list
@@ -398,7 +398,7 @@
class BbNode : public Node {
public:
- BbNode(MemoryManager&, uint32, uint32);
+ BbNode(MemoryManager&, U_32, U_32);
void addInst(Inst *inst) { insts.push_back(inst); }
void removeInst(Inst *inst) { insts.erase(find(insts.begin(),insts.end(),inst)); }
InstVector &getInsts() { return insts; }
Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfCodeLayouter.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfCodeLayouter.h?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfCodeLayouter.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfCodeLayouter.h Thu May 22 06:33:38 2008
@@ -57,7 +57,7 @@
void pushBack(Chain*, Node*);
void pushFront(Chain*, Node*);
void layoutNodes();
- uint32 calculateChainWeight(Chain*);
+ U_32 calculateChainWeight(Chain*);
// set branch targets
void setBranchTargets();
Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfCodeSelector.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfCodeSelector.h?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfCodeSelector.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfCodeSelector.h Thu May 22 06:33:38 2008
@@ -43,9 +43,9 @@
IpfMethodCodeSelector(Cfg&, CompilationInterface&);
MethodDesc *getMethodDesc();
- void genVars(uint32, VarCodeSelector&);
+ void genVars(U_32, VarCodeSelector&);
void setMethodDesc(MethodDesc*);
- void genCFG(uint32, CFGCodeSelector&, bool);
+ void genCFG(U_32, CFGCodeSelector&, bool);
// void setProfileInfo(CodeProfiler*) {}
virtual ~IpfMethodCodeSelector() {}
@@ -65,8 +65,8 @@
class IpfVarCodeSelector : public VarCodeSelector::Callback {
public:
IpfVarCodeSelector(Cfg&, OpndVector&);
- uint32 defVar(Type*, bool, bool);
- void setManagedPointerBase(uint32, uint32);
+ U_32 defVar(Type*, bool, bool);
+ void setManagedPointerBase(U_32, U_32);
protected:
MemoryManager &mm;
@@ -82,19 +82,19 @@
class IpfCfgCodeSelector : public CFGCodeSelector::Callback {
public:
IpfCfgCodeSelector(Cfg&, NodeVector&, OpndVector&, CompilationInterface&);
- uint32 genDispatchNode(uint32, uint32, const StlVector<MethodDesc*>&, double);
- uint32 genBlock(uint32, uint32, BlockKind, BlockCodeSelector&, double);
- uint32 genUnwindNode(uint32, uint32, double);
- uint32 genExitNode(uint32, double);
- void genUnconditionalEdge(uint32, uint32, double);
- void genTrueEdge(uint32, uint32, double);
- void genFalseEdge(uint32, uint32, double);
- void genSwitchEdges(uint32, uint32, uint32*, double*, uint32);
- void genExceptionEdge(uint32, uint32, double);
- void genCatchEdge(uint32, uint32, uint32, Type*, double);
- void genExitEdge(uint32, uint32, double);
- void setLoopInfo(uint32, bool, bool, uint32);
- void setPersistentId(uint32, uint32);
+ U_32 genDispatchNode(U_32, U_32, const StlVector<MethodDesc*>&, double);
+ U_32 genBlock(U_32, U_32, BlockKind, BlockCodeSelector&, double);
+ U_32 genUnwindNode(U_32, U_32, double);
+ U_32 genExitNode(U_32, double);
+ void genUnconditionalEdge(U_32, U_32, double);
+ void genTrueEdge(U_32, U_32, double);
+ void genFalseEdge(U_32, U_32, double);
+ void genSwitchEdges(U_32, U_32, U_32*, double*, U_32);
+ void genExceptionEdge(U_32, U_32, double);
+ void genCatchEdge(U_32, U_32, U_32, Type*, double);
+ void genExitEdge(U_32, U_32, double);
+ void setLoopInfo(U_32, bool, bool, U_32);
+ void setPersistentId(U_32, U_32);
virtual ~IpfCfgCodeSelector() {}
protected:
@@ -142,19 +142,19 @@
CG_OpndHandle *shl (IntegerOp::Types, CG_OpndHandle*, CG_OpndHandle*);
CG_OpndHandle *shr (IntegerOp::Types, CG_OpndHandle*, CG_OpndHandle*);
CG_OpndHandle *shru (IntegerOp::Types, CG_OpndHandle*, CG_OpndHandle*);
- CG_OpndHandle *shladd(IntegerOp::Types, CG_OpndHandle*, uint32, CG_OpndHandle*);
+ CG_OpndHandle *shladd(IntegerOp::Types, CG_OpndHandle*, U_32, CG_OpndHandle*);
CG_OpndHandle *convToInt(ConvertToIntOp::Types, bool, bool, ConvertToIntOp::OverflowMod, Type*, CG_OpndHandle*);
CG_OpndHandle *convToFp(ConvertToFpOp::Types, Type*, CG_OpndHandle*);
- CG_OpndHandle *ldc_i4(int32);
+ CG_OpndHandle *ldc_i4(I_32);
CG_OpndHandle *ldc_i8(int64);
CG_OpndHandle *ldc_s(float);
CG_OpndHandle *ldc_d(double);
CG_OpndHandle *ldnull(bool);
- CG_OpndHandle *ldVar(Type*, uint32);
- void stVar(CG_OpndHandle*, uint32);
- CG_OpndHandle *defArg(uint32, Type*);
+ CG_OpndHandle *ldVar(Type*, U_32);
+ void stVar(CG_OpndHandle*, U_32);
+ CG_OpndHandle *defArg(U_32, Type*);
CG_OpndHandle *cmp (CompareOp::Operators, CompareOp::Types, CG_OpndHandle*, CG_OpndHandle*, int);
CG_OpndHandle *czero (CompareZeroOp::Types, CG_OpndHandle*);
@@ -170,11 +170,11 @@
void branch(CompareOp::Operators, CompareOp::Types, CG_OpndHandle*, CG_OpndHandle*);
void bzero (CompareZeroOp::Types, CG_OpndHandle*);
void bnzero(CompareZeroOp::Types, CG_OpndHandle*);
- void tableSwitch(CG_OpndHandle*, uint32);
+ void tableSwitch(CG_OpndHandle*, U_32);
- CG_OpndHandle *call(uint32, CG_OpndHandle**, Type*, MethodDesc*);
- CG_OpndHandle *tau_call(uint32, CG_OpndHandle**, Type*, MethodDesc*, CG_OpndHandle*, CG_OpndHandle*);
- CG_OpndHandle *tau_calli(uint32,CG_OpndHandle**, Type*, CG_OpndHandle*, CG_OpndHandle*, CG_OpndHandle*);
+ CG_OpndHandle *call(U_32, CG_OpndHandle**, Type*, MethodDesc*);
+ CG_OpndHandle *tau_call(U_32, CG_OpndHandle**, Type*, MethodDesc*, CG_OpndHandle*, CG_OpndHandle*);
+ CG_OpndHandle *tau_calli(U_32,CG_OpndHandle**, Type*, CG_OpndHandle*, CG_OpndHandle*, CG_OpndHandle*);
void ret();
void ret(CG_OpndHandle*);
@@ -185,7 +185,7 @@
void throwException(CG_OpndHandle*, bool);
void throwException(ObjectType* excType);// generater code to throw noted type exception
void throwSystemException(CompilationInterface::SystemExceptionId);
- void throwLinkingException(Class_Handle, uint32, uint32);
+ void throwLinkingException(Class_Handle, U_32, U_32);
CG_OpndHandle *catchException(Type*);
CG_OpndHandle *tau_checkNull(CG_OpndHandle *, bool);
@@ -202,7 +202,7 @@
void tau_stInd(CG_OpndHandle*, CG_OpndHandle*, Type::Tag, bool, CG_OpndHandle*, CG_OpndHandle*, CG_OpndHandle*);
CG_OpndHandle *tau_ldInd(Type*, CG_OpndHandle*, Type::Tag, bool, bool, CG_OpndHandle*, CG_OpndHandle*);
- CG_OpndHandle *ldString(MethodDesc*, uint32, bool);
+ CG_OpndHandle *ldString(MethodDesc*, U_32, bool);
CG_OpndHandle *ldLockAddr(CG_OpndHandle*);
CG_OpndHandle *tau_ldVirtFunAddr(Type*, CG_OpndHandle*, MethodDesc*, CG_OpndHandle*);
CG_OpndHandle *tau_ldVTableAddr(Type*, CG_OpndHandle*, CG_OpndHandle*);
@@ -214,7 +214,7 @@
void initType(Type*);
CG_OpndHandle *newObj(ObjectType*);
CG_OpndHandle *newArray(ArrayType*, CG_OpndHandle*);
- CG_OpndHandle *newMultiArray(ArrayType*, uint32, CG_OpndHandle**);
+ CG_OpndHandle *newMultiArray(ArrayType*, U_32, CG_OpndHandle**);
CG_OpndHandle *ldElemBaseAddr(CG_OpndHandle*);
CG_OpndHandle *addElemIndex(Type *, CG_OpndHandle *, CG_OpndHandle *);
CG_OpndHandle *tau_arrayLen(Type*, ArrayType*, Type*, CG_OpndHandle*, CG_OpndHandle*, CG_OpndHandle*);
@@ -238,7 +238,7 @@
CG_OpndHandle *tauEdge() { return opndManager->getTau(); }
CG_OpndHandle *tauUnsafe() { return opndManager->getTau(); }
CG_OpndHandle *tauSafe() { return opndManager->getTau(); }
- CG_OpndHandle *tauAnd(uint32, CG_OpndHandle**) { return opndManager->getTau(); }
+ CG_OpndHandle *tauAnd(U_32, CG_OpndHandle**) { return opndManager->getTau(); }
void opndMaybeGlobal(CG_OpndHandle* opnd) {}
void setCurrentPersistentId(PersistentInstructionId) {}
void clearCurrentPersistentId() {}
@@ -265,23 +265,23 @@
CG_OpndHandle *addOffset(Type*, CG_OpndHandle*, CG_OpndHandle*) { NOT_IMPLEMENTED_C("addOffset") }
CG_OpndHandle *ldElemAddr(CG_OpndHandle*,CG_OpndHandle*) { NOT_IMPLEMENTED_C("ldElemAddr") }
CG_OpndHandle *ldStatic(Type*, FieldDesc*, Type::Tag, bool) { NOT_IMPLEMENTED_C("ldStatic") }
- CG_OpndHandle *ldVarAddr(uint32) { NOT_IMPLEMENTED_C("ldVarAddr") }
- CG_OpndHandle *ldToken(Type*, MethodDesc*, uint32) { NOT_IMPLEMENTED_C("ldToken") }
+ CG_OpndHandle *ldVarAddr(U_32) { NOT_IMPLEMENTED_C("ldVarAddr") }
+ CG_OpndHandle *ldToken(Type*, MethodDesc*, U_32) { NOT_IMPLEMENTED_C("ldToken") }
CG_OpndHandle *tau_cast(ObjectType*, CG_OpndHandle*, CG_OpndHandle*) { NOT_IMPLEMENTED_C("tau_cast") }
CG_OpndHandle *tau_asType(ObjectType*, CG_OpndHandle*, CG_OpndHandle*) { NOT_IMPLEMENTED_C("tau_asType") }
CG_OpndHandle *box(ObjectType*, CG_OpndHandle*) { NOT_IMPLEMENTED_C("box") }
CG_OpndHandle *unbox(Type*, CG_OpndHandle*) { NOT_IMPLEMENTED_C("unbox") }
CG_OpndHandle *ldValueObj(Type*, CG_OpndHandle*) { NOT_IMPLEMENTED_C("ldValueObj") }
CG_OpndHandle *tau_ckfinite(CG_OpndHandle*) { NOT_IMPLEMENTED_C("tau_ckfinite") }
- CG_OpndHandle *callhelper(uint32, CG_OpndHandle**, Type*, JitHelperCallOp::Id) { NOT_IMPLEMENTED_C("callhelper") }
- CG_OpndHandle *tau_callvirt(uint32, CG_OpndHandle**, Type*, MethodDesc*, CG_OpndHandle*, CG_OpndHandle*) { NOT_IMPLEMENTED_C("tau_callvirt") }
+ CG_OpndHandle *callhelper(U_32, CG_OpndHandle**, Type*, JitHelperCallOp::Id) { NOT_IMPLEMENTED_C("callhelper") }
+ CG_OpndHandle *tau_callvirt(U_32, CG_OpndHandle**, Type*, MethodDesc*, CG_OpndHandle*, CG_OpndHandle*) { NOT_IMPLEMENTED_C("tau_callvirt") }
CG_OpndHandle *select(CompareOp::Types, CG_OpndHandle*, CG_OpndHandle*, CG_OpndHandle*) { NOT_IMPLEMENTED_C("select") }
CG_OpndHandle *cmp3(CompareOp::Operators,CompareOp::Types, CG_OpndHandle*, CG_OpndHandle*) { NOT_IMPLEMENTED_C("cmp3") }
CG_OpndHandle *tau_optimisticBalancedMonitorEnter(CG_OpndHandle*, CG_OpndHandle*, CG_OpndHandle*) { NOT_IMPLEMENTED_C("tau_optimisticBalancedMonitorEnter") }
CG_OpndHandle *addOffsetPlusHeapbase(Type*, CG_OpndHandle*, CG_OpndHandle*) { NOT_IMPLEMENTED_C("addOffsetPlusHeapbase") }
CG_OpndHandle *tau_ldField(Type*, CG_OpndHandle*, Type::Tag, FieldDesc*, bool, CG_OpndHandle*, CG_OpndHandle*) { NOT_IMPLEMENTED_C("tau_ldField") }
CG_OpndHandle *tau_ldElem(Type*, CG_OpndHandle*, CG_OpndHandle*, bool, CG_OpndHandle*, CG_OpndHandle*) { NOT_IMPLEMENTED_C("tau_ldElem") }
- void incCounter(Type*, uint32) { NOT_IMPLEMENTED_V("incCounter") }
+ void incCounter(Type*, U_32) { NOT_IMPLEMENTED_V("incCounter") }
void incRecursionCount(CG_OpndHandle*, CG_OpndHandle*) { NOT_IMPLEMENTED_V("incRecursionCount") }
void monitorEnterFence(CG_OpndHandle*) { NOT_IMPLEMENTED_V("monitorEnterFence") }
void monitorExitFence(CG_OpndHandle*) { NOT_IMPLEMENTED_V("monitorExitFence") }
@@ -290,7 +290,7 @@
void copyValueObj(Type*, CG_OpndHandle*, CG_OpndHandle*) { NOT_IMPLEMENTED_V("copyValueObj") }
void prefetch(CG_OpndHandle*) { NOT_IMPLEMENTED_V("prefetch") }
void jump() { NOT_IMPLEMENTED_V("jump") }
- void throwLazyException(uint32, CG_OpndHandle**, MethodDesc*) { NOT_IMPLEMENTED_V("throwLazyException") }
+ void throwLazyException(U_32, CG_OpndHandle**, MethodDesc*) { NOT_IMPLEMENTED_V("throwLazyException") }
void tau_stStatic(CG_OpndHandle*, FieldDesc*, Type::Tag, bool, CG_OpndHandle*) { NOT_IMPLEMENTED_V("tau_stStatic") }
void tau_stField(CG_OpndHandle*, CG_OpndHandle*, Type::Tag, FieldDesc*, bool, CG_OpndHandle*, CG_OpndHandle*, CG_OpndHandle*) { NOT_IMPLEMENTED_V("tau_stField") }
void tau_stElem(CG_OpndHandle*, CG_OpndHandle*, CG_OpndHandle*, bool, CG_OpndHandle*, CG_OpndHandle*, CG_OpndHandle*) { NOT_IMPLEMENTED_V("tau_stElem") }
@@ -300,7 +300,7 @@
// TRANSITION
//---------------------------------------------------------------------------//
- CG_OpndHandle* callvmhelper(uint32, CG_OpndHandle**, Type*
+ CG_OpndHandle* callvmhelper(U_32, CG_OpndHandle**, Type*
, VM_RT_SUPPORT) { NOT_IMPLEMENTED_C("unbox") }
CG_OpndHandle* convUPtrToObject(ObjectType*, CG_OpndHandle*) { NOT_IMPLEMENTED_C("convUPtrToObject") }
@@ -352,9 +352,9 @@
CG_OpndHandle *op4=NULL, CG_OpndHandle *op5=NULL, CG_OpndHandle *op6=NULL);
// CG helper methods
- void directCall(uint32, Opnd**, RegOpnd*, Opnd*, RegOpnd*, Completer=CMPLT_WH_SPTK);
- void indirectCall(uint32, Opnd**, RegOpnd*, RegOpnd*, RegOpnd*, Completer=CMPLT_WH_SPTK);
- void makeCallArgs(uint32, Opnd**, Inst*, RegOpnd*);
+ void directCall(U_32, Opnd**, RegOpnd*, Opnd*, RegOpnd*, Completer=CMPLT_WH_SPTK);
+ void indirectCall(U_32, Opnd**, RegOpnd*, RegOpnd*, RegOpnd*, Completer=CMPLT_WH_SPTK);
+ void makeCallArgs(U_32, Opnd**, Inst*, RegOpnd*);
RegOpnd *makeConvOpnd(RegOpnd*);
void makeRetVal(RegOpnd*, RegOpnd*, RegOpnd*);
Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfEmitter.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfEmitter.h?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfEmitter.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ipf/include/IpfEmitter.h Thu May 22 06:33:38 2008
@@ -95,9 +95,9 @@
* tmpl = template field encoding
*/
struct BundleDescription {
- uint32 slots;
- uint32 stops;
- uint32 tmpl;
+ U_32 slots;
+ U_32 stops;
+ U_32 tmpl;
};
//============================================================================//
@@ -127,12 +127,12 @@
//============================================================================//
class Bundle {
public:
- Bundle(Cfg& cfg, uint32 tmpl, Inst *, Inst *, Inst *);
+ Bundle(Cfg& cfg, U_32 tmpl, Inst *, Inst *, Inst *);
Inst * getSlot(int si) { return slot[si]; };
- uint32 getTmplIndex() { return indxtmpl; };
- uint32 getTmpl() { return BundleDesc[indxtmpl].tmpl; };
- bool hasStop() { uint32 t = getTmpl();
+ U_32 getTmplIndex() { return indxtmpl; };
+ U_32 getTmpl() { return BundleDesc[indxtmpl].tmpl; };
+ bool hasStop() { U_32 t = getTmpl();
if (t%2==1 || t==0x2 || t==0xa) return true; return false; };
void emitBundleGeneral(void *);
void emitBundleExtended(void *);
@@ -145,7 +145,7 @@
static const BundleDescription BundleDesc[TEMPLATES_COUNT];
protected:
- uint32 indxtmpl;
+ U_32 indxtmpl;
Inst *slot[IPF_SLOTS_COUNT];
};
@@ -157,7 +157,7 @@
branches=new(mm) vector<int>;
};
- void addBundle(uint32 itmpl, Inst *i0, Inst *i1, Inst *i2) {
+ void addBundle(U_32 itmpl, Inst *i0, Inst *i1, Inst *i2) {
push_back(new(mm) Bundle(cfg, itmpl, i0, i1, i2));
if(Encoder::isBranchInst(i0) || Encoder::isBranchInst(i1) || Encoder::isBranchInst(i2)) {
branches->push_back(size() - 1);