TTAProgram::TPEFResourceUpdater Class Reference

#include <ProgramWriter.hh>

Collaboration diagram for TTAProgram::TPEFResourceUpdater:

Public Member Functions
	TPEFResourceUpdater (TTAMachine::Machine &mach, TPEF::ResourceSection &resources)
void	clearCache ()
TPEF::ResourceElement &	bus (const TTAMachine::Bus &bus)
TPEF::ResourceElement &	functionUnitPort (const TTAMachine::Port &port)
TPEF::ResourceElement &	operand (const TTAMachine::HWOperation &oper, int operandIndex)
TPEF::ResourceElement &	functionUnit (const TTAMachine::FunctionUnit &fu)
TPEF::ResourceElement &	registerFile (const TTAMachine::RegisterFile &rf)
TPEF::ResourceElement &	immediateUnit (const TTAMachine::ImmediateUnit &immUnit)

Private Types
typedef std::pair< const TTAMachine::MachinePart *, int >	CacheKey
typedef std::map< CacheKey, TPEF::ResourceElement * >	ResourceCache
	Mapping from parts of the target processor model to TPEF machine resource entries. More...

Private Member Functions
void	initCache ()

Private Attributes
TTAMachine::Machine &	mach_
	The model of the target processor architecture. More...
TPEF::ResourceSection &	resources_
	The TPEF input section that contains all machine resource entries. More...
ResourceCache	cache_
	Aggregate of all mappings between machine resource entries and target processor parts (machine parts). More...
HalfWord	lastBusId_
	Last TPEF bus id that was generated. More...
HalfWord	lastUnitPortId_
	Last TPEF unit port id that was generated. More...
HalfWord	lastFunctionUnitId_
	Last TPEF function unit id that was generated. More...
HalfWord	lastRegisterFileId_
	Last TPEF register file id that was generated. More...
HalfWord	lastImmediateUnitId_
	Last TPEF immediate unit id that was generated. More...

Detailed Description

Returns requested Machine parts as a TPEF resources.

Also adds new resources to resource section if resource is not already there.

NOTE: If resource section is modified externally, cache should be cleared.

Definition at line 81 of file ProgramWriter.hh.

Member Typedef Documentation

CacheKey

typedef std::pair<const TTAMachine::MachinePart*, int> TTAProgram::TPEFResourceUpdater::CacheKey

private

Definition at line 109 of file ProgramWriter.hh.

ResourceCache

typedef std::map<CacheKey, TPEF::ResourceElement*> TTAProgram::TPEFResourceUpdater::ResourceCache

private

Mapping from parts of the target processor model to TPEF machine resource entries.

Definition at line 112 of file ProgramWriter.hh.

Constructor & Destructor Documentation

TPEFResourceUpdater()

TTAProgram::TPEFResourceUpdater::TPEFResourceUpdater	(	TTAMachine::Machine &	mach,
		TPEF::ResourceSection &	resources
	)

Definition at line 151 of file ProgramWriter.cc.

                                               :
    mach_(mach), resources_(resources),
    lastBusId_(1), lastUnitPortId_(1),
    lastFunctionUnitId_(1), lastRegisterFileId_(1),
    lastImmediateUnitId_(1) {
 
    initCache();
}

References initCache().

Here is the call graph for this function:

Member Function Documentation

bus()

ResourceElement & TTAProgram::TPEFResourceUpdater::bus

(

const TTAMachine::Bus &

bus

)

Finds and creates ResourceElement for the bus given in parameter.

If resource id not already created to TPEF method creates it and adds CacheKey for it.

Parameters

bus	Bus whose tpef resource is looked for.

Returns

ResourceElement for the bus given in parameter.

