#include <Program.hh>

Inheritance diagram for TTAProgram::Program:

Collaboration diagram for TTAProgram::Program:

Public Types
typedef std::vector< Instruction * >	InstructionVector
	Vector for instructions.

Public Member Functions
	Program (const TTAMachine::AddressSpace &space)

	Program (const TTAMachine::AddressSpace &space, Address start)

	Program (const TTAMachine::AddressSpace &space, Address start, Address entry)

virtual	~Program ()

GlobalScope &	globalScope ()

const GlobalScope &	globalScopeConst () const

TTAMachine::Machine &	targetProcessor () const

UniversalMachine &	universalMachine () const

void	setUniversalMachine (UniversalMachine *umach)

Address	startAddress () const

void	setStartAddress (Address start)

Address	entryAddress () const

void	setEntryAddress (Address address)

void	addProcedure (Procedure *proc)

void	addInstruction (Instruction *ins)

void	moveProcedure (Procedure &proc, int howMuch)

Procedure &	firstProcedure () const

Procedure &	lastProcedure () const

Procedure &	nextProcedure (const Procedure &proc) const

int	procedureCount () const

Procedure &	procedure (int index) const

Procedure &	operator[] (size_t index)

Procedure &	procedure (const std::string &name) const

bool	hasProcedure (const std::string &name) const

Instruction &	firstInstruction () const

Instruction &	instructionAt (InstructionAddress address) const

int	instructionCount () const

const Move &	moveAt (int number) const

int	moveCount () const

const Procedure &	procedureAtIndex (int index) const

Instruction &	nextInstruction (const Instruction &) const

Instruction &	lastInstruction () const

InstructionReferenceManager &	instructionReferenceManager () const

Program &	operator= (const Program &old)

Program *	copy () const

void	removeProcedure (Procedure &proc)

int	dataMemoryCount () const

DataMemory &	dataMemory (int index) const

DataMemory &	dataMemory (const std::string &aSpaceName) const

void	addDataMemory (DataMemory *dataMem)

void	replaceUniversalAddressSpaces (const TTAMachine::AddressSpace &space)

InstructionVector	instructionVector () const

void	link (const TTAProgram::Program &other)

void	convertSymbolRefsToInsRefs (bool ignoreUnfoundSymbols=false)

void	fixInstructionReferences ()

TCEString	toString () const

void	finalize ()

bool	isFinalized () const

bool	isInstructionPerAddress () const

Static Public Member Functions
static Program *	loadFromUnscheduledTPEF (const std::string &tpefFileName, const TTAMachine::Machine &theMachine)

static Program *	loadFromTPEF (const std::string &tpefFileName, const TTAMachine::Machine &theMachine)

static Program *	loadFromUnscheduledTPEF (const std::string &tpefFileName)

static void	writeToTPEF (const TTAProgram::Program &program, const std::string &tpefFileName)

Private Types
typedef std::vector< Procedure * >	ProcList
	List for procedures.

typedef ProcList::const_iterator	ProcIter
	Iterator for the procedure list.

typedef std::vector< DataMemory * >	DataMemList
	List for data memories.

typedef std::vector< Move * >	MoveList
	List for moves.

Private Member Functions
	Program (const Program &)
	Copying not allowed.

void	copyDataMemoriesFrom (const Program &srcProg)

void	copyCodeLabelsFrom (const Program &srcProg)

void	copyDataLabelsFrom (const Program &srcProg)

void	copyFrom (const Program &source)

void	cleanup ()

TerminalImmediate *	convertSymbolRef (Terminal &tsr)

Private Attributes
GlobalScope *	globalScope_
	Global scope of the program.

ProcList	procedures_
	The procedures in the program.

DataMemList	dataMems_
	The data memories in the program.

MoveList	moves_
	List of all the moves of the program.

Address	start_
	The start address of the program.

Address	entry_
	The entry address of the program.

InstructionReferenceManager *	refManager_
	Keeps book of all instruction to instruction (jumps and calls) references in the program.

UniversalMachine *	umach_
	The UniversalMachine instance used to refer to in case of the unscheduled/unassigned parts of the program.

bool	finalized_
	True in case the program is not (and must not be) updated anymore and it has its final instruction addresses computed.

bool	instructionPerAddress_
	True in case the program is instruction indexed, that is, each instruction is assumed to be in a single instruction memory location.

Detailed Description

Represents a TTA program.

Definition at line 63 of file Program.hh.

Member Typedef Documentation

◆ DataMemList

typedef std::vector<DataMemory*> TTAProgram::Program::DataMemList

private

List for data memories.

Definition at line 158 of file Program.hh.

◆ InstructionVector

typedef std::vector<Instruction*> TTAProgram::Program::InstructionVector

Vector for instructions.

Definition at line 66 of file Program.hh.

◆ MoveList

typedef std::vector<Move*> TTAProgram::Program::MoveList

private

List for moves.

Definition at line 160 of file Program.hh.

◆ ProcIter

typedef ProcList::const_iterator TTAProgram::Program::ProcIter

private

Iterator for the procedure list.

Definition at line 156 of file Program.hh.

◆ ProcList

typedef std::vector<Procedure*> TTAProgram::Program::ProcList

private

List for procedures.

Definition at line 154 of file Program.hh.

Constructor & Destructor Documentation

◆ Program() [1/4]

TTAProgram::Program::Program ( const TTAMachine::AddressSpace & space )

Constructor.

Creates an empty program in given address space. A default value zero is used for start and entry addresses. Automatically creates an empty global scope to store all program symbols with external linkage.

Parameters

space The address space of the program.

Definition at line 91 of file Program.cc.

                                         :
    start_(0, space), entry_(0, space), umach_(NULL), finalized_(false),
    instructionPerAddress_(true) {
    globalScope_ = new GlobalScope();
    refManager_ = new InstructionReferenceManager();
}

References globalScope_, and refManager_.

◆ Program() [2/4]

TTAProgram::Program::Program	(	const TTAMachine::AddressSpace &	space,
		Address	start
	)

Constructor.

Alternative constructor that takes the start address as a parameter.

Parameters

space	The address space of the program.
start	The start address of the program.

Definition at line 116 of file Program.cc.

                                                        :
    start_(start), entry_(0, space), umach_(NULL), finalized_(false),
    instructionPerAddress_(true) {
    globalScope_ = new GlobalScope();
    refManager_ = new InstructionReferenceManager();
}

References globalScope_, and refManager_.

◆ Program() [3/4]

TTAProgram::Program::Program	(	const TTAMachine::AddressSpace &	space,
		Address	start,
		Address	entry
	)

Constructor.

Alternative constructor that takes the start and entry addresses as parameters.

Parameters

space	The address space of the program.
start	The start address of the program.
entry	The entry address of the program.

Definition at line 133 of file Program.cc.

                                                      :
    start_(start), entry_(entry), umach_(NULL), finalized_(false),
    instructionPerAddress_(true) {
    globalScope_ = new GlobalScope();
    refManager_ = new InstructionReferenceManager();
}

References globalScope_, and refManager_.

◆ ~Program()

TTAProgram::Program::~Program ( )

virtual

The destructor.

Definition at line 144 of file Program.cc.

                  {
    cleanup();
    delete globalScope_;
    globalScope_ = NULL;
    delete refManager_;
    refManager_ = NULL;
    // NOTE: we cannot delete universal machine anymore because after linking
    // the Program to another Program, the new Program refers to the,
    // TODO: make UniversalMachine a singleton and start hiding it from APIs.
    // delete umach_;
    // umach_ = NULL;
}

References cleanup(), globalScope_, and refManager_.

Here is the call graph for this function:

◆ Program() [4/4]

TTAProgram::Program::Program ( const Program & )

private

Copying not allowed.

Member Function Documentation

◆ addDataMemory()

void TTAProgram::Program::addDataMemory ( DataMemory * dataMem )

Insert the given data memory to the program.

Parameters

dataMem The data memory to be inserted.

Exceptions

IllegalRegistration Memory with the same address space is found from the program.

Definition at line 954 of file Program.cc.

                                          {
    // TODO: check that there is no another data mem with same address space...
    dataMems_.push_back(dataMem);
}

References dataMems_.

Referenced by copyDataMemoriesFrom(), TTAProgram::TPEFProgramFactory::createDataMemories(), and llvm::LLVMTCEBuilder::doFinalization().

◆ addInstruction()

void TTAProgram::Program::addInstruction ( Instruction * ins )

Insert the given instruction as the instruction of the last procedure of the program.

The ownership of the instruction will be passed to the procedure in which the instruction is inserted.

Parameters

ins	The instruction to be inserted.

Exceptions

IllegalRegistration if the instruction belongs to a procedure or there are no procedures in the program.

