CodePart.h

Go to the documentation of this file.

 
#ifndef ETISS_INCLUDE_CODEPART_H_
#define ETISS_INCLUDE_CODEPART_H_
 
#include <string>
#include <set>
#include <list>
#include <vector>
#include <map>
#include <sstream>
#include <iostream>
 
#include "etiss/jit/types.h"
#include "etiss/Misc.h"
 
namespace etiss
{
 
class RegisterPart
{
  public:
    inline RegisterPart() : name(""), bits(0), regWidth(0) {}
    inline RegisterPart(const std::string &name, unsigned registerWidth, etiss::uintMax bits = (uintMax)((intMax)-1))
        : name(name), regWidth(registerWidth)
    {
        uintMax mask = 0;
        for (unsigned i = 0; i < regWidth; i++)
        {
            mask |= ((uintMax)1) << i;
        }
        this->bits = bits & mask;
    }
    inline RegisterPart(const std::string &name, unsigned registerWidth, etiss::uintMax bits = (uintMax)((intMax)-1)) {…}
    inline RegisterPart(const RegisterPart &cpy)
    {
        this->name = cpy.name;
        this->bits = cpy.bits;
        this->regWidth = cpy.regWidth;
    }
    inline RegisterPart(const RegisterPart &cpy) {…}
 
  public:
    inline bool matches(const RegisterPart &rp) const
    {
        if (this->name != rp.name)
            return false;
#if DEBUG
        if (this->regWidth != rp.regWidth && !(isEmpty() || rp.isEmpty()))
        {
            std::cout << "Serve Warning: RegisterPart definitions exist with same name (=same register) but different "
                         "register width values"
                      << std::endl;
            return false;
        }
#endif
        return this->bits == rp.bits;
    }
    inline bool matches(const RegisterPart &rp) const {…}
    inline bool contains(const RegisterPart &rp) const
    {
        if (this->name != rp.name)
            return false;
#if DEBUG
        if (this->regWidth != rp.regWidth && !(isEmpty() || rp.isEmpty()))
        {
            std::cout << "Serve Warning: RegisterPart definitions exist with same name (=same register) but different "
                         "register width values"
                      << std::endl;
            return false;
        }
#endif
        return (this->bits & rp.bits) == rp.bits; // this->bits has every bit of rp.bits
    }
    inline bool contains(const RegisterPart &rp) const {…}
    inline void applyShadow(const RegisterPart &rp) const
    {
        if (name == rp.name)
            bits = bits & (~rp.bits);
    }
    inline void applyShadow(const RegisterPart &rp) const {…}
    inline void merge(const RegisterPart &rp) const
    {
        if (name == rp.name)
            bits = bits | rp.bits;
    }
    inline void merge(const RegisterPart &rp) const {…}
    inline void intersect(const RegisterPart &rp) const
    {
        if (name == rp.name)
            bits = bits & rp.bits;
    }
    inline void intersect(const RegisterPart &rp) const {…}
    inline bool maskedBy(const RegisterPart &rp) const { return rp.contains(*this); }
    inline const std::string &getName() const { return name; }
    inline const etiss::uintMax &getAffectedBits() const { return bits; }
    inline const unsigned &getRegisterWidth() const { return regWidth; }
    inline bool isEmpty() const { return bits == 0 || name.length() == 0; }
    inline bool operator<(const RegisterPart &other) const
    {
        if (name < other.name)
            return true;
#if DEBUG
        if (regWidth < other.regWidth && !(isEmpty() || other.isEmpty()))
        {
            std::cout << "Serve Warning: RegisterPart definitions exist with same name (=same register) but different "
                         "register width values"
                      << std::endl;
            return true;
        }
#endif
        return bits < other.bits;
    }
    inline bool operator<(const RegisterPart &other) const {…}
    inline bool operator==(const RegisterPart &other) const { return matches(other); }
 
