#include <CodeSnippet.hh>

Inheritance diagram for TTAProgram::CodeSnippet:

Collaboration diagram for TTAProgram::CodeSnippet:

Public Member Functions
	CodeSnippet ()

	CodeSnippet (const TTAProgram::Address &start)

virtual	~CodeSnippet ()

virtual void	clear ()

virtual void	removeLastInstruction ()

virtual int	instructionCount () const

virtual Program &	parent () const

virtual void	setParent (Program &prog)

virtual bool	isInProgram () const

virtual Address	address (const Instruction &ins) const

virtual Address	startAddress () const

virtual void	setStartAddress (Address start)

virtual Address	endAddress () const

virtual void	setEndAddress (Address end)

virtual Instruction &	firstInstruction () const

virtual Instruction &	instructionAt (UIntWord address) const

virtual Instruction &	instructionAtIndex (int index) const

virtual Instruction &	operator[] (size_t index) const

virtual bool	hasNextInstruction (const Instruction &ins) const

virtual Instruction &	nextInstruction (const Instruction &ins) const

virtual Instruction &	previousInstruction (const Instruction &ins) const

virtual Instruction &	lastInstruction () const

virtual void	addFront (Instruction *ins)

virtual void	add (Instruction *ins)

virtual void	insertAfter (const Instruction &pos, Instruction *ins)

virtual void	insertBefore (const Instruction &pos, Instruction *ins)

virtual void	remove (Instruction &ins)

virtual void	deleteInstructionAt (InstructionAddress address)

virtual CodeSnippet *	copy () const

virtual void	prepend (const CodeSnippet &cs)

virtual void	prepend (CodeSnippet *cs)

virtual void	append (const CodeSnippet &cs)

virtual void	append (CodeSnippet *cs)

virtual void	insertBefore (const Instruction &pos, const CodeSnippet &cs)

virtual void	insertBefore (const Instruction &pos, CodeSnippet *cs)

virtual void	insertAfter (const Instruction &pos, const CodeSnippet &cs)

virtual void	insertAfter (const Instruction &pos, CodeSnippet *cs)

bool	hasReturn () const

virtual std::string	disassembly () const

virtual std::string	toString () const

Protected Types
typedef std::vector< Instruction * >	InsList
	List of instructions.

typedef InsList::iterator	InsIter
	Iterator for the instruction list.

Protected Attributes
InsList	instructions_
	The instructions in this procedure.

Program *	parent_
	The parent program of the procedure.

Address	startAddr_
	The start (lowest) address of the procedure.

Address	endAddr_
	The highest address of the procedure.

Detailed Description

A code snippet is an ordered sequence of adjacent instructions.

It is a helper class for representing pieces of code that are not necessarily full procedures, for example basic blocks. Code snippet doesn't care, whether the sequence of instructions in it makes sense or not. That's the responsibility of the client that created the snippet.

Definition at line 59 of file CodeSnippet.hh.

Member Typedef Documentation

◆ InsIter

typedef InsList::iterator TTAProgram::CodeSnippet::InsIter

protected

Iterator for the instruction list.

Definition at line 123 of file CodeSnippet.hh.

◆ InsList

typedef std::vector<Instruction*> TTAProgram::CodeSnippet::InsList

protected

List of instructions.

Definition at line 121 of file CodeSnippet.hh.

Constructor & Destructor Documentation

◆ CodeSnippet() [1/2]

TTAProgram::CodeSnippet::CodeSnippet ( )

Constructor.

Definition at line 55 of file CodeSnippet.cc.

                         :
    parent_(NULL),
    startAddr_(0, TTAMachine::NullAddressSpace::instance()),
    endAddr_((InstructionAddress)-1,
             TTAMachine::NullAddressSpace::instance()) {
}

Referenced by copy().

◆ CodeSnippet() [2/2]

TTAProgram::CodeSnippet::CodeSnippet ( const TTAProgram::Address & start )

Constructor.

Definition at line 65 of file CodeSnippet.cc.

                                                       : 
    parent_(NULL), startAddr_(start), endAddr_(start) {
}

◆ ~CodeSnippet()

TTAProgram::CodeSnippet::~CodeSnippet ( )

virtual

The destructor.

Definition at line 73 of file CodeSnippet.cc.

                          {
    for (unsigned int i = 0; i < instructions_.size(); i++) {
        if (instructions_.at(i) != &NullInstruction::instance()) {
            delete instructions_.at(i);
        }
    }
    instructions_.clear();
}

References TTAProgram::NullInstruction::instance(), and instructions_.

Here is the call graph for this function:

Member Function Documentation

◆ add()

void TTAProgram::CodeSnippet::add ( Instruction * ins )

virtual

Adds an instruction as the last instruction in the code snippet.

The ownership of the instruction will be passed to the code snippet.

Parameters

ins	The instruction to add.

Exceptions

IllegalRegistration if the instruction is already registered in another code snippet.

Reimplemented in TTAProgram::Procedure.

Definition at line 432 of file CodeSnippet.cc.

                                 {
    if (!ins->isInProcedure()) {
 
        if (instructions_.size() == instructions_.capacity()) {
            instructions_.reserve(instructions_.size() * 2);
        }
 
        ins->setParent(*this);
        instructions_.push_back(ins);
 
    } else {
        throw IllegalRegistration(__FILE__, __LINE__, __func__,
                                  "Instruction: " +
                                  POMDisassembler::disassemble(*ins)
                                  + " allready has parent:\n " + 
                                  ins->parent().disassembly());
    }
}

References __func__, POMDisassembler::disassemble(), disassembly(), instructions_, TTAProgram::Instruction::isInProcedure(), TTAProgram::Instruction::parent(), and TTAProgram::Instruction::setParent().