Definition at line 554 of file Program.cc.

                                        {
    if (procedures_.empty()) {
        throw IllegalRegistration(
            __FILE__, __LINE__, __func__,
            "No procedures in the program.");
    }
    
    // add all moves of an instruction to the move list
    for (int i = 0; i < ins->moveCount(); ++i) {
        moves_.push_back(&ins->move(i));
    }
 
    if (!ins->isInProcedure()) {
        procedures_.back()->add(ins);
    } else {
        throw IllegalRegistration(
            __FILE__, __LINE__, __func__,
            "Instruction already belongs to a procedure.");
    }
}

References __func__, TTAProgram::Instruction::isInProcedure(), TTAProgram::Instruction::move(), TTAProgram::Instruction::moveCount(), moves_, and procedures_.

Here is the call graph for this function:

◆ addProcedure()

void TTAProgram::Program::addProcedure ( Procedure * proc )

Insert the given procedure as the last procedure of the program.

The ownership of the procedure will be passed to the program. Labels must be added explicitely by client because only it knows the scope where to add the labels.

Parameters

proc	The procedure to be inserted.

Exceptions

IllegalRegistration if the procedure belongs to another program.

Definition at line 524 of file Program.cc.

                                     {
    if (proc->isInProgram()) {
        throw IllegalRegistration(
            __FILE__, __LINE__, __func__,
            "Procedure is already in program.");
    } else {
 
        proc->setParent(*this);
        if (!procedures_.empty()) {
            proc->setStartAddress(procedures_.back()->endAddress());
        } else {
            proc->setStartAddress(start_);
        }
 
        procedures_.push_back(proc);
    }
}

References __func__, TTAProgram::CodeSnippet::isInProgram(), procedures_, TTAProgram::CodeSnippet::setParent(), TTAProgram::CodeSnippet::setStartAddress(), and start_.

Referenced by copyFrom(), ProgramDependenceGraph::disassemble(), link(), ProgrammabilityValidator::ProgrammabilityValidator(), llvm::LLVMTCEBuilder::writeMachineFunction(), and llvm::LLVMTCEIRBuilder::writeMachineFunction().

Here is the call graph for this function:

◆ cleanup()

void TTAProgram::Program::cleanup ( )

private

Cleans up the program to a state it was at the construction.

Definition at line 161 of file Program.cc.

                 {
 
    SequenceTools::deleteAllItems(procedures_);
    SequenceTools::deleteAllItems(dataMems_);
 
    delete globalScope_;
    globalScope_ = NULL;
    delete refManager_;
    refManager_ = NULL;
    globalScope_ = new GlobalScope();
    refManager_ = new InstructionReferenceManager();
}

References dataMems_, SequenceTools::deleteAllItems(), globalScope_, procedures_, and refManager_.

Referenced by copyFrom(), and ~Program().

Here is the call graph for this function:

◆ convertSymbolRef()

TerminalImmediate * TTAProgram::Program::convertSymbolRef ( Terminal & tsr )

private

Converts single TerminalSymbolReference into InstructionReference to the symbol or TerminalImmediate into the data label.

@TODO: Use CodeLabels instead of procedure?

Definition at line 1226 of file Program.cc.

                                       {
    TCEString procName = tsr.toString();
    if (!hasProcedure(procName)) {
        if (procName == "_end") {
            for (int i = 0; i < globalScope_->globalDataLabelCount(); i++) {
                const DataLabel& dl = globalScope_->globalDataLabel(i);
                if (dl.name() == "_end") {
                    // we do not know if this is going to sing- or zero
                    // extending immediate, lets be sure it fits and use
                    // signed. zero extends broke sign-extending ADFs
                    return new TTAProgram::TerminalImmediate(
                        SimValue(
                            dl.address().location(),
                            MathTools::requiredBitsSigned(dl.address().location())));
                }
            }
            throw InstanceNotFound(__FILE__,__LINE__,__func__,
                                   "_end not found in program!");
        }
        throw InstanceNotFound(__FILE__,__LINE__,__func__,
                               TCEString("procedure '")
                               + procName + TCEString("' not found!"));
    }
    const Procedure& target = procedure(procName);
    assert(target.instructionCount() > 0);
    return new TTAProgram::TerminalInstructionReference(
        refManager_->createReference(
            target.firstInstruction()));
}

References __func__, TTAProgram::Label::address(), assert, TTAProgram::InstructionReferenceManager::createReference(), TTAProgram::CodeSnippet::firstInstruction(), TTAProgram::GlobalScope::globalDataLabel(), TTAProgram::GlobalScope::globalDataLabelCount(), globalScope_, hasProcedure(), TTAProgram::CodeSnippet::instructionCount(), TTAProgram::Address::location(), TTAProgram::Label::name(), procedure(), refManager_, MathTools::requiredBitsSigned(), and TTAProgram::Terminal::toString().

Referenced by convertSymbolRefsToInsRefs().

Here is the call graph for this function:

◆ convertSymbolRefsToInsRefs()

void TTAProgram::Program::convertSymbolRefsToInsRefs ( bool ignoreUnfoundSymbols = false )

Converts all TerminalSymbolReferences into InstructionReferences pointing to instructions or TerminalImmediates into data label.

Parameters

ignoreUnfoundSymbols if set to true, just skips symbol references for which the symbol is not found. Otherwise throws in that case.

Definition at line 1264 of file Program.cc.

                                                             {
    for (int i = 0; i < procedureCount();i++) {
        Procedure& proc = procedure(i);
        for (int j = 0; j < proc.instructionCount(); j++) {
            TTAProgram::Instruction& ins = proc.instructionAtIndex(j);
            for (int k = 0; k < ins.moveCount(); k++) {
                TTAProgram::Move& move = ins.move(k);
                TTAProgram::Terminal& src = move.source();
 
                if (src.isCodeSymbolReference()) {
 
                    TCEString procName = src.toString();
                    if (!hasProcedure(procName) && ignoreUnfoundSymbols)
                        continue;
 
                    move.setSource(convertSymbolRef(src));
                }
            }
            for (int k = 0; k < ins.immediateCount(); k++) {
                TTAProgram::Immediate& imm = ins.immediate(k);
                TTAProgram::Terminal& immVal = imm.value();
 
                if (immVal.isCodeSymbolReference()) {
 
                    TCEString procName = immVal.toString();
                    if (!hasProcedure(procName) && ignoreUnfoundSymbols)
                        continue;
 
                    imm.setValue(convertSymbolRef(immVal));
                }
            }
        }
    }
}

References convertSymbolRef(), hasProcedure(), TTAProgram::Instruction::immediate(), TTAProgram::Instruction::immediateCount(), TTAProgram::CodeSnippet::instructionAtIndex(), TTAProgram::CodeSnippet::instructionCount(), TTAProgram::Terminal::isCodeSymbolReference(), TTAProgram::Instruction::move(), TTAProgram::Instruction::moveCount(), procedure(), procedureCount(), TTAProgram::Move::setSource(), TTAProgram::Immediate::setValue(), TTAProgram::Move::source(), TTAProgram::Terminal::toString(), and TTAProgram::Immediate::value().

Referenced by llvm::LLVMTCEIRBuilder::doFinalization(), llvm::LLVMTCEPOMBuilder::doFinalization(), and link().

Here is the call graph for this function:

◆ copy()

Program * TTAProgram::Program::copy ( ) const

Creates an exact copy of the program.

References to external object models will remain untouched.

Returns: An exact copy of the program.

Definition at line 714 of file Program.cc.

                    {
 
    Program* newProgram = new Program(
        startAddress().space(), startAddress(), entryAddress());
 
    newProgram->copyFrom(*this);
    return newProgram;
}

References copyFrom(), entryAddress(), and startAddress().

Here is the call graph for this function:

◆ copyCodeLabelsFrom()

void TTAProgram::Program::copyCodeLabelsFrom ( const Program & srcProg )

private

◆ copyDataLabelsFrom()

void TTAProgram::Program::copyDataLabelsFrom ( const Program & srcProg )

private

◆ copyDataMemoriesFrom()

void TTAProgram::Program::copyDataMemoriesFrom ( const Program & srcProg )

private

Copy data memories from source program to destination and fixes data->code references to use InstructionReferenceManager of the instance.

Parameters

srcProg Program from which data is copied.

Definition at line 845 of file Program.cc.

                                                    {
 
    // copy data memories 
    for (int i = 0; i < srcProg.dataMemoryCount(); i++) {
        DataMemory& currMem = srcProg.dataMemory(i);
        
        DataMemory* newDataMem = new DataMemory(currMem.addressSpace());
        
        for (int j = 0; j < currMem.dataDefinitionCount(); j++) {
            DataDefinition& currDef = currMem.dataDefinition(j);
 
            DataDefinition* newDef = NULL;
            
            if (currDef.isInstructionAddress()) {
                Instruction& dstInstr = instructionAt(
                    currDef.destinationAddress().location());
                
                InstructionReference dstRef = 
                    instructionReferenceManager().createReference(
                        dstInstr);
                
                newDef = new DataInstructionAddressDef(
                    currDef.startAddress(), currDef.size(), dstRef,
                    targetProcessor().isLittleEndian());
 
            } else {
                newDef = currDef.copy();
            }
            
            newDataMem->addDataDefinition(newDef);
        }
 
        addDataMemory(newDataMem);
    }
}

