#include <InstructionBitVector.hh>

Inheritance diagram for InstructionBitVector:

Collaboration diagram for InstructionBitVector:

Public Member Functions
	InstructionBitVector ()

	InstructionBitVector (const InstructionBitVector &toCopy)

virtual	~InstructionBitVector ()

void	pushBack (const InstructionBitVector &bits)

void	pushBack (const BitVector &bits)

InstructionBitVector *	subVector (unsigned int firstIndex, unsigned int lastIndex) const

void	startSettingInstructionReference (const TTAProgram::Instruction &instruction)

void	addIndexBoundsForReference (IndexBound bounds)

void	fixInstructionAddress (const TTAProgram::Instruction &instruction, unsigned int address)

void	markInstructionStartingPoint (unsigned int position)

unsigned int	instructionCount () const

unsigned int	instructionStartingPoint (unsigned int index) const

Public Member Functions inherited from BitVector
	BitVector ()

	BitVector (const BitVector &vector, unsigned int firstIndex, unsigned int lastIndex)

virtual	~BitVector ()

void	pushBack (long long unsigned int integer, int size)

void	pushBack (const BitVector &bits)

void	pushBack (bool bit)

std::string	toString () const

Private Types
typedef std::vector< IndexBound >	IndexBoundTable
	A vector type that stores index bounds.

typedef std::set< IndexBoundTable * >	IndexBoundSet
	A set type that stores IndexBoundTables.

typedef std::map< const TTAProgram::Instruction , IndexBoundSet >	ReferenceMap
	A map type that maps Instructions to IndexBoundSets.

typedef std::vector< unsigned int >	BoundaryTable
	A vector type that stores instruction boundaries.

typedef std::map< const TTAProgram::Instruction *, unsigned int >	InstructionAddressTable
	A map type for instruction addresses.

Private Member Functions
IndexBoundSet &	indexBounds (const TTAProgram::Instruction &instruction)

void	addIndexBoundTables (const IndexBoundSet &from, IndexBoundSet &to)

void	fixBits (const IndexBoundTable &indexes, unsigned int value)

Static Private Member Functions
static unsigned int	availableSize (const IndexBoundTable &indexes)

Private Attributes
ReferenceMap	references_
	Contains information of the parts of the bit vector that refer to an instruction address.

IndexBoundTable *	currentTable_
	IndexBoundTable being under construction.

BoundaryTable	instructionBoundaries_
	Stores the instruction boundaries.

InstructionAddressTable	instructionAddresses_
	Addresses of the instructions.

Detailed Description

A bit vector class that provides instruction relocation capabilities.

Definition at line 50 of file InstructionBitVector.hh.

Member Typedef Documentation

◆ BoundaryTable

typedef std::vector<unsigned int> InstructionBitVector::BoundaryTable

private

A vector type that stores instruction boundaries.

Definition at line 81 of file InstructionBitVector.hh.

◆ IndexBoundSet

typedef std::set<IndexBoundTable*> InstructionBitVector::IndexBoundSet

private

A set type that stores IndexBoundTables.

Definition at line 76 of file InstructionBitVector.hh.

◆ IndexBoundTable

typedef std::vector<IndexBound> InstructionBitVector::IndexBoundTable

private

A vector type that stores index bounds.

Definition at line 74 of file InstructionBitVector.hh.

◆ InstructionAddressTable

typedef std::map<const TTAProgram::Instruction*, unsigned int> InstructionBitVector::InstructionAddressTable

private

A map type for instruction addresses.

Definition at line 84 of file InstructionBitVector.hh.

◆ ReferenceMap

typedef std::map<const TTAProgram::Instruction*, IndexBoundSet*> InstructionBitVector::ReferenceMap

private

A map type that maps Instructions to IndexBoundSets.

Definition at line 79 of file InstructionBitVector.hh.

Constructor & Destructor Documentation

◆ InstructionBitVector() [1/2]

InstructionBitVector::InstructionBitVector ( )

The constructor.

Definition at line 46 of file InstructionBitVector.cc.

                                           : 
    BitVector(), currentTable_(NULL) {
}

