#include <Instruction.hh>

Inheritance diagram for TTAProgram::Instruction:

Collaboration diagram for TTAProgram::Instruction:

Public Member Functions
	Instruction (const TTAMachine::InstructionTemplate &instructionTemplate=TTAMachine::NullInstructionTemplate::instance())

	Instruction (int size, const TTAMachine::InstructionTemplate &instructionTemplate=TTAMachine::NullInstructionTemplate::instance())

	~Instruction ()

CodeSnippet &	parent () const

void	setParent (CodeSnippet &proc)

bool	isInProcedure () const

void	addMove (std::shared_ptr< Move > move)

int	moveCount () const

Move &	move (int i) const

std::shared_ptr< Move >	movePtr (int i) const

void	removeMove (Move &move)

bool	isNOP () const

void	addImmediate (std::shared_ptr< Immediate > imm)

int	immediateCount () const

Immediate &	immediate (int i) const

std::shared_ptr< Immediate >	immediatePtr (int i) const

void	removeImmediate (Immediate &imm)

Address	address () const

bool	hasFinalAddress () const

short	size () const

void	setSize (short size)

bool	hasRegisterAccesses () const

bool	hasConditionalRegisterAccesses () const

bool	hasJump () const

bool	hasCall () const

bool	hasReturn () const

bool	hasControlFlowMove () const

Instruction *	copy () const

void	setInstructionTemplate (const TTAMachine::InstructionTemplate &insTemp)

const TTAMachine::InstructionTemplate &	instructionTemplate () const

std::string	toString () const

void	setFinalAddress (InstructionAddress addr)

Public Member Functions inherited from TTAProgram::AnnotatedInstructionElement
	AnnotatedInstructionElement ()

	~AnnotatedInstructionElement ()

void	addAnnotation (const ProgramAnnotation &annotation)

void	setAnnotation (const ProgramAnnotation &annotation)

ProgramAnnotation	annotation (int index, ProgramAnnotation::Id id=ProgramAnnotation::ANN_UNDEF_ID) const

int	annotationCount (ProgramAnnotation::Id id=ProgramAnnotation::ANN_UNDEF_ID) const

void	removeAnnotations (ProgramAnnotation::Id id=ProgramAnnotation::ANN_UNDEF_ID)

bool	hasAnnotations (ProgramAnnotation::Id id=ProgramAnnotation::ANN_UNDEF_ID) const

bool	hasAnnotation (ProgramAnnotation::Id id, const TCEString &data) const

void	copyAnnotationsFrom (const AnnotatedInstructionElement &other)

Private Types
typedef std::vector< std::shared_ptr< Move > >	MoveList
	List for moves. More...

typedef std::vector< std::shared_ptr< Immediate > >	ImmList
	List for immediates. More...

Private Member Functions
	Instruction (const Instruction &)
	Copying not allowed. More...

Instruction &	operator= (const Instruction &)
	Assignment not allowed. More...

Private Attributes
MoveList	moves_
	Moves contained in this instruction. More...

ImmList	immediates_
	Immediates contained in this instruction. More...

CodeSnippet *	parent_
	Parent procedure. More...

const TTAMachine::InstructionTemplate *	insTemplate_
	Instruction template that is used for this instruction. More...

InstructionAddress	positionInProcedure_
	Cache the instruction's index in the its procedure for faster address(). More...

InstructionAddress	finalAddress_
	In case the final instruction address is known (due to program not modified anymore), the final instruction address is stored here. -1 in case not known. More...

short	size_
	Size of instruction in MAU's. More...

bool	hasRegisterAccesses_
	Set to true in case this instruction has moves that access registers. More...

bool	hasConditionalRegisterAccesses_
	Set to true in case this instruction has moves that access registers and are conditional. More...

Detailed Description

Represents a TTA instruction.

Note: : The annotations added with the AnnotatedInstructionElement are not saved to a TPEF file when the program is written!

Definition at line 57 of file Instruction.hh.

Member Typedef Documentation

◆ ImmList

typedef std::vector<std::shared_ptr<Immediate> > TTAProgram::Instruction::ImmList

private

List for immediates.

Definition at line 127 of file Instruction.hh.

◆ MoveList

typedef std::vector<std::shared_ptr<Move> > TTAProgram::Instruction::MoveList

private

List for moves.

Definition at line 125 of file Instruction.hh.

Constructor & Destructor Documentation

◆ Instruction() [1/3]

TTAProgram::Instruction::Instruction ( const TTAMachine::InstructionTemplate & instructionTemplate = TTAMachine::NullInstructionTemplate::instance() )

The constructor.

The default size of an instruction is 1 MAU.

Definition at line 63 of file Instruction.cc.

                                                               :
     parent_(NULL), insTemplate_(&instructionTemplate),
     positionInProcedure_((InstructionAddress)-1),
     finalAddress_((InstructionAddress)-1),
     size_(1), hasRegisterAccesses_(false), hasConditionalRegisterAccesses_(false) {
 }

Referenced by copy().

◆ Instruction() [2/3]