Referenced by copyFrom(), and link().

Here is the call graph for this function:

◆ copyFrom()

void TTAProgram::Program::copyFrom ( const Program & source )

private

Copies data from another program to itself.

References to external object models will remain untouched. The old data is cleaned first. this->copyFrom(another) is equivalent to *this = another.

Returns: source The other program to copy from.

Definition at line 732 of file Program.cc.

                                       {
 
    // cleanup the old data first
    cleanup();
 
    for (int k = 0; k < source.procedureCount(); k++) {
        Procedure& proc = source.procedure(k);
        Procedure* newProc =
            new Procedure(
                proc.name(), proc.startAddress().space(),
                proc.startAddress().location());
        addProcedure(newProc);
            
        for (int j = 0; j < proc.instructionCount(); j++) {
            Instruction &ins = proc.instructionAtIndex(j);
 
            Instruction* newIns = ins.copy();
            newProc->add(newIns);
        }
    }            
 
    fixInstructionReferences();
    copyDataMemoriesFrom(source);
 
    // set addresses
    setStartAddress(source.startAddress());
    setEntryAddress(source.entryAddress());
 
    delete globalScope_;
    globalScope_ = dynamic_cast<GlobalScope*>(
        source.globalScopeConst().copyAndRelocate(*this));
 
}

References TTAProgram::Procedure::add(), addProcedure(), cleanup(), TTAProgram::Instruction::copy(), TTAProgram::GlobalScope::copyAndRelocate(), copyDataMemoriesFrom(), entryAddress(), fixInstructionReferences(), globalScope_, globalScopeConst(), TTAProgram::CodeSnippet::instructionAtIndex(), TTAProgram::CodeSnippet::instructionCount(), TTAProgram::Address::location(), TTAProgram::Procedure::name(), procedure(), procedureCount(), setEntryAddress(), setStartAddress(), TTAProgram::Address::space(), TTAProgram::CodeSnippet::startAddress(), and startAddress().

Referenced by copy(), and operator=().

Here is the call graph for this function:

◆ dataMemory() [1/2]

DataMemory & TTAProgram::Program::dataMemory ( const std::string & aSpaceName ) const

Returns the data memory with the given address space name.

Parameters

aSpaceName The address space name of the memory.

Returns: The data memory with given address space name.

Exceptions

KeyNotFound if the data memory cannot be found.

Definition at line 987 of file Program.cc.

                                                     {
    for (int i = 0; i < dataMemoryCount(); i++) {
        if (dataMemory(i).addressSpace().name() == aSpaceName) {
            return dataMemory(i);
        }
    }
    
    throw KeyNotFound(
        __FILE__, __LINE__, __func__,
        "No data memory found by address space name: " +
        aSpaceName);
}

References __func__, TTAProgram::DataMemory::addressSpace(), dataMemory(), dataMemoryCount(), and TTAMachine::Component::name().

Here is the call graph for this function:

◆ dataMemory() [2/2]

DataMemory & TTAProgram::Program::dataMemory ( int index ) const

Returns the data memory at the given index.

Parameters

index The position index.

Returns: The data memory at the given index.

Exceptions

OutOfRange the index is out of range.

Definition at line 967 of file Program.cc.

                                   {
    if (index >= 0 &&
        static_cast<unsigned int>(index) < dataMems_.size()) {
        return *dataMems_.at(index);
    } else {
        throw OutOfRange(
            __FILE__, __LINE__, __func__, 
            "There is no data memory with index: " + 
            Conversion::toString(index));
    }
}

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

Referenced by ControlFlowGraph::computeLeadersFromRelocations(), copyDataMemoriesFrom(), TTAProgram::ProgramWriter::createDataSections(), dataMemory(), llvm::LLVMTCEBuilder::deleteDeadProcedures(), POMDisassembler::disassembleProgram(), SimulatorFrontend::initializeDataMemories(), and replaceUniversalAddressSpaces().

Here is the call graph for this function:

◆ dataMemoryCount()

int TTAProgram::Program::dataMemoryCount ( ) const

Returns the number of data memories accessed by the program.

Returns: The number of data memories accessed by the program.

Definition at line 942 of file Program.cc.

                               {
    return dataMems_.size();
}

References dataMems_.

Referenced by ControlFlowGraph::computeLeadersFromRelocations(), copyDataMemoriesFrom(), TTAProgram::ProgramWriter::createDataSections(), dataMemory(), llvm::LLVMTCEBuilder::deleteDeadProcedures(), POMDisassembler::disassembleProgram(), SimulatorFrontend::initializeDataMemories(), and replaceUniversalAddressSpaces().

◆ entryAddress()

Address TTAProgram::Program::entryAddress ( ) const

Returns the address of the program entry point.

The entry point is not necessarily the instruction of the program with the lowest address.

Note: Preserving this value is not implemented in TPEFProgramFactory and ProgramWriter, however implementation of property is already specified in TPEF specs.

Returns: The address of the program entry point.

Definition at line 330 of file Program.cc.

                            {
    return entry_;
}

References entry_.

Referenced by copy(), copyFrom(), and CompiledSimController::reset().

◆ finalize()

void TTAProgram::Program::finalize ( )

This should be called if the program has been fully constructed and won't get new instructions added anymore.

Computes and updates the final Instruction addresses with the best available accuracy. Before this method is called, instruction per address indexing is used, which is fast but might not reflect the final instruction addresses. After this method has been called, the user of the Program can also assume all the Instructions are attached to a Procedure and Procedures to the Program.

Definition at line 1343 of file Program.cc.

                  {
 
    InstructionVector instructions = instructionVector();
 
    if (instructions.size() == 0) return;
 
    InstructionAddress previousAddress = startAddress().location();
 
    POMDisassembler* disasm =
        POMDisassembler::disassembler(targetProcessor(), *this);
 
    InstructionAddress currentSize =
        disasm->instructionSize(*instructions[0]);
 
    instructions[0]->setFinalAddress(previousAddress);
    instructions[0]->setSize(currentSize);
 
    bool newInstructionPerAddress = instructionPerAddress_;
    // From now on assume there's not an instruction per address layout.
    instructionPerAddress_ = false;
 
    if (currentSize != 1)
        newInstructionPerAddress = false;
 
    for (size_t i = 1; i < instructions.size(); ++i) {
        TTAProgram::Instruction* instr = instructions[i];
        currentSize = disasm->instructionSize(*instr);
        instr->setSize(currentSize);
        InstructionAddress newAddress = previousAddress + currentSize;
        instr->setFinalAddress(newAddress);
        previousAddress = newAddress;
        if (currentSize != 1)
            newInstructionPerAddress = false;
    }
 
    instructionPerAddress_ = newInstructionPerAddress;
 
    // Fix the procedure start and end addresses.
    ProcIter iter = procedures_.begin();
    while (iter != procedures_.end()) {
        Procedure& proc = **iter;
        proc.setStartAddress(proc.firstInstruction().address());
        // End address is the first address that doesn't store
        // instructions of the procedure.
        proc.setEndAddress(
            Address(proc.lastInstruction().address().location() +
                    proc.lastInstruction().size(),
                    proc.lastInstruction().address().space()));
        ++iter;
    }
 
    finalized_ = true;
    delete disasm;
}

References TTAProgram::Instruction::address(), POMDisassembler::disassembler(), finalized_, TTAProgram::CodeSnippet::firstInstruction(), instructionPerAddress_, POMDisassembler::instructionSize(), instructionVector(), TTAProgram::CodeSnippet::lastInstruction(), TTAProgram::Address::location(), procedures_, TTAProgram::CodeSnippet::setEndAddress(), TTAProgram::Instruction::setFinalAddress(), TTAProgram::Instruction::setSize(), TTAProgram::CodeSnippet::setStartAddress(), TTAProgram::Instruction::size(), TTAProgram::Address::space(), startAddress(), and targetProcessor().

Referenced by SimulatorFrontend::loadProgram().

Here is the call graph for this function:

◆ firstInstruction()

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

Returns the first instruction of the program.

Returns: The first instruction of the program.

Exceptions

InstanceNotFound There is no instructions in program.

Definition at line 353 of file Program.cc.

                                {
    if (!procedures_.empty()) {
        return firstProcedure().firstInstruction();
    } else {
        throw InstanceNotFound(
            __FILE__, __LINE__, __func__,
            "There is no instructions in the program.");
    }
}

References __func__, TTAProgram::CodeSnippet::firstInstruction(), firstProcedure(), and procedures_.

Referenced by InstructionDictionary::addInstructions(), MoveSlotDictionary::addInstructions(), DEFAULT_Compressor::compress(), llvm::LLVMTCEBuilder::emitSPInitialization(), DisassemblyGridTable::GetNumberRows(), and CodeCompressorPlugin::initializeRelocations().

Here is the call graph for this function:

◆ firstProcedure()

Procedure & TTAProgram::Program::firstProcedure ( ) const

Returns the first procedure of the program.

