ETISS.cpp

Go to the documentation of this file.

// SPDX-License-Identifier: BSD-3-Clause
//
// This file is part of ETISS. It is licensed under the BSD 3-Clause License; you may not use this file except in
// compliance with the License. You should have received a copy of the license along with this project. If not, see the
// LICENSE file.
#include "etiss/ETISS.h"
#include "etiss/CPUCore.h"
#include "etiss/CPUArch.h"
 
#include "etiss/fault/Stressor.h"
#include "etiss/IntegratedLibrary/InstructionAccurateCallback.h"
#include "etiss/LibraryInterface.h"
 
#include <csignal>
#include <cstring>
#include <fstream>
#include <functional>
 
#include <boost/program_options/options_description.hpp>
#include <boost/program_options/parsers.hpp>
#include <boost/program_options/variables_map.hpp>
#include <boost/algorithm/string.hpp>
 
#include "SimpleIni.h"
// SimpleIni includes windows.h which defines NOERROR, clashing with our ReturnCode.
#ifdef NOERROR
#undef NOERROR
#endif
 
#if ETISS_USE_DLSYM
#include <dlfcn.h>
#endif
 
using namespace etiss;
 
std::string etiss_defaultjit_;
 
std::list<std::shared_ptr<etiss::LibraryInterface>> etiss_libraries_;
std::recursive_mutex etiss_libraries_mu_;
 
boost::program_options::variables_map vm;
std::vector<std::string> pluginOptions = { "plugin.logger.logaddr", "plugin.logger.logmask", "plugin.gdbserver.port" };
 
std::set<std::string> etiss::listCPUArchs()
{
    std::set<std::string> ret;
    std::lock_guard<std::recursive_mutex> lock(etiss_libraries_mu_);
    for (auto iter = etiss_libraries_.begin(); iter != etiss_libraries_.end(); iter++)
    {
        if ((*iter).get() != 0)
        {
            if (!(*iter)->isEmpty())
            {
                for (unsigned i = 0; i < (*iter)->countCPUArchs(); i++)
                {
                    std::string jit = (*iter)->nameCPUArch(i);
                    if (ret.find(jit) != ret.end())
                    {
                        etiss::log(etiss::ERROR, "CPUArch provided by multiple libraries: \"" + jit + "\"");
                    }
                    else
                    {
                        ret.insert(jit);
                    }
                }
            }
        }
    }
    return ret;
}
 
std::set<std::string> etiss::listJITs()
{
    std::set<std::string> ret;
    std::lock_guard<std::recursive_mutex> lock(etiss_libraries_mu_);
    for (auto iter = etiss_libraries_.begin(); iter != etiss_libraries_.end(); iter++)
    {
        if ((*iter).get() != 0)
        {
            if (!(*iter)->isEmpty())
            {
                for (unsigned i = 0; i < (*iter)->countJITs(); i++)
                {
                    std::string jit = (*iter)->nameJIT(i);
                    if (ret.find(jit) != ret.end())
                    {
                        etiss::log(etiss::ERROR, "JIT provided by multiple libraries: \"" + jit + "\"");
                    }
                    else
                    {
                        ret.insert(jit);
                    }
                }
            }
        }
    }
    return ret;
}
 
std::set<std::string> etiss::listPlugins()
{
    std::set<std::string> ret;
    std::lock_guard<std::recursive_mutex> lock(etiss_libraries_mu_);
    for (auto iter = etiss_libraries_.begin(); iter != etiss_libraries_.end(); iter++)
    {
        if ((*iter).get() != 0)
        {
            if (!(*iter)->isEmpty())
            {
                for (unsigned i = 0; i < (*iter)->countPlugins(); i++)
                {
                    std::string jit = (*iter)->namePlugin(i);
                    if (ret.find(jit) != ret.end())
                    {
                        etiss::log(etiss::ERROR, "JIT provided by multiple libraries: \"" + jit + "\"");
                    }
                    else
                    {
                        ret.insert(jit);
                    }
                }
            }
        }
    }
    return ret;
}
 