Here is the call graph for this function:

◆ addFront()

void TTAProgram::CodeSnippet::addFront ( Instruction * ins )

virtual

Adds an instruction as the first instruction in the code snippet.

The ownership of the instruction will be passed to the code snippet.

Parameters

ins	The instruction to add.

Exceptions

IllegalRegistration if the instruction is already registered in another code snippet.

Reimplemented in TTAProgram::Procedure.

Definition at line 406 of file CodeSnippet.cc.

                                      {
    if (!ins->isInProcedure()) {
 
        if (instructions_.size() == instructions_.capacity()) {
            instructions_.reserve(instructions_.size() * 2);
        }
 
        ins->setParent(*this);
        instructions_.insert(instructions_.begin(), ins);
 
    } else {
        throw IllegalRegistration(__FILE__, __LINE__);
    }
}

References instructions_, TTAProgram::Instruction::isInProcedure(), and TTAProgram::Instruction::setParent().

Referenced by prepend(), and prepend().

Here is the call graph for this function:

◆ address()

Address TTAProgram::CodeSnippet::address ( const Instruction & ins ) const

virtual

Returns the address of the given instruction.

Returns: The address of the given instruction.

Exceptions

IllegalRegistration if the instruction does not belong to this code snippet.

Reimplemented in TTAProgram::NullProcedure, and TTAProgram::Procedure.

Definition at line 163 of file CodeSnippet.cc.

                                                 {
    if (ins.hasFinalAddress()) return ins.address();
 
    unsigned int i = 0;
 
    /* this loop is executed very often, so it
       uses a pre-computed size and [] for performance reasons.
       TO CLEANUP: why not use std::find()? */
    const unsigned int size = instructions_.size();
    while (i < size && instructions_[i] != &ins) {
        i++;
    }
 
    if (i != instructions_.size()) {
        Address insAddress(
            startAddr_.location() + i, startAddr_.space());
        return insAddress;
    } else {
        throw IllegalRegistration(
            __FILE__, __LINE__, __func__, "Instruction not in CodeSnippet");
    }
}

References __func__, TTAProgram::Instruction::address(), TTAProgram::Instruction::hasFinalAddress(), instructions_, TTAProgram::Address::location(), TTAProgram::Address::space(), and startAddr_.

Referenced by TTAProgram::Instruction::address(), deleteInstructionAt(), and instructionAt().

Here is the call graph for this function:

◆ append() [1/2]

void TTAProgram::CodeSnippet::append ( CodeSnippet * cs )

virtual

Inserts a whole code snippet at the end of this code snippet.

This function moves the ownership of instructions from the old code snippet into the new one, and deletes the given code snippet.

@TODO: This routine is O(n^2). Optimize!

Parameters

cs	CodeSnippet containing the instructions being inserted.

Definition at line 730 of file CodeSnippet.cc.

                                   {
    for (int i = 0, count = cs->instructionCount(); i < count ; i++) {
        Instruction &ins = cs->instructionAtIndex(0);
        cs->remove(ins);
        add(&ins);
    }
    delete cs;
}

References add(), instructionAtIndex(), instructionCount(), and remove().

Here is the call graph for this function:

◆ append() [2/2]

void TTAProgram::CodeSnippet::append ( const CodeSnippet & cs )

virtual

Inserts a whole code snippet at end of this code snippet.

This function does not remove the instruction references from the code snippet.

Parameters

cs	CodeSnippet containing the instructions being inserted.

Definition at line 711 of file CodeSnippet.cc.

                             {
    for( int i = 0; i < cs.instructionCount(); i++ ) {
        add(cs.instructionAtIndex(i).copy());
    }
 }

References add(), TTAProgram::Instruction::copy(), instructionAtIndex(), and instructionCount().

Referenced by llvm::LLVMTCEBuilder::emitSPInitialization().

Here is the call graph for this function:

◆ clear()

void TTAProgram::CodeSnippet::clear ( )

virtual

Clears the code snippet.

Removes all instruction references inside the snippet and deletes the instructions.

Reimplemented in TTAProgram::BasicBlock, and TTAProgram::Procedure.

Definition at line 89 of file CodeSnippet.cc.

                   {
    for (unsigned int i = 0; i < instructions_.size(); i++) {
        if (instructions_.at(i) != &NullInstruction::instance()) {
            delete instructions_.at(i);
        }
    }
    instructions_.clear();
}

References TTAProgram::NullInstruction::instance(), and instructions_.

Referenced by TTAProgram::BasicBlock::clear(), and TTAProgram::Procedure::clear().

Here is the call graph for this function:

◆ copy()

CodeSnippet * TTAProgram::CodeSnippet::copy ( ) const

virtual

Make a complete copy of the code snippet.

The copy is identical, except that it is not registered to the program of the original code snippet.

Returns: A complete copy of the code snippet.

Reimplemented in TTAProgram::BasicBlock, and TTAProgram::Procedure.

Definition at line 608 of file CodeSnippet.cc.

                        {
 
    CodeSnippet* newProc = new CodeSnippet(startAddr_);
    if (instructionCount() > 0) {
        Instruction* ins = &firstInstruction();
        while (ins != &NullInstruction::instance()) {
            newProc->add(ins->copy());
            ins = &nextInstruction(*ins);
        }
    }
    return newProc;
}

References add(), CodeSnippet(), TTAProgram::Instruction::copy(), firstInstruction(), TTAProgram::NullInstruction::instance(), instructionCount(), nextInstruction(), and startAddr_.

Here is the call graph for this function:

◆ deleteInstructionAt()

void TTAProgram::CodeSnippet::deleteInstructionAt ( InstructionAddress address )

