#include <MachineResourceManager.hh>

Collaboration diagram for MachineResourceManager:

Classes
struct	ResourceID

struct	ResourceKey

Public Types
enum	RequestType { RQST_READ , RQST_WRITE , RQST_GUARD , RQST_INVGUARD }

Public Member Functions
	MachineResourceManager (TPEF::Binary &tpef, const TTAMachine::Machine &adf, AssemblyParserDiagnostic *parent_)

TPEF::Section *	nullSection ()

TPEF::StringSection *	stringSection ()

TPEF::ResourceSection *	resourceSection ()

TPEF::ASpaceElement *	findDataAddressSpace (std::string name)

UValue	findBusWidth (UValue slotNumber)

TPEF::ASpaceElement *	undefinedAddressSpace ()

TPEF::ASpaceElement *	codeAddressSpace ()

TPEF::Chunk *	stringToChunk (const std::string aStr)

ResourceID &	resourceID (UValue currentLine, const RegisterTerm &term, UValue slotNumber, RequestType type)

Private Member Functions
void	initResourceSection ()

void	addResourceElement (TPEF::ResourceElement *resource)

UValue	registerFileID (TTAMachine::BaseRegisterFile *rf)

UValue	functionUnitID (TTAMachine::FunctionUnit *unit)

UValue	opOrPortID (std::string opOrPortString, const TTAMachine::Port *port)

std::string	requestTypeString (RequestType type) const

ResourceID	functionUnitPortResource (const RegisterTerm &term)

ResourceID	indexResource (UValue currentLine, const RegisterTerm &term, UValue slotNumber, RequestType type, std::string &resourceKeyString)

ResourceID	rFPortOrFUIndexReference (TTAMachine::FunctionUnit fu, TTAMachine::BaseRegisterFile rf, UValue currentLine, const RegisterTerm &term, UValue slotNumber, RequestType type, std::string &resourceKeyString)

ResourceID	registerFileIndexReference (TTAMachine::BaseRegisterFile *rf, const RegisterTerm &term, UValue slotNumber, RequestType type, std::string &resourceKeyString)

Private Attributes
TPEF::Binary &	tpef_
	Binary where all used resources are added.

const TTAMachine::Machine &	adf_
	Machine where manager tries to find used resources.

TPEF::ASpaceSection *	aSpaceSection_
	The address space section of TPEF.

TPEF::StringSection *	strings_
	The string section of TPEF.

TPEF::ASpaceElement *	undefASpace_
	The undefined address space element of TPEF.

TPEF::ASpaceElement *	codeASpace_
	The instruction address space element of TPEF.

std::map< std::string, TPEF::ASpaceElement * >	addressSpaces_
	Bookkeeping for already requested address spaces.

TPEF::NullSection *	nullSection_
	The null section of TPEF.

TPEF::ResourceSection *	resourceSection_
	The resource section of TPEF.

std::map< ResourceKey, ResourceID >	resourceMap_
	Bookkeeping for already requested resources.

UValue	lastFunctionUnitID_
	For generating function unit resource ids.

std::map< TTAMachine::FunctionUnit *, UValue >	functionUnitIDs_
	Bookkeeping of already added function units.

UValue	lastRegisterFileID_
	For generating register file resource ids.

std::map< TTAMachine::BaseRegisterFile *, UValue >	registerFileIDs_
	Bookkeeping of already added register files.

UValue	lastOpOrSpecRegisterID_
	For generating shared ids for ports, operations or special registers.

std::map< std::string, UValue >	opOrPortIDs_
	Bookkeeping of already added ports, operations and special registers.

AssemblyParserDiagnostic *	parent_
	Assembler root class for adding warnings.

Detailed Description

Provides all TPEF and machine resources needed by CodeSectionCreator and DataSectionCreator.

Search resources from Machine and returns corresponding TPEF resources. Class also provides easy way to get common TPEF resource like strings, null section and required null elements. After all needed resources are returned the Binary that was given for MachineResourceManager will contain valid TPEF with NullSection, ASpaceSection, StringSection and ResourceSection.

Definition at line 76 of file MachineResourceManager.hh.

Member Enumeration Documentation

◆ RequestType

enum MachineResourceManager::RequestType

Type of resource id request.

Enumerator
RQST_READ	Register of port for reading.
RQST_WRITE	Register or port for writing.
RQST_GUARD	Register or port guard.
RQST_INVGUARD	Inverted register or port guard.

Definition at line 81 of file MachineResourceManager.hh.

                     {
        RQST_READ,     ///< Register of port for reading.
        RQST_WRITE,    ///< Register or port for writing.
        RQST_GUARD,    ///< Register or port guard.
        RQST_INVGUARD  ///< Inverted register or port guard.
    };

Constructor & Destructor Documentation

◆ MachineResourceManager()

MachineResourceManager::MachineResourceManager	(	TPEF::Binary &	tpef,
		const TTAMachine::Machine &	adf,
		AssemblyParserDiagnostic *	parent
	)

Constructor.

Parameters

tpef	Binary where to generated resources are added.
adf	Machine where from requested resources are found.
parent	Assembler root class for adding warning information.

Definition at line 63 of file MachineResourceManager.cc.

                                      :
    tpef_(tpef), adf_(adf), aSpaceSection_(NULL), strings_(NULL),
    undefASpace_(NULL), codeASpace_(NULL), nullSection_(NULL),
    resourceSection_(NULL), lastFunctionUnitID_(0), lastRegisterFileID_(0),
    lastOpOrSpecRegisterID_(0), parent_(parent) {
}

Member Function Documentation

◆ addResourceElement()

void MachineResourceManager::addResourceElement ( TPEF::ResourceElement * resource )

private

Adds resource element to TPEF.

Definition at line 418 of file MachineResourceManager.cc.

                                                                    {
    initResourceSection();
    assert(resourceSection_ != NULL);
 
#if 0
    // Valuable debug info... about resources that are added to 
    // resource section
    std::cerr << "Added resource element: " 
              << strings_->chunk2String(resource->name())
              << "\t" << (int)resource->type()
              << "\t" << (int)resource->id()
              << std::endl;
#endif
 
    resourceSection_->addElement(resource);
}

References TPEF::Section::addElement(), assert, TPEF::StringSection::chunk2String(), TPEF::ResourceElement::id(), initResourceSection(), TPEF::ResourceElement::name(), resourceSection_, strings_, and TPEF::ResourceElement::type().

Referenced by functionUnitID(), opOrPortID(), and registerFileID().

Here is the call graph for this function:

◆ codeAddressSpace()

ASpaceElement * MachineResourceManager::codeAddressSpace ( )

Returns the code address space.

Returns: The code address space.

