TTAProgram::TPEFProgramFactory Class Reference

#include <TPEFProgramFactory.hh>

Collaboration diagram for TTAProgram::TPEFProgramFactory:

Classes
class	CacheKey
	Cache key for resources that are accessed from MOM(s) More...
struct	SocketAllocation

Public Member Functions
	TPEFProgramFactory (const TPEF::Binary &aBinary, const TTAMachine::Machine &aMachine)
	TPEFProgramFactory (const TPEF::Binary &aBinary, const TTAMachine::Machine &aMachine, UniversalMachine *aUniversalMachine)
	TPEFProgramFactory (const TPEF::Binary &aBinary, UniversalMachine *aMachine)
virtual	~TPEFProgramFactory ()
Program *	build ()

Protected Types
typedef std::map< HalfWord, SimValue * >	InlineValues
typedef std::pair< Word, Word >	ImmediateKey
typedef std::map< ImmediateKey, TPEF::ImmediateElement * >	ImmediateMap
typedef std::vector< TPEF::MoveElement * >	MoveVector
typedef std::vector< TPEF::ImmediateElement * >	ImmediateVector

Protected Member Functions
Instruction *	createInstruction (const TPEF::ResourceSection &resources, MoveVector &moveElements, ImmediateVector &longImmediates, ImmediateMap &immElements) const
void	addProcedures (Program &program, const TTAMachine::AddressSpace &programASpace) const
Terminal *	createTerminal (const TPEF::ResourceSection &resources, const TTAMachine::Bus *aBus, TTAMachine::Socket::Direction direction, TPEF::MoveElement::FieldType type, HalfWord unitId, HalfWord index, const ImmediateMap *immediateMap=NULL) const
TTAMachine::Bus &	findBus (const TPEF::ResourceSection &resources, HalfWord busId) const
TTAMachine::RegisterFile &	findRegisterFile (const TPEF::ResourceSection &resources, HalfWord rfId) const
TTAMachine::ImmediateUnit &	findImmediateUnit (const TPEF::ResourceSection &resources, Byte immUnitId) const
TTAMachine::FunctionUnit &	findFunctionUnit (const TPEF::ResourceSection &resources, HalfWord unitId, std::string tpefOpName="") const
TTAMachine::Port &	findPort (const TTAMachine::Bus &bus, const TTAMachine::Unit &portParent, std::string tpefOpName="", int tpefOpIndex=0) const
TTAMachine::AddressSpace &	findAddressSpace (const TPEF::ASpaceElement *aSpace) const
TTAMachine::Guard &	findGuard (const TPEF::ResourceSection &resources, TTAMachine::Bus &bus, TPEF::MoveElement::FieldType type, HalfWord unitId, HalfWord index, bool isInverted) const
TTAMachine::InstructionTemplate &	findInstrTemplate (const TPEF::ResourceSection &resources, ImmediateVector &longImmediates, MoveVector &moves) const
void	seekFunctionStartPoints ()
void	createLabels (Program &prog)
void	createDataRelocs (Program &prog)
void	createDataMemories (Program &prog)
bool	isFunctionStart (const TPEF::InstructionElement &instructionElement) const
std::string	functionName (const TPEF::InstructionElement &instructionElement) const
std::string	stringOfChunk (const TPEF::Chunk *chunk, const TPEF::Section *chunkOwner) const

Private Member Functions
void	clearResourceAllocations () const
bool	canSourceBeAssigned (SocketAllocation &alloc, std::map< TTAMachine::Socket *, std::vector< SocketAllocation * > > &fixedSockets) const
bool	canDestinationBeAssigned (SocketAllocation &alloc, std::map< TTAMachine::Socket *, std::vector< SocketAllocation * > > &fixedSockets) const
void	resolveSocketAllocations (std::vector< SocketAllocation > &allocs) const
Terminal *	getFromCache (const CacheKey &key) const
void	addToCache (const CacheKey &key, Terminal *cachedTerm) const
void	clearCache () const

Private Attributes
const TPEF::Binary *	binary_
	Binary that is used for creating program.
const TTAMachine::Machine *	machine_
	Target machine of program.
UniversalMachine *	universalMachine_
	Universal machine of program.
TPEF::TPEFTools	tpefTools_
	TPEFTools object for helper functions.
TTAMachine::AddressSpace *	adfInstrASpace_
	Instruction address space of machine.
TPEF::ASpaceElement *	tpefInstrASpace_
	Instruction address space element of TPEF.
std::map< const TPEF::InstructionElement *, class FunctionStart * >	functionStartPositions_
	Stores information of start points of procedures that were found.
std::list< std::shared_ptr< Move > >	instructionImmediates_
	Moves whose source terminals are addresses referring to instructions.
std::list< std::shared_ptr< Immediate > >	longInstructionImmediates_
	Long immediates whose value terminals refers to instructions.
std::map< const CacheKey, Terminal * >	cache_
	Cache map of terminals that are returned by different search parameters.
std::set< HalfWord >	allocatedBusses_
	Busses that are already allocated by moves of current instruction.
std::map< TPEF::InstructionElement *, Instruction * >	instructionMap_
	Program instruction by TPEF instruction element.

Detailed Description

Creates a new TTA program out of a description of a binary representation of the program and a model of the target architecture.

This class builds only one program, even if the input binary contains many programs (the original TPEF file has multiple code sections with different address spaces).

Definition at line 87 of file TPEFProgramFactory.hh.

Member Typedef Documentation

ImmediateKey

typedef std::pair<Word, Word> TTAProgram::TPEFProgramFactory::ImmediateKey

protected

Definition at line 107 of file TPEFProgramFactory.hh.

ImmediateMap

typedef std::map<ImmediateKey, TPEF::ImmediateElement*> TTAProgram::TPEFProgramFactory::ImmediateMap

protected

Definition at line 108 of file TPEFProgramFactory.hh.

ImmediateVector

typedef std::vector<TPEF::ImmediateElement*> TTAProgram::TPEFProgramFactory::ImmediateVector

protected

Definition at line 110 of file TPEFProgramFactory.hh.

InlineValues

typedef std::map<HalfWord, SimValue*> TTAProgram::TPEFProgramFactory::InlineValues

protected

Definition at line 106 of file TPEFProgramFactory.hh.

MoveVector

typedef std::vector<TPEF::MoveElement*> TTAProgram::TPEFProgramFactory::MoveVector

protected

Definition at line 109 of file TPEFProgramFactory.hh.

Constructor & Destructor Documentation

TPEFProgramFactory() [1/3]

TTAProgram::TPEFProgramFactory::TPEFProgramFactory	(	const TPEF::Binary &	aBinary,
		const TTAMachine::Machine &	aMachine
	)

Constructor for fully scheduled code.

Parameters

aBinary	Binary that contains a program's instructions and data.
aMachine	Machine to which code refers.
relocs	Managed collection of relocation points in the program.

Definition at line 137 of file TPEFProgramFactory.cc.

                                                   :
    binary_(&aBinary), machine_(&aMachine),
    universalMachine_(&UniversalMachine::instance()),
    tpefTools_(aBinary),
    adfInstrASpace_(NULL),
    tpefInstrASpace_(NULL) {
}

TPEFProgramFactory() [2/3]

TTAProgram::TPEFProgramFactory::TPEFProgramFactory	(	const TPEF::Binary &	aBinary,
		const TTAMachine::Machine &	aMachine,
		UniversalMachine *	aUniversalMachine
	)

Constructor.

For mixed code which contains universal machine references and target machine references.

Parameters

aBinary	Binary that contains a program's instructions and data.
aMachine	Actual machine to which parallel code refers.
aUniversalMachine	Universal machine for sequential code.
relocs	Managed collection of relocation points in the program.

Definition at line 119 of file TPEFProgramFactory.cc.

                      :
    binary_(&aBinary), machine_(&aMachine),
    universalMachine_(&UniversalMachine::instance()),
    tpefTools_(aBinary),
    adfInstrASpace_(NULL),
    tpefInstrASpace_(NULL) {
}

TPEFProgramFactory() [3/3]

TTAProgram::TPEFProgramFactory::TPEFProgramFactory	(	const TPEF::Binary &	aBinary,
		UniversalMachine *	aMachine
	)

Constructor for fully unscheduled code.

Parameters

aBinary	Binary that contains a program's instructions and data.
uMachine	Universal Machine to which code refers.
relocs	Managed collection of relocation points in the program.

Definition at line 153 of file TPEFProgramFactory.cc.

                                             :
    binary_(&aBinary), machine_(NULL),
    universalMachine_(&UniversalMachine::instance()),
    tpefTools_(aBinary),
    adfInstrASpace_(NULL),
    tpefInstrASpace_(NULL) {
}

~TPEFProgramFactory()

TTAProgram::TPEFProgramFactory::~TPEFProgramFactory ( )

virtual

Destructor.

Definition at line 166 of file TPEFProgramFactory.cc.

                                        {
    MapTools::deleteAllValues(functionStartPositions_);
}

References MapTools::deleteAllValues(), and functionStartPositions_.

Here is the call graph for this function:

Member Function Documentation

addProcedures()

void TTAProgram::TPEFProgramFactory::addProcedures ( Program &  program, const TTAMachine::AddressSpace &  programASpace  ) const

protected

Parses procedures from all TPEF CodeSections and adds them to Program.

Parameters

program	Program where to add new procedures.
programASpace	Address space of instruction memory.

Definition at line 344 of file TPEFProgramFactory.cc.

                                              {
 
     // find code sections to chop and organize them by start address
     std::list<CodeSection*> sectionsToChop;
 
     for (Word i = 0; i < binary_->sectionCount(Section::ST_CODE); i++) {
 
         CodeSection* sectionToAdd =
             dynamic_cast<CodeSection*>(
                 binary_->section(Section::ST_CODE, i));
 
         if (sectionsToChop.empty()) {
             sectionsToChop.push_back(sectionToAdd);
             continue;
         }
 
         std::list<CodeSection*>::iterator iter = sectionsToChop.begin();
 
         while (iter != sectionsToChop.end()) {
 
             if ((*iter)->startingAddress() >
                 sectionToAdd->startingAddress()) {
                 sectionsToChop.insert(iter, sectionToAdd);
                 break;
             }
 
             iter++;
         }
     }
 
     // NOTE: maybe it should be checked if found code sections are legal.
     //       (adressSpaces and addresses does not collide)
 
     // add instruction elements of every found section
     std::list<CodeSection*>::iterator sectionIterator =
         sectionsToChop.begin();
 
     while (sectionIterator != sectionsToChop.end()) {
         CodeSection* section = *sectionIterator;
 
         ResourceSection* resources =
             dynamic_cast<ResourceSection*>(section->link());
         assert(resources != NULL);
 
         Word i = 0;
         int currentInstructionNumber = 0;
         while (i < section->elementCount()) {
 
             try {
                 // Create and add a new procedure to program with name if
                 // new procedure is started by current instruction or if
                 // there is no procedures in program.
 
                 SectionElement* element = section->element(i);
                 InstructionElement* instructionElement =
                     dynamic_cast<InstructionElement*>(element);
                 assert(instructionElement != NULL);
 
                 if (isFunctionStart(*instructionElement) ||
                     program.procedureCount() == 0) {
 
                     assert(instructionElement->begin());
 
                     // TODO: set the real start address.. ?
 
                     Procedure* newProcedure = new Procedure(
                         functionName(*instructionElement),
                         programASpace, 0);
 
                     program.addProcedure(newProcedure);
                 }
 
                 // scan instruction elements of next instruction
 
                 // moves of instruction
                 MoveVector moveElements;
                 // slots that encode immediate bits of instruction
                 ImmediateVector longImmediates;
                 // inline immediates of instruction
                 ImmediateMap immElements;
 
                 InstructionElement* beginElement = NULL;
 
                 do {
                     if (instructionElement->begin()) {
                         beginElement = instructionElement;
                     }
 
                     if (instructionElement->isMove()) {
                         moveElements.push_back(
                             dynamic_cast<MoveElement*>(instructionElement));
 
                     } else if (instructionElement->isImmediate()) {
                         ImmediateElement* imm =
                             dynamic_cast<ImmediateElement*>(
                                 instructionElement);
 
                         if (imm->isInline()) {
                             std::pair<Word,Word> 
                                 immKey(imm->destinationUnit(),
                                        imm->destinationIndex());
                             immElements[immKey] = imm;
                         } else {
                             longImmediates.push_back(imm);
                         }
                     } else {
                         abortWithError("Unknown instruction element type.");
                     }
 
                     i++;
                     if (i >= section->elementCount()) {
                         break;
                     }
 
                     SectionElement* sectionElement = section->element(i);
                     assert(sectionElement != NULL);
 
                     instructionElement =
                         dynamic_cast<InstructionElement*>(sectionElement);
 
                     assert(i < section->elementCount());
 
                 } while (instructionElement->begin() == false);
 
                 Instruction* currentInstruction =
                     createInstruction(*resources, moveElements,
                                       longImmediates, immElements);
 
                 // add created instruction to map for finding program
                 // instruction by tpef instruction element
                 assert(beginElement != NULL);
 
                 instructionMap_[beginElement] = currentInstruction;
 
                 assert(currentInstruction != NULL);
 
                 program.addInstruction(currentInstruction);
                 currentInstructionNumber++;
 
             } catch (const Exception& e) {
                 // add instruction number to start of exception message
                 NotAvailable error(
                     __FILE__, __LINE__, __func__,
                     (boost::format(
                         "Instruction %d: ") % currentInstructionNumber).
                     str() + e.errorMessage());
                 error.setCause(e);
 
                 throw error;
             }
         }
 
         sectionIterator++;
     }
 }

