CPUCore.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_CPUCORE_H_
#define ETISS_INCLUDE_CPUCORE_H_
 
#include "etiss/Misc.h"
#include "etiss/InterruptVector.h"
#include "etiss/VirtualStruct.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;
 
  protected:
    CPUCore(std::shared_ptr<etiss::CPUArch> arch, std::string const &name);
    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();
    };
 
  public:
    ~CPUCore();
    void reset(etiss::uint64 *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;
    }
 
    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 setBlockChainCount(unsigned bcc) { bcc_ = bcc; }
 
    etiss::int32 execute(ETISS_System &system);
 
    etiss::int32 execute(etiss::System &system);
 
    inline const std::string &getName() { return name_; }
 
    inline const int &getID() { return id_; }
 
    std::string getJITName();
 
    inline std::shared_ptr<etiss::JIT> getJIT() { return jit_; }
 
    inline const std::string &toString() const { return name_; }
 
    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_; 
};
 
} // namespace etiss
 
#endif