Instruction.h

Go to the documentation of this file.

 
#ifndef ETISS_INCLUDE_INSTRUCTION_H_
#define ETISS_INCLUDE_INSTRUCTION_H_
 
#include "etiss/Misc.h"
 
#include "etiss/CodePart.h"
 
#include <climits>
#include <cstring>
#include <iomanip>
#include <sstream>
#include <stdexcept>
#include <string>
#include <boost/dynamic_bitset.hpp>
 
namespace etiss
{
 
namespace instr
{
 
typedef uint32_t I;
 
class Instruction;
class VariableInstructionSet;
class ModedInstructionSet;
class InstructionClass;
class InstructionGroup;
class InstructionDefinition;
 
class Buffer {
public:
    I* d_;
    unsigned intcount_;
public:
    Buffer(): d_(nullptr), intcount_(0) {}
    Buffer(const Buffer& o) : d_(new I[o.intcount_]), intcount_(o.intcount_){
        *this = o;
    }
    Buffer(const Buffer& o) : d_(new I[o.intcount_]), intcount_(o.intcount_) {…}
    Buffer(Buffer&& o) : d_(o.d_), intcount_(o.intcount_){
        o.d_ = nullptr;
    }
    Buffer(Buffer&& o) : d_(o.d_), intcount_(o.intcount_) {…}
    Buffer(unsigned intcount) : d_(new I[intcount]), intcount_(intcount) {
        for (unsigned i = 0; i < intcount_; i++) d_[i] = 0;
    }
    Buffer(unsigned intcount) : d_(new I[intcount]), intcount_(intcount) {…}
    Buffer(unsigned intcount, I val) : Buffer(intcount) {
        *d_ = val;
    }
    Buffer(unsigned intcount, I val) : Buffer(intcount) {…}
    ~Buffer() {
        clear();
    }
    ~Buffer() {…}
 
    Buffer& operator=(const Buffer& o){
        if (o.intcount_ != intcount_)
            throw std::runtime_error("operator= called with incompatible bit array");
        for (unsigned i = 0; i < intcount_; i++)
            d_[i] = o.d_[i];
        return *this;
    }
    Buffer& operator=(const Buffer& o) {…}
 
    Buffer& operator=(Buffer&& o){
        clear();
        intcount_ = o.intcount_;
        d_ = o.d_;
        o.d_ = nullptr;
        return *this;
    }
    Buffer& operator=(Buffer&& o) {…}
 
    void clear(){
        if(d_) delete[] d_;
    }
    void clear() {…}
    char *internalBuffer();
    unsigned internalBufferSize();
 
    I data(){return *d_;}
    void recoverFromEndianness(unsigned alignment, endian_t endianness);
};
class Buffer {…};
 
typedef std::set<Instruction*> Node;
 
class BitArray : public boost::dynamic_bitset<>
{
private:
    typedef boost::dynamic_bitset<> super;
public:
    using super::dynamic_bitset;
    BitArray(const super& a) : super(a){} // hack for parent's explicit constructors
 
    unsigned byteCount() const;
    unsigned intCount() const;
    void set_value(size_type width, unsigned long value);
    void set_value(unsigned long value);
    BitArray get_range(size_type end, size_type start) const;
    void set_range(unsigned long val, size_type end, size_type start);
    static std::vector<BitArray> permutate(const BitArray& input, std::vector<size_type> indexes);
    std::string to_string() const;
};
class BitArray : public boost::dynamic_bitset<> {…};
 
class BitArrayRange
{
public:
    etiss_del_como(BitArrayRange)
private:
    BitArray::size_type startpos;
    BitArray::size_type endpos;
public:
    BitArrayRange(unsigned endindex_included, unsigned startindex_included);
 