References __func__, abortWithError, assert, TPEF::InstructionElement::begin(), binary_, createInstruction(), TPEF::ImmediateElement::destinationIndex(), TPEF::ImmediateElement::destinationUnit(), TPEF::CodeSection::element(), TPEF::Section::elementCount(), Exception::errorMessage(), functionName(), instructionMap_, isFunctionStart(), TPEF::InstructionElement::isImmediate(), TPEF::ImmediateElement::isInline(), TPEF::InstructionElement::isMove(), TPEF::Section::link(), program, TPEF::Binary::section(), TPEF::Binary::sectionCount(), Exception::setCause(), TPEF::Section::ST_CODE, and TPEF::Section::startingAddress().

Referenced by build().

Here is the call graph for this function:

addToCache()

void TTAProgram::TPEFProgramFactory::addToCache ( const CacheKey &  key, Terminal *  cachedTerm  ) const

private

Adds Terminal to cache.

Parameters

key	Key of search variables for getting terminal from machine(s).
cachedTerm	Terminal to be add to cache.

Returns

cached terminal if there is one.

Definition at line 1968 of file TPEFProgramFactory.cc.

                                {
 
    cache_[key] = cachedTerm;
}

References cache_.

Referenced by createTerminal().

build()

Program * TTAProgram::TPEFProgramFactory::build

(

)

Builds program model out of TPEF model.

Returns

Created program.

Exceptions

NotAvailable	if there the binary contains no sections; if the instruction address space is missing or conflicting with architecture definition.
Exception	if the TPEF or program in it is somehow broken.

Definition at line 200 of file TPEFProgramFactory.cc.

                          {
    assert(machine_ != NULL || universalMachine_ != NULL);
 
    if (binary_->sectionCount(Section::ST_CODE) == 0) {
        throw NotAvailable(
            __FILE__, __LINE__, __func__,
            "No code sections in TPEF.");
    }
 
    tpefInstrASpace_ = binary_->section(Section::ST_CODE, 0)->aSpace();
 
    // get address space for program from machine depending on
    // type of code (sequential, partially scheduled, fully scheduled)
    adfInstrASpace_ = NULL;
 
    if (machine_ == NULL) {
        adfInstrASpace_ = &universalMachine_->instructionAddressSpace();
        
    } else {
    
        if (binary_->type() == Binary::FT_OBJSEQ ||
            binary_->type() == Binary::FT_PURESEQ ||
            binary_->type() == Binary::FT_LIBSEQ) {
                throw NotAvailable(
                    __FILE__, __LINE__, __func__,
                    "Tried to load a sequential program with ADF already "
                    "loaded.");
            }
        
        // check if real machine has address space by defined name.
        // if not found then use universal address space.
        Machine::AddressSpaceNavigator aSpaceNav =
            machine_->addressSpaceNavigator();
 
        std::string aSpaceName = stringOfChunk(
            tpefInstrASpace_->name(),
            binary_->section(Section::ST_ADDRSP, 0)->link());
 
        if (aSpaceNav.hasItem(aSpaceName )) {
            adfInstrASpace_ = aSpaceNav.item(aSpaceName);
 
        } else {
            if (universalMachine_ == NULL) {
                throw NotAvailable(
                    __FILE__, __LINE__, __func__,
                    "No instruction(gcu) address space in ADF.");
            }
 
            adfInstrASpace_ = &universalMachine_->instructionAddressSpace();
        }
    }
    
    if (machine_ == NULL && 
        binary_->type() == Binary::FT_PARALLEL) {
        throw NotAvailable(
            __FILE__, __LINE__, __func__,
            "Tried to load a parallel TPEF without ADF.");
    }
 
    assert(adfInstrASpace_ != NULL);
 
    // ignored for backwards compatibility
    //     if (tpefInstrASpace_->MAU() != 0) {
    //         throw NotAvailable(
    //             __FILE__, __LINE__, __func__,
    //             (boost::format(
    //                 "TPEF instruction address space MAU size should be (%d).") %
    //                 static_cast<int>(tpefInstrASpace_->MAU())).str());
    //     }
 
    
    clearCache();
 
    seekFunctionStartPoints();
 
    Program* newProgram = new Program(*adfInstrASpace_);
    newProgram->setUniversalMachine(universalMachine_);
 
    // create all the code
    addProcedures(*newProgram, *adfInstrASpace_);
 
    TTAProgram::Program::InstructionVector allInstructions =
        newProgram->instructionVector();
    const InstructionAddress startAddress =
        newProgram->startAddress().location();
        
    // fix TerminalAddresses pointing to instructions to be
    // TerminalInstructionAddresses.
    while (!instructionImmediates_.empty()) {
        auto move = *instructionImmediates_.begin();
        instructionImmediates_.erase(instructionImmediates_.begin());
 
        Terminal &addressTerm = move->source();
 
        assert(&(addressTerm.address().space()) == adfInstrASpace_);
 
        Instruction& referencedInstruction =
            *allInstructions.at(addressTerm.address().location() - startAddress);
 
        InstructionReference instructionReference =
            newProgram->instructionReferenceManager().createReference(
                referencedInstruction);
 
        TerminalInstructionReference* instrTerm =
            new TerminalInstructionReference(instructionReference);
 
        move->setSource(instrTerm);
    }
 
    // and same for long immediates which refers to instruction addresses
    while (!longInstructionImmediates_.empty()) {
        auto immediate = *longInstructionImmediates_.begin();
        longInstructionImmediates_.erase(longInstructionImmediates_.begin());
 
        TerminalImmediate &addressTerm = immediate->value();
 
        assert(&(addressTerm.address().space()) == adfInstrASpace_);
 
        Instruction& referencedInstruction =
            *allInstructions.at(addressTerm.address().location() - startAddress);
 
        InstructionReference instructionReference =
            newProgram->instructionReferenceManager().createReference(
                referencedInstruction);
 
        TerminalInstructionReference* instrTerm =
            new TerminalInstructionReference(instructionReference);
 
        immediate->setValue(instrTerm);
    }
 
    createDataMemories(*newProgram);
    createLabels(*newProgram);
 
    return newProgram;
}

References __func__, addProcedures(), TTAProgram::Terminal::address(), TTAMachine::Machine::addressSpaceNavigator(), adfInstrASpace_, TPEF::Section::aSpace(), assert, binary_, clearCache(), createDataMemories(), createLabels(), TTAProgram::InstructionReferenceManager::createReference(), TPEF::Binary::FT_LIBSEQ, TPEF::Binary::FT_OBJSEQ, TPEF::Binary::FT_PARALLEL, TPEF::Binary::FT_PURESEQ, TTAMachine::Machine::Navigator< ComponentType >::hasItem(), UniversalMachine::instructionAddressSpace(), instructionImmediates_, TTAProgram::Program::instructionReferenceManager(), TTAProgram::Program::instructionVector(), TTAMachine::Machine::Navigator< ComponentType >::item(), TPEF::Section::link(), TTAProgram::Address::location(), longInstructionImmediates_, machine_, TPEF::ASpaceElement::name(), TPEF::Binary::section(), TPEF::Binary::sectionCount(), seekFunctionStartPoints(), TTAProgram::Program::setUniversalMachine(), TTAProgram::Address::space(), TPEF::Section::ST_ADDRSP, TPEF::Section::ST_CODE, TTAProgram::Program::startAddress(), stringOfChunk(), tpefInstrASpace_, TPEF::Binary::type(), universalMachine_, and TTAProgram::TerminalImmediate::value().

Referenced by InstructionDictionary::compress(), TTAProgram::Program::loadFromTPEF(), TTAProgram::Program::loadFromUnscheduledTPEF(), TTAProgram::Program::loadFromUnscheduledTPEF(), loadInputs(), SimulatorFrontend::loadProgram(), main(), InlineAsmParser::parse(), and CodeCompressorPlugin::startNewProgram().

Here is the call graph for this function:

canDestinationBeAssigned()

bool TTAProgram::TPEFProgramFactory::canDestinationBeAssigned ( SocketAllocation &  alloc, std::map< TTAMachine::Socket *, std::vector< SocketAllocation * > > &  fixedSockets  ) const

private

Checks if the destination of SocketAllocation can be assigned towards given map of already allocated sockets.

If tried socket is already used, it still can be used for another writing if the moves have opposite guards.

Parameters

alloc	Socket allocation structure which is checked.
fixedSockets	Map of already made socket allocations.

Returns

True if tried alloc is possible.

Definition at line 1667 of file TPEFProgramFactory.cc.

                                                                        {
 
    Socket* currentSocket = alloc.dstSocks[alloc.dst];
 
    if (MapTools::containsKey(fixedSockets, currentSocket)) {
 
        std::vector<SocketAllocation*>& socketAllocs = fixedSockets[currentSocket];
 
        // test against all allocations.
        for (unsigned int i = 0; i < socketAllocs.size(); i++) {
            // TODO: check against all users.
            auto oldMove = socketAllocs[i]->move;
            if (alloc.move->isUnconditional() || oldMove->isUnconditional() ||
                !alloc.move->guard().guard().isOpposite(
                    oldMove->guard().guard())) {
                return false;
            }
        }
    }
    return true;
}

References MapTools::containsKey(), TTAProgram::TPEFProgramFactory::SocketAllocation::dst, TTAProgram::TPEFProgramFactory::SocketAllocation::dstSocks, and TTAProgram::TPEFProgramFactory::SocketAllocation::move.

Referenced by resolveSocketAllocations().

Here is the call graph for this function:

canSourceBeAssigned()

bool TTAProgram::TPEFProgramFactory::canSourceBeAssigned ( SocketAllocation &  alloc, std::map< TTAMachine::Socket *, std::vector< SocketAllocation * > > &  fixedSockets  ) const

private

Checks if the source of SocketAllocation can be assigned towards given map of already allocated sockets.

If tried socket is already used, it still can be used for another reading if 1) the source register index is same for both of the allocations, or 2) the moves have opposite guards.

Parameters

alloc	Socket allocation structure which is checked.
fixedSockets	Map of already made socket allocations.

Returns

True if tried alloc is possible.

Definition at line 1624 of file TPEFProgramFactory.cc.

                                                                        {
 
    Socket* currentSocket = alloc.srcSocks[alloc.src];
 
    if (MapTools::containsKey(fixedSockets, currentSocket)) {
 
        std::vector<SocketAllocation*>& socketAllocs = fixedSockets[currentSocket];
 
        // test against all allocations.
        for (unsigned int i = 0; i < socketAllocs.size(); i++) {
            // TODO: check against all users.
            auto oldMove = socketAllocs[i]->move;
            Terminal* oldTerminal = &(oldMove->source());
 
            // allowed for same register of opposite guard.
            if (alloc.move->source().index() != oldTerminal->index() &&
                (alloc.move->isUnconditional() || oldMove->isUnconditional() ||
                 !alloc.move->guard().guard().isOpposite(oldMove->guard().guard()))) {
                return false;
            }
        }
        //Application::errorStream() << insTemp->NOPSlotCount() << " " << templateIsGood << " ";
        //Application::errorStream() << std::endl;
    }
 
    return true;
}

References MapTools::containsKey(), TTAProgram::Terminal::index(), TTAProgram::TPEFProgramFactory::SocketAllocation::move, TTAProgram::TPEFProgramFactory::SocketAllocation::src, and TTAProgram::TPEFProgramFactory::SocketAllocation::srcSocks.

Referenced by resolveSocketAllocations().

Here is the call graph for this function:

clearCache()

void TTAProgram::TPEFProgramFactory::clearCache ( ) const

private

Clears cache.

Definition at line 1979 of file TPEFProgramFactory.cc.

                                     {
    cache_.clear();
}

References cache_.

Referenced by build().

clearResourceAllocations()

void TTAProgram::TPEFProgramFactory::clearResourceAllocations ( ) const

private

createDataMemories()

void TTAProgram::TPEFProgramFactory::createDataMemories ( Program &  prog )

protected

Creates data memories to program.

Parameters

prog	Program containing converted TPEF instructions.

