TTAProgram::InstructionReferenceManager Class Reference

#include <InstructionReferenceManager.hh>

Inheritance diagram for TTAProgram::InstructionReferenceManager:

Collaboration diagram for TTAProgram::InstructionReferenceManager:

Classes
class	Iterator

Public Types
typedef std::map< Instruction *, InstructionReferenceImpl * >	RefMap
	Map for instruction references. faster to search than list. More...

Public Member Functions
	InstructionReferenceManager ()
virtual	~InstructionReferenceManager ()
InstructionReference	createReference (Instruction &ins)
void	replace (Instruction &insA, Instruction &insB)
void	clearReferences ()
bool	hasReference (Instruction &ins) const
unsigned int	referenceCount (Instruction &ins) const
void	referenceDied (Instruction *ins)
void	validate ()
Iterator	begin ()
Iterator	end ()

Private Member Functions
	InstructionReferenceManager (const InstructionReferenceManager &)
InstructionReferenceManager &	operator= (const InstructionReferenceManager &)

Private Attributes
RefMap	references_
	Instruction references to maintain. More...

Detailed Description

Helps in keeping instructions referenced in POM up-to-date.

Instructions are not referenced directly, but through an InstructionReference instance. The actual Instruction instance referred can be changed as needed.

Definition at line 82 of file InstructionReferenceManager.hh.

Member Typedef Documentation

RefMap

typedef std::map<Instruction*, InstructionReferenceImpl*> TTAProgram::InstructionReferenceManager::RefMap

Map for instruction references. faster to search than list.

Definition at line 85 of file InstructionReferenceManager.hh.

Constructor & Destructor Documentation

InstructionReferenceManager() [1/2]

TTAProgram::InstructionReferenceManager::InstructionReferenceManager

(

)

Constructor.

Note

Should not be instantiated independent of a Program instance.

Definition at line 54 of file InstructionReferenceManager.cc.

                                                         {
}

~InstructionReferenceManager()

TTAProgram::InstructionReferenceManager::~InstructionReferenceManager ( )

virtual

Destructor. Clears all instruction references.

Definition at line 60 of file InstructionReferenceManager.cc.

                                                          {
//    assert(references_.empty());
    clearReferences();
}

References clearReferences().

Here is the call graph for this function:

InstructionReferenceManager() [2/2]

TTAProgram::InstructionReferenceManager::InstructionReferenceManager ( const InstructionReferenceManager &  )

private

Member Function Documentation

begin()

Iterator TTAProgram::InstructionReferenceManager::begin ( )

inline

Referenced by ControlFlowGraph::computeLeadersFromRefManager(), and validate().

clearReferences()

void TTAProgram::InstructionReferenceManager::clearReferences

(

)

Clears all instruction references.

The result is a totally empty instruction reference manager. This nullifies all instructionreferences handled by this reference manager.

Definition at line 125 of file InstructionReferenceManager.cc.

                                             {
    // nullify modifies so take new iter every round.
    for (RefMap::iterator iter = references_.begin(); 
         iter != references_.end(); iter = references_.begin()) {
        assert(iter->second != NULL);
        // nullify causes use count to drop to 0 which kills this.
        iter->second->nullify();
    }
    references_.clear();
}

References assert, and references_.

Referenced by ~InstructionReferenceManager().

createReference()

InstructionReference TTAProgram::InstructionReferenceManager::createReference

(

Instruction &

ins

)

Creates a new reference to an instruction.

Parameters

ins	Referred instruction.

Returns

A new reference to an instruction, or if one already exists, return it.

Definition at line 73 of file InstructionReferenceManager.cc.

                                                             {
    RefMap::const_iterator iter = references_.find(&ins);
    if (iter == references_.end()) {
        InstructionReferenceImpl* newRef = 
            new InstructionReferenceImpl(ins, *this);
        references_[&ins] = newRef;
        return InstructionReference(newRef);
    } else {
        return InstructionReference(iter->second);
    }
}