Definition at line 213 of file MachineResourceManager.cc.

                                         {
 
    if (codeASpace_ == NULL) {
        // make sure that there is address space section created...
        undefinedAddressSpace();
 
        // find codeAddressSpace, create tpef version and add it to section
        AddressSpace* adfAddressSpace = adf_.controlUnit()->addressSpace();
 
        if (adfAddressSpace == NULL) {
            throw IllegalMachine(
                __FILE__, __LINE__, __func__,
                "Control unit has no address space.");
        }
 
        ASpaceElement* newASpace = new ASpaceElement();
        newASpace->setMAU(0);
        newASpace->setName(stringToChunk(adfAddressSpace->name()));
 
        addressSpaces_[adfAddressSpace->name()] = newASpace;
        codeASpace_ = newASpace;
 
        aSpaceSection_->addElement(newASpace);
    }
 
    return codeASpace_;
}

References __func__, TPEF::Section::addElement(), TTAMachine::FunctionUnit::addressSpace(), addressSpaces_, adf_, aSpaceSection_, codeASpace_, TTAMachine::Machine::controlUnit(), TTAMachine::Component::name(), TPEF::ASpaceElement::setMAU(), TPEF::ASpaceElement::setName(), stringToChunk(), and undefinedAddressSpace().

Referenced by AssemblerParser::definition< ScannerT >::definition(), CodeSectionCreator::finalize(), and findDataAddressSpace().

Here is the call graph for this function:

◆ findBusWidth()

UValue MachineResourceManager::findBusWidth ( UValue slotNumber )

Returns bitwidth of requested bus.

Parameters

Slot	number of requested bus.

Returns: Bitwidth of requested bus.

Exceptions

OutOfRange If slot number is out of bounds.

Definition at line 129 of file MachineResourceManager.cc.

                                                      {
    Bus* bus = adf_.busNavigator().item(slotNumber);
    return bus->width();
}

References adf_, TTAMachine::Machine::busNavigator(), TTAMachine::Machine::Navigator< ComponentType >::item(), and TTAMachine::Bus::width().

Referenced by CodeSectionCreator::addMove().

Here is the call graph for this function:

◆ findDataAddressSpace()

ASpaceElement * MachineResourceManager::findDataAddressSpace ( std::string name )

Finds data address space by name from ADF and adds it to TPEF.

Parameters

name	Name of requested address space.

Returns: ASpaceElement or NULL if not found.

Exceptions

IllegalMachine	Address space was not found from ADF.
InvalidData	Found address space is the code address space.

Definition at line 83 of file MachineResourceManager.cc.

                                                           {
    // check if address space is already created
    if (!MapTools::containsKey(addressSpaces_, name)) {
 
        // try to find address space for name
        Machine::AddressSpaceNavigator aSpaces = adf_.addressSpaceNavigator();
 
        // Check that address space is found from machine and create address
        // space section and address undef address space if needed to TPEF.
        if (!aSpaces.hasItem(name)) {
            throw IllegalMachine(
                __FILE__, __LINE__, __func__,
                "ADF doesn't contain address space: " + name);
        }
 
        undefinedAddressSpace();
 
        // create new address space and add it to TPEF
        AddressSpace* adfAddressSpace = aSpaces.item(name);
        assert(adfAddressSpace != NULL);
 
        ASpaceElement* newASpace = new ASpaceElement();
        newASpace->setMAU(adfAddressSpace->width());
        newASpace->setName(stringToChunk(name));
        addressSpaces_[name] = newASpace;
 
        aSpaceSection_->addElement(newASpace);
    }
 
    if (addressSpaces_[name] == codeAddressSpace()) {
        throw InvalidData(
            __FILE__, __LINE__, __func__,
            "Method can't be used for getting code address space.");
    }
 
    return addressSpaces_[name];
}

References __func__, TPEF::Section::addElement(), TTAMachine::Machine::addressSpaceNavigator(), addressSpaces_, adf_, aSpaceSection_, assert, codeAddressSpace(), MapTools::containsKey(), TTAMachine::Machine::Navigator< ComponentType >::hasItem(), TTAMachine::Machine::Navigator< ComponentType >::item(), TPEF::ASpaceElement::setMAU(), TPEF::ASpaceElement::setName(), stringToChunk(), undefinedAddressSpace(), and TTAMachine::AddressSpace::width().

Referenced by DataSectionCreator::finalize(), and DataSectionCreator::resolveDataAreaSizesAndLabelAddresses().

Here is the call graph for this function:

◆ functionUnitID()

UValue MachineResourceManager::functionUnitID ( TTAMachine::FunctionUnit * unit )

private

Returns TPEF resource ID of function unit.

If resource is not already in TPEF method creates resource and adds it.

Parameters

unit	Function unit whose ID is needed.

Returns: TPEF resource ID of function unit.

Definition at line 446 of file MachineResourceManager.cc.

                                                         {
 
    if (!MapTools::containsKey(functionUnitIDs_, unit)) {
        // create resource element and add its unit id to map
        lastFunctionUnitID_++;
 
        ResourceElement* newRes = new ResourceElement();
 
        newRes->setId(lastFunctionUnitID_);
        newRes->setType(ResourceElement::MRT_UNIT);
        newRes->setName(stringToChunk(unit->name()));
 
        addResourceElement(newRes);
 
        functionUnitIDs_[unit] = lastFunctionUnitID_;
    }
 
    assert(MapTools::containsKey(functionUnitIDs_, unit));
 
    return functionUnitIDs_[unit];
}

References addResourceElement(), assert, MapTools::containsKey(), functionUnitIDs_, lastFunctionUnitID_, TPEF::ResourceElement::MRT_UNIT, TTAMachine::Component::name(), TPEF::ResourceElement::setId(), TPEF::ResourceElement::setName(), TPEF::ResourceElement::setType(), and stringToChunk().

Referenced by functionUnitPortResource(), and rFPortOrFUIndexReference().

Here is the call graph for this function:

◆ functionUnitPortResource()

MachineResourceManager::ResourceID MachineResourceManager::functionUnitPortResource ( const RegisterTerm & term )

private

Finds resource for fu.port or fu.port.operation term.

Helper method for resourceID method.

Parameters

term	Requested term.

Returns: TPEF resource information of requested term.

Exceptions

IllegalMachine There was problems finding resource from ADF.

