#include <iostream>
#include <cmath>
#include <boost/format.hpp>
#include "PIGCmdLineOptions.hh"
#include "ProgramImageGenerator.hh"
#include "PIGCLITextGenerator.hh"
#include "ADFSerializer.hh"
#include "Machine.hh"
#include "ControlUnit.hh"
#include "BinaryEncoding.hh"
#include "BEMSerializer.hh"
#include "BEMGenerator.hh"
#include "Binary.hh"
#include "BinaryStream.hh"
#include "BinaryReader.hh"
#include "FileSystem.hh"

Include dependency graph for GenerateBits.cc:

Functions
static Binary *	loadTPEF (const std::string &tpefFile)

static BinaryEncoding *	loadBEM (const std::string &bemFile)

static Machine *	loadMachine (const std::string &adfFile)

static bool	isInstructionMemory (const TTAMachine::AddressSpace &as)

std::string	programImemImageFile (const std::string &tpefFile, const std::string &format)

std::string	programDataImageFile (const std::string &tpefFile, const std::string &format, const std::string &asName)

void	parseParameter (const std::string &param, std::string &paramName, std::string &paramValue)

void	createMauPkg (int language, int imemMauWidth, string fileName, string entityNameStr)

void	createCompressor (string fileName, ProgramImageGenerator &imageGenerator, string entityStr)

void	copyImageToTb (const string &source, const string &progeDir, const string &newImage)

int	main (int argc, char *argv[])

Variables
const int	DEFAULT_IMEMWIDTH_IN_MAUS = 1

const string	IMEM_MAU_PKG = "imem_mau_pkg.vhdl"

const string	VER_IMEM_MAU_PKG = "imem_mau_pkg.vh"

const string	DECOMPRESSOR_FILE = "idecompressor.vhdl"

const string	TB_DIR = "tb"

const string	DIR_SEP = FileSystem::DIRECTORY_SEPARATOR

const string	TB_IMEM_FILE = "imem_init.img"

const string	TB_DMEM_FILE = "dmem_init.img"

Detailed Description

Implementation of the main function of generatebits application.

Author: Lasse Laasonen 2005 (lasse.laasonen-no.spam-tut.fi); Otto Esko 2009 (otto.esko-no.spam-tut.fi); Pekka Jääskeläinen 2009 (pekka.jaaskelainen-no.spam-tut.fi); Otto Esko 2010 (otto.esko-no.spam-tut.fi); Pekka Jääskeläinen 2011; Vinogradov Viacheslav(added Verilog generating) 2012

Note: rating: red

Definition in file GenerateBits.cc.

Function Documentation

◆ copyImageToTb()

void copyImageToTb	(	const string &	source,
		const string &	progeDir,
		const string &	newImage
	)

Definition at line 271 of file GenerateBits.cc.

                            {
 
    if (!progeDir.empty()) {
        string tbDir = progeDir + DIR_SEP + TB_DIR;
        string tbImage = tbDir + DIR_SEP + newImage;
        if (FileSystem::fileIsDirectory(tbDir) 
            && (FileSystem::fileIsWritable(tbImage) 
                || FileSystem::fileIsCreatable(tbImage))) {
            try {
                FileSystem::copy(source, tbImage);
            } catch (Exception& e) {
                cerr << e.errorMessage() << endl;
            }
        }
    }
}

References FileSystem::copy(), DIR_SEP, Exception::errorMessage(), FileSystem::fileIsCreatable(), FileSystem::fileIsDirectory(), FileSystem::fileIsWritable(), and TB_DIR.

Referenced by main().

Here is the call graph for this function:

◆ createCompressor()

void createCompressor	(	string	fileName,
		ProgramImageGenerator &	imageGenerator,
		string	entityStr
	)

Definition at line 254 of file GenerateBits.cc.

                      {
 
    bool created = FileSystem::createFile(fileName);
    if (!created) {
        string errorMsg = "Unable to create file " + 
            fileName;
        throw IOException(__FILE__, __LINE__, __func__, errorMsg);
    }
    std::ofstream decompressorStream(
        fileName.c_str(), std::ofstream::out);
    imageGenerator.generateDecompressor(decompressorStream, entityStr);
    decompressorStream.close();
}

References __func__, FileSystem::createFile(), and ProgramImageGenerator::generateDecompressor().

Referenced by main().

Here is the call graph for this function:

◆ createMauPkg()

void createMauPkg	(	int	language,
		int	imemMauWidth,
		string	fileName,
		string	entityNameStr
	)

Definition at line 222 of file GenerateBits.cc.

                                                             {
 
    string indentation = "   ";
 
    if (!FileSystem::fileExists(fileName) 
        && !FileSystem::createFile(fileName)) {
        string errorMsg = "Unable to create file " + fileName;
        throw IOException(__FILE__, __LINE__, __func__, errorMsg);
    } else if (!FileSystem::fileIsWritable(fileName)) {
        string errorMsg = "Unable to write to file " + fileName;
        throw IOException(__FILE__, __LINE__, __func__, errorMsg);
    }
    std::ofstream stream(fileName.c_str());
    string entityName = entityNameStr + "_imem_mau";
    if(language==0){//vhdl
        stream << "package " << entityName << " is" << endl
               << indentation << "-- created by generatebits" << endl
               << indentation << "constant IMEMMAUWIDTH : positive := "
               << imemMauWidth << ";" << endl
               << "end " << entityName << ";" << endl;
    } else {
        stream << "//package " << entityName << " is" << endl
               << indentation  << "// created by generatebits" << endl
               << indentation  << "parameter IMEMMAUWIDTH = "
               << imemMauWidth << endl
               << "//end " << entityName << ";" << endl;    
    }
    stream.close();
}

References __func__, FileSystem::createFile(), FileSystem::fileExists(), and FileSystem::fileIsWritable().

Referenced by main().

Here is the call graph for this function:

◆ isInstructionMemory()

static bool isInstructionMemory ( const TTAMachine::AddressSpace & as )

static

Tells whether the given address space is instruction memory.

Parameters

as	The address space.

Returns: True if the address space is instruction memory, otherwise false.

Definition at line 135 of file GenerateBits.cc.

                                                      {
    Machine* mach = as.machine();
    ControlUnit* gcu = mach->controlUnit();
    if (gcu != NULL && gcu->addressSpace() == &as) {
        return true;
    } else {
        return false;
    }
}

References TTAMachine::FunctionUnit::addressSpace(), TTAMachine::Machine::controlUnit(), and TTAMachine::Component::machine().

Referenced by main().

Here is the call graph for this function:

◆ loadBEM()

static BinaryEncoding * loadBEM ( const std::string & bemFile )

static

Loads the given BEM file and creates a BinaryEncoding instance from it.

Parameters

bemFile The BEM file.

Returns: The newly created BinaryEncoding instance.

Exceptions

SerializerException	If an error occurs while reading the file.
ObjectStateLoadingException	If an error occurs while loading the state of BinaryEncoding instance.

Definition at line 106 of file GenerateBits.cc.

                                  {
    BEMSerializer serializer;
    serializer.setSourceFile(bemFile);
    return serializer.readBinaryEncoding();
}

References BEMSerializer::readBinaryEncoding(), and XMLSerializer::setSourceFile().

Referenced by main().

Here is the call graph for this function:

◆ loadMachine()

static Machine * loadMachine ( const std::string & adfFile )

static

Loads the given ADF file and creates a Machine instance from it.

Parameters

adfFile The ADF file.

Returns: The newly created Machine instance.

Exceptions

SerializerException	If an error occurs while reading the file.
ObjectStateLoadingException	If an error occurs while loading the state of Machine instance.

Definition at line 122 of file GenerateBits.cc.

                                      {
    ADFSerializer serializer;
    serializer.setSourceFile(adfFile);
    return serializer.readMachine();
}

References ADFSerializer::readMachine(), and XMLSerializer::setSourceFile().

Referenced by main().

Here is the call graph for this function:

◆ loadTPEF()

static Binary * loadTPEF ( const std::string & tpefFile )

static

Loads the given TPEF file and creates a Binary instance from it.

Parameters

tpefFile The TPEF file.

Returns: The newly created Binary instance.

Exceptions

InstanceNotFound	If instance for reading wasn't found.
UnreachableStream	If given file can't be read.
KeyAlreadyExists	Key was in use when trying to register object.
EndOfFile	If end of file were reached while it shouldn't.
OutOfRange	Some read value was out of range.
WrongSubclass	Some class couldn't do what it was asked for.
UnexpectedValue	If there was unexpected value when reading.