TTAProgram::Instruction::Instruction	(	int	size,
		const TTAMachine::InstructionTemplate &	instructionTemplate = `TTAMachine::NullInstructionTemplate::instance()`
	)

explicit

Constructor.

Alternative constructor that takes the instruction size as a parameter.

Parameters

size	The size of the instruction in MAU's.

Definition at line 78 of file Instruction.cc.

                                                               :
     parent_(NULL), insTemplate_(&instructionTemplate), 
     positionInProcedure_((InstructionAddress)-1),
     finalAddress_((InstructionAddress)-1),
     size_(size), hasRegisterAccesses_(false), hasConditionalRegisterAccesses_(false) {
     assert(size == 1 &&
            "Instructions sizes other than 1 not supported in POM at the "
            "moment.");
 }

References assert, and size().

Here is the call graph for this function:

◆ ~Instruction()

TTAProgram::Instruction::~Instruction ( )

The destructor.

Definition at line 93 of file Instruction.cc.

                           {
     for (auto i : moves_) {
         i->setParent(NullInstruction::instance());
     }
     moves_.clear();
     immediates_.clear();
 }

References immediates_, TTAProgram::NullInstruction::instance(), and moves_.

Here is the call graph for this function:

◆ Instruction() [3/3]

TTAProgram::Instruction::Instruction ( const Instruction & )

private

Copying not allowed.

Member Function Documentation

◆ addImmediate()

void TTAProgram::Instruction::addImmediate ( std::shared_ptr< Immediate > imm )

Adds an immediate to the instruction.

The ownership of the immediate will be passed to the instruction.

Parameters

imm	The immediate to add.

Definition at line 234 of file Instruction.cc.

                                                       {
     if (ContainerTools::containsValue(immediates_, imm)) {
         throw ObjectAlreadyExists(__FILE__, __LINE__, __func__,
                   "Immediate is already added.");
     } else {
         immediates_.push_back(imm);
         imm->setParent(this);
     }
  
 #if 0
     if (insTemplate_ != &TTAMachine::NullInstructionTemplate::instance()) {
         int requiredWidth = std::min(
             MathTools::requiredBits(imm->value().value().unsignedValue()),
             imm->value().value().width());
  
         if (requiredWidth >
             insTemplate_->supportedWidth(imm->destination().immediateUnit())) {
             assert(false &&
                 "The immediate is wider than the instruction template can "
                 "transport.");
         }
     }
 #endif
 }

References __func__, assert, ContainerTools::containsValue(), immediates_, TTAMachine::NullInstructionTemplate::instance(), insTemplate_, MathTools::requiredBits(), and TTAMachine::InstructionTemplate::supportedWidth().

Referenced by ITemplateBroker::assign(), ITemplateBroker::assignImmediate(), LoopPrologAndEpilogBuilder::build(), copy(), TTAProgram::TPEFProgramFactory::createInstruction(), and ITemplateBroker::unassign().

Here is the call graph for this function:

◆ addMove()

void TTAProgram::Instruction::addMove ( std::shared_ptr< Move > move )

Adds a move to the instruction.

The ownership of the move will be passed to the instruction.

Parameters

move	The move to add.

Definition at line 147 of file Instruction.cc.

                                              {
     if (ContainerTools::containsValue(moves_, move)) {
         throw ObjectAlreadyExists(__FILE__, __LINE__, __func__,
                   "Move is already added.");
     } else {
         if (move->source().isGPR() || move->destination().isGPR()) {
             hasRegisterAccesses_ = true;
             if (!move->isUnconditional())
                 hasConditionalRegisterAccesses_ = true;
         }
         moves_.push_back(move);
         move->setParent(*this);
     }
 #if 0
     if (insTemplate_ != &TTAMachine::NullInstructionTemplate::instance()) {
         if (insTemplate_->usesSlot(move->bus().name())) {
             assert(false &&
                 "Instruction template already uses the move's slot");
         }
     }
 #endif
 }

References __func__, assert, TTAProgram::Move::bus(), ContainerTools::containsValue(), TTAProgram::Move::destination(), hasConditionalRegisterAccesses_, hasRegisterAccesses_, TTAMachine::NullInstructionTemplate::instance(), insTemplate_, TTAProgram::Terminal::isGPR(), TTAProgram::Move::isUnconditional(), move(), moves_, TTAMachine::Component::name(), TTAProgram::Move::setParent(), TTAProgram::Move::source(), and TTAMachine::InstructionTemplate::usesSlot().

Here is the call graph for this function:

◆ address()

Address TTAProgram::Instruction::address ( ) const

Returns the address of the instruction.

Returns: The address of the instruction.

Exceptions

IllegalRegistration if the instruction does not belong to a procedure.

