#include <CodeCompressorPlugin.hh>

Inheritance diagram for CodeCompressorPlugin:

Collaboration diagram for CodeCompressorPlugin:

Classes
struct	Parameter
	Parameter struct. More...

Public Types
typedef std::vector< Parameter >	ParameterTable
	Table for passing plugin parameters.

Public Member Functions
virtual	~CodeCompressorPlugin ()

void	setParameters (ParameterTable parameters)

void	setPrograms (std::map< std::string, TPEF::Binary * > &programs)

void	setMachine (const TTAMachine::Machine &machine)

void	setBEM (const BinaryEncoding &bem)

const BinaryEncoding &	binaryEncoding () const

const TTAMachine::Machine &	machine () const

virtual InstructionBitVector *	compress (const std::string &program)=0

virtual void	generateDecompressor (std::ostream &stream, TCEString entityStr)=0

virtual void	printDescription (std::ostream &stream)=0

unsigned int	memoryAddress (const TTAProgram::Instruction &instruction) const

TTAProgram::Program &	currentProgram () const

int	imemMauWidth () const

InstructionBitVector *	bemInstructionBits (const TTAProgram::Instruction &)

Protected Types
typedef std::map< std::string, TPEF::Binary * >	TPEFMap
	Map type for handling programs.

Protected Member Functions
	CodeCompressorPlugin ()

InstructionBitVector *	bemBits (const TTAProgram::Program &program)

int	moveSlotCount () const

int	moveSlotWidth (int index) const

int	firstMoveSlotIndex () const

void	startNewProgram (const std::string &programName)

void	addInstruction (const TTAProgram::Instruction &instruction, InstructionBitVector *bits)

void	setInstructionToStartAtBeginningOfMAU (const TTAProgram::Instruction &instruction)

void	setAllInstructionsToStartAtBeginningOfMAU ()

InstructionBitVector *	programBits () const

bool	hasParameter (const std::string &paramName) const

std::string	parameterValue (const std::string &paramName) const

void	setImemWidth (int mau, int widthInMaus=1)

int	numberOfPrograms () const

TPEFMap::const_iterator	programElement (int index) const

std::string	indentation (int level)

Private Types
typedef std::set< const TTAProgram::Instruction * >	InstructionSet
	Set type for Instructions.

typedef std::set< const TTAProgram::Immediate * >	ImmediateSet
	Set type for Immediates.

typedef std::set< const TTAProgram::Terminal * >	TerminalSet
	Set type for Terminals.

typedef std::map< const TTAProgram::Immediate , const TTAProgram::Instruction >	RelocMap
	Map type that maps Immediates to the Instructions they are referring to.

typedef std::map< const TTAProgram::Immediate *, std::vector< IndexBound > >	IndexTable
	Map type that maps Immediates to a vector of indexes.

typedef std::map< const TTAProgram::Instruction *, unsigned int >	InstructionAddressMap
	Map type for addresses of instructions.

Private Member Functions
void	addBitsForICField (const ImmediateControlField &icField, const TTAProgram::Instruction &instruction, BitVector &bitVector) const

void	addBitsForMoveSlot (const MoveSlot &slot, const TTAProgram::Instruction &instruction, InstructionBitVector &bitVector)

void	addBitsForSourceField (const SourceField &srcField, const TTAProgram::Move &move, InstructionBitVector &bitVector) const

void	addBitsForImmediateSlot (const ImmediateSlotField &immSlot, const TTAProgram::Instruction &instruction, BitVector &bitVector)

void	addBitsForDstRegisterField (const LImmDstRegisterField &field, const TTAProgram::Instruction &instruction, BitVector &bitVector)

std::string	instructionTemplate (const TTAProgram::Instruction &instruction) const

bool	startsAtBeginningOfMAU (const TTAProgram::Instruction &instruction) const

unsigned int	nextAddressablePositionFrom (unsigned int position) const

void	encodeLongImmediate (const std::string &slotName, int slotWidth, const TTAProgram::Instruction &instruction, BitVector &bitVector)

void	encodeMove (const MoveSlot &slot, const TTAProgram::Instruction &instruction, InstructionBitVector &bitVector) const

void	encodeImmediateTerminal (const SourceField &field, const TTAProgram::Terminal &terminal, InstructionBitVector &bitVector) const

void	initializeRelocations ()

TTAProgram::Terminal *	immediateTerminal (const TPEF::CodeSection &codeSection, unsigned int elementIndex, const TPEF::ImmediateElement &immElem, const TTAProgram::Instruction &instruction) const

TTAProgram::Immediate *	programImmediate (const TPEF::ImmediateElement &immElem, const TTAProgram::Instruction &instruction) const

Static Private Member Functions
static void	addBitsForDestinationField (const DestinationField &dstField, const TTAProgram::Move &move, BitVector &bitVector)

static void	addBitsForGuardField (const GuardField &guardField, const TTAProgram::Move &move, BitVector &bitVector)

static void	encodeNOP (const MoveSlot &slot, BitVector &bitVector)

static void	encodeIUTerminal (const SlotField &field, const TTAProgram::Terminal &terminal, BitVector &bitVector)

static void	encodeRFTerminal (const SlotField &field, const TTAProgram::Terminal &terminal, BitVector &bitVector)

static void	encodeFUTerminal (const SlotField &field, const TTAProgram::Terminal &terminal, BitVector &bitVector)

static void	encodeSlotField (const SlotField &field, const BitVector &componentIDBits, const BitVector &socketCodeBits, BitVector &BitVector)

static BitVector	socketCodeBits (const SocketCodeTable &socketCodes, const PortCode &portCode, unsigned int registerIndex)

static void	addBits (unsigned int number, int leftmostBit, int rightmostBit, BitVector &bitVector)

Private Attributes
TPEFMap	tpefPrograms_
	Programs run in the machine.

TPEF::Binary *	currentTPEF_
	The current TPEF.

TTAProgram::Program *	currentPOM_
	The current program in POM.

std::string	currentProgram_
	The current program.

const BinaryEncoding *	bem_
	The binary encoding map.

const TTAMachine::Machine *	machine_
	The machine.

ParameterTable	parameters_
	Parameters for the plugin.

InstructionBitVector *	programBits_
	The bits of the program.

bool	allStartsAtBeginningOfMAU_
	Tells whether all the instructions starts at the beginning of MAU.

int	mau_
	The size of the minimum addressable unit.

int	addressSpaceOffset_
	The offset of the instruction memory (the address of the first instruction).

InstructionSet	instructionsAtBeginningOfMAU_
	Set of instructions that start at the beginning of MAU.

ImmediateSet	immediatesToRelocate_
	Set of (long) immediates that refer to an instruction.

TerminalSet	terminalsToRelocate_
	Set of (short) immediate terminals that refer to an instruction.

RelocMap	relocMap_
	Contains information to which instructions the immediates are referring to.

IndexTable	indexTable_
	A table of indexes used when encoding long immediates.

InstructionAddressMap	instructionAddresses_
	Contains the addresses of instructions.

Detailed Description

The base class for different code compressors.

Definition at line 84 of file CodeCompressorPlugin.hh.

Member Typedef Documentation

◆ ImmediateSet

typedef std::set<const TTAProgram::Immediate*> CodeCompressorPlugin::ImmediateSet

private

Set type for Immediates.

Definition at line 174 of file CodeCompressorPlugin.hh.

◆ IndexTable

typedef std::map<const TTAProgram::Immediate*, std::vector<IndexBound> > CodeCompressorPlugin::IndexTable

private

Map type that maps Immediates to a vector of indexes.

Definition at line 183 of file CodeCompressorPlugin.hh.

◆ InstructionAddressMap

typedef std::map<const TTAProgram::Instruction*, unsigned int> CodeCompressorPlugin::InstructionAddressMap

private

Map type for addresses of instructions.

Definition at line 186 of file CodeCompressorPlugin.hh.

◆ InstructionSet

typedef std::set<const TTAProgram::Instruction*> CodeCompressorPlugin::InstructionSet

private

Set type for Instructions.

Definition at line 172 of file CodeCompressorPlugin.hh.

◆ ParameterTable

typedef std::vector<Parameter> CodeCompressorPlugin::ParameterTable

Table for passing plugin parameters.

Definition at line 94 of file CodeCompressorPlugin.hh.

◆ RelocMap

typedef std::map<const TTAProgram::Immediate*, const TTAProgram::Instruction*> CodeCompressorPlugin::RelocMap

private

Map type that maps Immediates to the Instructions they are referring to.

Definition at line 180 of file CodeCompressorPlugin.hh.

◆ TerminalSet

typedef std::set<const TTAProgram::Terminal*> CodeCompressorPlugin::TerminalSet

private

Set type for Terminals.

Definition at line 176 of file CodeCompressorPlugin.hh.

◆ TPEFMap

typedef std::map<std::string, TPEF::Binary*> CodeCompressorPlugin::TPEFMap

protected

Map type for handling programs.

Definition at line 138 of file CodeCompressorPlugin.hh.

Constructor & Destructor Documentation

◆ ~CodeCompressorPlugin()

CodeCompressorPlugin::~CodeCompressorPlugin ( )

virtual

The destructor.

Definition at line 117 of file CodeCompressorPlugin.cc.

                                            {
    if (currentPOM_ != NULL) {
        delete currentPOM_;
    }
    if (programBits_ != NULL) {
        delete programBits_;
    }
}

References currentPOM_, and programBits_.

◆ CodeCompressorPlugin()

CodeCompressorPlugin::CodeCompressorPlugin ( )

protected

The constructor.

Definition at line 104 of file CodeCompressorPlugin.cc.

                                           :
    tpefPrograms_(), currentTPEF_(NULL), currentPOM_(NULL),
    currentProgram_(), bem_(NULL), machine_(NULL),
    parameters_(), programBits_(NULL), allStartsAtBeginningOfMAU_(false),
    mau_(0), addressSpaceOffset_(0), instructionsAtBeginningOfMAU_(),
    immediatesToRelocate_(), terminalsToRelocate_(), relocMap_(),
    indexTable_(), instructionAddresses_() {
}

Member Function Documentation

◆ addBits()

void CodeCompressorPlugin::addBits	(	unsigned int	number,
		int	leftmostBit,
		int	rightmostBit,
		BitVector &	bitVector
	)

staticprivate

Adds the bits of the given number to the given bit vector.

The bits added are determined by leftmostBit and rightmostBit parameters.

Parameters

number	The number.
leftmost	The leftmost bit of the number which is added to the bit vector.
rightmost	The rightmost bit of the number which is added to the bit vector.
bitVector	The bit vector to which the bits are added.

Definition at line 1688 of file CodeCompressorPlugin.cc.

                          {
    
    for (int i = leftmostBit; i >= rightmostBit; i--) {
        bitVector.push_back(MathTools::bit(number, i));
    }
}

References MathTools::bit().

Referenced by encodeLongImmediate().

Here is the call graph for this function:

◆ addBitsForDestinationField()

void CodeCompressorPlugin::addBitsForDestinationField	(	const DestinationField &	dstField,
		const TTAProgram::Move &	move,
		BitVector &	bitVector
	)

staticprivate

Adds bits for a destination field to the given bit vector.

Parameters

dstField	The destination field that determines the encoding rules.
move	The move that is being encoded.
bitVector	The bit vector to which the bits are added.

Exceptions

InvalidData If the BEM is erroneous.

Definition at line 800 of file CodeCompressorPlugin.cc.

                          {
    assert(move.bus().name() == dstField.parent()->name());
    Terminal& destination = move.destination();
 
    if (destination.isGPR()) {
        encodeRFTerminal(dstField, destination, bitVector);
    } else if (destination.isFUPort()) {
        encodeFUTerminal(dstField, destination, bitVector);
    } else {
        assert(false);
    }
}

References assert, TTAProgram::Move::bus(), TTAProgram::Move::destination(), encodeFUTerminal(), encodeRFTerminal(), TTAProgram::Terminal::isFUPort(), TTAProgram::Terminal::isGPR(), MoveSlot::name(), TTAMachine::Component::name(), and SlotField::parent().

Referenced by encodeMove().

Here is the call graph for this function:

◆ addBitsForDstRegisterField()

void CodeCompressorPlugin::addBitsForDstRegisterField	(	const LImmDstRegisterField &	field,
		const TTAProgram::Instruction &	instruction,
		BitVector &	bitVector
	)

private

Adds the bits of the given destination register field to the bit vector.

Parameters