    I read(const BitArray& ba);
    void write(BitArray &ba, I val);
    BitArray::size_type start();
    BitArray::size_type end();
};
class BitArrayRange {…};
 
class OPCode
{
  public:
    const BitArray code_;
    const BitArray mask_;
    template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type>
    OPCode(unsigned width, const T code, const T mask) : code_(width, code & mask), mask_(width, mask)
    {
#if DEBUG
        if ((code & mask) != code)
        {
            etiss::log(etiss::WARNING, "etiss::instr::OPCode constructed with mismatched code and mask");
        }
        if (width != 16 && width != 32 && width != 64 && width != 128 && width != 256)
        {
            etiss::log(etiss::VERBOSE, std::string("OPCode with unusual width: ") + toString(width) +
                                           "[width must be given in bits and is usually 16,32,64,128,256 bits long]");
        }
#endif
    }
    OPCode(unsigned width, const T code, const T mask) : code_(width, code & mask), mask_(width, mask) {…}
 
    OPCode(const BitArray &code, const BitArray &mask);
 
    OPCode(const OPCode &cpy);
 
    bool operator<(const OPCode &o) const;
    inline bool operator==(const OPCode &o) const { return !((*this < o) || (o < *this)); }
    inline bool operator!=(const OPCode &o) const { return !((*this) == o); }
};
class OPCode {…};
 
struct less
{
    bool operator()(const OPCode *const &o1, const OPCode *const &o2) const;
};
struct less {…};
 
class InstructionContext
{
 
  public:
    etiss_del_como(InstructionContext)
 
        inline InstructionContext()
    {
    } 
 
    bool is_not_default_width_; 
    unsigned instr_width_;
    bool instr_width_fully_evaluated_; 
    bool force_append_next_instr_;     
    bool force_block_end_; 
    unsigned &ufield(std::string name);
    template <typename T>
    uint64_t &ufield(const T &plugin, std::string name)
    {
        return lufields_[&plugin][name];
    }
    uint64_t &ufield(const T &plugin, std::string name) {…}
    uint64_t current_address_;       
    uint64_t current_local_address_; 
 
  public:
    // common fields
    unsigned cf_delay_slot_;
 
  private:
    std::map<std::string, unsigned> ufields_; 
    std::map<void *, std::map<std::string, uint64_t>>
        lufields_; 
};
 
class Instruction : public etiss::ToString
{
  private:
    std::list<std::tuple<std::function<bool(BitArray &, etiss::CodeSet &, InstructionContext &)>, uint32_t,
                         std::set<uint32_t>>> callbacks_;
    uint32_t builtinGroups_;
    std::set<uint32_t> groups_;
    std::function<std::string(BitArray &, Instruction &)> printer_;
  public:
    etiss_del_como(Instruction)
 
        enum class BUILTINGROUP : uint32_t {
            CPUTIMEUPDATE = 1 << 0 
        };
 
    const BitArray::size_type width;
    const OPCode opc_;
    const std::string name_;
 
    static std::string printASMSimple(BitArray &ba, Instruction &instr);
 
    Instruction(const OPCode &opc, const std::string &name);
    template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type>
    Instruction(unsigned width, const T code, const T mask, const std::string &name)
        : builtinGroups_(0), printer_(printASMSimple), width(width), opc_(OPCode(width, code, mask)), name_(name)
    {
    }
    Instruction(unsigned width, const T code, const T mask, const std::string &name) {…}
    virtual std::string print(std::string indent, I pos, unsigned pfillwidth, bool printunused = false);
    bool addCallback(std::function<bool(BitArray &, etiss::CodeSet &, InstructionContext &)> callback,
                     uint32_t builtinGroups, const std::set<uint32_t> &groups = std::set<uint32_t>());
    bool translate(BitArray &, CodeSet &cs, InstructionContext &context);
    uint32_t &presentBuiltinGroups();
    std::set<uint32_t> &presentGroups();
    std::string printASM(BitArray &);
    void setASMPrinter(std::function<std::string(BitArray &, Instruction &)> printer);
    inline std::string toString() const { return name_; }
};
class Instruction : public etiss::ToString {…};
 
class InstructionSet : public etiss::ToString
{
  public:
    etiss_del_como(InstructionSet)
 