Definition at line 327 of file Instruction.cc.

                            {
     if (finalAddress_ != (InstructionAddress)-1) {
         Address address(finalAddress_, parent().startAddress().space());
         return address;
     }
  
     if (!isInProcedure()) {
         TCEString msg = "Instruction is not registered in a procedure: ";
         msg += POMDisassembler::disassemble(*this);
         throw IllegalRegistration(
             __FILE__, __LINE__, __func__,
             msg);
     }
     // speed up by caching the Instruction's position in the Procedure
     if (positionInProcedure_ != (InstructionAddress)-1 &&
         positionInProcedure_ <
         (InstructionAddress)parent().instructionCount() &&
         &parent().instructionAtIndex(positionInProcedure_) == this) {
         // the instruction has not moved in the Procedure, we
         // can compute its address in constant time
         // cannot cache the Address itself because the Procedure might
         // have moved
         Address address(
             parent().startAddress().location() + positionInProcedure_,
             parent().startAddress().space());
         return address;
     } else {
         Address address = parent().address(*this);
         positionInProcedure_ =
             address.location() - parent().startAddress().location();
         return address;
     }
 }

References __func__, TTAProgram::CodeSnippet::address(), POMDisassembler::disassemble(), finalAddress_, isInProcedure(), TTAProgram::Address::location(), parent(), positionInProcedure_, and TTAProgram::CodeSnippet::startAddress().

Referenced by TTAProgram::TerminalInstructionReference::address(), TTAProgram::CodeLabel::address(), TTAProgram::Procedure::address(), TTAProgram::CodeSnippet::address(), SimProgramBuilder::build(), CompiledSimUtilizationStats::calculate(), SimulationStatistics::calculate(), POMValidator::checkCompiledSimulatability(), POMValidator::checkConnectivity(), POMValidator::checkLongImmediates(), POMValidator::checkSimulatability(), TTAProgram::CodeLabel::CodeLabel(), ControlFlowGraph::computeLeadersFromJumpSuccessors(), ControlFlowGraph::computeLeadersFromRefManager(), ProcedurePass::copyCfgToProcedure(), SequentialScheduler::createBasicBlocks(), ControlFlowGraph::createBBEdges(), ControlFlowGraph::createBlock(), TTAProgram::ProgramWriter::createCodeSection(), ControlFlowGraph::createControlFlowEdge(), ControlFlowGraph::createJumps(), SimulatorFrontend::currentProcedure(), TTAProgram::DataInstructionAddressDef::destinationAddress(), ControlFlowGraph::directJump(), POMDisassembler::disassemble(), DisassembleCommand::execute(), TTAProgram::Program::finalize(), ControlFlowGraph::findNextIndex(), TTASimulationController::findProgramExitPoints(), SimulatorFrontend::finishSimulation(), TTAProgram::Program::fixInstructionReferences(), CompiledSimCodeGenerator::generateInstruction(), DisassemblyGridTable::GetNumberRows(), ProcedureTransferTracker::handleEvent(), RFAccessTracker::handleEvent(), TTAProgram::CodeSnippet::instructionAt(), TTAProgram::CodeSnippet::nextInstruction(), TTAProgram::Program::nextInstruction(), TTAProgram::CodeSnippet::previousInstruction(), POMDisassembler::printAddress(), CompiledSimController::reset(), DisasmTopCountAttrProvider::updateTopCountTable(), and TTAProgram::InstructionReferenceManager::validate().

Here is the call graph for this function:

◆ copy()

Instruction * TTAProgram::Instruction::copy ( ) const

Make a complete copy of the instruction.

The copy is identical, except that it is not registered to the procedure of the original instruction (and therefore, any address it refers to is not meaningful).

Returns: A complete copy of the instruction.

Definition at line 379 of file Instruction.cc.

                         {
     Instruction* newIns = new Instruction(size_, *insTemplate_);
     for (int i = 0; i < moveCount(); i++) {
         newIns->addMove(move(i).copy());
     }
     for (int i = 0; i < immediateCount(); i++) {
         newIns->addImmediate(immediate(i).copy());
     }
     newIns->hasRegisterAccesses_ = hasRegisterAccesses_;
     newIns->hasConditionalRegisterAccesses_ = hasConditionalRegisterAccesses_;
     newIns->copyAnnotationsFrom(*this);
     return newIns;
 }

References addImmediate(), addMove(), TTAProgram::Immediate::copy(), TTAProgram::Move::copy(), TTAProgram::AnnotatedInstructionElement::copyAnnotationsFrom(), hasConditionalRegisterAccesses_, hasRegisterAccesses_, immediate(), immediateCount(), insTemplate_, Instruction(), move(), moveCount(), and size_.

Referenced by TTAProgram::CodeSnippet::append(), TTAProgram::Procedure::copy(), TTAProgram::BasicBlock::copy(), TTAProgram::CodeSnippet::copy(), SequentialScheduler::copyBasicBlocksToProcedure(), ProcedurePass::copyCfgToProcedure(), TTAProgram::Program::copyFrom(), ControlFlowGraph::copyToProcedure(), SequentialScheduler::createBasicBlocks(), ControlFlowGraph::createBlock(), TTAProgram::CodeSnippet::insertAfter(), TTAProgram::CodeSnippet::insertBefore(), and TTAProgram::CodeSnippet::prepend().

Here is the call graph for this function:

◆ hasCall()

bool TTAProgram::Instruction::hasCall ( ) const

Returns whether this instruction contains moves that are calls.

Returns: True in case at least one move in this instruction is a call.

