CPUCore.h

Go to the documentation of this file.

 
#ifndef ETISS_INCLUDE_CPUCORE_H_
#define ETISS_INCLUDE_CPUCORE_H_
 
#include "etiss/ClassDefs.h"
#include "etiss/Misc.h"
#include "etiss/LibraryInterface.h"
#include "etiss/JIT.h"
#include "etiss/CPUArch.h"
#include "etiss/Translation.h"
#include "etiss/System.h"
#include "etiss/InterruptHandler.h"
#include "etiss/InterruptEnable.h"
#include "etiss/Plugin.h"
#include "etiss/jit/ReturnCode.h"
#include "etiss/mm/MMU.h"
#include "etiss/mm/DMMUWrapper.h"
#include "etiss/mm/PageFaultVector.h"
 
#include <mutex>
#include <memory>
#include <list>
 
namespace etiss
{
 
// change this to enable an approximate instruction counter for processors. the instruction counter can be accessed via
// the VirtualStruct of the processor. the field is named "instructionCounter"
#define ETISS_CPUCORE_DBG_APPROXIMATE_INSTRUCTION_COUNTER 0
 
class CPUCore : public VirtualStructSupport, public etiss::ToString
{
    friend class CPUArchRegListenerInterface;
    friend class InterruptVectorWrapper;
 
  private:
    CPUCore(std::shared_ptr<etiss::CPUArch> arch);
 
    class InterruptVectorWrapper : public InterruptVector
    {
      private:
        std::list<etiss::InterruptListenerPlugin *> plugins_;
 
      public:
        CPUCore &parent_;
        InterruptVectorWrapper(CPUCore &parent);
        virtual void setBit(unsigned bit, bool state);
        virtual bool getBit(unsigned bit) const;
        virtual unsigned width() const;
        virtual bool isActive() const;
        virtual void clear();
    };
    class InterruptVectorWrapper : public InterruptVector {…};
 
  public:
    ~CPUCore();
    inline void reset(etiss::uint64 *startindex) { arch_->resetCPU(cpu_, startindex); }
 
    inline ETISS_CPU *getState() { return cpu_; }
 
    virtual inline std::shared_ptr<VirtualStruct> getStruct() { return vcpu_; }
 
    virtual inline std::shared_ptr<etiss::mm::MMU> getMMU() { return mmu_; }
 
    inline etiss::InterruptVector *getInterruptVector() { return intwrapper_; }
 
    inline etiss::InterruptEnable *getInterruptEnable() { return intenable_; }
 
    inline std::shared_ptr<etiss::CPUArch> getArch() { return arch_; }
 
    inline void set(std::shared_ptr<etiss::JIT> jit) { jit_ = jit; }
 
    inline void setTimer(bool on)
    {
        std::lock_guard<std::mutex> lock(mu_);
        timer_enabled_ = on;
    }
    inline void setTimer(bool on) {…}
 
    void addPlugin(std::shared_ptr<etiss::Plugin> plugin);
 
    void removePlugin(std::shared_ptr<etiss::Plugin> plugin);
 
    inline void removePlugins()
    {
        std::lock_guard<std::mutex> lock(mu_);
        plugins.clear();
    }
    inline void removePlugins() {…}
 
    inline void setBlockChainCount(unsigned bcc) { bcc_ = bcc; }
 
    etiss::int32 execute(ETISS_System &system);
 
    inline etiss::int32 execute(etiss::System &system)
    {
        std::shared_ptr<ETISS_System> sys = etiss::wrap(&system);
        if (sys.get() == 0)
            return RETURNCODE::GENERALERROR;
        etiss::uint32 ret = execute(*(sys.get()));
        return ret;
    }
    inline etiss::int32 execute(etiss::System &system) {…}
 
    inline const std::string &getName() { return name_; }
 
    inline const int &getID() { return id_; }
 
    inline std::string getJITName()
    {
        std::shared_ptr<etiss::JIT> jit = jit_;
        if (jit.get())
        {
            return jit->getName();
        }
        else
        {
            return "";
        }
    }
    inline std::string getJITName() {…}
 
    inline std::shared_ptr<etiss::JIT> getJIT() { return jit_; }
 
    inline const std::string &toString() const { return name_; }
 
    inline std::shared_ptr<Plugin> getPlugin(std::string name)
    {
        for (auto iter : plugins)
        {
            // std::cout << "found plugin: " << iter->_getPluginName();
            if (iter->_getPluginName() == name)
                return iter;
        }
        return nullptr;
    };
    inline std::shared_ptr<Plugin> getPlugin(std::string name) {…}
    inline std::list<std::shared_ptr<Plugin>> const *getPlugins() { return &plugins; };
  public:
    static std::shared_ptr<CPUCore> create(
        std::string archname,
        std::string instancename = "", 
        std::map<std::string, std::string> archoptions = std::map<std::string, std::string>());
 
    static int getNextID();
 
    static std::list<std::string> list();
 
  private:
    std::shared_ptr<etiss::CPUArch> arch_; 
    std::string name_;                     
    const int id_;                         
    ETISS_CPU *cpu_;                       
    std::shared_ptr<etiss::VirtualStruct> vcpu_;
    etiss::InterruptVector *intvector_;  
    InterruptVectorWrapper *intwrapper_; 
    etiss::InterruptEnable *intenable_;
    bool timer_enabled_; 
    std::shared_ptr<etiss::JIT>
        jit_;       
    std::mutex mu_; 
    std::list<std::shared_ptr<Plugin>> plugins; 
    unsigned bcc_;
    unsigned blockCounter;
    unsigned exception_skip_count_;
    int blockCacheLimit_; 
    bool mmu_enabled_;
    std::shared_ptr<etiss::mm::MMU> mmu_;
 
  public:
    uint64_t instrcounter; 
 
  private:
    static std::mutex instances_mu_; 
    static std::list<std::weak_ptr<CPUCore>>
        instances_; 
};
class CPUCore : public VirtualStructSupport, public etiss::ToString {…};
 
} // namespace etiss
 
#endif