TTAMachine::InstructionTemplate Class Reference

#include <InstructionTemplate.hh>

Inheritance diagram for TTAMachine::InstructionTemplate:

Collaboration diagram for TTAMachine::InstructionTemplate:

Public Member Functions
	InstructionTemplate (const std::string &name, Machine &owner)
	InstructionTemplate (const ObjectState *state, Machine &owner)
virtual	~InstructionTemplate ()
virtual void	setName (const std::string &name)
virtual void	addSlot (const std::string &slotName, int width, ImmediateUnit &dstUnit)
virtual void	removeSlot (const std::string &slotName)
virtual void	removeSlots (const ImmediateUnit &dstUnit)
virtual int	slotCount () const
virtual TemplateSlot *	slot (int index) const
TemplateSlot *	templateSlot (const std::string &slotName) const
virtual bool	usesSlot (const std::string &slotName) const
virtual bool	destinationUsesSlot (const std::string &slotName, const ImmediateUnit &dstUnit) const
virtual int	numberOfDestinations () const
virtual bool	isOneOfDestinations (const ImmediateUnit &dstUnit) const
virtual ImmediateUnit *	destinationOfSlot (const std::string &slotName) const
virtual int	numberOfSlots (const ImmediateUnit &dstUnit) const
virtual std::string	slotOfDestination (const ImmediateUnit &dstUnit, int index) const
virtual int	supportedWidth () const
virtual int	supportedWidth (const ImmediateUnit &dstUnit) const
virtual int	supportedWidth (const std::string &slotName) const
virtual bool	isEmpty () const
virtual void	setMachine (Machine &machine)
virtual void	unsetMachine ()
virtual ObjectState *	saveState () const
virtual void	loadState (const ObjectState *state)
Public Member Functions inherited from TTAMachine::Component
virtual	~Component ()
virtual TCEString	name () const
virtual Machine *	machine () const
virtual void	ensureRegistration (const Component &component) const
virtual bool	isRegistered () const
Public Member Functions inherited from Serializable
virtual	~Serializable ()

Static Public Attributes
static const std::string	OSNAME_INSTRUCTION_TEMPLATE = "i_template"
	ObjectState name for instruction template. More...
Static Public Attributes inherited from TTAMachine::Component
static const std::string	OSNAME_COMPONENT = "component"
	ObjectState name for component. More...
static const std::string	OSKEY_NAME = "name"
	ObjectState attribute key for the name of the component. More...

Private Types
typedef std::vector< TemplateSlot * >	SlotTable
	Container for TemplateSlots. More...

Private Member Functions
void	deleteAllSlots ()

Private Attributes
SlotTable	slots_
	Contains all the slots of the instruction template. More...

Additional Inherited Members
Protected Member Functions inherited from TTAMachine::Component
	Component (const std::string &name)
	Component (const ObjectState *state)
void	internalSetMachine (Machine &machine)
void	internalUnsetMachine ()
Protected Member Functions inherited from TTAMachine::MachinePart
	MachinePart ()
virtual	~MachinePart ()

Detailed Description

Definition at line 49 of file InstructionTemplate.hh.

Member Typedef Documentation

SlotTable

typedef std::vector<TemplateSlot*> TTAMachine::InstructionTemplate::SlotTable

private

Container for TemplateSlots.

Definition at line 94 of file InstructionTemplate.hh.

Constructor & Destructor Documentation

InstructionTemplate() [1/2]

TTAMachine::InstructionTemplate::InstructionTemplate	(	const std::string &	name,
		Machine &	owner
	)

Constructor.

Creates an empty instruction template. Add slots to make the instruction template non-empty. An empty instruction template represents the encoding format of instructions that don't specify any bits of a long immediate or any immediate register-write action.

Parameters

name	Name of the instruction template.
owner	The machine to which the instruction template is going to be registered.

Exceptions

ComponentAlreadyExists	If the given machine already contains another instruction template by the same name.
InvalidName	If the given name is not a valid component name.

Definition at line 69 of file InstructionTemplate.cc.

    : Component(name) {
    setMachine(owner);
}