Definition at line 438 of file Instruction.cc.

                            {
  
     for (int i = 0; i < moveCount(); i++ ) {
         if (move(i).isCall()) {
             return true;
         }
     }
     return false;
 }

References TTAProgram::Move::isCall(), move(), and moveCount().

Referenced by CopyingDelaySlotFiller::collectMoves(), CopyingDelaySlotFiller::findJump(), CallsToJumps::handleControlFlowGraph(), and ControlFlowGraph::splitBasicBlocksWithCallsAndRefs().

Here is the call graph for this function:

◆ hasConditionalRegisterAccesses()

bool TTAProgram::Instruction::hasConditionalRegisterAccesses ( ) const

Returns true in case this Instruction contains moves that access registers and are conditional.

This method can be used to optimize register utilization analysis.

Returns: True in case at least one conditional move accesses registers.

Definition at line 412 of file Instruction.cc.

                                                   {
     return hasConditionalRegisterAccesses_;
 }

References hasConditionalRegisterAccesses_.

Referenced by RFAccessTracker::handleEvent().

◆ hasControlFlowMove()

bool TTAProgram::Instruction::hasControlFlowMove ( ) const

Returns whether this instruction contains moves that affect the control flow (branches or calls).

Returns: True in case at least one move in this instruction is a control flow move.

Definition at line 471 of file Instruction.cc.

                                       {
     for (int i = 0; i < moveCount(); i++) {
         if (move(i).isControlFlowMove()) {
             return true;
         }
     }
     return false;
 }

References TTAProgram::Move::isControlFlowMove(), move(), and moveCount().

Referenced by llvm::LLVMTCEIRBuilder::buildTCECFG(), BasicBlockPass::copyRMToBB(), SequentialScheduler::createBasicBlocks(), ProgramDependenceGraph::createJump(), and ControlFlowGraph::findNextIndex().

Here is the call graph for this function:

◆ hasFinalAddress()

bool TTAProgram::Instruction::hasFinalAddress ( ) const

inline

Definition at line 100 of file Instruction.hh.

101 { return finalAddress_ != (InstructionAddress)-1; }

References finalAddress_.

Referenced by TTAProgram::Procedure::address(), and TTAProgram::CodeSnippet::address().

◆ hasJump()

bool TTAProgram::Instruction::hasJump ( ) const

Returns whether this instruction contains moves that are jumps.

Returns: True in case at least one move in this instruction is a jump.

Definition at line 422 of file Instruction.cc.

                            {
  
     for (int i = 0; i < moveCount(); i++ ) {
         if (move(i).isJump()) {
             return true;
         }
     }
     return false;
 }

References TTAProgram::Move::isJump(), move(), and moveCount().

Referenced by BBSchedulerController::handleBasicBlock(), and SimpleIfConverter::removeJump().

Here is the call graph for this function:

◆ hasRegisterAccesses()

bool TTAProgram::Instruction::hasRegisterAccesses ( ) const

Returns true in case this Instruction contains moves that access registers.

This method can be used to optimize register utilization analysis.

Definition at line 399 of file Instruction.cc.

                                        {
     return hasRegisterAccesses_;
 }

References hasRegisterAccesses_.

Referenced by RFAccessTracker::handleEvent().

◆ hasReturn()

bool TTAProgram::Instruction::hasReturn ( ) const

Returns whether this instruction contains a procedure return move.

Definition at line 452 of file Instruction.cc.

                              {
  
     for (int i = 0; i < moveCount(); i++ ) {
         if (move(i).isReturn()) {
             return true;
         }
     }
     return false;
 }

References TTAProgram::Move::isReturn(), move(), and moveCount().

Here is the call graph for this function:

◆ immediate()

Immediate & TTAProgram::Instruction::immediate ( int i ) const

Return the immediate write action at the given index in this instruction.

The order of immediates is arbitrary, no assumption should be made by clients.

Parameters

i	The index of the immediate.

Returns: The immediate write action at the given index in this instruction.

Exceptions

OutOfRange if the index is negative or greater than the number of immediates in the instruction.

Definition at line 285 of file Instruction.cc.

                                   {
     if (i < 0 || static_cast<unsigned int>(i) >= immediates_.size()) {
         throw OutOfRange(__FILE__, __LINE__, __func__,
              "No immediate in instruction with index: " +
              Conversion::toString(i));
     } else {
         return *immediates_.at(i);
     }
 }

References __func__, immediates_, and Conversion::toString().

Referenced by CodeCompressorPlugin::addBitsForDstRegisterField(), ITemplateBroker::assign(), LoopPrologAndEpilogBuilder::build(), CopyingDelaySlotFiller::checkImmediatesAfter(), POMValidator::checkLongImmediates(), CopyingDelaySlotFiller::collectMoves(), ControlFlowGraph::convertBBRefsToInstRefs(), TTAProgram::Program::convertSymbolRefsToInsRefs(), copy(), TTAProgram::ProgramWriter::createCodeSection(), POMDisassembler::createInstruction(), ControlFlowGraph::createJumps(), POMDisassembler::disassemble(), CodeCompressorPlugin::encodeLongImmediate(), ControlFlowGraph::findLimmWrite(), TTAProgram::Program::fixInstructionReferences(), CompiledSimCodeGenerator::generateInstruction(), ProgramImageGenerator::generateProgramImage(), getInstructionReferenceTerminals(), ITemplateBroker::isImmediateInTemplate(), main(), LoopPrologAndEpilogBuilder::optimizeProlog(), SimProgramBuilder::processInstruction(), CodeCompressorPlugin::programImmediate(), setInstructionTemplate(), CopyingDelaySlotFiller::tryToAssignNodes(), ITemplateBroker::unassignImmediate(), CopyingDelaySlotFiller::updateFTBBAndCfg(), and CopyingDelaySlotFiller::updateJumpsAndCfg().

