| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| /** |
| * @author Vyacheslav P. Shakin |
| */ |
| |
| #include "Ia32Inst.h" |
| #include "Ia32IRManager.h" |
| #include "Ia32CFG.h" |
| |
| namespace Jitrino |
| { |
| namespace Ia32{ |
| |
| |
| //================================================================================================= |
| // class Opnd |
| //================================================================================================= |
| |
| //_________________________________________________________________________________________________ |
| void Opnd::assignRegName(RegName r) |
| { |
| r=constraints[ConstraintKind_Calculated].getAliasRegName(r); |
| assert(r!=RegName_Null); |
| memOpndKind=MemOpndKind_Null; |
| regName=r; |
| constraints[ConstraintKind_Location]=Constraint(r); |
| checkConstraints(); |
| } |
| |
| //_________________________________________________________________________________________________ |
| void Opnd::assignImmValue(int64 v) |
| { |
| memOpndKind=MemOpndKind_Null; |
| if (constraints[ConstraintKind_Location].getKind() != OpndKind_Imm) |
| runtimeInfo=NULL; |
| immValue=v; |
| constraints[ConstraintKind_Location]=Constraint(OpndKind_Imm, constraints[ConstraintKind_Initial].getSize()); |
| checkConstraints(); |
| } |
| |
| //_________________________________________________________________________________________________ |
| void Opnd::assignMemLocation(MemOpndKind k, Opnd * _base, Opnd * _index, Opnd * _scale, Opnd * _displacement) |
| { |
| assert(_base||_index||_displacement); |
| assert(!_scale||_index); |
| |
| constraints[ConstraintKind_Location]=Constraint(OpndKind_Mem, constraints[ConstraintKind_Initial].getSize()); |
| memOpndKind=k; |
| |
| checkConstraints(); |
| |
| if (_base) |
| setMemOpndSubOpnd(MemOpndSubOpndKind_Base, _base); |
| else |
| memOpndSubOpnds[MemOpndSubOpndKind_Base]=NULL; |
| if (_index) |
| setMemOpndSubOpnd(MemOpndSubOpndKind_Index, _index); |
| else |
| memOpndSubOpnds[MemOpndSubOpndKind_Index]=NULL; |
| if (_scale) |
| setMemOpndSubOpnd(MemOpndSubOpndKind_Scale, _scale); |
| else |
| memOpndSubOpnds[MemOpndSubOpndKind_Scale]=NULL; |
| if (_displacement) |
| setMemOpndSubOpnd(MemOpndSubOpndKind_Displacement, _displacement); |
| else |
| memOpndSubOpnds[MemOpndSubOpndKind_Displacement]=NULL; |
| |
| } |
| |
| //_________________________________________________________________________________________________ |
| void Opnd::setMemOpndSubOpnd(MemOpndSubOpndKind so, Opnd * opnd) |
| { |
| assert(opnd); |
| assert((so != MemOpndSubOpndKind_Displacement) || (INT_MAX >= opnd->getImmValue() && INT_MIN <= opnd->getImmValue())); |
| assert((so != MemOpndSubOpndKind_Scale) || ((uint64)opnd->getImmValue() <= 8)); |
| assert(memOpndKind!=MemOpndKind_Null); |
| memOpndSubOpnds[so]=opnd; |
| } |
| |
| //_________________________________________________________________________________________________ |
| bool Opnd::replaceMemOpndSubOpnd(Opnd * opndOld, Opnd * opndNew) |
| { |
| bool replaced = false; |
| if (memOpndKind != MemOpndKind_Null){ |
| assert(isPlacedIn(OpndKind_Mem)); |
| for (U_32 i=0; i<MemOpndSubOpndKind_Count; i++) { |
| if (memOpndSubOpnds[i]!=NULL && memOpndSubOpnds[i]==opndOld) { |
| setMemOpndSubOpnd((MemOpndSubOpndKind)i, opndNew); |
| replaced = true; |
| } |
| } |
| if (replaced) { |
| normalizeMemSubOpnds(); |
| } |
| } |
| return replaced; |
| } |
| |
| //_________________________________________________________________________________________________ |
| bool Opnd::replaceMemOpndSubOpnds(Opnd * const * opndMap) |
| { |
| bool replaced = false; |
| if (memOpndKind != MemOpndKind_Null){ |
| assert(isPlacedIn(OpndKind_Mem)); |
| for (U_32 i=0; i<MemOpndSubOpndKind_Count; i++) { |
| if (memOpndSubOpnds[i]!=NULL && opndMap[memOpndSubOpnds[i]->id]!=NULL){ |
| setMemOpndSubOpnd((MemOpndSubOpndKind)i, opndMap[memOpndSubOpnds[i]->id]); |
| replaced = true; |
| } |
| } |
| if (replaced) { |
| normalizeMemSubOpnds(); |
| } |
| } |
| return replaced; |
| } |
| |
| |
| void Opnd::normalizeMemSubOpnds(void) |
| { |
| if (!isPlacedIn(OpndKind_Mem)) { |
| return; |
| } |
| Opnd* base = getMemOpndSubOpnd(MemOpndSubOpndKind_Base); |
| Opnd* disp = getMemOpndSubOpnd(MemOpndSubOpndKind_Displacement); |
| if (base != NULL && base->isPlacedIn(OpndKind_Imm)) { |
| assert(disp == NULL || !disp->isPlacedIn(OpndKind_Imm) || base->getType()->isNullObject()); |
| setMemOpndSubOpnd(MemOpndSubOpndKind_Displacement, base); |
| // can't call setMemOpndSubOpnd() as it fights against zero opnd. |
| memOpndSubOpnds[MemOpndSubOpndKind_Base] = disp; //==setMemOpndSubOpnd(MemOpndSubOpndKind_Base, disp); |
| } |
| } |
| |
| #ifdef _DEBUG |
| //_________________________________________________________________________________________________ |
| void Opnd::checkConstraints() |
| { |
| assert(constraints[ConstraintKind_Initial].contains(constraints[ConstraintKind_Calculated])); |
| assert(constraints[ConstraintKind_Calculated].contains(constraints[ConstraintKind_Location])); |
| } |
| #endif |
| |
| //_________________________________________________________________________________________________ |
| void Opnd::setCalculatedConstraint(Constraint c) |
| { |
| constraints[ConstraintKind_Calculated]=c & constraints[ConstraintKind_Initial]; |
| checkConstraints(); |
| assert(!constraints[ConstraintKind_Calculated].isNull()); |
| } |
| |
| //_________________________________________________________________________________________________ |
| void Opnd::addRefCount(U_32& index, U_32 blockExecCount) |
| { |
| if (blockExecCount==0) |
| blockExecCount=1; |
| refCount++; |
| if (id==EmptyUint32) |
| id=index++; |
| if (memOpndKind != MemOpndKind_Null){ |
| for (U_32 i=0; i<MemOpndSubOpndKind_Count; i++) |
| if (memOpndSubOpnds[i]!=NULL){ |
| memOpndSubOpnds[i]->addRefCount(index, blockExecCount); |
| } |
| } |
| } |
| |
| //_________________________________________________________________________________________________ |
| void Opnd::setDefiningInst(Inst * inst) |
| { |
| if (defScope==DefScope_Temporary||defScope==DefScope_Null){ |
| if (definingInst==NULL){ |
| defScope=DefScope_Temporary; |
| definingInst=inst; |
| }else{ |
| if (inst->getNode()==definingInst->getNode()) |
| defScope=DefScope_SemiTemporary; |
| else{ |
| defScope=DefScope_Variable; |
| } |
| definingInst=NULL; |
| } |
| } |
| } |
| |
| //================================================================================================= |
| // class Inst |
| //================================================================================================= |
| void* Inst::operator new(size_t sz, MemoryManager& mm, U_32 opndCount) |
| { |
| Inst * p = (Inst*)mm.alloc(sz + Inst::getOpndChunkSize(opndCount)); |
| p->allocatedOpndCount = opndCount; p->opnds = (Opnd**)((U_8*)p + sz); |
| return p; |
| } |
| |
| //_________________________________________________________________________________________________ |
| void Inst::insertOpnd(U_32 idx, Opnd * opnd, U_32 roles) |
| { |
| assert(opndCount < allocatedOpndCount); |
| |
| if (idx < defOpndCount) |
| roles |= OpndRole_Def; |
| |
| if (roles & OpndRole_Def){ |
| if (idx > defOpndCount) |
| idx = defOpndCount; |
| defOpndCount++; |
| } |
| |
| if (idx > opndCount) |
| idx = opndCount; |
| |
| U_32 * opndRoles = getOpndRoles(); |
| Constraint * opndConstraints = getConstraints(); |
| |
| for (U_32 i = opndCount; i > idx; i--){ |
| opnds[i] = opnds[i - 1]; |
| opndRoles[i] = opndRoles[i - 1]; |
| opndConstraints[i] = opndConstraints[i - 1]; |
| } |
| |
| opnds[idx] = opnd; |
| opndRoles[idx] = roles; |
| |
| opndCount++; |
| } |
| |
| //_________________________________________________________________________________________________ |
| U_32 Inst::countOpnds(U_32 roles)const |
| { |
| U_32 count=0; |
| if ( (roles & OpndRole_InstLevel) != 0 ){ |
| const U_32 * opndRoles = getOpndRoles(); |
| for (U_32 i = 0, n = opndCount; i < n; i++){ |
| U_32 r = opndRoles [i]; |
| if ( (r & roles & OpndRole_FromEncoder) != 0 && (r & roles & OpndRole_ForIterator) != 0 ) |
| count++; |
| } |
| } |
| if ( (roles & OpndRole_OpndLevel) != 0 && (roles & OpndRole_Use) != 0 ){ |
| for (U_32 i = 0, n = opndCount; i < n; i++){ |
| const Opnd * opnd = opnds[i]; |
| if ( opnd->memOpndKind != MemOpndKind_Null ){ |
| const Opnd * const * subOpnds = opnd->getMemOpndSubOpnds(); |
| for (U_32 j = 0; j < MemOpndSubOpndKind_Count; j++){ |
| const Opnd * subOpnd = subOpnds[j]; |
| if (subOpnd != NULL) |
| count++; |
| } |
| } |
| } |
| } |
| return count; |
| } |
| |
| //_________________________________________________________________________________________________ |
| Constraint Inst::getConstraint(U_32 idx, U_32 memOpndMask, OpndSize size) const |
| { |
| Constraint c(OpndKind_Any); |
| if (idx < opndCount){ |
| const U_32 * opndRoles = getOpndRoles(); |
| const Constraint * constraints = getConstraints(); |
| c = constraints[idx]; |
| if ((opndRoles[idx] & OpndRole_Explicit) && (properties & Inst::Properties_MemoryOpndConditional)){ |
| bool removeMemory = false; |
| if (memOpndMask == 0xFFFFFFFF){// Strong constraint requested |
| removeMemory = true; |
| } else if (memOpndMask != 0) { |
| for (unsigned j = 0; j < opndCount; j++) { |
| if (j != idx && ((1 << j) & memOpndMask) && (opndRoles[j] & OpndRole_Explicit)) { |
| if (getOpnd(j)->getConstraint(Opnd::ConstraintKind_Location).getKind() == OpndKind_Mem){ |
| removeMemory = true; |
| break; |
| } |
| } |
| } |
| } |
| if (removeMemory) |
| c = Constraint((OpndKind)(c.getKind() &~ OpndKind_Mem), c.getSize(), c.getMask()); |
| } |
| }else{ |
| c = opnds[(idx - opndCount) / 4]->getMemOpndSubOpndConstraint((MemOpndSubOpndKind)((idx - opndCount) & 3)); |
| } |
| return size==OpndSize_Null?c:c.getAliasConstraint(size); |
| } |
| |
| //_________________________________________________________________________________________________ |
| void Inst::setOpnd(U_32 index, Opnd * opnd) |
| { |
| Opnd ** opnds = getOpnds(); |
| if (index < opndCount) { |
| Constraint cc = opnds[index]->getConstraint(Opnd::ConstraintKind_Initial); |
| opnds[index] = opnd; |
| if(!hasKind(Kind_PseudoInst) |
| && (getOpndRoles()[index] & OpndRole_Explicit) |
| && cc != opnd->getConstraint(Opnd::ConstraintKind_Initial) |
| && !Encoder::isOpndAllowed(opcodeGroup, getExplicitOpndIndexFromOpndRoles(getOpndRoles()[index]), opnd->getConstraint(Opnd::ConstraintKind_Initial), getForm()==Form_Extended, true) |
| ) { |
| |
| BasicBlock * bb = getBasicBlock(); |
| |
| //instruction must be inserted into a basic block to be modifiable. |
| //it caused by necessity of reference to irManager for implicit operands |
| //assigning (flags, for example) |
| assert(bb); |
| assignOpcodeGroup(&bb->getIRManager()); |
| assert(opcodeGroup); |
| } |
| |
| } else{ |
| opnds[(index - opndCount) / 4]->setMemOpndSubOpnd((MemOpndSubOpndKind)((index - opndCount) & 3), opnd); |
| } |
| verify(); |
| } |
| |
| //_________________________________________________________________________________________________ |
| bool Inst::replaceOpnd(Opnd * oldOpnd, Opnd * newOpnd, U_32 opndRoleMask) |
| { |
| bool replaced = false; |
| assert(newOpnd != NULL); |
| for (U_32 i=0, n=getOpndCount(); i<n; i++){ |
| U_32 opndRole=getOpndRoles(i); |
| Opnd * opnd=getOpnd(i); |
| if ( |
| (opndRole&opndRoleMask&OpndRole_FromEncoder)!=0 && |
| (opndRole&opndRoleMask&OpndRole_InstLevel)!=0 |
| ){ |
| if (opnd==oldOpnd){ |
| assert((opndRole&OpndRole_Changeable)!=0); |
| setOpnd(i, newOpnd); |
| opnd=newOpnd; |
| replaced = true; |
| } |
| } |
| if ((opndRoleMask&OpndRole_OpndLevel)!=0 && |
| (opndRoleMask&OpndRole_Use)!=0) |
| replaced |= opnd->replaceMemOpndSubOpnd(oldOpnd, newOpnd); |
| } |
| return replaced; |
| } |
| |
| bool Inst::getPureDefProperty() const { |
| if (getProperties() & Properties_PureDef) { |
| assert(getOpndCount(OpndRole_InstLevel|OpndRole_Use)==2); |
| Opnd * use = NULL; |
| for (U_32 i=0, n=getOpndCount(); i<n; i++){ |
| if (getOpndRoles(i)&OpndRole_Use) { |
| if(!use) { |
| use = getOpnd(i); |
| } else { |
| return use == getOpnd(i); |
| } |
| } |
| } |
| } |
| return false; |
| } |
| //_________________________________________________________________________________________________ |
| bool Inst::replaceOpnds(Opnd * const * opndMap, U_32 opndRoleMask) |
| { |
| bool replaced = false; |
| for (U_32 i=0, n=getOpndCount(); i<n; i++){ |
| U_32 opndRole=getOpndRoles(i); |
| if ( |
| (opndRole&opndRoleMask&OpndRole_FromEncoder)!=0 && |
| (opndRole&opndRoleMask&OpndRole_ForIterator)!=0 |
| ){ |
| Opnd * opnd=getOpnd(i); |
| Opnd * newOpnd=opndMap[opnd->getId()]; |
| if (newOpnd!=NULL){ |
| assert((opndRole&OpndRole_Changeable)!=0); |
| setOpnd(i, newOpnd); |
| opnd=newOpnd; |
| replaced = true; |
| } |
| if ((opndRoleMask&OpndRole_OpndLevel)!=0) |
| replaced |= opnd->replaceMemOpndSubOpnds(opndMap); |
| } |
| } |
| return replaced; |
| } |
| |
| //_________________________________________________________________________________________________ |
| void Inst::swapOperands(U_32 idx0, U_32 idx1) |
| { |
| Opnd * opnd0=getOpnd(idx0), * opnd1=getOpnd(idx1); |
| setOpnd(idx1, opnd0); |
| setOpnd(idx0, opnd1); |
| verify(); |
| } |
| |
| //_________________________________________________________________________________________________ |
| void Inst::changeInstCondition(ConditionMnemonic cc, IRManager * irManager) |
| { |
| assert(getProperties()&Properties_Conditional); |
| Mnemonic baseMnemonic=getBaseConditionMnemonic(mnemonic); |
| assert(baseMnemonic!=Mnemonic_Null); |
| mnemonic=(Mnemonic)(baseMnemonic+cc); |
| assignOpcodeGroup(irManager); |
| assert(opcodeGroup!=NULL); |
| } |
| |
| //_________________________________________________________________________________________________ |
| void Inst::reverse(IRManager * irManager) |
| { |
| assert(canReverse()); |
| Mnemonic baseMnemonic=getBaseConditionMnemonic(mnemonic); |
| assert(baseMnemonic!=Mnemonic_Null); |
| changeInstCondition(reverseConditionMnemonic((ConditionMnemonic)(mnemonic-baseMnemonic)), irManager); |
| } |
| |
| //_________________________________________________________________________________________________ |
| U_8* Inst::emit(U_8* stream) |
| { |
| U_8 * instEnd = stream; |
| if (!hasKind(Inst::Kind_PseudoInst)){ |
| assert(mnemonic!=Mnemonic_Null); |
| assert(form==Form_Native); |
| instEnd = Encoder::emit(stream, this); |
| } |
| setCodeSize((U_32)(instEnd - stream)); |
| return instEnd; |
| } |
| |
| //_________________________________________________________________________________________________ |
| void Inst::initFindInfo(Encoder::FindInfo& fi, Opnd::ConstraintKind opndConstraintKind)const |
| { |
| Opnd * const * opnds = getOpnds(); |
| const U_32 * roles = getOpndRoles(); |
| U_32 count = 0, defCount = 0, defCountFromInst = defOpndCount; |
| for (U_32 i=0, n=opndCount; i<n; i++){ |
| U_32 r = roles[i]; |
| if (r & Inst::OpndRole_Explicit){ |
| fi.opndConstraints[count++] = opnds[i]->getConstraint(opndConstraintKind); |
| if (i < defCountFromInst) |
| defCount++; |
| } |
| } |
| fi.defOpndCount = defCount; |
| fi.opndCount = count; |
| fi.opcodeGroup= opcodeGroup; |
| fi.mnemonic = mnemonic; |
| fi.isExtended = (Form)form == Form_Extended; |
| } |
| |
| //_________________________________________________________________________________________________ |
| void Inst::fixOpndsForOpcodeGroup(IRManager * irManager) |
| { |
| U_32 handledExplicitOpnds = 0, handledImplicitOpnds = 0; |
| |
| U_32 * roles = getOpndRoles(); |
| Constraint * constraints = getConstraints(); |
| |
| Form f = getForm(); |
| |
| for (U_32 i=0, n=opndCount; i<n; i++){ |
| if (roles[i] & Inst::OpndRole_Explicit){ |
| U_32 idx, r; |
| if (f == Form_Native){ |
| idx = handledExplicitOpnds; |
| r = Encoder::getOpndRoles(opcodeGroup->opndRoles, idx); |
| if ( (r & OpndRole_Def) != 0 && defOpndCount<=i) |
| defOpndCount = i + 1; |
| }else{ |
| idx = opcodeGroup->extendedToNativeMap[handledExplicitOpnds]; |
| r = i < defOpndCount ? OpndRole_Def : OpndRole_Use; |
| } |
| r |= Inst::OpndRole_Explicit | (handledExplicitOpnds << 16); |
| roles[i] = r; |
| constraints[i] = opcodeGroup->opndConstraints[idx]; |
| handledExplicitOpnds++; |
| }else if (roles[i] & Inst::OpndRole_Implicit){ |
| assert(handledImplicitOpnds < opcodeGroup->implicitOpndRoles.count); |
| assert(opnds[i]->getRegName() == opcodeGroup->implicitOpndRegNames[handledImplicitOpnds]); |
| handledImplicitOpnds++; |
| } |
| } |
| |
| for (U_32 i = handledImplicitOpnds; i < opcodeGroup->implicitOpndRoles.count; i++){ |
| RegName iorn = opcodeGroup->implicitOpndRegNames[i]; |
| Opnd * implicitOpnd = irManager->getRegOpnd(iorn); |
| U_32 implicitOpndRoles = |
| Encoder::getOpndRoles(opcodeGroup->implicitOpndRoles, i) | Inst::OpndRole_Implicit; |
| if (implicitOpndRoles & OpndRole_Def){ |
| insertOpnd(defOpndCount, implicitOpnd, implicitOpndRoles); |
| constraints[defOpndCount - 1] = Constraint(iorn); |
| }else{ |
| insertOpnd(opndCount, implicitOpnd, implicitOpndRoles); |
| constraints[opndCount - 1] = Constraint(iorn); |
| } |
| } |
| } |
| |
| //_________________________________________________________________________________________________ |
| void Inst::assignOpcodeGroup(IRManager * irManager) |
| { |
| if (hasKind(Inst::Kind_PseudoInst)){ |
| assert(getForm() == Form_Extended); |
| opcodeGroup= (Encoder::OpcodeGroup *)Encoder::getDummyOpcodeGroup(); |
| U_32 * roles = getOpndRoles(); |
| U_32 i = 0; |
| for (U_32 n = defOpndCount; i < n; i++) |
| roles[i] = OpndRole_Auxilary | OpndRole_Def; |
| for (U_32 n = opndCount; i < n; i++) |
| roles[i] = OpndRole_Auxilary | OpndRole_Use; |
| }else{ |
| Encoder::FindInfo fi; |
| initFindInfo(fi, Opnd::ConstraintKind_Initial); |
| opcodeGroup=(Encoder::OpcodeGroup *)Encoder::findOpcodeGroup(fi); |
| assert(opcodeGroup); // Checks that the requested mnemonic is implemented in Ia32EncodingTable |
| fixOpndsForOpcodeGroup(irManager); |
| } |
| properties = opcodeGroup->properties; |
| } |
| |
| //_________________________________________________________________________________________________ |
| void Inst::makeNative(IRManager * irManager) |
| { |
| if (getForm()==Form_Native || hasKind(Kind_PseudoInst) ) |
| return; |
| assert(opcodeGroup); |
| |
| Node* bb = getNode(); |
| |
| U_32 * opndRoles = getOpndRoles(); |
| Constraint * constraints = getConstraints(); |
| |
| I_32 defs[IRMaxNativeOpnds]={ -1, -1, -1, -1 }; |
| for (U_32 i=0; i<opndCount; i++){ |
| U_32 r = opndRoles[i]; |
| if ((r & OpndRole_Explicit) == 0) continue; |
| U_32 extendedIdx = r >> 16; |
| U_32 nativeIdx = opcodeGroup->extendedToNativeMap[extendedIdx]; |
| assert(nativeIdx < IRMaxNativeOpnds); |
| I_32 defNativeIdx = defs[nativeIdx]; |
| if (defNativeIdx != -1){ |
| assert(i >= defOpndCount); |
| opndRoles[defNativeIdx] |= OpndRole_Use; |
| if (bb && opnds[defNativeIdx] != opnds[i]){ |
| Inst * moveInst=irManager->newCopySequence(Mnemonic_MOV, opnds[defNativeIdx], opnds[i]); |
| moveInst->insertBefore(this); |
| } |
| opnds[i] = NULL; |
| }else |
| defs[nativeIdx] = i; |
| } |
| |
| U_32 packedOpnds = 0, explicitOpnds = 0; |
| for (U_32 i = 0, n = opndCount; i < n; i++){ |
| if (opnds[i] == NULL) continue; |
| U_32 r = opndRoles[i]; |
| if ((r & OpndRole_Explicit) != 0){ |
| r = (r & 0xffff) | (explicitOpnds << 16); |
| explicitOpnds++; |
| } |
| if (i > packedOpnds){ |
| opnds[packedOpnds] = opnds[i]; |
| constraints[packedOpnds] = constraints[i]; |
| opndRoles[packedOpnds] = r; |
| } |
| packedOpnds++; |
| } |
| |
| opndCount=packedOpnds; |
| form = Form_Native; |
| } |
| |
| //_________________________________________________________________________________________________ |
| void * Inst::getCodeStartAddr() const |
| { |
| if (hasKind(Inst::Kind_PseudoInst)) { |
| return (void*)(POINTER_SIZE_INT)0xDEADBEEF; |
| } |
| BasicBlock* bb = getBasicBlock(); |
| return bb!=NULL?(U_8*)bb->getCodeStartAddr()+codeOffset:0; |
| } |
| |
| |
| //_________________________________________________________________________________________________ |
| Edge::Kind Inst::getEdgeKind(const Edge* edge) const |
| { |
| assert(edge->getSourceNode()->isBlockNode() && edge->getTargetNode()->isBlockNode()); |
| assert (!hasKind(Inst::Kind_BranchInst) && !hasKind(Inst::Kind_SwitchInst)); |
| return Edge::Kind_Unconditional; |
| } |
| |
| //========================================================================================================= |
| // class GCInfoPseudoInst |
| //========================================================================================================= |
| |
| GCInfoPseudoInst::GCInfoPseudoInst(IRManager* irm, int id) |
| : Inst(Mnemonic_NULL, id, Inst::Form_Extended), |
| offsets(irm->getMemoryManager()), desc(NULL) |
| { |
| kind = Kind_GCInfoPseudoInst; |
| } |
| |
| //================================================================================================= |
| // class BranchInst |
| //================================================================================================= |
| |
| void BranchInst::reverse(IRManager * irManager) |
| { |
| assert(canReverse()); |
| assert(node->isConnectedTo(true, trueTarget) && node->isConnectedTo(true, falseTarget)); |
| ControlTransferInst::reverse(irManager); |
| Node* tmp = trueTarget; |
| trueTarget = falseTarget; |
| falseTarget = tmp; |
| } |
| |
| //_________________________________________________________________________________________________ |
| Edge::Kind BranchInst::getEdgeKind(const Edge* edge) const |
| { |
| Node* node = edge->getTargetNode(); |
| if (node == trueTarget) { |
| return Edge::Kind_True; |
| } |
| assert(node == falseTarget); |
| return Edge::Kind_False; |
| } |
| |
| //_________________________________________________________________________________________________ |
| bool BranchInst::canReverse() const |
| { |
| return node!=NULL && isDirect() && ControlTransferInst::canReverse(); |
| } |
| |
| //_________________________________________________________________________________________________ |
| // called from CFG when edge target is replaced |
| void BranchInst::updateControlTransferInst(Node* oldTarget, Node* newTarget) |
| { |
| if (!newTarget->isBlockNode()) { |
| assert(newTarget->isDispatchNode()); |
| return; |
| } |
| if (oldTarget == trueTarget) { |
| trueTarget = newTarget; |
| } else { |
| assert(oldTarget == falseTarget); |
| falseTarget = newTarget; |
| } |
| } |
| |
| //_________________________________________________________________________________________________ |
| // called from CFG when 2 blocks are merging and one of the branches is redundant. |
| void BranchInst::removeRedundantBranch() |
| { |
| unlink(); |
| }; |
| |
| //_________________________________________________________________________________________________ |
| void BranchInst::verify() const |
| { |
| Inst::verify(); |
| assert(trueTarget!=NULL && falseTarget!=NULL); |
| assert(trueTarget->isBlockNode() && falseTarget->isBlockNode()); |
| assert(node->isConnectedTo(true, trueTarget)); |
| assert(node->isConnectedTo(true, falseTarget)); |
| } |
| |
| //========================================================================================================= |
| // class SwitchInst |
| //========================================================================================================= |
| |
| ConstantAreaItem * SwitchInst::getConstantAreaItem() const |
| { |
| return (ConstantAreaItem *)tableAddrRI->getValue(0); |
| } |
| |
| Node* SwitchInst::getTarget(U_32 i)const |
| { |
| ConstantAreaItem * cai = getConstantAreaItem(); |
| assert(i<cai->getSize()/sizeof(Node*)); |
| return ((Node**)cai->getValue())[i]; |
| } |
| |
| //_________________________________________________________________________________________________ |
| Edge::Kind SwitchInst::getEdgeKind(const Edge* edge) const |
| { |
| #ifdef _DEBUG |
| Node* target = edge->getTargetNode(); |
| assert(target->isBlockNode()); |
| bool found = false; |
| for (U_32 i =0 ; i < getNumTargets(); i++) { |
| Node* myTarget = getTarget(i); |
| if (myTarget == target) { |
| found = true; |
| break; |
| } |
| } |
| assert(found); |
| #endif |
| return Edge::Kind_Unconditional; |
| } |
| |
| //_________________________________________________________________________________________________ |
| U_32 SwitchInst::getNumTargets() const |
| { |
| return getConstantAreaItem()->getSize() / sizeof(Node*); |
| } |
| |
| //_________________________________________________________________________________________________ |
| void SwitchInst::setTarget(U_32 i, Node* bb) |
| { |
| assert(bb->isBlockNode()); |
| |
| ConstantAreaItem * cai = getConstantAreaItem(); |
| assert(i<cai->getSize()/sizeof(Node*)); |
| ((Node**)cai->getValue())[i]=bb; |
| } |
| |
| //_________________________________________________________________________________________________ |
| void SwitchInst::replaceTarget(Node * bbFrom, Node * bbTo) |
| { |
| assert(bbTo->isBlockNode()); |
| ConstantAreaItem * cai = getConstantAreaItem(); |
| Node** bbs=(Node**)cai->getValue(); |
| #ifdef _DEBUG |
| bool found = false; |
| #endif |
| for (U_32 i=0, n=cai->getSize()/sizeof(Node*); i<n; i++) { |
| if (bbs[i]==bbFrom) { |
| #ifdef _DEBUG |
| found = true; |
| #endif |
| bbs[i]=bbTo; |
| } |
| } |
| assert(found); |
| } |
| |
| //_________________________________________________________________________________________________ |
| // called from CFG when edge target is replaced |
| void SwitchInst::updateControlTransferInst(Node* oldTarget, Node* newTarget) |
| { |
| if (!newTarget->isBlockNode()) { |
| assert(newTarget->isDispatchNode()); |
| return; |
| } |
| replaceTarget(oldTarget, newTarget); |
| } |
| |
| //_________________________________________________________________________________________________ |
| // called from CFG when 2 blocks are merging and one of the branches is redundant. |
| void SwitchInst::removeRedundantBranch() |
| { |
| unlink(); |
| } |
| |
| //_________________________________________________________________________________________________ |
| Opnd * SwitchInst::getTableAddress() const |
| { |
| return tableAddr; |
| } |
| |
| //_________________________________________________________________________________________________ |
| void SwitchInst::verify() const |
| { |
| Inst::verify(); |
| #ifdef _DEBUG |
| for (U_32 i=0, n = getNumTargets(); i<n; ++i) { |
| Node* target = getTarget(i); |
| assert(target!=NULL && target->isBlockNode()); |
| assert(node->isConnectedTo(true, target)); |
| } |
| #endif |
| } |
| |
| |
| //========================================================================================================= |
| // class CallingConventionClient |
| //========================================================================================================= |
| //_________________________________________________________________________________________________ |
| void JumpInst::verify() const { |
| Inst::verify(); |
| #ifdef _DEBUG |
| if (node!=NULL) { |
| assert(node->getOutDegree()==1 || node->getOutDegree()==2); |
| assert(node->getUnconditionalEdge()!=NULL); |
| assert(node->getOutDegree() == 1 || node->getExceptionEdge()!=NULL); |
| } |
| #endif |
| } |
| |
| //========================================================================================================= |
| // class CallingConventionClient |
| //========================================================================================================= |
| //_________________________________________________________________________________________________ |
| void CallingConventionClient::finalizeInfos(Inst::OpndRole role, CallingConvention::ArgKind argKind) |
| { |
| U_32 slotNumber=0; |
| StlVector<CallingConvention::OpndInfo> & infos = getInfos(role); |
| |
| assert(callingConvention != NULL); |
| |
| callingConvention->getOpndInfo(argKind, (U_32)infos.size(), |
| infos.empty() ? (CallingConvention::OpndInfo*)NULL : &infos.front()); |
| |
| for (U_32 i = 0, n = (U_32)infos.size(); i != n; i++) { |
| U_32 index = callingConvention->pushLastToFirst() ? i : (n - 1 - i); |
| CallingConvention::OpndInfo & info = infos[index]; |
| for (U_32 j = 0; j < info.slotCount; j++) { |
| if (!info.isReg) |
| info.slots[j] = 0xFFFF & slotNumber++; |
| } |
| } |
| unsigned stackOpndSize = slotNumber * sizeof(POINTER_SIZE_INT); |
| unsigned stackAlignmentSize = 0; |
| |
| if (argKind == CallingConvention::ArgKind_InArg) { |
| // Compute stack alignment. |
| unsigned stackOnEnterSize = stackOpndSize + sizeof(POINTER_SIZE_INT); |
| unsigned alignment = (callingConvention->getStackAlignment() == STACK_ALIGN_HALF16) |
| ? STACK_ALIGN16 : callingConvention->getStackAlignment(); |
| |
| if (alignment != 0 && (stackOnEnterSize & (alignment - 1))) { |
| stackAlignmentSize = alignment - (stackOnEnterSize & (alignment - 1)); |
| } |
| } |
| |
| stackOpndSize += stackAlignmentSize; |
| |
| (role == Inst::OpndRole_Def ? defArgStackDepth : useArgStackDepth) = stackOpndSize; |
| (role == Inst::OpndRole_Def ? defArgStackDepthAlignment : useArgStackDepthAlignment) = stackAlignmentSize; |
| } |
| |
| //_________________________________________________________________________________________________ |
| void CallingConventionClient::layoutAuxilaryOpnds(Inst::OpndRole role, OpndKind kindForStackArgs) |
| { |
| StlVector<CallingConvention::OpndInfo> & infos = getInfos(role); |
| StlVector<StackOpndInfo> & stackOpndInfos = getStackOpndInfos(role); |
| U_32 slotSize=sizeof(POINTER_SIZE_INT); |
| U_32 regArgCount=0, stackArgCount=0; |
| Inst::Opnds opnds(ownerInst, Inst::OpndRole_Auxilary|role); |
| Inst::Opnds::iterator handledOpnds=opnds.begin(); |
| for (U_32 i=0, n=(U_32)infos.size(); i<n; i++){ |
| const CallingConvention::OpndInfo& info=infos[i]; |
| #ifdef _DEBUG |
| bool eachSlotRequiresOpnd=false; |
| #endif |
| U_32 offset=0; |
| for (U_32 j=0, cbCurrent=0; j<info.slotCount; j++){ |
| Opnd * opnd=opnds.getOpnd(handledOpnds); |
| OpndSize sz=opnd->getSize(); |
| U_32 cb=getByteSize(sz); |
| RegName r=(RegName)info.slots[j]; |
| if (info.isReg) { |
| r=Constraint::getAliasRegName(r,sz); |
| assert(r!=RegName_Null); |
| #ifdef _DEBUG |
| eachSlotRequiresOpnd=true; |
| #endif |
| cbCurrent+=getByteSize(getRegSize(r)); |
| }else{ |
| if (cbCurrent==0) |
| offset=(info.slots[j] & 0xffff)*slotSize; |
| cbCurrent+=slotSize; |
| } |
| |
| if (cbCurrent>=cb){ |
| if (info.isReg){ |
| ownerInst->setConstraint(handledOpnds, r); |
| regArgCount++; |
| }else{ |
| ownerInst->setConstraint(handledOpnds, Constraint(kindForStackArgs, sz)); |
| stackArgCount++; |
| StackOpndInfo sainfo={ handledOpnds, offset }; |
| stackOpndInfos.push_back(sainfo); |
| } |
| handledOpnds = opnds.next(handledOpnds); |
| #ifdef _DEBUG |
| eachSlotRequiresOpnd=false; |
| #endif |
| cbCurrent=0; |
| } |
| #ifdef _DEBUG |
| assert(!eachSlotRequiresOpnd); |
| #endif |
| } |
| } |
| if (stackArgCount>0) |
| sort(stackOpndInfos.begin(), stackOpndInfos.end()); |
| assert(handledOpnds == opnds.end()); |
| assert(stackArgCount==stackOpndInfos.size()); |
| } |
| |
| |
| //========================================================================================================= |
| // class EntryPointPseudoInst |
| //========================================================================================================= |
| EntryPointPseudoInst::EntryPointPseudoInst(IRManager * irm, int id, const CallingConvention * cc) |
| #ifdef _EM64T_ |
| : Inst(Mnemonic_NULL, id, Inst::Form_Extended), thisOpnd(0), callingConventionClient(irm->getMemoryManager(), cc) |
| #else |
| : Inst(Mnemonic_NULL, id, Inst::Form_Extended), callingConventionClient(irm->getMemoryManager(), cc) |
| #endif |
| { kind=Kind_EntryPointPseudoInst; callingConventionClient.setOwnerInst(this); } |
| //_________________________________________________________________________________________________________ |
| Opnd * EntryPointPseudoInst::getDefArg(U_32 i)const |
| { |
| return NULL; |
| } |
| |
| |
| //================================================================================================= |
| // class CallInst |
| //================================================================================================= |
| //_________________________________________________________________________________________________ |
| CallInst::CallInst(IRManager * irm, int id, const CallingConvention * cc, Opnd::RuntimeInfo* rri) |
| : ControlTransferInst(Mnemonic_CALL, id), callingConventionClient(irm->getMemoryManager(), cc), runtimeInfo(rri) |
| { |
| kind=Kind_CallInst; |
| callingConventionClient.setOwnerInst(this); |
| } |
| |
| //================================================================================================= |
| // class RetInst |
| //================================================================================================= |
| //_________________________________________________________________________________________________ |
| RetInst::RetInst(IRManager * irm, int id) |
| : ControlTransferInst(Mnemonic_RET, id), |
| callingConventionClient(irm->getMemoryManager(), irm->getCallingConvention()) |
| { |
| kind=Kind_RetInst; |
| callingConventionClient.setOwnerInst(this); |
| } |
| |
| |
| }}; // namespace Ia32 |
| |
| |
| |