References setMachine().

Here is the call graph for this function:

InstructionTemplate() [2/2]

TTAMachine::InstructionTemplate::InstructionTemplate	(	const ObjectState *	state,
		Machine &	owner
	)

Constructor.

Loads the state of the instruction template completely from the given ObjectState tree.

Parameters

state	The ObjectState instance.
owner	The machine to which the instruction template is going to be registered.

Exceptions

ObjectStateLoadingException

If the given ObjectState instance is invalid or if there exists an instruction template by the same as the upcoming name in the machine or if references to other components cannot be resolved.

Definition at line 90 of file InstructionTemplate.cc.

    : Component(state) {
    const string procName = "InstructionTemplate::InstructionTemplate";
 
    try {
        setMachine(owner);
    } catch (const ComponentAlreadyExists&) {
        MOMTextGenerator textGenerator;
        format errorMsg = textGenerator.text(
            MOMTextGenerator::TXT_IT_EXISTS_BY_NAME);
        errorMsg % name();
        throw ObjectStateLoadingException(
            __FILE__, __LINE__, procName, errorMsg.str());
    }
 
    try {
        loadState(state);
    } catch (const ObjectStateLoadingException&) {
        unsetMachine();
        throw;
    }
}

References loadState(), TTAMachine::Component::name(), setMachine(), Texts::TextGenerator::text(), MOMTextGenerator::TXT_IT_EXISTS_BY_NAME, and unsetMachine().

Here is the call graph for this function:

~InstructionTemplate()

TTAMachine::InstructionTemplate::~InstructionTemplate ( )

virtual

Destructor.

Deletes all the slots of this instruction template too.

Definition at line 119 of file InstructionTemplate.cc.

                                          {
    unsetMachine();
}

References unsetMachine().

Here is the call graph for this function:

Member Function Documentation

addSlot()

void TTAMachine::InstructionTemplate::addSlot ( const std::string &  slotName, int  width, ImmediateUnit &  dstUnit  )

virtual

Adds a template slot.

The given bit width must be greater than 0.

Parameters

slotName	Transport bus in which (part of) part of the long immediate is stored.
width	The number of long immediate bits that are encoded on the slot.
dstUnit	Destination immediate unit.

Exceptions

InstanceNotFound	If the machine does not have a bus or immediate slot with the given name.
IllegalRegistration	If the given destination unit is not registered to the same machine.
ComponentAlreadyExists	If the given slot is already in use.
OutOfRange	If the given bit width is out of range.

Reimplemented in TTAMachine::NullInstructionTemplate.

Definition at line 169 of file InstructionTemplate.cc.

                                                                  {
    const string procName = "InstructionTemplate::addSlot";
 
    ensureRegistration(dstUnit);
 
    if (width <= 0) {
        throw OutOfRange(__FILE__, __LINE__, procName);
    }
 
    if (templateSlot(slotName) != NULL) {
        throw ComponentAlreadyExists(__FILE__, __LINE__, procName);
    }
        
    if (machine()->busNavigator().hasItem(slotName)) {
        Bus* bus = machine()->busNavigator().item(slotName);
        slots_.push_back(new TemplateSlot(*bus, width, dstUnit));
    } else if (machine()->immediateSlotNavigator().hasItem(slotName)) {
        ImmediateSlot* slot = machine()->immediateSlotNavigator().item(
            slotName);
        slots_.push_back(new TemplateSlot(*slot, width, dstUnit));
    } else {
        throw InstanceNotFound(__FILE__, __LINE__, procName);
    }
}

References TTAMachine::Machine::busNavigator(), TTAMachine::Component::ensureRegistration(), TTAMachine::Machine::immediateSlotNavigator(), TTAMachine::Machine::Navigator< ComponentType >::item(), TTAMachine::Component::machine(), slot(), slots_, and templateSlot().

Referenced by ImmediateGenerator::addSplitInsTemplate(), BlocksTranslator::BuildTTAModel(), VLIWConnectIC::explore(), BlocksConnectIC::explore(), and loadState().

Here is the call graph for this function:

deleteAllSlots()