  private:
    std::string name;
    mutable etiss::uintMax bits;
    unsigned regWidth;
};
class RegisterPart {…};
 
class RegisterSet
{
    struct lex_compare
    {
        bool operator()(const RegisterPart &lhs, const RegisterPart &rhs) const
        {
            return lhs.getName() < rhs.getName();
        }
        bool operator()(const RegisterPart &lhs, const RegisterPart &rhs) const {…}
    };
    struct lex_compare {…};
 
  public:
    inline RegisterSet() {}
    inline RegisterSet(const RegisterSet &rs) { set_ = rs.set_; }
    inline void add(const RegisterPart &rp)
    {
        if (rp.isEmpty())
            return;
        std::set<RegisterPart, lex_compare>::iterator iter = set_.find(rp);
        if (iter != set_.end())
        {
            (*iter).merge(rp);
            if (iter->isEmpty())
            {
                set_.erase(iter);
            }
        }
        else
        {
            set_.insert(rp);
        }
    }
    inline void add(const RegisterPart &rp) {…}
    inline void add(const std::string &name, unsigned registerWidth, etiss::uintMax bits = (uintMax)((intMax)-1))
    {
        add(RegisterPart(name, registerWidth, bits));
    }
    inline void add(const std::string &name, unsigned registerWidth, etiss::uintMax bits = (uintMax)((intMax)-1)) {…}
    inline void applyShadow(const RegisterSet &rs)
    {
        std::set<RegisterPart, lex_compare>::iterator iter = set_.begin();
        std::set<RegisterPart, lex_compare>::const_iterator oiter;
        while (iter != set_.end())
        {
            oiter = rs.set_.find(*iter);
            if (oiter != rs.set_.end())
            {
                iter->applyShadow(*oiter);
                if (iter->isEmpty())
                {
                    set_.erase(iter++);
                }
                else
                {
                    iter++;
                }
            }
            else
            {
                iter++;
            }
        }
    }
    inline void applyShadow(const RegisterSet &rs) {…}
    inline void merge(const RegisterSet &rs)
    {
        std::set<RegisterPart, lex_compare>::const_iterator iter = rs.set_.begin();
        while (iter != rs.set_.end())
        {
            add(*iter);
            iter++;
        }
    }
    inline void merge(const RegisterSet &rs) {…}
    inline void intersect(const RegisterSet &rs)
    {
        std::set<RegisterPart, lex_compare>::iterator iter = set_.begin();
        while (iter != set_.end())
        {
            std::set<RegisterPart, lex_compare>::const_iterator f = rs.set_.find(*iter);
            if (f != rs.set_.end())
            {
                iter->intersect(*f);
                if (iter->isEmpty())
                {
                    set_.erase(iter++);
                }
                else
                {
                    iter++;
                }
            }
            else
            {
                set_.erase(iter++);
            }
        }
    }
    inline void intersect(const RegisterSet &rs) {…}
    inline bool disjoint(const RegisterSet &rs) const
    {
        std::set<RegisterPart, lex_compare>::const_iterator iter = set_.begin();
        while (iter != set_.end())
        {
            std::set<RegisterPart, lex_compare>::const_iterator f = rs.set_.find(*iter);
            if (f != rs.set_.end())
            {
                return false;
            }
            iter++;
        }
        return true;
    }
    inline bool disjoint(const RegisterSet &rs) const {…}
    inline bool maskedBy(const RegisterSet &rs) const
    {
        std::set<RegisterPart, lex_compare>::const_iterator iter = set_.begin();
        while (iter != set_.end())
        {
            std::set<RegisterPart, lex_compare>::const_iterator oiter = rs.set_.find(*iter);
            if (oiter != rs.set_.end())
            {
                if (!iter->maskedBy(*oiter))
                {
                    return false;
                }
            }
            else
            {
                return false;
            }
            iter++;
        }
        return true;
    }
    inline bool maskedBy(const RegisterSet &rs) const {…}
    inline bool isEmpty() { return set_.empty(); }
    inline void clear() { set_.clear(); }
    inline std::string _dbg_print() const
    {
        std::stringstream ss;
        std::set<RegisterPart, lex_compare>::const_iterator iter = set_.begin();
        while (iter != set_.end())
        {
            ss << iter->getName() << ": " << std::hex << iter->getAffectedBits() << "\n";
            iter++;
        }
        return ss.str();
    }
    inline std::string _dbg_print() const {…}
 