Definition at line 577 of file MachineResourceManager.cc.

                                                                         {
    ResourceID newResID;
 
    Machine::FunctionUnitNavigator fuNavi =
        adf_.functionUnitNavigator();
 
    FunctionUnit* fu = NULL;
 
    if (fuNavi.hasItem(term.fuTerm.part1)) {
        fu = fuNavi.item(term.fuTerm.part1);
 
    } else if (adf_.controlUnit()->name() == term.fuTerm.part1) {
        // NOTE: it would be easier, if control unit would be just
        // same that any fu and it would exist in fuNavigator.
        fu = adf_.controlUnit();
 
    } else {
        throw IllegalMachine(
            __FILE__, __LINE__, __func__,
            "Can't find function unit from machine: " +
            term.fuTerm.part1);
    }
 
    assert(fu != NULL);
 
    // find out port
    if (!fu->hasPort(term.fuTerm.part2)) {
        throw IllegalMachine(
            __FILE__, __LINE__, __func__,
            "Can't find port: " +
            term.fuTerm.part2);
    }
 
    Port* port = fu->port(term.fuTerm.part2);
 
    std::string regString;
 
    if (term.fuTerm.part3Used) {
        // find out operand
        if (!fu->hasOperation(term.fuTerm.part3)) {
            throw IllegalMachine(
                __FILE__, __LINE__, __func__,
                "Operation " + term.fuTerm.part3 +
                " is not found from fu: " +
                term.fuTerm.part1);
        }
 
        HWOperation* oper = fu->operation(term.fuTerm.part3);
 
        TTAMachine::FUPort* fuPort =
            dynamic_cast<TTAMachine::FUPort*>(port);
 
        try {
            regString =
                term.fuTerm.part3 + "." +
                Conversion::toString(oper->io(*fuPort));
 
        } catch (InstanceNotFound& e) {
 
            throw IllegalMachine(
                __FILE__, __LINE__, __func__,
                "Operation " + term.fuTerm.part3 +
                " is not bound to port: " +
                term.fuTerm.part2);
        }
 
    } else {
        // plain port reference
        regString = term.fuTerm.part2;
    }
 
    newResID.width = port->width();
    newResID.unit = functionUnitID(fu);
    newResID.index = opOrPortID(regString, port);
    newResID.type = MoveElement::MF_UNIT;
 
    return newResID;
}

References __func__, adf_, assert, TTAMachine::Machine::controlUnit(), functionUnitID(), TTAMachine::Machine::functionUnitNavigator(), RegisterTerm::fuTerm, TTAMachine::Machine::Navigator< ComponentType >::hasItem(), TTAMachine::FunctionUnit::hasOperation(), TTAMachine::Unit::hasPort(), MachineResourceManager::ResourceID::index, TTAMachine::HWOperation::io(), TTAMachine::Machine::Navigator< ComponentType >::item(), TPEF::MoveElement::MF_UNIT, TTAMachine::Component::name(), TTAMachine::FunctionUnit::operation(), opOrPortID(), FUTerm::part1, FUTerm::part2, FUTerm::part3, FUTerm::part3Used, TTAMachine::FunctionUnit::port(), Conversion::toString(), MachineResourceManager::ResourceID::type, MachineResourceManager::ResourceID::unit, MachineResourceManager::ResourceID::width, and TTAMachine::Port::width().

Referenced by resourceID().

Here is the call graph for this function:

◆ indexResource()

MachineResourceManager::ResourceID MachineResourceManager::indexResource	(	UValue	currentLine,
		const RegisterTerm &	term,
		UValue	slotNumber,
		RequestType	type,
		std::string &	resourceKeyString
	)

private

Finds resource for fu.operation.index, rf.index or rf.port.index term.

Helper method for resourceID method.

Parameters

currentLine	Line number information for warning messages.
term	Requested term.
slotNumber	Number of move slot, that was used.
type	Request type.
resourceKeyString	Resource key string for error messages.

Returns: TPEF resource information of requested term.

Exceptions

IllegalMachine There was problems finding resource from ADF.

Definition at line 670 of file MachineResourceManager.cc.

                                                    {
    ResourceID newResID;
 
    Machine::RegisterFileNavigator rfNavi =
        adf_.registerFileNavigator();
 
    Machine::ImmediateUnitNavigator immNavi =
        adf_.immediateUnitNavigator();
 
    Machine::FunctionUnitNavigator fuNavi =
        adf_.functionUnitNavigator();
 
    BaseRegisterFile* rf = NULL;
    FunctionUnit* fu = NULL;
 
    if (immNavi.hasItem(term.indexTerm.part1)) {
        rf = immNavi.item(term.indexTerm.part1);
    }
 
    // If the a unit is found in both immediate unit and register file
    // navigators, the unit from the register file navigator is selected
    // and a warning is displayed.
    if (rfNavi.hasItem(term.indexTerm.part1)) {
        if (rf != NULL) {
            std::string warning = "Unit name '";
            warning += term.indexTerm.part1;
            warning += "' is ambiguous. Because of disambiguity rules, '";
            warning += term.indexTerm.part1;
            warning += "' is selected to refer the register file insread of";
            warning += " the immediate unit.";
            parent_->addWarning(currentLine, warning);
        }
        rf = rfNavi.item(term.indexTerm.part1);
    }
 
    // if normal fu or gcu...
    if (fuNavi.hasItem(term.indexTerm.part1)) {
        fu = fuNavi.item(term.indexTerm.part1);
    } else {
        // NOTE: GCU  isn't found by name with FunctionUnitNavigator,
        // but it must be requested explicitely
        fu = adf_.controlUnit();
        if (fu->name() != term.indexTerm.part1) {
            fu = NULL;
        }
    }
 
    if (term.indexTerm.part2Used) {
        if (rf != NULL && fu != NULL) {
            std::string warning = "Unit name '";
            warning += term.indexTerm.part1;
            warning += "' is ambiguous.";
            parent_->addWarning(currentLine, warning);
        }
        // rf.port.index or fu.operation.index reference
        newResID = rFPortOrFUIndexReference(
            fu, rf, currentLine, term, slotNumber, type, resourceKeyString);
 
    } else {
        // this must be rf.index reference
        newResID = registerFileIndexReference(
            rf, term, slotNumber, type, resourceKeyString);
    }
 
    return newResID;
}

References AssemblyParserDiagnostic::addWarning(), adf_, TTAMachine::Machine::controlUnit(), TTAMachine::Machine::functionUnitNavigator(), TTAMachine::Machine::Navigator< ComponentType >::hasItem(), TTAMachine::Machine::immediateUnitNavigator(), RegisterTerm::indexTerm, TTAMachine::Machine::Navigator< ComponentType >::item(), TTAMachine::Component::name(), parent_, IndexTerm::part1, IndexTerm::part2Used, registerFileIndexReference(), TTAMachine::Machine::registerFileNavigator(), and rFPortOrFUIndexReference().

Referenced by resourceID().

Here is the call graph for this function:

◆ initResourceSection()

void MachineResourceManager::initResourceSection ( )

private

Initialises resource section if its not initialised already.