void TTAMachine::InstructionTemplate::deleteAllSlots ( )

private

Deletes all the template slots.

Definition at line 616 of file InstructionTemplate.cc.

                                    {
    SequenceTools::deleteAllItems(slots_);
}

References SequenceTools::deleteAllItems(), and slots_.

Referenced by loadState(), and unsetMachine().

Here is the call graph for this function:

destinationOfSlot()

ImmediateUnit * TTAMachine::InstructionTemplate::destinationOfSlot ( const std::string &  slotName ) const

virtual

Returns the destination unit of the given slot.

Parameters

slotName

Name of the slot.

Returns

The destination unit.

Exceptions

InstanceNotFound

If the instruction template does not use the given slot to encode long immediate.

Reimplemented in TTAMachine::NullInstructionTemplate.

Definition at line 346 of file InstructionTemplate.cc.

                                                                      {
    for (SlotTable::const_iterator iter = slots_.begin(); 
         iter != slots_.end(); iter++) {
        TemplateSlot* slot = *iter;
        if (slot->slot() == slotName) {
            return slot->destination();
        }
    }
 
    const string procName = "InstructionTemplate::destinationOfSlot";
    throw InstanceNotFound(__FILE__, __LINE__, procName);
}

References TTAMachine::TemplateSlot::destination(), slot(), TTAMachine::TemplateSlot::slot(), and slots_.

Referenced by CodeCompressorPlugin::encodeLongImmediate(), ITemplateBroker::setupResourceLinks(), and TemplateListDialog::updateSlotList().

Here is the call graph for this function:

destinationUsesSlot()

bool TTAMachine::InstructionTemplate::destinationUsesSlot ( const std::string &  slotName, const ImmediateUnit &  dstUnit  ) const

virtual

Returns true if the instruction template reserves the template slot given by the slotName input argument for long immediate bits that are written into a register of the given immediate unit.

Parameters

slotName	Name of the slot.
dstUnit	The destination immediate unit.

Reimplemented in TTAMachine::NullInstructionTemplate.

Definition at line 280 of file InstructionTemplate.cc.

                                        {
 
    TemplateSlot* slot = templateSlot(slotName);
    if (slot == NULL) {
        return false;
    }
 
    return (slot->destination() == &dstUnit);
}

References TTAMachine::TemplateSlot::destination(), slot(), and templateSlot().

Here is the call graph for this function:

isEmpty()

bool TTAMachine::InstructionTemplate::isEmpty ( ) const

virtual

Checks whether the instruction template is an empty instruction template which cannot have any slots.

Returns

True if the instruction template is empty, otherwise false.

Reimplemented in TTAMachine::NullInstructionTemplate.

Definition at line 494 of file InstructionTemplate.cc.

                                   {
    return (slots_.size() == 0);
}

References slots_.

Referenced by CodeCompressorPlugin::instructionTemplate(), and ImmediateGenerator::printImmediateTemplates().

isOneOfDestinations()

bool TTAMachine::InstructionTemplate::isOneOfDestinations ( const ImmediateUnit &  dstUnit ) const

virtual

Checks whether the given immediate unit is one of the immediate destinations in this instruction template.

Parameters

dstUnit

The immediate unit to check.

Returns

True if the given immediate unit is a destination, otherwise false.

Reimplemented in TTAMachine::NullInstructionTemplate.

Definition at line 323 of file InstructionTemplate.cc.

                                        {
 
    for (SlotTable::const_iterator iter = slots_.begin();
         iter != slots_.end(); iter++) {
        TemplateSlot* slot = *iter;
        if (slot->destination() == &dstUnit) {
            return true;
        }
    }
    return false;
}

References TTAMachine::TemplateSlot::destination(), slot(), and slots_.

Referenced by BEMGenerator::addLongImmDstRegisterFields(), BEMValidator::checkLImmDstRegisterFields(), TTAProgram::TPEFProgramFactory::findInstrTemplate(), ITemplateBroker::findITemplates(), IUBroker::setupResourceLinks(), and DefaultDecoderGenerator::writeInstructionTemplateProcedures().