    VariableInstructionSet &parent_;
    const std::string name_;
    const unsigned width_;
    const unsigned chunk_size;
    InstructionSet(VariableInstructionSet &parent, unsigned width, const std::string &name, unsigned c_size=4);
    ~InstructionSet();
 
    Instruction *get(const OPCode &key);
    Instruction &open(const OPCode &key, const std::string &name);
    Instruction *create(const OPCode &key, const std::string &name);
 
    template <typename T>
    Instruction &open(T code, T val, const std::string &name)
    {
        return open(OPCode(width_, code, val), name);
    }
    Instruction &open(T code, T val, const std::string &name) {…}
 
    bool compile();
    bool compile(Node* node, BitArray code, Instruction* instr);
 
    Instruction *resolve(BitArray &instr);
    Instruction *resolve(Node* node, BitArray &instr);
 
    std::string print(std::string prefix, bool printunused = false);
 
    Instruction &getInvalid();
 
    void foreach (std::function<void(Instruction &)> func);
 
    size_t size();
 
    inline std::string toString() const { return name_; }
 
  private:
    std::map<const OPCode *, Instruction *, etiss::instr::less> instrmap_;
 
    Node** root_; // holds the entry of the bucket tree in decoding and compilition algorithm
 
    Instruction invalid;
};
class InstructionSet : public etiss::ToString {…};
 
class VariableInstructionSet
{
  private:
    std::map<unsigned, InstructionSet *> ismap_;
 
  public:
    ModedInstructionSet &parent_;
    unsigned width_;
    const std::string archname_;
    std::function<void(VariableInstructionSet &, InstructionContext &, BitArray &)> length_updater_;
 
  public:
    etiss_del_como(VariableInstructionSet)
 
        VariableInstructionSet(ModedInstructionSet &, unsigned width, const std::string &archname);
    ~VariableInstructionSet();
    bool compile();
 
    InstructionSet *get(unsigned width);
    InstructionSet *create(unsigned width, const std::string &name = std::string());
    InstructionSet &open(unsigned width, const std::string &name = std::string());
    inline InstructionSet *getMain() { return get(width_); }
    inline InstructionSet *createMain(const std::string &name = std::string()) { return create(width_); }
    inline InstructionSet &openMain(const std::string &name = std::string()) { return open(width_); }
 
    template <typename T>
    Instruction &open(unsigned bits, T code, T mask, const char *name)
    {
#if DEBUG
        unsigned bytes = bits >> 3;
        if (bytes * 8 != bits)
        {
            etiss_log(ERROR, "Invalid bit count");
            throw std::runtime_error();
        }
#endif
        return open(bits).open<T>(bits, code, mask, std::string(name));
    }
    Instruction &open(unsigned bits, T code, T mask, const char *name) {…}
 
    void foreach (std::function<void(InstructionSet &)> func);
 
    std::string print(std::string prefix = std::string());
};
class VariableInstructionSet {…};
 
class ModedInstructionSet
{
  private:
    std::map<uint32_t, std::string> modetostring_;
    std::map<std::string, uint32_t> stringtomode_;
    std::map<uint32_t, VariableInstructionSet *> vismap_;
    std::map<VariableInstructionSet *, uint32_t> invvismap_;
 
  public:
    const std::string archname_;
 
  public:
    etiss_del_como(ModedInstructionSet)
 
        ModedInstructionSet(const std::string &name);
    ~ModedInstructionSet();
 
    VariableInstructionSet *get(uint32_t mode);
    VariableInstructionSet *create(uint32_t mode, unsigned width, const std::string &name = std::string());
    VariableInstructionSet &open(uint32_t mode, unsigned width, const std::string &name = std::string());
 
    template <typename T>
    Instruction &open(uint32_t mode, unsigned width, unsigned bits, T code, T mask, const char *instrname)
    {
        return open(mode, width).open<T>(bits, code, mask, instrname);
    }
    Instruction &open(uint32_t mode, unsigned width, unsigned bits, T code, T mask, const char *instrname) {…}
 