◆ InstructionBitVector() [2/2]

InstructionBitVector::InstructionBitVector ( const InstructionBitVector & toCopy )

The copy constructor.

Parameters

toCopy Bit vector to copy.

Definition at line 56 of file InstructionBitVector.cc.

                                        : 
    BitVector(toCopy), currentTable_(NULL), 
    instructionBoundaries_(toCopy.instructionBoundaries_),
    instructionAddresses_(toCopy.instructionAddresses_) {
 
    // copy reference map
    for (ReferenceMap::const_iterator iter = toCopy.references_.begin();
         iter != toCopy.references_.end(); iter++) {
        const Instruction* instruction = (*iter).first;
        IndexBoundSet* indexBounds = (*iter).second;
        IndexBoundSet* newSet = new IndexBoundSet;
        for (IndexBoundSet::const_iterator iter = indexBounds->begin();
             iter != indexBounds->end(); iter++) {
            IndexBoundTable* table = *iter;
            IndexBoundTable* newTable = new IndexBoundTable(*table);
            newSet->insert(newTable);
            if (toCopy.currentTable_ == table) {
                currentTable_ = newTable;
            }
        }
        references_.insert(
            std::pair<const Instruction*, IndexBoundSet*>(
                instruction, newSet));
    }    
}

References currentTable_, indexBounds(), and references_.

Here is the call graph for this function:

◆ ~InstructionBitVector()

InstructionBitVector::~InstructionBitVector ( )

virtual

The destructor.

Definition at line 87 of file InstructionBitVector.cc.

87 {

88}

Member Function Documentation

◆ addIndexBoundsForReference()

void InstructionBitVector::addIndexBoundsForReference ( IndexBound bounds )

Adds a pair of indexes that bound a part of the bit vector that refer to address of another instruction (given in startSettingInstructionReference).

Parameters

start	The start index (included in the boundary).
end	The end index (included in the boundary).

Definition at line 179 of file InstructionBitVector.cc.

                                                                  {
 
    assert(currentTable_ != NULL);
    assert(bounds.slotStartIndex() <= bounds.slotEndIndex());
    currentTable_->push_back(bounds);
}

References assert, currentTable_, IndexBound::slotEndIndex(), and IndexBound::slotStartIndex().

Referenced by CodeCompressorPlugin::bemInstructionBits(), and CodeCompressorPlugin::encodeImmediateTerminal().

Here is the call graph for this function:

◆ addIndexBoundTables()

void InstructionBitVector::addIndexBoundTables	(	const IndexBoundSet &	from,
		IndexBoundSet &	to
	)

private

Adds the IndexBoundTables from the given IndexBoundSet to the given IndexBoundSet.

Parameters

from	The IndexBoundSet from which the tables are copied.
to	The IndexBoundSet to which the tables are added.

Definition at line 308 of file InstructionBitVector.cc.

                       {
 
    for (IndexBoundSet::const_iterator iter = from.begin(); 
         iter != from.end(); iter++) {
 
        const IndexBoundTable* fromTable = *iter;
        IndexBoundTable* newTable = new IndexBoundTable(*fromTable);
        
        for (IndexBoundTable::iterator iter = newTable->begin();
             iter != newTable->end(); iter++) {
            (*iter).incrStartIndex(size());
            (*iter).incrEndIndex(size());
        }
 
        to.insert(newTable);
    }
}

Referenced by pushBack().

◆ availableSize()

unsigned int InstructionBitVector::availableSize ( const IndexBoundTable & indexes )

staticprivate

Returns the number of bits available in the given IndexBoundTable.

Parameters

indexes The IndexBoundTable.

Returns: The number of bits.

Definition at line 387 of file InstructionBitVector.cc.

                                                                  {
 
    unsigned int size(0);
    for (IndexBoundTable::const_iterator iter = indexes.begin();
         iter != indexes.end(); iter++) {
        size += (*iter).slotEndIndex() - (*iter).slotStartIndex() + 1;
    }
    return size;
}

Referenced by fixBits().

◆ fixBits()