Definition at line 2176 of file TPEFProgramFactory.cc.

                                                    {
 
    // ------- search through data sections and group them by address spaces
    std::map<AddressSpace*, std::vector<UDataSection*> > memories;    
 
    for (int i = 0; i < static_cast<int>(binary_->sectionCount()); i++) {
        Section* currSect = binary_->section(i);
        
        if (currSect->type() == Section::ST_DATA || 
            currSect->type() == Section::ST_UDATA ||
            currSect->type() == Section::ST_LEDATA) {
            
            UDataSection* uDataSect = dynamic_cast<UDataSection*>(currSect);
 
            AddressSpace& aSpace = findAddressSpace(uDataSect->aSpace());
            std::vector<UDataSection*>& secVec = memories[&aSpace];
            
            // sort sections of current vector by addess...
            UDataSection* temp = NULL;
            for (int j = 0; j < static_cast<int>(secVec.size()); j++) {
                if (secVec[j]->startingAddress() > 
                    uDataSect->startingAddress()) {
                    temp = secVec[j];
                    secVec[j] = uDataSect;                    
                    uDataSect = temp;
                }
            }
            
            secVec.push_back(uDataSect);
        }
    }
 
    // ------------- create DataMemory for each address space
    for (std::map<AddressSpace*, std::vector<UDataSection*> >::iterator iter =
             memories.begin(); 
         iter != memories.end(); iter++) {
               
        AddressSpace& aSpace = *(*iter).first;
        std::vector<UDataSection*>& secVec = (*iter).second;
        
        DataMemory* newDataMem = new DataMemory(aSpace);
        
        for (int i = 0; i < static_cast<int>(secVec.size()); i++) {
            UDataSection* currSect = secVec[i];
 
            if (currSect->type() == Section::ST_UDATA) {
                // ------- create uninitializes data definition
                DataDefinition* newDef = 
                    new DataDefinition(
                        Address(currSect->startingAddress(), aSpace),
                        static_cast<int>(currSect->lengthInMAUs()),
                        prog.targetProcessor().isLittleEndian());
 
                newDataMem->addDataDefinition(newDef);
                               
            } else {
                // -------- create initialized data definition
                assert(currSect->type() == Section::ST_DATA ||
                       currSect->type() == Section::ST_LEDATA);
                               
                // find relocation section for this section
                RelocSection* relocs = NULL;
                
                for (int j = 0; 
                     j < static_cast<int>(
                         binary_->sectionCount(Section::ST_RELOC)); j++) {
                    
                    RelocSection* temp = 
                        dynamic_cast<RelocSection*>(
                            binary_->section(Section::ST_RELOC, j));
                                        
                    if (temp->referencedSection() == currSect) {
                        // found it!
                        relocs = temp;
                        break;
                    }
                }
 
                // ------- create relocated definitions.
                if (relocs != NULL) {
 
                    DataSection* refSect = dynamic_cast<DataSection*>(
                        relocs->referencedSection());
 
                    for (int j = 0; 
                         j < static_cast<int>(relocs->elementCount()); j++) {
                                                
                        RelocElement* currElem = 
                            dynamic_cast<RelocElement*>(relocs->element(j));
                        
                        AddressSpace& dstSpace = 
                            findAddressSpace(currElem->aSpace());
                        
                        // resolve location address of relocation
                        Chunk* srcChunk = 
                            dynamic_cast<Chunk*>(currElem->location());
                        
                        int sourceAddress = 
                            refSect->startingAddress() + 
                            refSect->chunkToMAUIndex(srcChunk);
                        
                        Address startAddr(sourceAddress, aSpace);
                        
                        // resolve mau size of address field 
                        int mauSize = currElem->size() / aSpace.width(); 
                        
                        // field size must be multiple of mau of address space
                        assert(currElem->size() % aSpace.width() == 0);
                                       
                        if (&dstSpace == adfInstrASpace_) {
                            // ------- destination is instruction 
                            
                            InstructionElement* tpefInstr = 
                                dynamic_cast<InstructionElement*>(
                                    currElem->destination());
                            
                            assert(tpefInstr != NULL);
                            
                            // get the instruction reference of destination
                            InstructionReference instrRef = 
                                prog.instructionReferenceManager().
                                createReference(*instructionMap_[tpefInstr]);
                            
                            DataInstructionAddressDef* newDataDef = 
                                new DataInstructionAddressDef(
                                    startAddr, mauSize, instrRef,
                                    prog.targetProcessor().isLittleEndian());
                            
                            newDataMem->addDataDefinition(newDataDef);
                            
                        } else {
                            // ------- destination is chunk
                            
                            // find dst section of destination() chunk
                            Chunk* dstChunk = 
                                dynamic_cast<Chunk*>(currElem->destination());
                            
                            assert(dstChunk != NULL);
 
                            UDataSection* dstSect = NULL;
                            
                            std::vector<UDataSection*>& dstSecs = 
                                memories[&dstSpace];
 
                            for (int k = 0; 
                                 k < static_cast<int>(dstSecs.size()); k++) {
 
                                UDataSection* temp = dstSecs[k];
 
                                if (temp->belongsToSection(dstChunk)) {
                                    // dst section found!
                                    dstSect = temp;
                                    break;
                                }
                            }
                            
                            assert(dstSect != NULL);
                            
                            Address dstAddr(
                                dstSect->startingAddress() +
                                dstSect->chunkToMAUIndex(dstChunk), 
                                dstSpace);
                                                      
                            DataAddressDef* newDataDef = 
                                new DataAddressDef(
                                    startAddr, mauSize, dstAddr,
                                    prog.targetProcessor().isLittleEndian());
 
                            newDataMem->addDataDefinition(newDataDef);
                            
                        }                                                
                    }
                }
                
                // ----- create all the rest of the init data
 
                // find start and end addresses of current section
                std::pair<int, int> wholeSection(currSect->startingAddress(),
                                                 currSect->lengthInMAUs());
 
                std::vector<std::pair <int, int> > dataAreas;                
                dataAreas.push_back(wholeSection);
 
                // split area if there is some data area definitions in the
                // same addresses with current section
                for (int k = 0; k < newDataMem->dataDefinitionCount(); k++) {
                    DataDefinition& currDef = newDataMem->dataDefinition(k);
 
                    int prevIndex = dataAreas.size()-1;
                    std::pair<int, int>& lastArea = dataAreas[prevIndex];
 
                    // if data definition is inside this section, it splits 
                    // the last data area definition
                    if (static_cast<int>(currDef.startAddress().location()) >= 
                        lastArea.first && 
                        static_cast<int>(currDef.startAddress().location()) < 
                        lastArea.first + lastArea.second) {
                        
                        int lastAreaStart = lastArea.first;
                        int lastAreaEnd = currDef.startAddress().location();
 
                        int newAreaStart = 
                            currDef.startAddress().location() + 
                            currDef.size();
 
                        int newAreaEnd = lastArea.first + lastArea.second;
 
                        // new area starts after this data definition
                        std::pair<int, int> newArea(
                            newAreaStart, newAreaEnd - newAreaStart);
                        
                        // if the last area is no area anymore
                        lastArea.second = lastAreaEnd - lastAreaStart;
                        
                        if (lastArea.second == 0) {
                            dataAreas.pop_back();
                        }
                        
                        if (newArea.second != 0) {
                            dataAreas.push_back(newArea);
                        }
                    }
                }
                
                DataSection* dataSect = dynamic_cast<DataSection*>(currSect);
                assert(dataSect != NULL);
 
                // write out collected initialized data areas
                for (unsigned int k = 0; k < dataAreas.size(); k++) {
 
                    std::pair<int, int>& currArea = dataAreas[k];
                    std::vector<MinimumAddressableUnit> initData;
                    
                    int mauIndex = 
                        currArea.first - currSect->startingAddress();
 
                    assert(mauIndex >= 0);
 
                    assert(mauIndex + currArea.second <= 
                           static_cast<int>(currSect->lengthInMAUs()));
 
                    bool allZeros = true;
                    for (int l = 0; l < currArea.second; l++) {
                        if(dataSect->MAU(mauIndex + l) != 0) {
                            allZeros = false;
                        }
                    }
 
                    DataDefinition* newDataDef = NULL;
 
                    if (allZeros) {
                        newDataDef = new DataDefinition(
                            Address(currArea.first, aSpace),
                            currArea.second,
                            prog.targetProcessor().isLittleEndian(),
                            NULL, true);
                    } else {
                        for (int l = 0; l < currArea.second; l++) {
                            initData.push_back(dataSect->MAU(mauIndex++));
                        }
                    
                        newDataDef = new DataDefinition(
                            Address(currArea.first, aSpace),
                            initData, prog.targetProcessor().isLittleEndian());
                    }
                    
                    newDataMem->addDataDefinition(newDataDef);
                }
            }
        }
        
        prog.addDataMemory(newDataMem);                
    }
}

References TTAProgram::DataMemory::addDataDefinition(), TTAProgram::Program::addDataMemory(), adfInstrASpace_, TPEF::RelocElement::aSpace(), TPEF::Section::aSpace(), assert, TPEF::RawSection::belongsToSection(), binary_, TPEF::RawSection::chunkToMAUIndex(), TTAProgram::DataMemory::dataDefinition(), TTAProgram::DataMemory::dataDefinitionCount(), TPEF::RelocElement::destination(), TPEF::Section::element(), TPEF::Section::elementCount(), TTAMachine::AddressSpace::end(), findAddressSpace(), instructionMap_, TTAProgram::Program::instructionReferenceManager(), TTAMachine::Machine::isLittleEndian(), TPEF::RawSection::lengthInMAUs(), TTAProgram::Address::location(), TPEF::RelocElement::location(), TPEF::DataSection::MAU(), TPEF::RelocSection::referencedSection(), TPEF::Binary::section(), TPEF::Binary::sectionCount(), TTAProgram::DataDefinition::size(), TPEF::RelocElement::size(), TPEF::Section::ST_DATA, TPEF::Section::ST_LEDATA, TPEF::Section::ST_RELOC, TPEF::Section::ST_UDATA, TTAProgram::DataDefinition::startAddress(), TPEF::Section::startingAddress(), TTAProgram::Program::targetProcessor(), TPEF::UDataSection::type(), TPEF::Section::type(), and TTAMachine::AddressSpace::width().

Referenced by build().

Here is the call graph for this function:

createDataRelocs()

void TTAProgram::TPEFProgramFactory::createDataRelocs ( Program &  prog )

protected

createInstruction()

Instruction * TTAProgram::TPEFProgramFactory::createInstruction ( const TPEF::ResourceSection &  resources, MoveVector &  moveElements, ImmediateVector &  longImmediates, ImmediateMap &  immElements  ) const

protected

Creates an instruction out of given moves and immediate elements.

Parameters

resources	TPEF resource section.
moveElements	Move elements of instruction.
longImemdiates	Long immediates of instruction.
immElements	Immediate elements of instruction.

Returns

A new instruction.