Returns: The first procedure of the prgram.

Exceptions

InstanceNotFound if there are no procedures.

Definition at line 213 of file Program.cc.

                              {
    if (procedureCount() > 0) {
        return *procedures_.at(0);
    } else {
        throw InstanceNotFound(
            __FILE__, __LINE__, __func__,
            "There are no procedures in the program.");
    }
}

References __func__, procedureCount(), and procedures_.

Referenced by firstInstruction(), SimControlLanguageCommand::parseInstructionAddressExpression(), and setStartAddress().

Here is the call graph for this function:

◆ fixInstructionReferences()

void TTAProgram::Program::fixInstructionReferences ( )

Fix instruction references to point to the corresponding instructions of this Program.

This should be called after copying procedures from other programs to transform the instruction references to point to the current program instead of the old one.

Definition at line 775 of file Program.cc.

                                  {
    for (int k = 0; k < procedureCount(); k++) {
        Procedure& proc = procedure(k);
        for (int j = 0; j < proc.instructionCount(); j++) {
            Instruction& ins = proc.instructionAtIndex(j);
 
            // sources of all moves.
            for (int i = 0; i < ins.moveCount(); i++) {
                Terminal& source = ins.move(i).source();
                
                if (source.isInstructionAddress()) {
                    Instruction& oldRefIns =
                        source.instructionReference().instruction();
                    
                    // Fix the reference via 
                    // a procedure offset to not break references
                    // inside Procedures copied from another Program 
                    InstructionAddress procStartAddr = 
                        procedure(dynamic_cast<Procedure&>(oldRefIns.parent()).name()).
                        startAddress().location();
                    
                    Instruction& newRefIns =
                        instructionAt(
                            procStartAddr + 
                            oldRefIns.address().location() -
                            oldRefIns.parent().startAddress().location());
 
                    InstructionReference newRef =
                        instructionReferenceManager().createReference(
                            newRefIns);
                    source.setInstructionReference(newRef);
                }
            }
            // values of all immediates
            for (int i = 0; i < ins.immediateCount(); i++) {
                Terminal& value = ins.immediate(i).value();
                if (value.isInstructionAddress()) {
 
                    Instruction& oldRefIns =
                        value.instructionReference().instruction();
 
 
                    InstructionAddress procStartAddr = 
                        procedure(dynamic_cast<Procedure&>(oldRefIns.parent()).name()).
                        startAddress().location();
 
                    Instruction& newRefIns =
                        instructionAt(
                            procStartAddr +
                            oldRefIns.address().location() -
                            oldRefIns.parent().startAddress().location());
                    
                    InstructionReference newRef =
                        instructionReferenceManager().createReference(
                            newRefIns);
                    value.setInstructionReference(newRef);
                }
            }
        }
    }
}

References TTAProgram::Instruction::address(), TTAProgram::InstructionReferenceManager::createReference(), TTAProgram::Instruction::immediate(), TTAProgram::Instruction::immediateCount(), TTAProgram::InstructionReference::instruction(), instructionAt(), TTAProgram::CodeSnippet::instructionAtIndex(), TTAProgram::CodeSnippet::instructionCount(), TTAProgram::Terminal::instructionReference(), instructionReferenceManager(), TTAProgram::Terminal::isInstructionAddress(), TTAProgram::Address::location(), TTAProgram::Instruction::move(), TTAProgram::Instruction::moveCount(), TTAProgram::Procedure::name(), TTAProgram::Instruction::parent(), procedure(), procedureCount(), TTAProgram::Terminal::setInstructionReference(), TTAProgram::Move::source(), TTAProgram::CodeSnippet::startAddress(), startAddress(), and TTAProgram::Immediate::value().

Referenced by copyFrom(), and link().

Here is the call graph for this function:

◆ globalScope()

GlobalScope & TTAProgram::Program::globalScope ( )

Returns the global scope of the program.

Returns: The global scope of the program.

Definition at line 180 of file Program.cc.

                     {
    return *globalScope_;
}

References globalScope_.

Referenced by TTAProgram::CodeLabel::CodeLabel(), TTAProgram::CodeLabel::CodeLabel(), TTAProgram::TPEFProgramFactory::createLabels(), llvm::LLVMTCEBuilder::doFinalization(), llvm::LLVMTCEBuilder::initDataSections(), TTAProgram::Procedure::remove(), and llvm::LLVMTCEBuilder::writeMachineFunction().

◆ globalScopeConst()

const GlobalScope & TTAProgram::Program::globalScopeConst ( ) const

Returns the global scope of the program.

Const version.

Returns: The global scope of the program.

Definition at line 192 of file Program.cc.

                                {
    return *globalScope_;
}

References globalScope_.

Referenced by copyFrom(), TTAProgram::ProgramWriter::createBinary(), SymbolAddressCommand::execute(), DisassemblyGridTable::loadProgram(), SimControlLanguageCommand::parseDataAddressExpression(), and SimControlLanguageCommand::parseInstructionAddressExpression().

◆ hasProcedure()

bool TTAProgram::Program::hasProcedure ( const std::string & name ) const

Returns true in case the program has a procedure with the given name.

Definition at line 673 of file Program.cc.

                                                 {
    ProcList::const_iterator i = procedures_.begin();
    while (i != procedures_.end()) {
        if ((*i)->name() == name) {
            return true;
        }
        ++i;
    }
    return false;
}

References procedures_.

Referenced by convertSymbolRef(), convertSymbolRefsToInsRefs(), and ControlFlowGraph::createBBEdges().

◆ instructionAt()

Instruction & TTAProgram::Program::instructionAt ( InstructionAddress address ) const

Returns the instruction at a given address.

The address space of the address is implied, since there is only one address space for instructions.

Parameters

address The address of the instruction.

Exceptions

KeyNotFound if given address is illegal.

Returns: The instruction at the given address.

Definition at line 374 of file Program.cc.

                                                       {
    for (ProcIter iter = procedures_.begin(); iter != procedures_.end();
        iter++) {
 
        if ((*iter)->startAddress().location() <= address &&
            (*iter)->endAddress().location() > address) {
            return (*iter)->instructionAt(address);
        }
    }
 
    throw KeyNotFound(
        __FILE__, __LINE__, __func__, 
        "No instruction at address: " +
        Conversion::toString(address));
}

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

Referenced by ProximMachineStateWindow::addMoves(), SimulationStatistics::calculate(), SimulatorFrontend::compareState(), copyDataMemoriesFrom(), POMDisassembler::createInstruction(), SimulatorFrontend::currentProcedure(), SimulatorFrontend::disassembleInstruction(), CodeCompressorPlugin::encodeImmediateTerminal(), CodeCompressorPlugin::encodeLongImmediate(), BackTraceCommand::execute(), DisassembleCommand::execute(), fixInstructionReferences(), CompiledSimCodeGenerator::generateAddFUResult(), ProcedureTransferTracker::handleEvent(), RFAccessTracker::handleEvent(), SimulationController::next(), SimulatorFrontend::programLocationDescription(), ProximDebuggerWindow::updateAnnotations(), BasicBlockNode::updateReferencesFromProcToCfg(), and ProgramImageGenerator::writeDataSection().

Here is the call graph for this function:

◆ instructionCount()

int TTAProgram::Program::instructionCount ( ) const

Definition at line 1209 of file Program.cc.

                                { 
    if (procedureCount() == 0) {
        return 0;
    }
    return lastProcedure().startAddress().location() + 
        lastProcedure().instructionCount() -
        start_.location();
}

References TTAProgram::CodeSnippet::instructionCount(), lastProcedure(), TTAProgram::Address::location(), procedureCount(), start_, and TTAProgram::CodeSnippet::startAddress().

Referenced by TTAProgram::ProgramWriter::createBinary(), and ProgramImageGenerator::generateProgramImage().

Here is the call graph for this function:

◆ instructionReferenceManager()

InstructionReferenceManager & TTAProgram::Program::instructionReferenceManager ( ) const

Return the instruction reference manager.

Definition at line 688 of file Program.cc.

                                           {
    return *refManager_;
}

References refManager_.

Referenced by TTAProgram::TPEFProgramFactory::build(), llvm::LLVMTCEIRBuilder::buildTCECFG(), ControlFlowGraph::computeLeadersFromRefManager(), SequentialScheduler::copyBasicBlocksToProcedure(), ProcedurePass::copyCfgToProcedure(), copyDataMemoriesFrom(), ControlFlowGraph::copyToLLVMMachineFunction(), ControlFlowGraph::copyToProcedure(), SequentialScheduler::createBasicBlocks(), TTAProgram::TPEFProgramFactory::createDataMemories(), llvm::LLVMTCEBuilder::createGlobalValueDataDefinition(), ProgramDependenceGraph::createJump(), TTAProgram::TPEFProgramFactory::createLabels(), llvm::LLVMTCEBuilder::doFinalization(), llvm::LLVMTCEBuilder::emitSetjmp(), llvm::LLVMTCEBuilder::emitSPInitialization(), fixInstructionReferences(), SequentialScheduler::handleProcedure(), SimpleIfConverter::handleProcedure(), AbsoluteToRelativeJumps::handleProcedure(), TTAProgram::CodeLabel::instructionReference(), ControlFlowGraph::instructionReferenceManager(), TTAProgram::Procedure::remove(), CopyingDelaySlotFiller::updateFTBBAndCfg(), ControlFlowGraph::updateReferencesFromProcToCfg(), BasicBlockNode::updateReferencesFromProcToCfg(), and llvm::LLVMTCEIRBuilder::writeMachineFunction().