Here is the call graph for this function:

◆ immediateCount()

int TTAProgram::Instruction::immediateCount ( ) const

Returns the number of immediate registers written by the instruction template of this instruction.

Returns: The number of immediate registers written by the instruction template of this instruction.

Definition at line 267 of file Instruction.cc.

                                   {
     return immediates_.size();
 }

References immediates_.

Referenced by CodeCompressorPlugin::addBitsForDstRegisterField(), ITemplateBroker::assign(), LoopPrologAndEpilogBuilder::build(), CopyingDelaySlotFiller::checkImmediatesAfter(), POMValidator::checkLongImmediates(), CopyingDelaySlotFiller::collectMoves(), ControlFlowGraph::convertBBRefsToInstRefs(), TTAProgram::Program::convertSymbolRefsToInsRefs(), copy(), TTAProgram::ProgramWriter::createCodeSection(), POMDisassembler::createInstruction(), ControlFlowGraph::createJumps(), POMDisassembler::disassemble(), CodeCompressorPlugin::encodeLongImmediate(), ITemplateBroker::findITemplates(), CopyingDelaySlotFiller::findJumpImmediate(), ControlFlowGraph::findLimmWrite(), TTAProgram::Program::fixInstructionReferences(), CompiledSimCodeGenerator::generateInstruction(), ProgramImageGenerator::generateProgramImage(), getInstructionReferenceTerminals(), CodeCompressorPlugin::instructionTemplate(), ITemplateBroker::isImmediateInTemplate(), isNOP(), main(), LoopPrologAndEpilogBuilder::optimizeProlog(), SimProgramBuilder::processInstruction(), CodeCompressorPlugin::programImmediate(), ControlFlowGraph::removeJumpToTarget(), BFUnscheduleFromBody::returnOriginal(), BFUnscheduleMove::returnOriginal(), setInstructionTemplate(), TTAProgram::BasicBlock::statistics(), CopyingDelaySlotFiller::tryToAssignNodes(), SimpleBrokerDirector::unassign(), ITemplateBroker::unassignImmediate(), CopyingDelaySlotFiller::updateFTBBAndCfg(), and CopyingDelaySlotFiller::updateJumpsAndCfg().

◆ immediatePtr()

std::shared_ptr< Immediate > TTAProgram::Instruction::immediatePtr ( int i ) const

Return the immediate write action at the given index in this instruction.

The order of immediates is arbitrary, no assumption should be made by clients.

Parameters

i	The index of the immediate.

Returns: The immediate write action at the given index in this instruction.

Exceptions

OutOfRange if the index is negative or greater than the number of immediates in the instruction.

Definition at line 309 of file Instruction.cc.

                                      {
     if (i < 0 || static_cast<unsigned int>(i) >= immediates_.size()) {
         throw OutOfRange(__FILE__, __LINE__, __func__,
              "No immediate in instruction with index: " +
              Conversion::toString(i));
     } else {
         return immediates_[i];
     }
 }

References __func__, immediates_, and Conversion::toString().

Referenced by ITemplateBroker::findITemplates(), CopyingDelaySlotFiller::findJumpImmediate(), and AbsoluteToRelativeJumps::handleProcedure().

Here is the call graph for this function:

◆ instructionTemplate()

const TTAMachine::InstructionTemplate & TTAProgram::Instruction::instructionTemplate ( ) const

Returns the instruction template of instruction.

Returns: The instruction template of instruction.

Definition at line 523 of file Instruction.cc.

                                        {
     return *insTemplate_;
 }

References insTemplate_.

Referenced by ITemplateBroker::assign(), ITemplateBroker::assignImmediate(), POMValidator::checkLongImmediates(), BasicBlockPass::copyRMToBB(), POMDisassembler::disassemble(), CodeCompressorPlugin::encodeLongImmediate(), CodeCompressorPlugin::instructionTemplate(), ITemplateBroker::isAlreadyAssigned(), MoveNode::isAssigned(), and ITemplateBroker::unassignImmediate().

◆ isInProcedure()

bool TTAProgram::Instruction::isInProcedure ( ) const

Tells whether the instruction belongs to a procedure.

Returns: True if the instruction belongs to a procedure (it is registered), false otherwise.

Definition at line 135 of file Instruction.cc.

                                  {
     return (parent_ != NULL && parent_ != &NullProcedure::instance());
 }

References TTAProgram::NullProcedure::instance(), and parent_.