Definition at line 512 of file TPEFProgramFactory.cc.

                                     {
 
    std::vector<SocketAllocation> allocatedSockets;
 
    Instruction* newInstruction =
        new Instruction(NullInstructionTemplate::instance());
 
    for (unsigned int i = 0; i < moveElements.size(); i++) {
        MoveElement* move = moveElements[i];
 
        // NOTE: we just ignore empty moves
        if (!move->isEmpty()) {
            std::shared_ptr<TTAProgram::Move> newMove;
            Terminal* source = NULL;
            Terminal* destination = NULL;
            Terminal* guardRegister = NULL;
            MoveGuard* guard = NULL;
 
            // get bus
            Bus& bus = findBus(resources, move->bus());
 
            try {
                // create source terminal
                source = createTerminal(
                    resources, &bus, Socket::OUTPUT, move->sourceType(),
                    move->sourceUnit(), move->sourceIndex(), &immElements);
 
                // and destination terminal
                destination = createTerminal(
                    resources, &bus, Socket::INPUT, move->destinationType(),
                    move->destinationUnit(), move->destinationIndex());
 
                // create guard if move is guarded
                if (move->isGuarded()) {
 
                    Guard &adfGuard = findGuard(
                        resources,
                        bus,
                        move->guardType(),
                        move->guardUnit(),
                        move->guardIndex(),
                        move->isGuardInverted());
 
                    guard = new MoveGuard(adfGuard);
 
                    assert(guard != NULL);
                }
 
            } catch (const NotAvailable& e) {
 
                if (guard != NULL) {
                    delete guard;
                    guard = NULL;
 
                } else {
                    if (guardRegister != NULL) {
                        delete guardRegister;
                        guardRegister = NULL;
                    }
                }
 
                if (source != NULL) {
                    delete source;
                    source = NULL;
                }
 
                if (destination != NULL) {
                    delete destination;
                    destination = NULL;
                }
 
                delete newInstruction;
                newInstruction = NULL;
 
                throw e;
            } catch (Exception& e) {
                throw e;
            }
 
            if (guard != NULL) {
                newMove = std::make_shared<TTAProgram::Move>(source, destination, bus, guard);
            } else {
                newMove = std::make_shared<TTAProgram::Move>(source, destination, bus);
            }
            assert(newMove != NULL);
 
            // Add possible sockets for register references.
            Machine::SocketNavigator socketNav =
                bus.machine()->socketNavigator();
 
            SocketAllocation newAlloc(newMove, allocatedSockets.size());
 
            // find possible sockets for move source and destination
            for (int i = 0; i < socketNav.count(); i++) {
                Socket* currSocket = socketNav.item(i);
 
                if (currSocket->isConnectedTo(bus)) {
                    for (int j = 0; j < currSocket->portCount(); j++) {
 
                        if ((source->isGPR() ||
                             source->isImmediateRegister()) &&
                            currSocket->direction() == Socket::OUTPUT &&
                            currSocket->port(j)->parentUnit() ==
                            source->port().parentUnit()) {
 
                            newAlloc.srcSocks.push_back(currSocket);
                        }
 
                        if ((destination->isGPR() ||
                             destination->isImmediateRegister()) &&
                            currSocket->direction() == Socket::INPUT &&
                            currSocket->port(j)->parentUnit() ==
                            destination->port().parentUnit()) {
 
                            newAlloc.dstSocks.push_back(currSocket);
                        }
                    }
                }
            }
 
            allocatedSockets.push_back(newAlloc);
 
            // add move annotations
            if (move->annotationCount() > 0) {
                for (Word annotationIndex = 0; 
                     annotationIndex < move->annotationCount(); 
                     ++annotationIndex) {
                    newMove->addAnnotation(
                        ProgramAnnotation(
                            static_cast<ProgramAnnotation::Id>(
                                move->annotation(annotationIndex)->id()),
                            move->annotation(annotationIndex)->payload()));
                }
            }
 
            newInstruction->addMove(newMove);
 
            if (newMove->source().isAddress() &&
                &(newMove->source().address().space()) == adfInstrASpace_) {
                instructionImmediates_.push_back(newMove);
            }
        } else {
            // empty instruction
 
            // add move annotations
            if (move->annotationCount() > 0) {
                for (Word annotationIndex = 0;
                     annotationIndex < move->annotationCount();
                     ++annotationIndex) {
                    newInstruction->addAnnotation(
                        ProgramAnnotation(
                            static_cast<ProgramAnnotation::Id>(
                                move->annotation(annotationIndex)->id()),
                            move->annotation(annotationIndex)->payload()));
                }
            }
 
        }
    }
 
    // get template
    InstructionTemplate& instrTemplate =
        findInstrTemplate(resources, longImmediates, moveElements);
 
    newInstruction->setInstructionTemplate(instrTemplate);
 
    // and add long immediates
    for (unsigned int i = 0; i < longImmediates.size(); i++) {
        ImmediateElement* imm = longImmediates[i];
        Byte iUnitID = imm->destinationUnit();
 
        Terminal* destination = createTerminal(
            resources, NULL, Socket::INPUT,
            MoveElement::MF_IMM, iUnitID, imm->destinationIndex());
 
        ImmediateUnit& immUnit(findImmediateUnit(resources, iUnitID));
        SimValue simVal(instrTemplate.supportedWidth(immUnit));
 
        if (immUnit.signExtends()) {
            simVal = imm->sLongWord();
        } else {
            simVal = imm->longWord();
        }
 
        TerminalImmediate* immTerm = NULL;
 
        // TODO: refactor with createTerminal method's line 57
        bool isInstructionReference = false;
 
        if (tpefTools_.hasRelocation(*imm)) {
            const RelocElement &reloc = tpefTools_.relocation(*imm);
 
            // check if instruction address space
            if (tpefInstrASpace_ == reloc.aSpace()) {
                // create temporary TerminalAddress and add to vector
                // for late replacement
                immTerm = new TerminalAddress(simVal, *adfInstrASpace_);
 
                isInstructionReference = true;
 
            } else {
                AddressSpace& adfDataSpace =
                    findAddressSpace(reloc.aSpace());
                immTerm =
                    new TerminalAddress(simVal, adfDataSpace);
            }
 
        } else {
            immTerm = new TerminalImmediate(simVal);
        }
 
        auto newImmediate = std::make_shared<Immediate>(immTerm, destination);
 
        newInstruction->addImmediate(newImmediate);
 
        if (isInstructionReference) {
            longInstructionImmediates_.push_back(newImmediate);
        }
    }
 
    resolveSocketAllocations(allocatedSockets);
    return newInstruction;
}

References TTAProgram::AnnotatedInstructionElement::addAnnotation(), TTAProgram::Instruction::addImmediate(), TTAProgram::Instruction::addMove(), adfInstrASpace_, TPEF::InstructionElement::annotation(), TPEF::InstructionElement::annotationCount(), TPEF::RelocElement::aSpace(), assert, TPEF::MoveElement::bus(), TTAMachine::Machine::Navigator< ComponentType >::count(), createTerminal(), TPEF::ImmediateElement::destinationIndex(), TPEF::MoveElement::destinationIndex(), TPEF::MoveElement::destinationType(), TPEF::ImmediateElement::destinationUnit(), TPEF::MoveElement::destinationUnit(), TTAMachine::Socket::direction(), TTAProgram::TPEFProgramFactory::SocketAllocation::dstSocks, findAddressSpace(), findBus(), findGuard(), findImmediateUnit(), findInstrTemplate(), TPEF::MoveElement::guardIndex(), TPEF::MoveElement::guardType(), TPEF::MoveElement::guardUnit(), TPEF::TPEFTools::hasRelocation(), TPEF::InstructionAnnotation::id(), TTAMachine::Socket::INPUT, TTAMachine::NullInstructionTemplate::instance(), instructionImmediates_, TTAMachine::Socket::isConnectedTo(), TPEF::MoveElement::isEmpty(), TTAProgram::Terminal::isGPR(), TPEF::MoveElement::isGuarded(), TPEF::MoveElement::isGuardInverted(), TTAProgram::Terminal::isImmediateRegister(), TTAMachine::Machine::Navigator< ComponentType >::item(), longInstructionImmediates_, TPEF::ImmediateElement::longWord(), TTAMachine::Component::machine(), TPEF::MoveElement::MF_IMM, TTAMachine::Socket::OUTPUT, TTAMachine::Port::parentUnit(), TPEF::InstructionAnnotation::payload(), TTAProgram::Terminal::port(), TTAMachine::Socket::port(), TTAMachine::Socket::portCount(), TPEF::TPEFTools::relocation(), resolveSocketAllocations(), TTAProgram::Instruction::setInstructionTemplate(), TTAMachine::ImmediateUnit::signExtends(), TPEF::ImmediateElement::sLongWord(), TTAMachine::Machine::socketNavigator(), TPEF::MoveElement::sourceIndex(), TPEF::MoveElement::sourceType(), TPEF::MoveElement::sourceUnit(), TTAProgram::TPEFProgramFactory::SocketAllocation::srcSocks, TTAMachine::InstructionTemplate::supportedWidth(), tpefInstrASpace_, and tpefTools_.

Referenced by addProcedures().

createLabels()

void TTAProgram::TPEFProgramFactory::createLabels ( Program &  prog )

protected

Adds global labels of TPEF to Program.

Parameters

prog	Program where to add labels.

prevent addition of local symbol with same name multiple times

prevent addition of local symbol with same name multiple times

Definition at line 2036 of file TPEFProgramFactory.cc.

                                              {
    /// prevent addition of local symbol with same name multiple times    
    std::map<string, std::pair<DataLabel*, bool> > dataLabels;
 
    for (Word i = 0; i < binary_->sectionCount(Section::ST_SYMTAB); i++) {
 
        SymbolSection* currSect = dynamic_cast<SymbolSection*>(
            binary_->section(Section::ST_SYMTAB, i));
 
        assert(currSect != NULL);
 
        StringSection* strings =
            dynamic_cast<StringSection*>(currSect->link());
 
        assert(strings != NULL);
 
        for (Word j = 0; j < currSect->elementCount(); j++) {
            SymbolElement* sym =
                dynamic_cast<SymbolElement*>(currSect->element(j));
 
            // read all local and global data labels 
            if (sym->type() == SymbolElement::STT_DATA) {
 
                DataSymElement* dataSym =
                    dynamic_cast<DataSymElement*>(sym);
                
                const std::string labelString = 
                    strings->chunk2String(dataSym->name());
 
                UDataSection* dataSection = dynamic_cast<UDataSection*>(
                    dataSym->section());
                
                assert(dataSection != NULL);
 
                TTAMachine::AddressSpace* targetASpace = NULL;
                try {
                    targetASpace = 
                        &findAddressSpace(dataSection->aSpace());
                } catch (const NotAvailable& e) {
                    NotAvailable newException(
                        __FILE__, __LINE__, __func__, 
                        (boost::format(
                            "Unable to find address space for target "
                            "of data label '%s'") % labelString).str());
                    newException.setCause(e);
                    throw newException;                        
                }
                                
                Address refAddress(
                    dataSection->bytesToMAUs(
                        dataSym->reference()->offset()) +
                    dataSection->startingAddress(),
                    *targetASpace);
 
                DataLabel* dataLabel = new DataLabel(
                    labelString, refAddress, prog.globalScope());
 
// nice debug info
//          std::cerr << "Added data label\t"
//                <<"\tname: " << dataLabel->name()
//                << "\taddress: " 
//                << Conversion::toString(dataLabel->address().location())
//                << std::endl;
                                
                // check if label name is already used
                if (MapTools::containsKey(dataLabels, labelString)) {
                    
                    // if latest is global remove old one
                    if (sym->binding() == SymbolElement::STB_GLOBAL) {
                        
                        // if there is two global symbols with same name 
                        // throw exception
                        if (dataLabels[labelString].second) {
 
                            // free reserved labels
                            for (std::map<string, 
                                     std::pair<DataLabel*, 
                                     bool> >::iterator iter = 
                                     dataLabels.begin();
                                 iter != dataLabels.end(); iter++) {
                                delete (*iter).second.first;
                            }
                            delete dataLabel;
 
                            throw NotAvailable(
                                __FILE__, __LINE__, __func__,
                                "Found two global symbols with same name: " + 
                                labelString);
                        }
                        
                        delete dataLabels[labelString].first;
                        dataLabels[labelString].first = dataLabel;
                        dataLabels[labelString].second = true;
                    }
                } else {
                    // add symbol first time
                    dataLabels[labelString].first = dataLabel;
                    dataLabels[labelString].second = 
                        (sym->binding() == SymbolElement::STB_GLOBAL);
                }
                
                // Global code labels
            } else if (sym->binding() == SymbolElement::STB_GLOBAL && 
                       sym->type() == SymbolElement::STT_CODE) {
 
                CodeSymElement* codeSym =
                        dynamic_cast<CodeSymElement*>(sym);
 
                    assert(MapTools::containsKey(
                        instructionMap_, codeSym->reference()));
 
                    InstructionReference refIns =
                        prog.instructionReferenceManager().createReference(
                            *instructionMap_[codeSym->reference()]);
 
                    CodeLabel* newLabel =
                        new CodeLabel(refIns,
                                      strings->chunk2String(sym->name()));
 
                    prog.globalScope().addCodeLabel(newLabel);
            }
        }
    }
 
    // Add symbols to program
    /// prevent addition of local symbol with same name multiple times    
    for (std::map<string, std::pair<DataLabel*, bool> >::iterator iter =  
             dataLabels.begin();
         iter != dataLabels.end(); iter++) {
 
        prog.globalScope().addDataLabel((*iter).second.first);
    }
}

References __func__, TTAProgram::Scope::addCodeLabel(), TTAProgram::Scope::addDataLabel(), TPEF::Section::aSpace(), assert, binary_, TPEF::SymbolElement::binding(), TPEF::RawSection::bytesToMAUs(), TPEF::StringSection::chunk2String(), MapTools::containsKey(), TTAProgram::InstructionReferenceManager::createReference(), TPEF::Section::element(), TPEF::Section::elementCount(), findAddressSpace(), TTAProgram::Program::globalScope(), instructionMap_, TTAProgram::Program::instructionReferenceManager(), TPEF::Section::link(), TPEF::SymbolElement::name(), TPEF::Chunk::offset(), TPEF::CodeSymElement::reference(), TPEF::DataSymElement::reference(), TPEF::SymbolElement::section(), TPEF::Binary::section(), TPEF::Binary::sectionCount(), Exception::setCause(), TPEF::Section::ST_SYMTAB, TPEF::Section::startingAddress(), TPEF::SymbolElement::STB_GLOBAL, TPEF::SymbolElement::STT_CODE, TPEF::SymbolElement::STT_DATA, and TPEF::SymbolElement::type().

Referenced by build().

Here is the call graph for this function:

createTerminal()

