InterruptVector.h

Go to the documentation of this file.

 
#ifndef ETISS_INCLUDE_INTERRUPTVECTOR_H_
#define ETISS_INCLUDE_INTERRUPTVECTOR_H_
 
#include "etiss/Misc.h"
#include "etiss/jit/types.h"
#include <list>
#include <mutex>
#include <set>
#include <vector>
 
namespace etiss
{
 
class InterruptVector
{
  public:
    virtual ~InterruptVector();
    virtual void setBit(unsigned bit, bool state) = 0;
    virtual bool getBit(unsigned bit) const = 0;
    virtual unsigned width() const = 0;
    virtual bool isActive() const;
    virtual void clear();
 
    bool consumed_by_interruptlistener_{ false };
};
class InterruptVector {…};
 
template <typename INT>
class MappedInterruptVector : public InterruptVector
{
  public:
    typedef typename std::vector<INT *> Vector;
    MappedInterruptVector(Vector vec, Vector mask) : vector_(vec), mask_(mask)
    {
        if (vector_.size() > mask.size())
        {
            vector_.resize(mask.size());
            etiss::log(etiss::ERROR, "MappedInterruptVector: the interrupt and mask vectors must have equal size.");
        }
        if (vector_.size() < mask.size())
        {
            mask.resize(vector_.size());
            etiss::log(etiss::ERROR, "MappedInterruptVector: the interrupt and mask vectors must have equal size.");
        }
    }
    MappedInterruptVector(Vector vec, Vector mask) : vector_(vec), mask_(mask) {…}
    virtual ~MappedInterruptVector() {}
    virtual void setBit(unsigned bit, bool state)
    {
        unsigned o = bit % (sizeof(INT) * 8);
        unsigned i = (bit - o) / (sizeof(INT) * 8);
        if (i < vector_.size())
        {
            INT mask = ((INT)1) << o;
            *vector_[i] = (*vector_[i] & ~mask) | (state ? mask : 0);
        }
        //                        std::cout << "etiss::InterruptVector::setBit called i=" << std::dec << i << "
        //                        vector[i]=" << std::hex << *vector_[i] << " mask[i]=" << *mask_[i] << std::dec <<
        //                        std::endl;
    }
    virtual void setBit(unsigned bit, bool state) {…}
    virtual bool getBit(unsigned bit) const
    {
        unsigned o = bit % (sizeof(INT) * 8);
        unsigned i = (bit - o) / (sizeof(INT) * 8);
        INT mask = ((INT)1) << o;
        if (i < vector_.size())
        {
            return ((*vector_[i] & mask) & (*mask_[i] & mask)) != 0;
        }
        return false;
    }
    virtual bool getBit(unsigned bit) const {…}
    virtual unsigned width() const { return (unsigned)vector_.size() * sizeof(INT); }
    virtual bool isActive() const
    {
        for (unsigned i = 0; i < vector_.size(); i++)
        {
            if (*vector_[i] & *mask_[i])
                return true;
        }
        return false;
    }
    virtual bool isActive() const {…}
    virtual void clear()
    {
        for (unsigned i = 0; i < vector_.size(); i++)
        {
            *vector_[i] = (INT)0;
        }
    }
    virtual void clear() {…}
 
  private:
    Vector vector_;
    Vector mask_;
};
class MappedInterruptVector : public InterruptVector {…};
 
} // namespace etiss
 
#endif