◆ instructionVector()

Program::InstructionVector TTAProgram::Program::instructionVector ( ) const

Returns all Instructions in the program as random accessible vector.

The returned vector can be used for faster traversal of the program's instruction. It should be used instead of nextInstruction() or similar very slow methods when traversing through the whole program. Note that the Instruction* inside the vector should not be destroyed by the client as they are owned by the Program. The InstructionVector is not updated automatically as the Program changes!

Definition at line 1196 of file Program.cc.

                                 {
    InstructionVector instructions;
    for (std::size_t p = 0; p < procedures_.size(); ++p) {
        Procedure& proc = *procedures_.at(p);
        for (int i = 0; i < proc.instructionCount(); ++i) {
            Instruction* instr = &proc.instructionAtIndex(i);
            instructions.push_back(instr);
        }
    }
    return instructions;
}

References TTAProgram::CodeSnippet::instructionAtIndex(), TTAProgram::CodeSnippet::instructionCount(), and procedures_.

Referenced by TTAProgram::TPEFProgramFactory::build(), finalize(), and ProgramImageGenerator::generateProgramImage().

Here is the call graph for this function:

◆ isFinalized()

bool TTAProgram::Program::isFinalized ( ) const

inline

Definition at line 149 of file Program.hh.

149{ return finalized_; }

References finalized_.

◆ isInstructionPerAddress()

bool TTAProgram::Program::isInstructionPerAddress ( ) const

inline

Definition at line 151 of file Program.hh.

151{ return instructionPerAddress_; }

References instructionPerAddress_.

◆ lastInstruction()

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

Returns the last instruction of the program.

Returns: The last instruction of the program.

Exceptions

InstanceNotFound There is no instructions in the program.

Definition at line 463 of file Program.cc.

                               {
    if (!procedures_.empty()) {
        return lastProcedure().lastInstruction();
    } else {
        throw InstanceNotFound(
            __FILE__, __LINE__, __func__,
            "There is no instructions in the program.");
    }
}

References __func__, TTAProgram::CodeSnippet::lastInstruction(), lastProcedure(), and procedures_.

Referenced by SimulatorFrontend::currentProcedure(), SimulatorFrontend::finishSimulation(), CompiledSimCodeGenerator::generateInstruction(), DisassemblyGridTable::GetNumberRows(), and CompiledSimController::reset().

Here is the call graph for this function:

◆ lastProcedure()

Procedure & TTAProgram::Program::lastProcedure ( ) const

Returns the last procedure of the program.

Returns: The last procedure of the prgram.

Exceptions

InstanceNotFound if there are no procedures.

Definition at line 230 of file Program.cc.

                             {
    if (procedureCount() > 0) {
        return *procedures_.at(procedureCount() - 1);
    } else {
        throw InstanceNotFound(
            __FILE__, __LINE__, __func__,
            "There are no procedures in the program.");
    }
}

References __func__, procedureCount(), and procedures_.

Referenced by TTAProgram::Procedure::add(), TTAProgram::Procedure::clear(), SequentialScheduler::copyBasicBlocksToProcedure(), ProcedurePass::copyCfgToProcedure(), ControlFlowGraph::copyToProcedure(), SimulatorFrontend::currentProcedure(), DisassembleCommand::execute(), TTAProgram::Procedure::insertAfter(), TTAProgram::Procedure::insertBefore(), instructionCount(), lastInstruction(), nextProcedure(), SimControlLanguageCommand::parseInstructionAddressExpression(), SimulatorFrontend::programLocationDescription(), TTAProgram::Procedure::remove(), and removeProcedure().

Here is the call graph for this function:

◆ link()

void TTAProgram::Program::link ( const TTAProgram::Program & other )

Links the given Program with this one.

"Linking" here means copying all the procedures to this Program and fixing all fixable (external) symbol references. That is, in case either this or the other Program contained calls to external functions that are now found, the references are fixed to point to the actual Procedures.

Definition at line 1309 of file Program.cc.

                                            {
 
    if (other.procedureCount() == 0) return;
 
    for (int i = 0; i < other.procedureCount(); ++i) {
        addProcedure(dynamic_cast<Procedure*>(other.procedure(i).copy()));
    }
    copyDataMemoriesFrom(other);
    convertSymbolRefsToInsRefs(true);
    fixInstructionReferences();
 
    // todo merge GlobalScope (to retain labels)
}

References addProcedure(), convertSymbolRefsToInsRefs(), TTAProgram::Procedure::copy(), copyDataMemoriesFrom(), fixInstructionReferences(), procedure(), and procedureCount().

Here is the call graph for this function:

◆ loadFromTPEF()

Program * TTAProgram::Program::loadFromTPEF	(	const std::string &	tpefFileName,
		const TTAMachine::Machine &	theMachine
	)

static

A shortcut for loading a scheduled program from a TPEF file.

Parameters

tpefFileName	The file name of the TPEF.
theMachine	The target machine.

Returns: Created program.

Exceptions

Exception if the TPEF or program in it is somehow broken.

Definition at line 1112 of file Program.cc.

                                                                        {
    TPEF::BinaryStream binaryStream(tpefFileName);
 
    // read to TPEF Handler Module
    TPEF::Binary* tpef = TPEF::BinaryReader::readBinary(binaryStream);
 
    if (tpef == NULL) {
        throw IOException(
            __FILE__, __LINE__, __func__, "Loading TPEF failed.");
    }
 
    // convert the loaded TPEF to POM
    TTAProgram::TPEFProgramFactory factory(*tpef, theMachine);
    Program* prog = factory.build();
    delete tpef;
    tpef = NULL;
    return prog;
}

References __func__, TTAProgram::TPEFProgramFactory::build(), and TPEF::BinaryReader::readBinary().

Referenced by SimpleICOptimizer::explore(), main(), and DesignSpaceExplorer::schedule().

Here is the call graph for this function:

◆ loadFromUnscheduledTPEF() [1/2]

Program * TTAProgram::Program::loadFromUnscheduledTPEF ( const std::string & tpefFileName )

static

A shortcut for loading a sequential program (from the old gcc 2.7.0 frontend) from a TPEF file.

Parameters

tpefFileName	The file name of the TPEF.
umach	The universal machine for the unscheduled parts.

Returns: Created program.

Exceptions

Exception if the TPEF or program in it is somehow broken.

Definition at line 1142 of file Program.cc.

                                                              {
    TPEF::BinaryStream binaryStream(tpefFileName);
 
    // read to TPEF Handler Module
    TPEF::Binary* tpef = TPEF::BinaryReader::readBinary(binaryStream);
 
    if (tpef == NULL) {
        throw IOException(
            __FILE__, __LINE__, __func__, "Loading TPEF failed.");
    }
 
    // convert the loaded TPEF to POM
    TTAProgram::TPEFProgramFactory factory(*tpef, UniversalMachine::instance());
    Program* prog = factory.build();
    delete tpef;
    tpef = NULL;
    return prog;
}

References __func__, TTAProgram::TPEFProgramFactory::build(), UniversalMachine::instance(), and TPEF::BinaryReader::readBinary().

Here is the call graph for this function:

◆ loadFromUnscheduledTPEF() [2/2]

Program * TTAProgram::Program::loadFromUnscheduledTPEF	(	const std::string &	tpefFileName,
		const TTAMachine::Machine &	theMachine
	)

static

A shortcut for loading a partially scheduled program from a TPEF file.

Parameters

tpefFileName	The file name of the TPEF.
theMachine	The target machine.

Returns: Created program.

Exceptions

Exception if the TPEF or program in it is somehow broken.

Definition at line 1083 of file Program.cc.

                                                                        {
    TPEF::BinaryStream binaryStream(tpefFileName);
 
    // read to TPEF Handler Module
    TPEF::Binary* tpef = TPEF::BinaryReader::readBinary(binaryStream);
 
    if (tpef == NULL) {
        throw IOException(
            __FILE__, __LINE__, __func__, "Loading TPEF failed.");
    }
 
    // convert the loaded TPEF to POM
    TTAProgram::TPEFProgramFactory factory(*tpef, theMachine);
    Program* prog = factory.build();
    delete tpef;
    tpef = NULL;
    return prog;
}

References __func__, TTAProgram::TPEFProgramFactory::build(), and TPEF::BinaryReader::readBinary().

Here is the call graph for this function:

◆ moveAt()

const TTAProgram::Move & TTAProgram::Program::moveAt ( int number ) const

Returns a move at given location, counting from beginning, zero