    uint32_t getMode(VariableInstructionSet *vis);
    inline uint32_t getMode(VariableInstructionSet &vis) { return getMode(&vis); }
 
    void foreach (std::function<void(VariableInstructionSet &)> call);
 
    bool compile();
 
    std::string print(std::string prefix = std::string());
};
class ModedInstructionSet {…};
 
class InstructionCollection
{
  private:
    std::set<InstructionClass *> classes_;
    template <typename... T>
    void add(InstructionClass &klass, T &... args)
    {
        classes_.insert(&klass);
        add(args...);
    }
    void add(InstructionClass &klass, T &... args) {…}
    inline void add() {}
 
  public:
    etiss_del_como(InstructionCollection)
 
        const std::string name_; // e.g. ARMv6-M
    template <typename... T>
    inline InstructionCollection(const std::string &name, InstructionClass &class1, T &... otherclasses) : name_(name)
    {
        add(class1, otherclasses...);
    }
    inline InstructionCollection(const std::string &name, InstructionClass &class1, T &... otherclasses) : name_(name) {…}
    inline void foreach (std::function<void(InstructionClass &)> call)
    {
        for (auto iter = classes_.begin(); iter != classes_.end(); iter++)
        {
            call(**iter);
        }
    }
    inline void foreach (std::function<void(InstructionClass &)> call) {…}
    void addTo(ModedInstructionSet &set, bool &ok);
};
class InstructionCollection {…};
class InstructionClass
{
  private:
    std::set<InstructionGroup *> groups_;
    template <typename... T>
    void add(InstructionGroup &group, T &... args)
    {
        groups_.insert(&group);
        add(args...);
    }
    void add(InstructionGroup &group, T &... args) {…}
    inline void add() {}
 
  public:
    const unsigned mode_;    // e.g. 0 for ARM 1 for thumb
    const std::string name_; // e.g. ARM
    const unsigned width_;   // most common read width (fastest)
  public:
    etiss_del_como(InstructionClass)
 
        template <typename... T>
        InstructionClass(unsigned mode, const std::string &name, unsigned width, InstructionGroup &group1,
                         T &... othergroups)
        : mode_(mode), name_(name), width_(width)
    {
        add(group1, othergroups...);
    }
    inline void foreach (std::function<void(InstructionGroup &)> call)
    {
        for (auto iter = groups_.begin(); iter != groups_.end(); iter++)
        {
            call(**iter);
        }
    }
    inline void foreach (std::function<void(InstructionGroup &)> call) {…}
    void addTo(VariableInstructionSet &set, bool &ok);
};
class InstructionClass {…};
 
class InstructionGroup : public etiss::ToString
{
    friend class InstructionDefinition;
 
  private:
    std::set<InstructionDefinition *> defs_;
 
  public:
    const std::string name_; // e.g. thumb / thumb-2
    const unsigned width_;   // e.g. 16/32 bits
  public:
    etiss_del_como(InstructionGroup)
 
        inline InstructionGroup(const std::string &name, unsigned width)
        : name_(name), width_(width)
    {
    }
    etiss_del_como(InstructionGroup) {…}
    inline void foreach (std::function<void(InstructionDefinition &)> call)
    {
        for (auto iter = defs_.begin(); iter != defs_.end(); iter++)
        {
            call(**iter);
        }
    }
    inline void foreach (std::function<void(InstructionDefinition &)> call) {…}
    void addTo(InstructionSet &set, bool &ok);
    inline std::string toString() const { return name_; }
};
class InstructionGroup : public etiss::ToString {…};
 
class InstructionDefinition : public etiss::ToString
{
  public:
    InstructionGroup &group_;
    const std::string name_;
    const OPCode opc_;
    const std::function<bool(BitArray &, etiss::CodeSet &, InstructionContext &)> callback_;
    const std::function<std::string(BitArray &, Instruction &)> ASMprinter_;
    const uint32_t builtinGroups_;
 
  public:
    etiss_del_como(InstructionDefinition)
 
