Plugin.h

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.
#ifndef ETISS_INCLUDE_PLUGIN_H_
#define ETISS_INCLUDE_PLUGIN_H_
 
#include <sstream>
#include <string>
 
#include "etiss/ClassDefs.h"
#include "etiss/jit/CPU.h"
#include "etiss/jit/System.h"
 
#include "etiss/CodePart.h"
 
namespace etiss
{
 
class Plugin : public etiss::ToString
{
    friend class InterruptListenerPlugin;
    friend class TranslationPlugin;
    friend class CoroutinePlugin;
    friend class SystemWrapperPlugin;
    friend class RegisterDevicePlugin;
    friend class CPUCore;
 
  protected:
    Plugin(unsigned type = 0);
 
  public:
    virtual ~Plugin();
 
  public:
    static const unsigned INTERRUPTLISTENER = 1 << 0; 
    static const unsigned COROUTINE = 1 << 1;         
    static const unsigned SYSTEMWRAPPER = 1 << 2;     
    static const unsigned REGISTERDEVICE =
        1 << 3; 
    static const unsigned TRANSLATION =
        1 << 4; 
  public:
    inline unsigned getType() { return type_; }
    inline InterruptListenerPlugin *getInterruptListenerPlugin() { return tplugin_; }
    inline CoroutinePlugin *getCoroutinePlugin() { return cplugin_; }
    inline SystemWrapperPlugin *getSystemWrapperPlugin() { return splugin_; }
    inline RegisterDevicePlugin *getRegisterDevicePlugin() { return rplugin_; }
 
    inline TranslationPlugin *getTranslationPlugin() { return trplugin_; }
    inline std::string getPluginName() const
    {
        if (name_.length() <= 0)
        {
            std::stringstream ss;
            bool fe = true;
            ss << _getPluginName();
            ss << "{";
            if (type_ & INTERRUPTLISTENER)
            {
                ss << (fe ? "" : ",") << "INTERRUPTLISTENER";
                fe = false;
            }
            if (type_ & COROUTINE)
            {
                ss << (fe ? "" : ",") << "COROUTINE";
                fe = false;
            }
            if (type_ & SYSTEMWRAPPER)
            {
                ss << (fe ? "" : ",") << "SYSTEMWRAPPER";
                fe = false;
            }
            if (type_ & REGISTERDEVICE)
            {
                ss << (fe ? "" : ",") << "REGISTERDEVICE";
                fe = false;
            }
            if (type_ & TRANSLATION)
            {
                ss << (fe ? "" : ",") << "TRANSLATION";
            }
            ss << "}";
            name_ = ss.str();
        }
        return name_;
    }
 
    const std::string &getLastAssignedCoreName() { return lastAssignedCoreName_; }
 
    inline std::string toString() const { return getPluginName(); }
 
  protected:
    virtual std::string _getPluginName() const = 0;
 
  protected:
    virtual void init(ETISS_CPU *cpu, ETISS_System *system, CPUArch *arch);
    virtual void cleanup();
    ETISS_CPU
    *plugin_cpu_; 
    ETISS_System *plugin_system_; 
    CPUArch
        *plugin_arch_; 
    CPUCore *plugin_core_; 
 
    void setCorrespondingCPUCoreName(std::string name) { lastAssignedCoreName_ = name; }
    virtual inline void addedToCPUCore(etiss::CPUCore *core) {}
    virtual inline void removedFromCPUCore(etiss::CPUCore *core) {}
 
  private:
    unsigned type_;
    mutable std::string name_; 
    InterruptListenerPlugin *tplugin_;
    SystemWrapperPlugin *splugin_;
    CoroutinePlugin *cplugin_;
    RegisterDevicePlugin *rplugin_;
    TranslationPlugin *trplugin_;
    std::string lastAssignedCoreName_;
};
 
class InterruptListenerPlugin : virtual public Plugin
{
  public:
    InterruptListenerPlugin();
    virtual ~InterruptListenerPlugin();
    virtual bool interruptWrite(unsigned bit, bool value) = 0;
};
 
class TranslationPlugin : virtual public Plugin
{
    friend class etiss::Translation;
 
  public:
    TranslationPlugin();
    virtual ~TranslationPlugin();
    virtual void initInstrSet(etiss::instr::ModedInstructionSet &) const;
    virtual void finalizeInstrSet(etiss::instr::ModedInstructionSet &) const;
    virtual void initCodeBlock(etiss::CodeBlock &) const;
    virtual void finalizeCodeBlock(etiss::CodeBlock &) const;
    virtual void *getPluginHandle();
 
  protected:
    std::string getPointerCode() const;
 
  private:
    std::string pointerCode;
};
 
class CoroutinePlugin : virtual public Plugin
{
  public:
    CoroutinePlugin();
    virtual ~CoroutinePlugin();
    virtual etiss::int32 execute() = 0;
    virtual void executionEnd(int32_t code);
    virtual bool isActive() { return true; }
};
 
class SystemWrapperPlugin : virtual public Plugin
{
  public:
    SystemWrapperPlugin();
    virtual ~SystemWrapperPlugin();
    virtual ETISS_System *wrap(ETISS_CPU *cpu, ETISS_System *system) = 0;
    virtual ETISS_System *unwrap(ETISS_CPU *cpu, ETISS_System *system) = 0;
};
 
class RegisterDevicePlugin : virtual public Plugin
{
  public:
    RegisterDevicePlugin();
    virtual ~RegisterDevicePlugin();
    virtual void changedRegister(const char *name) = 0;
};
 
} // namespace etiss
 
#endif