field	The long immediate destination register field.
instruction	The instruction.
bitVector	The bit vector to which the bits are added.

Exceptions

InvalidData If the instruction or BEM is erroneous.

Definition at line 960 of file CodeCompressorPlugin.cc.

                                                                    {
    for (int i = 0; i < instruction.immediateCount(); i++) {
        TTAProgram::Immediate& immediate = instruction.immediate(i);
        const TTAProgram::Terminal& dstTerminal = immediate.destination();
        const ImmediateUnit& dstIU = dstTerminal.immediateUnit();
        if (dstIU.numberOfRegisters() == 1) {
            continue;
        }
        string instructionTemplate = "";
        try {
            instructionTemplate = this->instructionTemplate(instruction);
        } catch (const Exception& e) {
            throw InvalidData(
                __FILE__, __LINE__, __func__, e.errorMessage());
        }
 
        string iuName = field.immediateUnit(instructionTemplate);
        if (dstIU.name() == iuName) {
            bitVector.pushBack(dstTerminal.index(), field.width());
            return;
        }
    }
 
    // the field is not used by this instruction template
    bitVector.pushBack(0, field.width());
}

References __func__, TTAProgram::Immediate::destination(), Exception::errorMessage(), TTAProgram::Instruction::immediate(), TTAProgram::Instruction::immediateCount(), TTAProgram::Terminal::immediateUnit(), LImmDstRegisterField::immediateUnit(), TTAProgram::Terminal::index(), instructionTemplate(), TTAMachine::Component::name(), TTAMachine::BaseRegisterFile::numberOfRegisters(), BitVector::pushBack(), and LImmDstRegisterField::width().

Referenced by bemInstructionBits().

Here is the call graph for this function:

◆ addBitsForGuardField()

void CodeCompressorPlugin::addBitsForGuardField	(	const GuardField &	guardField,
		const TTAProgram::Move &	move,
		BitVector &	bitVector
	)

staticprivate

Adds bits for a guard field to the given bit vector.

Parameters

guardField	The guard field that determines the encoding rules.
move	The move that is being encoded.
bitVector	The bit vector to which the bits are added.

Exceptions

InvalidData If the BEM is erroneous.

Definition at line 824 of file CodeCompressorPlugin.cc.

                          {
    unsigned int encodingValue(0);
    const string procName = "CodeCompressorPlugin::addBitsForGuardField";
    string busName = guardField.parent()->name();
 
    // find the correct encoding value
    if (move.isUnconditional()) {
        UnconditionalGuardEncoding& encoding = guardField.
            unconditionalGuardEncoding(false);
        if (&encoding == &NullUnconditionalGuardEncoding::instance()) {
            PIGTextGenerator textGenerator;
            format text = textGenerator.text(
                PIGTextGenerator::TXT_ALWAYS_TRUE_GUARD_ENCODING_MISSING);
            text % busName;
            throw InvalidData(__FILE__, __LINE__, procName, text.str());
        }
        encodingValue = encoding.encoding();
 
    } else {
        const Guard& guard = move.guard().guard();
        const PortGuard* portGuard = dynamic_cast<const PortGuard*>(&guard);
        const RegisterGuard* registerGuard =
            dynamic_cast<const RegisterGuard*>(&guard);
    
        if (portGuard != NULL) {
            const Port& port = *portGuard->port();
            string portName = port.name();
            string fuName = port.parentUnit()->name();
            FUGuardEncoding& encoding = guardField.fuGuardEncoding(
                fuName, portName, guard.isInverted());
            if (&encoding == &NullFUGuardEncoding::instance()) {
                PIGTextGenerator textGenerator;
                format text = textGenerator.text(
                    PIGTextGenerator::TXT_FU_GUARD_ENCODING_MISSING);
                if (guard.isInverted()) {
                    text % "inverted" % portName % fuName;
                } else {
                    text % "non-inverted" % portName % fuName;
                }
                throw InvalidData(
                    __FILE__, __LINE__, procName, text.str());
            }
            encodingValue = encoding.encoding();
 
        } else if (registerGuard != NULL) {
            string rfName = registerGuard->registerFile()->name();
            int regIndex = registerGuard->registerIndex();
            GPRGuardEncoding& encoding = guardField.gprGuardEncoding(
                rfName, regIndex, guard.isInverted());
            if (&encoding == &NullGPRGuardEncoding::instance()) {
                PIGTextGenerator textGenerator;
                format text = textGenerator.text(
                    PIGTextGenerator::TXT_GPR_GUARD_ENCODING_MISSING);
                if (guard.isInverted()) {
                    text % "inverted" % regIndex % rfName;
                } else {
                    text % "non-inverted" % regIndex % rfName;
                }
                throw InvalidData(
                    __FILE__, __LINE__, procName, text.str());
            }
            encodingValue = encoding.encoding();
 
        } else {
            assert(false);
        }
    }
    
    // push back the encoding value to the bit vector
    unsigned int oldSize = bitVector.size();
    bitVector.pushBack(encodingValue, guardField.width());
    assert(
        bitVector.size() - oldSize == 
        static_cast<size_t>(guardField.width()));
}

References assert, GuardEncoding::encoding(), GuardField::fuGuardEncoding(), GuardField::gprGuardEncoding(), TTAProgram::Move::guard(), TTAProgram::MoveGuard::guard(), NullFUGuardEncoding::instance(), NullGPRGuardEncoding::instance(), NullUnconditionalGuardEncoding::instance(), TTAMachine::Guard::isInverted(), TTAProgram::Move::isUnconditional(), MoveSlot::name(), TTAMachine::Component::name(), TTAMachine::Port::name(), GuardField::parent(), TTAMachine::Port::parentUnit(), TTAMachine::PortGuard::port(), BitVector::pushBack(), TTAMachine::RegisterGuard::registerFile(), TTAMachine::RegisterGuard::registerIndex(), Texts::TextGenerator::text(), PIGTextGenerator::TXT_ALWAYS_TRUE_GUARD_ENCODING_MISSING, PIGTextGenerator::TXT_FU_GUARD_ENCODING_MISSING, PIGTextGenerator::TXT_GPR_GUARD_ENCODING_MISSING, and GuardField::width().

Referenced by encodeMove().

Here is the call graph for this function:

◆ addBitsForICField()

void CodeCompressorPlugin::addBitsForICField	(	const ImmediateControlField &	icField,
		const TTAProgram::Instruction &	instruction,
		BitVector &	bitVector
	)		const

private

Adds bits for immediate control field to the given bit vector.

Parameters

icField	The immediate control field that determines the encoding.
instruction	The instruction that is being encoded.
bitVector	The bit vector to which the bits are added.

Exceptions

InvalidData If the BEM or machine is erroneous.

Definition at line 669 of file CodeCompressorPlugin.cc.

                                                                          {
    string instructionTemplate("");
 
    // find the instruction template of the instruction
    try {
        instructionTemplate = 
            this->instructionTemplate(instruction);
    } catch (const InstanceNotFound& exception) {
        throw InvalidData(
            __FILE__, __LINE__, __func__, exception.errorMessage());
    }
 
    // get the encoding
    int encoding(0);
    try {
        encoding = icField.templateEncoding(instructionTemplate);
    } catch (const InstanceNotFound& exception) {
        PIGTextGenerator textGenerator;
        format text = textGenerator.text(
            PIGTextGenerator::TXT_TEMPLATE_ENCODING_MISSING);
        text % instructionTemplate;
        const string procName = "CodeCompressorPlugin::addBitsForICField";
        throw InvalidData(__FILE__, __LINE__, procName, text.str());
    }
 
    // add the encoding
    bitVector.pushBack(encoding, icField.width());
}

References __func__, Exception::errorMessage(), instructionTemplate(), BitVector::pushBack(), ImmediateControlField::templateEncoding(), Texts::TextGenerator::text(), PIGTextGenerator::TXT_TEMPLATE_ENCODING_MISSING, and ImmediateControlField::width().

Referenced by bemInstructionBits().

Here is the call graph for this function:

◆ addBitsForImmediateSlot()

void CodeCompressorPlugin::addBitsForImmediateSlot	(	const ImmediateSlotField &	immSlot,
		const TTAProgram::Instruction &	instruction,
		BitVector &	bitVector
	)

private

Adds the immediate bits of the given immediate slot to the bit vector.

Parameters

immSlot	The immediate slot.
instruction	The instruction that contains the immediate.
bitVector	The bit vector to which the bits are added.

Exceptions

InvalidData If the BEM is erroneous.

Definition at line 911 of file CodeCompressorPlugin.cc.

                                                                    {
    // get the correct instruction template
    string instructionTemplate = "";
    try {
        instructionTemplate = this->instructionTemplate(
            instruction);
    } catch (const InstanceNotFound& exception) {
        if (machine().immediateUnitNavigator().count() == 0) {
            // if no immediate units, no instruction templates either
            PIGTextGenerator textGenerator;
            format text = textGenerator.text(
                PIGTextGenerator::
                TXT_BEM_DEFINES_IMM_SLOT_THAT_IS_NEVER_USED);
            const string procName = 
                "CodeCompressorPlugin::addBitsForImmediateSlot";
            throw InvalidData(__FILE__, __LINE__, procName, text.str());
        } else {
            assert(false);
        }
    }
 
    Machine::InstructionTemplateNavigator itNav = 
        machine().instructionTemplateNavigator();
    if (!itNav.hasItem(instructionTemplate)) {
        assert(false);
    }
 
    // check whether there should be a long immediate on the immediate slot
    InstructionTemplate* iTemp = itNav.item(instructionTemplate);
    if (iTemp->usesSlot(immSlot.name())) {
        encodeLongImmediate(
            immSlot.name(), immSlot.width(), instruction, bitVector);        
    } else {
        // fill the slot with zeros
        bitVector.pushBack(0, immSlot.width());
    }
}

References assert, encodeLongImmediate(), TTAMachine::Machine::Navigator< ComponentType >::hasItem(), instructionTemplate(), TTAMachine::Machine::instructionTemplateNavigator(), TTAMachine::Machine::Navigator< ComponentType >::item(), machine(), ImmediateSlotField::name(), BitVector::pushBack(), Texts::TextGenerator::text(), TTAMachine::InstructionTemplate::usesSlot(), and ImmediateSlotField::width().

Referenced by bemInstructionBits().

Here is the call graph for this function:

◆ addBitsForMoveSlot()

void CodeCompressorPlugin::addBitsForMoveSlot	(	const MoveSlot &	slot,
		const TTAProgram::Instruction &	instruction,
		InstructionBitVector &	bitVector
	)

private

Adds bits for a move slot to the given bit vector.

Parameters

slot	The move slot that determines the encoding.
instruction	The instruction that is being encoded.
bitVector	The bit vector to which the bits are added.

Exceptions

InvalidData If the BEM is erroneous.

Definition at line 709 of file CodeCompressorPlugin.cc.

                                     {
    // find the correct bus from the machine
    string busName = slot.name();
    Machine::BusNavigator busNav = machine().busNavigator();
    if (!busNav.hasItem(busName)) {
        PIGTextGenerator textGenerator;
        format text = textGenerator.text(
            PIGTextGenerator::TXT_BEM_DEFINES_SLOT_FOR_NONEXISTING_BUS);
        text % busName;
        const string procName = "CodeCompressorPlugin::addBitsForMoveSlot";
        throw InvalidData(__FILE__, __LINE__, procName, text.str());
    }
 
    Bus* bus = busNav.item(busName);
 
    // get the correct instruction template
    string instructionTemplate = "";
    try {
        instructionTemplate = this->instructionTemplate(
            instruction);
    } catch (const InstanceNotFound& exception) {
        if (machine().immediateUnitNavigator().count() == 0) {
            // if no immediate units, no instruction templates either
            unsigned int oldSize = bitVector.size();
            encodeMove(slot, instruction, bitVector);
            assert(
                bitVector.size() - oldSize == 
                static_cast<size_t>(slot.width()));
            return;
        } else {
            assert(false);
        }
    }
 
    Machine::InstructionTemplateNavigator itNav = 
        machine().instructionTemplateNavigator();
    if (!itNav.hasItem(instructionTemplate)) {
        assert(false);
    }
 
    // check whether there should be a long immediate on the move slot
    InstructionTemplate* iTemp = itNav.item(instructionTemplate);
    if (iTemp->usesSlot(bus->name())) {
        encodeLongImmediate(
            bus->name(), slot.width(), instruction, bitVector);        
    } else {
        encodeMove(slot, instruction, bitVector);
    }
}