Definition at line 317 of file ProgramWriter.cc.

                                       {
 
    CacheKey key = CacheKey(&bus, 0);
    if (!MapTools::containsKey(cache_, key)) {
        ResourceElement *newRes = new ResourceElement();
 
        newRes->setType(ResourceElement::MRT_BUS);
 
        // check if bus belongs to universal machine, set universal bus ID
        // if it does
        UniversalMachine *uMach =
            dynamic_cast<UniversalMachine*>(bus.machine());
 
        if (uMach == NULL) {
            newRes->setId(lastBusId_++);
 
        } else {
            // find universal bus
            if (&bus == &uMach->universalBus()) {
                newRes->setId(ResourceElement::UNIVERSAL_BUS);
 
            } else {
                boost::format unexpectedBusMsg(
                    "Unexpected bus '%1%' in universal machine in addition "
                    "to the unique universal bus '%2%'.");
 
                abortWithError(unexpectedBusMsg.str());
            }
        }
 
        StringSection *strings =
            dynamic_cast<StringSection*>(resources_.link());
 
        newRes->setName(strings->string2Chunk(bus.name()));
#if 0
        std::cerr << "added MRT_BUS resource type: " << newRes->type()
                  << "\tid:" << newRes->id() << "\tname: "
                  << strings->chunk2String(newRes->name()) << std::endl;
#endif
        resources_.addElement(newRes);
        cache_[key] = newRes;
    }
 
    return *cache_[key];
}

References abortWithError, TPEF::Section::addElement(), cache_, TPEF::StringSection::chunk2String(), MapTools::containsKey(), TPEF::ResourceElement::id(), lastBusId_, TPEF::Section::link(), TPEF::ResourceElement::name(), resources_, TPEF::ResourceElement::setId(), TPEF::ResourceElement::setName(), TPEF::ResourceElement::setType(), TPEF::StringSection::string2Chunk(), TPEF::ResourceElement::type(), and UniversalMachine::universalBus().

Referenced by TTAProgram::ProgramWriter::createCodeSection(), and initCache().

Here is the call graph for this function:

clearCache()

void TTAProgram::TPEFResourceUpdater::clearCache

(

)

Clears the temporary variables and reinits the cache.

Definition at line 296 of file ProgramWriter.cc.

                                {
    cache_.clear();
    lastBusId_ = 1;
    lastUnitPortId_ = 1;
    lastFunctionUnitId_ = 1;
    lastRegisterFileId_ = 1;
    lastImmediateUnitId_ = 1;
    initCache();
}

References cache_, initCache(), lastBusId_, lastFunctionUnitId_, lastImmediateUnitId_, lastRegisterFileId_, and lastUnitPortId_.

Here is the call graph for this function:

functionUnit()

ResourceElement & TTAProgram::TPEFResourceUpdater::functionUnit

(

const TTAMachine::FunctionUnit &

fu

)

Finds and creates ResourceElement for a fu given in parameter.

If resource id not already created to TPEF method creates it and adds CacheKey for it.

Parameters

fu	Function unit whose TPEF resource is looked for.

Returns

ResourceElement for the function unit given in parameter.

Definition at line 512 of file ProgramWriter.cc.

                                                        {
 
    CacheKey key = CacheKey(&fu, 0);
 
    if (!MapTools::containsKey(cache_, key)) {
        ResourceElement *newRes = new ResourceElement();
 
        newRes->setType(ResourceElement::MRT_UNIT);
 
        // check if universal and set universal id
        // if reference to universal machine
        UniversalMachine *uMach =
            dynamic_cast<UniversalMachine*>(fu.machine());
 
        if (uMach == NULL) {
            newRes->setId(lastFunctionUnitId_++);
            resources_.addElement(newRes);
 
        } else {
            // find universal function unit or gcu...
            if (&fu == &uMach->universalFunctionUnit() ||
                &fu == uMach->controlUnit()) {
 
                CacheKey uFUKey = CacheKey(
                    &uMach->universalFunctionUnit(), 0);
                CacheKey uGCUKey = CacheKey(uMach->controlUnit(), 0);
 
                // check if resource element is already created
                if (MapTools::containsKey(cache_, uFUKey)) {
                    delete newRes;
                    newRes = cache_[uFUKey];
 
                } else if (MapTools::containsKey(cache_, uGCUKey)) {
                    delete newRes;
                    newRes = cache_[uGCUKey];
 
                } else {
                    newRes->setId(ResourceElement::UNIVERSAL_FU);
                    resources_.addElement(newRes);
                }
 
            } else {
                abortWithError(
                    "Unknown universal machine reference to function unit: " +
                    fu.name());
            }
        }
 
        StringSection *strings =
            dynamic_cast<StringSection*>(resources_.link());
 
        newRes->setName(strings->string2Chunk(fu.name()));
#if 0
        std::cerr << "added MRT_UNIT resource type: " << newRes->type()
                  << "\tid:" << newRes->id() << "\tname: "
                  << strings->chunk2String(newRes->name()) << std::endl;
#endif
 
        cache_[key] = newRes;
    }
    return *cache_[key];
}