std::shared_ptr<JIT> etiss::getJIT(std::string name, std::map<std::string, std::string> options)
{
    std::shared_ptr<JIT> jit;
    std::string ujit;
    std::lock_guard<std::recursive_mutex> lock(etiss_libraries_mu_);
    for (auto iter = etiss_libraries_.begin(); iter != etiss_libraries_.end(); iter++)
    {
        std::shared_ptr<LibraryInterface> lib = *iter;
        if (lib.get() != 0)
        {
            if (!lib->isEmpty())
            {
                for (unsigned i = 0; i < lib->countJITs(); i++)
                {
                    if (lib->nameJIT(i) == name)
                    {
                        if (jit.get() != 0)
                        {
                            etiss::log(etiss::ERROR, "JIT provided by multiple libraries: using \"" + name +
                                                         "\" from library \"" + ujit +
                                                         "\" [also provided by library \"" + lib->getName() + "\"]");
                        }
                        else
                        {
                            etiss::JIT *ca = lib->createJIT(i, options);
                            if (ca == 0)
                            {
                                etiss::log(etiss::ERROR,
                                           "Failed to create JIT via library interface \"" + lib->getName() + "\"");
                            }
                            else
                            {
                                jit = std::shared_ptr<JIT>(ca, [lib](JIT *j) { lib->deleteJIT(j); });
                                ujit = lib->getName();
                            }
                        }
                    }
                }
            }
        }
    }
    return jit;
}
 
std::shared_ptr<CPUArch> etiss::getCPUArch(std::string name, std::map<std::string, std::string> options)
{
    std::shared_ptr<CPUArch> arch;
    std::string uarch;
    std::lock_guard<std::recursive_mutex> lock(etiss_libraries_mu_);
    for (auto iter = etiss_libraries_.begin(); iter != etiss_libraries_.end(); iter++)
    {
        std::shared_ptr<LibraryInterface> lib = *iter;
        if (lib.get() != 0)
        {
            if (!lib->isEmpty())
            {
                for (unsigned i = 0; i < lib->countCPUArchs(); i++)
                {
                    if (lib->nameCPUArch(i) == name)
                    {
                        if (arch.get() != 0)
                        {
                            etiss::log(etiss::ERROR, "CPU Architecture provided by multiple libraries: using \"" +
                                                         name + "\" from library \"" + uarch +
                                                         "\" [also provided by library \"" + lib->getName() + "\"]");
                        }
                        else
                        {
                            etiss::CPUArch *ca = lib->createCPUArch(i, options);
                            if (ca == 0)
                            {
                                etiss::log(etiss::ERROR,
                                           "Failed to create CPUArch via library interface \"" + lib->getName() + "\"");
                            }
                            else
                            {
                                arch = std::shared_ptr<CPUArch>(ca, [lib](CPUArch *a) { lib->deleteCPUArch(a); });
                                uarch = lib->getName();
                            }
                        }
                    }
                }
            }
        }
    }
    return arch;
}
 
std::shared_ptr<Plugin> etiss::getPlugin(std::string name, std::map<std::string, std::string> options)
{
    std::shared_ptr<Plugin> ptrPlugin;
    std::string strPluginName;
    std::lock_guard<std::recursive_mutex> lock(etiss_libraries_mu_);
    for (auto iter = etiss_libraries_.begin(); iter != etiss_libraries_.end(); iter++)
    {
        std::shared_ptr<LibraryInterface> lib = *iter;
        if (lib.get() != 0)
        {
            if (!lib->isEmpty())
            {
                for (unsigned i = 0; i < lib->countPlugins(); i++)
                {
                    if (lib->namePlugin(i) == name)
                    {
                        if (ptrPlugin.get() != 0)
                        {
                            etiss::log(etiss::ERROR, "Plugin provided by multiple libraries: using \"" + name +
                                                         "\" from library \"" + strPluginName +
                                                         "\" [also provided by library \"" + lib->getName() + "\"]");
                        }
                        else
                        {
                            etiss::Plugin *ca = lib->createPlugin(i, options);
                            if (ca == 0)
                            {
                                etiss::log(etiss::ERROR,
                                           "Failed to create Plugin via library interface \"" + lib->getName() + "\"");
                            }
                            else
                            {
                                ptrPlugin = std::shared_ptr<Plugin>(ca, [lib](Plugin *p) { lib->deletePlugin(p); });
                                strPluginName = lib->getName();
                                etiss::log(etiss::INFO, "Plugin \"" + name + "\" loaded via library interface \"" +
                                                            strPluginName + "\"\n");
                            }
                        }
                        break;
                    }
                }
            }
        }
    }
    return ptrPlugin;
}
 
bool etiss::loadLibrary(std::string path, std::string name)
{
    auto lib = etiss::LibraryInterface::openSharedLibrary(path, name);
 
    if (lib.get())
    {
        addLibrary(lib);
        return true;
    }
 
    return false;
}
 
