ProgramImageGenerator Class Reference

#include <ProgramImageGenerator.hh>

Collaboration diagram for ProgramImageGenerator:

Public Types
enum	OutputFormat {   BINARY , ASCII , ARRAY , MIF ,   VHDL , COE , HEX , BIN2N }
	Different output formats of images. More...
typedef std::map< std::string, TPEF::Binary * >	TPEFMap

Public Member Functions
	ProgramImageGenerator ()
virtual	~ProgramImageGenerator ()
void	loadCompressorPlugin (const std::string &fileName)
void	loadCompressorParameters (CodeCompressorPlugin::ParameterTable parameters)
void	loadPrograms (TPEFMap programs)
void	loadMachine (const TTAMachine::Machine &machine)
void	loadBEM (const BinaryEncoding &bem)
void	generateProgramImage (const std::string &programName, std::ostream &stream, OutputFormat format, int mausPerLine=0)
void	generateDataImage (const std::string &programName, TPEF::Binary &program, const std::string &addressSpace, std::ostream &stream, OutputFormat format, int mausPerLine, bool usePregeneratedImage)
void	generateDecompressor (std::ostream &stream, TCEString entityStr)
int	imemMauWidth () const
CodeCompressorPlugin &	compressor ()
void	setEntityName (const std::string &entity)
void	setDataStartOptions (CmdLineOptionParser *options)
bool	isDataStartSet (std::string aSpace) const
uint64_t	dataStartAddress (std::string aSpace) const
void	writeDataSection (TPEF::Binary &program, BitVector &bitVector, const std::string &addressSpace, TPEF::Section &section)

Static Public Member Functions
static std::vector< std::string >	availableCompressors ()
static void	printCompressorDescription (const std::string &fileName, std::ostream &stream)

Private Types
typedef std::set< TPEF::Binary * >	ProgramSet
	Typedef for program set.

Private Member Functions
TPEF::InstructionElement *	relocTarget (const TPEF::Binary &program, const TPEF::DataSection &dataSection, Word dataSectionOffset) const

Static Private Member Functions
static CodeCompressorPlugin *	createCompressor (const std::string &fileName, PluginTools &pluginTool)

Private Attributes
CodeCompressorPlugin *	compressor_
	The code compressor.
std::string	entityName_
	Toplevel entity name.
CmdLineOptionParser *	dataStartOptions_
PluginTools	pluginTool_
	The plugin tool.

Static Private Attributes
static const std::string	DATA_START_DESC

Detailed Description

The main class of program image generator module.

This class provides the interface that is available to different user interfaces.

Definition at line 68 of file ProgramImageGenerator.hh.

Member Typedef Documentation

ProgramSet

typedef std::set<TPEF::Binary*> ProgramImageGenerator::ProgramSet

private

Typedef for program set.

Definition at line 125 of file ProgramImageGenerator.hh.

TPEFMap

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

Definition at line 82 of file ProgramImageGenerator.hh.

Member Enumeration Documentation

OutputFormat

enum ProgramImageGenerator::OutputFormat

Different output formats of images.

Enumerator
BINARY	Real binary format.
ASCII	ASCII 1's and 0's.
ARRAY	ASCII 1's and 0's in array form.
MIF	MIF Memory Initialization File.
VHDL	Array as a Vhdl package.
COE	COE memory initialization format.
HEX	HEX memory initialization format.
BIN2N	Binary format padded to 2**n.

Definition at line 72 of file ProgramImageGenerator.hh.

                      {
        BINARY, ///< Real binary format.
        ASCII, ///< ASCII 1's and 0's.
        ARRAY, ///< ASCII 1's and 0's in array form.
        MIF, ///< MIF Memory Initialization File
        VHDL, ///< Array as a Vhdl package
        COE, ///< COE memory initialization format
        HEX,  ///< HEX memory initialization format
    BIN2N /// Binary format padded to 2**n
    };

Constructor & Destructor Documentation

ProgramImageGenerator()

ProgramImageGenerator::ProgramImageGenerator

(

)

The constructor.

Parameters

program	The program.
bem	The binary encoding map.
machine	The machine.

Definition at line 91 of file ProgramImageGenerator.cc.

                                            : 
    compressor_(new DEFAULT_Compressor()), entityName_("") {
}

~ProgramImageGenerator()

ProgramImageGenerator::~ProgramImageGenerator ( )

virtual

The destructor.

Definition at line 99 of file ProgramImageGenerator.cc.

                                              {
    delete compressor_;
}

References compressor_.

Member Function Documentation

availableCompressors()

std::vector< std::string > ProgramImageGenerator::availableCompressors ( )

static