Terminal * TTAProgram::TPEFProgramFactory::createTerminal ( const TPEF::ResourceSection &  resources, const TTAMachine::Bus *  aBus, TTAMachine::Socket::Direction  direction, TPEF::MoveElement::FieldType  type, HalfWord  unitId, HalfWord  index, const ImmediateMap *  immediateMap = NULL  ) const

protected

Creates a move terminal of the appropriate type for given input data.

This method cannot be used for creating terminal for immediate unit or register file registers.

Parameters

resources	TPEF resource section.
aBus	Bus to which terminal is connected.
direction	Read or write terminal.
type	TPEF type of terminal.
unitId	TPEF identification code of the unit to which terminal belongs.
index	Register or operation terminal index, or immediate identifier.
immediateMap	All immediates of currently created instruction.

Returns

A new move terminal.

Definition at line 759 of file TPEFProgramFactory.cc.

                                                            {
 
    // omit caching because RF and IMM unit ports are resolved later
    if (type == MoveElement::MF_RF) {
        // port(0) just a dummy temporary assignment, it may even be illegal
        RegisterFile& registerFile = findRegisterFile(resources, unitId);
        return new TerminalRegister(*registerFile.port(0), index);
 
    } else if (type == MoveElement::MF_IMM &&
               unitId != ResourceElement::INLINE_IMM) {
 
        // port(0) just a dummy temporary assignment, it may even be illegal
        ImmediateUnit& immUnit = findImmediateUnit(resources, unitId);
        return new TerminalRegister(*immUnit.port(0), index);
    }
 
    CacheKey cacheKey(*aBus, direction, type, unitId, index);
 
    Terminal* returnValue = getFromCache(cacheKey);
 
    if (returnValue == NULL) {
 
        switch (type) {
 
        case MoveElement::MF_IMM: {
            ImmediateKey immKey(unitId, index);
            ImmediateElement* imm = NULL;
 
            if (MapTools::containsKey(*immediateMap, immKey)) {
                imm = MapTools::valueForKey<ImmediateElement*>(
                    *immediateMap, immKey);
            } else {
                Application::logStream()
                    << "Cannot find immediate with unitId/index "
                    << static_cast<int>(unitId) << "/" << index << std::endl
                    << "immediateMap.size(): " << immediateMap->size()
                    << std::endl;
                Application::abortProgram();
            }
 
            if (imm->isInline()) {
 
                int immWidth = aBus->immediateWidth();
                SimValue simValue(immWidth);
                simValue = imm->longWord();
                                
                // TODO: refactor with line createInstruction 
                //       method's line 158
                if (tpefTools_.hasRelocation(*imm)) {
                    const RelocElement &reloc = tpefTools_.relocation(*imm);
 
                    // check if instruction address space
                    if (tpefInstrASpace_ == reloc.aSpace()) {
                        // create temporary TerminalAddress and add to vector
                        // for late replacement
                        returnValue =
                            new TerminalAddress(simValue, *adfInstrASpace_);
 
                    } else {
                        try {
                            AddressSpace& adfDataSpace =
                                findAddressSpace(reloc.aSpace());
                            returnValue =
                                new TerminalAddress(simValue, adfDataSpace);
                        } catch (const NotAvailable& e) {
                            NotAvailable newException(
                                __FILE__, __LINE__, __func__, 
                                (boost::format(
                                    "Unable to find address space for "
                                    "target of reloc element for immediate "
                                    "'%d'.") % imm->word()).
                                str());
                            newException.setCause(e);
                            throw newException;                        
                        }                        
                    }
 
                } else {
                    returnValue = new TerminalImmediate(simValue);
                }
                TTAProgram::TerminalImmediate* retVal =
                    dynamic_cast<TerminalImmediate*>(returnValue);
                assert(returnValue != NULL);
                // add immediate annotations
                if (imm->annotationCount() > 0) {
                    for (Word annotationIndex = 0; 
                         annotationIndex < imm->annotationCount(); 
                         ++annotationIndex) {
                        retVal->addAnnotation(
                            ProgramAnnotation(
                                static_cast<ProgramAnnotation::Id>(
                                    imm->annotation(annotationIndex)->id()),
                                imm->annotation(annotationIndex)->payload()));
                    }
                }
                
            } else {
                abortWithError("Error: immediate register references "
                               "should be already handled in same place "
                               "with normal register references.");
            }
        } break;
 
        case MoveElement::MF_UNIT: {
            ResourceElement* tpefResource = NULL;
 
            // TODO refactor
            if (resources.hasResource(
                    ResourceElement::MRT_OP, index)) {
 
                tpefResource =
                    &resources.findResource(ResourceElement::MRT_OP, index);
 
            } else if (resources.hasResource(
                           ResourceElement::MRT_PORT, index)) {
 
                tpefResource =
                    &resources.findResource(ResourceElement::MRT_PORT, index);
 
            } else if (resources.hasResource(
                           ResourceElement::MRT_SR, index)) {
 
                tpefResource =
                    &resources.findResource(ResourceElement::MRT_SR, index);
 
            } else {
                abortWithError("Can't find resource port, operation or "
                               "special register with index:" +
                               Conversion::toString(index));
 
            }
 
            assert(tpefResource != NULL);
 
            std::string tpefOpStr =
                stringOfChunk(tpefResource->name(), resources.link());
 
            // TODO:
            // I need only unit.port and unit.operation.index parsing since
            // unit.port.opcode references are converted to
            // unit.operation.index form in tpef
 
            // NOTE:
            // for now parser can chop just add.1 and sub.3 etc. kind of
            // strings.
 
            // start of hack parser
            bool opCodePort = false;
            std::string::size_type opNameLength = tpefOpStr.rfind('.');
            std::string tpefOpName = tpefOpStr;
            int tpefOpIndex = 0;
 
            if (opNameLength != std::string::npos) {
                tpefOpName = tpefOpStr.substr(0, opNameLength);
                std::string::size_type opIndexStart = opNameLength + 1;
                std::string tpefOpIndexStr =
                    tpefOpStr.substr(
                        opIndexStart, tpefOpStr.length() - opIndexStart);
                tpefOpIndex = Conversion::toInt(tpefOpIndexStr);
                opCodePort = true;
            }
            // end of hack parser
 
            // returns normal fu or universal fu or universal gcu..
            FunctionUnit& functionUnit =
                findFunctionUnit(resources, unitId, tpefOpName);
 
            if (opCodePort) {
                // find HWOperation....
                HWOperation& oper = *functionUnit.operation(tpefOpName);
                returnValue = new TerminalFUPort(oper, tpefOpIndex);
 
            } else {
                // special register or plain port reference
                BaseFUPort& port = dynamic_cast<BaseFUPort&>(
                    findPort(*aBus, functionUnit, tpefOpName));
 
                returnValue = new TerminalFUPort(port);
            }
        } break;
 
        default: {
            abortWithError("Unknown move field type!");
        }
 
        }
 
        // immediates are not cached...
        if (type != MoveElement::MF_IMM) {
            addToCache(cacheKey, returnValue);
        }
 
    } else {
        return returnValue->copy();
    }
 
    return returnValue;
}

References __func__, Application::abortProgram(), abortWithError, TTAProgram::AnnotatedInstructionElement::addAnnotation(), addToCache(), adfInstrASpace_, TPEF::InstructionElement::annotation(), TPEF::InstructionElement::annotationCount(), TPEF::RelocElement::aSpace(), assert, MapTools::containsKey(), TTAProgram::Terminal::copy(), findAddressSpace(), findFunctionUnit(), findImmediateUnit(), findPort(), findRegisterFile(), TPEF::ResourceSection::findResource(), getFromCache(), TPEF::TPEFTools::hasRelocation(), TPEF::ResourceSection::hasResource(), TPEF::InstructionAnnotation::id(), TTAMachine::Bus::immediateWidth(), TPEF::ResourceElement::INLINE_IMM, TPEF::ImmediateElement::isInline(), MapTools::keyForValue(), TPEF::Section::link(), Application::logStream(), TPEF::ImmediateElement::longWord(), TPEF::MoveElement::MF_IMM, TPEF::MoveElement::MF_RF, TPEF::MoveElement::MF_UNIT, TPEF::ResourceElement::MRT_OP, TPEF::ResourceElement::MRT_PORT, TPEF::ResourceElement::MRT_SR, TPEF::ResourceElement::name(), TTAMachine::FunctionUnit::operation(), TPEF::InstructionAnnotation::payload(), TTAMachine::BaseRegisterFile::port(), TPEF::TPEFTools::relocation(), Exception::setCause(), stringOfChunk(), Conversion::toInt(), Conversion::toString(), tpefInstrASpace_, tpefTools_, and TPEF::ImmediateElement::word().

Referenced by createInstruction().

Here is the call graph for this function:

findAddressSpace()

TTAMachine::AddressSpace & TTAProgram::TPEFProgramFactory::findAddressSpace ( const TPEF::ASpaceElement *  aSpace ) const

protected

Finds address space by name.

Parameters

Name	of address space.

Returns

Address space.

Exceptions

NotAvailable

if requested address space does not belong to the target architecture.

Definition at line 1333 of file TPEFProgramFactory.cc.

                                                                      {
 
    std::string aSpaceName = tpefTools_.addressSpaceName(*aSpace);
 
    if (machine_ != NULL) {
        Machine::AddressSpaceNavigator aSpaceNavi =
            machine_->addressSpaceNavigator();
 
        if (aSpaceNavi.hasItem(aSpaceName)) {
            return *aSpaceNavi.item(aSpaceName);
        }
    }
 
    if (universalMachine_ != NULL) {
        if (aSpaceName == universalMachine_->dataAddressSpace().name()) {
            return universalMachine_->dataAddressSpace();
        } else if (aSpaceName == 
                   universalMachine_->instructionAddressSpace().name()) {
            return universalMachine_->instructionAddressSpace();
            
        }
    }
 
    throw NotAvailable(
        __FILE__, __LINE__, __func__,
        "Can't find address space by name: " + aSpaceName +
        " MAU: " + Conversion::toString(static_cast<int>(aSpace->MAU())));
}

References __func__, TPEF::TPEFTools::addressSpaceName(), TTAMachine::Machine::addressSpaceNavigator(), UniversalMachine::dataAddressSpace(), TTAMachine::Machine::Navigator< ComponentType >::hasItem(), UniversalMachine::instructionAddressSpace(), TTAMachine::Machine::Navigator< ComponentType >::item(), machine_, TPEF::ASpaceElement::MAU(), TTAMachine::Component::name(), Conversion::toString(), tpefTools_, and universalMachine_.

Referenced by createDataMemories(), createInstruction(), createLabels(), and createTerminal().

Here is the call graph for this function:

findBus()

Bus & TTAProgram::TPEFProgramFactory::findBus ( const TPEF::ResourceSection &  resources, HalfWord  busId  ) const

protected

Returns the bus of real or universal machine with the given bus identification number, as found in TPEF.

Parameters

resources	The resource section where the bus should be searched.
busId	Id of requested bus.

Returns

Requested bus.

Exceptions

NotAvailable

if requested bus does not belong to the target architecture.

Definition at line 972 of file TPEFProgramFactory.cc.

                          {
 
    if (busId == ResourceElement::UNIVERSAL_BUS) {
        if (universalMachine_ == NULL) {
            throw NotAvailable(
                __FILE__, __LINE__, __func__,
                "TPEF needs universal machine for universal bus reference.");
        }
 
        return universalMachine_->universalBus();
 
    } else {
        if (machine_ == NULL) {
            throw NotAvailable(
                __FILE__, __LINE__, __func__,
                "TPEF needs real machine for non-universal bus reference.");
        }
 
        // internal error with TPEF...
        assert(resources.hasResource(ResourceElement::MRT_BUS, busId));
 
        ResourceElement &tpefBus =
            resources.findResource(ResourceElement::MRT_BUS, busId);
 
        std::string busName =
            stringOfChunk(tpefBus.name(), resources.link());
 
        if (!machine_->busNavigator().hasItem(busName)) {
            throw NotAvailable(
                __FILE__, __LINE__, __func__,
                "ADF does not contain bus: " + busName);
        }
 
        return *(machine_->busNavigator().item(busName));
    }
}

References __func__, assert, TTAMachine::Machine::busNavigator(), TPEF::ResourceSection::findResource(), TTAMachine::Machine::Navigator< ComponentType >::hasItem(), TPEF::ResourceSection::hasResource(), TTAMachine::Machine::Navigator< ComponentType >::item(), TPEF::Section::link(), machine_, TPEF::ResourceElement::MRT_BUS, TPEF::ResourceElement::name(), stringOfChunk(), TPEF::ResourceElement::UNIVERSAL_BUS, UniversalMachine::universalBus(), and universalMachine_.

Referenced by createInstruction(), and findInstrTemplate().

Here is the call graph for this function:

findFunctionUnit()