void etiss::addLibrary(std::shared_ptr<etiss::LibraryInterface> libInterface)
{
    etiss::LibraryInterface *lif = libInterface.get();
 
    if (lif == 0)
    {
        return;
    }
 
    etiss::forceInitialization();
 
    {
        std::lock_guard<std::recursive_mutex> lock(etiss_libraries_mu_);
        etiss_libraries_.push_back(libInterface);
    }
    // if no default jit is present, try to use one from this library
    for (unsigned i = 0; (etiss_defaultjit_.size() <= 0) && (i < libInterface->countJITs()); i++)
    {
        etiss_defaultjit_ = libInterface->nameJIT(i);
    }
}
std::set<std::string> etiss::listLibraries()
{
    std::lock_guard<std::recursive_mutex> lock(etiss_libraries_mu_);
    std::set<std::string> ret;
    for (auto iter = etiss_libraries_.begin(); iter != etiss_libraries_.end(); iter++)
    {
        ret.insert((*iter)->getName() + "[" + (*iter)->versionInfo() + "]");
    }
    return ret;
}
 
std::set<std::string> etiss::listLibraryPrefixes()
{
    std::lock_guard<std::recursive_mutex> lock(etiss_libraries_mu_);
    std::set<std::string> ret;
    for (auto iter = etiss_libraries_.begin(); iter != etiss_libraries_.end(); iter++)
    {
        ret.insert((*iter)->getName());
    }
    return ret;
}
 
std::shared_ptr<etiss::JIT> etiss::getDefaultJIT()
{
    return getJIT(etiss_defaultjit_);
}
 
// transfer controll to etiss console on SIGINT
void (*etiss_prev_SIGINT_handler)(int) = 0;
bool etiss_SIGINT_handler_enabled = false;
 
void etiss_SIGINT_handler(int sig)
{
    if (sig == SIGINT)
    {
        std::cout << std::endl << "\033[0;31m" << std::endl;
        std::cout << std::endl << "\033[0m" << std::endl;
    }
    else
    { // false handler assignment
        signal(sig, SIG_DFL);
        raise(sig);
        return;
    }
}
 
//__attribute__((destructor))
static void etiss_remove_SIGINT()
{
    if (etiss_SIGINT_handler_enabled)
    {
        etiss_prev_SIGINT_handler = signal(SIGINT, etiss_prev_SIGINT_handler);
        etiss_SIGINT_handler_enabled = false;
    }
}
static class helper_class_etiss_2
{
  public:
    ~helper_class_etiss_2() { etiss_remove_SIGINT(); }
} helper_class_etiss_2;
 
// initialize
CSimpleIniA *po_simpleIni;
void etiss_loadIni(std::string fileName)
{
    if (po_simpleIni == NULL)
        po_simpleIni = new CSimpleIniA(true, true, true);
 
    SI_Error rc = po_simpleIni->LoadFile(fileName.c_str());
    if (rc < 0)
        std::cout << "Initializer::loadIni(): Failed to load Ini: " << fileName << std::endl;
    else
        std::cout << "Initializer::loadIni(): Ini sucessfully loaded " << fileName << std::endl;
}
 
void etiss::Initializer::loadIni(std::list<std::string> *files)
{
    std::cout << "  Load ini file." << std::endl;
    // create ini parser
    if (po_simpleIni == NULL)
        po_simpleIni = new CSimpleIniA(true, true, true);
    else
        std::cout << "Info: simpleIni already exists!" << std::endl;
 
    // load file
    for (auto it_files : *files)
    {
        // the check above is sufficient no need for this / checked for previous cases false and last true gives true
        // not the case based on files structure
        etiss_loadIni(it_files);
    }
}
 