Returns a vector containing paths to the compressors available.

Returns

The vector.

Definition at line 617 of file ProgramImageGenerator.cc.

                                            {
 
    std::vector<string> paths = Environment::codeCompressorPaths();
    std::vector<string> files;
    for (std::vector<string>::const_iterator iter = paths.begin();
         iter != paths.end(); iter++) {
        if (FileSystem::fileExists(*iter)) {
            std::vector<string> filesInPath = FileSystem::directoryContents(
                *iter);
            for (std::vector<string>::const_iterator iter = 
                     filesInPath.begin();
                 iter != filesInPath.end(); iter++) {
                if (!FileSystem::fileIsDirectory(*iter) && 
                    FileSystem::fileExtension(*iter) == ".so") {
                    files.push_back(*iter);
                }
            }
        }
    }
 
    return files;
}

References Environment::codeCompressorPaths(), FileSystem::directoryContents(), FileSystem::fileExists(), FileSystem::fileExtension(), and FileSystem::fileIsDirectory().

Referenced by main().

Here is the call graph for this function:

compressor()

CodeCompressorPlugin & ProgramImageGenerator::compressor ( )

inline

Definition at line 107 of file ProgramImageGenerator.hh.

{ return *compressor_; }

References compressor_.

Referenced by ProGe::RV32MicroCodeGenerator::constructBInstructions(), ProGe::RV32MicroCodeGenerator::constructIInstructions(), ProGe::RV32MicroCodeGenerator::constructR1Instructions(), ProGe::RV32MicroCodeGenerator::constructR1RInstructions(), ProGe::RV32MicroCodeGenerator::constructRInstructions(), ProGe::RV32MicroCodeGenerator::constructSInstructions(), ProGe::RV32MicroCodeGenerator::constructUJInstructions(), ProGe::RV32MicroCodeGenerator::generateNOP(), and printCompressorDescription().

createCompressor()

CodeCompressorPlugin * ProgramImageGenerator::createCompressor ( const std::string &  fileName, PluginTools &  pluginTool  )

staticprivate

Creates the code compressor from the given dynamic module.

Parameters

fileName	Name of the file.
pluginTool	The plugin tool to use.

Returns

The newly created code compressor plugin.

Exceptions

FileNotFound	If the given file is not found from the search paths of code compressor plugins.
DynamicLibraryException	If the dynamic library cannot be opened.

Definition at line 674 of file ProgramImageGenerator.cc.

                                                        {
    vector<string> searchPaths = Environment::codeCompressorPaths();
    for (vector<string>::const_iterator iter = searchPaths.begin();
         iter != searchPaths.end(); iter++) {
        if (FileSystem::fileExists(*iter)) {
            pluginTool.addSearchPath(*iter);
        }
    }
 
    pluginTool.registerModule(fileName);
    CodeCompressorPlugin* (*pluginCreator)();
    pluginTool.importSymbol(
        "create_code_compressor", pluginCreator, fileName);
 
    return pluginCreator();
}

References PluginTools::addSearchPath(), Environment::codeCompressorPaths(), FileSystem::fileExists(), PluginTools::importSymbol(), and PluginTools::registerModule().

Referenced by loadCompressorPlugin(), and printCompressorDescription().

Here is the call graph for this function:

dataStartAddress()

uint64_t ProgramImageGenerator::dataStartAddress

(

std::string

aSpace

)

const

Definition at line 796 of file ProgramImageGenerator.cc.

                                                              {
    CmdLineOptionParser* opts = dataStartOptions_;
    assert(opts);
    if (opts->isDefined()) {
        int size = opts->listSize();
        if (size == 1) {
            return Conversion::toUnsignedLong(opts->String(1));
        }
        if (size % 2 != 0) {
            abortWithError("ERROR: " + DATA_START_DESC);
        }
        for (int i = 1; i <= size; i += 2) {
            TCEString as_name = opts->String(i);
            if (as_name == aSpace) {
                return Conversion::toUnsignedLong(opts->String(i + 1));
            }
        }
    }
    abortWithError("ERROR: " + DATA_START_DESC);
}

References abortWithError, assert, DATA_START_DESC, dataStartOptions_, CmdLineOptionParser::isDefined(), CmdLineOptionParser::listSize(), CmdLineOptionParser::String(), and Conversion::toUnsignedLong().

Referenced by writeDataSection().

Here is the call graph for this function:

generateDataImage()

void ProgramImageGenerator::generateDataImage	(	const std::string &	programName,
		TPEF::Binary &	program,
		const std::string &	addressSpace,
		std::ostream &	stream,
		OutputFormat	format,
		int	mausPerLine,
		bool	usePregeneratedImage
	)