Referenced by TTAProgram::Procedure::add(), TTAProgram::CodeSnippet::add(), TTAProgram::CodeSnippet::addFront(), TTAProgram::Program::addInstruction(), address(), POMDisassembler::createMove(), DataDependenceGraph::createSubgraph(), POMDisassembler::disassemble(), ProcedureTransferTracker::handleEvent(), TTAProgram::Procedure::insertAfter(), TTAProgram::CodeSnippet::insertAfter(), TTAProgram::Procedure::insertBefore(), TTAProgram::CodeSnippet::insertBefore(), TTAProgram::Program::nextInstruction(), TTAProgram::Procedure::remove(), TTAProgram::CodeSnippet::remove(), and TTAProgram::InstructionReferenceManager::validate().

Here is the call graph for this function:

◆ isNOP()

bool TTAProgram::Instruction::isNOP ( ) const

inline

Definition at line 90 of file Instruction.hh.

90 { return moveCount() == 0 && immediateCount() == 0; }

References immediateCount(), and moveCount().

Referenced by ControlFlowGraph::buildMBBFromBB(), and ProgramImageGenerator::generateProgramImage().

Here is the call graph for this function:

◆ move()

Move & TTAProgram::Instruction::move ( int i ) const

Return the move at the given index in this instruction.

The order of moves is arbitrary, no assumption should be made by clients. Anyways, order of moves in instruction does not change between calls to this method.

Parameters

i	The index of the move.

Returns: The move at the given index in this instruction.

Exceptions

OutOfRange if the given index is negative or greater than the number of moves in the instruction.

Definition at line 193 of file Instruction.cc.

                              {
     if (i < 0 || static_cast<unsigned int>(i) >= moves_.size()) {
         throw OutOfRange(__FILE__, __LINE__, __func__,
              "No move in instruction for given index: " +
              Conversion::toString(i));
     } else {
         return *moves_.at(i);
     }
 }

References __func__, moves_, and Conversion::toString().

Here is the call graph for this function:

◆ moveCount()

int TTAProgram::Instruction::moveCount ( ) const

Returns the number of moves contained in this instruction.

Returns: The number of moves contained in this instruction.

Definition at line 176 of file Instruction.cc.

                              {
     return moves_.size();
 }

References moves_.

◆ movePtr()

std::shared_ptr< Move > TTAProgram::Instruction::movePtr ( int i ) const

Return the move at the given index in this instruction.

The order of moves is arbitrary, no assumption should be made by clients. Anyways, order of moves in instruction does not change between calls to this method.

Parameters

i	The index of the move.

Returns: The move at the given index in this instruction.

Exceptions

OutOfRange if the given index is negative or greater than the number of moves in the instruction.

Definition at line 216 of file Instruction.cc.

                                 {
     if (i < 0 || static_cast<unsigned int>(i) >= moves_.size()) {
         throw OutOfRange(__FILE__, __LINE__, __func__,
              "No move in instruction for given index: " +
              Conversion::toString(i));
     } else {
         return moves_.at(i);
     }
 }

References __func__, moves_, and Conversion::toString().

Referenced by MoveNodeGroupBuilder::build(), DataDependenceGraphBuilder::constructIndividualBB(), DataDependenceGraphBuilder::constructIndividualFromInlineAsmBB(), llvm::LLVMTCEBuilder::emitInstruction(), and ITemplateBroker::findITemplates().

Here is the call graph for this function:

◆ operator=()

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

private

Assignment not allowed.

◆ parent()

CodeSnippet & TTAProgram::Instruction::parent ( ) const

Return the parent that contains the instruction.

Returns: The parent that contains the instruction.

Exceptions

IllegalRegistration If the instruction is not registered anywhere.

Definition at line 109 of file Instruction.cc.

                           {
     if (parent_ != NULL) {
         return *parent_;
     } else {
         throw IllegalRegistration(__FILE__, __LINE__, __func__,
                   "Instruction is not registered.");
     }
 }

References __func__, and parent_.

Referenced by TTAProgram::Procedure::add(), TTAProgram::CodeSnippet::add(), address(), PreOptimizer::cfgAllowsJumpReversal(), TTAProgram::CodeLabel::CodeLabel(), SimulatorFrontend::compareState(), ControlFlowGraph::computeLeadersFromRefManager(), ControlFlowGraph::createBlock(), POMDisassembler::createMove(), DataDependenceGraph::createSubgraph(), SimulatorFrontend::currentProcedure(), POMDisassembler::disassemble(), SimulatorFrontend::disassembleInstruction(), llvm::LLVMTCEBuilder::emitSPInitialization(), DisassembleCommand::execute(), CopyingDelaySlotFiller::findJumpImmediate(), TTAProgram::Program::fixInstructionReferences(), ProcedureTransferTracker::handleEvent(), SimulationController::next(), TTAProgram::CodeSnippet::nextInstruction(), TTAProgram::Program::nextInstruction(), TTAProgram::CodeSnippet::previousInstruction(), TTAProgram::CodeLabel::procedure(), SimulatorFrontend::programLocationDescription(), TTAProgram::Procedure::remove(), TTAProgram::CodeSnippet::remove(), PreOptimizer::tryToPrecalcConstantAdd(), PreOptimizer::tryToRemoveGuardInversingOp(), and TTAProgram::InstructionReferenceManager::validate().