virtual

Remove instruction from the code snippet at the given address and delete it.

All instructions following the removed code snippet are relocated appropriately. All code labels attached to the removed instruction are deleted from the Program.

Note: Possible references to the instruction elsewhere in the program are not automatically fixed! It's a responsibility of the caller to fix the Program back to a consistent state.

Parameters

address Index of the instruction to remove.

Exceptions

IllegalRegistration If instruction does not belong to the code snippet.

Definition at line 593 of file CodeSnippet.cc.

                                                           {
    Instruction& instr = instructionAt(address);
    remove(instr);
    delete &instr;
}

References address(), instructionAt(), and remove().

Here is the call graph for this function:

◆ disassembly()

std::string TTAProgram::CodeSnippet::disassembly ( ) const

virtual

Returns the disassembly of the basic block as string.

Returns: The disassembly of the basic block.

Definition at line 820 of file CodeSnippet.cc.

                               {
 
    std::string content = "";
    const int iCount = instructionCount();
    for (int i = 0; i < iCount; ++i) {
        const TTAProgram::Instruction& instr = instructionAtIndex(i);
        content += POMDisassembler::disassemble(instr);
        content += "\n";
    }
    return content;
}

References POMDisassembler::disassemble(), instructionAtIndex(), and instructionCount().

Referenced by add(), LoopPrologAndEpilogBuilder::addEpilogFromRM(), LoopPrologAndEpilogBuilder::addPrologFromRM(), LoopPrologAndEpilogBuilder::build(), SimpleIfConverter::canConvert(), and toString().

Here is the call graph for this function:

◆ endAddress()

Address TTAProgram::CodeSnippet::endAddress ( ) const

virtual

Returns the first address that is outside of the code snippet.

Reimplemented in TTAProgram::NullProcedure.

Definition at line 788 of file CodeSnippet.cc.

                              {
 
    if (isInProgram() && parent().isFinalized()) {
        return endAddr_;
    } else {
        InstructionAddress endLocation =
            startAddr_.location() + instructions_.size();
        return Address(endLocation, startAddr_.space());
    }
}

References endAddr_, instructions_, isInProgram(), TTAProgram::Address::location(), parent(), TTAProgram::Address::space(), and startAddr_.

Referenced by ControlFlowGraph::buildFrom(), ProgramDependenceGraph::disassemble(), DesignSpaceExplorer::evaluate(), DisassembleCommand::execute(), TTASimulationController::findProgramExitPoints(), SimulatorFrontend::finishSimulation(), SimControlLanguageCommand::parseInstructionAddressExpression(), SimulatorFrontend::programLocationDescription(), and TTAProgram::Program::removeProcedure().

Here is the call graph for this function:

◆ firstInstruction()

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

virtual

Returns the first instruction in the code snippet.

Returns: The first instruction in the code snippet.

Exceptions

InstanceNotFound if there are no instructions in the code snippet.

Reimplemented in TTAProgram::NullProcedure.

Definition at line 216 of file CodeSnippet.cc.

                                    {
    if (!instructions_.empty()) {
        return *instructions_.at(0);
    } else {
        throw InstanceNotFound(
            __FILE__, __LINE__, __func__, "No instructions.");
    }
}

References __func__, and instructions_.

Referenced by SimpleIfConverter::addJump(), ControlFlowGraph::computeLeadersFromRefManager(), ControlFlowGraph::convertBBRefsToInstRefs(), TTAProgram::Program::convertSymbolRef(), copy(), SequentialScheduler::copyBasicBlocksToProcedure(), BasicBlockPass::copyRMToBB(), ControlFlowGraph::copyToProcedure(), ControlFlowGraph::createBBEdges(), ProgramDependenceGraph::createJump(), llvm::LLVMTCEBuilder::emitSPInitialization(), TTAProgram::TerminalBasicBlockReference::equals(), TTAProgram::TerminalInstructionReference::equals(), TTAProgram::Program::finalize(), TTASimulationController::findProgramExitPoints(), TTAProgram::Program::firstInstruction(), CallsToJumps::handleControlFlowGraph(), TTAProgram::CodeLabel::instructionReference(), ControlFlowGraph::jumpToBBN(), ControlFlowGraph::optimizeBBOrdering(), TTAProgram::Procedure::remove(), BasicBlockNode::updateReferencesFromProcToCfg(), TTAProgram::InstructionReferenceManager::validate(), and llvm::LLVMTCEIRBuilder::writeMachineFunction().

◆ hasNextInstruction()

bool TTAProgram::CodeSnippet::hasNextInstruction ( const Instruction & ins ) const

virtual

Tells whether the given instruction is the last instruction of the code snippet or not.

Parameters

ins	The instruction to compare.

Returns: True if the given instruction is not the last instruction in the code snippet, false otherwise.

Reimplemented in TTAProgram::NullProcedure.

Definition at line 303 of file CodeSnippet.cc.

                                                            {
    return (&nextInstruction(ins) != &NullInstruction::instance());
}

References TTAProgram::NullInstruction::instance(), and nextInstruction().

Referenced by insertAfter().

Here is the call graph for this function:

◆ hasReturn()

bool TTAProgram::CodeSnippet::hasReturn ( ) const

Returns true in case there is at least one procedure return in the code snippet.

Definition at line 804 of file CodeSnippet.cc.

                             {
    const int iCount = instructionCount();
    for (int i = 0; i < iCount; ++i) {
        if (instructionAtIndex(i).hasReturn()) {
            return true;
        }
    }
    return false;
}

References hasReturn(), instructionAtIndex(), and instructionCount().

Referenced by hasReturn().

Here is the call graph for this function:

◆ insertAfter() [1/3]

void TTAProgram::CodeSnippet::insertAfter	(	const Instruction &	pos,
		CodeSnippet *	cs
	)

virtual

Inserts a whole code snippet into this code snippet just after specified instruction.

This function moves the ownership of the moves and deletes the another code snippet.

Parameters

ins	The succeeding the place where to insert he instructions.
cs	CodeSnippet containing the instructions being inserted.

Reimplemented in TTAProgram::Procedure.

Definition at line 690 of file CodeSnippet.cc.

                                              {
 
     for (int i = cs->instructionCount()-1; i >= 0 ; i-- ) {
         Instruction& ins = cs->instructionAtIndex(i);
         cs->remove(ins);
         insertAfter(pos, &ins);
     }
     delete cs;
}

References insertAfter(), instructionAtIndex(), instructionCount(), and remove().

Here is the call graph for this function:

◆ insertAfter() [2/3]

void TTAProgram::CodeSnippet::insertAfter	(	const Instruction &	pos,
		const CodeSnippet &	cs
	)

virtual

Inserts a whole code snippet into this code snippet just after specified instruction.

This function does not remove the instruction references from the code snippet.

Parameters

ins	The succeeding the place where to insert he instructions.
cs	CodeSnippet containing the instructions being inserted.

Reimplemented in TTAProgram::Procedure.

Definition at line 671 of file CodeSnippet.cc.

                                                    {
 
     for (int i = cs.instructionCount()-1; i >= 0 ; i-- ) {
         insertAfter(pos, cs.instructionAtIndex(i).copy());
     }
}

References TTAProgram::Instruction::copy(), insertAfter(), instructionAtIndex(), and instructionCount().

Here is the call graph for this function:

◆ insertAfter() [3/3]

void TTAProgram::CodeSnippet::insertAfter	(	const Instruction &	pos,
		Instruction *	ins
	)

virtual

Insert the given instruction after the given position.

Instructions from pos are relocated to make room for the new instruction.

Parameters

pos	The position.
ins	The instruction to insert.

Exceptions

IllegalRegistration if pos does not belong to the code snippet or ins already belongs to a code snippet.

Reimplemented in TTAProgram::Procedure, and TTAProgram::Procedure.

Definition at line 462 of file CodeSnippet.cc.

                                                                 {
    if (!ins->isInProcedure()) {
 
        if (hasNextInstruction(pos)) {
 
            InsList::iterator iter = instructions_.begin();
            Instruction& next = nextInstruction(pos);
 
            while (iter != instructions_.end()) {
 
                if ((*iter) == &next) {
 
                    ins->setParent(*this);
 
                    iter = instructions_.insert(iter, ins);
 
                    iter++;
 
                    return;
                }
 
                iter++;
            }
 
            // should not go here in any case
            assert(false);
 
        } else {
            add(ins);
        }
 
    } else {
        throw IllegalRegistration(
            __FILE__, __LINE__, "CodeSnippet::insertInstructionBefore",
            "Instruction already belongs to a procedure.");
    }
}

References add(), assert, hasNextInstruction(), instructions_, TTAProgram::Instruction::isInProcedure(), nextInstruction(), and TTAProgram::Instruction::setParent().

Referenced by insertAfter(), insertAfter(), and PreOptimizer::tryToRemoveGuardInversingOp().

Here is the call graph for this function:

◆ insertBefore() [1/3]

void TTAProgram::CodeSnippet::insertBefore	(	const Instruction &	pos,
		CodeSnippet *	cs
	)

virtual

Inserts a whole code snippet into this code snippet just before specified instruction. This function moves the ownership of the moves and deletes the another code snippet.

Parameters

ins	The succeeding the place where to insert he instructions.
cs	CodeSnippet containing the instructions being inserted.

Reimplemented in TTAProgram::Procedure.

Definition at line 650 of file CodeSnippet.cc.

                                             {
    for( int i = 0, count = cs->instructionCount(); i < count; i++ ) {
        Instruction& ins = cs->instructionAtIndex(0);
        cs->remove(ins);
        insertBefore(pos, &ins);
    }
    delete cs;
 }

References insertBefore(), instructionAtIndex(), instructionCount(), and remove().

Here is the call graph for this function:

◆ insertBefore() [2/3]

void TTAProgram::CodeSnippet::insertBefore	(	const Instruction &	pos,
		const CodeSnippet &	cs
	)

virtual

Inserts a whole code snippet into this code snippet just before specified instruction.

This function does not remove the instruction references from the code snippet.

Parameters

ins	The succeeding the place where to insert he instructions.
cs	CodeSnippet containing the instructions being inserted.

Reimplemented in TTAProgram::Procedure.

Definition at line 632 of file CodeSnippet.cc.

                                                   {
    for( int i = 0; i < cs.instructionCount(); i++ ) {
        insertBefore(pos, cs.instructionAtIndex(i).copy());
    }
 }

References TTAProgram::Instruction::copy(), insertBefore(), instructionAtIndex(), and instructionCount().

Here is the call graph for this function:

◆ insertBefore() [3/3]

void TTAProgram::CodeSnippet::insertBefore	(	const Instruction &	pos,
		Instruction *	ins
	)

virtual

Insert the given instruction before the given position.

Instructions from and including pos are relocated to make room for the new instruction.

Todo:: Refactor and share implementation with insertInstructionAfter()

Parameters

pos	The position.
ins	The instruction to insert.

Exceptions

IllegalRegistration if pos does not belong to the code snippet or ins already belongs to a code snippet.

Reimplemented in TTAProgram::Procedure, and TTAProgram::Procedure.