Here is the call graph for this function:

loadState()

void TTAMachine::InstructionTemplate::loadState ( const ObjectState *  state )

virtual

Loads its state from the given ObjectState tree.

Parameters

state

The ObjectState tree.

Exceptions

ObjectStateLoadingException

If the given ObjectState tree is invalid.

Reimplemented from TTAMachine::Component.

Reimplemented in TTAMachine::NullInstructionTemplate.

Definition at line 558 of file InstructionTemplate.cc.

                                                       {
    const string procName = "InstructionTemplate::loadState";
 
    if (state->name() != OSNAME_INSTRUCTION_TEMPLATE) {
        throw ObjectStateLoadingException(__FILE__, __LINE__, procName);
    }
 
    deleteAllSlots();
    Component::loadState(state);
 
    // add template slots
    try {
        for (int i = 0; i < state->childCount(); i++) {
            MOMTextGenerator textGenerator;
            ObjectState* child = state->child(i);
 
            string slotName = child->stringAttribute(
                TemplateSlot::OSKEY_SLOT);
            if (!machine()->busNavigator().hasItem(slotName) &&
                !machine()->immediateSlotNavigator().hasItem(slotName)) {
                format errorMsg = textGenerator.text(
                    MOMTextGenerator::TXT_IT_REF_LOAD_ERR_SLOT);
                errorMsg % slotName % name();
                throw ObjectStateLoadingException(
                    __FILE__, __LINE__, procName, errorMsg.str());
            }
 
            if (child->name() == TemplateSlot::OSNAME_TEMPLATE_SLOT) {
                int width = child->intAttribute(TemplateSlot::OSKEY_WIDTH);
                string destination =
                    child->stringAttribute(TemplateSlot::OSKEY_DESTINATION);
                Machine::ImmediateUnitNavigator iuNav =
                    machine()->immediateUnitNavigator();
                ImmediateUnit* iu = NULL;
 
                try {
                    iu = iuNav.item(destination);
                } catch (const InstanceNotFound&) {
                    format errorMsg = textGenerator.text(
                        MOMTextGenerator::TXT_IT_REF_LOAD_ERR_IU);
                    errorMsg % destination % name();
                    throw ObjectStateLoadingException(
                        __FILE__, __LINE__, procName, errorMsg.str());
                }
 
                addSlot(slotName, width, *iu);
            }
        }
    } catch (const Exception& exception) {
        throw ObjectStateLoadingException(
            __FILE__, __LINE__, procName, exception.errorMessage());
    }
}

References addSlot(), ObjectState::child(), ObjectState::childCount(), deleteAllSlots(), Exception::errorMessage(), TTAMachine::Machine::immediateUnitNavigator(), ObjectState::intAttribute(), TTAMachine::Machine::Navigator< ComponentType >::item(), TTAMachine::Component::loadState(), TTAMachine::Component::machine(), ObjectState::name(), TTAMachine::Component::name(), TTAMachine::TemplateSlot::OSKEY_DESTINATION, TTAMachine::TemplateSlot::OSKEY_SLOT, TTAMachine::TemplateSlot::OSKEY_WIDTH, OSNAME_INSTRUCTION_TEMPLATE, TTAMachine::TemplateSlot::OSNAME_TEMPLATE_SLOT, ObjectState::stringAttribute(), Texts::TextGenerator::text(), MOMTextGenerator::TXT_IT_REF_LOAD_ERR_IU, and MOMTextGenerator::TXT_IT_REF_LOAD_ERR_SLOT.

Referenced by InstructionTemplate().

Here is the call graph for this function:

numberOfDestinations()

int TTAMachine::InstructionTemplate::numberOfDestinations ( ) const

virtual

Returns how many immediate units are written in parallel by this instruction template.

Returns

The number of immediate units.

Reimplemented in TTAMachine::NullInstructionTemplate.

Definition at line 300 of file InstructionTemplate.cc.

                                                {
 
    std::set<ImmediateUnit*> destinations;
 
    for (SlotTable::const_iterator iter = slots_.begin();
         iter != slots_.end(); iter++) {
        TemplateSlot* slot = *iter;
        destinations.insert(slot->destination());
    }
 
    return destinations.size();
}