void InstructionBitVector::fixBits	(	const IndexBoundTable &	indexes,
		unsigned int	value
	)

private

Fixes the sections given in the IndexBoundTable of the bit vector with the given value.

Parameters

indexes	The table of section being fixed.
value	The value.

Exceptions

OutOfRange If the value is too large to fit to the boundary.

Definition at line 338 of file InstructionBitVector.cc.

                                                        {
    int requiredSize = MathTools::requiredBits(value);
    int availableSize = this->availableSize(indexes);
    if (requiredSize > availableSize) {
        string errorMsg = "Unable to fix instruction reference with the "
            "correct instruction address due to insuffient space reserved "
            "for the immediate.";
        throw OutOfRange(__FILE__, __LINE__, __func__, errorMsg);
    }
 
    int currentBit = 0;
    int stopBit = requiredSize;
 
    for (IndexBoundTable::const_reverse_iterator iter = indexes.rbegin();
         iter != indexes.rend(); iter++) {
 
        const IndexBound& iBound = *iter;
 
        unsigned int startIndex = iBound.slotStartIndex();
        unsigned int endIndex = iBound.slotEndIndex();
 
        if ((*iter).isLimmEncoded()) {
            // Check limm slice indices and update iteration boundaries.
            // LIMM is written from LSB to MSB. Start from the rightmost bit
            // of *this* limm slot.
            currentBit = iBound.limmRightIndex();
            stopBit = iBound.limmLeftIndex();
            assert((stopBit-currentBit) == (iBound.limmWidth()-1));
        }
        for (unsigned int index = endIndex; index >= startIndex; index--) {
            // Rewrite with new value required bits, zero the higher ones
            if (currentBit <= stopBit) {
                operator[](index) = MathTools::bit(value, currentBit);
            } else {
                operator[](index) = false;
            }
            currentBit++;
        }
    }
}

References __func__, assert, availableSize(), MathTools::bit(), IndexBound::limmLeftIndex(), IndexBound::limmRightIndex(), IndexBound::limmWidth(), MathTools::requiredBits(), IndexBound::slotEndIndex(), and IndexBound::slotStartIndex().

Referenced by fixInstructionAddress(), and pushBack().

Here is the call graph for this function:

◆ fixInstructionAddress()

void InstructionBitVector::fixInstructionAddress	(	const TTAProgram::Instruction &	instruction,
		unsigned int	address
	)

Fixes the address of the given instruction.

When this is called, all the references to the given instruction are fixed with the given value of the address.

Parameters

instruction	The instruction.
address	The address of the instruction.

Exceptions

OutOfRange If the given value is too large to fit to a boundary that refers to the instruction.

Definition at line 199 of file InstructionBitVector.cc.

                                                                    {
    instructionAddresses_.insert(
        std::pair<const Instruction*, unsigned int>(&instruction, address));
    if (!MapTools::containsKey(references_, &instruction)) {
        return;
    } else {
        IndexBoundSet& setForInstruction = indexBounds(instruction);
        for (IndexBoundSet::const_iterator iter = setForInstruction.begin();
             iter != setForInstruction.end(); iter++) {
            IndexBoundTable* table = *iter;
            fixBits(*table, address);
        }
    }
}

References MapTools::containsKey(), fixBits(), indexBounds(), instructionAddresses_, and references_.

Referenced by CodeCompressorPlugin::addInstruction().

Here is the call graph for this function:

◆ indexBounds()

InstructionBitVector::IndexBoundSet & InstructionBitVector::indexBounds ( const TTAProgram::Instruction & instruction )

private

Returns the set of index bounds that refer to the given instruction.

Parameters

instruction The instruction.

Definition at line 284 of file InstructionBitVector.cc.

                                              {
 
    if (!MapTools::containsKey(references_, &instruction)) {
        IndexBoundSet* newSet = new IndexBoundSet;
        std::pair<const Instruction*, IndexBoundSet*> newPair(
            &instruction, newSet);
        references_.insert(newPair);
        return *newSet;
    } else {
        return *MapTools::valueForKey<IndexBoundSet*>(
            references_, &instruction);
    }
}    

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