References abortWithError, TPEF::Section::addElement(), cache_, TPEF::StringSection::chunk2String(), MapTools::containsKey(), TTAMachine::Machine::controlUnit(), TPEF::ResourceElement::id(), lastFunctionUnitId_, TPEF::Section::link(), TTAMachine::Component::machine(), TPEF::ResourceElement::name(), TTAMachine::Component::name(), resources_, TPEF::ResourceElement::setId(), TPEF::ResourceElement::setName(), TPEF::ResourceElement::setType(), TPEF::StringSection::string2Chunk(), TPEF::ResourceElement::type(), and UniversalMachine::universalFunctionUnit().

Referenced by TTAProgram::ProgramWriter::createCodeSection(), and TTAProgram::ProgramWriter::terminalResource().

Here is the call graph for this function:

functionUnitPort()

ResourceElement & TTAProgram::TPEFResourceUpdater::functionUnitPort

(

const TTAMachine::Port &

port

)

Finds and creates ResourceElement for a fu port given in parameter.

If resource id not already created to TPEF method creates it and adds CacheKey for it.

Parameters

port	Port whose tpef resource is looked for.

Returns

ResourceElement for the machine part given in parameter.

Definition at line 373 of file ProgramWriter.cc.

                                                      {
 
    CacheKey key = CacheKey(&port, 0);
    if (!MapTools::containsKey(cache_, key)) {
        ResourceElement *newRes = new ResourceElement();
 
        if (dynamic_cast<const TTAMachine::FUPort*>(&port) != NULL) {
            newRes->setType(ResourceElement::MRT_PORT);
 
        } else if (dynamic_cast<const TTAMachine::SpecialRegisterPort*>(
                       &port) != NULL) {
 
            newRes->setType(ResourceElement::MRT_SR);
 
        } else {
            abortWithError(
                "Port must be either FUPort or SpecialRegisterPort!");
        }
 
        newRes->setId((lastUnitPortId_++));
 
        StringSection *strings =
            dynamic_cast<StringSection*>(resources_.link());
 
        // check if universal and set return-address register name if needed
        UniversalMachine *uMach =
            dynamic_cast<UniversalMachine*>(port.parentUnit()->machine());
 
        if (uMach != NULL) {
            assert(uMach->controlUnit()->hasReturnAddressPort());
            if (uMach->controlUnit()->returnAddressPort() == &port) {
 
                newRes->setName(
                    strings->string2Chunk(
                        ResourceElement::RETURN_ADDRESS_NAME));
            } else {
 
                const SpecialRegisterPort* srp =
                    dynamic_cast<const SpecialRegisterPort*>(&port);
 
                if (srp == NULL) {
                    boost::format unexpectedPortMsg(
                        "Port '%1%' in universal global control unit. "
                        "Normal RF and FU ports are not allowed there.");
                    unexpectedPortMsg % port.name();
                    abortWithError(unexpectedPortMsg.str());
 
                } else {
                    // Might be allowed in the future if the system can
                    // be extended to support open-ended sets of special
                    // register ports in GCU.
                    boost::format unexpectedSRPortMsg(
                        "The special register port '%1%' is not one of "
                        "the ports currently supported by the global "
                        "control unit.");
                    unexpectedSRPortMsg % port.name();
                    abortWithError(unexpectedSRPortMsg.str());
                }
            }
        } else {
            newRes->setName(strings->string2Chunk(port.name()));
        }
 
#if 0
        std::cerr << "added MRT_SR resource type: " << newRes->type()
                  << "\tid:" << newRes->id() << "\tname: "
                  << strings->chunk2String(newRes->name()) << std::endl;
#endif
        resources_.addElement(newRes);
 
        // TODO: check that port is really found from universal or normal
        // machine
        cache_[CacheKey(&port, 0)] = newRes;
 
    }
 
    return *cache_[key];
}

