TTAProgram::Procedure Class Reference

#include <Procedure.hh>

Inheritance diagram for TTAProgram::Procedure:

Collaboration diagram for TTAProgram::Procedure:

Public Member Functions
	Procedure (const TCEString &name, const TTAMachine::AddressSpace &space)
	Procedure (const TCEString &name, const TTAMachine::AddressSpace &space, UIntWord startLocation)
virtual	~Procedure ()
TCEString	name () const
int	alignment () const
Address	address (const Instruction &ins) const
void	addFront (Instruction *)
void	add (Instruction *ins)
void	insertAfter (const Instruction &pos, Instruction *ins)
void	insertBefore (const Instruction &pos, Instruction *ins)
void	clear ()
void	remove (Instruction &ins)
CodeSnippet *	copy () const
virtual void	insertAfter (const Instruction &pos, Instruction *ins)
virtual void	insertAfter (const Instruction &pos, const CodeSnippet &cs)
virtual void	insertAfter (const Instruction &pos, CodeSnippet *cs)
virtual void	insertBefore (const Instruction &pos, Instruction *ins)
virtual void	insertBefore (const Instruction &pos, const CodeSnippet &cs)
virtual void	insertBefore (const Instruction &pos, CodeSnippet *cs)
Public Member Functions inherited from TTAProgram::CodeSnippet
	CodeSnippet ()
	CodeSnippet (const TTAProgram::Address &start)
virtual	~CodeSnippet ()
virtual void	removeLastInstruction ()
virtual int	instructionCount () const
virtual Program &	parent () const
virtual void	setParent (Program &prog)
virtual bool	isInProgram () 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	deleteInstructionAt (InstructionAddress address)
virtual void	prepend (const CodeSnippet &cs)
virtual void	prepend (CodeSnippet *cs)
virtual void	append (const CodeSnippet &cs)
virtual void	append (CodeSnippet *cs)
bool	hasReturn () const
virtual std::string	disassembly () const
virtual std::string	toString () const

Private Member Functions
	Procedure (const Procedure &)
	Copying not allowed.
Procedure &	operator= (const Procedure &)
	Assignment not allowed.

Private Attributes
const TCEString	name_
	The name of the procedure.
int	alignment_
	The alignment of instructions.

Static Private Attributes
static const int	INSTRUCTION_INDEX_ALIGNMENT = 1
	The default alignment of instructions.

Additional Inherited Members
Protected Types inherited from TTAProgram::CodeSnippet
typedef std::vector< Instruction * >	InsList
	List of instructions.
typedef InsList::iterator	InsIter
	Iterator for the instruction list.
Protected Attributes inherited from TTAProgram::CodeSnippet
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

Represents a TTA procedure.

Definition at line 55 of file Procedure.hh.

Constructor & Destructor Documentation

Procedure() [1/3]

TTAProgram::Procedure::Procedure	(	const TCEString &	name,
		const TTAMachine::AddressSpace &	space
	)

Constructor.

Create an empty procedure in given address space. Automatically create an empty procedure scope to store all program symbols that are local to this procedure. The default value zero will be used for the start location. Alignment is 1 MAU.

Parameters

name	Name of the procedure.
space	The address space of the procedure.

Definition at line 59 of file Procedure.cc.

                                                     :
    CodeSnippet(Address(0, space)), name_(name) {
}

Procedure() [2/3]

TTAProgram::Procedure::Procedure	(	const TCEString &	name,
		const TTAMachine::AddressSpace &	space,
		UIntWord	startLocation
	)

Alternative constructor that takes the start location of the procedure.

Parameters

name	Name of the procedure.
space	The address space of the procedure.
startLocation	The start location of the procedure.

Definition at line 71 of file Procedure.cc.

                           :
    CodeSnippet(Address(startLocation, space)), name_(name) {
}

~Procedure()

TTAProgram::Procedure::~Procedure ( )

virtual

Destructor

Definition at line 80 of file Procedure.cc.

                      {
}

Procedure() [3/3]

TTAProgram::Procedure::Procedure ( const Procedure &  )

private

Copying not allowed.

Member Function Documentation

add()

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

virtual

Adds an instruction as the last instruction in the procedure.