Generates the data image of the given address space to the given output stream in the given format.

Parameters

program	The program of which data image is generated.
addressSpace	The address space.
stream	The output stream.
format	The output format.
mausPerLine	Tells how many MAUs of data is generated on one line.
usePregeneratedImage	Tells whether use the program image that was previously generated for relocation of data elements.

Exceptions

InvalidData	If tried to use pregenerated program but it has not been generated or if the given program is not in the program set loaded or if machine is not loaded or if is does not have the given address space.
OutOfRange	If the given MAUs per line is not positive.

Definition at line 404 of file ProgramImageGenerator.cc.

                                                {
    if (mausPerLine < 1) {
        string errorMsg = "Data memory width in MAUs must be positive.";
        throw OutOfRange(__FILE__, __LINE__, __func__, errorMsg);
    }
 
    const Machine* mach = NULL;
    try {
        mach = &compressor_->machine();
    } catch (const Exception& e) {
        throw InvalidData(__FILE__, __LINE__, __func__, e.errorMessage());
    }
    
    Machine::AddressSpaceNavigator navigator = 
        mach->addressSpaceNavigator();
    if (!navigator.hasItem(addressSpace)) {
        const string procName = "ProgramImageGenerator::generateDataImage";
        throw InstanceNotFound(__FILE__, __LINE__, procName);
    }
    AddressSpace* as = navigator.item(addressSpace);
    int memWidth = mausPerLine * as->width();
 
    if (!usePregeneratedImage) {
        InstructionBitVector* programBits = compressor_->compress(programName);
        delete programBits;
    }
 
    BitVector dataBits;
    
    // TODO: LEDATA? if le adf?
    for (unsigned int i = 0; i < program.sectionCount(Section::ST_DATA); 
         i++) {
        writeDataSection(program, dataBits, addressSpace,
                         *program.section(Section::ST_DATA, i));
    }
    for (unsigned int i = 0; i < program.sectionCount(Section::ST_LEDATA); 
         i++) {
 
        unsigned int lineOffset = dataBits.size(); // start afer previous
        // this writes data into the databits struct, not from it!
        writeDataSection(program, dataBits, addressSpace,
                         *program.section(Section::ST_LEDATA, i));
 
        // The stupid binary images are in big-endian bitness
        // format(bit 0 == highest bit).
        // Have to convert LE data into nasty mixed endian for
        // initialization with those tools.
        while (lineOffset < dataBits.size()) {
            // Pad to full line width.
            // if need padding (size not divisible by mem width)
            // and we are at last iter of the loop, add pad.
            if ((dataBits.size() % memWidth &&
                 lineOffset > (dataBits.size() - memWidth))) {
                unsigned int preferredSize =
                    ((dataBits.size() / (memWidth))+1) *
                    (memWidth);
                while (dataBits.size() < preferredSize) {
                    dataBits.push_back(0);
                }
            }
 
            for (int k = 0; k < mausPerLine/2; k++) {
                int bitOffset0 = k * as->width();
                int bitOffset1 = (mausPerLine-k-1) * as->width();
                // swap bytes of one MAU.
                for (int j = 0; j < as->width(); j++) {
                    bool bit0 = dataBits[lineOffset+bitOffset0 + j];
                    dataBits[lineOffset+bitOffset0+j] =
                        dataBits[lineOffset+bitOffset1+j];
                    dataBits[lineOffset+bitOffset1+j] = bit0;
                }
            }
            lineOffset += memWidth;
        }
    }
 
    BitImageWriter* writer = NULL;
    if (format == BINARY) {
        writer = new RawImageWriter(dataBits);
    } else if (format == ASCII) {
        writer = new AsciiImageWriter(dataBits, as->width() * mausPerLine);
    } else if (format == ARRAY) {
        writer = new ArrayImageWriter(dataBits, as->width() * mausPerLine);
    } else if (format == MIF) {
        writer = new MifImageWriter(dataBits, as->width() * mausPerLine);
    } else if (format == VHDL) {
        writer = new VhdlImageWriter(
            dataBits, as->width() * mausPerLine, entityName_);
    } else if (format == COE) {
        writer = new CoeImageWriter(dataBits, as->width() * mausPerLine);
    } else if (format == HEX) {
        writer = new HexImageWriter(dataBits, as->width() * mausPerLine);
    } else if (format == BIN2N) {
        writer = new Bin2nImageWriter(dataBits, as->width() * mausPerLine);
    } else {
        assert(false);
    }
 
    writer->writeImage(stream);
    delete writer;
}