Referenced by fixInstructionAddress(), InstructionBitVector(), and startSettingInstructionReference().

Here is the call graph for this function:

◆ instructionCount()

unsigned int InstructionBitVector::instructionCount ( ) const

Returns the number of instructions in the vector.

The count is determined by means of the number of instruction boundaries.

Returns: The number of instructions.

Definition at line 254 of file InstructionBitVector.cc.

                                             {
    return instructionBoundaries_.size();
}

References instructionBoundaries_.

Referenced by ArrayProgramImageWriter::writeImage(), AsciiProgramImageWriter::writeImage(), and Bin2nProgramImageWriter::writeImage().

◆ instructionStartingPoint()

unsigned int InstructionBitVector::instructionStartingPoint ( unsigned int index ) const

Returns the instruction starting point at the given position.

The boundaries are returned in the correct order, that is, if parameter 0 is given, the starting point of the first instruction is returned.

Returns: The instruction starting point at the given position.

Exceptions

OutOfRange If the given index is too large.

Definition at line 269 of file InstructionBitVector.cc.

                                                                       {
    if (index >= instructionBoundaries_.size()) {
        const string procName = "InstructionBitVector::instructionBoundary";
        throw OutOfRange(__FILE__, __LINE__, procName);
    } else {
        return instructionBoundaries_[index];
    }
}

References instructionBoundaries_.

Referenced by ArrayProgramImageWriter::writeImage(), AsciiProgramImageWriter::writeImage(), and Bin2nProgramImageWriter::writeImage().

◆ markInstructionStartingPoint()

void InstructionBitVector::markInstructionStartingPoint ( unsigned int position )

Marks the instruction starting point.

The instruction starting point should be marked to the position of the first bit (the smallest index in the vector) of instruction.

Parameters

position The position of the starting point.

Definition at line 224 of file InstructionBitVector.cc.

                                                                        {
    if (instructionBoundaries_.size() == 0) {
        instructionBoundaries_.push_back(position);
    } else {
        if (instructionBoundaries_.back() < position) {
            instructionBoundaries_.push_back(position);
        } else {
            for (BoundaryTable::iterator iter = instructionBoundaries_.begin();
                 iter != instructionBoundaries_.end(); iter++) {
                if (*iter > position) {
                    instructionBoundaries_.insert(iter, position);
                    return;
                } else if (*iter == position) {
                    return;
                }
            }
            assert(false);
        }
    }
}

References assert, and instructionBoundaries_.

Referenced by CodeCompressorPlugin::addInstruction().

◆ pushBack() [1/2]

void InstructionBitVector::pushBack ( const BitVector & bits )

Concatenates the given bit vector to this vector.

Parameters

bits	The bit vector to be concatenated to this vector.

Definition at line 149 of file InstructionBitVector.cc.

                                                    {
    BitVector::pushBack(bits);
}

References BitVector::pushBack().

Here is the call graph for this function:

◆ pushBack() [2/2]

void InstructionBitVector::pushBack ( const InstructionBitVector & bits )

Concatenates the given instruction bit vector to this vector.

Fixes the instruction references of the given bit vector with the known instruction addresses.

Parameters

bits	The bit vector to be concatenated to this vector.

Exceptions

OutOfRange If some of the instruction references cannot be fixed due to insufficient bit width.