Definition at line 514 of file CodeSnippet.cc.

                                                                  {
    if (!ins->isInProcedure()) {
 
        InsList::iterator iter = instructions_.begin();
        const Instruction& next = pos;
 
        while (iter != instructions_.end()) {
 
            if ((*iter) == &next) {
 
                ins->setParent(*this);
                iter = instructions_.insert(iter, ins);
                iter++;
                return;
            }
            iter++;
        }
        // should not go here in any case
        assert(false);
    } else {
        throw IllegalRegistration(
            __FILE__, __LINE__, "CodeSnippet::insertInstructionBefore",
            "Instruction already belongs to a procedure.");
    }
}

References assert, instructions_, TTAProgram::Instruction::isInProcedure(), and TTAProgram::Instruction::setParent().

Referenced by llvm::LLVMTCEBuilder::emitSPInitialization(), CallsToJumps::handleControlFlowGraph(), insertBefore(), and insertBefore().

Here is the call graph for this function:

◆ instructionAt()

Instruction & TTAProgram::CodeSnippet::instructionAt ( UIntWord address ) const

virtual

Returns the explicit instruction at a given address.

The address space of the address is implied, since there is only one address space for instructions. In case there are multiple instructions at the given address, only one of them is considered explicit, others implicit. The implicit instructions are detected by having a size of 0.

Parameters

address The instruction address.

Note: This is a slow method to traverse instructions, it's O(N).

Exceptions

KeyNotFound if given address is illegal.

Todo:: Rename to instruction() to match Program::procedure() and Instruction::move().

Reimplemented in TTAProgram::NullProcedure.

Definition at line 241 of file CodeSnippet.cc.

                                                 {
    if (isInProgram() && !parent().isInstructionPerAddress()) {
        // In the finalized program, there might not be one instruction
        // per index, thus we have to find the instruction by an
        // exhaustive search. @todo optimize this in case it's a
        // bottleneck somewhere.
 
        for (size_t i = 0; i < instructions_.size(); ++i) {
            Instruction* ins = instructions_.at(i);
            if (ins->address().location() == address &&
                ins->size() > 0)
                return *ins;
        }
    } else {
        int index = (address - startAddr_.location());
        if (index >= 0 && static_cast<unsigned int>(index) <
            instructions_.size()) {
            Instruction* ins = instructions_.at(index);
            if (ins == &NullInstruction::instance()) {
                throw KeyNotFound(__FILE__, __LINE__);
            } else {
                return *ins;
            }
        }
    }
    std::string msg = "Address " + Conversion::toString(address) + 
        " not in this codesnippet( " + 
        Conversion::toString(startAddr_.location()) + "-" +
        Conversion::toString(startAddr_.location() +
                             instructions_.size()-1)
        + " )";
    throw KeyNotFound(__FILE__, __LINE__, __func__, msg );
}

References __func__, TTAProgram::Instruction::address(), address(), TTAProgram::NullInstruction::instance(), instructions_, isInProgram(), TTAProgram::Address::location(), parent(), TTAProgram::Instruction::size(), startAddr_, and Conversion::toString().

Referenced by ControlFlowGraph::computeLeadersFromRelocations(), SequentialScheduler::copyBasicBlocksToProcedure(), ProcedurePass::copyCfgToProcedure(), ControlFlowGraph::createAllBlocks(), deleteInstructionAt(), and ControlFlowGraph::splitBasicBlocksWithCallsAndRefs().

Here is the call graph for this function:

◆ instructionAtIndex()

Instruction & TTAProgram::CodeSnippet::instructionAtIndex ( int index ) const

virtual

Returns the instruction at a given index in the container of instructions.

This method is for quickly traversing through all the instructions within time critical loops.

Parameters

index The instruction index in the list of instructions.

Returns: The Instruction at the given index.

Definition at line 285 of file CodeSnippet.cc.

                                               {
    return *instructions_.at(index);
}

References instructions_.

◆ instructionCount()

int TTAProgram::CodeSnippet::instructionCount ( ) const

virtual

Returns the number of instructions in this code snippet.

Returns: the number of instructions in this code snippet.

Reimplemented in TTAProgram::NullProcedure.

Definition at line 205 of file CodeSnippet.cc.

                                    {
    return instructions_.size();
}

References instructions_.

◆ isInProgram()

bool TTAProgram::CodeSnippet::isInProgram ( ) const

virtual

Tells whether the code snippet belongs to a program.

Returns: True if the code snippet belongs to a program (it is registered), false otherwise.

Reimplemented in TTAProgram::NullProcedure.

Definition at line 151 of file CodeSnippet.cc.

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

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

Referenced by TTAProgram::Program::addProcedure(), TTAProgram::Procedure::address(), ControlFlowGraph::buildFrom(), ControlFlowGraph::computeLeadersFromRefManager(), ControlFlowGraph::computeLeadersFromRelocations(), SequentialScheduler::copyBasicBlocksToProcedure(), ProcedurePass::copyCfgToProcedure(), ControlFlowGraph::copyToProcedure(), ControlFlowGraph::createBBEdges(), POMDisassembler::createMove(), ProgramDependenceGraph::disassemble(), POMDisassembler::disassemble(), endAddress(), instructionAt(), TTAProgram::Program::nextInstruction(), nextInstruction(), TTAProgram::Program::nextProcedure(), previousInstruction(), and TTAProgram::InstructionReferenceManager::validate().

Here is the call graph for this function:

◆ lastInstruction()

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

virtual

Returns the last instruction in the code snippet.

Returns: The last instruction in the code snippet.

Exceptions

IllegalRegistration if there are no instructions in the code snippet.

Reimplemented in TTAProgram::NullProcedure.