References abortWithError, TPEF::Section::addElement(), assert, cache_, TPEF::StringSection::chunk2String(), MapTools::containsKey(), TTAMachine::Machine::controlUnit(), TTAMachine::ControlUnit::hasReturnAddressPort(), TPEF::ResourceElement::id(), lastUnitPortId_, TPEF::Section::link(), TTAMachine::Component::machine(), TTAMachine::Port::name(), TPEF::ResourceElement::name(), TTAMachine::Port::parentUnit(), resources_, TTAMachine::ControlUnit::returnAddressPort(), TPEF::ResourceElement::setId(), TPEF::ResourceElement::setName(), TPEF::ResourceElement::setType(), TPEF::StringSection::string2Chunk(), and TPEF::ResourceElement::type().

Referenced by TTAProgram::ProgramWriter::createCodeSection(), and TTAProgram::ProgramWriter::terminalResource().

Here is the call graph for this function:

immediateUnit()

ResourceElement & TTAProgram::TPEFResourceUpdater::immediateUnit

(

const TTAMachine::ImmediateUnit &

immUnit

)

Find and return the TPEF machine resource entry that corresponds to a given immediate unit of the target processor.

If no machine resource entry exists for the given unit, it is created, cached into the resource updater and added to the TPEF machine resource section.

Parameters

immUnit

An immediate unit of the target processor.

Returns

The machine resource entry corresponding to given unit.

Definition at line 646 of file ProgramWriter.cc.

                                                               {
 
    CacheKey key = CacheKey(&immUnit, 0);
    if (!MapTools::containsKey(cache_, key)) {
        ResourceElement* newRes = new ResourceElement();
 
        newRes->setType(ResourceElement::MRT_IMM);
        newRes->setId(lastImmediateUnitId_++);
 
        StringSection* strings =
            dynamic_cast<StringSection*>(resources_.link());
 
        newRes->setName(strings->string2Chunk(immUnit.name()));
 
#if 0
        std::cerr << "added MRT_IMM resource type: " << newRes->type()
            << "\tid:" << newRes->id() << "\tname: "
            << strings->chunk2String(newRes->name()) << std::endl;
#endif
 
        resources_.addElement(newRes);
        cache_[key] = newRes;
    }
    return *cache_[key];
}

References TPEF::Section::addElement(), cache_, TPEF::StringSection::chunk2String(), MapTools::containsKey(), TPEF::ResourceElement::id(), lastImmediateUnitId_, TPEF::Section::link(), TPEF::ResourceElement::name(), TTAMachine::Component::name(), resources_, TPEF::ResourceElement::setId(), TPEF::ResourceElement::setName(), TPEF::ResourceElement::setType(), TPEF::StringSection::string2Chunk(), and TPEF::ResourceElement::type().

Referenced by TTAProgram::ProgramWriter::terminalResource().

Here is the call graph for this function:

initCache()

void TTAProgram::TPEFResourceUpdater::initCache ( )

private

Initialises resource updater cache, for finding TPEF resources by machine resources.

This also checks already created TPEF resources to prevent multiple creation of the same ResourceElement.