References assert, TTAMachine::Machine::busNavigator(), encodeLongImmediate(), encodeMove(), TTAMachine::Machine::Navigator< ComponentType >::hasItem(), instructionTemplate(), TTAMachine::Machine::instructionTemplateNavigator(), TTAMachine::Machine::Navigator< ComponentType >::item(), machine(), MoveSlot::name(), TTAMachine::Component::name(), Texts::TextGenerator::text(), PIGTextGenerator::TXT_BEM_DEFINES_SLOT_FOR_NONEXISTING_BUS, TTAMachine::InstructionTemplate::usesSlot(), and MoveSlot::width().

Referenced by bemInstructionBits().

Here is the call graph for this function:

◆ addBitsForSourceField()

void CodeCompressorPlugin::addBitsForSourceField	(	const SourceField &	srcField,
		const TTAProgram::Move &	move,
		InstructionBitVector &	bitVector
	)		const

private

Adds bits for a source field to the given bit vector.

Parameters

srcField	The source field that determines the encoding rules.
move	The move that is being encoded.
bitVector	The bit vector to which the bits are added.

Exceptions

InvalidData If the BEM is erroneous.

Definition at line 770 of file CodeCompressorPlugin.cc.

                                           {
    unsigned int oldSize = bitVector.size();
    assert(move.bus().name() == srcField.parent()->name());
    Terminal& source = move.source();
    
    if (source.isImmediateRegister()) {
        encodeIUTerminal(srcField, source, bitVector);
    } else if (source.isGPR()) {
        encodeRFTerminal(srcField, source, bitVector);
    } else if (source.isFUPort()) {
        encodeFUTerminal(srcField, source, bitVector);
    } else if (source.isImmediate()) {
        encodeImmediateTerminal(srcField, source, bitVector);
    }
 
    assert(
        bitVector.size() - oldSize == static_cast<size_t>(srcField.width()));
}

References assert, TTAProgram::Move::bus(), encodeFUTerminal(), encodeImmediateTerminal(), encodeIUTerminal(), encodeRFTerminal(), TTAProgram::Terminal::isFUPort(), TTAProgram::Terminal::isGPR(), TTAProgram::Terminal::isImmediate(), TTAProgram::Terminal::isImmediateRegister(), MoveSlot::name(), TTAMachine::Component::name(), SlotField::parent(), TTAProgram::Move::source(), and SourceField::width().

Referenced by encodeMove().

Here is the call graph for this function:

◆ addInstruction()

void CodeCompressorPlugin::addInstruction	(	const TTAProgram::Instruction &	instruction,
		InstructionBitVector *	bits
	)

protected

Adds the given instruction to the program.

Parameters

instruction	The instruction.
bits	The bits that models the instruction.

Exceptions

InvalidData	If new program is not started by startNewProgram.
OutOfRange	If some immediate would become too large to fit in its space due to the address of the instruction being added.

Definition at line 384 of file CodeCompressorPlugin.cc.

                                                                {
    if (programBits_ == NULL) {
        throw InvalidData(__FILE__, __LINE__, __func__);
    }
 
    unsigned int firstFree = programBits_->size();
    unsigned int instructionPosition = firstFree;
 
    if (startsAtBeginningOfMAU(instruction)) {
        instructionPosition = nextAddressablePositionFrom(firstFree);
    }
 
    // fill the memory from last instruction to this instruction with 0's
    for (unsigned int i = firstFree; i < instructionPosition; i++) {
        programBits_->push_back(false);
    }
 
    // add the instruction bits
    programBits_->pushBack(*bits);
    delete bits;
 
    // mark the instruction starting point
    programBits_->markInstructionStartingPoint(instructionPosition);
 
    unsigned int memoryAddress = addressSpaceOffset_ + 
        (instructionPosition / mau_);
    programBits_->fixInstructionAddress(instruction, memoryAddress);
    instructionAddresses_.insert(
        std::pair<const Instruction*, unsigned int>(
            &instruction, memoryAddress));
}

References __func__, addressSpaceOffset_, InstructionBitVector::fixInstructionAddress(), instructionAddresses_, InstructionBitVector::markInstructionStartingPoint(), mau_, memoryAddress(), nextAddressablePositionFrom(), programBits_, InstructionBitVector::pushBack(), and startsAtBeginningOfMAU().

Referenced by InstructionDictionary::addInstructions(), MoveSlotDictionary::addInstructions(), and DEFAULT_Compressor::compress().

Here is the call graph for this function:

◆ bemBits()

InstructionBitVector * CodeCompressorPlugin::bemBits ( const TTAProgram::Program & program )

protected

Returns the bit image of the program encoded as the BEM determines.

Parameters

program The program.

Returns: The program image.

Exceptions

InvalidData If the BEM is erroneous.

Definition at line 205 of file CodeCompressorPlugin.cc.

                                                              {
    relocMap_.clear();
    indexTable_.clear();
 
    InstructionBitVector* imageBits = new InstructionBitVector();
    for (int i = 0; i < program.procedureCount(); i++) {
    Procedure& p = program.procedure(i);
    for (int j = 0; j < p.instructionCount(); j++) {
        Instruction& instruction = p.instructionAtIndex(j);
        InstructionBitVector* bits = bemInstructionBits(instruction);
        assert(bits->size() == static_cast<size_t>(bem_->width()));
        imageBits->pushBack(*bits);
    }
    }
    return imageBits;
}

References assert, bem_, bemInstructionBits(), indexTable_, TTAProgram::CodeSnippet::instructionAtIndex(), TTAProgram::CodeSnippet::instructionCount(), program, InstructionBitVector::pushBack(), relocMap_, and BinaryEncoding::width().

Referenced by InstructionDictionary::addInstructions(), and MoveSlotDictionary::addInstructions().

Here is the call graph for this function:

◆ bemInstructionBits()

InstructionBitVector * CodeCompressorPlugin::bemInstructionBits ( const TTAProgram::Instruction & instruction )

Returns bit vector that represents the given instruction as the BEM determines.

Parameters

instruction The instruction.

Returns: The newly created bit vector containing the instruction bits.

Exceptions

InvalidData If the BEM is erroneous.

Definition at line 454 of file CodeCompressorPlugin.cc.

                                              {
    if (bem_ == NULL) {
        throw InvalidData(__FILE__, __LINE__, __func__);
    }
 
    InstructionBitVector* instructionBits = new InstructionBitVector();
 
    // insert the bits to the vector
    for (int i = binaryEncoding().childFieldCount() - 1; i >= 0; i--) {
        InstructionField& field = binaryEncoding().childField(i);
        ImmediateControlField* icField = 
            dynamic_cast<ImmediateControlField*>(&field);
        MoveSlot* moveSlot = dynamic_cast<MoveSlot*>(&field);
        ImmediateSlotField* immField = 
            dynamic_cast<ImmediateSlotField*>(&field);
        LImmDstRegisterField* dstRegField = 
            dynamic_cast<LImmDstRegisterField*>(&field);
        unsigned int oldSize = instructionBits->size();
        if (icField != NULL) {
            addBitsForICField(
                *icField, instruction, *instructionBits);
            assert(
                instructionBits->size() - oldSize == 
                static_cast<size_t>(icField->width()));
        } else if (moveSlot != NULL) {
            addBitsForMoveSlot(
                *moveSlot, instruction, *instructionBits);
            assert(
                instructionBits->size() - oldSize == 
                static_cast<size_t>(moveSlot->width()));
        } else if (immField != NULL) {
            addBitsForImmediateSlot(
                *immField, instruction, *instructionBits);
            assert(instructionBits->size() - oldSize == 
                   static_cast<size_t>(immField->width()));
        } else if (dstRegField != NULL) {
            addBitsForDstRegisterField(
                *dstRegField, instruction, *instructionBits);
            assert(
                instructionBits->size() - oldSize ==
                static_cast<size_t>(dstRegField->width()));
        } else {
            assert(false);
        }
    }
 
    // mark the instruction references to the bit vector
    for (RelocMap::const_iterator iter = relocMap_.begin(); 
         iter != relocMap_.end(); iter++) {
        const Immediate* immediate = (*iter).first;
        const Instruction* instruction = (*iter).second;
        assert(MapTools::containsKey(indexTable_, immediate));
        vector<IndexBound> indexes = MapTools::valueForKey<
            vector<IndexBound> >(indexTable_, immediate);
        instructionBits->startSettingInstructionReference(*instruction);
        for (vector<IndexBound>::const_iterator iter = indexes.begin();
             iter != indexes.end(); iter++) {
            instructionBits->addIndexBoundsForReference(*iter);
        }
    }
 
    relocMap_.clear();
    indexTable_.clear();
 
    return instructionBits;
}

References __func__, addBitsForDstRegisterField(), addBitsForICField(), addBitsForImmediateSlot(), addBitsForMoveSlot(), InstructionBitVector::addIndexBoundsForReference(), assert, bem_, binaryEncoding(), BinaryEncoding::childField(), MapTools::containsKey(), indexTable_, relocMap_, InstructionBitVector::startSettingInstructionReference(), MapTools::valueForKey(), ImmediateControlField::width(), ImmediateSlotField::width(), LImmDstRegisterField::width(), and MoveSlot::width().

Here is the call graph for this function:

◆ binaryEncoding()

const BinaryEncoding & CodeCompressorPlugin::binaryEncoding ( ) const

Returns the binary encoding map.

Returns: The binary encoding map.

Exceptions

NotAvailable If the BEM is not set.

Definition at line 280 of file CodeCompressorPlugin.cc.

                                           {
    if (bem_ == NULL) {
        throw NotAvailable(__FILE__, __LINE__, __func__);
    }
 
    return *bem_;
}

References __func__, and bem_.

Referenced by bemInstructionBits(), InstructionDictionary::createDictionary(), InstructionDictionary::generateDecompressor(), ProgramImageGenerator::generateProgramImage(), and MoveSlotDictionary::printDetails().

◆ compress()

virtual InstructionBitVector * CodeCompressorPlugin::compress ( const std::string & program )

pure virtual

Generates bit image of the program.

Returns: The bit image.

Exceptions

InvalidData If the BEM is erroneous.

Implemented in InstructionDictionary, DEFAULT_Compressor, and MoveSlotDictionary.

Referenced by ProgramImageGenerator::generateDataImage(), and ProgramImageGenerator::generateProgramImage().

◆ currentProgram()

TTAProgram::Program & CodeCompressorPlugin::currentProgram ( ) const

Returns the program (POM) being processed currently.

Returns: The program.

Exceptions

NotAvailable If there is no program being processed.

Definition at line 295 of file CodeCompressorPlugin.cc.

                                           {
    if (currentPOM_ == NULL) {
        throw NotAvailable(__FILE__, __LINE__, __func__);
    }
 
    return *currentPOM_;
}

References __func__, and currentPOM_.

Referenced by InstructionDictionary::addInstructions(), MoveSlotDictionary::addInstructions(), DEFAULT_Compressor::compress(), InstructionDictionary::createDictionary(), MoveSlotDictionary::createDictionary(), ProgramImageGenerator::generateProgramImage(), and ProgramImageGenerator::writeDataSection().

◆ encodeFUTerminal()

void CodeCompressorPlugin::encodeFUTerminal	(	const SlotField &	field,
		const TTAProgram::Terminal &	terminal,
		BitVector &	bitVector
	)

staticprivate

Encodes the given function unit terminal to the given bit vector.

Parameters

field	The slot field that determines the encoding rules.
terminal	The terminal to be encoded.
bitVector	The bit vector to which the bits are added.

Exceptions

InvalidData If the BEM is erroneous.