Parameters

number zero-beginning count of move's location

Returns: a reference to the found move

Exceptions

KeyNotFound if the move wasn't found at the given location

Definition at line 480 of file Program.cc.

                                {
    if (number < 0 || number >= static_cast<int>(moves_.size())) {
        throw KeyNotFound(__FILE__, __LINE__, __FUNCTION__,
            "Move not found at location: " + Conversion::toString(number));
    }
    return *moves_.at(number);
}

References moves_, and Conversion::toString().

Referenced by ProgramImageGenerator::generateProgramImage().

Here is the call graph for this function:

◆ moveCount()

int TTAProgram::Program::moveCount ( ) const

Returns the total count of moves used in the program

Returns: the total count of moves used in the program

Definition at line 494 of file Program.cc.

                         {
    return static_cast<int>(moves_.size());
}

References moves_.

Referenced by CompiledSimulation::CompiledSimulation(), and ProgramImageGenerator::generateProgramImage().

◆ moveProcedure()

void TTAProgram::Program::moveProcedure	(	Procedure &	proc,
		int	howMuch
	)

Moves the given procedure and its succeeding procedures the given count of instructions.

Note: If the given count is negative, does not perform any checking for overlapping procedures, thus the relocated procedure might end up sharing instruction indices with the preceeding procedure, which means a corrupted program.

Parameters

proc	The procedure to move.
howMuch	How many instructions the procedure should be moved.

Definition at line 588 of file Program.cc.

                                                   {
    unsigned int index;
    // skip procedures before given procedure
    for (index = 0; index < procedures_.size(); index++) {
        if (procedures_[index] == &proc) {
            break; 
        }
    } 
    // only update procedures after.
    for (;index < procedures_.size(); index++) {
        Procedure* p2 = procedures_[index];
        UIntWord oldAddr = p2->startAddress().location();
        p2->setStartAddress(Address(oldAddr + howMuch, start_.space()));
    }
}

References TTAProgram::Address::location(), procedures_, TTAProgram::CodeSnippet::setStartAddress(), TTAProgram::Address::space(), start_, and TTAProgram::CodeSnippet::startAddress().

Referenced by TTAProgram::Procedure::add(), TTAProgram::Procedure::clear(), SequentialScheduler::copyBasicBlocksToProcedure(), ProcedurePass::copyCfgToProcedure(), ControlFlowGraph::copyToProcedure(), TTAProgram::Procedure::insertAfter(), TTAProgram::Procedure::insertBefore(), TTAProgram::Procedure::remove(), removeProcedure(), and setStartAddress().

Here is the call graph for this function:

◆ nextInstruction()

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

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 program.

Exceptions

IllegalRegistration If given instruction does not belong to the program.

Note: This method is very slow, do not use it for traversing the whole program!

Definition at line 403 of file Program.cc.

                                                     {
    if (!ins.isInProcedure() || !ins.parent().isInProgram() ||
        &ins.parent().parent() != this) {
 
        throw IllegalRegistration(
            __FILE__, __LINE__, __func__,
            "Instruction in parameter doesn't belong to this program.");
    }
 
    unsigned int insAddress = ins.address().location();
 
    // Check first the basic case of having the next instruction in the same
    // procedure. Find the instruction and return its next iterator.
    Instruction* nextInstr = &ins.parent().nextInstruction(ins);
    if (nextInstr != &NullInstruction::instance())
        return *nextInstr;
 
    ProcIter iter = procedures_.begin();
    while (iter != procedures_.end()) {
 
        // if the current instruction address fits procedure's
        // address space
        if ((*iter)->startAddress().location() <= insAddress &&
            (*iter)->endAddress().location() > insAddress) {
 
            // return next instruction, if it's in the same procedure
            if ((*iter)->hasNextInstruction(ins)) {
                return (*iter)->nextInstruction(ins);
 
                // otherwise find the next non-empty procedure and return
                // its first instruction
            } else {
                iter++;
                while (iter != procedures_.end()) {
                    if ((*iter)->instructionCount() != 0) {
                        return (*iter)->instructionAt(
                            (*iter)->startAddress().location());
                    }
                    iter++;
                }
 
                // if no non-empty procedures found, return null instruction
                return NullInstruction::instance();
            }
        }
        iter++;
    }
 
    // no procedure where current instruction fits was found
    // (should throw exception?)
    return NullInstruction::instance();
}

References __func__, TTAProgram::Instruction::address(), TTAProgram::NullInstruction::instance(), TTAProgram::Instruction::isInProcedure(), TTAProgram::CodeSnippet::isInProgram(), TTAProgram::Address::location(), TTAProgram::CodeSnippet::nextInstruction(), TTAProgram::CodeSnippet::parent(), TTAProgram::Instruction::parent(), and procedures_.

Referenced by InstructionDictionary::addInstructions(), MoveSlotDictionary::addInstructions(), SimulationStatistics::calculate(), DEFAULT_Compressor::compress(), and CodeCompressorPlugin::initializeRelocations().

Here is the call graph for this function:

◆ nextProcedure()

Procedure & TTAProgram::Program::nextProcedure ( const Procedure & proc ) const

Returns the procedure following the given procedure.

Returns: The procedure following the given procedure or a null procedure, if the given procedure is the last procedure in the program.

Parameters

proc	The following procedure of this parameter is returned.

Exceptions

IllegalRegistration if the given procedure does not belong to this program.

Definition at line 250 of file Program.cc.

                                                  {
    if (!proc.isInProgram() || &proc.parent() != this) {
        throw IllegalRegistration(
            __FILE__, __LINE__, __func__,
            "The procedure given in parameter doesn't "
            "belong to this program.");
    }
 
    if (&proc != &lastProcedure()) {
        int i = 0;
        for (; i < procedureCount(); i++) {
            if (procedures_.at(i) == &proc) {
                break;
            }
        }
        assert(i < procedureCount() - 1);
        return *procedures_.at(i + 1);
 
    } else {
        return NullProcedure::instance();
    }
}

References __func__, assert, TTAProgram::NullProcedure::instance(), TTAProgram::CodeSnippet::isInProgram(), lastProcedure(), TTAProgram::CodeSnippet::parent(), procedureCount(), and procedures_.

Referenced by TTAProgram::Procedure::add(), TTAProgram::Procedure::clear(), SequentialScheduler::copyBasicBlocksToProcedure(), ProcedurePass::copyCfgToProcedure(), ControlFlowGraph::copyToProcedure(), TTAProgram::Procedure::insertAfter(), TTAProgram::Procedure::insertBefore(), TTAProgram::Procedure::remove(), and removeProcedure().

Here is the call graph for this function:

◆ operator=()

Program & TTAProgram::Program::operator= ( const Program & newProgram )

Assignment operator.

Replaces the contents of this program with the given program.

Parameters

newProgram The Program instance to be assigned

Returns: The assigned Program instance.

Definition at line 701 of file Program.cc.

                                            {
    copyFrom(newProgram);
    return *this;
}

References copyFrom().

Here is the call graph for this function:

◆ operator[]()

Procedure & TTAProgram::Program::operator[] ( size_t index )

Returns the procedure at the given index.

Parameters

index The position index.

Returns: The procedure at the given index.

Exceptions

OutOfRange if the index is out of range.

Definition at line 642 of file Program.cc.

                                {
    return *procedures_[index];
}

References procedures_.

◆ procedure() [1/2]

Procedure & TTAProgram::Program::procedure ( const std::string & name ) const

Returns the procedure with the given name.

Parameters

name	The procedure name.

Returns: The procedure with given name.

Exceptions

KeyNotFound if the procedure cannot be found.

Definition at line 654 of file Program.cc.

                                              {
    ProcList::const_iterator i = procedures_.begin();
    while (i != procedures_.end()) {
        if ((*i)->name() == name) {
            return *(*i);
        }
        ++i;
    }
 
    throw KeyNotFound(
        __FILE__, __LINE__, __func__,
        "No procedure found with name: " +
        name);
}

References __func__, and procedures_.

◆ procedure() [2/2]

Procedure & TTAProgram::Program::procedure ( int index ) const

Returns the procedure at the given index.

Parameters

index The position index.

Returns: The procedure at the given index.

Exceptions

OutOfRange if the index is out of range.

Definition at line 622 of file Program.cc.

                                  {
    if (index >= 0 &&
        static_cast<unsigned int>(index) < procedures_.size()) {
        return *procedures_.at(index);
    } else {
        throw OutOfRange(
            __FILE__, __LINE__, __func__,
            "There is no procedure by index: " + 
            Conversion::toString(index));
    }
}

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

Referenced by SimpleICOptimizer::addConnections(), convertSymbolRef(), convertSymbolRefsToInsRefs(), copyFrom(), ControlFlowGraph::createBBEdges(), TTAProgram::ProgramWriter::createBinary(), TTAProgram::ProgramWriter::createCodeSection(), llvm::LLVMTCEBuilder::deleteDeadProcedures(), llvm::LLVMTCEIRBuilder::doFinalization(), CompiledSimCodeGenerator::findBasicBlocks(), SimulatorFrontend::finishSimulation(), fixInstructionReferences(), CompiledSimCodeGenerator::generateSimulationCode(), POMDisassembler::instructionCount(), link(), SimControlLanguageCommand::parseInstructionAddressExpression(), and replaceUniversalAddressSpaces().