Definition at line 169 of file ProgramWriter.cc.

                               {
 
    for (Word i = 0; i < resources_.elementCount(); i++) {
        ResourceElement* currRes =
            dynamic_cast<ResourceElement*>(resources_.element(i));
 
        StringSection* strings =
            dynamic_cast<StringSection*>(resources_.link());
 
        std::string resourceName = strings->chunk2String(currRes->name());
 
        switch(currRes->type()) {
 
        case ResourceElement::MRT_NULL: {
            abortWithError("There should not be NULL resources.");
        } break;
 
        case ResourceElement::MRT_BUS: {
            Machine::BusNavigator navi = mach_.busNavigator();
            assert(navi.hasItem(resourceName));
            Bus *bus = navi.item(resourceName);
 
            cache_[CacheKey(bus, 0)] = currRes;
        } break;
 
        case ResourceElement::MRT_UNIT: {
            Machine::FunctionUnitNavigator navi =
                mach_.functionUnitNavigator();
            assert(navi.hasItem(resourceName));
 
            if (lastFunctionUnitId_ < currRes->id()) {
                lastFunctionUnitId_ = currRes->id()+1;
            }
 
            FunctionUnit *fu = navi.item(resourceName);
 
            cache_[CacheKey(fu, 0)] = currRes;
        } break;
 
        case ResourceElement::MRT_RF: {
            Machine::RegisterFileNavigator navi =
                mach_.registerFileNavigator();
            assert(navi.hasItem(resourceName));
 
            if (lastRegisterFileId_ < currRes->id()) {
                lastRegisterFileId_ = currRes->id()+1;
            }
 
            RegisterFile *rf = navi.item(resourceName);
 
            cache_[CacheKey(rf, 0)] = currRes;
        } break;
 
        case ResourceElement::MRT_OP: {
            std::string::size_type dotPos = resourceName.find('.');
            assert(dotPos != std::string::npos);
 
            std::string operName = resourceName.substr(0, dotPos);
 
            int operandIndex = Conversion::toInt(
                resourceName.substr(
                    dotPos+1, resourceName.length() - dotPos - 1));
 
            Machine::FunctionUnitNavigator navi =
                mach_.functionUnitNavigator();
 
            if (lastUnitPortId_ < currRes->id()) {
                lastUnitPortId_ = currRes->id()+1;
            }
 
            // if function unit has operation by that name, get HWOperation...
            for (int i = 0; i < navi.count(); i++) {
                FunctionUnit *fu = navi.item(i);
                if (fu->hasOperation(operName)) {
                    cache_[CacheKey(fu->operation(operName), operandIndex)] =
                        currRes;
                }
            }
 
        } break;
 
        case ResourceElement::MRT_IMM: {
            Machine::ImmediateUnitNavigator navi =
                mach_.immediateUnitNavigator();
            assert(navi.hasItem(resourceName));
 
            if (lastImmediateUnitId_ < currRes->id()) {
                lastImmediateUnitId_ = currRes->id()+1;
            }
 
            ImmediateUnit* immUnit = navi.item(resourceName);
 
            cache_[CacheKey(immUnit, 0)] = currRes;
 
        } break;
 
        case ResourceElement::MRT_PORT:
        case ResourceElement::MRT_SR: {
            Machine::FunctionUnitNavigator navi =
                mach_.functionUnitNavigator();
 
            if (lastUnitPortId_ < currRes->id()) {
                lastUnitPortId_ = currRes->id()+1;
            }
 
            // if function unit has port by that name, get port
            for (int i = 0; i < navi.count(); i++) {
                FunctionUnit *fu = navi.item(i);
 
                if (fu->hasPort(resourceName)) {
                    cache_[CacheKey(fu->port(resourceName), 0)] = currRes;
                }
            }
        } break;
 
        default:
            abortWithError("Unknown resource type.");
        }
 
    }
}

References abortWithError, assert, bus(), TTAMachine::Machine::busNavigator(), cache_, TPEF::StringSection::chunk2String(), TPEF::Section::element(), TPEF::Section::elementCount(), TTAMachine::Machine::functionUnitNavigator(), TTAMachine::FunctionUnit::hasOperation(), TTAMachine::Unit::hasPort(), TPEF::ResourceElement::id(), TTAMachine::Machine::immediateUnitNavigator(), lastFunctionUnitId_, lastImmediateUnitId_, lastRegisterFileId_, lastUnitPortId_, TPEF::Section::link(), mach_, TPEF::ResourceElement::name(), TTAMachine::FunctionUnit::operation(), TTAMachine::FunctionUnit::port(), TTAMachine::Machine::registerFileNavigator(), resources_, Conversion::toInt(), and TPEF::ResourceElement::type().