Definition at line 1418 of file CodeCompressorPlugin.cc.

                          {
    const string procName = "CodeCompressorPlugin::encodeFUTerminal";
    assert(terminal.isFUPort());
    string fuName = terminal.functionUnit().name();
    const Port& port = terminal.port();
    string socketName("");
 
    // find the correct socket
    if (dynamic_cast<const SourceField*>(&field) != NULL) {
        socketName = port.outputSocket()->name();
    } else if (dynamic_cast<const DestinationField*>(&field) != NULL) {
        socketName = port.inputSocket()->name();
    } else {
        assert(false);
    }
 
    if (!field.hasSocketEncoding(socketName)) {
        PIGTextGenerator textGenerator;
        format text = textGenerator.text(
            PIGTextGenerator::TXT_SOCKET_ENCODING_MISSING);
        if (dynamic_cast<const SourceField*>(&field) != NULL) {
            text % socketName % "source" % field.parent()->name();
        } else {
            text % socketName % "destination" % field.parent()->name();
        }
        throw InvalidData(__FILE__, __LINE__, procName, text.str());
    }
 
    // create encoding for socket ID
    SocketEncoding& socketID = field.socketEncoding(socketName);
    BitVector socketIDBits;
    socketIDBits.pushBack(socketID.encoding(), socketID.socketIDWidth());
 
    // create encoding for socket code
    BitVector socketCodeBits;
    if (socketID.hasSocketCodes()) {
        SocketCodeTable& socketCodes = socketID.socketCodes();
        FUPortCode* portCode = NULL;
        if (terminal.isOpcodeSetting()) {
            if (&terminal.operation() == &NullOperation::instance()) {
                const TTAProgram::TerminalFUPort* fuTerm =
                    dynamic_cast<const TerminalFUPort*>(&terminal);
                PIGTextGenerator textGenerator;
                format text = textGenerator.text(
                    PIGTextGenerator::TXT_OSAL_OC_MISSING);
                text % (fuTerm != NULL ? fuTerm->hwOperation()->name() : "") % fuName;
                throw InvalidData(__FILE__, __LINE__, procName, text.str());
            }
            string opName = terminal.operation().name();
            if (!socketCodes.hasFUPortCode(fuName, port.name(), opName)) {
                PIGTextGenerator textGenerator;
                format text = textGenerator.text(
                    PIGTextGenerator::TXT_FU_OC_PORT_CODE_MISSING);
                text % fuName % opName;
                throw InvalidData(__FILE__, __LINE__, procName, text.str());
            }
            portCode = &socketCodes.fuPortCode(fuName, port.name(), opName);
 
        } else {
            if (!socketCodes.hasFUPortCode(fuName, port.name())) {
                PIGTextGenerator textGenerator;
                format text = textGenerator.text(
                    PIGTextGenerator::TXT_FU_PORT_CODE_MISSING);
                text % port.name() % fuName % socketName;
                throw InvalidData(__FILE__, __LINE__, procName, text.str());
            }
            portCode = &socketCodes.fuPortCode(fuName, port.name());
        }
        socketCodeBits.pushBack(portCode->encoding(), socketCodes.width());
    }
 
    encodeSlotField(field, socketIDBits, socketCodeBits, bitVector);
}

References assert, encodeSlotField(), Encoding::encoding(), PortCode::encoding(), TTAProgram::Terminal::functionUnit(), SocketCodeTable::fuPortCode(), SocketCodeTable::hasFUPortCode(), SocketEncoding::hasSocketCodes(), SlotField::hasSocketEncoding(), TTAProgram::TerminalFUPort::hwOperation(), TTAMachine::Port::inputSocket(), NullOperation::instance(), TTAProgram::Terminal::isFUPort(), TTAProgram::Terminal::isOpcodeSetting(), MoveSlot::name(), TTAMachine::HWOperation::name(), TTAMachine::Component::name(), TTAMachine::Port::name(), Operation::name(), TTAProgram::Terminal::operation(), TTAMachine::Port::outputSocket(), SlotField::parent(), TTAProgram::Terminal::port(), BitVector::pushBack(), socketCodeBits(), SocketEncoding::socketCodes(), SlotField::socketEncoding(), SocketEncoding::socketIDWidth(), Texts::TextGenerator::text(), PIGTextGenerator::TXT_FU_OC_PORT_CODE_MISSING, PIGTextGenerator::TXT_FU_PORT_CODE_MISSING, PIGTextGenerator::TXT_OSAL_OC_MISSING, PIGTextGenerator::TXT_SOCKET_ENCODING_MISSING, and SocketCodeTable::width().

Referenced by addBitsForDestinationField(), and addBitsForSourceField().

Here is the call graph for this function:

◆ encodeImmediateTerminal()

void CodeCompressorPlugin::encodeImmediateTerminal	(	const SourceField &	field,
		const TTAProgram::Terminal &	terminal,
		InstructionBitVector &	bitVector
	)		const

private

Encodes the given immediate terminal to the given bit vector.

Parameters

field	The source field which determines the encoding rules.
terminal	The immediate terminal to be encoded.
bitVector	The bit vector to which the bits are added.

Exceptions

InvalidData If the BEM is erroneous.

Definition at line 1503 of file CodeCompressorPlugin.cc.

                                           {
    assert(terminal.isImmediate());
    unsigned int immValue = terminal.value().uIntWordValue();
    ImmediateEncoding& encoding = field.immediateEncoding();
 
    if (&encoding == &NullImmediateEncoding::instance()) {
        PIGTextGenerator textGenerator;
        format text = textGenerator.text(
            PIGTextGenerator::TXT_IMMEDIATE_ENCODING_MISSING);
        text % field.parent()->name();
        const string procName = 
            "CodeCompressorPlugin::encodeImmediateTerminal";
        throw InvalidData(__FILE__, __LINE__, procName, text.str());
    }
 
    // create bits for the immediate value
    InstructionBitVector immediateBits;
    static_cast<BitVector&>(immediateBits).pushBack(
        immValue, field.width() - encoding.encodingWidth());
    if (AssocTools::containsKey(terminalsToRelocate_, &terminal)) {
        Instruction& referenced = currentPOM_->instructionAt(immValue);
        assert(&referenced != &NullInstruction::instance());
        immediateBits.startSettingInstructionReference(referenced);
        IndexBound simmBound(0, (immediateBits.size()-1));
        immediateBits.addIndexBoundsForReference(simmBound);
    }
 
    // encode the source field
    unsigned int oldSize = bitVector.size();
    if (field.componentIDPosition() == BinaryEncoding::LEFT) {
        static_cast<BitVector&>(bitVector).pushBack(
            encoding.encoding(), encoding.encodingWidth());
        bitVector.pushBack(immediateBits);
    } else {
        bitVector.pushBack(immediateBits);
        static_cast<BitVector&>(bitVector).pushBack(
            encoding.encoding(), encoding.encodingWidth());
    }
    assert(bitVector.size() - oldSize == static_cast<size_t>(field.width()));
}

References InstructionBitVector::addIndexBoundsForReference(), assert, SlotField::componentIDPosition(), AssocTools::containsKey(), currentPOM_, Encoding::encoding(), ImmediateEncoding::encodingWidth(), SourceField::immediateEncoding(), NullImmediateEncoding::instance(), TTAProgram::NullInstruction::instance(), TTAProgram::Program::instructionAt(), TTAProgram::Terminal::isImmediate(), BinaryEncoding::LEFT, MoveSlot::name(), SlotField::parent(), InstructionBitVector::pushBack(), InstructionBitVector::startSettingInstructionReference(), terminalsToRelocate_, Texts::TextGenerator::text(), PIGTextGenerator::TXT_IMMEDIATE_ENCODING_MISSING, SimValue::uIntWordValue(), TTAProgram::Terminal::value(), and SourceField::width().

Referenced by addBitsForSourceField().

Here is the call graph for this function:

◆ encodeIUTerminal()

void CodeCompressorPlugin::encodeIUTerminal	(	const SlotField &	field,
		const TTAProgram::Terminal &	terminal,
		BitVector &	bitVector
	)

staticprivate

Encodes the immediate unit register terminal to the given bit vector.

Parameters

field	The slot field that determines the encoding rules.
terminal	The terminal to be encoded.
bitVector	The bit vector to which the bits are added.

Exceptions

InvalidData If the BEM is erroneous.

Definition at line 1288 of file CodeCompressorPlugin.cc.

                          {
    const string procName = "CodeCompressorPlugin::encodeIUTerminal";
    assert(terminal.isImmediateRegister());
    string iuName = terminal.immediateUnit().name();
    const Port& port = terminal.port();
    string socketName("");
 
    // find the correct socket
    if (dynamic_cast<const SourceField*>(&field) != NULL) {
        socketName = port.outputSocket()->name();
    } else if (dynamic_cast<const DestinationField*>(&field) != NULL) {
        socketName = port.inputSocket()->name();
    } else {
        assert(false);
    }
 
    if (!field.hasSocketEncoding(socketName)) {
        PIGTextGenerator textGenerator;
        format text = textGenerator.text(
            PIGTextGenerator::TXT_SOCKET_ENCODING_MISSING);
        if (dynamic_cast<const SourceField*>(&field) != NULL) {
            text % socketName % "source" % field.parent()->name();
        } else {
            text % socketName % "destination" % field.parent()->name();
        }
        throw InvalidData(__FILE__, __LINE__, procName, text.str());
    }
 
    // create socket ID encoding
    SocketEncoding& socketID = field.socketEncoding(socketName);
    BitVector socketIDBits;
    socketIDBits.pushBack(socketID.encoding(), socketID.socketIDWidth());
 
    // create socket code encoding
    BitVector socketCodeBits;
    if (socketID.hasSocketCodes()) {
        SocketCodeTable& socketCodes = socketID.socketCodes();
        if (!socketCodes.hasIUPortCode(iuName)) {
            PIGTextGenerator textGenerator;
            format text = textGenerator.text(
                PIGTextGenerator::TXT_IU_PORT_CODE_MISSING);
            text % iuName % socketName % field.parent()->name();
            throw InvalidData(__FILE__, __LINE__, procName, text.str());
        }
 
        IUPortCode& portCode = socketCodes.iuPortCode(iuName);
        unsigned int registerIndex = terminal.index();
        socketCodeBits.pushBack(
            CodeCompressorPlugin::socketCodeBits(
                socketCodes, portCode, registerIndex));
    }
    
    encodeSlotField(field, socketIDBits, socketCodeBits, bitVector);
}

References assert, encodeSlotField(), Encoding::encoding(), SocketCodeTable::hasIUPortCode(), SocketEncoding::hasSocketCodes(), SlotField::hasSocketEncoding(), TTAProgram::Terminal::immediateUnit(), TTAProgram::Terminal::index(), TTAMachine::Port::inputSocket(), TTAProgram::Terminal::isImmediateRegister(), SocketCodeTable::iuPortCode(), MoveSlot::name(), TTAMachine::Component::name(), TTAMachine::Port::outputSocket(), SlotField::parent(), TTAProgram::Terminal::port(), BitVector::pushBack(), socketCodeBits(), SocketEncoding::socketCodes(), SlotField::socketEncoding(), SocketEncoding::socketIDWidth(), Texts::TextGenerator::text(), PIGTextGenerator::TXT_IU_PORT_CODE_MISSING, and PIGTextGenerator::TXT_SOCKET_ENCODING_MISSING.

Referenced by addBitsForSourceField().

Here is the call graph for this function:

◆ encodeLongImmediate()

void CodeCompressorPlugin::encodeLongImmediate	(	const std::string &	slotName,
		int	slotWidth,
		const TTAProgram::Instruction &	instruction,
		BitVector &	bitVector
	)

private

Encodes the instruction's long immediate bits that belong to the given (move or immediate) slot to the bit vector.

Parameters

slotName	Name of the slot.
width	Bit width of the slot.
instruction	The instruction that is being encoded.
bitVector	The bit vector to which the bits are added.

Definition at line 1066 of file CodeCompressorPlugin.cc.

                          {
        
    // find the correct immediate from the instruction
    for (int i = 0; i < instruction.immediateCount(); i++) {
        Immediate& imm = instruction.immediate(i);
        const InstructionTemplate& iTemp = instruction.instructionTemplate();
 
        if (iTemp.usesSlot(slotName)) {
            // correct immediate
            ImmediateUnit* dstUnit = iTemp.destinationOfSlot(slotName);
 
            // find the correct boundary of the long immediate which is to
            // be encoded in the given (immediate or move) slot
            int rightmostBitToEncode = 0;
            for (int i = iTemp.numberOfSlots(*dstUnit) - 1; i >= 0; i--) {
                string slotOfImm = iTemp.slotOfDestination(*dstUnit, i);
                if (slotOfImm != slotName) {
                    rightmostBitToEncode += iTemp.supportedWidth(slotOfImm);
                } else {
                    break;
                }
            }
            unsigned int limmSlotWidth = iTemp.supportedWidth(slotName);
            int leftmostBitToEncode = 
                rightmostBitToEncode + limmSlotWidth - 1;
            assert(leftmostBitToEncode >= rightmostBitToEncode);
            assert(
                leftmostBitToEncode - rightmostBitToEncode < slotWidth);
            
            // need to add zero bits to the move slot if the immediate
            // width is smaller than the width of the move slot
            int zerosToAdd = slotWidth - (
                leftmostBitToEncode - rightmostBitToEncode) - 1;
            assert(zerosToAdd >= 0);
            for (int i = 0; i < zerosToAdd; i++) {
                bitVector.push_back(false);
            }
 
            // push back the immediate value
            UIntWord immediateValue = imm.value().value().uIntWordValue();
            addBits(
                immediateValue, leftmostBitToEncode, rightmostBitToEncode, 
                bitVector);
 
            // if the long immediate is address of an instruction, mark it
            // to relocMap_ and indexTable_
            if (AssocTools::containsKey(immediatesToRelocate_, &imm)) {
                Instruction& referenced = currentPOM_->instructionAt(
                    immediateValue);
                unsigned int startIndex = bitVector.size() - slotWidth;
                unsigned int endIndex = bitVector.size() - 1;
                relocMap_.insert(
                    pair<const Immediate*, const Instruction*>(
                        &imm, &referenced));
                vector<IndexBound> indices;
                if (MapTools::containsKey(indexTable_, &imm)) {
                    indices = MapTools::valueForKey<vector<IndexBound> >(
                        indexTable_, &imm);
                }
                IndexBound bounds(startIndex, endIndex, limmSlotWidth,
                                  leftmostBitToEncode, rightmostBitToEncode);
                indices.push_back(bounds);
                indexTable_[&imm] = indices;
            }
 
            return;
        }
    }
    assert(false);
}