References TTAMachine::TemplateSlot::destination(), slot(), and slots_.

Referenced by TTAProgram::TPEFProgramFactory::findInstrTemplate(), and ImmediateGenerator::printImmediateTemplates().

Here is the call graph for this function:

numberOfSlots()

int TTAMachine::InstructionTemplate::numberOfSlots ( const ImmediateUnit &  dstUnit ) const

virtual

Tells the number of slots that are used to encode the long immediate which is written to the given destination unit.

Parameters

dstUnit

The destination unit.

Returns

The number of slots.

Reimplemented in TTAMachine::NullInstructionTemplate.

Definition at line 367 of file InstructionTemplate.cc.

                                                                     {
    int slots(0);
    for (SlotTable::const_iterator iter = slots_.begin();
         iter != slots_.end(); iter++) {
        TemplateSlot* slot = *iter;
        if (slot->destination() == &dstUnit) {
            slots++;
        }
    }
    return slots;
}

References TTAMachine::TemplateSlot::destination(), slot(), and slots_.

Referenced by CodeCompressorPlugin::encodeLongImmediate(), slotOfDestination(), and DefaultDecoderGenerator::writeInstructionTemplateProcedures().

Here is the call graph for this function:

removeSlot()

void TTAMachine::InstructionTemplate::removeSlot ( const std::string &  slotName )

virtual

Removes the template slot which uses the given slot.

Parameters

slotName

Name of the slot.

Reimplemented in TTAMachine::NullInstructionTemplate.

Definition at line 201 of file InstructionTemplate.cc.

                                                         {
    TemplateSlot* slot = templateSlot(slotName);
    if (slot != NULL) {
        bool removed = ContainerTools::deleteValueIfExists(slots_, slot);
        assert(removed);
    }
}

References assert, ContainerTools::deleteValueIfExists(), slot(), slots_, and templateSlot().

Referenced by TTAMachine::ImmediateSlot::unsetMachine(), and TTAMachine::Bus::unsetMachine().

Here is the call graph for this function:

removeSlots()

void TTAMachine::InstructionTemplate::removeSlots ( const ImmediateUnit &  dstUnit )

virtual

Removes the template slots that has the given immediate unit as destination unit.

Parameters

dstUnit

The destination immediate unit.

Reimplemented in TTAMachine::NullInstructionTemplate.

Definition at line 217 of file InstructionTemplate.cc.

                                                             {
    for (SlotTable::iterator iter = slots_.begin(); iter != slots_.end();) {
        TemplateSlot* slot = *iter;
        if (slot->destination() == &dstUnit) {
            delete slot;
            SlotTable::iterator next = slots_.erase(iter);
            iter = next;
        } else {
            iter++;
        }
    }
}

References TTAMachine::TemplateSlot::destination(), slot(), and slots_.

Referenced by TTAMachine::ImmediateUnit::unsetMachine().

Here is the call graph for this function:

saveState()

ObjectState * TTAMachine::InstructionTemplate::saveState ( ) const

virtual

Saves its state to an ObjectState tree.

Returns

The newly created ObjectState tree.

Reimplemented from TTAMachine::Component.

Reimplemented in TTAMachine::NullInstructionTemplate.

Definition at line 536 of file InstructionTemplate.cc.

                                     {
    ObjectState* state = Component::saveState();
    state->setName(OSNAME_INSTRUCTION_TEMPLATE);
    SlotTable::const_iterator iter = slots_.begin();
    while (iter != slots_.end()) {
        TemplateSlot* templateSlot = *iter;
        ObjectState* slotState = templateSlot->saveState();
        state->addChild(slotState);
        iter++;
    }
    return state;
}

References ObjectState::addChild(), OSNAME_INSTRUCTION_TEMPLATE, TTAMachine::TemplateSlot::saveState(), TTAMachine::Component::saveState(), ObjectState::setName(), slots_, and templateSlot().

Here is the call graph for this function:

setMachine()