Here is the call graph for this function:

◆ procedureAtIndex()

const Procedure & TTAProgram::Program::procedureAtIndex ( int index ) const

Returns the procedure at a given index in the container of procedures.

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

Parameters

index The procedure index in the list of procedures.

Returns: The Procedure at the given index.

Definition at line 508 of file Program.cc.

                                         {
    return *procedures_.at(index);
}

References procedures_.

Referenced by SimProgramBuilder::build(), InlineAsmParser::copyInstructions(), and POMDisassembler::disassembleProcedures().

◆ procedureCount()

int TTAProgram::Program::procedureCount ( ) const

Returns the number of procedures in the program.

Returns: The number of procedures in the program.

Definition at line 610 of file Program.cc.

                              {
    return procedures_.size();
}

References procedures_.

Referenced by SimpleICOptimizer::addConnections(), SimProgramBuilder::build(), llvm::LLVMTCEIRBuilder::buildTCECFG(), convertSymbolRefsToInsRefs(), copyFrom(), InlineAsmParser::copyInstructions(), TTAProgram::ProgramWriter::createBinary(), TTAProgram::ProgramWriter::createCodeSection(), POMDisassembler::disassembleProcedures(), llvm::LLVMTCEIRBuilder::doFinalization(), CompiledSimCodeGenerator::findBasicBlocks(), SimulatorFrontend::finishSimulation(), firstProcedure(), fixInstructionReferences(), CompiledSimCodeGenerator::generateSimulationCode(), POMDisassembler::instructionCount(), instructionCount(), lastProcedure(), link(), nextProcedure(), replaceUniversalAddressSpaces(), and setStartAddress().

◆ removeProcedure()

void TTAProgram::Program::removeProcedure ( Procedure & proc )

Remove procedure from the program.

The procedure becomes independent (it is not deleted). All instructions following the removed procedure are relocated appropriately. All code labels attached to the removed procedure are deleted from the Program.

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

Todo:: Copy the deleted CodeLabels to the removed procedure's own Scope objects.

Parameters

proc	Procedure to remove.

Exceptions

IllegalRegistration If procedure does not belong to the program.

Definition at line 901 of file Program.cc.

                                        {
    if (&proc.parent() != this) {
        throw IllegalRegistration(
            __FILE__, __LINE__, __func__, 
            "Procedure doesn't belong to this program.");
    }
 
    const InstructionAddress firstAddress = proc.startAddress().location();
    const InstructionAddress lastAddress = proc.endAddress().location() - 1;
 
    for (InstructionAddress addr = firstAddress;
         addr <= lastAddress;
         ++addr) {
 
        globalScope_->removeCodeLabels(addr);
    }
 
    if (&proc != &lastProcedure()) {
        moveProcedure(
            nextProcedure(proc),
            proc.startAddress().location() - proc.endAddress().location());
    }
 
    for (ProcList::iterator iter = procedures_.begin();
         iter != procedures_.end(); iter++) {
 
        if ((*iter) == &proc) {
            procedures_.erase(iter);
            break;
        }
    }
 
    proc.setParent(NullProgram::instance());
}

References __func__, TTAProgram::CodeSnippet::endAddress(), globalScope_, TTAProgram::NullProgram::instance(), lastProcedure(), TTAProgram::Address::location(), moveProcedure(), nextProcedure(), TTAProgram::CodeSnippet::parent(), procedures_, TTAProgram::GlobalScope::removeCodeLabels(), TTAProgram::CodeSnippet::setParent(), and TTAProgram::CodeSnippet::startAddress().

Referenced by llvm::LLVMTCEBuilder::deleteDeadProcedures(), and ProgramDependenceGraph::disassemble().

Here is the call graph for this function:

◆ replaceUniversalAddressSpaces()

void TTAProgram::Program::replaceUniversalAddressSpaces ( const TTAMachine::AddressSpace & space )

Replace instruction and data address space of a sequential program with real ones of the target machine.

Only the data address space of the target machine that corresponds to the universal data address space is required. Target machine and instruction address space are replaced implicitly.

Parameters

space New data address space.

Note: Use only to convert a sequential program to use a real machine!

Definition at line 1012 of file Program.cc.

                                                                          {
 
    if (dynamic_cast<UniversalMachine*>(start_.space().machine()) == NULL) {
        abortWithError("Address space not connected to a machine.");
    }
 
    AddressSpace& instructionAS = 
        *space.machine()->controlUnit()->addressSpace();
 
    start_ = Address(start_.location(), instructionAS);
    entry_ = Address(entry_.location(), instructionAS);
 
 
    for (int k = 0; k < procedureCount(); k++) {
        Procedure& proc = procedure(k);
        for (int j = 0; j < proc.instructionCount(); j++) {
            Instruction &ins = proc.instructionAtIndex(j);
            for (int i = 0; i < ins.moveCount(); i++) {
                Move& move = ins.move(i);
                Terminal& source = move.source();
                if (source.isAddress() && !source.isInstructionAddress()) {
                    TerminalAddress* newSource = new TerminalAddress(
                        source.value(), const_cast<AddressSpace&>(space));
                    move.setSource(newSource);
                }
            }
        }
    }
    
    if (dataMemoryCount()  > 1) {
        throw IllegalProgram(
            __FILE__, __LINE__, __func__,
            "There should be less than two data memories. Number of memories: " + 
            Conversion::toString(dataMemoryCount()));
    }
 
    if (dataMemoryCount() == 0) {
        // TODO: what to do when there is no data used in program...
    } else if (dataMemoryCount() == 1) {
        DataMemory& dataMem = dataMemory(0);
        dataMem.setAddressSpace(const_cast<AddressSpace&>(space));
 
        // fix dest addresses in data defs to point to the new single data AS
        for (int i = 0; i < dataMem.dataDefinitionCount(); i++) {
            DataDefinition& def = dataMem.dataDefinition(i);
            if (def.isAddress() && !def.isInstructionAddress()) {
                def.setDestinationAddress(
                    Address(def.destinationAddress().location(), space));
            }
        }
        
        assert(dataMemoryCount() == 1);
        globalScope_->setDataLabelAddressSpace(space);
 
    } else {
        throw IllegalProgram(
            __FILE__, __LINE__, __func__,
            "There should be less than two data memories. Number of memories: " + 
            Conversion::toString(dataMemoryCount()));
    }
}

References __func__, abortWithError, TTAMachine::FunctionUnit::addressSpace(), assert, TTAMachine::Machine::controlUnit(), TTAProgram::DataMemory::dataDefinition(), TTAProgram::DataMemory::dataDefinitionCount(), dataMemory(), dataMemoryCount(), TTAProgram::DataDefinition::destinationAddress(), entry_, globalScope_, TTAProgram::CodeSnippet::instructionAtIndex(), TTAProgram::CodeSnippet::instructionCount(), TTAProgram::DataDefinition::isAddress(), TTAProgram::Terminal::isAddress(), TTAProgram::DataDefinition::isInstructionAddress(), TTAProgram::Terminal::isInstructionAddress(), TTAProgram::Address::location(), TTAMachine::Component::machine(), TTAProgram::Instruction::move(), TTAProgram::Instruction::moveCount(), procedure(), procedureCount(), TTAProgram::DataMemory::setAddressSpace(), TTAProgram::GlobalScope::setDataLabelAddressSpace(), TTAProgram::DataDefinition::setDestinationAddress(), TTAProgram::Move::setSource(), TTAProgram::Move::source(), TTAProgram::Address::space(), start_, Conversion::toString(), and TTAProgram::Terminal::value().

Here is the call graph for this function:

◆ setEntryAddress()

void TTAProgram::Program::setEntryAddress ( Address address )

Sets the entry address of the program.

Note: Preserving this value is not implemented in TPEFProgramFactory and ProgramWriter, however implementation of property is already specified in TPEF specs.

Definition at line 342 of file Program.cc.

                                        {
    entry_ = address;
}

References entry_.

Referenced by copyFrom().

◆ setStartAddress()

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

Sets the start (lowest) address of the program.

The start address of the program is not necessarily the lowest address of the instruction address space. Relocates instructions to start from the address.

Note: Preserving this value is not implemented in TPEFProgramFactory and ProgramWriter, however implementation of property is already specified in TPEF specs.

Parameters

start The start (lowest) address of the program.

Definition at line 304 of file Program.cc.

                                      {
 
    start_ = start;
 
    // move procedures before the new starting address
    if (procedureCount() > 0 && 
        firstProcedure().startAddress().location() < start_.location()) {
        moveProcedure(
            firstProcedure(), 
            start_.location() - firstProcedure().startAddress().location());
    }
}