References addBits(), assert, AssocTools::containsKey(), MapTools::containsKey(), currentPOM_, TTAMachine::InstructionTemplate::destinationOfSlot(), TTAProgram::Instruction::immediate(), TTAProgram::Instruction::immediateCount(), immediatesToRelocate_, indexTable_, TTAProgram::Program::instructionAt(), TTAProgram::Instruction::instructionTemplate(), MapTools::keyForValue(), TTAMachine::InstructionTemplate::numberOfSlots(), relocMap_, TTAMachine::InstructionTemplate::slotOfDestination(), TTAMachine::InstructionTemplate::supportedWidth(), SimValue::uIntWordValue(), TTAMachine::InstructionTemplate::usesSlot(), TTAProgram::Immediate::value(), and TTAProgram::TerminalImmediate::value().

Referenced by addBitsForImmediateSlot(), and addBitsForMoveSlot().

Here is the call graph for this function:

◆ encodeMove()

void CodeCompressorPlugin::encodeMove	(	const MoveSlot &	slot,
		const TTAProgram::Instruction &	instruction,
		InstructionBitVector &	bitVector
	)		const

private

Encodes a move to the given bit vector.

Parameters

slot	The move slot that determines the encoding rules.
instruction	The instruction that is being encoded.
bitVector	The bit vector to which the bits are added.

Exceptions

InvalidData If the BEM is erroneous.

Definition at line 1151 of file CodeCompressorPlugin.cc.

                                           {
    string busName = slot.name();
    Machine::BusNavigator busNav = machine().busNavigator();
    Bus* bus = busNav.item(busName);
 
    for (int i = 0; i < instruction.moveCount(); i++) {
        Move& move = instruction.move(i);
        if (&move.bus() == bus) {
            // correct move
            SourceField& srcField = slot.sourceField();
            DestinationField& dstField = slot.destinationField();
            GuardField& guardField = slot.guardField();
            for (int i = slot.childFieldCount() - 1; i >= 0; i--) {
                InstructionField& childField = slot.childField(i);
                unsigned int oldSize = bitVector.size();
                if (dynamic_cast<GuardField*>(&childField) != NULL) {
                    addBitsForGuardField(guardField, move, bitVector);
                    assert(bitVector.size() - oldSize == 
                           static_cast<size_t>(guardField.width()));
                } else if (dynamic_cast<SourceField*>(&childField) != NULL) {
                    addBitsForSourceField(srcField, move, bitVector);
                    assert(bitVector.size() - oldSize == 
                           static_cast<size_t>(srcField.width()));
 
                } else if (dynamic_cast<DestinationField*>(&childField) !=
                           NULL) {
                    addBitsForDestinationField(dstField, move, bitVector);
                    assert(bitVector.size() - oldSize == 
                           static_cast<size_t>(dstField.width()));
                } else {
                    assert(false);
                }
            }
            return;
        }
    }
 
    // no move on the bus
    unsigned int oldSize = bitVector.size();
    encodeNOP(slot, bitVector);
    assert(bitVector.size() - oldSize == static_cast<size_t>(slot.width()));
}

References addBitsForDestinationField(), addBitsForGuardField(), addBitsForSourceField(), assert, TTAProgram::Move::bus(), TTAMachine::Machine::busNavigator(), MoveSlot::childField(), MoveSlot::childFieldCount(), MoveSlot::destinationField(), encodeNOP(), MoveSlot::guardField(), TTAMachine::Machine::Navigator< ComponentType >::item(), machine(), TTAProgram::Instruction::move(), TTAProgram::Instruction::moveCount(), MoveSlot::name(), MoveSlot::sourceField(), GuardField::width(), MoveSlot::width(), SlotField::width(), and SourceField::width().

Referenced by addBitsForMoveSlot().

Here is the call graph for this function:

◆ encodeNOP()

void CodeCompressorPlugin::encodeNOP	(	const MoveSlot &	slot,
		BitVector &	bitVector
	)

staticprivate

Encodes a NOP to the given bitVector.

Parameters

slot	The move slot that determines the encoding rules.
bitVector	The bit vector to which the bits are added.

Exceptions

InvalidData If the BEM does not define encoding for NOP.

Definition at line 1204 of file CodeCompressorPlugin.cc.

                                                                          {
    for (int i = slot.childFieldCount() - 1; i >= 0; i--) {
        InstructionField& childField = slot.childField(i);
        GuardField& guardField = slot.guardField();
        SourceField& srcField = slot.sourceField();
        DestinationField& dstField = slot.destinationField();
 
        if (&guardField == &childField) {
            if ((!srcField.hasNoOperationEncoding() ||
                 !dstField.hasNoOperationEncoding()) && 
                guardField.hasUnconditionalGuardEncoding(true)) {
                bitVector.pushBack(
                    guardField.unconditionalGuardEncoding(true).encoding(),
                    guardField.width());
            } else {
                bitVector.pushBack(0, guardField.width());
            }
 
        } else if (&srcField == &childField) {
            if (srcField.width() == 0) {
                continue;
            }
 
            NOPEncoding& encoding = srcField.noOperationEncoding();
            if (&encoding == &NullNOPEncoding::instance() &&
                !guardField.hasUnconditionalGuardEncoding(true)) {
                PIGTextGenerator textGenerator;
                format text = textGenerator.text(
                    PIGTextGenerator::TXT_NOP_ENCODING_MISSING);
                text % slot.name();
                const string procName = "CodeCompressorPlugin::encodeNOP";
                throw InvalidData(
                    __FILE__, __LINE__, procName, text.str());
            }
            if (&encoding == &NullNOPEncoding::instance()) {
                bitVector.pushBack(0, srcField.width());
            } else {
                if (srcField.componentIDPosition() == BinaryEncoding::LEFT) {
                    bitVector.pushBack(
                        encoding.encoding(), encoding.width());
                    bitVector.pushBack(
                        0, srcField.width() - encoding.width());
                } else {
                    bitVector.pushBack(
                        encoding.encoding(), srcField.width());
                }
            }
 
        } else if (&dstField == &childField) {
            if (dstField.width() == 0) {
                continue;
            }
            NOPEncoding& encoding = dstField.noOperationEncoding();
            if (&encoding == &NullNOPEncoding::instance() &&
                !guardField.hasUnconditionalGuardEncoding(true)) {
                PIGTextGenerator textGenerator;
                format text = textGenerator.text(
                    PIGTextGenerator::TXT_NOP_ENCODING_MISSING);
                text % slot.name();
                throw InvalidData(__FILE__, __LINE__, __func__, text.str());
            }
            if (&encoding == &NullNOPEncoding::instance()) {
                bitVector.pushBack(0, dstField.width());
            } else {
                if (dstField.componentIDPosition() == BinaryEncoding::LEFT) {
                    bitVector.pushBack(encoding.encoding(), encoding.width());
                    bitVector.pushBack(0, dstField.width() - encoding.width());
                } else {
                    bitVector.pushBack(encoding.encoding(), dstField.width());
                }
            }
        }
    }
}

References __func__, MoveSlot::childField(), MoveSlot::childFieldCount(), SlotField::componentIDPosition(), MoveSlot::destinationField(), Encoding::encoding(), GuardEncoding::encoding(), MoveSlot::guardField(), SlotField::hasNoOperationEncoding(), GuardField::hasUnconditionalGuardEncoding(), NullNOPEncoding::instance(), BinaryEncoding::LEFT, MoveSlot::name(), SlotField::noOperationEncoding(), BitVector::pushBack(), MoveSlot::sourceField(), Texts::TextGenerator::text(), PIGTextGenerator::TXT_NOP_ENCODING_MISSING, GuardField::unconditionalGuardEncoding(), Encoding::width(), GuardField::width(), SlotField::width(), and SourceField::width().

Referenced by encodeMove().

Here is the call graph for this function:

◆ encodeRFTerminal()

void CodeCompressorPlugin::encodeRFTerminal	(	const SlotField &	field,
		const TTAProgram::Terminal &	terminal,
		BitVector &	bitVector
	)

staticprivate

Encodes the given register file terminal to the given bit vector.

Parameters

field	The slot field that determines the encoding rules.
terminal	The terminal to be encoded.
bitVector	The bit vector to which the bits are added.

Exceptions

InvalidData If the BEM is erroneous.

Definition at line 1354 of file CodeCompressorPlugin.cc.

                          {
    const string procName = "CodeCompressorPlugin::encodeRFTerminal";
    assert(terminal.isGPR());
    string rfName = terminal.registerFile().name();
    const Port& port = terminal.port();
    string socketName("");
    
    // find the correct socket
    if (dynamic_cast<const SourceField*>(&field) != NULL) {
        socketName = port.outputSocket()->name();
    } else if (dynamic_cast<const DestinationField*>(&field) != NULL) {
        socketName = port.inputSocket()->name();
    } else {
        assert(false);
    }
    
    if (!field.hasSocketEncoding(socketName)) {
        PIGTextGenerator textGenerator;
        format text = textGenerator.text(
            PIGTextGenerator::TXT_SOCKET_ENCODING_MISSING);
        if (dynamic_cast<const SourceField*>(&field) != NULL) {
            text % socketName % "source" % field.parent()->name();
        } else {
            text % socketName % "destination" % field.parent()->name();
        }
        throw InvalidData(__FILE__, __LINE__, procName, text.str());
    }
 
    // create encoding for socket ID
    SocketEncoding& socketID = field.socketEncoding(socketName);
    BitVector socketIDBits;
    socketIDBits.pushBack(socketID.encoding(), socketID.socketIDWidth());
    
    // create encoding for socket code
    BitVector socketCodeBits;
    if (socketID.hasSocketCodes()) {
        SocketCodeTable& socketCodes = socketID.socketCodes();
        if (!socketCodes.hasRFPortCode(rfName)) {
            PIGTextGenerator textGenerator;
            format text = textGenerator.text(
                PIGTextGenerator::TXT_RF_PORT_CODE_MISSING);
            text % rfName % socketName % field.parent()->name();
            throw InvalidData(__FILE__, __LINE__, procName, text.str());
        }
        RFPortCode& portCode = socketCodes.rfPortCode(rfName);
        unsigned int registerIndex = terminal.index();
        socketCodeBits = CodeCompressorPlugin::socketCodeBits(
            socketCodes, portCode, registerIndex);
    }
    
    encodeSlotField(field, socketIDBits, socketCodeBits, bitVector);
}

References assert, encodeSlotField(), Encoding::encoding(), SocketCodeTable::hasRFPortCode(), SocketEncoding::hasSocketCodes(), SlotField::hasSocketEncoding(), TTAProgram::Terminal::index(), TTAMachine::Port::inputSocket(), TTAProgram::Terminal::isGPR(), MoveSlot::name(), TTAMachine::Component::name(), TTAMachine::Port::outputSocket(), SlotField::parent(), TTAProgram::Terminal::port(), BitVector::pushBack(), TTAProgram::Terminal::registerFile(), SocketCodeTable::rfPortCode(), socketCodeBits(), SocketEncoding::socketCodes(), SlotField::socketEncoding(), SocketEncoding::socketIDWidth(), Texts::TextGenerator::text(), PIGTextGenerator::TXT_RF_PORT_CODE_MISSING, and PIGTextGenerator::TXT_SOCKET_ENCODING_MISSING.