References __func__, TTAMachine::Machine::addressSpaceNavigator(), ARRAY, ASCII, assert, BIN2N, BINARY, COE, CodeCompressorPlugin::compress(), compressor_, entityName_, Exception::errorMessage(), TTAMachine::Machine::Navigator< ComponentType >::hasItem(), HEX, TTAMachine::Machine::Navigator< ComponentType >::item(), CodeCompressorPlugin::machine(), MIF, program, TPEF::Section::ST_DATA, TPEF::Section::ST_LEDATA, VHDL, TTAMachine::AddressSpace::width(), writeDataSection(), and BitImageWriter::writeImage().

Referenced by main().

Here is the call graph for this function:

generateDecompressor()

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

Generates the decompressor to the given output stream.

Note! The program image should have been generated at first. Otherwise this may not function properly.

Parameters

stream	The output stream.
entityStr	The entity string used to make HDL entity/component names unique for multiprocessor designs.

Definition at line 600 of file ProgramImageGenerator.cc.

                         {
    if (compressor_ == NULL) {
        return;
    } else {
        compressor_->generateDecompressor(stream, entityStr);
    }
}

References compressor_, and CodeCompressorPlugin::generateDecompressor().

Referenced by createCompressor().

Here is the call graph for this function:

generateProgramImage()

void ProgramImageGenerator::generateProgramImage	(	const std::string &	programName,
		std::ostream &	stream,
		OutputFormat	format,
		int	mausPerLine = 0
	)

Generates the program image to the given output stream in the given format.

If the output is in ASCII format, mausPerLine parameter defines the number of MAUs printed per line. If 0 is given, each instruction is printed on different line.

Parameters

stream	The output stream.
format	The output format.
mausPerLine	If the output is ASCII format, defines the number of MAUs printed per line.

Exceptions

InvalidData	If machine or BEM is not loaded or if they are erroneous or if the given program is not in the program set.
OutOfRange	If mausPerLine is negative.