FunctionUnit & TTAProgram::TPEFProgramFactory::findFunctionUnit ( const TPEF::ResourceSection &  resources, HalfWord  unitId, std::string  tpefOpName = ""  ) const

protected

Returns FunctionUnit by TPEF identification number and operation name.

If function unit ID corresponds to the universal function unit, then operation name is checked to see if we should return universal gcu or universal fu.

If operation name is special register of function unit or if operation name is operation of gcu then universal gcu is returned.

Parameters

resources	The resource section where the bus should be searched.
unitId	Id of requested unit.
tpefOpName	Name of operation or special register for universal machine resources.

Returns

Function unit from real or universal machine.

Exceptions

NotAvailable

if requested function unit does not belong to the target architecture.

Definition at line 1143 of file TPEFProgramFactory.cc.

                                {
 
    switch (unitId) {
 
    case ResourceElement::UNIVERSAL_FU: {
 
        if (universalMachine_ == NULL) {
            throw NotAvailable(
                __FILE__, __LINE__, __func__,
                "TPEF needs universal machine for getting universal FU.");
        }
 
        FunctionUnit* gcu = universalMachine_->controlUnit();
 
        assert(gcu != NULL);
 
        if (tpefOpName == ResourceElement::RETURN_ADDRESS_NAME) {
            return *gcu;
        }
 
        FunctionUnit* fu  = &universalMachine_->universalFunctionUnit();
        assert(fu != NULL);
 
        if (gcu->hasOperation(tpefOpName)) {
            return *gcu;
 
        } else if (fu->hasOperation(tpefOpName)) {
            return *fu;
 
        } else {
            boost::format errMsg(
                "Unknown operation '%1%'. Operation definition not found.");
            throw NotAvailable(
                __FILE__, __LINE__, __func__, (errMsg % tpefOpName).str());
        }
    }
 
    default: {
 
        if (machine_ == NULL) {
            throw NotAvailable(__FILE__, __LINE__, __func__,
                "TPEF needs real target architecture for getting a "
                "non-universal FU.");
        }
 
        ResourceElement &tpefFU = resources.findResource(
        ResourceElement::MRT_UNIT, unitId);
 
        std::string fuName =
            stringOfChunk(tpefFU.name(), resources.link());
 
        if (machine_->functionUnitNavigator().hasItem(fuName)) {
            return *(machine_->functionUnitNavigator().item(fuName));
 
        } else {
 
            // maybe it's GCU ..
            if (machine_->controlUnit()->name() == fuName) {
                return *machine_->controlUnit();
 
            } else {
                throw NotAvailable(
                    __FILE__, __LINE__, __func__,
                    "Can't  find RFU \"" + fuName + "\" from ADF.");
            }
        }
    }
 
    }
 
    abortWithError("This line should never be run!");
    return universalMachine_->universalFunctionUnit();
}

References __func__, abortWithError, assert, TTAMachine::Machine::controlUnit(), TPEF::ResourceSection::findResource(), TTAMachine::Machine::functionUnitNavigator(), TTAMachine::Machine::Navigator< ComponentType >::hasItem(), TTAMachine::FunctionUnit::hasOperation(), TTAMachine::Machine::Navigator< ComponentType >::item(), TPEF::Section::link(), machine_, TPEF::ResourceElement::MRT_UNIT, TTAMachine::Component::name(), TPEF::ResourceElement::name(), TPEF::ResourceElement::RETURN_ADDRESS_NAME, stringOfChunk(), TPEF::ResourceElement::UNIVERSAL_FU, UniversalMachine::universalFunctionUnit(), and universalMachine_.

Referenced by createTerminal(), and findGuard().

Here is the call graph for this function:

findGuard()

TTAMachine::Guard & TTAProgram::TPEFProgramFactory::findGuard ( const TPEF::ResourceSection &  resources, TTAMachine::Bus &  bus, TPEF::MoveElement::FieldType  type, HalfWord  unitId, HalfWord  index, bool  isInverted  ) const

protected

Finds guard of bus.

Parameters

resources	TPEF resource section.
bus	Bus of guard.
type	Is fu or register guard.
unitId	Id of the unit that contains guard register or port.
index	Register or operand index of guard.
isInverted	Is inverted guard.

Definition at line 1373 of file TPEFProgramFactory.cc.

                                                            {
 
    RegisterFile* guardRF = NULL;
    Port* guardPort = NULL;
 
    // find corresponding function unit or register file.
    switch (type) {
    case TPEF::MoveElement::MF_UNIT: {
        FunctionUnit &guardUnit = findFunctionUnit(resources, unitId);
 
        // find port
        ResourceElement* resource = NULL;
 
        // TODO refactor
        if (resources.hasResource(
                ResourceElement::MRT_OP, index)) {
 
            resource =
                &resources.findResource(ResourceElement::MRT_OP, index);
 
        } else if (resources.hasResource(
                       ResourceElement::MRT_PORT, index)) {
 
            resource =
                &resources.findResource(ResourceElement::MRT_PORT, index);
 
        } else if (resources.hasResource(
                       ResourceElement::MRT_SR, index)) {
 
            resource =
                &resources.findResource(ResourceElement::MRT_SR, index);
 
        } else {
            abortWithError("Can't find resource port, operation or "
                           "special register with index:" +
                           Conversion::toString(index));
 
        }
 
 
        std::string tpefOpStr =
            stringOfChunk(resource->name(), resources.link());
 
        // find operation port or special register port
        if (guardUnit.hasPort(tpefOpStr)) {
            guardPort = guardUnit.port(tpefOpStr);
 
        } else {
            std::string::size_type dotPos = tpefOpStr.find('.');
            assert (dotPos != std::string::npos);
            std::string operationName = tpefOpStr.substr(0, dotPos);
            HWOperation* oper = guardUnit.operation(operationName);
            Word operandIndex = Conversion::toInt(
                tpefOpStr.substr(dotPos+1, tpefOpStr.length() - dotPos - 1));
 
            guardPort = oper->port(operandIndex);
        }
    } break;
 
    case TPEF::MoveElement::MF_RF:
        guardRF = &findRegisterFile(resources, unitId);
        break;
 
    default:
        abortWithError(
            "Error: Unknown guard type. Guard must be either FU port "
            "or RF index.");
    }
 
    assert (reinterpret_cast<long int>(guardPort) != 
            reinterpret_cast<long int>(guardRF));
 
    for (int i = 0; i < bus.guardCount(); i++) {
        Guard* currGuard = bus.guard(i);
 
        if (currGuard->isInverted() == isInverted) {
            PortGuard* portGuard = dynamic_cast<PortGuard*>(currGuard);
            RegisterGuard* registerGuard =
                dynamic_cast<RegisterGuard*>(currGuard);
 
            if (portGuard != NULL && guardPort != NULL) {
                if (portGuard->port() == guardPort) {
                    return *currGuard;
                }
 
            } else if (registerGuard != NULL && guardRF != NULL) {
                if (registerGuard->registerFile() == guardRF &&
                    registerGuard->registerIndex() == index) {
                    return *currGuard;
                }
            }
        }
    }
 
    std::string guardType;
    if (isInverted) {
        guardType = "! ";
    } else {
        guardType = "? ";
    }
 
    if (guardRF != NULL) {
        guardType += guardRF->name()  + "." + Conversion::toString(index);
    }
 
    if (guardPort != NULL) {
        guardType += "Some FU operation or special register.";
    }
 
    throw NotAvailable(
        __FILE__, __LINE__, __func__,
        "Can't find suitable guard: " + guardType + "\tfrom bus: " +
        bus.name());
 
    return *bus.guard(0);
}

References __func__, abortWithError, assert, findFunctionUnit(), findRegisterFile(), TPEF::ResourceSection::findResource(), TTAMachine::Bus::guard(), TTAMachine::Bus::guardCount(), TTAMachine::Unit::hasPort(), TPEF::ResourceSection::hasResource(), TTAMachine::Guard::isInverted(), TPEF::Section::link(), TPEF::MoveElement::MF_RF, TPEF::MoveElement::MF_UNIT, TPEF::ResourceElement::MRT_OP, TPEF::ResourceElement::MRT_PORT, TPEF::ResourceElement::MRT_SR, TTAMachine::Component::name(), TPEF::ResourceElement::name(), TTAMachine::FunctionUnit::operation(), TTAMachine::PortGuard::port(), TTAMachine::FunctionUnit::port(), TTAMachine::HWOperation::port(), TTAMachine::RegisterGuard::registerFile(), TTAMachine::RegisterGuard::registerIndex(), stringOfChunk(), Conversion::toInt(), and Conversion::toString().

Referenced by createInstruction().

Here is the call graph for this function:

findImmediateUnit()

ImmediateUnit & TTAProgram::TPEFProgramFactory::findImmediateUnit ( const TPEF::ResourceSection &  resources, Byte  immUnitId  ) const

protected

Returns ImmediateUnit by TPEF id number.

Parameters

resources	The resource section where the bus should be searched.
immUnitId	Id of requested immediate unit.

Returns

Immediate unit.

Exceptions

NotAvailable

if requested immediate unit does not belong to the target architecture.

Definition at line 1099 of file TPEFProgramFactory.cc.

                          {
 
    if (machine_ == NULL) {
        throw NotAvailable(
            __FILE__, __LINE__, __func__,
            "TPEF needs real machine for immediate unit reference.");
    }
 
    ResourceElement &tpefImmUnit =
        resources.findResource(ResourceElement::MRT_IMM, immUnitId);
 
    std::string immUnitName =
        stringOfChunk(tpefImmUnit.name(), resources.link());
 
    if (!machine_->immediateUnitNavigator().hasItem(immUnitName)) {
        throw NotAvailable(
            __FILE__, __LINE__, __func__,
            "Can't  find immediate unit \"" + immUnitName + "\" from ADF.");
    }
 
    return *(machine_->immediateUnitNavigator().item(immUnitName));
}

References __func__, TPEF::ResourceSection::findResource(), TTAMachine::Machine::Navigator< ComponentType >::hasItem(), TTAMachine::Machine::immediateUnitNavigator(), TTAMachine::Machine::Navigator< ComponentType >::item(), TPEF::Section::link(), machine_, TPEF::ResourceElement::MRT_IMM, TPEF::ResourceElement::name(), and stringOfChunk().

Referenced by createInstruction(), createTerminal(), and findInstrTemplate().

Here is the call graph for this function:

findInstrTemplate()

InstructionTemplate & TTAProgram::TPEFProgramFactory::findInstrTemplate ( const TPEF::ResourceSection &  resources, ImmediateVector &  longImmediates, MoveVector &  moves  ) const

protected

Returns instruction template that can be used for current instruction.

Parameters

resources	TPEF resource section.
longImmediates	Long immediates of instruction.
moves	Moves of instruction.

Returns

Instruction template that can be used for this instruction.

Definition at line 1502 of file TPEFProgramFactory.cc.

                             {
 
    if (machine_ == NULL) {
        assert(
            universalMachine_->instructionTemplateNavigator().count() == 1);
        return *universalMachine_->instructionTemplateNavigator().item(0);
    }
 
    // check how many bits must be written to each immediate unit....
    std::map<ImmediateUnit*, int> bitsToWrite;
 
    for (unsigned int i = 0; i < longImmediates.size(); i++) {
        ImmediateElement* imm = longImmediates[i];
 
        // destination unit
        ImmediateUnit* dstUnit =
            &findImmediateUnit(resources, imm->destinationUnit());
 
        if (MapTools::containsKey(bitsToWrite, dstUnit)) {
            throw NotAvailable(
                __FILE__, __LINE__, __func__,
                "Can't write two immediates to the same immediate unit "
                " in the same instruction.");
        } else {
            bitsToWrite[dstUnit] = dstUnit->zeroExtends() ?
                MathTools::requiredBits(imm->longWord()) :
                MathTools::requiredBitsSigned(imm->sLongWord());
        }
    }
 
    // find suitable template
    Machine::InstructionTemplateNavigator tempNav =
        machine_->instructionTemplateNavigator();
 
    // try to find an instruction template with the most NOP slots
    // to enhance the possible variable length encoding benefits 
    InstructionTemplate* bestiTempFound = NULL;
 
    for (int i = 0; i < tempNav.count(); i++) {
        InstructionTemplate* insTemp = tempNav.item(i);
 
        // check if numberOfDestinations is same that number of
        // immediates to write
        if (insTemp->numberOfDestinations() ==
            static_cast<int>(bitsToWrite.size())) {
 
            bool templateIsGood = true;
 
            // check that destinations and bitwidths match
            for (std::map<ImmediateUnit*, int>::iterator iter =
                     bitsToWrite.begin();
                 iter != bitsToWrite.end();
                 iter++) {
 
                if (!insTemp->isOneOfDestinations(*(*iter).first) ||
                    (*iter).second >
                    insTemp->supportedWidth(*(*iter).first)) {
                    templateIsGood = false;
                    break;
                }
            }
 
            // check if move slots allows to use this template
            if (templateIsGood) {
                for (unsigned int j = 0; j < moves.size(); j++) {
                    MoveElement* move = moves[j];
 
                    if (move->isEmpty()) {
                        continue;
                    }
 
                    Bus& usedBus = findBus(resources, move->bus());
 
                    // can be NOP slot also in which case the template cannot
                    // used for the move either
                    if (insTemp->usesSlot(usedBus.name())) {
                        templateIsGood = false;
                        break;
                    }
                }
            }
 
            // if template passed all the checks
            if (templateIsGood) {
                if (bestiTempFound == NULL)
                    bestiTempFound = insTemp;
            }
        }
    }
 
    if (bestiTempFound == NULL) {
        std::string bitRequirementmsg;
        for (const auto& pair : bitsToWrite) {
            bitRequirementmsg += Conversion::toString(pair.second)
                + " bits to IU: " + pair.first->name() + "\n";
        }
        THROW_EXCEPTION(NotAvailable,
            "Valid instruction template is not found for instruction layout:\n"
            + "An instruction template is needed that can write:\n"
            + bitRequirementmsg);
    } else {
        return *bestiTempFound;
    }
}

