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 [3/19] - in /harmony/enhanced/drlvm/trunk/vm: em/src/
gc_gen/src/common/ gc_gen/src/mark_compact/ gc_gen/src/mark_sweep/
gc_gen/src/semi_space/ gc_gen/src/trace_forward/ include/open/
interpreter/src/ jitrino/src/codegenerator/ jitr...
Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CallingConvention.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CallingConvention.h?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CallingConvention.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CallingConvention.h Thu May 22 06:33:38 2008
@@ -78,10 +78,10 @@
struct OpndInfo
{
- uint32 typeTag;
- uint32 slotCount;
+ U_32 typeTag;
+ U_32 slotCount;
bool isReg;
- uint32 slots[4];
+ U_32 slots[4];
};
//--------------------------------------------------------------
@@ -96,7 +96,7 @@
/** Fills the infos array with information how incoming arguments or return values are passed
according to this calling convention
*/
- virtual void getOpndInfo(ArgKind kind, uint32 argCount, OpndInfo * infos) const =0;
+ virtual void getOpndInfo(ArgKind kind, U_32 argCount, OpndInfo * infos) const =0;
/** Returns a mask describing registers of regKind which are to be preserved by a callee
*/
@@ -113,7 +113,7 @@
/**
* Defines stack pointer alignment on method enter.
*/
- virtual uint32 getStackAlignment()const { return 0; }
+ virtual U_32 getStackAlignment()const { return 0; }
/**
* Maps a string representation of CallingConvention to the
@@ -140,7 +140,7 @@
public:
virtual ~STDCALLCallingConventionIA32() {}
- virtual void getOpndInfo(ArgKind kind, uint32 argCount, OpndInfo * infos) const;
+ virtual void getOpndInfo(ArgKind kind, U_32 argCount, OpndInfo * infos) const;
virtual Constraint getCalleeSavedRegs(OpndKind regKind) const;
virtual bool calleeRestoresStack() const{ return true; }
virtual bool pushLastToFirst() const { return true; }
@@ -152,10 +152,10 @@
public:
virtual ~STDCALLCallingConventionEM64T() {}
- virtual void getOpndInfo(ArgKind kind, uint32 argCount, OpndInfo * infos) const;
+ virtual void getOpndInfo(ArgKind kind, U_32 argCount, OpndInfo * infos) const;
virtual Constraint getCalleeSavedRegs(OpndKind regKind) const;
virtual bool calleeRestoresStack() const { return false; }
- virtual uint32 getStackAlignment() const { return STACK_ALIGNMENT; }
+ virtual U_32 getStackAlignment() const { return STACK_ALIGNMENT; }
virtual bool pushLastToFirst() const { return true; }
};
@@ -191,9 +191,9 @@
{
public:
virtual ~ManagedCallingConventionIA32() {}
- virtual void getOpndInfo(ArgKind kind, uint32 argCount, OpndInfo * infos) const;
+ virtual void getOpndInfo(ArgKind kind, U_32 argCount, OpndInfo * infos) const;
virtual bool pushLastToFirst( ) const { return false; }
- virtual uint32 getStackAlignment() const { return STACK_ALIGNMENT; }
+ virtual U_32 getStackAlignment() const { return STACK_ALIGNMENT; }
};
class ManagedCallingConventionEM64T: public STDCALLCallingConventionEM64T
@@ -221,7 +221,7 @@
{
public:
virtual ~MultiArrayCallingConventionEM64T() {}
- virtual void getOpndInfo(ArgKind kind, uint32 argCount, OpndInfo * infos) const;
+ virtual void getOpndInfo(ArgKind kind, U_32 argCount, OpndInfo * infos) const;
};
#ifdef _EM64T_
Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeEmitter.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeEmitter.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeEmitter.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeEmitter.cpp Thu May 22 06:33:38 2008
@@ -50,11 +50,11 @@
}
- CodeBlockHeat getCodeSectionHeat(uint32 sectionID)const;
+ CodeBlockHeat getCodeSectionHeat(U_32 sectionID)const;
protected:
- uint32 getNeedInfo()const{ return NeedInfo_LivenessInfo; }
- uint32 getSideEffects()const{ return 0; }
+ U_32 getNeedInfo()const{ return NeedInfo_LivenessInfo; }
+ U_32 getSideEffects()const{ return 0; }
void runImpl();
bool verify(bool force=false);
@@ -144,7 +144,7 @@
class CompiledMethodInfo {
public:
- CompiledMethodInfo(MemoryManager& mm, POINTER_SIZE_INT addr, MethodMarkerPseudoInst* outerEntry, uint32 idpth):
+ CompiledMethodInfo(MemoryManager& mm, POINTER_SIZE_INT addr, MethodMarkerPseudoInst* outerEntry, U_32 idpth):
memoryManager(mm),
locationMap(memoryManager),
codeSize(0),
@@ -152,8 +152,8 @@
outerMethodEntry(outerEntry),
inlineDepth(idpth)
{}
- uint32 getCodeSize() { return codeSize; }
- uint32 getInlineDepth() { return inlineDepth; }
+ U_32 getCodeSize() { return codeSize; }
+ U_32 getInlineDepth() { return inlineDepth; }
POINTER_SIZE_INT getCodeAddr() { return codeAddr; }
MethodMarkerPseudoInst* getOuterMethodEntry() { return outerMethodEntry; }
@@ -161,13 +161,13 @@
friend class CodeEmitter;
MemoryManager& memoryManager;
LocationMap locationMap;
- uint32 codeSize;
+ U_32 codeSize;
POINTER_SIZE_INT codeAddr;
MethodMarkerPseudoInst* outerMethodEntry;
// inlineDepth == 1 means that CompiledMethod is inlined into irManager->getMethodDesc()
- uint32 inlineDepth;
+ U_32 inlineDepth;
- void addCodeSize(uint32 size) { codeSize += size; }
+ void addCodeSize(U_32 size) { codeSize += size; }
void includeInst(Inst* inst, uint64 bcOffset) {
if( inst->hasKind(Inst::Kind_PseudoInst)) {
@@ -193,7 +193,7 @@
//________________________________________________________________________________________
void CodeEmitter::ConstantAreaLayout::collectItems()
{
- for (uint32 i=0, n=irManager->getOpndCount(); i<n; ++i){
+ for (U_32 i=0, n=irManager->getOpndCount(); i<n; ++i){
Opnd * opnd=irManager->getOpnd(i);
Opnd::RuntimeInfo * ri=NULL;
if (opnd->isPlacedIn(OpndKind_Mem)&&opnd->getMemOpndKind()==MemOpndKind_ConstantArea){
@@ -275,8 +275,8 @@
if (item->hasKind(ConstantAreaItem::Kind_SwitchTableConstantAreaItem)){
void ** table = (void **)item->getAddress();
Node** bbs=(Node **)item->getValue();
- uint32 nbb=(uint32)item->getSize()/sizeof(Node*);
- for (uint32 ibb=0; ibb<nbb; ibb++){
+ U_32 nbb=(U_32)item->getSize()/sizeof(Node*);
+ for (U_32 ibb=0; ibb<nbb; ibb++){
BasicBlock* bb=(BasicBlock*)bbs[ibb];
assert(bb!=NULL);
assert(std::find(nodes.begin(), nodes.end(), bb)!=nodes.end());
@@ -379,7 +379,7 @@
InlineInfoMap::Entry* e = inlineBCMap->newEntry(parentEntry, parentEntry->method, bcOffset);
//register whole entry chain now
- inlineBCMap->registerEntry(e, (uint32)nativeInstEndOffset);
+ inlineBCMap->registerEntry(e, (U_32)nativeInstEndOffset);
}
if (Log::isEnabled()) {
if (!parentEntry) {
@@ -389,7 +389,7 @@
Log::out()<<" global-bc-offset="<<globalBCMapOffset<<std::endl;
}
if (globalBCMapOffset!=ILLEGAL_BC_MAPPING_VALUE) {
- bcMap->setEntry((uint32)nativeInstStartOffset, globalBCMapOffset);
+ bcMap->setEntry((U_32)nativeInstStartOffset, globalBCMapOffset);
}
}
}
@@ -438,7 +438,7 @@
if (force || getVerificationLevel() >= 1)
{
irManager->updateLivenessInfo();
- for (uint32 i=0, n=irManager->getOpndCount(); i<n; i++){
+ for (U_32 i=0, n=irManager->getOpndCount(); i<n; i++){
Opnd * opnd=irManager->getOpnd(i);
if (!opnd->hasAssignedPhysicalLocation()){
VERIFY_OUT("Unassigned operand: " << opnd << ::std::endl);
@@ -482,12 +482,12 @@
uint8 * blockStartIp = ip;
assert(fit32(blockStartIp-codeStreamStart));
- bb->setCodeOffset( (uint32)(blockStartIp-codeStreamStart) );
+ bb->setCodeOffset( (U_32)(blockStartIp-codeStreamStart) );
for (Inst* inst = (Inst*)bb->getFirstInst(); inst!=NULL; inst = inst->getNextInst()) {
if( inst->hasKind(Inst::Kind_PseudoInst)) {
uint8 * instStartIp = ip;
- inst->setCodeOffset( (uint32)(instStartIp-blockStartIp) );
+ inst->setCodeOffset( (U_32)(instStartIp-blockStartIp) );
continue;
}
@@ -508,7 +508,7 @@
// if the inst is the only in the bb)
Inst* nopInst = irManager->newInst(Mnemonic_NOP);
bb->prependInst(nopInst,inst);
- nopInst->setCodeOffset( (uint32)(ip-blockStartIp) );
+ nopInst->setCodeOffset( (U_32)(ip-blockStartIp) );
ip = nopInst->emit(ip);
// the last two
ip = (uint8*)EncoderBase::nops((char*)ip,2);
@@ -522,10 +522,10 @@
uint8 * instStartIp = ip;
assert(fit32(instStartIp-blockStartIp));
- inst->setCodeOffset( (uint32)(instStartIp-blockStartIp) );
+ inst->setCodeOffset( (U_32)(instStartIp-blockStartIp) );
ip = inst->emit(ip);
}
- bb->setCodeSize( (uint32)(ip-blockStartIp) );
+ bb->setCodeSize( (U_32)(ip-blockStartIp) );
}
//register SOE checks offset to be used in unwind as 0-depth area
@@ -572,12 +572,12 @@
uint8 * instCodeStartAddr = (uint8*)inst->getCodeStartAddr();
uint8 * instCodeEndAddr = (uint8*)instCodeStartAddr+inst->getCodeSize();
uint8 * targetCodeStartAddr = (uint8*)bbTarget->getCodeStartAddr();
- uint32 targetOpndIndex = ((ControlTransferInst*)inst)->getTargetOpndIndex();
+ U_32 targetOpndIndex = ((ControlTransferInst*)inst)->getTargetOpndIndex();
int64 offset=targetCodeStartAddr-instCodeEndAddr;
if (offset >= -128 && offset < 127 && inst->getOpnd(targetOpndIndex)->getSize() != OpndSize_8) {
inst->setOpnd(targetOpndIndex, irManager->newImmOpnd(irManager->getTypeFromTag(Type::Int8), offset));
uint8 * newInstCodeEndAddr = inst->emit(instCodeStartAddr);
- bb->setCodeSize(bb->getCodeSize() + (uint32)(newInstCodeEndAddr - instCodeEndAddr));
+ bb->setCodeSize(bb->getCodeSize() + (U_32)(newInstCodeEndAddr - instCodeEndAddr));
newOpndsCreated = true;
}
}
@@ -616,7 +616,7 @@
uint8 * instCodeStartAddr=(uint8*)inst->getCodeStartAddr();
uint8 * instCodeEndAddr=(uint8*)instCodeStartAddr+inst->getCodeSize();
uint8 * targetCodeStartAddr=0;
- uint32 targetOpndIndex = ((ControlTransferInst*)inst)->getTargetOpndIndex();
+ U_32 targetOpndIndex = ((ControlTransferInst*)inst)->getTargetOpndIndex();
MethodDesc * md = NULL;
if (inst->hasKind(Inst::Kind_BranchInst)){
BasicBlock * bbTarget=(BasicBlock*)((BranchInst*)inst)->getTrueTarget();
@@ -654,7 +654,7 @@
uint8* blockStartIp = (uint8*)bb->getCodeStartAddr();
// 10 bytes are dumped with 'nops' ahead of the call especially for this MOV
uint8* movAddr = instCodeStartAddr-10;
- movInst->setCodeOffset((uint32)(movAddr - blockStartIp));
+ movInst->setCodeOffset((U_32)(movAddr - blockStartIp));
uint8* callAddr = movInst->emit(movAddr);
assert(callAddr == instCodeStartAddr);
// then dump 2 bytes with nops to keep return ip the same for both
@@ -662,7 +662,7 @@
EncoderBase::nops((char*)(callAddr), 2);
// reemit the call as a register-based at the address 'callAddr+2'
inst->emit(callAddr+2);
- inst->setCodeOffset( (uint32)(callAddr + 2 - blockStartIp) );
+ inst->setCodeOffset( (U_32)(callAddr + 2 - blockStartIp) );
// the register call is being registered for patching in the same way as immediate calls
// code patcher takes care of the correct patching
if(md) {
@@ -713,7 +713,7 @@
// we can not guarantee the (callAddr+1) aligned
// self-jump is a kind of lock for the time of call patching
- uint32 movSize =
+ U_32 movSize =
#ifdef _EM64T_
10;
#else
@@ -769,12 +769,12 @@
EncoderBase::nops((char*)(movAddr), 10);
// emit the call in immediate form
args.clear();
- args.add(EncoderBase::Operand(OpndSize_32, (int32)offset));
+ args.add(EncoderBase::Operand(OpndSize_32, (I_32)offset));
EncoderBase::encode((char*)callAddr, Mnemonic_CALL, args); // 5 bytes
} else
#endif
{ // offset fits into 32 bits
- *(uint32*)(callAddr+1) = (uint32)offset;
+ *(U_32*)(callAddr+1) = (U_32)offset;
}
// removing self-jump
@@ -787,7 +787,7 @@
}
//________________________________________________________________________________________
-CodeBlockHeat CodeEmitter::getCodeSectionHeat(uint32 sectionID)const
+CodeBlockHeat CodeEmitter::getCodeSectionHeat(U_32 sectionID)const
{
CodeBlockHeat heat;
if (irManager->getCompilationContext()->hasDynamicProfileToUse())
@@ -823,9 +823,9 @@
registerExceptionRegion((void*)regionStart, (void*)regionEnd, regionDispatchNode);
}
- uint32 handlerInfoCount=(uint32)exceptionHandlerInfos.size();
+ U_32 handlerInfoCount=(U_32)exceptionHandlerInfos.size();
irManager->getMethodDesc().setNumExceptionHandler(handlerInfoCount);
- for (uint32 i=0; i<handlerInfoCount; i++){
+ for (U_32 i=0; i<handlerInfoCount; i++){
const ExceptionHandlerInfo & info=exceptionHandlerInfos[i];
if (Log::isEnabled()) {
Log::out() << "Exception Handler Info [ " << i << "]: " << ::std::endl;
@@ -848,8 +848,8 @@
static bool edge_prior_comparator(const Edge* e1, const Edge* e2) {
assert(e1->isCatchEdge() && e2->isCatchEdge());
- uint32 p1 = ((CatchEdge*)e1)->getPriority();
- uint32 p2 = ((CatchEdge*)e2)->getPriority();
+ U_32 p1 = ((CatchEdge*)e1)->getPriority();
+ U_32 p2 = ((CatchEdge*)e2)->getPriority();
assert(p1!=p2 || e1==e2);
return p1 < p2 ? true : p1 > p2 ? false : e1 > e2;
};
@@ -907,7 +907,7 @@
Node* node, bool isForward) {
assert(node!=NULL);
assert(traversalInfo[node->getId()]==0); //node is white here
- uint32 nodeId = node->getId();
+ U_32 nodeId = node->getId();
traversalInfo[nodeId] = 1; //mark node gray
// preprocess the node
if (node->getKind() == Node::Kind_Block) {
@@ -931,7 +931,7 @@
methInfo = new(memoryManager) CompiledMethodInfo(memoryManager,
(POINTER_SIZE_INT)methMarkerInst->getCodeStartAddr(),
oldMethodEntryInst,
- (uint32)inlineStack.size());
+ (U_32)inlineStack.size());
methodLocationMap[methMarkerInst] = methInfo;
} else if (inst->getKind() == Inst::Kind_MethodEndPseudoInst) {
@@ -946,14 +946,14 @@
if( ! inst->hasKind(Inst::Kind_PseudoInst)) {
POINTER_SIZE_INT instAddr = (POINTER_SIZE_INT)inst->getCodeStartAddr();
POINTER_SIZE_INT nextAddr = (POINTER_SIZE_INT)inst->getNext()->getCodeStartAddr();
- uint32 instSize = inst->getCodeSize();
+ U_32 instSize = inst->getCodeSize();
if (inst->getMnemonic() == Mnemonic_NOP && instAddr+instSize < nextAddr) {
// there is a special case when code patching support generates 3 (ia32) or 13 (em64t) nops
// before calls for future runtime patching. First nop is generated as a common CFG inst.
// The rest ones are generated directly to the memory using encoder.
// Taking this into account:
assert(nextAddr > instAddr);
- instSizeMap[instAddr] = (uint32)(nextAddr-instAddr);
+ instSizeMap[instAddr] = (U_32)(nextAddr-instAddr);
} else {
instSizeMap[instAddr] = instSize;
}
@@ -1017,8 +1017,8 @@
POINTER_SIZE_INT methodStartAddr = litStart == litEnd ? methInfo->getCodeAddr() : (*litStart).first;
POINTER_SIZE_INT prevAddr = 0;
- uint32 methodSize = 0;
- uint32 locationMapSize = 0;
+ U_32 methodSize = 0;
+ U_32 locationMapSize = 0;
for (lit = litStart; lit != litEnd; lit++) {
@@ -1081,7 +1081,7 @@
// send events according to inlining depth
// depth == 1 - the first level inlinees
bool found = false;
- uint32 depth = 1;
+ U_32 depth = 1;
do {
found = false;
for (i = methodLocationMap.begin(); i != itEnd; i++) {
Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeGenerator.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeGenerator.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeGenerator.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeGenerator.cpp Thu May 22 06:33:38 2008
@@ -42,7 +42,7 @@
{
//___________________________________________________________________________________________________
-void _cdecl die(uint32 retCode, const char * message, ...)
+void _cdecl die(U_32 retCode, const char * message, ...)
{
::std::cerr<<"---------- die called (ret code = "<<retCode<<") --------------------------------------"<<std::endl;
if (message!=NULL){
@@ -59,8 +59,8 @@
//___________________________________________________________________________________________________
class InstructionFormTranslator : public SessionAction {
void runImpl(){ irManager->translateToNativeForm(); }
- uint32 getNeedInfo()const{ return 0; }
- uint32 getSideEffects()const{ return 0; }
+ U_32 getNeedInfo()const{ return 0; }
+ U_32 getSideEffects()const{ return 0; }
};
static ActionFactory<InstructionFormTranslator> _native("native");
@@ -68,8 +68,8 @@
//___________________________________________________________________________________________________
class UserRequestedDie : public SessionAction {
void runImpl(){ die(10, getArg("msg")); }
- uint32 getNeedInfo()const{ return 0; }
- uint32 getSideEffects()const{ return 0; }
+ U_32 getNeedInfo()const{ return 0; }
+ U_32 getSideEffects()const{ return 0; }
bool isIRDumpEnabled(){ return false; }
};
@@ -80,8 +80,8 @@
void runImpl(){
irManager->getFlowGraph()->getEntryNode()->prependInst(irManager->newInst(Mnemonic_INT3));
}
- uint32 getNeedInfo()const{ return 0; }
- uint32 getSideEffects()const{ return 0; }
+ U_32 getNeedInfo()const{ return 0; }
+ U_32 getSideEffects()const{ return 0; }
bool isIRDumpEnabled(){ return false; }
};
@@ -97,7 +97,7 @@
void CodeGenerator::genCode(::Jitrino::SessionAction* sa, ::Jitrino::MethodCodeSelector& inputProvider) {
LogStream& irdump = Log::log(LogStream::IRDUMP);
LogStream& dotdump = Log::log(LogStream::DOTDUMP);
- uint32 stageId = Log::getStageId();
+ U_32 stageId = Log::getStageId();
const char* stageName = sa->getName();
if (irdump.isEnabled()) {
Log::printStageBegin(irdump.out(), stageId, "IA32", stageName, stageName);
Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeLayout.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeLayout.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeLayout.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeLayout.cpp Thu May 22 06:33:38 2008
@@ -198,8 +198,8 @@
void Linearizer::checkLayout(IRManager* irm) {
#ifdef _DEBUG
- uint32 maxNodes = irm->getFlowGraph()->getMaxNodeId();
- StlVector<uint32> numVisits(irm->getMemoryManager(), maxNodes, 0);
+ U_32 maxNodes = irm->getFlowGraph()->getMaxNodeId();
+ StlVector<U_32> numVisits(irm->getMemoryManager(), maxNodes, 0);
StlVector<bool> isBB(irm->getMemoryManager(), maxNodes, false);
// Find basic blocks
@@ -214,7 +214,7 @@
assert(!wasLast);
wasLast = true;
} else {
- uint32 id = layoutSucc->getId();
+ U_32 id = layoutSucc->getId();
numVisits[id]++;
assert(numVisits[id] == 1);
}
@@ -224,8 +224,8 @@
// Check that every basic block has been visited once
bool wasFirst = false;
- for (uint32 i = 0; i < maxNodes; i++) {
- uint32 correctNumVisits = isBB[i] ? 1 : 0;
+ for (U_32 i = 0; i < maxNodes; i++) {
+ U_32 correctNumVisits = isBB[i] ? 1 : 0;
if (numVisits[i] != correctNumVisits) {
if (isBB[i] && numVisits[i] == 0 && !wasFirst) {
wasFirst = true;
Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeLayout.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeLayout.h?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeLayout.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeLayout.h Thu May 22 06:33:38 2008
@@ -33,8 +33,8 @@
class Layouter : public SessionAction {
void runImpl();
- uint32 getSideEffects() const {return 0;}
- uint32 getNeedInfo()const{ return 0;}
+ U_32 getSideEffects() const {return 0;}
+ U_32 getNeedInfo()const{ return 0;}
};
/**
Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeLayoutBottomUp.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeLayoutBottomUp.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeLayoutBottomUp.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeLayoutBottomUp.cpp Thu May 22 06:33:38 2008
@@ -207,7 +207,7 @@
assert(*chains.begin() ==irManager->getFlowGraph()->getEntryNode());
assert(*chains.begin() == irManager->getFlowGraph()->getEntryNode());
- for (uint32 i = 0, n = (uint32)chains.size()-1; i<n;i++) {
+ for (U_32 i = 0, n = (U_32)chains.size()-1; i<n;i++) {
BasicBlock* firstChain = chains[i];
BasicBlock* secondChain= chains[i+1];
BasicBlock* lastInFirst = firstChain;
Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeSelector.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeSelector.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeSelector.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeSelector.cpp Thu May 22 06:33:38 2008
@@ -50,7 +50,7 @@
CompilationInterface& compIntfc,
MethodCodeSelector& methodCodeSel,
MemoryManager& codeSelectorMM,
- uint32 nNodes,
+ U_32 nNodes,
IRManager& irM
)
: numNodes(nNodes), nextNodeId(0), compilationInterface(compIntfc), methodCodeSelector(methodCodeSel),
@@ -60,7 +60,7 @@
{
nextNodeId = 0;
nodes = new (codeSelectorMemManager) Node*[numNodes];
- uint32 i;
+ U_32 i;
for (i = 0; i < numNodes; i++)
nodes[i] = NULL;
@@ -72,10 +72,10 @@
//_______________________________________________________________________________________________
/** Create an exception handling (dispatching) node */
-uint32 CfgCodeSelector::genDispatchNode(uint32 numInEdges,uint32 numOutEdges, const StlVector<MethodDesc*>& inlineEndMarkers, double cnt)
+U_32 CfgCodeSelector::genDispatchNode(U_32 numInEdges,U_32 numOutEdges, const StlVector<MethodDesc*>& inlineEndMarkers, double cnt)
{
assert(nextNodeId < numNodes);
- uint32 nodeId = nextNodeId++;
+ U_32 nodeId = nextNodeId++;
Node* node = irManager.getFlowGraph()->createDispatchNode();
node->setExecCount(cnt);
nodes[nodeId] = node;
@@ -90,14 +90,14 @@
//_______________________________________________________________________________________________
/** Create a basic block */
-uint32 CfgCodeSelector::genBlock(uint32 numInEdges,
- uint32 numOutEdges,
+U_32 CfgCodeSelector::genBlock(U_32 numInEdges,
+ U_32 numOutEdges,
BlockKind blockKind,
BlockCodeSelector& codeSelector,
double cnt)
{
assert(nextNodeId < numNodes);
- uint32 nodeId = nextNodeId++;
+ U_32 nodeId = nextNodeId++;
Node* bb = irManager.getFlowGraph()->createBlockNode();
bb->setExecCount(cnt);
nodes[nodeId] = bb;
@@ -130,7 +130,7 @@
if (instCodeSelector.endsWithSwitch()) {
// Generate an additional node that contains switch dispatch
- uint32 numTargets = instCodeSelector.getSwitchNumTargets();
+ U_32 numTargets = instCodeSelector.getSwitchNumTargets();
Opnd * switchSrc = instCodeSelector.getSwitchSrc();
genSwitchBlock(bb, numTargets, switchSrc);
}
@@ -145,12 +145,12 @@
We create it using code selector memory manager and insert it into its own CFG.
*/
-uint32 CfgCodeSelector::genUnwindNode(uint32 numInEdges,
- uint32 numOutEdges,
+U_32 CfgCodeSelector::genUnwindNode(U_32 numInEdges,
+ U_32 numOutEdges,
double cnt)
{
assert(nextNodeId < numNodes);
- uint32 nodeId = nextNodeId++;
+ U_32 nodeId = nextNodeId++;
ControlFlowGraph* fg = irManager.getFlowGraph();
Node* unwindNode = fg->createDispatchNode();
fg->setUnwindNode(unwindNode);
@@ -162,10 +162,10 @@
//_______________________________________________________________________________________________
/** Create exit node */
-uint32 CfgCodeSelector::genExitNode(uint32 numInEdges, double cnt)
+U_32 CfgCodeSelector::genExitNode(U_32 numInEdges, double cnt)
{
assert(nextNodeId < numNodes);
- uint32 nodeId = nextNodeId++;
+ U_32 nodeId = nextNodeId++;
ControlFlowGraph* fg = irManager.getFlowGraph();
Node* exitNode = fg->createExitNode();
exitNode->setExecCount(cnt);
@@ -178,7 +178,7 @@
/** Create a block for a switch statement */
void CfgCodeSelector::genSwitchBlock(Node *originalBlock,
- uint32 numTargets,
+ U_32 numTargets,
Opnd * switchSrc)
{
Node *bb = irManager.getFlowGraph()->createBlockNode();
@@ -194,7 +194,7 @@
//_______________________________________________________________________________________________
/** Create true edge (i.e., edge that corresponds to a taken conditional branch) */
-void CfgCodeSelector::genTrueEdge(uint32 tailNodeId,uint32 headNodeId, double prob)
+void CfgCodeSelector::genTrueEdge(U_32 tailNodeId,U_32 headNodeId, double prob)
{
Node* tailNode= nodes[tailNodeId];
Node * headNode = nodes[headNodeId];
@@ -215,7 +215,7 @@
//_______________________________________________________________________________________________
/** Create false edge (i.e., edge that corresponds to a fallthrough after untaken conditional branch) */
-void CfgCodeSelector::genFalseEdge(uint32 tailNodeId,uint32 headNodeId, double prob)
+void CfgCodeSelector::genFalseEdge(U_32 tailNodeId,U_32 headNodeId, double prob)
{
Node* tailNode = nodes[tailNodeId];
Node* headNode = nodes[headNodeId];
@@ -236,7 +236,7 @@
//_______________________________________________________________________________________________
/** Create unconditional edge (i.e., edge that corresponds to fallthrough) */
-void CfgCodeSelector::genUnconditionalEdge(uint32 tailNodeId,uint32 headNodeId, double prob)
+void CfgCodeSelector::genUnconditionalEdge(U_32 tailNodeId,U_32 headNodeId, double prob)
{
Node * tailNode = nodes[tailNodeId];
Node * headNode = nodes[headNodeId];
@@ -255,9 +255,9 @@
//_______________________________________________________________________________________________
/** Create switch edges */
-void CfgCodeSelector::genSwitchEdges(uint32 tailNodeId, uint32 numTargets,
- uint32 *targets, double *probs,
- uint32 defaultTarget)
+void CfgCodeSelector::genSwitchEdges(U_32 tailNodeId, U_32 numTargets,
+ U_32 *targets, double *probs,
+ U_32 defaultTarget)
{
//
// Switch structure:
@@ -278,8 +278,8 @@
double defaultEdgeProb = 1.0;
defaultEdgeProb = 1.0;
- for (uint32 i = 0; i < numTargets; i++) {
- uint32 targetId = targets[i];
+ for (U_32 i = 0; i < numTargets; i++) {
+ U_32 targetId = targets[i];
if ( targetId == defaultTarget) {
defaultEdgeProb = probs[i];
break;
@@ -301,7 +301,7 @@
origBlock->getOutEdges().front()->setEdgeProb(1.0 - defaultEdgeProb);
}
// Generate edges from switchBlock to switch targets
- for (uint32 i = 0; i < numTargets; i++) {
+ for (U_32 i = 0; i < numTargets; i++) {
Node * targetNode = nodes[targets[i]];
// Avoid generating duplicate edges. Jump table however needs all entries
if (! switchBlock->isConnectedTo(true, targetNode)) {
@@ -314,7 +314,7 @@
//_______________________________________________________________________________________________
/** Create an edge to the exception dispatch node or unwind node */
-void CfgCodeSelector::genExceptionEdge(uint32 tailNodeId, uint32 headNodeId, double prob)
+void CfgCodeSelector::genExceptionEdge(U_32 tailNodeId, U_32 headNodeId, double prob)
{
Node * headNode = nodes[headNodeId];
Node * tailNode = nodes[tailNodeId];
@@ -325,9 +325,9 @@
//_______________________________________________________________________________________________
/** Create catch edge */
-void CfgCodeSelector::genCatchEdge(uint32 tailNodeId,
- uint32 headNodeId,
- uint32 priority,
+void CfgCodeSelector::genCatchEdge(U_32 tailNodeId,
+ U_32 headNodeId,
+ U_32 priority,
Type* exceptionType,
double prob)
{
@@ -358,14 +358,14 @@
///////////////////////////////////////////////////////////////////////////////////
//_______________________________________________________________________________________________
-uint32 VarGenerator::defVar(Type* varType, bool isAddressTaken, bool isPinned)
+U_32 VarGenerator::defVar(Type* varType, bool isAddressTaken, bool isPinned)
{
Opnd * opnd=irManager.newOpnd(varType);
return opnd->getId();
}
//_______________________________________________________________________________________________
-void VarGenerator::setManagedPointerBase(uint32 managedPtrVarNum, uint32 baseVarNum)
+void VarGenerator::setManagedPointerBase(U_32 managedPtrVarNum, U_32 baseVarNum)
{
}
@@ -379,7 +379,7 @@
//_______________________________________________________________________________________________
/** Generate variable operands */
-void MethodCodeSelector::genVars(uint32 numVars, VarCodeSelector& varCodeSelector)
+void MethodCodeSelector::genVars(U_32 numVars, VarCodeSelector& varCodeSelector)
{
numVarOpnds = numVars;
VarGenerator varCodeSelectorCallback(irManager,*this);
@@ -494,7 +494,7 @@
}
-void MethodCodeSelector::genCFG(uint32 numNodes, CFGCodeSelector& codeSelector,
+void MethodCodeSelector::genCFG(U_32 numNodes, CFGCodeSelector& codeSelector,
bool useEdgeProfile)
{
ControlFlowGraph* fg = irManager.getFlowGraph();
Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeSelector.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeSelector.h?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeSelector.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CodeSelector.h Thu May 22 06:33:38 2008
@@ -80,26 +80,26 @@
//
CfgCodeSelector(::Jitrino::SessionAction* sa, CompilationInterface& compIntfc,
MethodCodeSelector& methodCodeSel,
- MemoryManager& codeSelectorMM, uint32 nNodes,
+ MemoryManager& codeSelectorMM, U_32 nNodes,
IRManager& irM);
- uint32 genDispatchNode(uint32 numInEdges, uint32 numOutEdges, const StlVector<MethodDesc*>& inlineEndMarkers, double cnt);
- uint32 genBlock(uint32 numInEdges, uint32 numOutEdges, BlockKind blockKind,
+ U_32 genDispatchNode(U_32 numInEdges, U_32 numOutEdges, const StlVector<MethodDesc*>& inlineEndMarkers, double cnt);
+ U_32 genBlock(U_32 numInEdges, U_32 numOutEdges, BlockKind blockKind,
BlockCodeSelector& codeSelector, double cnt);
- uint32 genUnwindNode(uint32 numInEdges, uint32 numOutEdges,double cnt);
- uint32 genExitNode(uint32 numInEdges, double cnt);
- void genUnconditionalEdge(uint32 tailNodeId,uint32 headNodeId, double prob);
- void genTrueEdge(uint32 tailNodeId,uint32 headNodeId, double prob);
+ U_32 genUnwindNode(U_32 numInEdges, U_32 numOutEdges,double cnt);
+ U_32 genExitNode(U_32 numInEdges, double cnt);
+ void genUnconditionalEdge(U_32 tailNodeId,U_32 headNodeId, double prob);
+ void genTrueEdge(U_32 tailNodeId,U_32 headNodeId, double prob);
void genTrueEdge(Node* tailNode, Node* headNode, double prob);
- void genFalseEdge(uint32 tailNodeId,uint32 headNodeId, double prob);
+ void genFalseEdge(U_32 tailNodeId,U_32 headNodeId, double prob);
void genFalseEdge(Node* tailNode, Node* headNode, double prob);
- void genSwitchEdges(uint32 tailNodeId, uint32 numTargets, uint32 *targets,
- double *probs, uint32 defaultTarget);
- void genExceptionEdge(uint32 tailNodeId, uint32 headNodeId, double prob);
- void genCatchEdge(uint32 headNodeId,uint32 tailNodeId,
- uint32 priority,Type* exceptionType, double prob);
+ void genSwitchEdges(U_32 tailNodeId, U_32 numTargets, U_32 *targets,
+ double *probs, U_32 defaultTarget);
+ void genExceptionEdge(U_32 tailNodeId, U_32 headNodeId, double prob);
+ void genCatchEdge(U_32 headNodeId,U_32 tailNodeId,
+ U_32 priority,Type* exceptionType, double prob);
- void setPersistentId(uint32 nodeId, uint32 persistentId) {
+ void setPersistentId(U_32 nodeId, U_32 persistentId) {
((CGNode*)nodes[nodeId])->setPersistentId(persistentId);
}
@@ -127,7 +127,7 @@
//
// Methods
//
- void genSwitchBlock(Node *originalBlock, uint32 numTargets,
+ void genSwitchBlock(Node *originalBlock, U_32 numTargets,
Opnd *switchSrc);
void genEpilogNode();
Inst * findExceptionInst(Node* block);
@@ -136,8 +136,8 @@
// Fields
//
Node** nodes;
- uint32 numNodes;
- uint32 nextNodeId;
+ U_32 numNodes;
+ U_32 nextNodeId;
CompilationInterface& compilationInterface;
MethodCodeSelector& methodCodeSelector;
MemoryManager& irMemManager; // for data live after code selection
@@ -173,9 +173,9 @@
IRManager& irM);
- void genVars(uint32 numVars, ::Jitrino::VarCodeSelector& varCodeSelector);
+ void genVars(U_32 numVars, ::Jitrino::VarCodeSelector& varCodeSelector);
void setMethodDesc(MethodDesc * desc) {methodDesc = desc;}
- void genCFG(uint32 numNodes, ::Jitrino::CFGCodeSelector& codeSelector, bool useDynamicProfile);
+ void genCFG(U_32 numNodes, ::Jitrino::CFGCodeSelector& codeSelector, bool useDynamicProfile);
MethodDesc * getMethodDesc() {return methodDesc;}
private:
@@ -220,10 +220,10 @@
VarGenerator(IRManager& irM, MethodCodeSelector& methodCodeSel)
: nextVarId(0), irManager(irM), methodCodeSelector(methodCodeSel) {
}
- uint32 defVar(Type* varType, bool isAddressTaken, bool isPinned);
- void setManagedPointerBase(uint32 managedPtrVarNum, uint32 baseVarNum);
+ U_32 defVar(Type* varType, bool isAddressTaken, bool isPinned);
+ void setManagedPointerBase(U_32 managedPtrVarNum, U_32 baseVarNum);
private:
- uint32 nextVarId;
+ U_32 nextVarId;
IRManager& irManager;
MethodCodeSelector& methodCodeSelector;
};
Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32ComplexAddrFormLoader.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32ComplexAddrFormLoader.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32ComplexAddrFormLoader.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32ComplexAddrFormLoader.cpp Thu May 22 06:33:38 2008
@@ -53,7 +53,7 @@
bool checkIsScale(Inst * inst);
void walkThroughOpnds(SubOpndsTable& table);
private:
- uint32 refCountThreshold;
+ U_32 refCountThreshold;
};
static ActionFactory<ComplexAddrFormLoader> _cafl("cafl");
@@ -67,9 +67,9 @@
}
StlMap<Opnd *, bool> memOpnds(irManager->getMemoryManager());
- uint32 opndCount = irManager->getOpndCount();
+ U_32 opndCount = irManager->getOpndCount();
irManager->calculateOpndStatistics();
- for (uint32 i = 0; i < opndCount; i++) {
+ for (U_32 i = 0; i < opndCount; i++) {
Opnd * opnd = irManager->getOpnd(i);
if(opnd->isPlacedIn(OpndKind_Mem)) {
Opnd * baseOp = opnd->getMemOpndSubOpnd(MemOpndSubOpndKind_Base);
@@ -177,7 +177,7 @@
return;
}
- uint32 defCount = instUp->getOpndCount(Inst::OpndRole_InstLevel|Inst::OpndRole_Def);
+ U_32 defCount = instUp->getOpndCount(Inst::OpndRole_InstLevel|Inst::OpndRole_Def);
if(instUp->getMnemonic()==Mnemonic_ADD) {
Opnd * src1 = instUp->getOpnd(defCount);
Opnd * src2 = instUp->getOpnd(defCount+1);
Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32Constraint.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32Constraint.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32Constraint.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32Constraint.cpp Thu May 22 06:33:38 2008
@@ -35,7 +35,7 @@
const char * Constraint::parse(const char * str)
{
Constraint szc, kc;
- for (uint32 i=0, j=0; i<0x100 && *str;){
+ for (U_32 i=0, j=0; i<0x100 && *str;){
const char * tokenEnd=str; char token[0x100];
for (j=0; j<0x100 && *tokenEnd && (isalpha(*tokenEnd)||isdigit(*tokenEnd)); tokenEnd++, j++)
token[j]=*tokenEnd;
@@ -78,7 +78,7 @@
}
//_________________________________________________________________________________________________
-OpndSize Constraint::getDefaultSize(uint32 k)
+OpndSize Constraint::getDefaultSize(U_32 k)
{
OpndKind regKind=(OpndKind)(k & OpndKind_Reg);
if (regKind){
@@ -99,7 +99,7 @@
}
//_________________________________________________________________________________________________
-Constraint Constraint::getAliasConstraint(OpndSize s, uint32 offset)const
+Constraint Constraint::getAliasConstraint(OpndSize s, U_32 offset)const
{
OpndSize sz=(OpndSize)size;
if (s==OpndSize_Default){
@@ -112,8 +112,8 @@
if (sz>s)
return Constraint();
- uint32 newKind=kind, newMask=0;
- uint32 newRegKind=newKind & OpndKind_Reg;
+ U_32 newKind=kind, newMask=0;
+ U_32 newRegKind=newKind & OpndKind_Reg;
OpndSize maxSubregisterSize =
#ifdef _EM64T_
OpndSize_32;
@@ -138,7 +138,7 @@
}
//_________________________________________________________________________________________________
-RegName Constraint::getAliasRegName(RegName regName, OpndSize sz, uint32 offset)
+RegName Constraint::getAliasRegName(RegName regName, OpndSize sz, U_32 offset)
{
if (regName==RegName_Null)
return RegName_Null;
@@ -158,7 +158,7 @@
if (regKind==OpndKind_GPReg){
#ifndef _EM64T_
if (sz==OpndSize_8 && (s==OpndSize_16 || s==OpndSize_32)){
- uint32 idx=getRegIndex(regName);
+ U_32 idx=getRegIndex(regName);
if (idx>4)
return RegName_Null;
return getRegName(regKind, sz, idx);
@@ -178,7 +178,7 @@
}
//_________________________________________________________________________________________________
-RegName Constraint::getAliasRegName(RegName regName, uint32 offset)const
+RegName Constraint::getAliasRegName(RegName regName, U_32 offset)const
{
RegName rn=getAliasRegName(regName, (OpndSize)size, offset);
return contains(rn)?rn:RegName_Null;
Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32Constraint.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32Constraint.h?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32Constraint.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32Constraint.h Thu May 22 06:33:38 2008
@@ -91,7 +91,7 @@
For OpndKind_Reg and sub-kinds initializes the mask field to 0xffff
*/
- Constraint(OpndKind k, OpndSize s, uint32 m)
+ Constraint(OpndKind k, OpndSize s, U_32 m)
:mask(m), size(s), kind(k)
{ assert(k!=OpndKind_Null && size!=OpndSize_Null); assert(mask==0||(OpndKind_Reg&k)!=0); }
@@ -113,14 +113,14 @@
//----------------------------------------------------------------------
/** returns the kind field of the constraint */
- uint32 getKind()const{ return kind; }
+ U_32 getKind()const{ return kind; }
/** returns the size field of the constraint */
OpndSize getSize()const{ return (OpndSize)size; }
/** returns the mask field of the constraint */
- uint32 getMask()const{ return mask; }
+ U_32 getMask()const{ return mask; }
/** sets the mask field of the constraint */
- void setMask(uint32 m){ mask=m; }
+ void setMask(U_32 m){ mask=m; }
/** resets the constraint to the Null value */
void makeNull(){ fullValue = 0; }
@@ -147,7 +147,7 @@
bool isNull()const{ return kind==OpndKind_Null; }
/** Returns the default size for the OpndKind combination k */
- static OpndSize getDefaultSize(uint32 k);
+ static OpndSize getDefaultSize(U_32 k);
/** Returns true if 'this' can be merged (via unionWith) with c
@@ -157,11 +157,11 @@
*/
bool canBeMergedWith(Constraint c)
{
- uint32 filter = (uint32)OpndKind_Reg << 24;
- uint32 thisTmp = fullValue & filter, cTmp = c.fullValue & filter, rTmp = thisTmp & cTmp;
+ U_32 filter = (U_32)OpndKind_Reg << 24;
+ U_32 thisTmp = fullValue & filter, cTmp = c.fullValue & filter, rTmp = thisTmp & cTmp;
if (rTmp!=thisTmp && rTmp!=cTmp)
return false;
- filter = (uint32)OpndSize_Any << 16;
+ filter = (U_32)OpndSize_Any << 16;
thisTmp = fullValue & filter, cTmp = c.fullValue & filter, rTmp = thisTmp & cTmp;
return rTmp==thisTmp || rTmp==cTmp;
}
@@ -201,7 +201,7 @@
/** Returns the constraint for an outer aliased operand
s must be greater than or equal to the constraint's size
*/
- Constraint getAliasConstraint(OpndSize s, uint32 offset=0)const;
+ Constraint getAliasConstraint(OpndSize s, U_32 offset=0)const;
/** Returns the regname for an aliased regname
@@ -209,18 +209,18 @@
e.g. for eax it can return eax, ax, ah, al, depending on the constraint
The constraint's size must be less than or equal to regName's size
*/
- static RegName getAliasRegName(RegName regName, OpndSize s, uint32 offset=0);
- RegName getAliasRegName(RegName regName, uint32 offset=0)const;
+ static RegName getAliasRegName(RegName regName, OpndSize s, U_32 offset=0);
+ RegName getAliasRegName(RegName regName, U_32 offset=0)const;
//----------------------------------------------------------------------
private:
union{
struct {
- uint32 mask:16;
- uint32 size:8;
- uint32 kind:8;
+ U_32 mask:16;
+ U_32 size:8;
+ U_32 kind:8;
};
- uint32 fullValue;
+ U_32 fullValue;
};
friend struct DefaultConstraintInitializer;
Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32ConstraintsResolver.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32ConstraintsResolver.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32ConstraintsResolver.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32ConstraintsResolver.cpp Thu May 22 06:33:38 2008
@@ -123,8 +123,8 @@
/** runImpl is required override, calls ConstraintsResolverImpl.runImpl */
void runImpl();
/** This transformer requires up-to-date liveness info */
- uint32 getNeedInfo()const{ return NeedInfo_LivenessInfo; }
- uint32 getSideEffects()const{ return 0; }
+ U_32 getNeedInfo()const{ return NeedInfo_LivenessInfo; }
+ U_32 getSideEffects()const{ return 0; }
};
@@ -238,11 +238,11 @@
liveAtDispatchBlockEntry.resizeClear(originalOpndCount);
opndReplaceWorkset.resize(originalOpndCount);
- for (uint32 i=0; i<originalOpndCount; i++)
+ for (U_32 i=0; i<originalOpndCount; i++)
opndReplaceWorkset[i]=NULL;
opndUsage.resize(originalOpndCount);
- for (uint32 i=0; i<originalOpndCount; i++)
+ for (U_32 i=0; i<originalOpndCount; i++)
opndUsage[i]=0;
@@ -282,8 +282,8 @@
Node* node = *it;
if (node->isBlockNode()){
double bbecv = getBasicBlockPriority(node);
- uint32 ibb=0;
- for (uint32 nbb=(uint32)basicBlocks.size(); ibb<nbb; ++ibb){
+ U_32 ibb=0;
+ for (U_32 nbb=(U_32)basicBlocks.size(); ibb<nbb; ++ibb){
if (bbecv > getBasicBlockPriority(basicBlocks[ibb]))
break;
}
@@ -310,7 +310,7 @@
// Reset calculated constraints to null constraints
irManager.resetOpndConstraints();
// For all operands in the CFG
- for (uint32 i=0; i<originalOpndCount; i++){
+ for (U_32 i=0; i<originalOpndCount; i++){
Opnd * opnd=irManager.getOpnd(i);
Constraint c=opnd->getConstraint(Opnd::ConstraintKind_Initial);
@@ -339,9 +339,9 @@
{
if (cnew.isNull())
return true;
- uint32 newMask = cnew.getMask(), oldMask = cold.getMask();
+ U_32 newMask = cnew.getMask(), oldMask = cold.getMask();
if ((newMask & oldMask) != oldMask){
- uint32 newMaskCount = countOnes(newMask);
+ U_32 newMaskCount = countOnes(newMask);
return
(newMaskCount == 0 && normedBBExecCount < splitThresholdForNoRegs) ||
(newMaskCount <= 1 && normedBBExecCount < splitThresholdFor1Reg) ||
@@ -547,7 +547,7 @@
// if we come to bb entry with some replacement for an operand and the operand is live at the entry
// insert copying from the original operand to the replacement operand
- uint32 execCount = (uint32)bb->getExecCount();
+ U_32 execCount = (U_32)bb->getExecCount();
BitSet * ls = irManager.getLiveAtEntry(bb);
BitSet::IterB ib(*ls);
for (int i = ib.getNext(); i != -1; i = ib.getNext()){
@@ -570,7 +570,7 @@
void ConstraintsResolverImpl::resolveConstraints()
{
// for all basic blocks in the array
- for (uint32 ibb=0, nbb=(uint32)basicBlocks.size(); ibb<nbb; ++ibb){
+ for (U_32 ibb=0, nbb=(U_32)basicBlocks.size(); ibb<nbb; ++ibb){
resolveConstraints(basicBlocks[ibb]);
}
}
Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32ConstraintsResolver.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32ConstraintsResolver.h?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32ConstraintsResolver.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32ConstraintsResolver.h Thu May 22 06:33:38 2008
@@ -235,7 +235,7 @@
Nodes basicBlocks;
/** result of irManager.getOpndCount before the pass */
- uint32 originalOpndCount;
+ U_32 originalOpndCount;
/** Current live set, updated as usual for each instruction in resolveConstraints(Inst*) */
BitSet liveOpnds;
@@ -260,7 +260,7 @@
StlVector<Opnd*> opndReplaceWorkset;
- StlVector<uint32> opndUsage;
+ StlVector<U_32> opndUsage;
unsigned callSplitThresholdForNoRegs;
unsigned callSplitThresholdFor1Reg;
Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CopyExpansion.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CopyExpansion.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CopyExpansion.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32CopyExpansion.cpp Thu May 22 06:33:38 2008
@@ -71,8 +71,8 @@
struct CandidateInst
{
Inst * inst;
- uint32 execCount;
- CandidateInst(Inst * i = NULL, uint32 ec = 0)
+ U_32 execCount;
+ CandidateInst(Inst * i = NULL, U_32 ec = 0)
:inst(i), execCount(ec){}
static bool less (const CandidateInst& x, const CandidateInst& y)
@@ -83,21 +83,21 @@
typedef StlVector<CandidateInst> CandidateInsts;
- uint32 initIntervals();
+ U_32 initIntervals();
bool isCandidate(const Inst * inst) const;
void collectCandidates();
void collectIntervals();
void addReplacement(Opnd * dst, Opnd * src);
void removeInsts();
void replaceOpnds();
- void printCandidates(::std::ostream& os, uint32 detailLevel = 0)const;
+ void printCandidates(::std::ostream& os, U_32 detailLevel = 0)const;
IRManager & irManager;
MemoryManager memoryManager;
CandidateInsts candidateInsts;
Intervals intervals;
OpndVector opndReplacements;
- uint32 replacementsAdded;
+ U_32 replacementsAdded;
bool emptyBlocks;
};
@@ -124,12 +124,12 @@
}
//_________________________________________________________________________________________________
-uint32 SimpleStackOpndCoalescer::initIntervals()
+U_32 SimpleStackOpndCoalescer::initIntervals()
{
- uint32 candidateOpndCount = 0;
- uint32 opndCount = irManager.getOpndCount();
+ U_32 candidateOpndCount = 0;
+ U_32 opndCount = irManager.getOpndCount();
intervals.resize(opndCount);
- for (uint32 i = 0; i < opndCount; i++){
+ for (U_32 i = 0; i < opndCount; i++){
Opnd * opnd = irManager.getOpnd(i);
if (opnd->isPlacedIn(OpndKind_Mem) && opnd->getMemOpndKind() == MemOpndKind_StackAutoLayout){
intervals[i] = new (memoryManager) Interval(memoryManager);
@@ -151,7 +151,7 @@
if (node->isBlockNode()){
for (Inst* inst = (Inst*)node->getFirstInst(); inst!=NULL; inst=inst->getNextInst()){
if (isCandidate(inst)){
- uint32 execCount = (uint32)node->getExecCount();
+ U_32 execCount = (U_32)node->getExecCount();
if (execCount < 1)
execCount = 1;
candidateInsts.push_back(CandidateInst(inst, execCount));
@@ -164,12 +164,12 @@
}
//_________________________________________________________________________________________________
-void SimpleStackOpndCoalescer::printCandidates(::std::ostream& os, uint32 detailLevel)const
+void SimpleStackOpndCoalescer::printCandidates(::std::ostream& os, U_32 detailLevel)const
{
os << irManager.getMethodDesc().getParentType()->getName() << "." << irManager.getMethodDesc().getName()
<< ": " << candidateInsts.size() << ::std::endl;
if (detailLevel > 0){
- for (uint32 i = 0; i < candidateInsts.size(); i++){
+ for (U_32 i = 0; i < candidateInsts.size(); i++){
if (detailLevel > 1)
IRPrinter::printInst(os, candidateInsts[i].inst);
Inst * inst = candidateInsts[i].inst;
@@ -211,7 +211,7 @@
void SimpleStackOpndCoalescer::collectIntervals()
{
irManager.indexInsts();
- uint32 opndCount = irManager.getOpndCount();
+ U_32 opndCount = irManager.getOpndCount();
Interval * interval;
@@ -224,7 +224,7 @@
if (inst == 0)
continue;
- uint32 instIndex=inst->getIndex();
+ U_32 instIndex=inst->getIndex();
BitSet lives(memoryManager, opndCount);
@@ -240,7 +240,7 @@
Inst::Opnds defs(inst, Inst::OpndRole_All);
for (Inst::Opnds::iterator it = defs.begin(); it != defs.end(); it = defs.next(it)){
Opnd * opnd = inst->getOpnd(it);
- uint32 opndId = opnd->getId();
+ U_32 opndId = opnd->getId();
if ( (interval = intervals[opndId]) != NULL ){
if (inst->isLiveRangeEnd(it))
intervals[opndId]->stop(instIndex + 1);
@@ -260,7 +260,7 @@
}
}
- for (uint32 i = 0; i < opndCount; i++){
+ for (U_32 i = 0; i < opndCount; i++){
if ( (interval = intervals[i]) != NULL )
interval->finish();
}
@@ -283,7 +283,7 @@
{
if (dstOpnd != srcOpnd){
intervals[srcOpnd->getId()]->unionWith(intervals[dstOpnd->getId()]);
- for (uint32 i = 0, n = irManager.getOpndCount(); i < n; i++){
+ for (U_32 i = 0, n = irManager.getOpndCount(); i < n; i++){
if (opndReplacements[i] == dstOpnd){
if (srcOpnd->getId() != i)
opndReplacements[i] = srcOpnd;
@@ -299,7 +299,7 @@
//_________________________________________________________________________________________________
void SimpleStackOpndCoalescer::removeInsts()
{
- uint32 opndCount = irManager.getOpndCount();
+ U_32 opndCount = irManager.getOpndCount();
// Exclude aliased memory locations from the optimization
// example: if for "mov arg1, arg0" both args are on stack but arg0 is placed in incoming args stack area
@@ -312,9 +312,9 @@
replacementsAdded = 0;
opndReplacements.resize(opndCount);
- for (uint32 i = 0; i < opndCount; i++)
+ for (U_32 i = 0; i < opndCount; i++)
opndReplacements[i] = NULL;
- for (uint32 i = 0; i < candidateInsts.size(); i++){
+ for (U_32 i = 0; i < candidateInsts.size(); i++){
int adj;
Inst * inst = candidateInsts[i].inst;
if (Log::isEnabled()) {
@@ -351,9 +351,9 @@
*/
class CopyExpansion : public SessionAction {
void runImpl();
- void restoreRegUsage(Node * bb, Inst * toInst, uint32& gpRegUsageMask, uint32& appRegUsageMask);
- uint32 getNeedInfo()const{ return NeedInfo_LivenessInfo; }
- uint32 getSideEffects()const{ return SideEffect_InvalidatesLivenessInfo; }
+ void restoreRegUsage(Node * bb, Inst * toInst, U_32& gpRegUsageMask, U_32& appRegUsageMask);
+ U_32 getNeedInfo()const{ return NeedInfo_LivenessInfo; }
+ U_32 getSideEffects()const{ return SideEffect_InvalidatesLivenessInfo; }
};
@@ -380,8 +380,8 @@
for (Nodes::const_iterator it = nodes.begin(),end = nodes.end();it!=end; ++it) {
Node* node = *it;
if (node->isBlockNode()){
- uint32 flagsRegUsageMask = 0;
- uint32 gpRegUsageMask = 0;
+ U_32 flagsRegUsageMask = 0;
+ U_32 gpRegUsageMask = 0;
bool calculatingRegUsage = false;
for (Inst * inst=(Inst*)node->getLastInst(), * nextInst=NULL; inst!=NULL; inst=nextInst){
nextInst=inst->getPrevInst();
@@ -460,7 +460,7 @@
}
//_________________________________________________________________________________________________
-void CopyExpansion::restoreRegUsage(Node* bb, Inst * toInst, uint32& gpRegUsageMask, uint32& appRegUsageMask)
+void CopyExpansion::restoreRegUsage(Node* bb, Inst * toInst, U_32& gpRegUsageMask, U_32& appRegUsageMask)
{
assert(bb->isBlockNode());
if (bb->isEmpty()) {
Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32DCE.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32DCE.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32DCE.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32DCE.cpp Thu May 22 06:33:38 2008
@@ -32,8 +32,8 @@
class DCE : public SessionAction {
public:
void runImpl();
- uint32 getSideEffects() const {return 0;}
- uint32 getNeedInfo()const {return 0;}
+ U_32 getSideEffects() const {return 0;}
+ U_32 getNeedInfo()const {return 0;}
};
static ActionFactory<DCE> _dce("cg_dce");
Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32EarlyPropagation.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32EarlyPropagation.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32EarlyPropagation.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32EarlyPropagation.cpp Thu May 22 06:33:38 2008
@@ -45,16 +45,16 @@
struct OpndInfo
{
- uint32 defCount;
+ U_32 defCount;
Inst * sourceInst;
- uint32 sourceOpndId;
- uint32 sourceOpndDefCountAtCopy;
+ U_32 sourceOpndId;
+ U_32 sourceOpndDefCountAtCopy;
OpndInfo()
:defCount(0), sourceInst(NULL), sourceOpndId(EmptyUint32), sourceOpndDefCountAtCopy(0){}
};
void runImpl();
- uint32 getNeedInfo()const{ return 0; }
+ U_32 getNeedInfo()const{ return 0; }
};
static ActionFactory<EarlyPropagation> _early_prop("early_prop");
@@ -71,7 +71,7 @@
void EarlyPropagation::runImpl()
{
irManager->updateLoopInfo();
- uint32 opndCount=irManager->getOpndCount();
+ U_32 opndCount=irManager->getOpndCount();
MemoryManager mm("early_prop");
OpndInfo * opndInfos = new(mm) OpndInfo[opndCount];
@@ -89,7 +89,7 @@
Node * loopHeader = lt->getLoopHeader(node, false);
if (currentLoopHeader != loopHeader){
currentLoopHeader = loopHeader;
- for (uint32 i = 0; i < opndCount; ++i)
+ for (U_32 i = 0; i < opndCount; ++i)
if (opndInfos[i].sourceOpndId != EmptyUint32)
opndInfos[i].defCount++;
}
@@ -99,11 +99,11 @@
Inst::Opnds opnds(inst, Inst::OpndRole_All);
for (Inst::Opnds::iterator it = opnds.begin(); it != opnds.end(); it = opnds.next(it)){
Opnd * opnd=inst->getOpnd(it);
- uint32 roles=inst->getOpndRoles(it);
- uint32 opndId = opnd->getId();
+ U_32 roles=inst->getOpndRoles(it);
+ U_32 opndId = opnd->getId();
OpndInfo& opndInfo = opndInfos[opndId];
- uint32 mask = 0;
+ U_32 mask = 0;
if (roles & Inst::OpndRole_Def){
++opndInfo.defCount;
@@ -150,7 +150,7 @@
if (isCopy){ // CopyPseudoInst or mov
Opnd * defOpnd = inst->getOpnd(0);
Opnd * srcOpnd = inst->getOpnd(1);
- uint32 defOpndId = defOpnd->getId();
+ U_32 defOpndId = defOpnd->getId();
OpndInfo * opndInfo = opndInfos + defOpndId;
bool instHandled=false;
bool typeConvOk = isTypeConversionAllowed(srcOpnd, defOpnd);
@@ -175,7 +175,7 @@
Opnd ** replacements = new(mm) Opnd* [opndCount];
memset(replacements, 0, sizeof(Opnd*) * opndCount);
bool hasReplacements = false;
- for (uint32 i = 0; i < opndCount; ++i){
+ for (U_32 i = 0; i < opndCount; ++i){
if (opndInfos[i].sourceOpndId != EmptyUint32){
Inst * inst = opndInfos[i].sourceInst;
if (inst !=NULL){
Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32Encoder.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32Encoder.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32Encoder.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32Encoder.cpp Thu May 22 06:33:38 2008
@@ -115,12 +115,12 @@
return Constraint();
}
-uint32 Encoder::getMnemonicProperties(Mnemonic mn)
+U_32 Encoder::getMnemonicProperties(Mnemonic mn)
{
return getMnemonicProperties(*getMnemonicDesc(mn));
};
-uint32 Encoder::getMnemonicProperties(const MnemonicDesc& mdesc)
+U_32 Encoder::getMnemonicProperties(const MnemonicDesc& mdesc)
{
return (mdesc.flags & MF_CONDITIONAL ? Inst::Properties_Conditional:0) |
(mdesc.flags & MF_SYMMETRIC ? Inst::Properties_Symmetric : 0) |
@@ -129,7 +129,7 @@
};
//_________________________________________________________________________________________________
-bool Encoder::matches(Constraint co, Constraint ci, uint32 opndRoles,
+bool Encoder::matches(Constraint co, Constraint ci, U_32 opndRoles,
bool allowAliases)
{
return co.isNull() || !(ci&co).isNull() ||
@@ -144,7 +144,7 @@
assert(m != Mnemonic_Null && m < Mnemonic_Count);
const OpcodeGroupsHolder& mi = getOpcodeGroups()[m];
// first, find better matching for already assigned operands
- for (uint32 i=0; i<mi.count; i++) {
+ for (U_32 i=0; i<mi.count; i++) {
const OpcodeGroup* og=mi.opgroups+i;
if (matches(og, fi, false)) {
return og;
@@ -152,7 +152,7 @@
}
// now find any matching suitable for the type constraint (initial)
- for (uint32 i=0; i<mi.count; i++) {
+ for (U_32 i=0; i<mi.count; i++) {
const OpcodeGroup* og=mi.opgroups+i;
if (matches(og, fi, true)) {
return og;
@@ -176,8 +176,8 @@
return false;
}
}
- for (uint32 i = 0, n = fi.opndCount; i < n; i++) {
- uint32 idx = fi.isExtended ? og->extendedToNativeMap[i] : i;
+ for (U_32 i = 0, n = fi.opndCount; i < n; i++) {
+ U_32 idx = fi.isExtended ? og->extendedToNativeMap[i] : i;
Constraint co=fi.opndConstraints[idx];
if (any) {
co = Constraint(OpndKind_Any, co.getSize());
@@ -190,9 +190,9 @@
//_________________________________________________________________________________________________
bool
-Encoder::isOpndAllowed(const Encoder::OpcodeGroup * og, uint32 i, Constraint co, bool isExtended, bool any)
+Encoder::isOpndAllowed(const Encoder::OpcodeGroup * og, U_32 i, Constraint co, bool isExtended, bool any)
{
- uint32 idx = isExtended ? og->extendedToNativeMap[i] : i;
+ U_32 idx = isExtended ? og->extendedToNativeMap[i] : i;
assert(idx<IRMaxNativeOpnds);
Constraint ci=og->opndConstraints[idx];
@@ -212,7 +212,7 @@
EncoderBase::Operands args;
Opnd * const * opnds = inst->getOpnds();
- const uint32 * roles = inst->getOpndRoles();
+ const U_32 * roles = inst->getOpndRoles();
for( int idx=0, n=inst->getOpndCount(); idx<n; idx++ ) {
if (!(roles[idx] & Inst::OpndRole_Explicit)) continue;
@@ -385,7 +385,7 @@
//
if (canBeIncluded(og, od)) {
- for (uint32 j=0; j<og.opndRoles.count; j++) {
+ for (U_32 j=0; j<og.opndRoles.count; j++) {
og.opndConstraints[j].unionWith(od.opndConstraints[j]);
}
break;
@@ -399,7 +399,7 @@
OpcodeGroup& og = mitem->opgroups[mitem->count];
initOG(og, mdesc);
og.opndRoles = od.opndRoles;
- for (uint32 j=0; j<og.opndRoles.count; j++) {
+ for (U_32 j=0; j<og.opndRoles.count; j++) {
og.opndConstraints[j].unionWith(od.opndConstraints[j]);
}
++mitem->count;
@@ -464,22 +464,22 @@
void Encoder::finalizeOG(OpcodeGroup& og) {
- uint32 etmIdx = 0;
- for (uint32 i = 0; i < og.opndRoles.count; i++) {
+ U_32 etmIdx = 0;
+ for (U_32 i = 0; i < og.opndRoles.count; i++) {
if (getOpndRoles(og.opndRoles, i) & Inst::OpndRole_Def){
og.extendedToNativeMap[etmIdx++] = i;
}
}
assert(etmIdx == og.opndRoles.defCount);
- for (uint32 i = 0; i < og.opndRoles.count; i++) {
+ for (U_32 i = 0; i < og.opndRoles.count; i++) {
if (getOpndRoles(og.opndRoles, i) & Inst::OpndRole_Use) {
og.extendedToNativeMap[etmIdx++] = i;
}
}
- assert(etmIdx == (uint32)(og.opndRoles.defCount + og.opndRoles.useCount));
+ assert(etmIdx == (U_32)(og.opndRoles.defCount + og.opndRoles.useCount));
- uint32 memOpnds = 0;
- for (uint32 i = 0; i < og.opndRoles.count; i++) {
+ U_32 memOpnds = 0;
+ for (U_32 i = 0; i < og.opndRoles.count; i++) {
if (og.opndConstraints[i].getKind() & OpndKind_Mem)
memOpnds++;
}
Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32Encoder.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32Encoder.h?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32Encoder.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32Encoder.h Thu May 22 06:33:38 2008
@@ -50,12 +50,12 @@
/** struct OpcodeGroupDescription contains the description of an opcode group */
struct OpcodeGroup {
Mnemonic mnemonic;
- uint32 properties;
+ U_32 properties;
OpndRolesDescription opndRoles;
Constraint opndConstraints[IRMaxNativeOpnds];
OpndRolesDesc implicitOpndRoles;
RegName implicitOpndRegNames[3];
- uint32 extendedToNativeMap[IRMaxExtendedOpnds];
+ U_32 extendedToNativeMap[IRMaxExtendedOpnds];
const char * printMnemonic;
};
@@ -68,10 +68,10 @@
const OpcodeGroup * opcodeGroup;
};
- static bool matches(Constraint co, Constraint ci, uint32 opndRoles, bool allowAliases);
+ static bool matches(Constraint co, Constraint ci, U_32 opndRoles, bool allowAliases);
static const OpcodeGroup* findOpcodeGroup(const FindInfo& fi);
static bool matches(const OpcodeGroup* og, const FindInfo& fi, bool any);
- static bool isOpndAllowed(const Encoder::OpcodeGroup * og, uint32 i, Constraint co, bool isExtended, bool any);
+ static bool isOpndAllowed(const Encoder::OpcodeGroup * og, U_32 i, Constraint co, bool isExtended, bool any);
/**
* Retunrs an empty opcode group.
@@ -91,10 +91,10 @@
Constraint constraints[MemOpndSubOpndKind_Count];
};
- static const MemOpndConstraints * getMemOpndConstraints(uint32 idx)
+ static const MemOpndConstraints * getMemOpndConstraints(U_32 idx)
{ assert(idx<lengthof(memOpndConstraints)); return memOpndConstraints+idx; }
- static Constraint getMemOpndSubOpndConstraint(Constraint memOpndConstraint, uint32 subOpndIndex) {
+ static Constraint getMemOpndSubOpndConstraint(Constraint memOpndConstraint, U_32 subOpndIndex) {
return getMemOpndConstraints(0)->constraints[subOpndIndex];
}
@@ -108,12 +108,12 @@
/**
* Returns properties (see Inst::Properties) for a given mnemonic.
*/
- static uint32 getMnemonicProperties(Mnemonic mn);
+ static U_32 getMnemonicProperties(Mnemonic mn);
/**
* Returns properties (see Inst::Properties) for a given MnemonicDesc.
*/
- static uint32 getMnemonicProperties(const MnemonicDesc& mdesc);
+ static U_32 getMnemonicProperties(const MnemonicDesc& mdesc);
private:
/**
* Empty opcode group.
Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32GCMap.cpp
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32GCMap.cpp?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32GCMap.cpp (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32GCMap.cpp Thu May 22 06:33:38 2008
@@ -186,7 +186,7 @@
}
//ok register this opnd
MPtrPair* pair = GCSafePointsInfo::findPairByMPtrOpnd(pairs, opnd);
- int32 offset = pair == NULL ? 0 : pair->getOffset();
+ I_32 offset = pair == NULL ? 0 : pair->getOffset();
bool isObject = offset == 0;
#ifdef _EM64T_
bool isCompressed = (opnd->getType()->tag <= Type::CompressedVTablePtr && opnd->getType()->tag >= Type::CompressedSystemObject);
@@ -195,9 +195,9 @@
RegName reg = opnd->getRegName();
if (reg != RegName_Null) {
#ifdef _EM64T_
- gcOpnd = new (mm) GCSafePointOpnd(isObject, TRUE, uint32(reg), offset, isCompressed);
+ gcOpnd = new (mm) GCSafePointOpnd(isObject, TRUE, U_32(reg), offset, isCompressed);
#else
- gcOpnd = new (mm) GCSafePointOpnd(isObject, TRUE, uint32(reg), offset);
+ gcOpnd = new (mm) GCSafePointOpnd(isObject, TRUE, U_32(reg), offset);
#endif
} else if (opnd->getMemOpndKind() == MemOpndKind_StackAutoLayout) {
const Opnd* displOpnd = opnd->getMemOpndSubOpnd(MemOpndSubOpndKind_Displacement);
@@ -330,10 +330,10 @@
POINTER_SIZE_INT nOpnds = image[1];
gcOpnds.reserve(nOpnds);
POINTER_SIZE_INT offs = 2;
- for (uint32 i = 0; i< nOpnds; i++, offs+=3) {
- GCSafePointOpnd* gcOpnd= new (mm) GCSafePointOpnd(uint32(image[offs]), int(image[offs+1]), int32(image[offs+2]));
+ for (U_32 i = 0; i< nOpnds; i++, offs+=3) {
+ GCSafePointOpnd* gcOpnd= new (mm) GCSafePointOpnd(U_32(image[offs]), int(image[offs+1]), I_32(image[offs+2]));
#ifdef GCMAP_TRACK_IDS
- gcOpnd->firstId = uint32(image[offs+3]);
+ gcOpnd->firstId = U_32(image[offs+3]);
offs++;
#endif
gcOpnds.push_back(gcOpnd);
@@ -357,7 +357,7 @@
POINTER_SIZE_INT offs=0;
data[offs++] = ip;
data[offs++] = (POINTER_SIZE_INT)gcOpnds.size();
- for (uint32 i = 0, n = (uint32)gcOpnds.size(); i<n; i++, offs+=3) {
+ for (U_32 i = 0, n = (U_32)gcOpnds.size(); i<n; i++, offs+=3) {
GCSafePointOpnd* gcOpnd = gcOpnds[i];
data[offs] = gcOpnd->flags;
data[offs+1] = gcOpnd->val;
@@ -413,7 +413,7 @@
//In this case it's impossible to derive valid base for mptr with unknown offset.
//1. Derive all offsets. Use GCSafePointOpnd.mptrOffset to store the result.
- for (uint32 i=0, n = (uint32)gcOpnds.size(); i<n; i++) {
+ for (U_32 i=0, n = (U_32)gcOpnds.size(); i<n; i++) {
GCSafePointOpnd* gcOpnd = gcOpnds[i];
POINTER_SIZE_INT valPtrAddr = getOpndSaveAddr(context, stackInfo, gcOpnd);
if (gcOpnd->isObject() || gcOpnd->getMPtrOffset()!=MPTR_OFFSET_UNKNOWN) {
@@ -427,7 +427,7 @@
POINTER_SIZE_INT basePtrAddr = 0;
#endif
POINTER_SIZE_INT baseAddr = 0;
- for (uint32 j=0; j<n; j++) {
+ for (U_32 j=0; j<n; j++) {
GCSafePointOpnd* tmpOpnd = gcOpnds[j];
if (tmpOpnd->isObject()) {
POINTER_SIZE_INT tmpPtrAddr = getOpndSaveAddr(context, stackInfo, tmpOpnd);
@@ -453,7 +453,7 @@
}
//2. Report the results
- for (uint32 i=0, n = (uint32)gcOpnds.size(); i<n; i++) {
+ for (U_32 i=0, n = (U_32)gcOpnds.size(); i<n; i++) {
GCSafePointOpnd* gcOpnd = gcOpnds[i];
POINTER_SIZE_INT valPtrAddr = getOpndSaveAddr(context, stackInfo, gcOpnd);
if (gcOpnd->isObject()) {
@@ -462,7 +462,7 @@
#endif
#ifdef _EM64T_
if(gcOpnd->isCompressed())
- gcInterface->enumerateCompressedRootReference((uint32*)valPtrAddr);
+ gcInterface->enumerateCompressedRootReference((U_32*)valPtrAddr);
else
#endif
gcInterface->enumerateRootReference((void**)valPtrAddr);
@@ -521,7 +521,7 @@
AutoTimer tm(enumerateTimer);
// Compute stack information
- uint32 stackInfoSize = (uint32)StackInfo::getByteSize(methodDesc);
+ U_32 stackInfoSize = (U_32)StackInfo::getByteSize(methodDesc);
U_8* infoBlock = methodDesc->getInfoBlock();
U_8* gcBlock = infoBlock + stackInfoSize;
#ifdef _EM64T_
@@ -567,9 +567,9 @@
inlineInfo->write(compIntf.allocateJITDataBlock(inlineInfo->getImageSize(), 8));
}
- uint32 stackInfoSize = (uint32)stackInfo->getByteSize();
- uint32 gcInfoSize = (uint32)gcMap->getByteSize();
- uint32 bcMapSize = (uint32)bcMap->getByteSize(); // we should write at least the size of map in the info block
+ U_32 stackInfoSize = (U_32)stackInfo->getByteSize();
+ U_32 gcInfoSize = (U_32)gcMap->getByteSize();
+ U_32 bcMapSize = (U_32)bcMap->getByteSize(); // we should write at least the size of map in the info block
assert(bcMapSize >= 4); // minimum size for empty BCMap for all platforms
U_8* infoBlock = compIntf.allocateInfoBlock(stackInfoSize + gcInfoSize + bcMapSize);
Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32GCMap.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32GCMap.h?rev=659108&r1=659107&r2=659108&view=diff
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32GCMap.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/codegenerator/ia32/Ia32GCMap.h Thu May 22 06:33:38 2008
@@ -84,7 +84,7 @@
POINTER_SIZE_INT getUint32Size() const;
void write(POINTER_SIZE_INT* image) const;
- uint32 getNumOpnds() const {return (uint32)gcOpnds.size();}
+ U_32 getNumOpnds() const {return (U_32)gcOpnds.size();}
static POINTER_SIZE_INT getIP(const POINTER_SIZE_INT* image);
void enumerate(GCInterface* gcInterface, const JitFrameContext* c, const StackInfo& stackInfo) const;
@@ -104,15 +104,15 @@
class GCSafePointOpnd {
friend class GCSafePoint;
- static const uint32 OBJ_MASK = 0x1;
- static const uint32 REG_MASK = 0x2;
+ static const U_32 OBJ_MASK = 0x1;
+ static const U_32 REG_MASK = 0x2;
#ifdef _EM64T_
- static const uint32 COMPRESSED_MASK = 0x4;
+ static const U_32 COMPRESSED_MASK = 0x4;
#endif
#ifdef GCMAP_TRACK_IDS
// flags + val + mptrOffset + firstId
- static const uint32 IMAGE_SIZE_UINT32 = 4; //do not use sizeof due to the potential struct layout problems
+ static const U_32 IMAGE_SIZE_UINT32 = 4; //do not use sizeof due to the potential struct layout problems
#else
// flags + val + mptrOffset
static const POINTER_SIZE_INT IMAGE_SIZE_UINT32 = 3;
@@ -121,10 +121,10 @@
public:
#ifdef _EM64T_
- GCSafePointOpnd(bool isObject, bool isOnRegister, int32 _val, int32 _mptrOffset, bool isCompressed=false) : val(_val), mptrOffset(_mptrOffset) {
+ GCSafePointOpnd(bool isObject, bool isOnRegister, I_32 _val, I_32 _mptrOffset, bool isCompressed=false) : val(_val), mptrOffset(_mptrOffset) {
flags = flags | (isCompressed ? COMPRESSED_MASK: 0);
#else
- GCSafePointOpnd(bool isObject, bool isOnRegister, int32 _val, int32 _mptrOffset) : val(_val), mptrOffset(_mptrOffset) {
+ GCSafePointOpnd(bool isObject, bool isOnRegister, I_32 _val, I_32 _mptrOffset) : val(_val), mptrOffset(_mptrOffset) {
#endif
flags = isObject ? OBJ_MASK : 0;
flags = flags | (isOnRegister ? REG_MASK: 0);
@@ -143,37 +143,37 @@
bool isCompressed() const { return (flags & COMPRESSED_MASK)!=0;}
#endif
RegName getRegName() const { assert(isOnRegister()); return RegName(val);}
- int32 getDistFromInstESP() const { assert(isOnStack()); return val;}
+ I_32 getDistFromInstESP() const { assert(isOnStack()); return val;}
- int32 getMPtrOffset() const {return mptrOffset;}
+ I_32 getMPtrOffset() const {return mptrOffset;}
void getMPtrOffset(int newOffset) {mptrOffset = newOffset;}
#ifdef GCMAP_TRACK_IDS
- uint32 firstId;
+ U_32 firstId;
#endif
private:
- GCSafePointOpnd(uint32 _flags, int32 _val, int32 _mptrOffset) : flags(_flags), val(_val), mptrOffset(_mptrOffset) {}
+ GCSafePointOpnd(U_32 _flags, I_32 _val, I_32 _mptrOffset) : flags(_flags), val(_val), mptrOffset(_mptrOffset) {}
//first bit is location, second is type
- uint32 flags;
+ U_32 flags;
//opnd placement ->Register or offset
- int32 val;
- int32 mptrOffset;
+ I_32 val;
+ I_32 mptrOffset;
};
class GCMapCreator : public SessionAction {
void runImpl();
- uint32 getNeedInfo()const{ return NeedInfo_LivenessInfo;}
- uint32 getSideEffects() {return Log::isEnabled();}
+ U_32 getNeedInfo()const{ return NeedInfo_LivenessInfo;}
+ U_32 getSideEffects() {return Log::isEnabled();}
bool isIRDumpEnabled(){ return true;}
};
class InfoBlockWriter : public SessionAction {
void runImpl();
- uint32 getNeedInfo()const{ return 0; }
- uint32 getSideEffects()const{ return 0; }
+ U_32 getNeedInfo()const{ return 0; }
+ U_32 getSideEffects()const{ return 0; }
bool isIRDumpEnabled(){ return false; }
};