References references_.

Referenced by SimpleIfConverter::addJump(), TTAProgram::TPEFProgramFactory::build(), TTAProgram::Program::convertSymbolRef(), TTAProgram::Program::copyDataMemoriesFrom(), InlineAsmParser::copyInstructions(), llvm::LLVMTCEBuilder::createGlobalValueDataDefinition(), ProgramDependenceGraph::createJump(), TTAProgram::TPEFProgramFactory::createLabels(), TTAProgram::CodeGenerator::createSchedYieldProcedure(), llvm::LLVMTCEBuilder::doFinalization(), llvm::LLVMTCEBuilder::emitSetjmp(), TTAProgram::Program::fixInstructionReferences(), CallsToJumps::handleControlFlowGraph(), TTAProgram::CodeLabel::instructionReference(), LoopPrologAndEpilogBuilder::moveJumpDestination(), ControlFlowGraph::sanitize(), and CopyingDelaySlotFiller::updateJumpsAndCfg().

end()

Iterator TTAProgram::InstructionReferenceManager::end ( )

inline

Referenced by ControlFlowGraph::computeLeadersFromRefManager(), and validate().

hasReference()

bool TTAProgram::InstructionReferenceManager::hasReference

(

Instruction &

ins

)

const

Tells whether the manager has created a reference to the given instruction.

Returns

True if the manager has created a reference to the given instruction.

Definition at line 143 of file InstructionReferenceManager.cc.

                                                                {
    return references_.find(&ins) != references_.end();
}

References references_.

Referenced by SequentialScheduler::copyBasicBlocksToProcedure(), ProcedurePass::copyCfgToProcedure(), BasicBlockPass::copyRMToBB(), ControlFlowGraph::copyToLLVMMachineFunction(), ControlFlowGraph::copyToProcedure(), SequentialScheduler::createBasicBlocks(), llvm::LLVMTCEBuilder::emitSPInitialization(), CopyingDelaySlotFiller::fillDelaySlots(), CopyingDelaySlotFiller::findJumpImmediate(), CallsToJumps::handleControlFlowGraph(), ControlFlowGraph::optimizeBBOrdering(), TTAProgram::Procedure::remove(), ControlFlowGraph::splitBasicBlocksWithCallsAndRefs(), PostpassOperandSharer::tryRemoveOperandWrite(), PreOptimizer::tryToRemoveGuardInversingOp(), CopyingDelaySlotFiller::updateFTBBAndCfg(), CopyingDelaySlotFiller::updateJumpsAndCfg(), BasicBlockNode::updateReferencesFromProcToCfg(), and ControlFlowGraph::updateReferencesFromProcToCfg().

operator=()

InstructionReferenceManager& TTAProgram::InstructionReferenceManager::operator= ( const InstructionReferenceManager &  )

private

referenceCount()

unsigned int TTAProgram::InstructionReferenceManager::referenceCount

(

Instruction &

ins

)

const

Tells how many alive references there are to an instruction.

Definition at line 151 of file InstructionReferenceManager.cc.

                                                                  {
    RefMap::const_iterator iter = references_.find(&ins);
    if (iter == references_.end()) {
        return 0;
    }
    return iter->second->count();
}

References references_.

referenceDied()

void TTAProgram::InstructionReferenceManager::referenceDied

(

Instruction *

ins

)

Notifies instructionreferencemanager that a reference has completely died.

This causes the reference manager to remove the reference impl object.

Definition at line 165 of file InstructionReferenceManager.cc.

                                                           {
    RefMap::iterator iter = references_.find(ins);
    assert (iter != references_.end());
    assert (iter->second->count() == 0);
    delete iter->second; iter->second = NULL;
    references_.erase(iter);
}

References assert, and references_.

Referenced by TTAProgram::InstructionReferenceImpl::removeRef().

replace()

void TTAProgram::InstructionReferenceManager::replace	(	Instruction &	insA,
		Instruction &	insB
	)