Definition at line 387 of file CodeSnippet.cc.

                                   {
    if (!instructions_.empty()) {
        return *instructions_.back();
    } else {
        throw IllegalRegistration(__FILE__, __LINE__);
    }
}

References instructions_.

Referenced by SimpleIfConverter::canConvert(), SimpleIfConverter::combineBlocks(), ControlFlowGraph::createAllBlocks(), ProgramDependenceGraph::createJump(), llvm::LLVMTCEBuilder::emitGlobalXXtructorCalls(), llvm::LLVMTCEBuilder::emitReadSP(), llvm::LLVMTCEBuilder::emitReturnTo(), llvm::LLVMTCEBuilder::emitWriteSP(), DisassembleCommand::execute(), TTAProgram::Program::finalize(), BBSchedulerController::handleBasicBlock(), llvm::LLVMTCEBuilder::handleMemoryCategoryInfo(), TTAProgram::Program::lastInstruction(), SimpleIfConverter::removeJump(), ControlFlowGraph::splitBasicBlocksWithCallsAndRefs(), SimpleIfConverter::successors(), and BasicBlockNode::toString().

◆ nextInstruction()

Instruction & TTAProgram::CodeSnippet::nextInstruction ( const Instruction & ins ) const

virtual

Returns the next instruction in the instruction stream.

Returns: The next instruction in the instruction stream or a special null instruction if the given instruction is the last instruction of the code snippet.

Exceptions

IllegalRegistration If given instruction does not belong to the code snippet.

Reimplemented in TTAProgram::NullProcedure.

Definition at line 318 of file CodeSnippet.cc.

                                                         {
    if (&ins.parent() != this)
        throw IllegalRegistration(__FILE__, __LINE__);
 
    if (isInProgram() && !parent().isInstructionPerAddress()) {
        InsList::const_iterator pos =
            std::find(instructions_.begin(), instructions_.end(), &ins);
        if (pos == instructions_.end() || pos+1 == instructions_.end())
            return NullInstruction::instance();
        else
            return **(pos+1);
    } else {
        int insAddress = ins.address().location();
 
        unsigned int current = (insAddress - startAddr_.location());
        unsigned int next = current + 1;
 
        if (next < instructions_.size())
            return *instructions_.at(next);
        else
            return NullInstruction::instance();
    }
}

References TTAProgram::Instruction::address(), TTAProgram::NullInstruction::instance(), instructions_, isInProgram(), TTAProgram::Address::location(), parent(), TTAProgram::Instruction::parent(), and startAddr_.

Referenced by copy(), TTAProgram::CodeGenerator::createSchedYieldProcedure(), llvm::LLVMTCEBuilder::emitReadSP(), llvm::LLVMTCEBuilder::emitReturnTo(), llvm::LLVMTCEBuilder::emitWriteSP(), llvm::LLVMTCEBuilder::handleMemoryCategoryInfo(), hasNextInstruction(), insertAfter(), and TTAProgram::Program::nextInstruction().

Here is the call graph for this function:

◆ operator[]()

Instruction & TTAProgram::CodeSnippet::operator[] ( size_t index ) const

virtual

Definition at line 290 of file CodeSnippet.cc.

                                          {
    return *instructions_[index];
}

References instructions_.

◆ parent()

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

virtual

Return the parent program that contains the code snippet.

Returns: The parent program that contains the code snippet

Exceptions

IllegalRegistration If the code snippet is not registered anywhere.

Reimplemented in TTAProgram::NullProcedure.

Definition at line 118 of file CodeSnippet.cc.

                          {
    if (parent_ != NULL) {
        return *parent_;
    } else {
        throw IllegalRegistration(__FILE__, __LINE__,__func__,"no parent");
    }
}

References __func__, and parent_.

Referenced by TTAProgram::Procedure::address(), ControlFlowGraph::buildFrom(), TTAProgram::CodeLabel::CodeLabel(), TTAProgram::CodeLabel::CodeLabel(), ControlFlowGraph::computeLeadersFromRefManager(), ControlFlowGraph::computeLeadersFromRelocations(), SequentialScheduler::copyBasicBlocksToProcedure(), ProcedurePass::copyCfgToProcedure(), ControlFlowGraph::copyToProcedure(), SequentialScheduler::createBasicBlocks(), POMDisassembler::createMove(), POMDisassembler::destinationLabels(), POMDisassembler::disassemble(), endAddress(), SequentialScheduler::handleProcedure(), SimpleIfConverter::handleProcedure(), AbsoluteToRelativeJumps::handleProcedure(), instructionAt(), TTAProgram::CodeLabel::instructionReference(), TTAProgram::Program::nextInstruction(), nextInstruction(), TTAProgram::Program::nextProcedure(), previousInstruction(), TTAProgram::Procedure::remove(), and TTAProgram::Program::removeProcedure().

◆ prepend() [1/2]

void TTAProgram::CodeSnippet::prepend ( CodeSnippet * cs )

virtual

Inserts a whole code snippet at the beginning of this code snippet.

This function moves the ownership of instructions from the old code snippet into the new one, and deletes the given code snippet.

@TODO: This routine is O(n^2). Optimize!

Parameters

cs	CodeSnippet containing the instructions being inserted.

Definition at line 765 of file CodeSnippet.cc.

                                    {
    for (int i = cs->instructionCount()-1; i >= 0 ; i--) {
        Instruction &ins = cs->instructionAtIndex(i);
        cs->remove(ins);
        addFront(&ins);
    }
    delete cs;
}

References addFront(), instructionAtIndex(), instructionCount(), and remove().

Here is the call graph for this function:

◆ prepend() [2/2]

void TTAProgram::CodeSnippet::prepend ( const CodeSnippet & cs )

virtual