◆ removeImmediate()

void TTAProgram::Instruction::removeImmediate ( Immediate & imm )

Remove immediate from instruction.

Immediate may get deleted if use-count of smart pointer goes to zero.

Parameters

immediate Immediate to remove.

Exceptions

IllegalRegistration If immediate doesn't belong to instruction.

Definition at line 560 of file Instruction.cc.

                                            {
     for (ImmList::iterator iter = immediates_.begin();
          iter != immediates_.end(); iter++) {
         if ((*iter).get() == &imm) {
             imm.setParent(nullptr);
             immediates_.erase(iter);
             return;
         }
     }
     throw IllegalRegistration(__FILE__, __LINE__);
 }

References immediates_, and TTAProgram::Immediate::setParent().

Referenced by ITemplateBroker::assign(), LoopPrologAndEpilogBuilder::optimizeProlog(), ITemplateBroker::unassign(), ITemplateBroker::unassignImmediate(), CopyingDelaySlotFiller::updateFTBBAndCfg(), and CopyingDelaySlotFiller::updateJumpsAndCfg().

Here is the call graph for this function:

◆ removeMove()

void TTAProgram::Instruction::removeMove ( Move & move )

Remove move from instruction.

Move may become deleted if last smart pointer to it gets removed.

Parameters

move	Move to remove.

Exceptions

IllegalRegistration If move doesn't belong to instruction.

Definition at line 536 of file Instruction.cc.

                                   {
     if (&move.parent() != this) {
         throw IllegalRegistration(__FILE__, __LINE__);
     }
  
     move.setParent(NullInstruction::instance());
     for (MoveList::iterator iter = moves_.begin();
          iter != moves_.end(); iter++) {
         if ((iter->get()) == &move) {
             moves_.erase(iter);
             break;
         }
     }
 }

References TTAProgram::NullInstruction::instance(), move(), moves_, TTAProgram::Move::parent(), and TTAProgram::Move::setParent().

Referenced by ITemplateBroker::assign(), ProcedurePass::copyCfgToProcedure(), PostpassOperandSharer::handleBasicBlock(), SimpleIfConverter::removeJump(), ControlFlowGraph::removeJumpToTarget(), ITemplateBroker::unassign(), CopyingDelaySlotFiller::updateFTBBAndCfg(), and CopyingDelaySlotFiller::updateJumpsAndCfg().

Here is the call graph for this function:

◆ setFinalAddress()

void TTAProgram::Instruction::setFinalAddress ( InstructionAddress addr )

inline

Definition at line 121 of file Instruction.hh.

121 { finalAddress_ = addr; }

References finalAddress_.

Referenced by TTAProgram::Program::finalize().

◆ setInstructionTemplate()

void TTAProgram::Instruction::setInstructionTemplate ( const TTAMachine::InstructionTemplate & insTemp )

Sets instruction template.

Parameters

insTemp Instruction template for the instruction.

Definition at line 488 of file Instruction.cc.

                                                   {
     insTemplate_= &insTemp;
  
 #if 0
     for (int i = 0; i < moveCount(); i++) {
         if (insTemplate_->usesSlot(move(i).bus().name())) {
             assert(false && "Instruction template conflicts with the "
                 "instruction's slot layout: Both the new template and a move "
                 "uses same slot.");
         }
     }
  
     for (int i = 0; i < immediateCount(); i++) {
         int requiredWidth = std::min(
             MathTools::requiredBits(
                 immediate(i).value().value().unsignedValue()),
             immediate(i).value().value().width());
         if (requiredWidth >
             insTemplate_->supportedWidth(
                 immediate(i).destination().immediateUnit())) {
             assert(false && "The instruction has an long immediate "
                 "not supported by the new instruction template.");
         }
     }
 #endif
 }

References assert, immediate(), immediateCount(), insTemplate_, move(), moveCount(), MathTools::requiredBits(), TTAMachine::InstructionTemplate::supportedWidth(), and TTAMachine::InstructionTemplate::usesSlot().

Referenced by ITemplateBroker::assign(), ITemplateBroker::assignImmediate(), TTAProgram::TPEFProgramFactory::createInstruction(), ITemplateBroker::instruction(), and ITemplateBroker::reselectTemplate().

Here is the call graph for this function:

◆ setParent()

void TTAProgram::Instruction::setParent ( CodeSnippet & proc )

Sets the parent procedure of the instruction.

Parameters

proc	The new parent procedure.

Definition at line 124 of file Instruction.cc.

                                         {
     parent_ = &proc;
 }

References parent_.

Referenced by TTAProgram::Procedure::add(), TTAProgram::CodeSnippet::add(), TTAProgram::CodeSnippet::addFront(), TTAProgram::Procedure::insertAfter(), TTAProgram::CodeSnippet::insertAfter(), TTAProgram::Procedure::insertBefore(), TTAProgram::CodeSnippet::insertBefore(), TTAProgram::Procedure::remove(), and TTAProgram::CodeSnippet::remove().