References firstProcedure(), TTAProgram::Address::location(), moveProcedure(), procedureCount(), start_, and startAddress().

Referenced by copyFrom().

Here is the call graph for this function:

◆ setUniversalMachine()

void TTAProgram::Program::setUniversalMachine ( UniversalMachine * umach )

inline

Definition at line 81 of file Program.hh.

81{ umach_ = umach; }

References umach_.

Referenced by TTAProgram::TPEFProgramFactory::build().

◆ startAddress()

Address TTAProgram::Program::startAddress ( ) const

Returns the start (lowest) address of the program.

The start address of the program is not necessarily the lowest address of the instruction address space.

Note: Preserving this value is not implemented in TPEFProgramFactory and ProgramWriter, however implementation of property is already specified in TPEF specs.

Returns: The start (lowest) address of the program.

Definition at line 286 of file Program.cc.

                            {
    return start_;
}

References start_.

Referenced by TTAProgram::TPEFProgramFactory::build(), SimProgramBuilder::build(), SimulationStatistics::calculate(), copy(), copyFrom(), TTAProgram::ProgramWriter::createBinary(), TTAProgram::ProgramWriter::createCodeSection(), finalize(), SimulatorFrontend::finishSimulation(), fixInstructionReferences(), CompiledSimulation::moveExecutionCount(), setStartAddress(), and POMDisassembler::startAddress().

◆ targetProcessor()

Machine & TTAProgram::Program::targetProcessor ( ) const

Returns the target TTA processor of the program.

Returns: The target TTA processor of the program.

Definition at line 202 of file Program.cc.

                               {
    return *start_.space().machine();
}

References TTAMachine::Component::machine(), TTAProgram::Address::space(), and start_.

Referenced by SimProgramBuilder::build(), copyDataMemoriesFrom(), TTAProgram::ProgramWriter::createASpaceElement(), TTAProgram::ProgramWriter::createBinary(), TTAProgram::ProgramWriter::createCodeSection(), TTAProgram::TPEFProgramFactory::createDataMemories(), finalize(), ProgramImageGenerator::generateProgramImage(), DisassemblyGridTable::GetColLabelValue(), DisassemblyGridTable::GetNumberCols(), and DisassemblyGridTable::GetValue().

Here is the call graph for this function:

◆ toString()

TCEString TTAProgram::Program::toString ( ) const

Dump the Program as a disassembly string.

Definition at line 1327 of file Program.cc.

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

References POMDisassembler::disassemble().

Here is the call graph for this function:

◆ universalMachine()

UniversalMachine & TTAProgram::Program::universalMachine ( ) const

Deprecated.

Use UniversalMachine::instance() directly.

Definition at line 104 of file Program.cc.

                                {
    return UniversalMachine::instance();
}

References UniversalMachine::instance().

Referenced by ProgramDependenceGraph::createJump(), ProgramDependenceGraph::disassemble(), and llvm::LLVMTCEPOMBuilder::emitMove().

Here is the call graph for this function:

◆ writeToTPEF()

void TTAProgram::Program::writeToTPEF	(	const TTAProgram::Program &	program,
		const std::string &	tpefFileName
	)

static

A shortcut for writing a program to a TPEF file.

Parameters

program	The program to write.
tpefFileName	The file name of the TPEF.

Exceptions

Exception if the TPEF or program in it is somehow broken.

Definition at line 1169 of file Program.cc.

                                                                     {
    std::ofstream outputFile(
        tpefFileName.c_str(),
        std::ios_base::out|std::ios_base::trunc|std::ios_base::binary);
    TPEF::BinaryStream binaryStream(outputFile);
 
    TTAProgram::ProgramWriter writer(program);
    TPEF::Binary* tpefBin = writer.createBinary();
 
    TPEF::TPEFWriter::instance().writeBinary(binaryStream, tpefBin);
 
    delete tpefBin;
    tpefBin = NULL;
}

References TTAProgram::ProgramWriter::createBinary(), TPEF::TPEFWriter::instance(), program, and TPEF::BinaryWriter::writeBinary().

Referenced by main().

Here is the call graph for this function:

Member Data Documentation

◆ dataMems_

DataMemList TTAProgram::Program::dataMems_

private

The data memories in the program.

Definition at line 180 of file Program.hh.

Referenced by addDataMemory(), cleanup(), dataMemory(), and dataMemoryCount().

◆ entry_

Address TTAProgram::Program::entry_

private

The entry address of the program.

Definition at line 188 of file Program.hh.

Referenced by entryAddress(), replaceUniversalAddressSpaces(), and setEntryAddress().

◆ finalized_

bool TTAProgram::Program::finalized_

private

True in case the program is not (and must not be) updated anymore and it has its final instruction addresses computed.

Definition at line 200 of file Program.hh.

Referenced by finalize(), and isFinalized().

◆ globalScope_

GlobalScope* TTAProgram::Program::globalScope_

private

Global scope of the program.

Definition at line 174 of file Program.hh.

Referenced by cleanup(), convertSymbolRef(), copyFrom(), globalScope(), globalScopeConst(), Program(), Program(), Program(), removeProcedure(), replaceUniversalAddressSpaces(), and ~Program().

◆ instructionPerAddress_

bool TTAProgram::Program::instructionPerAddress_

private

True in case the program is instruction indexed, that is, each instruction is assumed to be in a single instruction memory location.

Definition at line 204 of file Program.hh.

Referenced by finalize(), and isInstructionPerAddress().

◆ moves_

MoveList TTAProgram::Program::moves_

private

List of all the moves of the program.

Definition at line 183 of file Program.hh.

Referenced by addInstruction(), moveAt(), and moveCount().

◆ procedures_

ProcList TTAProgram::Program::procedures_

private

The procedures in the program.

Definition at line 177 of file Program.hh.

Referenced by addInstruction(), addProcedure(), cleanup(), finalize(), firstInstruction(), firstProcedure(), hasProcedure(), instructionAt(), instructionVector(), lastInstruction(), lastProcedure(), moveProcedure(), nextInstruction(), nextProcedure(), operator[](), procedure(), procedure(), procedureAtIndex(), procedureCount(), and removeProcedure().

◆ refManager_

InstructionReferenceManager* TTAProgram::Program::refManager_

private

Keeps book of all instruction to instruction (jumps and calls) references in the program.

Definition at line 192 of file Program.hh.

Referenced by cleanup(), convertSymbolRef(), instructionReferenceManager(), Program(), Program(), Program(), and ~Program().

◆ start_

Address TTAProgram::Program::start_

private

The start address of the program.

Definition at line 186 of file Program.hh.

Referenced by addProcedure(), instructionCount(), moveProcedure(), replaceUniversalAddressSpaces(), setStartAddress(), startAddress(), and targetProcessor().

◆ umach_

UniversalMachine* TTAProgram::Program::umach_

mutableprivate

The UniversalMachine instance used to refer to in case of the unscheduled/unassigned parts of the program.

Definition at line 196 of file Program.hh.

Referenced by setUniversalMachine().

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

Public Types

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ DataMemList

◆ InstructionVector

◆ MoveList

◆ ProcIter

◆ ProcList

Constructor & Destructor Documentation

◆ Program() [1/4]

◆ Program() [2/4]

◆ Program() [3/4]

◆ ~Program()

◆ Program() [4/4]

Member Function Documentation

◆ addDataMemory()

◆ addInstruction()

◆ addProcedure()

◆ cleanup()

◆ convertSymbolRef()

◆ convertSymbolRefsToInsRefs()

◆ copy()

◆ copyCodeLabelsFrom()

◆ copyDataLabelsFrom()

◆ copyDataMemoriesFrom()

◆ copyFrom()

◆ dataMemory() [1/2]

◆ dataMemory() [2/2]

◆ dataMemoryCount()

◆ entryAddress()

◆ finalize()

◆ firstInstruction()

◆ firstProcedure()

◆ fixInstructionReferences()

◆ globalScope()

◆ globalScopeConst()

◆ hasProcedure()

◆ instructionAt()

◆ instructionCount()

◆ instructionReferenceManager()

◆ instructionVector()

◆ isFinalized()

◆ isInstructionPerAddress()

◆ lastInstruction()

◆ lastProcedure()

◆ link()

◆ loadFromTPEF()

◆ loadFromUnscheduledTPEF() [1/2]

◆ loadFromUnscheduledTPEF() [2/2]

◆ moveAt()

◆ moveCount()

◆ moveProcedure()

◆ nextInstruction()

◆ nextProcedure()

◆ operator=()

◆ operator[]()

◆ procedure() [1/2]

◆ procedure() [2/2]

◆ procedureAtIndex()

◆ procedureCount()

◆ removeProcedure()

◆ replaceUniversalAddressSpaces()

◆ setEntryAddress()

◆ setStartAddress()

◆ setUniversalMachine()

◆ startAddress()

◆ targetProcessor()

◆ toString()

◆ universalMachine()

◆ writeToTPEF()

Member Data Documentation

◆ dataMems_

◆ entry_

◆ finalized_

◆ globalScope_