Inserts a whole code snippet at the beginning of this code snippet.

This function does not remove the instruction references from the code snippet.

Parameters

cs	CodeSnippet containing the instructions being inserted.

Definition at line 748 of file CodeSnippet.cc.

                                           {
    for (int i = cs.instructionCount()-1; i >= 0 ; i--) {
        addFront(cs.instructionAtIndex(i).copy());
    }
}

References addFront(), TTAProgram::Instruction::copy(), instructionAtIndex(), and instructionCount().

Here is the call graph for this function:

◆ previousInstruction()

Instruction & TTAProgram::CodeSnippet::previousInstruction ( const Instruction & ins ) const

virtual

Return the previous instruction in the instruction stream.

Returns: The previous instruction in the instruction stream or a special null instruction if the given instruction is the first instruction of the code snippet.

Exceptions

IllegalRegistration If given instruction does not belong to the code snippet.

Reimplemented in TTAProgram::NullProcedure.

Definition at line 352 of file CodeSnippet.cc.

                                                             {
    if (&ins.parent() != this)
        throw IllegalRegistration(__FILE__, __LINE__, __func__);
 
    if (isInProgram() && !parent().isInstructionPerAddress()) {
        InsList::const_iterator pos =
            std::find(instructions_.begin(), instructions_.end(), &ins);
 
        if (pos == instructions_.begin())
            return NullInstruction::instance();
 
        return *const_cast<Instruction*>(*(--pos));
    } else {
        int insAddress =
            (ins.address().location() - startAddr_.location()) - 1;
        while (insAddress >= 0) {
            Instruction& prevIns = *instructions_.at(insAddress);
            if (&prevIns != &NullInstruction::instance()) {
                return prevIns;
            } else {
                insAddress--;
            }
        }
        return NullInstruction::instance();
    }
}

References __func__, TTAProgram::Instruction::address(), TTAProgram::NullInstruction::instance(), instructions_, isInProgram(), TTAProgram::Address::location(), parent(), TTAProgram::Instruction::parent(), and startAddr_.

Referenced by SimpleIfConverter::canConvert(), ControlFlowGraph::createJumps(), and SimpleIfConverter::successors().

Here is the call graph for this function:

◆ remove()

void TTAProgram::CodeSnippet::remove ( Instruction & ins )

virtual

Remove instruction from the code snippet.

The instruction becomes independent (it is not deleted). All instructions following the removed code snippet are relocated appropriately.

The instructions should not have code labels attached to them.

Note: Possible references to the instruction elsewhere in the program are not automatically fixed! It's a responsibility of the caller to fix the Program back to a consistent state.

Parameters

ins	Instruction to remove.

Exceptions

IllegalRegistration If instruction does not belong to the code snippet.

Reimplemented in TTAProgram::Procedure.

Definition at line 558 of file CodeSnippet.cc.

                                    {
    if (!ins.isInProcedure() || !(&ins.parent() == this)) {
        string msg = "Instruction doesn't belong to the procedure.";
        throw IllegalRegistration(__FILE__, __LINE__, __func__, msg);
    }
 
    InsList::iterator iter = instructions_.begin();
 
    for (; iter != instructions_.end(); iter++) {
        if ((*iter) == &ins) {
 
            iter = instructions_.erase(iter);
            ins.setParent(NullProcedure::instance());
 
            return;
        }
    }
}

References __func__, TTAProgram::NullProcedure::instance(), instructions_, TTAProgram::Instruction::isInProcedure(), TTAProgram::Instruction::parent(), and TTAProgram::Instruction::setParent().

Referenced by append(), deleteInstructionAt(), CallsToJumps::handleControlFlowGraph(), insertAfter(), insertBefore(), ControlFlowGraph::mergeNodes(), LoopPrologAndEpilogBuilder::optimizeEpilog(), LoopPrologAndEpilogBuilder::optimizeProlog(), prepend(), ControlFlowGraph::splitBasicBlockAtIndex(), ControlFlowGraph::splitBB(), PreOptimizer::tryToPrecalcConstantAdd(), and PreOptimizer::tryToRemoveGuardInversingOp().

Here is the call graph for this function:

◆ removeLastInstruction()

void TTAProgram::CodeSnippet::removeLastInstruction ( )

virtual

Remove one instruction from the end of the code snippet.

Nothing happens if the code snippet is empty.

Definition at line 104 of file CodeSnippet.cc.

                                   {
    if (!instructions_.empty()) {
        instructions_.pop_back();
    }
}

References instructions_.

◆ setEndAddress()

void TTAProgram::CodeSnippet::setEndAddress ( Address end )

virtual

Definition at line 195 of file CodeSnippet.cc.

                                      {
    endAddr_ = end;
}

References endAddr_.

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

◆ setParent()

void TTAProgram::CodeSnippet::setParent ( Program & prog )

virtual

Sets the parent program of the code snippet.

Note: This method does not check that the code snippet actually belongs to the given program. It should, therefore be called only be Program::addProcedure().

Parameters

prog	The new parent program.

Reimplemented in TTAProgram::NullProcedure.

Definition at line 136 of file CodeSnippet.cc.

                                    {
    if (&prog == &NullProgram::instance()) {
        parent_ = NULL;
    } else {
        parent_ = &prog;
    }
}

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

Referenced by TTAProgram::Program::addProcedure(), and TTAProgram::Program::removeProcedure().

Here is the call graph for this function:

◆ setStartAddress()

void TTAProgram::CodeSnippet::setStartAddress ( Address start )

virtual

Sets the start address of the code snippet.

Reimplemented in TTAProgram::NullProcedure.

Definition at line 190 of file CodeSnippet.cc.

                                          {
    startAddr_ = start;
}