Definition at line 185 of file ProgramImageGenerator.cc.

                     {
 
    if (mausPerLine < 0) {
        string errorMsg = "Negative number of MAUs printed per line.";
        throw OutOfRange(__FILE__, __LINE__, __func__, errorMsg);
    }
    InstructionBitVector* programBits = compressor_->compress(programName);
    int mau = compressor_->machine().controlUnit()->addressSpace()->width();
    BitImageWriter* writer = NULL;
 
    if (Application::verboseLevel() > 0) {
        size_t instructionCount = 
            compressor_->currentProgram().instructionCount();
        size_t uncompressedWidth = compressor_->binaryEncoding().width();
        Application::logStream()
            << (boost::format(
                    "%s: %d instructions\n"
                    "uncompressed total size %d bits (%d bytes),\n")
                % programName % instructionCount 
                % (uncompressedWidth * instructionCount)
                % int(std::ceil(uncompressedWidth * instructionCount / 8.0))).
            str();
 
        Application::logStream()
            << (boost::format(
                    "compressed total size %d bits (%d bytes)\n")
                % programBits->size() 
                % size_t(std::ceil(programBits->size() / 8.0))).str();
 
        // count some stats from the program that affect instruction 
        // memory usage
        TTAProgram::Program& prog = compressor_->currentProgram();
        TTAMachine::Machine mach = prog.targetProcessor();
 
        TTAProgram::Program::InstructionVector instructions =
            prog.instructionVector();
 
        std::size_t moveSlots = mach.busNavigator().count();
        std::size_t maxMoves = moveSlots * prog.instructionCount();
        std::size_t moves = prog.moveCount();
        std::size_t NOPCount = maxMoves - moves;
 
        Application::logStream()
            << (boost::format(
                    "number of NOP moves: %d (%.1f%% of total move slots)\n")
                % NOPCount % (float(NOPCount) * 100 / maxMoves)).str();
 
 
        // immediate stats
        int totalImmediates = 0;
        int totalLongImmediates = 0;
        std::set<int> allImmediates;
        std::set<int> programAddresses;
        std::set<int> dataAddresses;
 
        for (int m = 0; m < prog.moveCount(); ++m) {
            const TTAProgram::Move& move = prog.moveAt(m);
            if (move.source().isImmediate()) {
                const auto value = move.source().value().sIntWordValue();
                ++totalImmediates;
                allImmediates.insert(value);
                if (move.source().isAddress()) {
                    dataAddresses.insert(value);
                } else if (move.source().isInstructionAddress()) {
                    programAddresses.insert(value);
                }
            }
        }
        // find the long immediates also
        for (TTAProgram::Program::InstructionVector::const_iterator i = 
                 instructions.begin(); i != instructions.end(); ++i) {
            const TTAProgram::Instruction& instruction = **i;
            for (int imm = 0; imm < instruction.immediateCount(); ++imm) {
                const Immediate& immediate = instruction.immediate(imm);
                const auto value = immediate.value().value().sIntWordValue();
                ++totalImmediates;
                ++totalLongImmediates;
                allImmediates.insert(value);
                if (immediate.value().isAddress()) {
                    dataAddresses.insert(value);
                } else if (immediate.value().isInstructionAddress()) {
                    programAddresses.insert(value);
                }
            }
                
        }
 
        // variables for NOP counting
        int totalFullNOPs = 0;
        int totalTwoConsNOPs = 0;
        int totalThreeConsNOPs = 0;
        int totalFourConsNOPs = 0;
        bool oneConsecutiveNOP = false;
        bool twoConsecutiveNOPs = false;
        bool threeConsecutiveNOPs = false;
        bool fourConsecutiveNOPs = false;
        
        // Find information about NOP instructions from program's instr.vectors
        for (TTAProgram::Program::InstructionVector::const_iterator i = 
                 instructions.begin(); i != instructions.end(); ++i) {
            const TTAProgram::Instruction& instruction = **i;
            if (instruction.isNOP()) {
 
                // Increase count for each single full instruction NOP
                ++totalFullNOPs;
 
                // Find full instruction NOP groups iteratively, ie. if there
                // are 4 NOPs in a row, decrease count for 3 NOPs, etc.
                if (fourConsecutiveNOPs) {
                    // We don't change count beyond 4 or more consecutive
                    // NOP instructions.
                } else if (threeConsecutiveNOPs) {
                    fourConsecutiveNOPs = true;
                    ++totalFourConsNOPs;
                    --totalThreeConsNOPs; // Actually 4 NOPs in a row, not 3
                } else if (twoConsecutiveNOPs) {
                    threeConsecutiveNOPs = true;
                    ++totalThreeConsNOPs;
                    --totalTwoConsNOPs; // Actually 3 NOPs in a row, not 2
                } else if (oneConsecutiveNOP) {
                    twoConsecutiveNOPs = true;
                    ++totalTwoConsNOPs;
                }
                oneConsecutiveNOP = true;
            } else {
                oneConsecutiveNOP = false;
                twoConsecutiveNOPs = false;
                threeConsecutiveNOPs = false;
                fourConsecutiveNOPs = false;
            }
        } 
 
        // Print information about immediates, addresses and NOPs
        Application::logStream()
            << (boost::format(
                    "total immediates: %d (long %.1f%%), "
                    "different immediate values: %d,\n"
                    "instr. addresses %d (%.1f%%), "
                    "data addresses %d (%.1f%%),\n"
                    "total full instruction NOPs: %d (%.1f%% of instructions),\n"
                    "two consecutive full instruction NOPs: %d,\n" 
                    "three consecutive full instruction NOPs: %d,\n" 
                    "four consecutive full instruction NOPs: %d\n") 
                % totalImmediates 
                % (totalLongImmediates * 100.0 / totalImmediates)
                % allImmediates.size() % programAddresses.size() 
                % (programAddresses.size() * 100.0 / allImmediates.size())
                % dataAddresses.size()
                % (dataAddresses.size() * 100.0 / allImmediates.size())
                % totalFullNOPs
                % (totalFullNOPs * 100.0 / instructionCount)
                % totalTwoConsNOPs
                % totalThreeConsNOPs
                % totalFourConsNOPs)
                .str();
    }
 
 
    if (format == BINARY) {
        writer = new RawImageWriter(*programBits);
    } else if (format == ASCII) {
        // change this to "mausPerLine > 0" when mau == instructionwidth
        // does not apply anymore
        if (mausPerLine > 1) {
            writer = new AsciiImageWriter(*programBits, mau * mausPerLine);
        } else {
           writer = new AsciiProgramImageWriter(*programBits);
       }
    } else if (format == ARRAY) {
        if (mausPerLine > 1) {
            writer = new ArrayImageWriter(*programBits, mau * mausPerLine);
        } else {
            writer = new ArrayProgramImageWriter(*programBits);
        }
    } else if (format == MIF) {
        writer = new MifImageWriter(*programBits, mau);
    } else if (format == VHDL) {
        writer = new VhdlProgramImageWriter(*programBits, entityName_);
    } else if (format == COE) {
        writer = new CoeImageWriter(*programBits, mau);
    } else if (format == HEX) {
        writer = new HexImageWriter(*programBits, mau);
    } else if (format == BIN2N) {
        writer = new Bin2nProgramImageWriter(*programBits);
    } else {
        assert(false);
    }
    
 
    writer->writeImage(stream);
 
    delete writer;
    delete programBits;
}