Definition at line 89 of file GenerateBits.cc.

                                    {
    BinaryStream stream(tpefFile);
    return BinaryReader::readBinary(stream);
}

References TPEF::BinaryReader::readBinary().

Referenced by main().

Here is the call graph for this function:

◆ main()

int main	(	int	argc,
		char *	argv[]
	)

The main function of generatebits application.

Definition at line 294 of file GenerateBits.cc.

                                 {
 
    PIGCmdLineOptions* options = new PIGCmdLineOptions;
    try {
        options->parse(argv, argc);
    } catch (ParserStopRequest const&) {
        return EXIT_SUCCESS;
    } catch (const IllegalCommandLine& exception) {
        cerr << exception.errorMessage() << endl;
        return EXIT_FAILURE;
    }
 
    Application::setCmdLineOptions(options);
    
    string adfFile = "";
    if (options->numberOfArguments() < 1) {
        PIGCLITextGenerator textGen;
        cerr << textGen.text(PIGCLITextGenerator::TXT_ADF_REQUIRED) << endl;
        return EXIT_FAILURE;
    } else if (options->numberOfArguments() > 1) {
        PIGCLITextGenerator textGen;
        cerr << textGen.text(PIGCLITextGenerator::TXT_ILLEGAL_ARGS) << endl;
        return EXIT_FAILURE;
    } else {
        adfFile = options->argument(1);
    }
    
    string bemFile = options->bemFile();
    string piFormat = options->programImageOutputFormat();
    string diFormat = options->dataImageOutputFormat();
    int dmemMAUsPerLine = options->dataMemoryWidthInMAUs();
    string compressor = options->compressorPlugin();
    const bool useCompression = compressor != "";
    bool generateDataImages = options->generateDataImages();
    bool generateDecompressor = options->generateDecompressor();
    bool showCompressors = options->showCompressors();
    int imemMAUsPerLine = DEFAULT_IMEMWIDTH_IN_MAUS;
    string progeOutputDir = options->progeOutputDirectory();
 
    TCEString entityStr = options->entityName();
    if (entityStr == "")
        entityStr = "tta0";
 
    if (showCompressors) {
        std::vector<string> compressorFiles = 
            ProgramImageGenerator::availableCompressors();
        for (std::vector<string>::const_iterator iter = 
                 compressorFiles.begin();
             iter != compressorFiles.end(); iter++) {
            try {
                std::cout << "******************************************"
                          << "**********************" << endl;
                std::cout << "Compressor file: " << *iter << endl;
             
                ProgramImageGenerator::printCompressorDescription(
                    *iter, std::cout);
            } catch (const Exception& e) {
                cerr << "Error: " << e.errorMessage() << endl;
            }
            std::cout << std::endl;
        }
        return EXIT_SUCCESS;
    }       
 
    CodeCompressorPlugin::ParameterTable compressorParams;
    for (int i = 0; i < options->compressorParameterCount(); i++) {
        string param = options->compressorParameter(i);
        string paramName;
        string paramValue;
        try {
            parseParameter(param, paramName, paramValue);
        } catch (const Exception& e) {
            cerr << e.errorMessage() << endl;
            return EXIT_FAILURE;
        }
        CodeCompressorPlugin::Parameter newParam = {paramName, paramValue};
        compressorParams.push_back(newParam);
    }
    
    if (adfFile == "" || 
        (piFormat != "" && piFormat != "binary" && piFormat != "ascii" &&
         piFormat != "array" && piFormat != "mif" && piFormat != "vhdl" &&
         piFormat != "coe" && piFormat != "hex" && piFormat != "bin2n") ||
        (diFormat != "" && diFormat != "binary" &&
         diFormat != "ascii" && diFormat != "array" && diFormat != "mif" &&
         diFormat != "vhdl" && diFormat != "coe" && diFormat != "hex" && diFormat != "bin2n")) {
        options->printHelp();
        return EXIT_FAILURE;
    }
 
    std::vector<Binary*> tpefTable;        
    ProgramImageGenerator::TPEFMap tpefMap;
    try {
        Machine* mach = loadMachine(adfFile);
 
        for (int i = 0; i < options->tpefFileCount(); i++) {
            string tpefFile = options->tpefFile(i);
            Binary* tpef = loadTPEF(tpefFile);
            tpefTable.push_back(tpef);
            tpefMap[FileSystem::fileOfPath(tpefFile)] = tpef;
        }
 
        BinaryEncoding* bem = NULL;
        
        if (bemFile != "") {
            bem = loadBEM(bemFile);
        } else {
            PIGCLITextGenerator textGen;
#if 0
            // useless error output as this happens 100% of the time,
            // no-one hasn't wanted to customize BEMs yet
            std::cerr 
                << textGen.text(PIGCLITextGenerator::TXT_GENERATING_BEM).
                str() << std::endl;
#endif
            BEMGenerator bemGenerator(*mach);
            bem = bemGenerator.generate();
        }
 
        ProgramImageGenerator imageGenerator;
        if (useCompression) {
            imageGenerator.loadCompressorPlugin(compressor);
        }
        imageGenerator.loadCompressorParameters(compressorParams);
        imageGenerator.loadBEM(*bem);
        imageGenerator.loadMachine(*mach);        
        imageGenerator.loadPrograms(tpefMap);
        imageGenerator.setEntityName(entityStr);
        imageGenerator.setDataStartOptions(options->dataStart());
 
        if (Application::verboseLevel() > 0) {
            Application::logStream()
                << (boost::format(
                        "uncompressed instruction width: %d bits (%d bytes)\n" )
                    % bem->width() % std::ceil(bem->width() / 8.0)).str();
        }
 
        for (size_t i = 0; i < tpefTable.size(); i++) {
 
            Binary* program = tpefTable[i];
            string tpefFile = FileSystem::fileOfPath(options->tpefFile(i));
            string imageFile = programImemImageFile(tpefFile, piFormat);
            ofstream piStream(imageFile.c_str());
            if (piFormat == "binary") {
                imageGenerator.generateProgramImage(
                    tpefFile, piStream, ProgramImageGenerator::BINARY);
            } else if (piFormat == "array") {
                imageGenerator.generateProgramImage(
                    tpefFile, piStream, ProgramImageGenerator::ARRAY,
                    imemMAUsPerLine);
            } else if (piFormat == "mif") {
                imageGenerator.generateProgramImage(
                    tpefFile, piStream, ProgramImageGenerator::MIF,
                    imemMAUsPerLine);
            } else if (piFormat == "vhdl") {
                imageGenerator.generateProgramImage(
                    tpefFile, piStream, ProgramImageGenerator::VHDL,
                    imemMAUsPerLine);
            } else if (piFormat == "coe") {
                imageGenerator.generateProgramImage(
                    tpefFile, piStream, ProgramImageGenerator::COE,
                    imemMAUsPerLine);
            } else if (piFormat == "hex") {
                imageGenerator.generateProgramImage(
                    tpefFile, piStream, ProgramImageGenerator::HEX,
                    imemMAUsPerLine);
        } else if (piFormat == "bin2n") {
                imageGenerator.generateProgramImage(
                    tpefFile, piStream, ProgramImageGenerator::BIN2N,
                    imemMAUsPerLine);
            } else {
                assert(piFormat == "ascii" || piFormat == "");
                imageGenerator.generateProgramImage(
                    tpefFile, piStream, ProgramImageGenerator::ASCII,
                    imemMAUsPerLine);
            }
            piStream.close();
 
            if (piFormat == "ascii" || piFormat == "") {
                copyImageToTb(imageFile, progeOutputDir, TB_IMEM_FILE);
            }
 
            if (generateDataImages) {
                Machine::AddressSpaceNavigator asNav =
                    mach->addressSpaceNavigator();
                for (int i = 0; i < asNav.count(); i++) {
                    AddressSpace* as = asNav.item(i);
                    if (!isInstructionMemory(*as)) {
                        string fileName =
                            programDataImageFile(
                                tpefFile, diFormat, as->name());
                        ofstream stream(fileName.c_str());
                        if (diFormat == "binary") {
                            imageGenerator.generateDataImage(
                                tpefFile, *program, as->name(), stream,
                                ProgramImageGenerator::BINARY, 1, true);
                        } else if (diFormat == "array") {
                            imageGenerator.generateDataImage(
                                tpefFile, *program, as->name(), stream,
                                ProgramImageGenerator::ARRAY,
                                dmemMAUsPerLine, true);
                        } else if (diFormat == "mif") {
                            imageGenerator.generateDataImage(
                                tpefFile, *program, as->name(), stream,
                                ProgramImageGenerator::MIF,
                                dmemMAUsPerLine, true);
                        } else if (diFormat == "vhdl") {
                            imageGenerator.generateDataImage(
                                tpefFile, *program, as->name(), stream,
                                ProgramImageGenerator::VHDL,
                                dmemMAUsPerLine, true);
                        } else if (diFormat == "coe") {
                            imageGenerator.generateDataImage(
                                tpefFile, *program, as->name(), stream,
                                ProgramImageGenerator::COE,
                                dmemMAUsPerLine, true);
                        } else if (diFormat == "hex") {
                            imageGenerator.generateDataImage(
                                tpefFile, *program, as->name(), stream,
                                ProgramImageGenerator::HEX,
                                dmemMAUsPerLine, true);
                        } else if (diFormat == "bin2n") {
                            imageGenerator.generateDataImage(
                                tpefFile, *program, as->name(), stream,
                                ProgramImageGenerator::BIN2N,
                                dmemMAUsPerLine, true);
                        } else {
                            assert(diFormat == "ascii" || diFormat == "");
                            imageGenerator.generateDataImage(
                                tpefFile, *program, as->name(), stream,
                                ProgramImageGenerator::ASCII,
                                dmemMAUsPerLine, true);
                        }
                        stream.close();
 
                        if (diFormat == "ascii" || piFormat == "") {
                            std::string dmemInitFile("dmem_");
                            dmemInitFile += as->name() + "_init.img";
                            copyImageToTb(
                                fileName, progeOutputDir, dmemInitFile);
                        }
                    }
                }
            }
        }
 
        if (generateDecompressor) {
            string decomp = DECOMPRESSOR_FILE;
            if (!progeOutputDir.empty()) {
                string temp =
                    progeOutputDir + DIR_SEP + "gcu_ic" + DIR_SEP 
                    + DECOMPRESSOR_FILE;
               if ( (FileSystem::fileExists(temp) 
                  &&FileSystem::fileIsWritable(temp)) 
                 || FileSystem::fileIsCreatable(temp)) {
                   decomp = temp;
               }
            }
            createCompressor(decomp, imageGenerator, entityStr);            
        }
        
        int compressedInstructionWidth = imageGenerator.imemMauWidth();
        if (!progeOutputDir.empty()) {
            string temp =
                progeOutputDir + DIR_SEP + "vhdl" + DIR_SEP + entityStr + 
                "_" + IMEM_MAU_PKG;
            if ( (FileSystem::fileExists(temp) 
                  &&FileSystem::fileIsWritable(temp)) 
                 || FileSystem::fileIsCreatable(temp)) {
                //vhdl
                createMauPkg(0,compressedInstructionWidth, temp, entityStr);
            }
            temp = 
                progeOutputDir + DIR_SEP + "verilog" + DIR_SEP + entityStr + 
                "_" + VER_IMEM_MAU_PKG;
            if ( (FileSystem::fileExists(temp) 
                  &&FileSystem::fileIsWritable(temp)) 
                 || FileSystem::fileIsCreatable(temp)) {
                //verilog
                createMauPkg(1,compressedInstructionWidth, temp, entityStr);
            }
        } else {//if none exist generate in current folder for both HDLs
            createMauPkg(0,compressedInstructionWidth, entityStr + "_" +
                         IMEM_MAU_PKG, entityStr); //vhdl
            createMauPkg(1,compressedInstructionWidth,
                entityStr + "_" + VER_IMEM_MAU_PKG, entityStr); //verilog
        }
 
        for (std::vector<Binary*>::iterator iter = tpefTable.begin();
             iter != tpefTable.end(); iter++) {
            delete *iter;
        }
        delete mach;
        delete bem;
 
        return EXIT_SUCCESS;
 
    } catch (const Exception& exception) {
        cerr << exception.errorMessageStack() << endl;
        return EXIT_FAILURE;
    }
}