Definition at line 102 of file InstructionBitVector.cc.

                                                               {
    for (ReferenceMap::const_iterator iter = bits.references_.begin();
         iter != bits.references_.end(); iter++) {
        const Instruction* instruction = (*iter).first;
        IndexBoundSet* indexBoundSet = (*iter).second;
        if (!MapTools::containsKey(references_, instruction)) {
            IndexBoundSet* newSet = new IndexBoundSet;
            addIndexBoundTables(*indexBoundSet, *newSet);
            references_.insert(
                std::pair<const Instruction*, IndexBoundSet*>(
                    instruction, newSet));
        } else {
            IndexBoundSet* oldSet = MapTools::valueForKey<IndexBoundSet*>(
                references_, instruction);
            addIndexBoundTables(*indexBoundSet, *oldSet);
        }
    }
 
    InstructionBitVector bitsCopy(bits);
    
    // fix the instruction references of the given bit vector
    for (ReferenceMap::const_iterator iter = bits.references_.begin();
         iter != bits.references_.end(); iter++) {
        const Instruction* instruction = iter->first;
        IndexBoundSet* indexBoundSet = iter->second;
        if (MapTools::containsKey(instructionAddresses_, instruction)) {
            for (IndexBoundSet::const_iterator setIter = 
                     indexBoundSet->begin(); 
                 setIter != indexBoundSet->end(); setIter++) {
                IndexBoundTable* table = *setIter;
                bitsCopy.fixBits(
                    *table, 
                    MapTools::valueForKey<unsigned int>(
                        instructionAddresses_, instruction));
            }
        }
    }           
         
    insert(end(), bitsCopy.begin(), bitsCopy.end());
}

References addIndexBoundTables(), MapTools::containsKey(), fixBits(), instructionAddresses_, MapTools::keyForValue(), and references_.

Referenced by CodeCompressorPlugin::addInstruction(), CodeCompressorPlugin::bemBits(), and CodeCompressorPlugin::encodeImmediateTerminal().

Here is the call graph for this function:

◆ startSettingInstructionReference()

void InstructionBitVector::startSettingInstructionReference ( const TTAProgram::Instruction & instruction )

Starts setting an instruction reference.

Parameters

instruction The instruction being referenced.

Definition at line 160 of file InstructionBitVector.cc.

                                              {
 
    IndexBoundSet& setForInstruction = indexBounds(instruction);
    IndexBoundTable* newTable = new IndexBoundTable;
    currentTable_ = newTable;
    setForInstruction.insert(newTable);
}

References currentTable_, and indexBounds().

Referenced by CodeCompressorPlugin::bemInstructionBits(), and CodeCompressorPlugin::encodeImmediateTerminal().

Here is the call graph for this function:

◆ subVector()

InstructionBitVector * InstructionBitVector::subVector	(	unsigned int	firstIndex,
		unsigned int	lastIndex
	)		const

Member Data Documentation

◆ currentTable_

IndexBoundTable* InstructionBitVector::currentTable_

private

IndexBoundTable being under construction.

Definition at line 96 of file InstructionBitVector.hh.

Referenced by addIndexBoundsForReference(), InstructionBitVector(), and startSettingInstructionReference().

◆ instructionAddresses_

InstructionAddressTable InstructionBitVector::instructionAddresses_

private

Addresses of the instructions.

Definition at line 100 of file InstructionBitVector.hh.

Referenced by fixInstructionAddress(), and pushBack().

◆ instructionBoundaries_

BoundaryTable InstructionBitVector::instructionBoundaries_

private

Stores the instruction boundaries.

Definition at line 98 of file InstructionBitVector.hh.

Referenced by instructionCount(), instructionStartingPoint(), and markInstructionStartingPoint().

◆ references_

ReferenceMap InstructionBitVector::references_

private

Contains information of the parts of the bit vector that refer to an instruction address.

Definition at line 94 of file InstructionBitVector.hh.

Referenced by fixInstructionAddress(), indexBounds(), InstructionBitVector(), and pushBack().

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

Public Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ BoundaryTable

◆ IndexBoundSet

◆ IndexBoundTable

◆ InstructionAddressTable

◆ ReferenceMap

Constructor & Destructor Documentation

◆ InstructionBitVector() [1/2]

◆ InstructionBitVector() [2/2]

◆ ~InstructionBitVector()

Member Function Documentation

◆ addIndexBoundsForReference()

◆ addIndexBoundTables()

◆ availableSize()

◆ fixBits()

◆ fixInstructionAddress()

◆ indexBounds()

◆ instructionCount()

◆ instructionStartingPoint()

◆ markInstructionStartingPoint()

◆ pushBack() [1/2]

◆ pushBack() [2/2]

◆ startSettingInstructionReference()

◆ subVector()

Member Data Documentation

◆ currentTable_

◆ instructionAddresses_

◆ instructionBoundaries_

◆ references_