Referenced by clearCache(), and TPEFResourceUpdater().

Here is the call graph for this function:

operand()

ResourceElement & TTAProgram::TPEFResourceUpdater::operand	(	const TTAMachine::HWOperation &	oper,
		int	operandIndex
	)

Finds and creates ResourceElement for a fu operand given in parameter.

If resource id not already created to TPEF method creates it and adds CacheKey for it.

Parameters

oper	Operation whose TPEF resource is looked for.
operandIndex	Index of the operand of operation.

Returns

ResourceElement for the operand given in parameter.

Definition at line 464 of file ProgramWriter.cc.

                                                                      {
 
    CacheKey key = CacheKey(&oper, operandIndex);
    if (!MapTools::containsKey(cache_, key)) {
 
        ResourceElement *newRes = new ResourceElement();
 
        newRes->setType(ResourceElement::MRT_OP);
        newRes->setId(lastUnitPortId_++);
 
        StringSection *strings =
            dynamic_cast<StringSection*>(resources_.link());
 
        newRes->setName(
            strings->string2Chunk(
                oper.name() + "." + Conversion::toString(operandIndex)));
#if 0
        std::cerr << "Added MRT_OP resource type: " << newRes->type()
                  << "\tid:" << newRes->id() << "\tname: "
                  << strings->chunk2String(newRes->name()) << std::endl;
#endif
        resources_.addElement(newRes);
 
        FunctionUnit *parentUnit = oper.parentUnit();
 
        if (parentUnit->hasOperation(oper.name())) {
            cache_[CacheKey(parentUnit->operation(oper.name()),
                            operandIndex)] = newRes;
        } else {
            abortWithError(
                "Parent unit: " + parentUnit->name() +
                " didn't contain requested operation:" + oper.name());
        }
    }
    return *cache_[key];
}

References abortWithError, TPEF::Section::addElement(), cache_, TPEF::StringSection::chunk2String(), MapTools::containsKey(), TTAMachine::FunctionUnit::hasOperation(), TPEF::ResourceElement::id(), lastUnitPortId_, TPEF::Section::link(), TTAMachine::HWOperation::name(), TPEF::ResourceElement::name(), TTAMachine::Component::name(), TTAMachine::FunctionUnit::operation(), TTAMachine::HWOperation::parentUnit(), resources_, TPEF::ResourceElement::setId(), TPEF::ResourceElement::setName(), TPEF::ResourceElement::setType(), TPEF::StringSection::string2Chunk(), Conversion::toString(), and TPEF::ResourceElement::type().

Referenced by TTAProgram::ProgramWriter::createCodeSection(), and TTAProgram::ProgramWriter::terminalResource().

Here is the call graph for this function:

registerFile()

ResourceElement & TTAProgram::TPEFResourceUpdater::registerFile

(

const TTAMachine::RegisterFile &

rf

)

Finds and creates ResourceElement for a rf given in parameter.

If resource id not already created to TPEF method creates it and adds CacheKey for it.

Parameters

rf	Register file whose TPEF resource is looked for.

Returns

ResourceElement for the register file given in parameter.