void etiss_loadIniConfigs()
{
    if (!po_simpleIni) // no .ini files were given.
    {
        return;
    }
    std::cout << "  Load Configs from .ini files:" << std::endl;
 
    // preload loglevel
    if (!etiss::cfg().isSet("etiss.loglevel"))
    {
        etiss::cfg().set<int>("etiss.loglevel",
                              po_simpleIni->GetLongValue("IntConfigurations", "etiss.loglevel", etiss::WARNING));
    }
    {
        int ll = cfg().get<int>("etiss.loglevel", etiss::WARNING);
        if (ll >= 0 && ll <= etiss::VERBOSE)
        { // valid log level
          // dnm
            // etiss::verbosity() = etiss::VERBOSE;
            etiss::verbosity() = (Verbosity)ll;
            etiss::log(etiss::VERBOSE, "Log level set to VERBOSE");
        }
        else
        {
            etiss::verbosity() = etiss::WARNING;
            etiss::log(etiss::ERROR, "Specified log level is not valid. must range between 0 (= "
                                     "silent) and 5 (= verbose)");
        }
    }
 
    // get all sections
    CSimpleIniA::TNamesDepend sections;
    po_simpleIni->GetAllSections(sections);
    for (auto iter_section : sections)
    {
        // only load config sections
        if (std::string(iter_section.pItem) != "StringConfigurations" &&
            std::string(iter_section.pItem) != "BoolConfigurations" &&
            std::string(iter_section.pItem) != "IntConfigurations")
        {
            continue;
        }
        etiss::log(etiss::INFO, std::string("  [") + iter_section.pItem + ']');
 
        // get all keys in a section
        CSimpleIniA::TNamesDepend keys;
        po_simpleIni->GetAllKeys(iter_section.pItem, keys);
        for (auto iter_key : keys)
        {
            std::stringstream message;
            bool warning = false;
 
            // skip loglevel
            if (std::string(iter_key.pItem) == "etiss.loglevel")
                continue;
 
            // check if cfg is already set
            if (etiss::cfg().isSet(iter_key.pItem))
            {
                message << "    cfg already set on command line. ";
                message << "    " << iter_key.pItem << "=";
                const ::std::type_info &type = vm[std::string(iter_key.pItem)].value().type();
                if (type == typeid(::std::string))
                    message << vm[std::string(iter_key.pItem)].as<std::string>() << ",";
                else if (type == typeid(int))
                    message << vm[std::string(iter_key.pItem)].as<int>() << ",";
                else if (type == typeid(bool))
                    message << std::boolalpha << vm[std::string(iter_key.pItem)].as<bool>() << ",";
                warning = true;
            }
            else
            {
                // write key (=option) to message.
                message << "    " << iter_key.pItem << "=";
 
                // get all values of a key with multiple values
                CSimpleIniA::TNamesDepend values;
                po_simpleIni->GetAllValues(iter_section.pItem, iter_key.pItem, values);
                for (auto iter_value : values)
                {
                    // Handle configurations
                    if (std::string(iter_section.pItem) == "StringConfigurations")
                    {
                        etiss::cfg().set<std::string>(iter_key.pItem, iter_value.pItem);
                    }
                    else if (std::string(iter_section.pItem) == "BoolConfigurations")
                    {
                        std::string itemval = iter_value.pItem;
                        boost::algorithm::to_lower(itemval); // converts itemval to lower case string
 
                        if ((itemval == "true") || (itemval == "yes") || (itemval == "1") || (itemval == "t"))
                        {
                            etiss::cfg().set<bool>(iter_key.pItem, true);
                        }
                        else if ((itemval == "false") || (itemval == "no") || (itemval == "0") || (itemval == "f"))
                        {
                            etiss::cfg().set<bool>(iter_key.pItem, false);
                        }
                        else
                            etiss::log(etiss::FATALERROR, std::string("Configuration value ") + iter_key.pItem +
                                                              " could not be parsed as boolean");
                    }
                    else if (std::string(iter_section.pItem) == "IntConfigurations") // already load!
                    {
                        std::string itemval = iter_value.pItem;
                        std::size_t sz = 0;
                        long long val;
                        try
                        {
                            val = std::stoll(itemval, &sz, 0);
                        }
                        // catch invalid_argument exception.
                        catch (std::invalid_argument const &)
                        {
                            etiss::log(etiss::FATALERROR, std::string("Configuration value ") + iter_key.pItem +
                                                              " could not be parsed as integer");
                        }
                        etiss::cfg().set<long long>(iter_key.pItem, val);
                        // we use double, as long could have only 32 Bit (e.g. on Windows)
                        // and long long is not offered by the ini library
                    }
                    else
                    // we don't add a DoubleConfigurations section, as converting them
                    // to and from strings could provoke accuracy issues.
                    // To support double, a Configuration::get<double>() has to be
                    // added to Misc.cpp
                    {
                        message << "   Section not found  for Value:";
                        warning = true;
                    }
 
                    // write item (=option value) to message.
                    message << iter_value.pItem << ",";
                }
 
                // check if more than one value is set in the ini file
                if (values.size() > 1)
                {
                    warning = true;
                    message << "   Multi values. Take only LAST one!";
                }
            }
            // add message to etiss log.
            etiss::log(warning ? etiss::WARNING : etiss::INFO, message.str());
        }
    }
}
 