Remaining procedures in the parent program will be relocated as needed. The ownership of the instruction will be passed to the procedure.

Parameters

ins	The instruction to add.

Exceptions

IllegalRegistration

if the instruction is already registered in another procedure.

Reimplemented from TTAProgram::CodeSnippet.

Definition at line 160 of file Procedure.cc.

                               {
    if (!ins->isInProcedure() || &ins->parent() == this) {
 
        if (instructions_.size() == instructions_.capacity()) {
            instructions_.reserve(instructions_.size() * 2);
        }
 
        ins->setParent(*this);
        instructions_.push_back(ins);
 
        // if registered to a program, tell to move the procedures
        // after the added instruction
        if (parent_ != NULL && this != &parent_->lastProcedure()) {
            parent_->moveProcedure(
                parent_->nextProcedure(*this), 1);
        }
 
    } else {
        throw IllegalRegistration(__FILE__, __LINE__);
    }
}

References TTAProgram::CodeSnippet::instructions_, TTAProgram::Instruction::isInProcedure(), TTAProgram::Program::lastProcedure(), TTAProgram::Program::moveProcedure(), TTAProgram::Program::nextProcedure(), TTAProgram::Instruction::parent(), TTAProgram::CodeSnippet::parent_, and TTAProgram::Instruction::setParent().

Referenced by ProgrammabilityValidator::addConnectionToProgram(), copy(), TTAProgram::Program::copyFrom(), TTAProgram::CodeGenerator::createSchedYieldProcedure(), insertAfter(), and llvm::LLVMTCEBuilder::writeMachineFunction().

Here is the call graph for this function:

addFront()

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

inlinevirtual

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 from TTAProgram::CodeSnippet.

Definition at line 73 of file Procedure.hh.

                           {
        abortWithError("Not Implemented yet.");
    }

References abortWithError.

address()

Address TTAProgram::Procedure::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 procedure.

Reimplemented from TTAProgram::CodeSnippet.