Here is the call graph for this function:

◆ parseParameter()

void parseParameter	(	const std::string &	param,
		std::string &	paramName,
		std::string &	paramValue
	)

Parses the given parameter which has form 'paramname=paramvalue" to different strings.

Parameters

param	The parameter.
paramName	Parameter name is stored here.
paramValue	Parameter value is stored here.

Exceptions

InvalidData If the given parameter is not in the correct form.

Definition at line 207 of file GenerateBits.cc.

                                                                         {
    string::size_type separatorPos = param.find("=", 0);
    if (separatorPos == string::npos) {
        string errorMsg = 
            "Compressor parameters must be in form "
            "'parametername=parametervalue'.";
        throw InvalidData(__FILE__, __LINE__, __func__, errorMsg);
    }
 
    paramName = param.substr(0, separatorPos);
    paramValue = param.substr(separatorPos+1, param.length());
}

References __func__.

Referenced by main().

◆ programDataImageFile()

std::string programDataImageFile	(	const std::string &	tpefFile,
		const std::string &	format,
		const std::string &	asName
	)

Returns the name of the program data image file for the given TPEF file.

Parameters

tpefFile	Name of the TPEF file.
format	The image output format
asName	Name of the address space the image belongs to.

Returns: Name of the program image file.

Definition at line 179 of file GenerateBits.cc.

                             {
    
    string imageFile = FileSystem::fileNameBody(tpefFile) + "_" + asName;
    if (format == "mif") {
        imageFile += ".mif";
    } else if (format == "vhdl") {
        imageFile += "_pkg.vhdl";
    } else if (format == "coe") {
        imageFile += ".coe";
    } else {
        imageFile += ".img";
    }
    return imageFile;
}