void TTAMachine::InstructionTemplate::setMachine ( Machine &  machine )

virtual

Adds the instruction template to the given machine.

Parameters

machine

Machine to which the instruction template is added.

Exceptions

ComponentAlreadyExists

If there already is another instruction template by the same name or another empty instruction template in the given machine.

Implements TTAMachine::Component.

Reimplemented in TTAMachine::NullInstructionTemplate.

Definition at line 509 of file InstructionTemplate.cc.

                                                {
    machine.addInstructionTemplate(*this);
    internalSetMachine(machine);
}

References TTAMachine::Machine::addInstructionTemplate(), TTAMachine::Component::internalSetMachine(), and TTAMachine::Component::machine().

Referenced by InstructionTemplate().

Here is the call graph for this function:

setName()

void TTAMachine::InstructionTemplate::setName ( const std::string &  name )

virtual

Sets the name of the instruction template.

Parameters

name	Name of the instruction template.

Exceptions

ComponentAlreadyExists	If an instruction template with the given name is already in the same machine.
InvalidName	If the given name is not a valid component name.

Reimplemented from TTAMachine::Component.

Reimplemented in TTAMachine::NullInstructionTemplate.

Definition at line 134 of file InstructionTemplate.cc.

                                               {
    if (name == this->name()) {
        return;
    }
 
    if (machine() != NULL) {
        if (machine()->instructionTemplateNavigator().hasItem(name)) {
            string procName = "InstructionTemplate::setName";
            throw ComponentAlreadyExists(__FILE__, __LINE__, procName);
        } else {
            Component::setName(name);
        }
    } else {
        Component::setName(name);
    }
}

References TTAMachine::Component::machine(), TTAMachine::Component::name(), and TTAMachine::Component::setName().

Here is the call graph for this function:

slot()

TemplateSlot * TTAMachine::InstructionTemplate::slot ( int  index ) const

virtual

Return the slot in the given index.

Parameters

index

Index of slot.

Returns

The slot in the given index.

Exceptions

OutOfRange

If index is equal to or greater than the number of slots in the template.

Reimplemented in TTAMachine::NullInstructionTemplate.

Definition at line 249 of file InstructionTemplate.cc.

                                         {
    if (index < 0 || index >= static_cast<int>(slots_.size())) {
        string msg = "Slot index out of bounds.";
        throw OutOfRange(__FILE__, __LINE__, __func__, msg);
    } else {
        return slots_[index];
    }
}

References __func__, and slots_.

Referenced by addSlot(), BusBroker::buildResources(), destinationOfSlot(), destinationUsesSlot(), isOneOfDestinations(), BEMGenerator::maxLongImmSlotWidth(), numberOfDestinations(), numberOfSlots(), ImmediateGenerator::printImmediateTemplates(), removeSlot(), removeSlots(), slotOfDestination(), supportedWidth(), templateSlot(), and usesSlot().

slotCount()

int TTAMachine::InstructionTemplate::slotCount ( ) const

virtual

Return the total number of slots in the template.

Returns

The total number of slots in the template.

Reimplemented in TTAMachine::NullInstructionTemplate.

Definition at line 236 of file InstructionTemplate.cc.

                                     {
    return slots_.size();
}

References slots_.

Referenced by BusBroker::buildResources(), BEMGenerator::maxLongImmSlotWidth(), ImmediateGenerator::printImmediateTemplates(), and DefaultDecoderGenerator::writeInstructionTemplateProcedures().

slotOfDestination()

std::string TTAMachine::InstructionTemplate::slotOfDestination ( const ImmediateUnit &  dstUnit, int  index  ) const

virtual

By the given index, returns the slot used to encode a part of the long immediate that is to be written to the given destination unit.

The slot are returned in the same order the parts of the long immediates are concatenated when they are written to the destination registers. The most significant end of the immediate is returned by index 0.

Parameters

dstUnit	The destination unit.
index	The index.

Exceptions

OutOfRange

If the given index is negative or not smaller than the number of slots that are written to the given destination unit.

Reimplemented in TTAMachine::NullInstructionTemplate.