Definition at line 101 of file Procedure.cc.

                                               {
    if (isInProgram() && ins.hasFinalAddress())
        return ins.address();
 
    assert (!isInProgram() || parent().isInstructionPerAddress());
 
    // In case the instruction does not have a fixed final address,
    // compute it according to its current position in the instruction.
    unsigned int i = 0;
 
    /* This loop is executed very often so
       uses pre-computed size and [] for performance reasons.
       TO CLEANUP: 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__);
    }
}

References TTAProgram::Instruction::address(), assert, TTAProgram::Instruction::hasFinalAddress(), TTAProgram::CodeSnippet::instructions_, TTAProgram::CodeSnippet::isInProgram(), TTAProgram::Address::location(), TTAProgram::CodeSnippet::parent(), TTAProgram::Address::space(), and TTAProgram::CodeSnippet::startAddr_.

Referenced by AbsoluteToRelativeJumps::handleProcedure().

Here is the call graph for this function:

alignment()

int TTAProgram::Procedure::alignment

(

)

const

Returns the alignment.

Returns

The alignment.

Definition at line 89 of file Procedure.cc.

                           {
    return alignment_;
}

References alignment_.

Referenced by ControlFlowGraph::buildFrom().

clear()

void TTAProgram::Procedure::clear ( )

virtual

Clears a procedure, updates addresses of following addresses.

Reimplemented from TTAProgram::CodeSnippet.

Definition at line 345 of file Procedure.cc.

                 {
    int insCount = instructionCount();
    CodeSnippet::clear();
 
    if (parent_ != NULL && this != &parent_->lastProcedure()) {
        parent_->moveProcedure(
            parent_->nextProcedure(*this), -insCount);
    }
}

References TTAProgram::CodeSnippet::clear(), TTAProgram::CodeSnippet::instructionCount(), TTAProgram::Program::lastProcedure(), TTAProgram::Program::moveProcedure(), TTAProgram::Program::nextProcedure(), and TTAProgram::CodeSnippet::parent_.

Referenced by SequentialScheduler::copyBasicBlocksToProcedure(), ControlFlowGraph::copyToProcedure(), and BBSchedulerController::handleProcedure().

Here is the call graph for this function:

copy()

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

virtual

Make a complete copy of the procedure.

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

Returns

A complete copy of the procedure.

Reimplemented from TTAProgram::CodeSnippet.

Definition at line 137 of file Procedure.cc.

                      {
 
    Procedure* newProc = new Procedure(
        name_, startAddr_.space(), startAddr_.location());
    for (int i = 0; i < instructionCount(); i++) {
        Instruction* insCopy = instructionAtIndex(i).copy();
        newProc->add(insCopy);
    }
    return newProc;
}

References add(), TTAProgram::Instruction::copy(), TTAProgram::CodeSnippet::instructionAtIndex(), TTAProgram::CodeSnippet::instructionCount(), TTAProgram::Address::location(), name_, TTAProgram::Address::space(), and TTAProgram::CodeSnippet::startAddr_.

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

Here is the call graph for this function:

insertAfter() [1/4]

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 from TTAProgram::CodeSnippet.

Definition at line 112 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;
}

insertAfter() [2/4]

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 from TTAProgram::CodeSnippet.

Definition at line 111 of file CodeSnippet.cc.

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

insertAfter() [3/4]

void TTAProgram::Procedure::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 procedure or ins already belongs to a procedure.

Reimplemented from TTAProgram::CodeSnippet.

Definition at line 193 of file Procedure.cc.

                                                               {
    if (!ins->isInProcedure()) {
        for (InsList::iterator iter = instructions_.begin();
             iter != instructions_.end(); iter++) {
            
            if ((*iter) == &pos) {
                iter++;
                if (iter != instructions_.end()) {
                    ins->setParent(*this);
                    instructions_.insert(iter, ins);
                    
                    // if registered to a program, tell to move the procedures
                    // after this procedure 
                    if (parent_ != NULL && this != &parent_->lastProcedure()) {
                        parent_->moveProcedure(
                            parent_->nextProcedure(*this), 1);
                    }
                    return;
                } else { // end of procedure
                    add(ins);
                    return;
                }
            }
        }
        // should not go here in any case
        throw IllegalRegistration(
            __FILE__,__LINE__,__func__,"pos not in this procedure");
 
    } else {
        throw IllegalRegistration(
            __FILE__, __LINE__, "CodeSnippet::insertInstructionBefore",
            "Instruction already belongs to a procedure.");
    }
}

References __func__, add(), TTAProgram::CodeSnippet::instructions_, TTAProgram::Instruction::isInProcedure(), TTAProgram::Program::lastProcedure(), TTAProgram::Program::moveProcedure(), TTAProgram::Program::nextProcedure(), TTAProgram::CodeSnippet::parent_, and TTAProgram::Instruction::setParent().

Referenced by ProcedurePass::copyCfgToProcedure().

Here is the call graph for this function:

insertAfter() [4/4]

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 from TTAProgram::CodeSnippet.

Definition at line 95 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.");
    }
}

insertBefore() [1/4]

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 from TTAProgram::CodeSnippet.

Definition at line 110 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;
 }

insertBefore() [2/4]

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 from TTAProgram::CodeSnippet.

Definition at line 109 of file CodeSnippet.cc.

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

insertBefore() [3/4]

void TTAProgram::Procedure::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 procedure or ins already belongs to a procedure.

Reimplemented from TTAProgram::CodeSnippet.

Definition at line 242 of file Procedure.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++;
                
                // if registered to a program, tell to move the procedures
                // after this procedure 
                if (parent_ != NULL && this != &parent_->lastProcedure()) {
                    parent_->moveProcedure(
                        parent_->nextProcedure(*this), 1);
                }
                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, TTAProgram::CodeSnippet::instructions_, TTAProgram::Instruction::isInProcedure(), TTAProgram::Program::lastProcedure(), TTAProgram::Program::moveProcedure(), TTAProgram::Program::nextProcedure(), TTAProgram::CodeSnippet::parent_, and TTAProgram::Instruction::setParent().

Here is the call graph for this function:

insertBefore() [4/4]

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 from TTAProgram::CodeSnippet.

Definition at line 96 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.");
    }
}

name()

TCEString TTAProgram::Procedure::name ( ) const

inline

Definition at line 66 of file Procedure.hh.

{ return name_; }

References name_.

Referenced by ControlFlowGraph::buildFrom(), TTAProgram::CodeLabel::CodeLabel(), TTAProgram::Program::copyFrom(), ControlFlowGraph::copyToProcedure(), TTAProgram::ProgramWriter::createBinary(), TTAProgram::ProgramWriter::createCodeSection(), BBSchedulerController::createDDGFromBB(), POMDisassembler::disassemble(), SimulatorFrontend::disassembleInstruction(), llvm::LLVMTCEIRBuilder::doFinalization(), ProgramPass::executeProcedurePass(), TTASimulationController::findProgramExitPoints(), SimulatorFrontend::finishSimulation(), TTAProgram::Program::fixInstructionReferences(), CompiledSimCodeGenerator::generateInstruction(), BBSchedulerController::handleProcedure(), main(), POMDisassembler::procedureDescription(), SimulatorFrontend::programLocationDescription(), and TTAProgram::InstructionReferenceManager::validate().

operator=()

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

private

Assignment not allowed.

remove()

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

virtual

Remove instruction from the procedure.

The instruction becomes independent (it is not deleted). All instructions following the removed procedure 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

ins	Instruction to remove.

Exceptions

IllegalRegistration

If instruction does not belong to the procedure.

Reimplemented from TTAProgram::CodeSnippet.

Definition at line 297 of file Procedure.cc.

                                  {
    bool first = false;
    bool refs = false;
 
    if( parent_ != NULL ) {
        InstructionReferenceManager& irm = 
            parent_->instructionReferenceManager();
        refs = irm.hasReference(ins);
    }
 
    if (!ins.isInProcedure() || !(&ins.parent() == this)) {
        string msg = "Instruction doesn't belong to the procedure.";
        throw IllegalRegistration(__FILE__, __LINE__, __func__, msg);
    }
 
    if (&ins == &firstInstruction()) {
        first = true;
    }
 
    int insIndex = 0;
    for (InsList::iterator iter = instructions_.begin();
         iter != instructions_.end(); iter++, insIndex++) {
        if ((*iter) == &ins) {
 
            iter = instructions_.erase(iter);
            const InstructionAddress addr = startAddr_.location() + insIndex;
 
            // remove code label of first instruction only if empty
            if ((!first && refs) || instructions_.empty()) {
                parent().globalScope().removeCodeLabels(addr);
            }
 
            ins.setParent(NullProcedure::instance());
 
            if (parent_ != NULL && this != &parent_->lastProcedure()) {
                parent_->moveProcedure(
                    parent_->nextProcedure(*this), -1);
            }
 
            return;
        }
    }
}

References __func__, TTAProgram::CodeSnippet::firstInstruction(), TTAProgram::Program::globalScope(), TTAProgram::InstructionReferenceManager::hasReference(), TTAProgram::NullProcedure::instance(), TTAProgram::Program::instructionReferenceManager(), TTAProgram::CodeSnippet::instructions_, TTAProgram::Instruction::isInProcedure(), TTAProgram::Program::lastProcedure(), TTAProgram::Address::location(), TTAProgram::Program::moveProcedure(), TTAProgram::Program::nextProcedure(), TTAProgram::CodeSnippet::parent(), TTAProgram::Instruction::parent(), TTAProgram::CodeSnippet::parent_, TTAProgram::GlobalScope::removeCodeLabels(), TTAProgram::Instruction::setParent(), and TTAProgram::CodeSnippet::startAddr_.

Referenced by ProcedurePass::copyCfgToProcedure(), and TTAProgram::CodeGenerator::createSchedYieldProcedure().

Here is the call graph for this function:

Member Data Documentation

alignment_

int TTAProgram::Procedure::alignment_

private

The alignment of instructions.

Definition at line 99 of file Procedure.hh.

Referenced by alignment().

INSTRUCTION_INDEX_ALIGNMENT

const int TTAProgram::Procedure::INSTRUCTION_INDEX_ALIGNMENT = 1

staticprivate

The default alignment of instructions.

Definition at line 101 of file Procedure.hh.

name_

const TCEString TTAProgram::Procedure::name_

private

The name of the procedure.

Definition at line 97 of file Procedure.hh.

Referenced by copy(), and name().

---

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

• Procedure.hh
• Procedure.cc