Definition at line 382 of file MachineResourceManager.cc.

                                                 {
    // init resource section if needed and add new resource element.
    if (resourceSection_ == NULL) {
        resourceSection_ = dynamic_cast<ResourceSection*>(
            Section::createSection(Section::ST_MR));
 
        assert(resourceSection_ != NULL);
 
        resourceSection_->setName(stringToChunk(""));
        resourceSection_->setASpace(undefinedAddressSpace());
        resourceSection_->setLink(strings_);
 
        // add all busses at once
        Machine::BusNavigator busNavi = adf_.busNavigator();
 
        for (int i = 0; i < busNavi.count(); i++) {
            Bus* bus = busNavi.item(i);
 
            ResourceElement* newRes = new ResourceElement();
 
            newRes->setId(i + 1);
            newRes->setType(ResourceElement::MRT_BUS);
            newRes->setName(stringToChunk(bus->name()));
 
            resourceSection_->addElement(newRes);
        }
 
        tpef_.addSection(resourceSection_);
    }
}

References TPEF::Section::addElement(), TPEF::Binary::addSection(), adf_, assert, TTAMachine::Machine::busNavigator(), TTAMachine::Machine::Navigator< ComponentType >::count(), TPEF::Section::createSection(), TTAMachine::Machine::Navigator< ComponentType >::item(), TPEF::ResourceElement::MRT_BUS, TTAMachine::Component::name(), resourceSection_, TPEF::Section::setASpace(), TPEF::ResourceElement::setId(), TPEF::Section::setLink(), TPEF::Section::setName(), TPEF::ResourceElement::setName(), TPEF::ResourceElement::setType(), TPEF::Section::ST_MR, strings_, stringToChunk(), tpef_, and undefinedAddressSpace().

Referenced by addResourceElement(), and resourceSection().

Here is the call graph for this function:

◆ nullSection()

Section * MachineResourceManager::nullSection ( )

Returns NullSection instance of TPEF.

Returns: NullSection instance of TPEF.

Definition at line 140 of file MachineResourceManager.cc.

                                    {
 
    if (nullSection_ == NULL) {
 
        nullSection_ = dynamic_cast<NullSection*>(
            Section::createSection(Section::ST_NULL));
 
        assert(nullSection_ != NULL);
 
        nullSection_->setASpace(undefinedAddressSpace());
        nullSection_->setName(stringToChunk(""));
        nullSection_->setLink(nullSection_);
 
        tpef_.addSection(nullSection_);
    }
 
    return nullSection_;
}

References TPEF::Binary::addSection(), assert, TPEF::Section::createSection(), nullSection_, TPEF::Section::setASpace(), TPEF::Section::setLink(), TPEF::Section::setName(), TPEF::Section::ST_NULL, stringToChunk(), tpef_, and undefinedAddressSpace().

Referenced by stringToChunk().

Here is the call graph for this function:

◆ opOrPortID()

UValue MachineResourceManager::opOrPortID	(	std::string	opOrPortString,
		const TTAMachine::Port *	port
	)

private

Returns TPEF resource ID of operand or port.

If resource is not already in TPEF method creates resource and adds it.

Parameters

opPortString	TPEF resource string of port or operand.
port	Port that is connected with requested resource in ADF.

Returns: TPEF resource ID of port or operand.

Definition at line 518 of file MachineResourceManager.cc.

                                                          {
 
    if (!MapTools::containsKey(opOrPortIDs_, opOrPortString)) {
        // create resource element and add its unit id to map
        lastOpOrSpecRegisterID_++;
        UValue generatedID = lastOpOrSpecRegisterID_;
 
        ResourceElement* newRes = new ResourceElement();
 
        // check if string is port or operand by string format
        if (opOrPortString.find('.') == std::string::npos) {
 
            if (dynamic_cast<const SpecialRegisterPort*>(port) != NULL) {
                newRes->setType(ResourceElement::MRT_SR);
            } else {
                newRes->setType(ResourceElement::MRT_PORT);
            }
 
        } else {
            newRes->setType(ResourceElement::MRT_OP);
        }
 
        newRes->setName(stringToChunk(opOrPortString));
        newRes->setId(generatedID);
        addResourceElement(newRes);
        opOrPortIDs_[opOrPortString] = generatedID;
    }
 
    return opOrPortIDs_[opOrPortString];
}

References addResourceElement(), MapTools::containsKey(), lastOpOrSpecRegisterID_, TPEF::ResourceElement::MRT_OP, TPEF::ResourceElement::MRT_PORT, TPEF::ResourceElement::MRT_SR, opOrPortIDs_, TPEF::ResourceElement::setId(), TPEF::ResourceElement::setName(), TPEF::ResourceElement::setType(), and stringToChunk().

Referenced by functionUnitPortResource(), and rFPortOrFUIndexReference().

Here is the call graph for this function:

◆ registerFileID()

UValue MachineResourceManager::registerFileID ( TTAMachine::BaseRegisterFile * rf )

private

Returns TPEF resource ID corresponding to a register file.

If there is no resource entry in TPEF for the given register file, this method creates it, assigns a new unique ID code to it and adds it to the pool of managed TPEF resources.

Parameters

rf	A register file.

Returns: TPEF resource ID of the register file.

Definition at line 480 of file MachineResourceManager.cc.

                                                           {
 
    if (!MapTools::containsKey(registerFileIDs_, rf)) {
        // create resource element and add its unit id to map
        lastRegisterFileID_++;
 
        ResourceElement* newRes = new ResourceElement();
 
        newRes->setId(lastRegisterFileID_);
 
        if (dynamic_cast<ImmediateUnit*>(rf) == NULL) {
            newRes->setType(ResourceElement::MRT_RF);
        } else {
            newRes->setType(ResourceElement::MRT_IMM);
        }
 
        newRes->setName(stringToChunk(rf->name()));
        addResourceElement(newRes);
 
        registerFileIDs_[rf] = lastRegisterFileID_;
    }
 
    assert(MapTools::containsKey(registerFileIDs_, rf));
 
    return registerFileIDs_[rf];
}

References addResourceElement(), assert, MapTools::containsKey(), lastRegisterFileID_, TPEF::ResourceElement::MRT_IMM, TPEF::ResourceElement::MRT_RF, TTAMachine::Component::name(), registerFileIDs_, TPEF::ResourceElement::setId(), TPEF::ResourceElement::setName(), TPEF::ResourceElement::setType(), and stringToChunk().

Referenced by registerFileIndexReference(), and rFPortOrFUIndexReference().

Here is the call graph for this function:

◆ registerFileIndexReference()