References FileSystem::fileNameBody().

Referenced by main().

Here is the call graph for this function:

◆ programImemImageFile()

std::string programImemImageFile	(	const std::string &	tpefFile,
		const std::string &	format
	)

Returns the name of the program's imem image file for the given TPEF file.

Parameters

tpefFile	Name of the TPEF file.
format	The image output format

Returns: Name of the program image file.

Definition at line 154 of file GenerateBits.cc.

                                                                         {
 
    string imageFile = FileSystem::fileNameBody(tpefFile);
    if (format == "mif") {
        // altera tools want .mif ending for MIF files
        imageFile += ".mif";
    } else if (format == "vhdl") {
        imageFile += "_imem_pkg.vhdl";
    } else if (format == "coe") {
        imageFile += ".coe";
    } else {
        imageFile += ".img";
    }  
    return imageFile;
}

References FileSystem::fileNameBody().

Referenced by main().

Here is the call graph for this function:

Variable Documentation

◆ DECOMPRESSOR_FILE

const string DECOMPRESSOR_FILE = "idecompressor.vhdl"

Definition at line 68 of file GenerateBits.cc.

Referenced by main().

◆ DEFAULT_IMEMWIDTH_IN_MAUS

const int DEFAULT_IMEMWIDTH_IN_MAUS = 1