References __func__, assert, TPEF::MoveElement::bus(), MapTools::containsKey(), TTAMachine::Machine::Navigator< ComponentType >::count(), TPEF::ImmediateElement::destinationUnit(), findBus(), findImmediateUnit(), TTAMachine::Machine::instructionTemplateNavigator(), TPEF::MoveElement::isEmpty(), TTAMachine::InstructionTemplate::isOneOfDestinations(), TTAMachine::Machine::Navigator< ComponentType >::item(), TPEF::ImmediateElement::longWord(), machine_, TTAMachine::Component::name(), TTAMachine::InstructionTemplate::numberOfDestinations(), MathTools::requiredBits(), MathTools::requiredBitsSigned(), TPEF::ImmediateElement::sLongWord(), TTAMachine::InstructionTemplate::supportedWidth(), THROW_EXCEPTION, Conversion::toString(), universalMachine_, TTAMachine::InstructionTemplate::usesSlot(), and TTAMachine::ImmediateUnit::zeroExtends().

Referenced by createInstruction().

Here is the call graph for this function:

findPort()

Port & TTAProgram::TPEFProgramFactory::findPort ( const TTAMachine::Bus &  bus, const TTAMachine::Unit &  portParent, std::string  tpefOpName = "", int  tpefOpIndex = 0  ) const

protected

Finds any function unit or special register port from target architecture (possiby the universal machine).

NOTE: this is currently used only for plain port references (sr or port without opcode) if TPEFProgramFactory. However method should be able finding also function unit ports.

Parameters

bus	Bus where to socket is connected.
portParent	Parent to which port in connected to.
tpefOpName	Name of operation if opcode port to find.
tpefOpIndex	Terminal index of operation if opcode port to find.

Returns

Found port.

Exceptions

NotAvailable

if requested port does not belong to the target architecture.

Definition at line 1237 of file TPEFProgramFactory.cc.

                           {
 
    const Machine* machineOfBus = NULL;
 
    if (universalMachine_ != NULL &&
        &bus == &universalMachine_->universalBus()) {
        machineOfBus = universalMachine_;
    } else {
        machineOfBus = machine_;
    }
 
    assert(machineOfBus != NULL);
 
    // check if it is function unit port to find
    const FunctionUnit* fu =
        dynamic_cast<const FunctionUnit*>(&portParent);
 
    if (fu != NULL) {
 
        // check if known special register (for sequential code)
        if (tpefOpName == ResourceElement::RETURN_ADDRESS_NAME) {
 
            const ControlUnit &controlUnit =
                dynamic_cast<const ControlUnit&>(portParent);
 
            if (controlUnit.hasReturnAddressPort()) {
                return *(controlUnit.returnAddressPort());
 
            } else {
                throw NotAvailable(
                    __FILE__, __LINE__, __func__,
                    "GCU needs return address port.");
            }
 
        } else {
            // function unit is either gcu or real fu
 
            // if operation index is valid and opname is found from FU
            // then we know that it's port with opcode given
            if (fu->hasOperation(tpefOpName) && tpefOpIndex != 0) {
                // must be operation port
                HWOperation* oper = fu->operation(tpefOpName);
                return *(oper->port(tpefOpIndex));
 
            } else if (fu->hasPort(tpefOpName)) {
                // must be special plain port reference
                TTAMachine::SpecialRegisterPort* srPort =
                    dynamic_cast<TTAMachine::SpecialRegisterPort*>(
                        fu->port(tpefOpName));
 
                if (srPort != NULL) {
                    // NOTE: only known specialregister ports are allowed!
                    //       add asserts for special registers here :)
                    assert(srPort == 
                           machineOfBus->controlUnit()->returnAddressPort());
                    return *srPort;
                } else {
                    return *fu->port(tpefOpName);
                }
 
            } else {
                throw NotAvailable(
                    __FILE__, __LINE__, __func__, "Can't find port for: " +
                    fu->name() + "." + tpefOpName + "." +
                    Conversion::toString(tpefOpIndex));
            }
        }
    }
 
    // didn't seem to be fu port... this is not used for normal 
    // registers anymore...
 
    std::string throwError = "Can't find port for: " + portParent.name();
 
    if (tpefOpName != "") {
        throwError += "." + tpefOpName;
    }
 
    throwError += "." + Conversion::toString(tpefOpIndex);
 
    throw NotAvailable(__FILE__, __LINE__, __func__,throwError);
}

References __func__, assert, TTAMachine::Machine::controlUnit(), TTAMachine::FunctionUnit::hasOperation(), TTAMachine::Unit::hasPort(), TTAMachine::ControlUnit::hasReturnAddressPort(), machine_, TTAMachine::Component::name(), TTAMachine::FunctionUnit::operation(), TTAMachine::FunctionUnit::port(), TTAMachine::HWOperation::port(), TPEF::ResourceElement::RETURN_ADDRESS_NAME, TTAMachine::ControlUnit::returnAddressPort(), Conversion::toString(), UniversalMachine::universalBus(), and universalMachine_.

Referenced by createTerminal().

Here is the call graph for this function:

findRegisterFile()

RegisterFile & TTAProgram::TPEFProgramFactory::findRegisterFile ( const TPEF::ResourceSection &  resources, HalfWord  rfId  ) const

protected

Returns RegisterFile by TPEF id number.

Parameters

resources	The resource section where the bus should be searched.
rfId	Id of requested register file.

Returns

Register file from real or universal machine.

Exceptions

NotAvailable

if requested register file does not belong to the target architecture.

Definition at line 1021 of file TPEFProgramFactory.cc.

                         {
 
    switch (rfId) {
 
    case ResourceElement::ILLEGAL_RF:
        abortWithError("Illegal registerfile ID!");
 
    case ResourceElement::INT_RF:
        if (universalMachine_ == NULL) {
            throw NotAvailable(
                __FILE__, __LINE__, __func__,
                "TPEF needs universal machine for universal integer RF "
                "reference.");
        }
 
        return universalMachine_->integerRegisterFile();
 
    case ResourceElement::BOOL_RF:
        if (universalMachine_ == NULL) {
            throw NotAvailable(
                __FILE__, __LINE__, __func__,
                "TPEF needs universal machine for universal boolean RF "
                "reference.");
        }
 
        return universalMachine_->booleanRegisterFile();
 
    case ResourceElement::FP_RF:
        if (universalMachine_ == NULL) {
            throw NotAvailable(
                __FILE__, __LINE__, __func__,
                "TPEF needs universal machine for universal floating point "
                "RF reference.");
        }
 
        return universalMachine_->doubleRegisterFile();
 
    default: {
 
        if (machine_ == NULL) {
            throw NotAvailable(
                __FILE__, __LINE__, __func__,
                "TPEF needs real machine for non-universal RF reference.");
        }
 
        ResourceElement &tpefRF =
            resources.findResource(ResourceElement::MRT_RF, rfId);
 
        std::string rfName =
            stringOfChunk(tpefRF.name(), resources.link());
 
        if (!machine_->registerFileNavigator().hasItem(rfName)) {
            throw NotAvailable(
                __FILE__, __LINE__, __func__,
                "Can't  find RF \"" + rfName + "\" from ADF.");
        }
 
        return *(machine_->registerFileNavigator().item(rfName));
    }
 
    }
 
    abortWithError("This line should never be executed!");
    return universalMachine_->integerRegisterFile();
}

References __func__, abortWithError, TPEF::ResourceElement::BOOL_RF, UniversalMachine::booleanRegisterFile(), UniversalMachine::doubleRegisterFile(), TPEF::ResourceSection::findResource(), TPEF::ResourceElement::FP_RF, TTAMachine::Machine::Navigator< ComponentType >::hasItem(), TPEF::ResourceElement::ILLEGAL_RF, TPEF::ResourceElement::INT_RF, UniversalMachine::integerRegisterFile(), TTAMachine::Machine::Navigator< ComponentType >::item(), TPEF::Section::link(), machine_, TPEF::ResourceElement::MRT_RF, TPEF::ResourceElement::name(), TTAMachine::Machine::registerFileNavigator(), stringOfChunk(), and universalMachine_.

Referenced by createTerminal(), and findGuard().

Here is the call graph for this function:

functionName()

std::string TTAProgram::TPEFProgramFactory::functionName ( const TPEF::InstructionElement &  instructionElement ) const

protected

Returns name of function, that starts, from given instruction element.

Parameters

instructionElement

Starting element, of procedure.

Returns

Function name string.

Definition at line 2471 of file TPEFProgramFactory.cc.

                                                        {
    if (MapTools::containsKey(functionStartPositions_, &instructionElement)) {
        return MapTools::valueForKey<FunctionStart*>(
            functionStartPositions_, &instructionElement)->name();
    } else {
        return "unknownFunctionName";
    }
}

References MapTools::containsKey(), functionStartPositions_, and MapTools::keyForValue().

Referenced by addProcedures(), and seekFunctionStartPoints().

Here is the call graph for this function:

getFromCache()

Terminal * TTAProgram::TPEFProgramFactory::getFromCache ( const CacheKey &  key ) const

private

Returns cached terminal.

Parameters

key	Cache key of terminal.

Returns

Cached terminal if there is one, NULL otherwise.

Definition at line 1951 of file TPEFProgramFactory.cc.

                                                 {
 
    if (MapTools::containsKey(cache_,key)) {
        return MapTools::valueForKey<Terminal*>(cache_,key);
    }
    return NULL;
}

References cache_, MapTools::containsKey(), and MapTools::keyForValue().

Referenced by createTerminal().

Here is the call graph for this function:

isFunctionStart()

bool TTAProgram::TPEFProgramFactory::isFunctionStart ( const TPEF::InstructionElement &  instructionElement ) const

protected

Checks if move is start point of function.

Parameters

instructionElement

Intruction element which should be checked.

Returns

True if instruction in parameter is function start point.

Definition at line 2458 of file TPEFProgramFactory.cc.

                                                        {
    return MapTools::containsKey(
        functionStartPositions_, &instructionElement);
}

References MapTools::containsKey(), and functionStartPositions_.

Referenced by addProcedures().

Here is the call graph for this function:

resolveSocketAllocations()

void TTAProgram::TPEFProgramFactory::resolveSocketAllocations ( std::vector< SocketAllocation > &  allocs ) const

private

Resolves sockets that are used for GPR and Immediate Unit reading and writing for instruction.

NOTE: TPEF specification currently supports storing port information of GPR references, so if this solution does not work or if this is too slow, then register port information should be implemented to TPEF object modell.

Todo:

Yes, we should store the port allocations also to TPEF, if they have been assigned by the scheduler. This kind of resolving again and again does not make sense!

Parameters

allocs

All GPR and IU reads and writes of instruction. One item in this vector represents one move in the instruction.