◆ setSize()

void TTAProgram::Instruction::setSize ( short size )

inline

Definition at line 104 of file Instruction.hh.

104 { size_ = size; }

References size(), and size_.

Referenced by TTAProgram::Program::finalize().

Here is the call graph for this function:

◆ size()

short TTAProgram::Instruction::size ( ) const

Returns the size of the instruction in MAU's.

Definition at line 365 of file Instruction.cc.

                         {
     return size_;
 }

References size_.

Referenced by SimProgramBuilder::build(), SimulationStatistics::calculate(), POMDisassembler::disassembleProcedure(), DisassembleCommand::execute(), TTAProgram::Program::finalize(), Instruction(), TTAProgram::CodeSnippet::instructionAt(), and setSize().

◆ toString()

std::string TTAProgram::Instruction::toString ( ) const

Returns the disassembly of the instruction.

Definition at line 576 of file Instruction.cc.

                             {
     return POMDisassembler::disassemble(*this);
 }

References POMDisassembler::disassemble().

Referenced by ResourceConstraintAnalyzer::analyzeMoveNode(), BFOptimization::assignCopyToPrologEpilog(), BasicBlockPass::copyRMToBB(), ProgramDependenceGraph::createJump(), CallsToJumps::handleControlFlowGraph(), BasicBlockScheduler::handleRemovedResultMoves(), BasicBlockNode::toString(), and llvm::LLVMTCEBuilder::writeMachineFunction().

Here is the call graph for this function:

Member Data Documentation

◆ finalAddress_

InstructionAddress TTAProgram::Instruction::finalAddress_

mutableprivate

In case the final instruction address is known (due to program not modified anymore), the final instruction address is stored here. -1 in case not known.

Definition at line 149 of file Instruction.hh.

Referenced by address(), hasFinalAddress(), and setFinalAddress().

◆ hasConditionalRegisterAccesses_

bool TTAProgram::Instruction::hasConditionalRegisterAccesses_

private

Set to true in case this instruction has moves that access registers and are conditional.

Definition at line 157 of file Instruction.hh.

Referenced by addMove(), copy(), and hasConditionalRegisterAccesses().

◆ hasRegisterAccesses_

bool TTAProgram::Instruction::hasRegisterAccesses_

private

Set to true in case this instruction has moves that access registers.

Definition at line 154 of file Instruction.hh.

Referenced by addMove(), copy(), and hasRegisterAccesses().

◆ immediates_

ImmList TTAProgram::Instruction::immediates_

private

Immediates contained in this instruction.

Definition at line 137 of file Instruction.hh.

Referenced by addImmediate(), immediate(), immediateCount(), immediatePtr(), removeImmediate(), and ~Instruction().

◆ insTemplate_

const TTAMachine::InstructionTemplate* TTAProgram::Instruction::insTemplate_

private

Instruction template that is used for this instruction.

Definition at line 142 of file Instruction.hh.

Referenced by addImmediate(), addMove(), copy(), instructionTemplate(), and setInstructionTemplate().

◆ moves_

MoveList TTAProgram::Instruction::moves_

private

Moves contained in this instruction.

Definition at line 135 of file Instruction.hh.

Referenced by addMove(), move(), moveCount(), movePtr(), removeMove(), and ~Instruction().

◆ parent_

CodeSnippet* TTAProgram::Instruction::parent_

private

Parent procedure.

Definition at line 139 of file Instruction.hh.

Referenced by isInProcedure(), parent(), and setParent().

◆ positionInProcedure_

InstructionAddress TTAProgram::Instruction::positionInProcedure_

mutableprivate

Cache the instruction's index in the its procedure for faster address().

Definition at line 145 of file Instruction.hh.

Referenced by address().

◆ size_

short TTAProgram::Instruction::size_

mutableprivate

Size of instruction in MAU's.

Definition at line 152 of file Instruction.hh.

Referenced by copy(), setSize(), and size().

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

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ ImmList

◆ MoveList

Constructor & Destructor Documentation

◆ Instruction() [1/3]

◆ Instruction() [2/3]

◆ ~Instruction()

◆ Instruction() [3/3]

Member Function Documentation

◆ addImmediate()

◆ addMove()

◆ address()

◆ copy()

◆ hasCall()

◆ hasConditionalRegisterAccesses()

◆ hasControlFlowMove()

◆ hasFinalAddress()

◆ hasJump()

◆ hasRegisterAccesses()

◆ hasReturn()

◆ immediate()

◆ immediateCount()

◆ immediatePtr()

◆ instructionTemplate()

◆ isInProcedure()

◆ isNOP()

◆ move()

◆ moveCount()

◆ movePtr()

◆ operator=()

◆ parent()

◆ removeImmediate()

◆ removeMove()

◆ setFinalAddress()

◆ setInstructionTemplate()

◆ setParent()

◆ setSize()

◆ size()

◆ toString()

Member Data Documentation

◆ finalAddress_

◆ hasConditionalRegisterAccesses_

◆ hasRegisterAccesses_

◆ immediates_

◆ insTemplate_

◆ moves_

◆ parent_

◆ positionInProcedure_

◆ size_