Referenced by addBitsForDestinationField(), and addBitsForSourceField().

Here is the call graph for this function:

◆ encodeSlotField()

void CodeCompressorPlugin::encodeSlotField	(	const SlotField &	field,
		const BitVector &	componentIDBits,
		const BitVector &	socketCodeBits,
		BitVector &	bitVector
	)

staticprivate

Encodes the given source or destination field with the given bit vectors.

Parameters

field	The source or destination field which determines the encoding order of component ID bits and socket code bits.
componentIDBits	The encoding for component ID.
socketCodeBits	The encoding for socket code.
bitVector	The bit vector to which the bits are added.

Definition at line 1556 of file CodeCompressorPlugin.cc.

                          {
 
    unsigned int oldSize = bitVector.size();
    unsigned int numberOfZeros = field.width() - componentIDBits.size() - 
        socketCodeBits.size();
 
    if (field.componentIDPosition() == BinaryEncoding::LEFT) {
        bitVector.pushBack(componentIDBits);
        bitVector.pushBack(0, numberOfZeros);
        bitVector.pushBack(socketCodeBits);
    } else {
        bitVector.pushBack(socketCodeBits);
        bitVector.pushBack(0, numberOfZeros);
        bitVector.pushBack(componentIDBits);
    }
    assert(bitVector.size() - oldSize == static_cast<size_t>(field.width()));
}

References assert, SlotField::componentIDPosition(), BinaryEncoding::LEFT, BitVector::pushBack(), socketCodeBits(), and SlotField::width().

Referenced by encodeFUTerminal(), encodeIUTerminal(), and encodeRFTerminal().

Here is the call graph for this function:

◆ firstMoveSlotIndex()

int CodeCompressorPlugin::firstMoveSlotIndex ( ) const

protected

Returns the index of first move slot defined in bem

Definition at line 242 of file CodeCompressorPlugin.cc.

                                                   {
    int moveSlotIndex = 0;
    if (bem_->hasImmediateControlField()) {
        moveSlotIndex = bem_->immediateControlField().width();
        for (int i = 0; i < bem_->longImmDstRegisterFieldCount(); i++) {
            moveSlotIndex += bem_->longImmDstRegisterField(i).width();
        }
    }
    return moveSlotIndex;
}

References bem_, BinaryEncoding::hasImmediateControlField(), BinaryEncoding::immediateControlField(), BinaryEncoding::longImmDstRegisterField(), BinaryEncoding::longImmDstRegisterFieldCount(), ImmediateControlField::width(), and LImmDstRegisterField::width().

Referenced by MoveSlotDictionary::addInstructions(), MoveSlotDictionary::compress(), MoveSlotDictionary::evaluateMoveSlotBoundaries(), MoveSlotDictionary::generateDecompressorBody(), MoveSlotDictionary::generateDecompressorSignals(), and MoveSlotDictionary::updateDictionary().

Here is the call graph for this function:

◆ generateDecompressor()

virtual void CodeCompressorPlugin::generateDecompressor	(	std::ostream &	stream,
		TCEString	entityStr
	)

pure virtual

Generates the HDL code of the decompressor block.

Parameters

stream The stream to write.

Implemented in DEFAULT_Compressor, InstructionDictionary, and MoveSlotDictionary.

Referenced by ProgramImageGenerator::generateDecompressor().

◆ hasParameter()

bool CodeCompressorPlugin::hasParameter ( const std::string & paramName ) const

protected

Tells whether the plugin has the given parameter defined.

Parameters

paramName Name of the parameter.

Returns: True if the given parameter is defined, otherwise false.

Definition at line 558 of file CodeCompressorPlugin.cc.

                                                                   {
    for (ParameterTable::const_iterator iter = parameters_.begin();
         iter != parameters_.end(); iter++) {
        Parameter param = *iter;
        if (param.name == paramName) {
            return true;
        }
    }
    return false;
}

References CodeCompressorPlugin::Parameter::name, and parameters_.

Referenced by InstructionDictionary::compress().

◆ imemMauWidth()

int CodeCompressorPlugin::imemMauWidth ( ) const

Returns the mau of instruction memory.

Before compression this is the original width and after compression it returns the compressed instruction width

Returns: mau width

Definition at line 600 of file CodeCompressorPlugin.cc.

                                         {
    return mau_;
}

References mau_.

Referenced by ProgramImageGenerator::imemMauWidth().

◆ immediateTerminal()

TTAProgram::Terminal * CodeCompressorPlugin::immediateTerminal	(	const TPEF::CodeSection &	codeSection,
		unsigned int	elementIndex,
		const TPEF::ImmediateElement &	immElem,
		const TTAProgram::Instruction &	instruction
	)		const

private

Returns the immediate terminal that matches with the given ImmediateElement instance.

Parameters

codeSection	The code section that contains the immediate element.
elementIndex	The index at which the instruction containing the immediate element starts.
immElem	The immediate element.
instruction	The instruction that contains the immediate terminal.

Returns: The immediate terminal or NULL if there is no such terminal.

Definition at line 1712 of file CodeCompressorPlugin.cc.

                                                    {
 
    if (!immElem.isInline()) {
        return NULL;
    }
 
    Byte busIndex = immElem.destinationIndex();
    string busName = "";
    for (unsigned int i = elementIndex; i < codeSection.elementCount(); 
         i++) {
        InstructionElement* element = dynamic_cast<InstructionElement*>(
            codeSection.element(i));
        if (element->begin() && i > elementIndex) {
            assert(false);
        }
        MoveElement* moveElem = dynamic_cast<MoveElement*>(element);
        if (moveElem != NULL && 
            moveElem->sourceType() == MoveElement::MF_IMM &&
            moveElem->sourceIndex() == busIndex) {
            busName = TPEFTools::resourceName(
                *currentTPEF_, ResourceElement::MRT_BUS, moveElem->bus());
            break;
        }
    }
    
    assert(busName != "");
    
    for (int i = 0; i < instruction.moveCount(); i++) {
        Move& move = instruction.move(i);
        if (move.bus().name() == busName) {
            return &move.source();
        }
    }
 
    assert(false);
    return NULL;
}

References assert, TPEF::InstructionElement::begin(), TTAProgram::Move::bus(), TPEF::MoveElement::bus(), currentTPEF_, TPEF::ImmediateElement::destinationIndex(), TPEF::CodeSection::element(), TPEF::Section::elementCount(), TPEF::ImmediateElement::isInline(), TPEF::MoveElement::MF_IMM, TTAProgram::Instruction::move(), TTAProgram::Instruction::moveCount(), TPEF::ResourceElement::MRT_BUS, TTAMachine::Component::name(), TPEF::TPEFTools::resourceName(), TTAProgram::Move::source(), TPEF::MoveElement::sourceIndex(), and TPEF::MoveElement::sourceType().

Referenced by initializeRelocations().

Here is the call graph for this function:

◆ indentation()

std::string CodeCompressorPlugin::indentation ( int level )

protected

Returns the indentation string of the given level.

Parameters

level The indentation level.

Definition at line 652 of file CodeCompressorPlugin.cc.

                                           {
    string ind;
    for (int i = 0; i < level; i++) {
        ind += "  ";
    }
    return ind;
}

Referenced by InstructionDictionary::generateDecompressor(), MoveSlotDictionary::generateDecompressorBody(), MoveSlotDictionary::generateDecompressorEntity(), MoveSlotDictionary::generateDecompressorProcess(), MoveSlotDictionary::generateDecompressorSignals(), and MoveSlotDictionary::generateDictionaryVhdl().

◆ initializeRelocations()

void CodeCompressorPlugin::initializeRelocations ( )

private

Initializes the immediatesToRelocate_ and terminalsToRelocate_ members.

Definition at line 1608 of file CodeCompressorPlugin.cc.

                                            {
 
    typedef std::set<const TPEF::SectionElement*> SectionElemSet;
    SectionElemSet toRelocate;
    RelocSection* relocSection = NULL;
 
    // find the correct reloc section from tpef
    for (unsigned int sectionIndex = 0; 
         sectionIndex < currentTPEF_->sectionCount(Section::ST_RELOC);
         sectionIndex++) {
        relocSection = dynamic_cast<RelocSection*>(
            currentTPEF_->section(Section::ST_RELOC, sectionIndex));
        Section* codeSection = currentTPEF_->section(Section::ST_CODE, 0);
        if (relocSection->referencedSection() == codeSection) {
            break;
        }
    }
 
    if (relocSection == NULL) {
        return;
    }
 
    // collect the section elements that are to be relocated to a set
    for (unsigned int i = 0; i < relocSection->elementCount(); i++) {
        RelocElement* element = dynamic_cast<RelocElement*>(
            relocSection->element(i));
        assert(element != NULL);
        SectionElement* location = element->location();
        SectionElement* destination = element->destination();
        assert(dynamic_cast<InstructionElement*>(location) != NULL);
        if (dynamic_cast<InstructionElement*>(destination) != NULL){
            toRelocate.insert(location);
        }
    }
 
    // find the corresponding Immediates and Terminals from POM and add
    // them to immediatesToRelocate_ and terminalsToRelocate_ members
    CodeSection* codeSection = dynamic_cast<CodeSection*>(
        currentTPEF_->section(Section::ST_CODE, 0));
    Instruction* instruction = &currentPOM_->firstInstruction();
    unsigned int instStart = 0;
    for (unsigned int i = 0; i < codeSection->elementCount(); i++) {
        InstructionElement* instructionElem = 
            dynamic_cast<InstructionElement*>(codeSection->element(i));     
        if (instructionElem->begin() && i > 0) {
            instruction = &currentPOM_->nextInstruction(*instruction);
            instStart = i;
        }
        if (AssocTools::containsKey(toRelocate, instructionElem)) {
            assert(instructionElem->isImmediate());
            ImmediateElement* immElem = dynamic_cast<ImmediateElement*>(
                instructionElem);                
            Terminal* terminal = immediateTerminal(
                *codeSection, instStart, *immElem, *instruction);
            Immediate* immediate = programImmediate(*immElem, *instruction);
            if (terminal != NULL) {
                terminalsToRelocate_.insert(terminal);
            } else if (immediate != NULL) {
                immediatesToRelocate_.insert(immediate);
            } else {
                assert(false);
            }
        }
    }
}

References assert, TPEF::InstructionElement::begin(), AssocTools::containsKey(), currentPOM_, currentTPEF_, TPEF::RelocElement::destination(), TPEF::CodeSection::element(), TPEF::Section::element(), TPEF::Section::elementCount(), TTAProgram::Program::firstInstruction(), immediatesToRelocate_, immediateTerminal(), TPEF::InstructionElement::isImmediate(), TPEF::RelocElement::location(), TTAProgram::Program::nextInstruction(), programImmediate(), TPEF::RelocSection::referencedSection(), TPEF::Binary::section(), TPEF::Binary::sectionCount(), TPEF::Section::ST_CODE, TPEF::Section::ST_RELOC, and terminalsToRelocate_.

Referenced by startNewProgram().

Here is the call graph for this function:

◆ instructionTemplate()

std::string CodeCompressorPlugin::instructionTemplate ( const TTAProgram::Instruction & instruction ) const

private

Returns the name of the instruction template of the given instruction.

Parameters

instruction The instruction.

Exceptions

InstanceNotFound If the machine does not have such an instruction template.

Definition at line 997 of file CodeCompressorPlugin.cc.

                                                    {
    if (instruction.immediateCount() == 0) {
        Machine::InstructionTemplateNavigator itNav = 
            machine().instructionTemplateNavigator();
        for (int i = 0; i < itNav.count(); i++) {
            InstructionTemplate* iTemp = itNav.item(i);
            if (iTemp->isEmpty()) {
                return iTemp->name();
            }
        }
        const string procName = "CodeCompressorPlugin::instructionTemplate";
        PIGTextGenerator textGen;
        format text = textGen.text(PIGTextGenerator::TXT_EMPTY_ITEMP_MISSING);
        throw InstanceNotFound(__FILE__, __LINE__, procName, text.str());
    } else {
        return instruction.instructionTemplate().name();
    }
}