  private:
    std::set<RegisterPart, lex_compare> set_;
};
class RegisterSet {…};
 
class CodePart
{
  public:
    enum TYPE
    {
        PREINITIALDEBUGRETURNING,
        INITIALREQUIRED,
        OPTIONALMIDDLE,
        APPENDEDREQUIRED,
        APPENDEDOPTIONAL,
        APPENDEDRETURNINGREQUIRED
    };
    enum TYPE {…};
    inline CodePart() : flag_requireAll_(false) {}
    inline CodePart(const std::string &code, const RegisterSet &registerDependencies = RegisterSet(),
                    const RegisterSet &affectedRegisters = RegisterSet())
        : code_(code)
        , registerDependencies_(registerDependencies)
        , affectedRegisters_(affectedRegisters)
        , flag_requireAll_(false)
    {
    }
    inline CodePart(const std::string &code, const RegisterSet &registerDependencies = RegisterSet(), {…}
    inline RegisterSet &getRegisterDependencies() { return registerDependencies_; }
    inline RegisterSet &getAffectedRegisters() { return affectedRegisters_; }
    inline std::string &getCode() { return code_; }
    inline std::string &code() { return code_; }
    inline const std::string &code() const { return code_; }
    inline const RegisterSet &getRegisterDependencies() const { return registerDependencies_; }
    inline const RegisterSet &getAffectedRegisters() const { return affectedRegisters_; }
    inline const std::string &getCode() const { return code_; }
    inline const bool &fullRegistersDependency() const { return flag_requireAll_; }
 
  private:
    std::string code_;
    RegisterSet registerDependencies_;
    RegisterSet affectedRegisters_;
    bool flag_requireAll_;
};
class CodePart {…};
 
class Translation;
class CodeSet
{
 
  public:
    inline CodeSet() {}
    inline CodeSet(const CodeSet &cs)
    {
        pindbgretreq_parts_ = cs.pindbgretreq_parts_;
        inireq_parts_ = cs.inireq_parts_;
        midopt_parts_ = cs.midopt_parts_;
        appreq_parts_ = cs.appreq_parts_;
        appopt_parts_ = cs.appopt_parts_;
        appretreq_parts_ = cs.appretreq_parts_;
    }
    inline CodeSet(const CodeSet &cs) {…}
    inline void append(const CodePart &part, CodePart::TYPE type)
    {
        switch (type)
        {
        case CodePart::PREINITIALDEBUGRETURNING:
            pindbgretreq_parts_.push_front(part);
            break;
        case CodePart::INITIALREQUIRED:
            inireq_parts_.push_front(part);
            break;
        case CodePart::OPTIONALMIDDLE:
            midopt_parts_.push_front(part);
            break;
        case CodePart::APPENDEDREQUIRED:
            appreq_parts_.push_front(part);
            break;
        case CodePart::APPENDEDOPTIONAL:
            appopt_parts_.push_front(part);
            break;
        case CodePart::APPENDEDRETURNINGREQUIRED:
            appretreq_parts_.push_front(part);
            break;
        }
    }
    inline void append(const CodePart &part, CodePart::TYPE type) {…}
    inline CodePart &append(CodePart::TYPE type)
    {
        switch (type)
        {
        case CodePart::PREINITIALDEBUGRETURNING:
            pindbgretreq_parts_.emplace_front();
            return pindbgretreq_parts_.front();
        case CodePart::INITIALREQUIRED:
            inireq_parts_.emplace_front();
            return inireq_parts_.front();
        case CodePart::OPTIONALMIDDLE:
            midopt_parts_.emplace_front();
            return midopt_parts_.front();
        case CodePart::APPENDEDREQUIRED:
            appreq_parts_.emplace_front();
            return appreq_parts_.front();
        case CodePart::APPENDEDOPTIONAL:
            appopt_parts_.emplace_front();
            return appopt_parts_.front();
        case CodePart::APPENDEDRETURNINGREQUIRED:
            appretreq_parts_.emplace_front();
            return appretreq_parts_.front();
        default:
            std::cout << "ERROR: etiss::CodePart::append called with invalid etiss::CodePart::TYPE parameter"
                      << std::endl;
            appretreq_parts_.emplace_front();
            return appretreq_parts_.front();
        }
    }
    inline CodePart &append(CodePart::TYPE type) {…}
    inline CodePart &prepend(CodePart::TYPE type)
    {
        switch (type)
        {
        case CodePart::PREINITIALDEBUGRETURNING:
            pindbgretreq_parts_.emplace_back();
            return pindbgretreq_parts_.back();
        case CodePart::INITIALREQUIRED:
            inireq_parts_.emplace_back();
            return inireq_parts_.back();
        case CodePart::OPTIONALMIDDLE:
            midopt_parts_.emplace_back();
            return midopt_parts_.back();
        case CodePart::APPENDEDREQUIRED:
            appreq_parts_.emplace_back();
            return appreq_parts_.back();
        case CodePart::APPENDEDOPTIONAL:
            appopt_parts_.emplace_back();
            return appopt_parts_.back();
        case CodePart::APPENDEDRETURNINGREQUIRED:
            appretreq_parts_.emplace_back();
            return appretreq_parts_.back();
        default:
            std::cout << "ERROR: etiss::CodePart::prepend called with invalid etiss::CodePart::TYPE parameter"
                      << std::endl;
            appretreq_parts_.emplace_back();
            return appretreq_parts_.back();
        }
    }
    inline CodePart &prepend(CodePart::TYPE type) {…}
 