Definition at line 65 of file GenerateBits.cc.

Referenced by GenerateProcessor::generateProcessor(), and main().

◆ DIR_SEP

const string DIR_SEP = FileSystem::DIRECTORY_SEPARATOR

Definition at line 71 of file GenerateBits.cc.

Referenced by copyImageToTb(), main(), and PluginTools::registerModule().

◆ IMEM_MAU_PKG

const string IMEM_MAU_PKG = "imem_mau_pkg.vhdl"

Definition at line 66 of file GenerateBits.cc.

Referenced by main().

◆ TB_DIR

const string TB_DIR = "tb"

Definition at line 70 of file GenerateBits.cc.

Referenced by copyImageToTb().

◆ TB_DMEM_FILE

const string TB_DMEM_FILE = "dmem_init.img"

Definition at line 73 of file GenerateBits.cc.

◆ TB_IMEM_FILE

const string TB_IMEM_FILE = "imem_init.img"

Definition at line 72 of file GenerateBits.cc.

Referenced by main().

◆ VER_IMEM_MAU_PKG

const string VER_IMEM_MAU_PKG = "imem_mau_pkg.vh"

Definition at line 67 of file GenerateBits.cc.

Referenced by main().

Functions

Variables

Detailed Description

Function Documentation

◆ copyImageToTb()

◆ createCompressor()

◆ createMauPkg()

◆ isInstructionMemory()

◆ loadBEM()

◆ loadMachine()

◆ loadTPEF()

◆ main()

◆ parseParameter()

◆ programDataImageFile()

◆ programImemImageFile()

Variable Documentation

◆ DECOMPRESSOR_FILE

◆ DEFAULT_IMEMWIDTH_IN_MAUS

◆ DIR_SEP

◆ IMEM_MAU_PKG

◆ TB_DIR

◆ TB_DMEM_FILE

◆ TB_IMEM_FILE

◆ VER_IMEM_MAU_PKG