References __func__, TTAMachine::FunctionUnit::addressSpace(), ARRAY, ASCII, assert, BIN2N, BINARY, CodeCompressorPlugin::binaryEncoding(), TTAMachine::Machine::busNavigator(), COE, CodeCompressorPlugin::compress(), compressor_, TTAMachine::Machine::controlUnit(), TTAMachine::Machine::Navigator< ComponentType >::count(), CodeCompressorPlugin::currentProgram(), entityName_, HEX, TTAProgram::Instruction::immediate(), TTAProgram::Instruction::immediateCount(), TTAProgram::Program::instructionCount(), TTAProgram::Program::instructionVector(), TTAProgram::Terminal::isAddress(), TTAProgram::Terminal::isImmediate(), TTAProgram::Terminal::isInstructionAddress(), TTAProgram::Instruction::isNOP(), Application::logStream(), CodeCompressorPlugin::machine(), MIF, TTAProgram::Program::moveAt(), TTAProgram::Program::moveCount(), SimValue::sIntWordValue(), TTAProgram::Move::source(), TTAProgram::Program::targetProcessor(), TTAProgram::Immediate::value(), TTAProgram::Terminal::value(), TTAProgram::TerminalImmediate::value(), Application::verboseLevel(), VHDL, TTAMachine::AddressSpace::width(), BinaryEncoding::width(), and BitImageWriter::writeImage().

Referenced by RemoteController::loadIMemImage(), and main().

Here is the call graph for this function:

imemMauWidth()

int ProgramImageGenerator::imemMauWidth

(

)

const

Asks the instruction memory mau width from code compressor plugin and returns it

Returns

instruction memory mau width

Definition at line 747 of file ProgramImageGenerator.cc.

                                          {
 
    return compressor_->imemMauWidth();
}

References compressor_, and CodeCompressorPlugin::imemMauWidth().

Referenced by main().

Here is the call graph for this function:

isDataStartSet()

bool ProgramImageGenerator::isDataStartSet

(

std::string

aSpace

)

const

Definition at line 774 of file ProgramImageGenerator.cc.

                                                            {
    CmdLineOptionParser* opts = dataStartOptions_;
    assert(opts);
    if (opts->isDefined()) {
        int size = opts->listSize();
        if (size == 1) {
            return true;
        }
        if (size % 2 != 0) {
            abortWithError("ERROR: " + DATA_START_DESC);
        }
        for (int i = 1; i <= size; i += 2) {
            TCEString as_name = opts->String(i);
            if (as_name == aSpace) {
                return true;
            }
        }
    }
    return false;
}

References abortWithError, assert, DATA_START_DESC, dataStartOptions_, CmdLineOptionParser::isDefined(), CmdLineOptionParser::listSize(), and CmdLineOptionParser::String().

Referenced by writeDataSection().

Here is the call graph for this function:

loadBEM()

void ProgramImageGenerator::loadBEM

(

const BinaryEncoding &

bem

)

Sets the binary encoding map used when generating the program image.

Parameters

bem	The binary encoding map.

Definition at line 162 of file ProgramImageGenerator.cc.

                                                        {
    compressor_->setBEM(bem);
}

References compressor_, and CodeCompressorPlugin::setBEM().

Referenced by RemoteController::loadIMemImage(), main(), and ProGe::RV32MicroCodeGenerator::RV32MicroCodeGenerator().

Here is the call graph for this function:

loadCompressorParameters()

void ProgramImageGenerator::loadCompressorParameters

(

CodeCompressorPlugin::ParameterTable

parameters

)

Loads the given code compressor plugin parameters to the plugin.

Parameters

parameters

The parameters.

Definition at line 127 of file ProgramImageGenerator.cc.

                                                   {
        
    compressor_->setParameters(parameters);
}

References compressor_, and CodeCompressorPlugin::setParameters().

Referenced by main().

Here is the call graph for this function:

loadCompressorPlugin()

void ProgramImageGenerator::loadCompressorPlugin

(

const std::string &

fileName

)

Loads the code compressor plugin from the given object file.

Parameters

fileName

The file name.

Exceptions

FileNotFound	If the given file is not found from the search paths of code compressor plugins.
DynamicLibraryException	If the dynamic library cannot be opened.

Definition at line 114 of file ProgramImageGenerator.cc.

                                                                     {
    CodeCompressorPlugin* newCompressor = createCompressor(
        fileName, pluginTool_);
    delete compressor_;
    compressor_ = newCompressor;
}

References compressor_, createCompressor(), and pluginTool_.

Referenced by main().

Here is the call graph for this function:

loadMachine()

void ProgramImageGenerator::loadMachine