void etiss::Initializer::loadIniPlugins(std::shared_ptr<etiss::CPUCore> cpu)
{
    std::map<std::string, std::string> options;
    for (auto iter = pluginOptions.begin(); iter != pluginOptions.end(); iter++)
    {
        if (etiss::cfg().isSet(*iter))
        {
            options[*iter] = std::string(vm[std::string(*iter)].as<std::string>());
            etiss::log(etiss::INFO, *iter + " written from command line\n" + "               options[" +
                                        std::string(*iter) +
                                        "] = " + std::string(vm[std::string(*iter)].as<std::string>()) + "\n");
        }
    }
    if (vm.count("pluginToLoad"))
    {
        const std::vector<std::string> pluginList = vm["pluginToLoad"].as<std::vector<std::string>>();
        for (auto pluginName = pluginList.begin(); pluginName != pluginList.end(); pluginName++)
        {
            std::string::size_type pos = std::string(*pluginName).length();
            bool pluginAlreadyPresent = false;
            for (auto iter : *cpu->getPlugins())
            {
                std::string pluginNamecpu = iter->getPluginName();
                if (pos != std::string::npos)
                {
                    pluginNamecpu = pluginNamecpu.substr(0, pos);
                }
                if (pluginNamecpu == *pluginName)
                {
                    pluginAlreadyPresent = true;
                    break;
                }
            }
            if (pluginAlreadyPresent)
            {
                etiss::log(etiss::WARNING, "    Warning: Plugin already present. Skipping it: " + *pluginName + "\n");
                continue;
            }
            etiss::log(etiss::INFO, "  Adding Plugin " + *pluginName + "\n");
            std::shared_ptr<Plugin> plugin = etiss::getPlugin(*pluginName, options);
            if (!plugin)
                etiss::log(etiss::FATALERROR, "Plugin not found: " + *pluginName + "\n");
            cpu->addPlugin(plugin);
        }
    }
    if (!po_simpleIni)
    {
        etiss::log(etiss::WARNING, "Ini file not loaded. Can't load plugins from simpleIni!");
        return;
    }
    // get all sections
    CSimpleIniA::TNamesDepend sections;
    po_simpleIni->GetAllSections(sections);
    for (auto iter_section : sections)
    {
        // only load Plugin sections
        if (std::string(iter_section.pItem).substr(0, 6) != std::string("Plugin"))
            continue;
        std::string pluginName = std::string(iter_section.pItem).substr(7);
        std::string::size_type pos = pluginName.length();
        // check if Plugin is already present
        bool pluginAlreadyPresent = false;
        for (auto iter : *cpu->getPlugins())
        {
            std::string pluginNamecpu = iter->getPluginName();
            if (pos != std::string::npos)
            {
                pluginNamecpu = pluginNamecpu.substr(0, pos);
            }
            if (pluginNamecpu == pluginName)
            {
                pluginAlreadyPresent = true;
                break;
            }
        }
        if (pluginAlreadyPresent)
        {
            etiss::log(etiss::WARNING, "    Warning: Plugin already present. Skipping it: " + pluginName + "\n");
            continue;
        }
 
        etiss::log(etiss::INFO, "  Adding Plugin " + pluginName + "\n");
 
        // get all keys in a section = plugin option
        CSimpleIniA::TNamesDepend keys;
        po_simpleIni->GetAllKeys(iter_section.pItem, keys);
        for (auto iter_key : keys)
        {
            // get all values of a key with multiple values = value of option
            CSimpleIniA::TNamesDepend values;
            po_simpleIni->GetAllValues(iter_section.pItem, iter_key.pItem, values);
            if (!etiss::cfg().isSet(iter_key.pItem))
            {
                std::stringstream ss;
                ss << iter_key.pItem << " not set on the command line. Checking in .ini file.";
                etiss::log(etiss::INFO, ss.str());
 
                for (auto iter_value : values)
                {
                    options[iter_key.pItem] = iter_value.pItem;
                    etiss::log(etiss::INFO, "    options[" + std::string(iter_key.pItem) +
                                                "] = " + std::string(iter_value.pItem) + "\n\n");
                }
                // check if more than one value is set in the ini file
                if (values.size() > 1)
                    etiss::log(etiss::WARNING, "Multiple values for option. Took only last one!");
            }
        }
        std::shared_ptr<Plugin> plugin = etiss::getPlugin(pluginName, options);
        if (!plugin)
            etiss::log(etiss::FATALERROR, "Plugin not found: " + pluginName + "\n");
        cpu->addPlugin(plugin);
    }
}
 
void etiss::Initializer::loadIniJIT(std::shared_ptr<etiss::CPUCore> cpu)
{
    // check if JIT is set
    if (!etiss::cfg().isSet("jit.type"))
    {
        etiss::log(etiss::INFO, "No JIT configured. Will use default JIT. \n");
        cpu->set(etiss::getDefaultJIT());
        return;
    }
    if (cpu->getJITName() != "")
    {
        etiss::log(etiss::WARNING,
                   "etiss::Initializer::loadIniJIT:" + std::string(" JIT already present. Overwriting it."));
    }
    etiss::log(etiss::INFO, " Adding JIT \"" + cfg().get<std::string>("jit.type", "") + '\"');
    cpu->set(getJIT(cfg().get<std::string>("jit.type", "")));
}
 