MachineResourceManager::ResourceID MachineResourceManager::registerFileIndexReference	(	TTAMachine::BaseRegisterFile *	rf,
		const RegisterTerm &	term,
		UValue	slotNumber,
		RequestType	type,
		std::string &	resourceKeyString
	)

private

Finds resource for rf.index term.

Helper method for indexResource method.

Parameters

rf	Register file of term.
term	Requested term.
slotNumber	Number of move slot, that was used.
type	Request type.
resourceKeyString	Resource key string for error messages.

Returns: TPEF resource information of requested term.

Exceptions

IllegalMachine There was problems finding resource from ADF.

Definition at line 983 of file MachineResourceManager.cc.

                                                    {
    ResourceID newResID;
    // this is normal rf reference unless register is immediate unit...
    newResID.type = MoveElement::MF_RF;
 
    if (rf == NULL) {
        throw IllegalMachine(
            __FILE__, __LINE__, __func__,
            "Can't find connection for " +  requestTypeString(type) +
            " rf.index term: " + resourceKeyString);
    }
 
    // check that there is enough registers in file
    if(static_cast<UValue>(rf->numberOfRegisters()) <= term.indexTerm.index) {
 
        throw IllegalMachine(
            __FILE__, __LINE__, __func__,
            "Not enough registers in registerfile.");
    }
 
    // check defined if port can be used for current direction
    // and bus
    Bus* bus = adf_.busNavigator().item(slotNumber);
    bool isPossible = false;
 
    switch (type) {
 
    case RQST_READ:
    case RQST_WRITE: {
        ImmediateUnit* immUnit = dynamic_cast<ImmediateUnit*>(rf);
 
        // Code section creator checks in the end if it's really possible...
        if (immUnit != NULL) {
            isPossible = true;
            newResID.type = MoveElement::MF_IMM;
            break;
        }
 
        for (int i = 0; i < rf->portCount(); i++) {
            Port* port = rf->port(i);
 
            Socket* sock =
                (type == RQST_WRITE) ?
                (port->inputSocket()) :
                (port->outputSocket());
 
            if (sock != NULL && sock->isConnectedTo(*bus)) {
                isPossible = true;
                break;
            }
        }
 
    } break;
 
    case RQST_INVGUARD:
    case RQST_GUARD: {
        bool invertedRequested = (type == RQST_INVGUARD);
 
        for (int i = 0; i < bus->guardCount(); i++) {
            RegisterGuard* guard =
                dynamic_cast<RegisterGuard*>(bus->guard(i));
 
            if (guard != NULL) {
                if (guard->registerFile() == rf &&
                    guard->registerIndex() ==
                    static_cast<int>(term.indexTerm.index) &&
                    guard->isInverted() == invertedRequested) {
 
                    isPossible = true;
                    break;
                }
            }
        }
 
    } break;
 
    default:
        abortWithError("Unknown request type: " +
                       Conversion::toString(type));
    }
 
    if (isPossible) {
        newResID.width = rf->width();
        newResID.unit = registerFileID(rf);
        newResID.index = term.indexTerm.index;
 
    } else {
        throw IllegalMachine(
            __FILE__, __LINE__, __func__,
            "Can't find connection for " + requestTypeString(type) +
            " term: " + resourceKeyString);
    }
 
    return newResID;
}

References __func__, abortWithError, adf_, TTAMachine::Machine::busNavigator(), TTAMachine::Bus::guard(), TTAMachine::Bus::guardCount(), MachineResourceManager::ResourceID::index, IndexTerm::index, RegisterTerm::indexTerm, TTAMachine::Port::inputSocket(), TTAMachine::Socket::isConnectedTo(), TTAMachine::Guard::isInverted(), TTAMachine::Machine::Navigator< ComponentType >::item(), TPEF::MoveElement::MF_IMM, TPEF::MoveElement::MF_RF, TTAMachine::BaseRegisterFile::numberOfRegisters(), TTAMachine::Port::outputSocket(), TTAMachine::BaseRegisterFile::port(), TTAMachine::Unit::portCount(), TTAMachine::RegisterGuard::registerFile(), registerFileID(), TTAMachine::RegisterGuard::registerIndex(), requestTypeString(), RQST_GUARD, RQST_INVGUARD, RQST_READ, RQST_WRITE, Conversion::toString(), MachineResourceManager::ResourceID::type, MachineResourceManager::ResourceID::unit, MachineResourceManager::ResourceID::width, and TTAMachine::BaseRegisterFile::width().

Referenced by indexResource().

Here is the call graph for this function:

◆ requestTypeString()

std::string MachineResourceManager::requestTypeString ( RequestType type ) const

private

Returns debug string for request type for error message generation.

Parameters

type	Request type.

Returns: Debug string for request type.

Definition at line 557 of file MachineResourceManager.cc.

                                                                {
    switch (type) {
    case RQST_READ:      return "read";
    case RQST_WRITE:     return "write";
    case RQST_GUARD:     return "guard";
    case RQST_INVGUARD:  return "inverted guard";
    default:             return "invalid request type";
    }
}

References RQST_GUARD, RQST_INVGUARD, RQST_READ, and RQST_WRITE.

Referenced by registerFileIndexReference(), and rFPortOrFUIndexReference().

◆ resourceID()

MachineResourceManager::ResourceID & MachineResourceManager::resourceID	(	UValue	currentLine,
		const RegisterTerm &	term,
		UValue	slotNumber,
		RequestType	type
	)

Resolves type, unit and index fields, of given register term.

Also checks if requested term is possible and creates machine resource section.

Parameters

currentLine	line number where term is located in assembly code.
term	Term to resolve.
slotNumber	Number of move slot, that was used.
type	Is read, write or guard.

Returns: Information of Term's type, unit and index for instruction element.

Exceptions

IllegalMachine There is problem to find or access the resource.