Definition at line 586 of file ProgramWriter.cc.

                                                        {
 
    CacheKey key = CacheKey(&rf, 0);
    if (!MapTools::containsKey(cache_, key)) {
        ResourceElement *newRes = new ResourceElement();
 
        newRes->setType(ResourceElement::MRT_RF);
 
        // check if universal RF
        UniversalMachine *uMach =
            dynamic_cast<UniversalMachine*>(rf.machine());
 
        if (uMach == NULL) {
            newRes->setId(lastRegisterFileId_++);
 
        } else {
 
            // find universal register file
            if (&rf == &uMach->booleanRegisterFile()) {
                newRes->setId(ResourceElement::BOOL_RF);
            } else if (&rf == &uMach->integerRegisterFile()) {
                newRes->setId(ResourceElement::INT_RF);
            } else if (&rf == &uMach->doubleRegisterFile()) {
                newRes->setId(ResourceElement::FP_RF);
            } else {
                abortWithError(
                    "Reference to unknown universal register file.");
            }
        }
 
        StringSection *strings =
            dynamic_cast<StringSection*>(resources_.link());
 
        newRes->setName(strings->string2Chunk(rf.name()));
 
#if 0
        std::cerr << "added MRT_RF resource type: " << newRes->type()
            << "\tid:" << newRes->id() << "\tname: "
            << strings->chunk2String(newRes->name()) << std::endl;
#endif
 
        resources_.addElement(newRes);
        cache_[key] = newRes;
    }
    return *cache_[key];
}

References abortWithError, TPEF::Section::addElement(), UniversalMachine::booleanRegisterFile(), cache_, TPEF::StringSection::chunk2String(), MapTools::containsKey(), UniversalMachine::doubleRegisterFile(), TPEF::ResourceElement::id(), UniversalMachine::integerRegisterFile(), lastRegisterFileId_, TPEF::Section::link(), TTAMachine::Component::machine(), TPEF::ResourceElement::name(), TTAMachine::Component::name(), resources_, TPEF::ResourceElement::setId(), TPEF::ResourceElement::setName(), TPEF::ResourceElement::setType(), TPEF::StringSection::string2Chunk(), and TPEF::ResourceElement::type().

Referenced by TTAProgram::ProgramWriter::createCodeSection(), and TTAProgram::ProgramWriter::terminalResource().

Here is the call graph for this function:

Member Data Documentation

cache_

ResourceCache TTAProgram::TPEFResourceUpdater::cache_

private

Aggregate of all mappings between machine resource entries and target processor parts (machine parts).

Definition at line 116 of file ProgramWriter.hh.

Referenced by bus(), clearCache(), functionUnit(), functionUnitPort(), immediateUnit(), initCache(), operand(), and registerFile().

lastBusId_

HalfWord TTAProgram::TPEFResourceUpdater::lastBusId_

private

Last TPEF bus id that was generated.

Definition at line 119 of file ProgramWriter.hh.

Referenced by bus(), and clearCache().

lastFunctionUnitId_

HalfWord TTAProgram::TPEFResourceUpdater::lastFunctionUnitId_

private

Last TPEF function unit id that was generated.

Definition at line 123 of file ProgramWriter.hh.

Referenced by clearCache(), functionUnit(), and initCache().

lastImmediateUnitId_

HalfWord TTAProgram::TPEFResourceUpdater::lastImmediateUnitId_

private

Last TPEF immediate unit id that was generated.

Definition at line 127 of file ProgramWriter.hh.

Referenced by clearCache(), immediateUnit(), and initCache().

lastRegisterFileId_

HalfWord TTAProgram::TPEFResourceUpdater::lastRegisterFileId_

private

Last TPEF register file id that was generated.

Definition at line 125 of file ProgramWriter.hh.

Referenced by clearCache(), initCache(), and registerFile().

lastUnitPortId_

HalfWord TTAProgram::TPEFResourceUpdater::lastUnitPortId_

private

Last TPEF unit port id that was generated.

Definition at line 121 of file ProgramWriter.hh.

Referenced by clearCache(), functionUnitPort(), initCache(), and operand().

mach_

TTAMachine::Machine& TTAProgram::TPEFResourceUpdater::mach_

private

The model of the target processor architecture.

Definition at line 103 of file ProgramWriter.hh.

Referenced by initCache().

resources_

TPEF::ResourceSection& TTAProgram::TPEFResourceUpdater::resources_

private

The TPEF input section that contains all machine resource entries.

Definition at line 105 of file ProgramWriter.hh.

Referenced by bus(), functionUnit(), functionUnitPort(), immediateUnit(), initCache(), operand(), and registerFile().

---

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

• ProgramWriter.hh
• ProgramWriter.cc