void etiss_initialize(const std::vector<std::string> &args, bool forced = false)
{
    static std::mutex mu_;
    static bool initialized_(false);
    {
        std::lock_guard<std::mutex> lock(mu_);
        if (initialized_)
        {
            if (!forced)
            {
                etiss::log(etiss::WARNING, "Multiple calls to etiss::initialize");
            }
            else
            {
                return;
            }
        }
        else
        {
            if (forced)
            {
                etiss::log(etiss::WARNING, "etiss::initialize has not been called before using ETISS library "
                                           "functions. Please add the line \'etiss::initialize(argc,argv);\' "
                                           "at the beginning of \'int main(int argc, char**argv);\'");
            }
        }
        initialized_ = true;
    }
 
    {
        namespace po = boost::program_options;
        try
        {
            // clang-format off
            po::options_description desc("Allowed options");
            desc.add_options()
            ("help", "Produce a help message that lists all supported options.")
            ("ini,i", po::value<std::vector<std::string>>(), "INI file(s)")
            ("arch.cpu", po::value<std::string>(), "The CPU Architecture to simulate.")
            ("arch.or1k.ignore_sr_iee", po::value<bool>(), "Ignore exception on OpenRISC.")
            ("arch.or1k.if_stall_cycles", po::value<int>(), "Add instruction stall cycles on OpenRISC.")
            ("arch.cpu_cycle_time_ps", po::value<int>(), "Sets CPU cycles time on OpenRISC and ARM.")
            ("arch.enable_semihosting", po::value<bool>(), "Enables semihosting operations")
            ("etiss.enable_dmi", po::value<bool>(), "Enables the Direct Memory Interface feature of SystemC to speed up memory accesses. This needs to be disabled for memory tracing.")
            ("etiss.log_pc", po::value<bool>(), "Enables logging of the program counter.")
            ("etiss.max_block_size", po::value<int>(), "Sets maximum amount of instructions in a block.")
            ("etiss.output_path_prefix", po::value<std::string>(), "Path prefix to use when writing output files.")
            ("etiss.loglevel", po::value<int>(), "Verbosity of logging output.")
            ("etiss.log_to_stderr", po::value<bool>(), "Log to stderr instead of stdout.")
            ("jit.gcc.cleanup", po::value<bool>(), "Cleans up temporary files in GCCJIT. ")
            ("jit.gcc.opt_level", po::value<std::string>(), "GCCJIT optimization level (0/1/2/3/s/fast=default). ")
            ("jit.verify", po::value<bool>(), "Run some basic checks to verify the functionality of the JIT engine.")
            ("jit.debug", po::value<bool>(), "Causes the JIT Engines to compile in debug mode.")
            ("jit.type", po::value<std::string>(), "The JIT compiler to use.")
            ("jit.external_headers", po::value<std::string>(), "List of semicolon-separated paths to headers for the JIT to include.")
            ("jit.external_libs", po::value<std::string>(), "List of semicolon-separated library names for the JIT to link.")
            ("jit.external_header_paths", po::value<std::string>(), "List of semicolon-separated headers paths for the JIT.")
            ("jit.external_lib_paths", po::value<std::string>(), "List of semicolon-separated library paths for the JIT.")
            ("vp.sw_binary_ram", po::value<std::string>(), "Path to binary file to be loaded into RAM.")
            ("vp.sw_binary_rom", po::value<std::string>(), "Path to binary file to be loaded into ROM.")
            ("vp.elf_file", po::value<std::string>(), "Load ELF file.")
            ("vp.stats_file_path", po::value<std::string>(), "Path where the output json file gets stored after bare processor is run.")
            ("vp.quiet", po::value<std::string>(), "Disable logging of bare_etiss_processor.")
            ("faults.xml", po::value<std::string>(), "Path to faults XML file.")
            ("simple_mem_system.print_dbus_access", po::value<bool>(), "Traces accesses to the data bus.")
            ("simple_mem_system.print_ibus_access", po::value<bool>(), "Traces accesses to the instruction bus.")
            ("simple_mem_system.print_dbgbus_access", po::value<bool>(), "Traces accesses to the debug bus.")
            ("simple_mem_system.print_to_file", po::value<bool>(), "Write all tracing to a file instead of the terminal. The file will be located at etiss.output_path_prefix.")
            ("plugin.logger.logaddr", po::value<std::string>(), "Provides the compare address that is used to check for memory accesses that are redirected to the logger.")
            ("plugin.logger.logmask", po::value<std::string>(), "Provides the mask that is used to check for memory accesses that are redirected to the logger.")
            ("plugin.gdbserver.port", po::value<std::string>(), "Option for gdbserver")
            ("pluginToLoad,p", po::value<std::vector<std::string>>()->multitoken(), "List of plugins to be loaded.")
            ;
            // clang-format on
 
            po::command_line_parser parser{ args };
            po::command_line_parser iniparser{ args };
            parser.options(desc).allow_unregistered().extra_parser(etiss::Configuration::set_cmd_line_boost);
            po::parsed_options parsed_options = parser.run();
            po::store(parsed_options, vm);
 
            if (vm.count("help"))
            {
                std::cout << "\nPlease begin all options with --\n\n";
                std::cout << desc << "\n";
                etiss::log(etiss::FATALERROR,
                           std::string("Please choose the right configurations from the list and re-run.\n"));
            }
 
            if (vm.count("ini"))
            {
                auto files = vm["ini"].as<std::vector<std::string>>();
                for (auto const &f : files)
                {
                    etiss_loadIni(f);
                }
            }
 
            auto unregistered = po::collect_unrecognized(parsed_options.options, po::include_positional);
            for (auto iter_unreg : unregistered)
            {
                if (iter_unreg.find("-i") != 0 && iter_unreg.find("-p"))
                {
                    etiss::log(etiss::FATALERROR, std::string("Unrecognised option ") + iter_unreg +
                                                      "\n\t Please use --help to list all recognised options. \n");
                }
            }
 
            for (po::variables_map::iterator i = vm.begin(); i != vm.end(); ++i)
            {
                const po::variable_value &v = i->second;
                if (!v.empty())
                {
                    const ::std::type_info &type = v.value().type();
                    if (type == typeid(::std::string))
                    {
                        const ::std::string &val = v.as<::std::string>();
                        etiss::cfg().set<std::string>(std::string(i->first), val);
                    }
                    else if (type == typeid(int))
                    {
                        int val = v.as<int>();
                        etiss::cfg().set<int>(std::string(i->first), val);
                    }
                    else if (type == typeid(bool))
                    {
                        bool val = v.as<bool>();
                        etiss::cfg().set<bool>(std::string(i->first), val);
                    }
                }
            }
        }
        catch (std::exception &e)
        {
            etiss::log(etiss::FATALERROR,
                       std::string(e.what()) + "\n\t Please use --help to list all recognised options. \n");
        }
    }
    etiss_loadIniConfigs();
 
    // log level
    {
        int ll = cfg().get<int>("etiss.loglevel", etiss::WARNING);
        if (ll >= 0 && ll <= etiss::VERBOSE)
        { // valid log level
          // dnm
            // etiss::verbosity() = etiss::VERBOSE;
            etiss::verbosity() = (Verbosity)ll;
            etiss::log(etiss::VERBOSE, "Log level set to VERBOSE");
        }
        else
        {
            etiss::verbosity() = etiss::WARNING;
            etiss::log(etiss::ERROR, "Specified log level is not valid. must range between 0 (= "
                                     "silent) and 5 (= verbose)");
        }
    }
    // log to strerr
    {
        bool log_to_stderr = cfg().get<bool>("etiss.log_to_stderr", false);
        etiss::log_to_stderr() = log_to_stderr;
        etiss::log(etiss::VERBOSE, "Logging to stderr");
    }
 
    etiss::py::init(); // init python
 
    etiss_remove_SIGINT();
    preloadLibraries();
 
    // load integrated library
    if (cfg().get<bool>("etiss.load_integrated_libraries", true))
    {
        etiss::addLibrary(LibraryInterface::openIntegratedLibrary());
    }
 
    // check if some required files can be found
    {
        std::string path = etiss::installDir();
        std::vector<std::string> requiredFiles;
 
        // required files
        requiredFiles.push_back(path + "/include/jit/etiss/jit/CPU.h");
 
        // check
        for (auto iter = requiredFiles.begin(); iter != requiredFiles.end(); iter++)
        {
            std::ifstream f(iter->c_str());
            if (!f)
            {
                etiss::log(etiss::WARNING,
                           std::string("Could not find file: ") + *iter + "\n" + "\t The installation seems broken");
            }
        }
    }
}
 