Replaces a referred instruction with another. This replaces ALL references that point into the same instruction.

Parameters

insA	Instruction to be replaced.
insB	The new referred instruction.

Returns

A handle to the reference to the new referred instruction.

Exceptions

InstanceNotFound

if the instruction to be replaced is not found.

Definition at line 96 of file InstructionReferenceManager.cc.

                                                                         {
    RefMap::iterator itera = references_.find(&insA);
    if (itera == references_.end()) {
        throw InstanceNotFound(
            __FILE__, __LINE__, "InstructionReferenceManager::replace()",
            "Instruction reference to be replaced not found.");
    }
 
    RefMap::iterator iterb = references_.find(&insB);
    if (iterb == references_.end()) { // just update one.
        // no ref to b, just update a to point to b.
        InstructionReferenceImpl* impl = itera->second;
        impl->setInstruction(insB);
        references_.erase(itera);
        references_[&insB] = impl;
        return;
    }
 
    // merge the two ref implementations.
    iterb->second->merge(*itera->second);
}

References TTAProgram::InstructionReferenceImpl::merge(), references_, and TTAProgram::InstructionReferenceImpl::setInstruction().

Referenced by SequentialScheduler::copyBasicBlocksToProcedure(), ProcedurePass::copyCfgToProcedure(), BasicBlockPass::copyRMToBB(), ControlFlowGraph::copyToLLVMMachineFunction(), ControlFlowGraph::copyToProcedure(), TTAProgram::CodeGenerator::createSchedYieldProcedure(), llvm::LLVMTCEBuilder::emitSPInitialization(), CallsToJumps::handleControlFlowGraph(), ControlFlowGraph::optimizeBBOrdering(), and BasicBlockNode::updateReferencesFromProcToCfg().

Here is the call graph for this function:

validate()

void TTAProgram::InstructionReferenceManager::validate

(

)

Performs sanity checks to the instruction references.

Asserts in case of illegal irefs found. Before calling this method, all instruction references must have been "stabilized", i.e., pointing to valid instructions inside the Program.

Definition at line 181 of file InstructionReferenceManager.cc.

                                       {
 
    for (InstructionReferenceManager::Iterator i = begin();
         i != end(); ++i) {
        Instruction& targetInstruction = i->instruction();
 
        if (!targetInstruction.isInProcedure()) {
            Application::logStream()
                << "Reference to an instruction " << &targetInstruction
                << " that is not in a Procedure." << std::endl;
            PRINT_VAR(targetInstruction.address().location());
            abort();
        } else if (!targetInstruction.parent().isInProgram()) {
            Application::logStream()
                << "Reference to an instruction " << &targetInstruction
                << " that is not in a Program." << std::endl;
            PRINT_VAR(&(*i));
            PRINT_VAR(
                dynamic_cast<TTAProgram::Procedure&>(
                    targetInstruction.parent()).name());
            PRINT_VAR(
                &targetInstruction.parent().firstInstruction());
            PRINT_VAR(targetInstruction.address().location());
            abort();
        }
    }    
}

References TTAProgram::Instruction::address(), begin(), end(), TTAProgram::CodeSnippet::firstInstruction(), TTAProgram::Instruction::isInProcedure(), TTAProgram::CodeSnippet::isInProgram(), TTAProgram::Address::location(), Application::logStream(), TTAProgram::Procedure::name(), TTAProgram::Instruction::parent(), and PRINT_VAR.

Here is the call graph for this function:

Member Data Documentation

references_

RefMap TTAProgram::InstructionReferenceManager::references_

private

Instruction references to maintain.

Definition at line 120 of file InstructionReferenceManager.hh.

Referenced by clearReferences(), createReference(), hasReference(), referenceCount(), referenceDied(), and replace().

---

The documentation for this class was generated from the following files:

• InstructionReferenceManager.hh
• InstructionReferenceManager.cc