(

const TTAMachine::Machine &

machine

)

Sets the machine which executes the programs.

Parameters

machine

The machine.

Definition at line 151 of file ProgramImageGenerator.cc.

                                                                   {
    compressor_->setMachine(machine);
}

References compressor_, machine, and CodeCompressorPlugin::setMachine().

Referenced by RemoteController::loadIMemImage(), main(), and ProGe::RV32MicroCodeGenerator::RV32MicroCodeGenerator().

Here is the call graph for this function:

loadPrograms()

void ProgramImageGenerator::loadPrograms

(

TPEFMap

programs

)

Loads the programs to be generated to the compressor plugin.

Parameters

programs

The programs.

Definition at line 140 of file ProgramImageGenerator.cc.

                                                    {
    compressor_->setPrograms(programs);
}

References compressor_, and CodeCompressorPlugin::setPrograms().

Referenced by RemoteController::loadIMemImage(), and main().

Here is the call graph for this function:

printCompressorDescription()

void ProgramImageGenerator::printCompressorDescription ( const std::string &  fileName, std::ostream &  stream  )

static

Loads the code compressor plugin from the given file and prints its description to the given stream.

Parameters

fileName	The code compressor plugin file.
stream	The output stream.

Exceptions

FileNotFound	If the given file is not found from the search paths of code compressor plugins.
DynamicLibraryException	If the dynamic library cannot be opened.

Definition at line 653 of file ProgramImageGenerator.cc.

                                                   {
    PluginTools pluginTool;
    CodeCompressorPlugin* compressor = createCompressor(
        fileName, pluginTool);
    compressor->printDescription(stream);
    delete compressor;
}

References compressor(), createCompressor(), and CodeCompressorPlugin::printDescription().

Referenced by main().

Here is the call graph for this function:

relocTarget()

TPEF::InstructionElement * ProgramImageGenerator::relocTarget ( const TPEF::Binary &  program, const TPEF::DataSection &  dataSection, Word  dataSectionOffset  ) const

private

Returns an InstructionElement that is relocation target of the data in data section at the given offset. Returns NULL if the data doesn't need to be altered.

Parameters

dataSection	The data section,
dataSectionOffset	The offset.

Returns

The InstructionElement or NULL.

Definition at line 702 of file ProgramImageGenerator.cc.

                                  {
 
    // find the correct reloc section
    for (unsigned int i = 0; i < program.sectionCount(Section::ST_RELOC);
         i++) {
        RelocSection* section =  dynamic_cast<RelocSection*>(
            program.section(Section::ST_RELOC, i));
        assert(section != NULL);
        if (section->referencedSection() == &dataSection) {
            // correct reloc section found
            Word elemCount = section->elementCount();
            for (Word elemIndex = 0; elemIndex < elemCount; elemIndex++) {
                RelocElement* relocElem = dynamic_cast<RelocElement*>(
                    section->element(elemIndex));
                assert(relocElem != NULL);
                Chunk* location = dynamic_cast<Chunk*>(
                    relocElem->location());
                assert(location != NULL);
                if (location->offset() == dataSectionOffset) {
                    InstructionElement* destination = 
                        dynamic_cast<InstructionElement*>(
                            relocElem->destination());
                    if (destination != NULL) {
                        return destination;
                    } else {
                        return NULL;
                    }
                }
            }
        }
    }
 
    return NULL;
}

References assert, TPEF::RelocElement::destination(), TPEF::Section::element(), TPEF::Section::elementCount(), TPEF::RelocElement::location(), TPEF::Chunk::offset(), program, TPEF::RelocSection::referencedSection(), and TPEF::Section::ST_RELOC.

Referenced by writeDataSection().

Here is the call graph for this function:

setDataStartOptions()

void ProgramImageGenerator::setDataStartOptions

(

CmdLineOptionParser *

options

)

Definition at line 760 of file ProgramImageGenerator.cc.

                                                                       {
    dataStartOptions_ = options;
}

References dataStartOptions_, and options.

Referenced by main().

setEntityName()

void ProgramImageGenerator::setEntityName

(

const std::string &

entity

)

Definition at line 754 of file ProgramImageGenerator.cc.

                                                            {
    
    entityName_ = entity;
}

References entityName_.

Referenced by main().

writeDataSection()

void ProgramImageGenerator::writeDataSection	(	TPEF::Binary &	program,
		BitVector &	bitVector,
		const std::string &	addressSpace,
		TPEF::Section &	section
	)