        template <typename T>
        InstructionDefinition(InstructionGroup &ig, const std::string &name, T code, T mask,
                              std::function<bool(BitArray &, etiss::CodeSet &, InstructionContext &)> callback,
                              uint32_t builtinGroups, std::function<std::string(BitArray &, Instruction &)> ASMprinter)
        : group_(ig)
        , name_(name)
        , opc_(ig.width_, code, mask)
        , callback_(callback)
        , ASMprinter_(ASMprinter)
        , builtinGroups_(builtinGroups)
    {
        if (!callback)
        {
            etiss_log(
                FATALERROR,
                (std::string(
                     "Instruction defined without a function callback: ") +
                 name));
            return;
        }
        group_.defs_.insert(this);
    }
        , builtinGroups_(builtinGroups) {…}
    inline ~InstructionDefinition()
    {
        // group_.defs_.erase(this); // removed since InstructionDefinition should not be deleted during execution
    }
    inline ~InstructionDefinition() {…}
    void addTo(Instruction &set, bool &ok);
    inline std::string toString() const { return group_.name_ + ":" + name_; }
};
class InstructionDefinition : public etiss::ToString {…};
 
#if __cplusplus >= 201103L
uint32_t operator"" _i32(const char *s);
#endif
 
uint32_t parse_i32(const char *s);
 
template <typename T_>
typename std::enable_if<std::is_integral<T_>::value, typename std::make_unsigned<T_>::type>::type parse_i(
    const char *s, bool *good = 0)
{
    if (good)
        *good = true;
    typedef typename std::make_unsigned<T_>::type U;
    unsigned shifted = 0;
    unsigned pos = 0;
    int mode = 0;
    U tmp = 0;
    U ret = 0;
    U mask = 0;
    do
    {
        switch (mode)
        {
        case 0:
            if (s[pos] >= '0' && s[pos] <= '9')
            {
                tmp = tmp * 10 + s[pos] - '0';
            }
            else if (s[pos] == 'x' || s[pos] == 'x')
            {
                mask = 0;
                ret = ret << tmp;
                shifted += tmp;
                for (unsigned i = 0; i < tmp; i++)
                    mask = (mask << 1) | 1;
                tmp = 0;
                mode = 1;
            }
            else if (s[pos] == ' ' || s[pos] == '\t')
            {
                // ignore spaces
                // TODO only ignore leading spaces
            }
            else
            {
                if (good)
                    *good = false;
                etiss::log(etiss::ERROR, std::string("Failed to parse literal ") + s);
                return (U)(T_)-1;
            }
            break;
        case 1:
            if (s[pos] >= '0' && s[pos] <= '9')
            {
                tmp = tmp * 16 + s[pos] - '0';
            }
            else if (s[pos] >= 'a' && s[pos] <= 'f')
            {
                tmp = tmp * 16 + s[pos] + 10 - 'a';
            }
            else if (s[pos] >= 'A' && s[pos] <= 'F')
            {
                tmp = tmp * 16 + s[pos] + 10 - 'A';
            }
            else if (s[pos] == ' ' || s[pos] == '\t' || s[pos] == 0)
            {
                // complain if hex is shorter than bit length?
                ret = ret | (tmp & mask);
                tmp = 0;
                mode = 0;
            }
            else
            {
                if (good)
                    *good = false;
                etiss::log(etiss::ERROR, std::string("Failed to parse literal ") + s);
                return (U)(T_)-1;
            }
        }
    } while (s[pos++] != 0);
 
    if (shifted != 32)
    {
        if (good)
            *good = false;
        etiss::log(etiss::ERROR, std::string("Failed to parse literal due to invalid length: ") + s);
        // return  (U)(T_)-1; return the parsed value anyway
    }
 
    return ret;
}
typename std::enable_if<std::is_integral<T_>::value, typename std::make_unsigned<T_>::type>::type parse_i( {…}
 
} // namespace instr
 
} // namespace etiss
#endif
    bool is_not_default_width_;  {…};
class InstructionContext {…};