Definition at line 285 of file MachineResourceManager.cc.

                      {
    // create resource key for reference
    ResourceID newResID;
 
    ResourceKey resKey;
    resKey.slotNumber = slotNumber;
    resKey.type = type;
 
#if 0
    // Valuable debug info (currently resolved term)
    term.clear();
    std::cerr << "\ttype: " << term.type << std::endl;
#endif
 
    // create key for requested resource
    if (term.type == RegisterTerm::INDEX) {
        resKey.keyString = term.indexTerm.part1;
 
        if (term.indexTerm.part2Used) {
            resKey.keyString += "." + term.indexTerm.part2;
        }
 
        resKey.keyString += "." + Conversion::toString(term.indexTerm.index);
 
    } else if (term.type == RegisterTerm::FUNCTION_UNIT) {
        resKey.keyString =
            term.fuTerm.part1 + "." + term.fuTerm.part2;
 
        if (term.fuTerm.part3Used) {
            resKey.keyString += "." + term.fuTerm.part3;
        }
 
    } else if (term.type == RegisterTerm::BUS) {
        if (term.busTerm.prev) {
            resKey.keyString = "{prev}";
        } else {
            resKey.keyString = "{next}";
        }
 
    } else {
        abortWithError(
            "Unknown term type." + Conversion::toString(term.type));
    }
 
    // check if resource is used before or do we have to
    // retrieve it and add it to resource section
    if (!MapTools::containsKey(resourceMap_, resKey)) {
 
        if (term.type == RegisterTerm::INDEX) {
            // check if rf[.port].index  or fu.operation.index
            newResID = indexResource(
                currentLine, term, slotNumber, type, resKey.keyString);
 
        } else if (term.type == RegisterTerm::FUNCTION_UNIT) {
            // this is definately unit.port[.operation]
            newResID = functionUnitPortResource(term);
 
        } else if (term.type == RegisterTerm::BUS) {
            abortWithError("{prev} and {next} might never be supported.");
 
        } else {
            assert(false);
        }
 
#if 0
        // Very useful debugging information
        std::cerr << "resKey: " << resKey.keyString
                  << "\ttype: " << resKey.type
                  << "\tslot:" << resKey.slotNumber
                  << std::endl;
#endif
        // copy to map
        resourceMap_[resKey] = newResID;
    }
 
    // get resource id from map and give it away
    assert(MapTools::containsKey(resourceMap_, resKey));
 
    return resourceMap_[resKey];
}

References abortWithError, assert, RegisterTerm::BUS, RegisterTerm::busTerm, MapTools::containsKey(), RegisterTerm::FUNCTION_UNIT, functionUnitPortResource(), RegisterTerm::fuTerm, IndexTerm::index, RegisterTerm::INDEX, indexResource(), RegisterTerm::indexTerm, MachineResourceManager::ResourceKey::keyString, FUTerm::part1, IndexTerm::part1, FUTerm::part2, IndexTerm::part2, IndexTerm::part2Used, FUTerm::part3, FUTerm::part3Used, BusTerm::prev, resourceMap_, MachineResourceManager::ResourceKey::slotNumber, Conversion::toString(), MachineResourceManager::ResourceKey::type, and RegisterTerm::type.

Referenced by CodeSectionCreator::addMove().

Here is the call graph for this function:

◆ resourceSection()

ResourceSection * MachineResourceManager::resourceSection ( )

Returns the resource section of TPEF.

Returns: The resource section of TPEF.

Definition at line 373 of file MachineResourceManager.cc.

                                                         {
    initResourceSection();
    return resourceSection_;
}

References initResourceSection(), and resourceSection_.

Referenced by CodeSectionCreator::finalize().

Here is the call graph for this function:

◆ rFPortOrFUIndexReference()

MachineResourceManager::ResourceID MachineResourceManager::rFPortOrFUIndexReference	(	TTAMachine::FunctionUnit *	fu,
		TTAMachine::BaseRegisterFile *	rf,
		UValue	currentLine,
		const RegisterTerm &	term,
		UValue	slotNumber,
		RequestType	type,
		std::string &	resourceKeyString
	)

private

Finds resource for fu.operation.index or rf.port.index term.

Helper method for indexResource method.

Parameters

fu	Function unit of term, might be NULL.
rf	Register file of term, might be NULL.
currentLine	Line number information for warning messages.
term	Requested term.
slotNumber	Number of move slot, that was used.
type	Request type.
resourceKeyString	Resource key string for error messages.

Returns: TPEF resource information of requested term.

Exceptions

IllegalMachine There was problems finding resource from ADF.

Definition at line 755 of file MachineResourceManager.cc.

                                  {
    ResourceID newResID;
 
    // NOTE: disambiguation rule says that rf.port.index has higher
    // priority than fu.operation.index ...
    if (rf != NULL) {
 
        // check defined if port can be used for current
        // direction and bus
        Bus* bus = NULL;
        try {
            bus = adf_.busNavigator().item(slotNumber);
        } catch (OutOfRange &e) {
            std::stringstream newErrorMsg;
            newErrorMsg 
                << "Too few busses for all moves in instruction."
                << std::endl;
 
            IllegalMachine error(
                    __FILE__, __LINE__, __func__,
                    newErrorMsg.str() + e.errorMessage());
            error.setCause(e);
            throw error;
        }
        bool isPossible = false;
 
        switch (type) {
        case RQST_READ:
        case RQST_WRITE: {
            for (int i = 0; i < rf->portCount(); i++) {
                Port* port = rf->port(i);
 
                Socket* sock =
                    (type == RQST_WRITE) ?
                    (port->inputSocket()) :
                    (port->outputSocket());
 
                if (sock != NULL && sock->isConnectedTo(*bus)) {
                    isPossible = true;
 
                    // we never store information that which port of RF
                    // was used for reading or writing, since TPEF doesn't
                    // support storing that data :(
                    if (port->name() != term.indexTerm.part2) {
 
                        parent_->addWarning(
                            currentLine,
                            "Selected different port for move"
                            "that was given by user.");
                    }
 
                    newResID.width = port->width();
                    break;
                }
            }
 
        } break;
 
        case RQST_INVGUARD:
        case RQST_GUARD: {
            bool isInverted =
                (type == RQST_GUARD) ?
                (false) : (true);
 
            for (int i = 0; i < bus->guardCount(); i++) {
                RegisterGuard* guard =
                    dynamic_cast<RegisterGuard*>(bus->guard(i));
 
                if (guard != NULL) {
                    if (guard->registerFile() == rf &&
                        guard->registerIndex() ==
                        static_cast<int>(term.indexTerm.index) &&
                        guard->isInverted() == isInverted) {
 
                        isPossible = true;
                        break;
                    }
                }
            }
 
        } break;
 
        default:
            abortWithError("Unknown request type: " +
                           Conversion::toString(type));
        }
 
        // if request is possible
        if (isPossible) {
            newResID.unit = registerFileID(rf);
            newResID.index = term.indexTerm.index;
 
            if (dynamic_cast<ImmediateUnit*>(rf) == NULL) {
                newResID.type =  MoveElement::MF_RF;
            } else {
                newResID.type =  MoveElement::MF_IMM;
            }
 
        } else {
            rf = NULL;
        }
    }
 
    if (rf == NULL && fu != NULL) {
        //  check if operation is found from fu
        if (fu->hasOperation(term.indexTerm.part2)) {
 
            // check that requested port is possible
            HWOperation* oper =
                fu->operation(term.indexTerm.part2);
 
 
            Port* port = oper->port(term.indexTerm.index);
 
            if (port == NULL) {
                throw IllegalMachine(
                    __FILE__, __LINE__, __func__,
                    "Can't find operand: " +
                    term.indexTerm.part2 + "." +
                    Conversion::toString(term.indexTerm.index));
            }
 
            Bus* bus = NULL;
            try { 
                bus = adf_.busNavigator().item(slotNumber);
            } catch (OutOfRange &e) {
                std::stringstream newErrorMsg;
                newErrorMsg 
                    << "Too few busses for all moves in instruction."
                    << std::endl;
 
                IllegalMachine error(
                    __FILE__, __LINE__, __func__,
                    newErrorMsg.str() + e.errorMessage());
                error.setCause(e);
                throw error;
            }
            bool isPossible = false;
 
            switch (type) {
            case RQST_WRITE:
            case RQST_READ: {
                Socket* sock =
                    (type == RQST_WRITE) ?
                    (port->inputSocket()) :
                    (port->outputSocket());
 
                if (sock != NULL && sock->isConnectedTo(*bus)) {
                    isPossible = true;
                    break;
                }
            } break;
 
            case RQST_GUARD:
            case RQST_INVGUARD: {
                bool isInverted =
                    (type == RQST_GUARD) ?
                    (false) : (true);
 
                for (int i = 0; i < bus->guardCount(); i++) {
                    PortGuard* guard =
                        dynamic_cast<PortGuard*>(bus->guard(i));
 
                    if (guard != NULL) {
                        if (guard->port() == port &&
                            guard->isInverted() == isInverted) {
 
                            isPossible = true;
                            break;
                        }
                    }
                }
            } break;
 
            default:
                abortWithError("Unknown request type: " +
                               Conversion::toString(type));
            }
 
            std::string operationRegisterStr =
                term.indexTerm.part2 + "." +
                Conversion::toString(term.indexTerm.index);
 
            if (isPossible) {
                newResID.width = port->width();
                newResID.unit = functionUnitID(fu);
                newResID.index = opOrPortID(operationRegisterStr, port);
                newResID.type =  MoveElement::MF_UNIT;
 
            } else {
                fu = NULL;
            }
 
        } else {
            throw IllegalMachine(
                __FILE__, __LINE__, __func__,
                "Can't find operation: " + term.indexTerm.part2);
        }
    }
 
    // if both tests failed
    if (rf == NULL && fu == NULL) {
        throw IllegalMachine(
            __FILE__, __LINE__, __func__,
            "Can't find connection for " + requestTypeString(type) +
            "fu term: " + resourceKeyString);
    }
 
    return newResID;
}