Definition at line 1711 of file TPEFProgramFactory.cc.

                                               {
 
    // map of socket to all moves which use it.
    std::map<Socket*, std::vector<SocketAllocation*> > fixedSockets;
 
    // try to resolve working combination starting from the first allocation
    unsigned currIndex = 0;
 
    while (currIndex < allocs.size()) {
        bool allocationWasSuccess = true;
 
        SocketAllocation& alloc = allocs[currIndex];
 
        if (alloc.srcSocks.empty()) {
            currIndex++;
            continue;
        }
 
        // try to get allocation for current element
        if (alloc.src < alloc.srcSocks.size()) {
            while (!canSourceBeAssigned(alloc, fixedSockets)) {
                alloc.src++;
 
                if (alloc.src == alloc.srcSocks.size()) {
                    // working socket could not be found
                    allocationWasSuccess = false;
                    break;
                }
            }
        } else {
            allocationWasSuccess = false;
        }
 
        // if allocation was success add allocation to for the socket
        // otherwise remove the latest allocations and try to resolve them
        // again
 
        if (allocationWasSuccess) {
            // assign allocation for this socket
            Socket* currentSocket = alloc.srcSocks[alloc.src];
            fixedSockets[currentSocket].push_back(&alloc);
 
        } else {
            // reset allocation try sequence
            alloc.src = 0;
 
            // free previous allocation and try again
            unsigned int prevIndex = currIndex;
 
            do {
                if (prevIndex == 0) {
                    throw NotAvailable(
                        __FILE__, __LINE__, __func__,
                        "Can't resolve src sockets for instruction.");
                }
 
                prevIndex--;
 
            } while (allocs[prevIndex].srcSocks.empty());
 
 
            Socket* socketToFree =
                allocs[prevIndex].srcSocks[allocs[prevIndex].src];
            std::vector<SocketAllocation*>& freedAllocs =
                fixedSockets[socketToFree];
 
            bool prevFound = false;
            // find first freed allocation where we continue search
            for (int k = prevIndex; k >= 0 && !prevFound; k--) {
                for (std::vector<SocketAllocation*>::iterator j =
                         freedAllocs.begin(); j != freedAllocs.end(); j++) {
                    
                    if (static_cast<int>((*j)->index) == k) {
                        (*j)->src++;
                        currIndex = k;
                        prevFound = true;
                        freedAllocs.erase(j);
                        break;
                    }                        
                }
            }
            continue; // don't touch currIndex here
        }
 
        currIndex++;
    }
 
 
    // and same for the destinations
    fixedSockets.clear();
    currIndex = 0;
 
    while (currIndex < allocs.size()) {
        bool allocationWasSuccess = true;
 
        SocketAllocation& alloc = allocs[currIndex];
 
        if (alloc.dstSocks.empty()) {
            currIndex++;
            continue;
        }
 
        // try to get allocation for current element
        if (alloc.dst < alloc.dstSocks.size()) {
            while (!canDestinationBeAssigned(alloc, fixedSockets)) {
                alloc.dst++;
 
                if (alloc.dst == alloc.dstSocks.size()) {
                    // working socket could not be found
                    allocationWasSuccess = false;
                    break;
                }
            }
        } else {
            allocationWasSuccess = false;
        }
 
        // if allocation was success add allocation to for the socket
        // otherwise remove the latest allocations and try to resolve them
        // again
 
        if (allocationWasSuccess) {
            // assign allocation for this socket
            Socket* currentSocket = alloc.dstSocks[alloc.dst];
            fixedSockets[currentSocket].push_back(&alloc);
 
        } else {
            // reset allocation try sequence
            alloc.dst = 0;
 
            // free previous allocation and try again
            unsigned int prevIndex = currIndex;
 
            do {
                if (prevIndex == 0) {
                    throw NotAvailable(
                        __FILE__, __LINE__, __func__,
                        "Can't resolve dst sockets for instruction.");
                }
 
                prevIndex--;
 
            } while (allocs[prevIndex].dstSocks.empty());
 
 
            Socket* socketToFree =
                allocs[prevIndex].dstSocks[allocs[prevIndex].dst];
            std::vector<SocketAllocation*>& freedAllocs =
                fixedSockets[socketToFree];
 
            // find first freed allocation where we continue search
            for (unsigned int j = 0; j < freedAllocs.size(); j++) {
                if (freedAllocs[j]->index < currIndex) {
                    currIndex = freedAllocs[j]->index;
                }
            }
 
            // clean allocation indexes and increment index that is used
            // as a next start point for the search loop
            for (unsigned int j = 0; j < freedAllocs.size(); j++) {
                if (freedAllocs[j]->index != currIndex) {
                    freedAllocs[j]->dst = 0;
                } else {
                    freedAllocs[j]->dst++;
                }
            }
 
            fixedSockets.erase(socketToFree);
            continue; // don't touch currIndex here
        }
 
        currIndex++;
    }
 
    // fix terminals
    for (unsigned i = 0; i < allocs.size(); i++) {
        SocketAllocation &alloc = allocs[i];
 
#if 0
        std::cerr << "next allocation source: " 
                  << alloc.move->source().isGPR()
                  << " destination: " 
                  << alloc.move->destination().isGPR() << std::endl;
#endif
 
        if (!alloc.srcSocks.empty()) {
            Socket* srcSocket = alloc.srcSocks[alloc.src];
            Unit* parent = alloc.move->source().port().parentUnit();
 
            for (int j = 0; j < srcSocket->portCount(); j++) {
                if (srcSocket->port(j)->parentUnit() == parent) {
                    alloc.move->setSource(
                        new TerminalRegister(
                            *srcSocket->port(j),
                            alloc.move->source().index()));
#if 0
                    std::cerr << "source was replaced" << std::endl;
#endif
                    break;
                }
            }
        }
 
        if (!alloc.dstSocks.empty()) {
            Socket* dstSocket = alloc.dstSocks[alloc.dst];
            Unit* parent = alloc.move->destination().port().parentUnit();
 
            for (int j = 0; j < dstSocket->portCount(); j++) {
                if (dstSocket->port(j)->parentUnit() == parent) {
                    alloc.move->setDestination(
                        new TerminalRegister(
                            *dstSocket->port(j),
                            alloc.move->destination().index()));
#if 0
                    std::cerr << "dst was replaced" << std::endl;
#endif
                    break;
                }
            }
        }
#if 0
        if (alloc.move->source().isGPR() &&
            alloc.move->destination().isGPR()) {
            std::cerr << "next allocation source: "
                      << alloc.move->source().port().name()
                      << " destination: "
                      << alloc.move->destination().port().name() << std::endl;
        }
#endif
    }
}

References __func__, canDestinationBeAssigned(), canSourceBeAssigned(), TTAProgram::TPEFProgramFactory::SocketAllocation::dst, TTAProgram::TPEFProgramFactory::SocketAllocation::dstSocks, TTAProgram::TPEFProgramFactory::SocketAllocation::move, TTAMachine::Port::parentUnit(), TTAMachine::Socket::port(), TTAMachine::Socket::portCount(), TTAProgram::TPEFProgramFactory::SocketAllocation::src, and TTAProgram::TPEFProgramFactory::SocketAllocation::srcSocks.

Referenced by createInstruction().

Here is the call graph for this function:

seekFunctionStartPoints()

void TTAProgram::TPEFProgramFactory::seekFunctionStartPoints ( )

protected

Analyses all CodeSection from TPEF and tries to find function start points.

Todo:

This function should do code analysis, but for it actually scans symbol sections for code symbol, which are intepret as function start points.

Definition at line 1991 of file TPEFProgramFactory.cc.

                                            {
 
    // clear table if already exists (from previous POM builds)
    MapTools::deleteAllValues(functionStartPositions_);
 
    // check every symbol section
    for (Word i = 0; i < binary_->sectionCount(Section::ST_SYMTAB); i++) {
 
        SymbolSection *currSect =
            dynamic_cast<SymbolSection*>(
                binary_->section(Section::ST_SYMTAB, i));
 
        for (Word j = 0; j < currSect->elementCount(); j++) {
            ProcedSymElement* procedSymbol =
                dynamic_cast<ProcedSymElement*>(currSect->element(j));
 
            // symbol was not procedure symbol
            if (procedSymbol == NULL) {
                continue;
            }
 
            InstructionElement* referencedInstruction =
                procedSymbol->reference();
 
            // maybe we just could ignore null elements... but
            // there really should not be NULL code symbols, unless
            // referenced instruction has been moved or something...
            assert(referencedInstruction != NULL);
 
            std::string functionName =
                stringOfChunk(procedSymbol->name(), currSect->link());
 
            // add instruction element of symbol to entrypoint table
            functionStartPositions_[referencedInstruction] =
                new FunctionStart(functionName);
        }
    }
}

References assert, binary_, MapTools::deleteAllValues(), TPEF::Section::element(), TPEF::Section::elementCount(), functionName(), functionStartPositions_, TPEF::Section::link(), TPEF::SymbolElement::name(), TPEF::CodeSymElement::reference(), TPEF::Binary::section(), TPEF::Binary::sectionCount(), TPEF::Section::ST_SYMTAB, and stringOfChunk().

Referenced by build().

Here is the call graph for this function:

stringOfChunk()

std::string TTAProgram::TPEFProgramFactory::stringOfChunk ( const TPEF::Chunk *  chunk, const TPEF::Section *  chunkOwner  ) const

protected

Returns value of chunk as string.

Helps getting names for various TPEF resources.

Parameters

chunk	Chunk referring to section.
chunkOwner	StringSection that contains requested string.

Returns

String referred by chunk.

Definition at line 180 of file TPEFProgramFactory.cc.

                                     {
 
    const StringSection* strSect =
        dynamic_cast<const StringSection*>(chunkOwner);
    assert(strSect != NULL);
    return strSect->chunk2String(chunk);
}

References assert, and TPEF::StringSection::chunk2String().

Referenced by build(), createTerminal(), findBus(), findFunctionUnit(), findGuard(), findImmediateUnit(), findRegisterFile(), and seekFunctionStartPoints().

Here is the call graph for this function:

Member Data Documentation

adfInstrASpace_

TTAMachine::AddressSpace* TTAProgram::TPEFProgramFactory::adfInstrASpace_

private

Instruction address space of machine.

Definition at line 281 of file TPEFProgramFactory.hh.

Referenced by build(), createDataMemories(), createInstruction(), and createTerminal().

allocatedBusses_

std::set<HalfWord> TTAProgram::TPEFProgramFactory::allocatedBusses_

mutableprivate

Busses that are already allocated by moves of current instruction.

Definition at line 300 of file TPEFProgramFactory.hh.

binary_

const TPEF::Binary* TTAProgram::TPEFProgramFactory::binary_

private

Binary that is used for creating program.

Definition at line 272 of file TPEFProgramFactory.hh.

Referenced by addProcedures(), build(), createDataMemories(), createLabels(), and seekFunctionStartPoints().

cache_

std::map<const CacheKey, Terminal *> TTAProgram::TPEFProgramFactory::cache_

mutableprivate

Cache map of terminals that are returned by different search parameters.

Definition at line 297 of file TPEFProgramFactory.hh.

Referenced by addToCache(), clearCache(), and getFromCache().

functionStartPositions_

std::map<const TPEF::InstructionElement*, class FunctionStart*> TTAProgram::TPEFProgramFactory::functionStartPositions_

private

Stores information of start points of procedures that were found.

Definition at line 287 of file TPEFProgramFactory.hh.

Referenced by functionName(), isFunctionStart(), seekFunctionStartPoints(), and ~TPEFProgramFactory().

instructionImmediates_

std::list<std::shared_ptr<Move> > TTAProgram::TPEFProgramFactory::instructionImmediates_

mutableprivate

Moves whose source terminals are addresses referring to instructions.

Definition at line 290 of file TPEFProgramFactory.hh.

Referenced by build(), and createInstruction().

instructionMap_

std::map<TPEF::InstructionElement*, Instruction*> TTAProgram::TPEFProgramFactory::instructionMap_

mutableprivate

Program instruction by TPEF instruction element.

Definition at line 303 of file TPEFProgramFactory.hh.

Referenced by addProcedures(), createDataMemories(), and createLabels().

longInstructionImmediates_

std::list<std::shared_ptr<Immediate> > TTAProgram::TPEFProgramFactory::longInstructionImmediates_

mutableprivate

Long immediates whose value terminals refers to instructions.

Definition at line 293 of file TPEFProgramFactory.hh.

Referenced by build(), and createInstruction().

machine_

const TTAMachine::Machine* TTAProgram::TPEFProgramFactory::machine_

private

Target machine of program.

Definition at line 274 of file TPEFProgramFactory.hh.

Referenced by build(), findAddressSpace(), findBus(), findFunctionUnit(), findImmediateUnit(), findInstrTemplate(), findPort(), and findRegisterFile().

tpefInstrASpace_

TPEF::ASpaceElement* TTAProgram::TPEFProgramFactory::tpefInstrASpace_

private

Instruction address space element of TPEF.

Definition at line 283 of file TPEFProgramFactory.hh.

Referenced by build(), createInstruction(), and createTerminal().

tpefTools_

TPEF::TPEFTools TTAProgram::TPEFProgramFactory::tpefTools_

private

TPEFTools object for helper functions.

Definition at line 279 of file TPEFProgramFactory.hh.

Referenced by createInstruction(), createTerminal(), and findAddressSpace().

universalMachine_

UniversalMachine* TTAProgram::TPEFProgramFactory::universalMachine_

private

Universal machine of program.

Definition at line 276 of file TPEFProgramFactory.hh.

Referenced by build(), findAddressSpace(), findBus(), findFunctionUnit(), findInstrTemplate(), findPort(), and findRegisterFile().

---

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

• TPEFProgramFactory.hh
• TPEFProgramFactory.cc