Definition at line 395 of file InstructionTemplate.cc.

                                                   {
    if (index < 0 || index >= numberOfSlots(dstUnit)) {
        const string procName = "InstructionTemplate::slotOfDestination";
        throw OutOfRange(__FILE__, __LINE__, procName);
    }
 
    int count(0);
    
    for (SlotTable::const_iterator iter = slots_.begin(); 
         iter != slots_.end(); iter++) {
        TemplateSlot* slot = *iter;
        if (slot->destination() == &dstUnit) {
            if (count == index) {
                return slot->slot();
            } else {
                count++;
            }
        }
    }
 
    assert(false);
    return NULL;
}

References assert, TTAMachine::TemplateSlot::destination(), numberOfSlots(), slot(), TTAMachine::TemplateSlot::slot(), and slots_.

Referenced by CodeCompressorPlugin::encodeLongImmediate(), and DefaultDecoderGenerator::writeInstructionTemplateProcedures().

Here is the call graph for this function:

supportedWidth() [1/3]

int TTAMachine::InstructionTemplate::supportedWidth ( ) const

virtual

Returns the bit width of the widest long immediate that can be encoded by this instruction template.

Returns

The bit width.

Reimplemented in TTAMachine::NullInstructionTemplate.

Definition at line 427 of file InstructionTemplate.cc.

                                          {
 
    int maxWidth(0);
 
    Machine::ImmediateUnitNavigator iuNav =
        machine()->immediateUnitNavigator();
    for (int i = 0; i < iuNav.count(); i++) {
        ImmediateUnit* iu = iuNav.item(i);
        if (supportedWidth(*iu) > maxWidth) {
            maxWidth = supportedWidth(*iu);
        }
    }
 
    return maxWidth;
}

References TTAMachine::Machine::Navigator< ComponentType >::count(), TTAMachine::Machine::immediateUnitNavigator(), TTAMachine::Machine::Navigator< ComponentType >::item(), and TTAMachine::Component::machine().

Referenced by TTAProgram::Instruction::addImmediate(), ITemplateBroker::assign(), ITemplateBroker::assignImmediate(), MachineInfo::canEncodeImmediateInteger(), POMValidator::checkLongImmediates(), TTAProgram::TPEFProgramFactory::createInstruction(), CodeCompressorPlugin::encodeLongImmediate(), TTAProgram::TPEFProgramFactory::findInstrTemplate(), ITemplateBroker::findITemplates(), ImmediateGenerator::printImmediateTemplates(), TTAProgram::Instruction::setInstructionTemplate(), TemplateListDialog::updateSlotList(), TTAMachine::ImmediateSlot::width(), and DefaultDecoderGenerator::writeInstructionTemplateProcedures().

Here is the call graph for this function:

supportedWidth() [2/3]

int TTAMachine::InstructionTemplate::supportedWidth ( const ImmediateUnit &  dstUnit ) const

virtual

Returns the bit width of the widest long immediate that can be encoded by this instruction template and that writes a register of the given immediate unit.

Parameters

dstUnit

The immediate unit.

Returns

The bit width.

Reimplemented in TTAMachine::NullInstructionTemplate.

Definition at line 453 of file InstructionTemplate.cc.

                                                                      {
 
    int totalWidth(0);
 
    for (SlotTable::const_iterator iter = slots_.begin();
         iter != slots_.end(); iter++) {
        TemplateSlot* slot = *iter;
        if (slot->destination() == &dstUnit) {
            totalWidth += slot->width();
        }
    }
 
    return totalWidth;
}

References TTAMachine::TemplateSlot::destination(), slot(), slots_, and TTAMachine::TemplateSlot::width().

Here is the call graph for this function:

supportedWidth() [3/3]

int TTAMachine::InstructionTemplate::supportedWidth ( const std::string &  slotName ) const

virtual

Returns the bit width of the long immediate that can be encoded in the given slot by this instruction template.

Parameters

slotName

Name of the slot.

Returns

The bit width.

Reimplemented in TTAMachine::NullInstructionTemplate.