  private:
    static void writeCodeParts(std::string &code, const std::list<CodePart> &parts, bool required, RegisterSet &ignored,
                               bool intersect);
 
  public:
    std::string toString(RegisterSet &ignored, bool &ok) const;
 
  private:
    std::list<CodePart> pindbgretreq_parts_;
    std::list<CodePart> inireq_parts_;
    std::list<CodePart> midopt_parts_;
    std::list<CodePart> appreq_parts_;
    std::list<CodePart> appopt_parts_;
    std::list<CodePart> appretreq_parts_;
};
class CodeSet {…};
 
class CodeBlock
{
    friend class Translation;
 
  public:
    class Line
    {
        friend class CodeBlock;
 
      private:
      public:
        Line(const Line &line) : codeset_(line.codeset_), addr_(line.addr_) {}
        inline Line(etiss::uint64 addr) : addr_(addr) {}
        inline CodeSet &getCodeSet() { return codeset_; }
        inline const etiss::uint64 &getAddress() { return addr_; }
 
      private:
        CodeSet codeset_;
        bool ismeta_;
        etiss::uint64 addr_;
    };
    class Line {…};
 
  public:
    inline CodeBlock(etiss::uint64 startindex) : startindex_(startindex) {}
    inline void reserve(int num) { lines_.reserve(num); }
    inline Line &get(unsigned index) { return lines_[index]; }
    inline Line &append(etiss::uint64 addr)
    {
        lines_.push_back(Line(addr));
        return lines_.back();
    }
    inline Line &append(etiss::uint64 addr) {…}
    inline unsigned length() const { return (unsigned)lines_.size(); }
    inline std::set<std::string> &fileglobalCode() { return fileglobal_code; }
    inline std::set<std::string> &functionglobalCode() { return functionglobal_code; }
    void toCode(std::stringstream &out, const std::string &funcname, std::set<std::string> *fileglobalcode);
 
  private:
    std::vector<Line> lines_;
    etiss::uint64 startindex_;
    etiss::uint64 endaddress_;
    std::set<std::string> fileglobal_code;
    std::set<std::string> functionglobal_code;
};
class CodeBlock {…};
} // namespace etiss
#endif