References __func__, abortWithError, AssemblyParserDiagnostic::addWarning(), adf_, TTAMachine::Machine::busNavigator(), Exception::errorMessage(), functionUnitID(), TTAMachine::Bus::guard(), TTAMachine::Bus::guardCount(), TTAMachine::FunctionUnit::hasOperation(), MachineResourceManager::ResourceID::index, IndexTerm::index, RegisterTerm::indexTerm, TTAMachine::Port::inputSocket(), TTAMachine::Socket::isConnectedTo(), TTAMachine::Guard::isInverted(), TTAMachine::Machine::Navigator< ComponentType >::item(), TPEF::MoveElement::MF_IMM, TPEF::MoveElement::MF_RF, TPEF::MoveElement::MF_UNIT, TTAMachine::Port::name(), TTAMachine::FunctionUnit::operation(), opOrPortID(), TTAMachine::Port::outputSocket(), parent_, IndexTerm::part2, TTAMachine::PortGuard::port(), TTAMachine::BaseRegisterFile::port(), TTAMachine::HWOperation::port(), TTAMachine::Unit::portCount(), TTAMachine::RegisterGuard::registerFile(), registerFileID(), TTAMachine::RegisterGuard::registerIndex(), requestTypeString(), RQST_GUARD, RQST_INVGUARD, RQST_READ, RQST_WRITE, Exception::setCause(), Conversion::toString(), MachineResourceManager::ResourceID::type, MachineResourceManager::ResourceID::unit, MachineResourceManager::ResourceID::width, and TTAMachine::Port::width().

Referenced by indexResource().

Here is the call graph for this function:

◆ stringSection()

StringSection * MachineResourceManager::stringSection ( )

Returns string table of TPEF.

Returns: String table of TPEF.

Definition at line 166 of file MachineResourceManager.cc.

                                      {
    // makes sure that strings section is initialized
    undefinedAddressSpace();
    return strings_;
}

References strings_, and undefinedAddressSpace().

Referenced by LabelManager::finalize().

Here is the call graph for this function:

◆ stringToChunk()

Chunk * MachineResourceManager::stringToChunk ( const std::string aStr )

Finds or adds string to TPEF string section and returns chunk pointing to it.

Parameters

aStr	String whose chunk is needed.

Returns: Chunk pointing to string stored in TPEF.

Definition at line 249 of file MachineResourceManager.cc.

                                                          {
 
    if (strings_ == NULL) {
        strings_ = dynamic_cast<StringSection*>(
            Section::createSection(Section::ST_STRTAB));
 
        // first byte must be zero
        strings_->addByte(0);
 
        tpef_.setStrings(strings_);
        tpef_.addSection(strings_);
 
        // start zero of string section must be added befor this, since
        // undefined address space calls this function to get chunk(0)
        strings_->setASpace(undefinedAddressSpace());
        strings_->setLink(nullSection());
    }
 
    return strings_->string2Chunk(aStr);
}

References TPEF::DataSection::addByte(), TPEF::Binary::addSection(), TPEF::Section::createSection(), nullSection(), TPEF::Section::setASpace(), TPEF::Section::setLink(), TPEF::Binary::setStrings(), TPEF::Section::ST_STRTAB, TPEF::StringSection::string2Chunk(), strings_, tpef_, and undefinedAddressSpace().

Referenced by codeAddressSpace(), CodeSectionCreator::finalize(), DataSectionCreator::finalize(), findDataAddressSpace(), functionUnitID(), initResourceSection(), nullSection(), opOrPortID(), registerFileID(), and undefinedAddressSpace().

Here is the call graph for this function:

◆ undefinedAddressSpace()

ASpaceElement * MachineResourceManager::undefinedAddressSpace ( )

Returns undefined address space element.

Returns: undefined address space element.

Definition at line 179 of file MachineResourceManager.cc.

                                              {
 
    // create address space section when needed
    if (aSpaceSection_ == NULL) {
 
        // create address space section with undefined address space element
        aSpaceSection_ =
            dynamic_cast<ASpaceSection*>(
                Section::createSection(Section::ST_ADDRSP));
 
        assert(aSpaceSection_ != NULL);
 
        undefASpace_ = new ASpaceElement();
        undefASpace_->setName(stringToChunk(""));
 
        aSpaceSection_->setLink(strings_);
        aSpaceSection_->setName(stringToChunk(""));
        aSpaceSection_->setASpace(undefinedAddressSpace());
        aSpaceSection_->setUndefinedASpace(undefASpace_);
 
        aSpaceSection_->addElement(undefASpace_);
        tpef_.addSection(aSpaceSection_);
    }
 
    return undefASpace_;
}