References TTAMachine::Machine::Navigator< ComponentType >::count(), TTAProgram::Instruction::immediateCount(), TTAProgram::Instruction::instructionTemplate(), TTAMachine::Machine::instructionTemplateNavigator(), TTAMachine::InstructionTemplate::isEmpty(), TTAMachine::Machine::Navigator< ComponentType >::item(), machine(), TTAMachine::Component::name(), Texts::TextGenerator::text(), and PIGTextGenerator::TXT_EMPTY_ITEMP_MISSING.

Referenced by addBitsForDstRegisterField(), addBitsForICField(), addBitsForImmediateSlot(), and addBitsForMoveSlot().

Here is the call graph for this function:

◆ machine()

const Machine & CodeCompressorPlugin::machine ( ) const

Returns the machine.

Returns: The machine.

Exceptions

NotAvailable If the machine is not set.

Definition at line 310 of file CodeCompressorPlugin.cc.

                                    {
    if (machine_ == NULL) {
        throw NotAvailable(__FILE__, __LINE__, __func__);
    }
 
    return *machine_;
}

References __func__, and machine_.

Referenced by addBitsForImmediateSlot(), addBitsForMoveSlot(), InstructionDictionary::compress(), encodeMove(), ProgramImageGenerator::generateDataImage(), ProgramImageGenerator::generateProgramImage(), instructionTemplate(), setMachine(), and ProgramImageGenerator::writeDataSection().

◆ memoryAddress()

unsigned int CodeCompressorPlugin::memoryAddress ( const TTAProgram::Instruction & instruction ) const

Tells the memory address of the given instruction.

Parameters

instruction The instruction.

Returns: The memory address.

Exceptions

InstanceNotFound If the program does not contain the given instruction.

Definition at line 262 of file CodeCompressorPlugin.cc.

                                                    {
    if (!MapTools::containsKey(instructionAddresses_, &instruction)) {
        const string procName = "CodeCompressorPlugin::memoryAddress";
        throw InstanceNotFound(__FILE__, __LINE__, procName);
    } else {
        return MapTools::valueForKey<unsigned int>(
            instructionAddresses_, &instruction);
    }
}

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

Referenced by addInstruction(), and ProgramImageGenerator::writeDataSection().

Here is the call graph for this function:

◆ moveSlotCount()

int CodeCompressorPlugin::moveSlotCount ( ) const

protected

Returns the number of move slots

Definition at line 226 of file CodeCompressorPlugin.cc.

                                              {
    return bem_->moveSlotCount();
}

References bem_, and BinaryEncoding::moveSlotCount().

Referenced by MoveSlotDictionary::addInstructions(), MoveSlotDictionary::createDictionary(), MoveSlotDictionary::evaluateMoveSlotBoundaries(), MoveSlotDictionary::generateDecompressorBody(), MoveSlotDictionary::generateDecompressorProcess(), MoveSlotDictionary::generateDecompressorSignals(), MoveSlotDictionary::generateDictionaryVhdl(), and MoveSlotDictionary::updateDictionary().

Here is the call graph for this function:

◆ moveSlotWidth()

int CodeCompressorPlugin::moveSlotWidth ( int index ) const

protected

Returns the width of the move slot in the given index

Parameters

index Index of move slot

Definition at line 235 of file CodeCompressorPlugin.cc.

                                                       {
    return bem_->moveSlot(index).width();
}

References bem_, BinaryEncoding::moveSlot(), and MoveSlot::width().

Referenced by MoveSlotDictionary::addInstructions(), MoveSlotDictionary::generateDecompressorSignals(), MoveSlotDictionary::generateDictionaryVhdl(), and MoveSlotDictionary::updateDictionary().

Here is the call graph for this function:

◆ nextAddressablePositionFrom()

unsigned int CodeCompressorPlugin::nextAddressablePositionFrom ( unsigned int position ) const

private

Returns the next addressable position in the bit vector calculated from the given position.

Parameters

position The position.

Returns: The next addressable position.

Definition at line 1045 of file CodeCompressorPlugin.cc.

                                 {
 
    if (position % mau_ == 0) {
        return position;
    } else {
        return position + mau_ - (position % mau_);
    }
}

References mau_.

Referenced by addInstruction().

◆ numberOfPrograms()

int CodeCompressorPlugin::numberOfPrograms ( ) const

protected

Returns the number of programs to be compressed

Returns: number of programs

Definition at line 623 of file CodeCompressorPlugin.cc.

                                             {
    return tpefPrograms_.size();
}

References tpefPrograms_.

Referenced by InstructionDictionary::createDictionary(), and MoveSlotDictionary::createDictionary().

◆ parameterValue()

std::string CodeCompressorPlugin::parameterValue ( const std::string & paramName ) const

protected

Returns the value of the given parameter.

Parameters

paramName Name of the parameter.

Returns: The value.

Exceptions

NotAvailable If the given parameter is not defined.

Definition at line 578 of file CodeCompressorPlugin.cc.

                                                                     {
    for (ParameterTable::const_iterator iter = parameters_.begin();
         iter != parameters_.end(); iter++) {
        Parameter param = *iter;
        if (param.name == paramName) {
            return param.value;
        }
    }
 
    throw NotAvailable(__FILE__, __LINE__, __func__);
}

References __func__, CodeCompressorPlugin::Parameter::name, parameters_, and CodeCompressorPlugin::Parameter::value.

Referenced by InstructionDictionary::compress().

◆ printDescription()

virtual void CodeCompressorPlugin::printDescription ( std::ostream & stream )

pure virtual

Prints description of the plugin to the given stream.

Implemented in InstructionDictionary, MoveSlotDictionary, and DEFAULT_Compressor.

Referenced by ProgramImageGenerator::printCompressorDescription().

◆ programBits()

InstructionBitVector * CodeCompressorPlugin::programBits ( ) const

protected

Returns the bits of the program constructed by calling addInstruction method several times.

This method creates a copy of the constructed bit vector and add extra bits to the end to make sure the length of the vector is divisible by MAU.

Returns: The program bits.

Definition at line 533 of file CodeCompressorPlugin.cc.

                                        {
 
    InstructionBitVector* bits = new InstructionBitVector(*programBits_);
 
    // add extra bits to the end if the length of program image is not
    // divisible by MAU
    int bitCount = mau_ - (bits->size() % mau_);
    if (bitCount == mau_) {
        bitCount = 0;
    }
    for (int i = 0; i < bitCount; i++) {
        bits->push_back(false);
    }
 
    return bits;
}

References mau_, and programBits_.

Referenced by InstructionDictionary::compress(), DEFAULT_Compressor::compress(), and MoveSlotDictionary::compress().

◆ programElement()

CodeCompressorPlugin::TPEFMap::const_iterator CodeCompressorPlugin::programElement ( int index ) const

protected

Returns a const iterator to program map element at the given index

Returns: const iterator to program map element

Exceptions

OutOfRange If index is out of range

Definition at line 634 of file CodeCompressorPlugin.cc.

                                                    {
    if (index >= static_cast<int>(tpefPrograms_.size())) {
        string errorMsg("Tried to overindex program map");
        throw OutOfRange(__FILE__, __LINE__, __func__, errorMsg);
    }
    TPEFMap::const_iterator iter = tpefPrograms_.begin();
    for (int i = 0; i < index; i++) {
        iter++;
    }
    return iter;
}

References __func__, and tpefPrograms_.

Referenced by InstructionDictionary::createDictionary(), and MoveSlotDictionary::createDictionary().

◆ programImmediate()

TTAProgram::Immediate * CodeCompressorPlugin::programImmediate	(	const TPEF::ImmediateElement &	immElem,
		const TTAProgram::Instruction &	instruction
	)		const

private

Returns the immediate in the given instruction that matches with the given immediate element.

Parameters

immElem	The immediate element.
instruction	The instruction.

Returns: The immediate or NULL if there is no such an immediate.

Definition at line 1764 of file CodeCompressorPlugin.cc.

                                                    {
 
    if (immElem.isInline()) {
        return NULL;
    }
 
    string dstUnitName = TPEFTools::resourceName(
        *currentTPEF_, ResourceElement::MRT_IMM, immElem.destinationUnit());
    
    for (int i = 0; i < instruction.immediateCount(); i++) {
        Immediate& immediate = instruction.immediate(i);
        const Terminal& dstTerminal = immediate.destination();
        assert(dstTerminal.isImmediateRegister());
        const ImmediateUnit& dstUnit = dstTerminal.immediateUnit();
        if (dstUnit.name() == dstUnitName) {
            return &immediate;
        }
    }
 
    assert(false);
    return NULL;
}

References assert, currentTPEF_, TTAProgram::Immediate::destination(), TPEF::ImmediateElement::destinationUnit(), TTAProgram::Instruction::immediate(), TTAProgram::Instruction::immediateCount(), TTAProgram::Terminal::immediateUnit(), TTAProgram::Terminal::isImmediateRegister(), TPEF::ImmediateElement::isInline(), TPEF::ResourceElement::MRT_IMM, TTAMachine::Component::name(), and TPEF::TPEFTools::resourceName().

Referenced by initializeRelocations().

Here is the call graph for this function:

◆ setAllInstructionsToStartAtBeginningOfMAU()

void CodeCompressorPlugin::setAllInstructionsToStartAtBeginningOfMAU ( )

protected

Sets all instructions to start at the beginning of MAU.

This method must be called before any instructions are added to the bit vector.

Definition at line 440 of file CodeCompressorPlugin.cc.

                                                                {
    allStartsAtBeginningOfMAU_ = true;
}

References allStartsAtBeginningOfMAU_.

Referenced by InstructionDictionary::compress(), DEFAULT_Compressor::compress(), MoveSlotDictionary::compress(), InstructionDictionary::createDictionary(), and MoveSlotDictionary::createDictionary().

◆ setBEM()

void CodeCompressorPlugin::setBEM ( const BinaryEncoding & bem )

Sets the binary encoding map.

Parameters

bem The BEM.

Definition at line 192 of file CodeCompressorPlugin.cc.

                                                      {
    bem_ = &bem;
}

References bem_.

Referenced by ProgramImageGenerator::loadBEM().

◆ setImemWidth()

void CodeCompressorPlugin::setImemWidth	(	int	mau,
		int	widthInMaus = `1`
	)

protected

Sets the imem width to the given mau * widthInMaus and mau to given mau

Parameters

mau	Mau of instruction memory
widthInMaus	Memory width in maus (default = 1)

Definition at line 612 of file CodeCompressorPlugin.cc.

                                                           {
    machine_->controlUnit()->addressSpace()->setWidth(mau*widthInMaus);
    mau_ = mau;
}

References TTAMachine::FunctionUnit::addressSpace(), TTAMachine::Machine::controlUnit(), machine_, mau_, and TTAMachine::AddressSpace::setWidth().

Referenced by InstructionDictionary::compress(), MoveSlotDictionary::compress(), and setMachine().

Here is the call graph for this function:

◆ setInstructionToStartAtBeginningOfMAU()

void CodeCompressorPlugin::setInstructionToStartAtBeginningOfMAU ( const TTAProgram::Instruction & instruction )

protected

Sets the given instruction to start at the beginning of MAU.

This method must be called before the instruction is added to the bit vector.

Parameters

instruction The instruction.

Definition at line 426 of file CodeCompressorPlugin.cc.

                                              {
 
    instructionsAtBeginningOfMAU_.insert(&instruction);
}

References instructionsAtBeginningOfMAU_.

◆ setMachine()

void CodeCompressorPlugin::setMachine ( const TTAMachine::Machine & machine )

Sets the machine.

Machine must be set before generating the program image. BEM must be set before calling this

Parameters

machine The machine.

Exceptions

InvalidData	If the machine does not have control unit.
InvalidData	If bem is not set

Definition at line 161 of file CodeCompressorPlugin.cc.

                                                                 {
    ControlUnit* gcu = machine.controlUnit();
    if (gcu == NULL) {
        string errorMsg = "The machine does not have GCU.";
        throw InvalidData(__FILE__, __LINE__, __func__, errorMsg);
    }
    machine_ = &machine;
    AddressSpace* iMem = gcu->addressSpace();
    if (bem_ == NULL) {
        string errorMsg = "Bem not set!";
            throw InvalidData(__FILE__, __LINE__, __func__, errorMsg);
    }
    mau_ = bem_->width();
    // For RISCV fix mau to 4
    if (machine.isRISCVMachine()) {
        mau_ = 8;
        setImemWidth(8);
        // fix machines imem width if adf has wrong value
    } else if (mau_ != iMem->width()) {
        setImemWidth(mau_);
    }
    addressSpaceOffset_ = iMem->start();
}    