Definition at line 477 of file InstructionTemplate.cc.

                                                                   {
    TemplateSlot* slot = templateSlot(slotName);
    if (slot == NULL) {
        return 0;
    } else {
        return slot->width();
    }
}

References slot(), templateSlot(), and TTAMachine::TemplateSlot::width().

Here is the call graph for this function:

templateSlot()

TemplateSlot * TTAMachine::InstructionTemplate::templateSlot

(

const std::string &

slotName

)

const

Returns the template slot that uses slot with the given name.

Returns NULL if no template slot uses the given slot.

Parameters

slotName

Name of the slot.

Returns

The template slot or NULL.

Definition at line 630 of file InstructionTemplate.cc.

                                                                 {
    for (SlotTable::const_iterator iter = slots_.begin();
         iter != slots_.end(); iter++) {
        TemplateSlot* slot = *iter;
        if (slot->slot() == slotName) {
            return slot;
        }
    }
    return NULL;
}

References slot(), TTAMachine::TemplateSlot::slot(), and slots_.

Referenced by addSlot(), destinationUsesSlot(), removeSlot(), saveState(), supportedWidth(), and usesSlot().

Here is the call graph for this function:

unsetMachine()

void TTAMachine::InstructionTemplate::unsetMachine ( )

virtual

Removes the instruction template from its machine.

The instruction template is also deleted because it cannot be alone. It must be registered to a machine.

Implements TTAMachine::Component.

Reimplemented in TTAMachine::NullInstructionTemplate.

Definition at line 521 of file InstructionTemplate.cc.

                                  {
    deleteAllSlots();
    Machine* mach = machine();
    assert(mach != NULL);
    internalUnsetMachine();
    mach->deleteInstructionTemplate(*this);
}

References assert, deleteAllSlots(), TTAMachine::Machine::deleteInstructionTemplate(), TTAMachine::Component::internalUnsetMachine(), and TTAMachine::Component::machine().

Referenced by InstructionTemplate(), and ~InstructionTemplate().

Here is the call graph for this function:

usesSlot()

bool TTAMachine::InstructionTemplate::usesSlot ( const std::string &  slotName ) const

virtual

Returns true if the instruction template uses the given slot.

Parameters

slotName

Name of the slot.

Returns

True if the instruction template uses the given slot.

Reimplemented in TTAMachine::NullInstructionTemplate.

Definition at line 265 of file InstructionTemplate.cc.

                                                             {
    TemplateSlot* slot = templateSlot(slotName);
    return (slot != NULL);
}

References slot(), and templateSlot().

Referenced by CodeCompressorPlugin::addBitsForImmediateSlot(), CodeCompressorPlugin::addBitsForMoveSlot(), TTAProgram::Instruction::addMove(), POMDisassembler::disassemble(), CodeCompressorPlugin::encodeLongImmediate(), TTAProgram::TPEFProgramFactory::findInstrTemplate(), TTAProgram::Instruction::setInstructionTemplate(), ITemplateBroker::setupResourceLinks(), MachineInfo::templatesUsesSlot(), MachineInfo::templatesUsingSlot(), and TemplateListDialog::updateSlotList().

Here is the call graph for this function:

Member Data Documentation

OSNAME_INSTRUCTION_TEMPLATE

const string TTAMachine::InstructionTemplate::OSNAME_INSTRUCTION_TEMPLATE = "i_template"

static

ObjectState name for instruction template.

Definition at line 90 of file InstructionTemplate.hh.

Referenced by loadState(), TTAMachine::Machine::loadState(), and saveState().

slots_

SlotTable TTAMachine::InstructionTemplate::slots_

private

Contains all the slots of the instruction template.

Definition at line 98 of file InstructionTemplate.hh.

Referenced by addSlot(), deleteAllSlots(), destinationOfSlot(), isEmpty(), isOneOfDestinations(), numberOfDestinations(), numberOfSlots(), removeSlot(), removeSlots(), saveState(), slot(), slotCount(), slotOfDestination(), supportedWidth(), and templateSlot().

---

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

• InstructionTemplate.hh
• InstructionTemplate.cc