References TPEF::Section::addElement(), TPEF::Binary::addSection(), aSpaceSection_, assert, TPEF::Section::createSection(), TPEF::Section::setASpace(), TPEF::Section::setLink(), TPEF::ASpaceElement::setName(), TPEF::Section::setName(), TPEF::ASpaceSection::setUndefinedASpace(), TPEF::Section::ST_ADDRSP, strings_, stringToChunk(), tpef_, undefASpace_, and undefinedAddressSpace().

Referenced by codeAddressSpace(), LabelManager::finalize(), findDataAddressSpace(), LabelManager::findOrCreateRelocationSection(), initResourceSection(), nullSection(), stringSection(), stringToChunk(), and undefinedAddressSpace().

Here is the call graph for this function:

Member Data Documentation

◆ addressSpaces_

std::map<std::string, TPEF::ASpaceElement*> MachineResourceManager::addressSpaces_

private

Bookkeeping for already requested address spaces.

Definition at line 216 of file MachineResourceManager.hh.

Referenced by codeAddressSpace(), and findDataAddressSpace().

◆ adf_

const TTAMachine::Machine& MachineResourceManager::adf_

private

Machine where manager tries to find used resources.

Definition at line 202 of file MachineResourceManager.hh.

Referenced by codeAddressSpace(), findBusWidth(), findDataAddressSpace(), functionUnitPortResource(), indexResource(), initResourceSection(), registerFileIndexReference(), and rFPortOrFUIndexReference().

◆ aSpaceSection_

TPEF::ASpaceSection* MachineResourceManager::aSpaceSection_

private

The address space section of TPEF.

Definition at line 205 of file MachineResourceManager.hh.

Referenced by codeAddressSpace(), findDataAddressSpace(), and undefinedAddressSpace().

◆ codeASpace_

TPEF::ASpaceElement* MachineResourceManager::codeASpace_

private

The instruction address space element of TPEF.

Definition at line 214 of file MachineResourceManager.hh.

Referenced by codeAddressSpace().

◆ functionUnitIDs_

std::map<TTAMachine::FunctionUnit*, UValue> MachineResourceManager::functionUnitIDs_

private

Bookkeeping of already added function units.

Definition at line 229 of file MachineResourceManager.hh.

Referenced by functionUnitID().

◆ lastFunctionUnitID_

UValue MachineResourceManager::lastFunctionUnitID_

private

For generating function unit resource ids.

Definition at line 227 of file MachineResourceManager.hh.

Referenced by functionUnitID().

◆ lastOpOrSpecRegisterID_

UValue MachineResourceManager::lastOpOrSpecRegisterID_

private

For generating shared ids for ports, operations or special registers.

Definition at line 237 of file MachineResourceManager.hh.

Referenced by opOrPortID().

◆ lastRegisterFileID_

UValue MachineResourceManager::lastRegisterFileID_

private

For generating register file resource ids.

Definition at line 232 of file MachineResourceManager.hh.

Referenced by registerFileID().

◆ nullSection_

TPEF::NullSection* MachineResourceManager::nullSection_

private

The null section of TPEF.

Definition at line 219 of file MachineResourceManager.hh.

Referenced by nullSection().

◆ opOrPortIDs_

std::map<std::string, UValue> MachineResourceManager::opOrPortIDs_

private

Bookkeeping of already added ports, operations and special registers.

Definition at line 239 of file MachineResourceManager.hh.

Referenced by opOrPortID().

◆ parent_

AssemblyParserDiagnostic* MachineResourceManager::parent_

private

Assembler root class for adding warnings.

Definition at line 242 of file MachineResourceManager.hh.

Referenced by indexResource(), and rFPortOrFUIndexReference().

◆ registerFileIDs_

std::map<TTAMachine::BaseRegisterFile*, UValue> MachineResourceManager::registerFileIDs_

private

Bookkeeping of already added register files.

Definition at line 234 of file MachineResourceManager.hh.

Referenced by registerFileID().

◆ resourceMap_

std::map<ResourceKey, ResourceID> MachineResourceManager::resourceMap_

private

Bookkeeping for already requested resources.

Definition at line 224 of file MachineResourceManager.hh.

Referenced by resourceID().

◆ resourceSection_

TPEF::ResourceSection* MachineResourceManager::resourceSection_

private

The resource section of TPEF.

Definition at line 222 of file MachineResourceManager.hh.

Referenced by addResourceElement(), initResourceSection(), and resourceSection().

◆ strings_

TPEF::StringSection* MachineResourceManager::strings_

private

The string section of TPEF.

Definition at line 208 of file MachineResourceManager.hh.

Referenced by addResourceElement(), initResourceSection(), stringSection(), stringToChunk(), and undefinedAddressSpace().

◆ tpef_

TPEF::Binary& MachineResourceManager::tpef_

private

Binary where all used resources are added.

Definition at line 199 of file MachineResourceManager.hh.

Referenced by initResourceSection(), nullSection(), stringToChunk(), and undefinedAddressSpace().

◆ undefASpace_

TPEF::ASpaceElement* MachineResourceManager::undefASpace_

private

The undefined address space element of TPEF.

Definition at line 211 of file MachineResourceManager.hh.

Referenced by undefinedAddressSpace().

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

Classes

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ RequestType

Constructor & Destructor Documentation

◆ MachineResourceManager()

Member Function Documentation

◆ addResourceElement()

◆ codeAddressSpace()

◆ findBusWidth()

◆ findDataAddressSpace()

◆ functionUnitID()

◆ functionUnitPortResource()

◆ indexResource()

◆ initResourceSection()

◆ nullSection()

◆ opOrPortID()

◆ registerFileID()

◆ registerFileIndexReference()

◆ requestTypeString()

◆ resourceID()

◆ resourceSection()

◆ rFPortOrFUIndexReference()

◆ stringSection()

◆ stringToChunk()

◆ undefinedAddressSpace()

Member Data Documentation

◆ addressSpaces_

◆ adf_

◆ aSpaceSection_

◆ codeASpace_

◆ functionUnitIDs_

◆ lastFunctionUnitID_

◆ lastOpOrSpecRegisterID_

◆ lastRegisterFileID_

◆ nullSection_

◆ opOrPortIDs_

◆ parent_

◆ registerFileIDs_

◆ resourceMap_

◆ resourceSection_

◆ strings_

◆ tpef_

◆ undefASpace_