References startAddr_.

Referenced by TTAProgram::Program::addProcedure(), TTAProgram::Program::finalize(), and TTAProgram::Program::moveProcedure().

◆ startAddress()

Address TTAProgram::CodeSnippet::startAddress ( ) const

virtual

Returns the start address of the code snippet.

Returns: The start (lowest) address of the code snippet.

Reimplemented in TTAProgram::NullProcedure.

Definition at line 780 of file CodeSnippet.cc.

                                {
    return startAddr_;
}

References startAddr_.

Referenced by TTAProgram::CodeLabel::address(), TTAProgram::Instruction::address(), ControlFlowGraph::buildFrom(), TTAProgram::CodeLabel::CodeLabel(), TTAProgram::Program::copyFrom(), ControlFlowGraph::createBBEdges(), TTAProgram::ProgramWriter::createBinary(), ControlFlowGraph::createBlock(), llvm::LLVMTCEBuilder::deleteDeadProcedures(), POMDisassembler::destinationLabels(), ControlFlowGraph::directJump(), ProgramDependenceGraph::disassemble(), SimulatorFrontend::disassembleInstruction(), POMDisassembler::disassembleProcedure(), DesignSpaceExplorer::evaluate(), DisassembleCommand::execute(), TTASimulationController::findProgramExitPoints(), SimulatorFrontend::finishSimulation(), TTAProgram::Program::fixInstructionReferences(), ControlFlowGraph::indirectJump(), TTAProgram::Program::instructionCount(), TTAProgram::Program::moveProcedure(), SimControlLanguageCommand::parseInstructionAddressExpression(), SimulatorFrontend::programLocationDescription(), TTAProgram::Program::removeProcedure(), and TTAProgram::TerminalBasicBlockReference::value().

◆ toString()

virtual std::string TTAProgram::CodeSnippet::toString ( ) const

inlinevirtual

Definition at line 117 of file CodeSnippet.hh.

117{ return disassembly(); }

TTAProgram::CodeSnippet::disassembly

virtual std::string disassembly() const

Definition CodeSnippet.cc:820

References disassembly().

Referenced by ControlFlowGraph::buildMBBFromBB(), ControlFlowGraph::copyToProcedure(), llvm::LLVMTCEIRBuilder::createMBBReference(), CallsToJumps::handleControlFlowGraph(), and InlineAsmParser::parse().

Here is the call graph for this function:

Member Data Documentation

◆ endAddr_

Address TTAProgram::CodeSnippet::endAddr_

protected

The highest address of the procedure.

Definition at line 132 of file CodeSnippet.hh.

Referenced by endAddress(), and setEndAddress().

◆ instructions_

InsList TTAProgram::CodeSnippet::instructions_

protected

The instructions in this procedure.

Definition at line 126 of file CodeSnippet.hh.

Referenced by add(), TTAProgram::Procedure::add(), addFront(), address(), TTAProgram::Procedure::address(), clear(), endAddress(), firstInstruction(), insertAfter(), TTAProgram::Procedure::insertAfter(), insertBefore(), TTAProgram::Procedure::insertBefore(), instructionAt(), instructionAtIndex(), instructionCount(), lastInstruction(), nextInstruction(), operator[](), previousInstruction(), remove(), TTAProgram::Procedure::remove(), removeLastInstruction(), and ~CodeSnippet().

◆ parent_

Program* TTAProgram::CodeSnippet::parent_

protected

The parent program of the procedure.

Definition at line 128 of file CodeSnippet.hh.

Referenced by TTAProgram::Procedure::add(), TTAProgram::Procedure::clear(), TTAProgram::Procedure::insertAfter(), TTAProgram::Procedure::insertBefore(), isInProgram(), parent(), TTAProgram::Procedure::remove(), and setParent().

◆ startAddr_

Address TTAProgram::CodeSnippet::startAddr_

protected

The start (lowest) address of the procedure.

Definition at line 130 of file CodeSnippet.hh.

Referenced by address(), TTAProgram::Procedure::address(), TTAProgram::BasicBlock::copy(), copy(), TTAProgram::Procedure::copy(), endAddress(), instructionAt(), nextInstruction(), previousInstruction(), TTAProgram::Procedure::remove(), setStartAddress(), and startAddress().

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

Public Member Functions

Protected Types

Protected Attributes

Detailed Description

Member Typedef Documentation

◆ InsIter

◆ InsList

Constructor & Destructor Documentation

◆ CodeSnippet() [1/2]

◆ CodeSnippet() [2/2]

◆ ~CodeSnippet()

Member Function Documentation

◆ add()

◆ addFront()

◆ address()

◆ append() [1/2]

◆ append() [2/2]

◆ clear()

◆ copy()

◆ deleteInstructionAt()

◆ disassembly()

◆ endAddress()

◆ firstInstruction()

◆ hasNextInstruction()

◆ hasReturn()

◆ insertAfter() [1/3]

◆ insertAfter() [2/3]

◆ insertAfter() [3/3]

◆ insertBefore() [1/3]

◆ insertBefore() [2/3]

◆ insertBefore() [3/3]

◆ instructionAt()

◆ instructionAtIndex()

◆ instructionCount()

◆ isInProgram()

◆ lastInstruction()

◆ nextInstruction()

◆ operator[]()

◆ parent()

◆ prepend() [1/2]

◆ prepend() [2/2]

◆ previousInstruction()

◆ remove()

◆ removeLastInstruction()

◆ setEndAddress()

◆ setParent()

◆ setStartAddress()

◆ startAddress()

◆ toString()

Member Data Documentation

◆ endAddr_

◆ instructions_

◆ parent_

◆ startAddr_