void etiss::initialize(std::vector<std::string> &args)
{
    etiss_initialize(args, false);
}
 
void etiss::forceInitialization()
{
    std::vector<std::string> args{};
    etiss_initialize(args, true);
}
 
//__attribute__((destructor))
static void etiss_shutdown()
{
    etiss::shutdown(); // TODO: verify with spec. assuming shared library close
                       // after __attribute__((destructor)) functions have been
                       // called
 
    // force close open libraries
    //{
    //  std::lock_guard<std::recursive_mutex> lock(etiss_libraries_mu_);
    //  etiss_libraries_.clear();
    //}
}
static class helper_class_etiss_1
{
  public:
    ~helper_class_etiss_1() { etiss_shutdown(); }
} helper_class_etiss_1;
 
bool etiss_shutdownOk = false;
 
void etiss::initialize_virtualstruct(std::shared_ptr<etiss::CPUCore> cpu_core)
{
    auto mount_successful = etiss::VirtualStruct::root()->mountStruct(cpu_core->getName(), cpu_core->getStruct());
    // check if it the core is already mounted.
    if (etiss::VirtualStruct::root()->findStruct(cpu_core->getName()))
    {
        mount_successful = true; // already mounted as a substruct to the root()
    }
 
    if (!mount_successful)
    {
        etiss::log(etiss::FATALERROR, std::string("Tried to mount ") + cpu_core->getName() +
                                          std::string("'s VirtualStruct, but failed: etiss::CPUCore not created!"));
    }
    else
    {
        etiss::log(etiss::VERBOSE, std::string("Mounted ") + cpu_core->getName() +
                                       std::string("'s VirtualStruct to root VirtualStruct"));
 
        // load fault files
        std::string faults = cfg().get<std::string>("faults.xml", "");
        if (!faults.empty())
        {
            std::list<std::string> ffs = etiss::split(faults, ';');
            for (const auto &ff : ffs)
            {
                auto stressor_successful = etiss::fault::Stressor::loadXML(ff, cpu_core->getID());
                if (!stressor_successful)
                {
                    etiss::log(etiss::FATALERROR, std::string("Failed to load requested faults.xml \'") + ff +
                                                      std::string("\' for ") + cpu_core->getName() + std::string("."));
                }
                else
                {
                    etiss::log(etiss::VERBOSE, std::string("Faults from \'") + ff + std::string("\' loaded for ") +
                                                   cpu_core->getName() + std::string("."));
                }
            }
 
            etiss::log(etiss::VERBOSE, std::string("Add InstructionAccurateCallback Plugin to ") + cpu_core->getName() +
                                           std::string(". Required for etiss::fault::Injector."));
            cpu_core->addPlugin(std::make_shared<etiss::plugin::InstructionAccurateCallback>());
        }
    }
}
 
