#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. More...

const TTAMachine::Machine *	machine_
	Target machine of program. More...

UniversalMachine *	universalMachine_
	Universal machine of program. More...

TPEF::TPEFTools	tpefTools_
	TPEFTools object for helper functions. More...

TTAMachine::AddressSpace *	adfInstrASpace_
	Instruction address space of machine. More...

TPEF::ASpaceElement *	tpefInstrASpace_
	Instruction address space element of TPEF. More...

std::map< const TPEF::InstructionElement , class FunctionStart >	functionStartPositions_
	Stores information of start points of procedures that were found. More...

std::list< std::shared_ptr< Move > >	instructionImmediates_
	Moves whose source terminals are addresses referring to instructions. More...

std::list< std::shared_ptr< Immediate > >	longInstructionImmediates_
	Long immediates whose value terminals refers to instructions. More...

std::map< const CacheKey, Terminal * >	cache_
	Cache map of terminals that are returned by different search parameters. More...

std::set< HalfWord >	allocatedBusses_
	Busses that are already allocated by moves of current instruction. More...

std::map< TPEF::InstructionElement , Instruction >	instructionMap_
	Program instruction by TPEF instruction element. More...

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(), 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(), 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(), TTAProgram::Program::startAddress(), stringOfChunk(), tpefInstrASpace_, TPEF::Binary::type(), universalMachine_, and TTAProgram::TerminalImmediate::value().

Referenced by InstructionDictionary::compress(), TTAProgram::Program::loadFromTPEF(), 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(), 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(), 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;
 }

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

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::DataSymElement::reference(), TPEF::CodeSymElement::reference(), TPEF::Binary::section(), TPEF::SymbolElement::section(), TPEF::Binary::sectionCount(), Exception::setCause(), TPEF::Section::startingAddress(), 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::ImmediateElement::isInline(), TPEF::Section::link(), Application::logStream(), TPEF::ImmediateElement::longWord(), 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::name(), stringOfChunk(), 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::name(), TTAMachine::Component::name(), stringOfChunk(), 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::name(), TTAMachine::Component::name(), TTAMachine::FunctionUnit::operation(), TTAMachine::FunctionUnit::port(), TTAMachine::HWOperation::port(), TTAMachine::PortGuard::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::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(), 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, UniversalMachine::booleanRegisterFile(), UniversalMachine::doubleRegisterFile(), TPEF::ResourceSection::findResource(), TTAMachine::Machine::Navigator< ComponentType >::hasItem(), UniversalMachine::integerRegisterFile(), TTAMachine::Machine::Navigator< ComponentType >::item(), TPEF::Section::link(), machine_, 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(), and functionStartPositions_.

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_, and MapTools::containsKey().

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(), 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:

Classes

Public Member Functions

Protected Types

Protected Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ ImmediateKey

◆ ImmediateMap

◆ ImmediateVector

◆ InlineValues

◆ MoveVector

Constructor & Destructor Documentation

◆ TPEFProgramFactory() [1/3]

◆ TPEFProgramFactory() [2/3]

◆ TPEFProgramFactory() [3/3]

◆ ~TPEFProgramFactory()

Member Function Documentation

◆ addProcedures()

◆ addToCache()

◆ build()

◆ canDestinationBeAssigned()

◆ canSourceBeAssigned()

◆ clearCache()

◆ clearResourceAllocations()

◆ createDataMemories()

◆ createDataRelocs()

◆ createInstruction()

◆ createLabels()

◆ createTerminal()

◆ findAddressSpace()

◆ findBus()

◆ findFunctionUnit()

◆ findGuard()

◆ findImmediateUnit()

◆ findInstrTemplate()

◆ findPort()

◆ findRegisterFile()

◆ functionName()

◆ getFromCache()

◆ isFunctionStart()

◆ resolveSocketAllocations()

◆ seekFunctionStartPoints()

◆ stringOfChunk()

Member Data Documentation

◆ adfInstrASpace_

◆ allocatedBusses_

◆ binary_

◆ cache_

◆ functionStartPositions_

◆ instructionImmediates_

◆ instructionMap_

◆ longInstructionImmediates_

◆ machine_

◆ tpefInstrASpace_

◆ tpefTools_

◆ universalMachine_