Definition at line 510 of file ProgramImageGenerator.cc.

                      {
    
    // get the data section
    StringSection* stringSection = program.strings();
 
    CodeSection* codeSection = dynamic_cast<CodeSection*>(
        program.section(Section::ST_CODE, 0));
 
    if (stringSection->chunk2String(section.aSpace()->name()) == 
        addressSpace) {
        
        // correct data section found
        DataSection& dataSection = dynamic_cast<DataSection&>(section);
        
        // fill the beginning of the data image with zeros
        AddressImage startingAddress = dataSection.startingAddress();
        // If we already have put something, fill the correct number,
        // not from 0.
        unsigned int zeroFillStart = 0;
        if ((dataBits.size() == 0) && isDataStartSet(addressSpace)) {
            // User can set custom starting address, which means that the
            // beginning is not zero-filled up to that point
            zeroFillStart = dataStartAddress(addressSpace);
        } else {
            zeroFillStart = dataBits.size() / 8;  // 8 bits per byte
        }
 
        for (AddressImage i = zeroFillStart; i < startingAddress; i++) {
            dataBits.pushBack(0, 8);
        }
        if (zeroFillStart > startingAddress) {
            throw InvalidData(
                __FILE__,__LINE__,__func__, "Illegal order of data sections.");
        }
        
        // fill the data
        Word sectionLength = dataSection.length();
        for (Word offset = 0; offset < sectionLength;) {
            InstructionElement* relocTarget = 
                this->relocTarget(program, dataSection, offset);
            if (relocTarget != NULL) {
                Word indexOfInstruction = 
                    codeSection->indexOfInstruction(*relocTarget);
                Instruction& instruction = 
                    compressor_->currentProgram().instructionAt(
                        indexOfInstruction);
                try {
                    unsigned int memAddress = compressor_->memoryAddress(
                        instruction);
                    if (compressor_->machine().isLittleEndian()){
                        // Byteswap the pointer
                        unsigned int num = memAddress;
                        memAddress = ((num>>24)&0xff) |
                        ((num<<8)&0xff0000) |
                        ((num>>8)&0xff00) |
                        ((num<<24)&0xff000000);
                    }
                    dataBits.pushBack(memAddress, 32);
                    offset += 4;
                    } catch (const Exception& e) {
                    string errorMsg = 
                            "Program image must be generated before "
                        "generating data image.";
                    throw InvalidData(
                        __FILE__, __LINE__, __func__, errorMsg);
                }
            } else {                    
                Byte byte = dataSection.byte(offset);
                dataBits.pushBack(byte, 8);
                offset++;
            }
        }
    }
}

References __func__, TPEF::Section::aSpace(), TPEF::DataSection::byte(), TPEF::StringSection::chunk2String(), compressor_, CodeCompressorPlugin::currentProgram(), dataStartAddress(), TPEF::CodeSection::indexOfInstruction(), TTAProgram::Program::instructionAt(), isDataStartSet(), TTAMachine::Machine::isLittleEndian(), TPEF::DataSection::length(), CodeCompressorPlugin::machine(), CodeCompressorPlugin::memoryAddress(), TPEF::ASpaceElement::name(), program, BitVector::pushBack(), relocTarget(), TPEF::Section::ST_CODE, and TPEF::Section::startingAddress().

Referenced by generateDataImage().

Here is the call graph for this function:

Member Data Documentation

compressor_

CodeCompressorPlugin* ProgramImageGenerator::compressor_

private

The code compressor.

Definition at line 135 of file ProgramImageGenerator.hh.

Referenced by compressor(), generateDataImage(), generateDecompressor(), generateProgramImage(), imemMauWidth(), loadBEM(), loadCompressorParameters(), loadCompressorPlugin(), loadMachine(), loadPrograms(), writeDataSection(), and ~ProgramImageGenerator().

DATA_START_DESC

const std::string ProgramImageGenerator::DATA_START_DESC

staticprivate

Definition at line 139 of file ProgramImageGenerator.hh.

Referenced by dataStartAddress(), and isDataStartSet().

dataStartOptions_

CmdLineOptionParser* ProgramImageGenerator::dataStartOptions_

private

Definition at line 140 of file ProgramImageGenerator.hh.

Referenced by dataStartAddress(), isDataStartSet(), and setDataStartOptions().

entityName_

std::string ProgramImageGenerator::entityName_

private

Toplevel entity name.

Definition at line 137 of file ProgramImageGenerator.hh.

Referenced by generateDataImage(), generateProgramImage(), and setEntityName().

pluginTool_

PluginTools ProgramImageGenerator::pluginTool_

private

The plugin tool.

Definition at line 142 of file ProgramImageGenerator.hh.

Referenced by loadCompressorPlugin().

---

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

• ProgramImageGenerator.hh
• ProgramImageGenerator.cc