References __func__, TTAMachine::FunctionUnit::addressSpace(), addressSpaceOffset_, bem_, TTAMachine::Machine::controlUnit(), TTAMachine::Machine::isRISCVMachine(), machine(), machine_, mau_, setImemWidth(), TTAMachine::AddressSpace::start(), TTAMachine::AddressSpace::width(), and BinaryEncoding::width().

Referenced by ProgramImageGenerator::loadMachine().

Here is the call graph for this function:

◆ setParameters()

void CodeCompressorPlugin::setParameters ( ParameterTable parameters )

Sets the plugin parameters.

Parameters

parameters The parameters.

Definition at line 133 of file CodeCompressorPlugin.cc.

                                                             {
    parameters_ = parameters;
}

References parameters_.

Referenced by ProgramImageGenerator::loadCompressorParameters().

◆ setPrograms()

void CodeCompressorPlugin::setPrograms ( std::map< std::string, TPEF::Binary * > & programs )

Sets the programs to be executed in the machine.

Parameters

program Map of programs.

Definition at line 144 of file CodeCompressorPlugin.cc.

                                              {
    tpefPrograms_ = programs;
}

References tpefPrograms_.

Referenced by ProgramImageGenerator::loadPrograms().

◆ socketCodeBits()

BitVector CodeCompressorPlugin::socketCodeBits	(	const SocketCodeTable &	socketCodes,
		const PortCode &	portCode,
		unsigned int	registerIndex
	)

staticprivate

Creates a bit vector that encodes the given register file terminal.

Parameters

socketCodes	The socket code table that contains the port codes.
portCode	The port code that defines the encoding.
registerIndex	The register index to be encoded.

Returns: Bit vector that contains encoding for the register file terminal.

Definition at line 1588 of file CodeCompressorPlugin.cc.

                                {
 
    BitVector bits;
    unsigned int encodingWidth = portCode.width() - portCode.indexWidth();
    if (portCode.hasEncoding()) {
        bits.pushBack(portCode.encoding(), encodingWidth);
    }
    bits.pushBack(registerIndex, socketCodes.width() - encodingWidth);
    assert(bits.size() == static_cast<size_t>(socketCodes.width()));
    return bits;
}

References assert, PortCode::encoding(), PortCode::hasEncoding(), PortCode::indexWidth(), BitVector::pushBack(), PortCode::width(), and SocketCodeTable::width().

Referenced by encodeFUTerminal(), encodeIUTerminal(), encodeRFTerminal(), and encodeSlotField().

Here is the call graph for this function:

◆ startNewProgram()

void CodeCompressorPlugin::startNewProgram ( const std::string & programName )

protected

Starts generating new program image.

This function must be called always before starting to add instructions to the program image.

Parameters

programName The program of which to generate the image.

Exceptions

InvalidData If the program object model cannot be created.

Definition at line 328 of file CodeCompressorPlugin.cc.

                                                               {
    if (programBits_ != NULL) {
        delete programBits_;
        programBits_ = NULL;
    }
 
    if (tpefPrograms_.find(programName) == tpefPrograms_.end()) {
        string errorMsg = "Program " + programName + " not found from "
            + "compressor plugin";
        throw InvalidData(__FILE__, __LINE__, __func__, errorMsg);
    }
 
    TPEF::Binary* program = tpefPrograms_.find(programName)->second;
 
    if (program == NULL) {
        string errorMsg = "Program bits for program " + programName
            + " not found";
        throw InvalidData(__FILE__, __LINE__, __func__, errorMsg);
    }
 
    programBits_ = new InstructionBitVector();
    currentTPEF_ = program;
 
    if (currentPOM_ != NULL) {
        delete currentPOM_;
        currentPOM_ = NULL;
    }
 
    TPEFProgramFactory factory(*program, *machine_);
    try {
        currentPOM_ = factory.build();
    } catch (const Exception& e) {
        throw InvalidData(__FILE__, __LINE__, __func__, e.errorMessage());
    }
    
    // clear previous relocations
    if (immediatesToRelocate_.size() != 0) {
        immediatesToRelocate_.clear();
    }
    if (terminalsToRelocate_.size() != 0) {
        terminalsToRelocate_.clear();
    }
    initializeRelocations();
}

References __func__, TTAProgram::TPEFProgramFactory::build(), currentPOM_, currentTPEF_, Exception::errorMessage(), immediatesToRelocate_, initializeRelocations(), machine_, program, programBits_, terminalsToRelocate_, and tpefPrograms_.

Referenced by InstructionDictionary::compress(), DEFAULT_Compressor::compress(), MoveSlotDictionary::compress(), InstructionDictionary::createDictionary(), and MoveSlotDictionary::createDictionary().

Here is the call graph for this function:

◆ startsAtBeginningOfMAU()

bool CodeCompressorPlugin::startsAtBeginningOfMAU ( const TTAProgram::Instruction & instruction ) const

private

Tells whether the given instruction starts at the beginning of MAU.

Parameters

instruction The instruction.

Returns: True if the instruction start at the beginning of MAU, otherwise false.

Definition at line 1025 of file CodeCompressorPlugin.cc.

                                                    {
 
    if (allStartsAtBeginningOfMAU_) {
        return true;
    } else {
        return AssocTools::containsKey(
            instructionsAtBeginningOfMAU_, &instruction);
    }
}

References allStartsAtBeginningOfMAU_, AssocTools::containsKey(), and instructionsAtBeginningOfMAU_.

Referenced by addInstruction().

Here is the call graph for this function:

Member Data Documentation

◆ addressSpaceOffset_

int CodeCompressorPlugin::addressSpaceOffset_

private

The offset of the instruction memory (the address of the first instruction).

Definition at line 283 of file CodeCompressorPlugin.hh.

Referenced by addInstruction(), and setMachine().

◆ allStartsAtBeginningOfMAU_

bool CodeCompressorPlugin::allStartsAtBeginningOfMAU_

private

Tells whether all the instructions starts at the beginning of MAU.

Definition at line 278 of file CodeCompressorPlugin.hh.

Referenced by setAllInstructionsToStartAtBeginningOfMAU(), and startsAtBeginningOfMAU().

◆ bem_

const BinaryEncoding* CodeCompressorPlugin::bem_

private

The binary encoding map.

Definition at line 269 of file CodeCompressorPlugin.hh.

Referenced by bemBits(), bemInstructionBits(), binaryEncoding(), firstMoveSlotIndex(), moveSlotCount(), moveSlotWidth(), setBEM(), and setMachine().

◆ currentPOM_

TTAProgram::Program* CodeCompressorPlugin::currentPOM_

private

The current program in POM.

Definition at line 264 of file CodeCompressorPlugin.hh.

Referenced by currentProgram(), encodeImmediateTerminal(), encodeLongImmediate(), initializeRelocations(), startNewProgram(), and ~CodeCompressorPlugin().

◆ currentProgram_

std::string CodeCompressorPlugin::currentProgram_

private

The current program.

Definition at line 266 of file CodeCompressorPlugin.hh.

◆ currentTPEF_

TPEF::Binary* CodeCompressorPlugin::currentTPEF_

private

The current TPEF.

Definition at line 262 of file CodeCompressorPlugin.hh.

Referenced by immediateTerminal(), initializeRelocations(), programImmediate(), and startNewProgram().

◆ immediatesToRelocate_

ImmediateSet CodeCompressorPlugin::immediatesToRelocate_

private

Set of (long) immediates that refer to an instruction.

Definition at line 288 of file CodeCompressorPlugin.hh.

Referenced by encodeLongImmediate(), initializeRelocations(), and startNewProgram().

◆ indexTable_

IndexTable CodeCompressorPlugin::indexTable_

private

A table of indexes used when encoding long immediates.

Definition at line 296 of file CodeCompressorPlugin.hh.

Referenced by bemBits(), bemInstructionBits(), and encodeLongImmediate().

◆ instructionAddresses_

InstructionAddressMap CodeCompressorPlugin::instructionAddresses_

private

Contains the addresses of instructions.

Definition at line 299 of file CodeCompressorPlugin.hh.

Referenced by addInstruction(), and memoryAddress().

◆ instructionsAtBeginningOfMAU_

InstructionSet CodeCompressorPlugin::instructionsAtBeginningOfMAU_

private

Set of instructions that start at the beginning of MAU.

Definition at line 286 of file CodeCompressorPlugin.hh.

Referenced by setInstructionToStartAtBeginningOfMAU(), and startsAtBeginningOfMAU().

◆ machine_

const TTAMachine::Machine* CodeCompressorPlugin::machine_

private

The machine.

Definition at line 271 of file CodeCompressorPlugin.hh.

Referenced by machine(), setImemWidth(), setMachine(), and startNewProgram().

◆ mau_

int CodeCompressorPlugin::mau_

private

The size of the minimum addressable unit.

Definition at line 280 of file CodeCompressorPlugin.hh.

Referenced by addInstruction(), imemMauWidth(), nextAddressablePositionFrom(), programBits(), setImemWidth(), and setMachine().

◆ parameters_

ParameterTable CodeCompressorPlugin::parameters_

private

Parameters for the plugin.

Definition at line 273 of file CodeCompressorPlugin.hh.

Referenced by hasParameter(), parameterValue(), and setParameters().

◆ programBits_

InstructionBitVector* CodeCompressorPlugin::programBits_

private

The bits of the program.

Definition at line 276 of file CodeCompressorPlugin.hh.

Referenced by addInstruction(), programBits(), startNewProgram(), and ~CodeCompressorPlugin().

◆ relocMap_

RelocMap CodeCompressorPlugin::relocMap_

private

Contains information to which instructions the immediates are referring to.

Definition at line 294 of file CodeCompressorPlugin.hh.

Referenced by bemBits(), bemInstructionBits(), and encodeLongImmediate().

◆ terminalsToRelocate_

TerminalSet CodeCompressorPlugin::terminalsToRelocate_

private

Set of (short) immediate terminals that refer to an instruction.

Definition at line 290 of file CodeCompressorPlugin.hh.

Referenced by encodeImmediateTerminal(), initializeRelocations(), and startNewProgram().

◆ tpefPrograms_

TPEFMap CodeCompressorPlugin::tpefPrograms_

private

Programs run in the machine.

Definition at line 260 of file CodeCompressorPlugin.hh.

Referenced by numberOfPrograms(), programElement(), setPrograms(), and startNewProgram().

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

Classes

Public Types

Public Member Functions

Protected Types

Protected Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ ImmediateSet

◆ IndexTable

◆ InstructionAddressMap

◆ InstructionSet

◆ ParameterTable

◆ RelocMap

◆ TerminalSet

◆ TPEFMap

Constructor & Destructor Documentation

◆ ~CodeCompressorPlugin()

◆ CodeCompressorPlugin()

Member Function Documentation

◆ addBits()

◆ addBitsForDestinationField()

◆ addBitsForDstRegisterField()

◆ addBitsForGuardField()

◆ addBitsForICField()

◆ addBitsForImmediateSlot()

◆ addBitsForMoveSlot()

◆ addBitsForSourceField()

◆ addInstruction()

◆ bemBits()

◆ bemInstructionBits()

◆ binaryEncoding()

◆ compress()

◆ currentProgram()

◆ encodeFUTerminal()

◆ encodeImmediateTerminal()

◆ encodeIUTerminal()

◆ encodeLongImmediate()

◆ encodeMove()

◆ encodeNOP()

◆ encodeRFTerminal()

◆ encodeSlotField()

◆ firstMoveSlotIndex()

◆ generateDecompressor()

◆ hasParameter()

◆ imemMauWidth()

◆ immediateTerminal()

◆ indentation()

◆ initializeRelocations()

◆ instructionTemplate()

◆ machine()

◆ memoryAddress()

◆ moveSlotCount()

◆ moveSlotWidth()

◆ nextAddressablePositionFrom()

◆ numberOfPrograms()

◆ parameterValue()

◆ printDescription()

◆ programBits()

◆ programElement()

◆ programImmediate()

◆ setAllInstructionsToStartAtBeginningOfMAU()

◆ setBEM()

◆ setImemWidth()

◆ setInstructionToStartAtBeginningOfMAU()

◆ setMachine()

◆ setParameters()

◆ setPrograms()

◆ socketCodeBits()

◆ startNewProgram()

◆ startsAtBeginningOfMAU()

Member Data Documentation

◆ addressSpaceOffset_

◆ allStartsAtBeginningOfMAU_

◆ bem_

◆ currentPOM_

◆ currentProgram_