void etiss::initialize_virtualstruct(std::shared_ptr<etiss::CPUCore> cpu_core,
                                     std::function<bool(const etiss::fault::Fault &, const etiss::fault::Action &,
                                                        std::string & /*errormsg*/)> const &fcustom_action)
{
    etiss::initialize_virtualstruct(cpu_core);
    cpu_core->getStruct()->applyCustomAction = fcustom_action;
}
 
void etiss::shutdown()
{
    if (etiss_shutdownOk) // only on shutdown
        return;
 
    etiss_shutdownOk = true;
 
    etiss::fault::Stressor::clear();
 
    // unload libraries
    {
        std::list<std::weak_ptr<LibraryInterface>> libraries_weak;
        {
            std::lock_guard<std::recursive_mutex> lock(etiss_libraries_mu_);
            for (auto iter = etiss_libraries_.begin(); iter != etiss_libraries_.end(); iter++)
            {
                libraries_weak.push_back(std::weak_ptr<LibraryInterface>(*iter));
            }
            etiss_libraries_.clear();
        }
        for (auto iter = libraries_weak.begin(); iter != libraries_weak.end(); iter++)
        {
            std::shared_ptr<LibraryInterface> li = iter->lock();
            if (li.get() != 0)
            {
                std::stringstream ss;
                ss << "Failed to unload library \"" << li.get()->getName() << "\": ";
                ss << li.use_count() - 1 << " references " << std::endl;
                etiss::log(etiss::ERROR, ss.str());
            }
        }
    }
 
    // check for existing cpu core instances
    {
        std::list<std::string> cores = CPUCore::list();
        if (cores.size() > 0)
        {
            for (auto iter = cores.begin(); iter != cores.end(); iter++)
            {
                etiss::log(etiss::ERROR, std::string("CPU core has not been deleted before "
                                                     "etiss::shutdown() call: ") +
                                             *iter);
            }
        }
    }
 
    etiss::py::shutdown();
}
 
//__attribute__((destructor))
static void etiss_check_shutdown()
{
    if (!etiss_shutdownOk)
    {
        etiss::log(etiss::ERROR, "To prevent segmentation faults it is neccessary to call "
                                 "\"etiss::shutdown();\" at the end of main and free any "
                                 "resource acquired through ETISS.");
    }
}
static class helper_class_etiss_3
{
  public:
    ~helper_class_etiss_3() { etiss_check_shutdown(); }
} helper_class_etiss_3;
 
etiss::Initializer::~Initializer()
{
    if (po_simpleIni)
        delete po_simpleIni;
    etiss::shutdown();
}
 
std::string etiss::errorMessage(etiss::int32 code, CPUArch *arch)
{
    if (code <= 0)
    { // global code
        const char *msg = etiss::RETURNCODE::getErrorMessages()[code];
        if (msg == 0)
            return std::string();
        return std::string(msg);
    }
    else
    { // cpu arch dependent code
        if (arch != 0)
        {
            std::string ret = arch->getName() + ": ";
            return ret;
        }
        else
        {
            return "Unknown CPU architecture dependent error code.";
        }
    }
}