TraceSemantics.h

#ifndef ROSE_BinaryAnalysis_InstructionSemantics_TraceSemantics_H
#define ROSE_BinaryAnalysis_InstructionSemantics_TraceSemantics_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
 
#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics.h>
#include <Rose/Diagnostics.h>
 
namespace Rose {
namespace BinaryAnalysis {
namespace InstructionSemantics {
 
namespace TraceSemantics {
 
 
//                                      Semantic values
 
using SValue = void;
 
using SValuePtr = boost::shared_ptr<void>;
 
 
//                                      Register state
 
using RegisterState = void;
 
using RegisterStatePtr = boost::shared_ptr<void>;
 
 
//                                      Memory state
 
using MemoryState = void;
 
using MemoryStatePtr = boost::shared_ptr<void>;
 
 
//                                      RISC operators
 
using RiscOperatorsPtr = boost::shared_ptr<class RiscOperators>;
 
class RiscOperators: public BaseSemantics::RiscOperators {
public:
    using Super = BaseSemantics::RiscOperators;
 
    using Ptr = RiscOperatorsPtr;
 
private:
    BaseSemantics::RiscOperatorsPtr subdomain_;         // Domain to which all our RISC operators chain
    Sawyer::Message::Stream stream_;                    // stream to which output is emitted
    std::string indentation_;                           // string to print at start of each line
    bool showingSubdomain_ = true;                      // show subdomain name and address on each line of output?
    bool showingInstructionVa_ = true;                  // show instruction VA on each line of output?
    bool onlyInstructions_ = true;                      // trace only operations associated with an instruction.
 
    // Real constructors.
protected:
    // use the version that takes a subdomain instead of this c'tor
    explicit RiscOperators(const BaseSemantics::SValuePtr &protoval, const SmtSolverPtr &solver = SmtSolverPtr());
 
    // use the version that takes a subdomain instead of this c'tor.
    explicit RiscOperators(const BaseSemantics::StatePtr &state, const SmtSolverPtr &solver = SmtSolverPtr());
 
    explicit RiscOperators(const BaseSemantics::RiscOperatorsPtr &subdomain);
 
public:
    virtual ~RiscOperators();
 
    // Static allocating constructors.
public:
    static RiscOperatorsPtr instance(const BaseSemantics::SValuePtr &protoval, const SmtSolverPtr& = SmtSolverPtr());
 
    static RiscOperatorsPtr instance(const BaseSemantics::StatePtr&, const SmtSolverPtr& = SmtSolverPtr());
 
    static RiscOperatorsPtr instance(const BaseSemantics::RiscOperatorsPtr &subdomain);
 
    // Virtual constructors
public:
    virtual BaseSemantics::RiscOperatorsPtr create(const BaseSemantics::SValuePtr &protoval,
                                                   const SmtSolverPtr& = SmtSolverPtr()) const override;
 
    virtual BaseSemantics::RiscOperatorsPtr create(const BaseSemantics::StatePtr &state,
                                                   const SmtSolverPtr& = SmtSolverPtr()) const override;
 
    virtual BaseSemantics::RiscOperatorsPtr create(const BaseSemantics::RiscOperatorsPtr &subdomain);
 
    // Dynamic pointer casts
public:
    static RiscOperatorsPtr promote(const BaseSemantics::RiscOperatorsPtr&);
 
    // Methods first defined at this level of the class hierarchy
public:
    const BaseSemantics::RiscOperatorsPtr& subdomain() const;
    void subdomain(const BaseSemantics::RiscOperatorsPtr &subdomain);
    void checkSubdomain() const;
 
    Sawyer::Message::Stream& stream();
    void stream(Sawyer::Message::Stream&);
    const std::string& indentation() const;
    void indentation(const std::string&);
    bool showingSubdomain() const;
    void showingSubdomain(bool);
    bool showingInstructionVa() const;
    void showingInstructionVa(bool);
    bool onlyInstructions() const;
    void onlyInstructions(bool);
protected:
    void linePrefix();
    std::string toString(const BaseSemantics::SValuePtr&);
    std::string toString(SgAsmFloatType*);
    void check_equal_widths(const BaseSemantics::SValuePtr&, const BaseSemantics::SValuePtr&);
    const BaseSemantics::SValuePtr &check_width(const BaseSemantics::SValuePtr &a, size_t nbits,
                                                const std::string &what="result");
    std::string register_name(RegisterDescriptor);
 
    bool shouldPrint() const;
    bool shouldPrint(SgAsmInstruction*) const;
 
    void before(const std::string&);
    void before(const std::string&, RegisterDescriptor);
    void before(const std::string&, RegisterDescriptor, const BaseSemantics::SValuePtr&);
    void before(const std::string&, RegisterDescriptor, const BaseSemantics::SValuePtr&, const BaseSemantics::SValuePtr&);
    void before(const std::string&, RegisterDescriptor, const BaseSemantics::SValuePtr&, const BaseSemantics::SValuePtr&,
                size_t);
    void before(const std::string&, RegisterDescriptor, const BaseSemantics::SValuePtr&, const BaseSemantics::SValuePtr&,
                const BaseSemantics::SValuePtr&);
    void before(const std::string&, SgAsmInstruction*, bool showAddress);
    void before(const std::string&, size_t);
    void before(const std::string&, size_t, uint64_t);
    void before(const std::string&, const BaseSemantics::SValuePtr&);
    void before(const std::string&, const BaseSemantics::SValuePtr&, size_t);
    void before(const std::string&, const BaseSemantics::SValuePtr&, size_t, size_t);
    void before(const std::string&, const BaseSemantics::SValuePtr&, const BaseSemantics::SValuePtr&);
    void before(const std::string&, const BaseSemantics::SValuePtr&, const BaseSemantics::SValuePtr&,
                const BaseSemantics::SValuePtr&);
    void before(const std::string&, const BaseSemantics::SValuePtr&, SgAsmFloatType*);
    void before(const std::string&, const BaseSemantics::SValuePtr&, SgAsmFloatType*, const BaseSemantics::SValuePtr&);
    void before(const std::string&, const BaseSemantics::SValuePtr&, SgAsmFloatType*, SgAsmFloatType*);
    void before(const std::string&, const BaseSemantics::SValuePtr&, const BaseSemantics::SValuePtr&, SgAsmFloatType*);
 
    void after();
    void after(SgAsmInstruction*);
    const BaseSemantics::SValuePtr& after(const BaseSemantics::SValuePtr&);
    const BaseSemantics::SValuePtr& after(const BaseSemantics::SValuePtr&, const BaseSemantics::SValuePtr&);
    const BaseSemantics::SValuePtr& after(const BaseSemantics::SValuePtr&, IteStatus);
    void after(const BaseSemantics::Exception&);
    void after(const BaseSemantics::Exception&, SgAsmInstruction*);
    void after_exception();
    void after_exception(SgAsmInstruction*);
 
    // Methods we override from our super class
public:
    virtual BaseSemantics::SValuePtr protoval() const override;
    virtual void solver(const SmtSolverPtr&) override;
    virtual SmtSolverPtr solver() const override;
    virtual BaseSemantics::StatePtr currentState() const override;
    virtual void currentState(const BaseSemantics::StatePtr&) override;
    virtual void print(std::ostream&, BaseSemantics::Formatter&) const override;
    virtual size_t nInsns() const override;
    virtual void nInsns(size_t n) override;
    virtual SgAsmInstruction* currentInstruction() const override;
    virtual void currentInstruction(SgAsmInstruction*) override;
    virtual bool isNoopRead() const override;
    virtual void isNoopRead(bool) override;
    virtual void startInstruction(SgAsmInstruction*) override;
    virtual void finishInstruction(SgAsmInstruction*) override;
    virtual void comment(const std::string&) override;
 
    virtual BaseSemantics::SValuePtr undefined_(size_t nbits) override;
    virtual BaseSemantics::SValuePtr unspecified_(size_t nbits) override;
    virtual BaseSemantics::SValuePtr number_(size_t nbits, uint64_t value) override;
    virtual BaseSemantics::SValuePtr boolean_(bool value) override;
    virtual BaseSemantics::SValuePtr bottom_(size_t nbits) override;
 
    virtual BaseSemantics::SValuePtr filterCallTarget(const BaseSemantics::SValuePtr&) override;
    virtual BaseSemantics::SValuePtr filterReturnTarget(const BaseSemantics::SValuePtr&) override;
    virtual BaseSemantics::SValuePtr filterIndirectJumpTarget(const BaseSemantics::SValuePtr&) override;
    virtual void hlt() override;
    virtual void cpuid() override;
    virtual BaseSemantics::SValuePtr rdtsc() override;
 
    // The actual RISC operators. These are pure virtual in the base class
    virtual BaseSemantics::SValuePtr and_(const BaseSemantics::SValuePtr&, const BaseSemantics::SValuePtr&) override;
    virtual BaseSemantics::SValuePtr or_(const BaseSemantics::SValuePtr&, const BaseSemantics::SValuePtr&) override;
    virtual BaseSemantics::SValuePtr xor_(const BaseSemantics::SValuePtr&, const BaseSemantics::SValuePtr&) override;
    virtual BaseSemantics::SValuePtr invert(const BaseSemantics::SValuePtr&) override;
    virtual BaseSemantics::SValuePtr extract(const BaseSemantics::SValuePtr&, size_t begin_bit, size_t end_bit) override;
    virtual BaseSemantics::SValuePtr concat(const BaseSemantics::SValuePtr&, const BaseSemantics::SValuePtr&) override;
    virtual BaseSemantics::SValuePtr leastSignificantSetBit(const BaseSemantics::SValuePtr&) override;
    virtual BaseSemantics::SValuePtr mostSignificantSetBit(const BaseSemantics::SValuePtr&) override;
    virtual BaseSemantics::SValuePtr rotateLeft(const BaseSemantics::SValuePtr&, const BaseSemantics::SValuePtr&) override;
    virtual BaseSemantics::SValuePtr rotateRight(const BaseSemantics::SValuePtr&, const BaseSemantics::SValuePtr&) override;
    virtual BaseSemantics::SValuePtr shiftLeft(const BaseSemantics::SValuePtr&, const BaseSemantics::SValuePtr&) override;
    virtual BaseSemantics::SValuePtr shiftRight(const BaseSemantics::SValuePtr&, const BaseSemantics::SValuePtr&) override;
    virtual BaseSemantics::SValuePtr shiftRightArithmetic(const BaseSemantics::SValuePtr&,
                                                          const BaseSemantics::SValuePtr&) override;
    virtual BaseSemantics::SValuePtr equalToZero(const BaseSemantics::SValuePtr&) override;
    virtual BaseSemantics::SValuePtr iteWithStatus(const BaseSemantics::SValuePtr&, const BaseSemantics::SValuePtr&,
                                                   const BaseSemantics::SValuePtr&, IteStatus&) override;
    virtual BaseSemantics::SValuePtr unsignedExtend(const BaseSemantics::SValuePtr&, size_t nbits) override;
    virtual BaseSemantics::SValuePtr signExtend(const BaseSemantics::SValuePtr&, size_t nbits) override;
    virtual BaseSemantics::SValuePtr add(const BaseSemantics::SValuePtr&, const BaseSemantics::SValuePtr&) override;
    virtual BaseSemantics::SValuePtr addWithCarries(const BaseSemantics::SValuePtr&, const BaseSemantics::SValuePtr&,
                                                    const BaseSemantics::SValuePtr&,
                                                    BaseSemantics::SValuePtr&/*out*/) override;
    virtual BaseSemantics::SValuePtr negate(const BaseSemantics::SValuePtr&) override;
    virtual BaseSemantics::SValuePtr signedDivide(const BaseSemantics::SValuePtr&, const BaseSemantics::SValuePtr&) override;
    virtual BaseSemantics::SValuePtr signedModulo(const BaseSemantics::SValuePtr&, const BaseSemantics::SValuePtr&) override;
    virtual BaseSemantics::SValuePtr signedMultiply(const BaseSemantics::SValuePtr&,
                                                    const BaseSemantics::SValuePtr&) override;
    virtual BaseSemantics::SValuePtr unsignedDivide(const BaseSemantics::SValuePtr&,
                                                    const BaseSemantics::SValuePtr&) override;
    virtual BaseSemantics::SValuePtr unsignedModulo(const BaseSemantics::SValuePtr&,
                                                    const BaseSemantics::SValuePtr&) override;
    virtual BaseSemantics::SValuePtr unsignedMultiply(const BaseSemantics::SValuePtr&,
                                                      const BaseSemantics::SValuePtr&) override;
 
    virtual void interrupt(int majr, int minr) override;
 
    virtual BaseSemantics::SValuePtr fpFromInteger(const BaseSemantics::SValuePtr&, SgAsmFloatType*) override;
    virtual BaseSemantics::SValuePtr fpToInteger(const BaseSemantics::SValuePtr&, SgAsmFloatType*,
                                                 const BaseSemantics::SValuePtr&) override;
    virtual BaseSemantics::SValuePtr fpConvert(const BaseSemantics::SValuePtr&, SgAsmFloatType*, SgAsmFloatType*) override;
    virtual BaseSemantics::SValuePtr fpIsNan(const BaseSemantics::SValuePtr&, SgAsmFloatType*) override;
    virtual BaseSemantics::SValuePtr fpIsDenormalized(const BaseSemantics::SValuePtr&, SgAsmFloatType*) override;
    virtual BaseSemantics::SValuePtr fpIsZero(const BaseSemantics::SValuePtr&, SgAsmFloatType*) override;
    virtual BaseSemantics::SValuePtr fpIsInfinity(const BaseSemantics::SValuePtr&, SgAsmFloatType*) override;
    virtual BaseSemantics::SValuePtr fpSign(const BaseSemantics::SValuePtr&, SgAsmFloatType*) override;
    virtual BaseSemantics::SValuePtr fpEffectiveExponent(const BaseSemantics::SValuePtr&, SgAsmFloatType*) override;
    virtual BaseSemantics::SValuePtr fpAdd(const BaseSemantics::SValuePtr&, const BaseSemantics::SValuePtr&,
                                           SgAsmFloatType*) override;
    virtual BaseSemantics::SValuePtr fpSubtract(const BaseSemantics::SValuePtr&, const BaseSemantics::SValuePtr&,
                                                SgAsmFloatType*) override;
    virtual BaseSemantics::SValuePtr fpMultiply(const BaseSemantics::SValuePtr&, const BaseSemantics::SValuePtr&,
                                                SgAsmFloatType*) override;
    virtual BaseSemantics::SValuePtr fpDivide(const BaseSemantics::SValuePtr&, const BaseSemantics::SValuePtr&,
                                              SgAsmFloatType*) override;
    virtual BaseSemantics::SValuePtr fpSquareRoot(const BaseSemantics::SValuePtr&, SgAsmFloatType*) override;
    virtual BaseSemantics::SValuePtr fpRoundTowardZero(const BaseSemantics::SValuePtr&, SgAsmFloatType*) override;
    
    virtual BaseSemantics::SValuePtr readRegister(RegisterDescriptor,
                                                  const BaseSemantics::SValuePtr &dflt) override;
    virtual BaseSemantics::SValuePtr peekRegister(RegisterDescriptor,
                                                  const BaseSemantics::SValuePtr &dflt) override;
    virtual void writeRegister(RegisterDescriptor, const BaseSemantics::SValuePtr&) override;
    virtual BaseSemantics::SValuePtr readMemory(RegisterDescriptor segreg, const BaseSemantics::SValuePtr &addr,
                                                const BaseSemantics::SValuePtr &dflt,
                                                const BaseSemantics::SValuePtr &cond) override;
    virtual BaseSemantics::SValuePtr peekMemory(RegisterDescriptor segreg, const BaseSemantics::SValuePtr &addr,
                                                const BaseSemantics::SValuePtr &dflt) override;
    virtual void writeMemory(RegisterDescriptor segreg, const BaseSemantics::SValuePtr &addr,
                             const BaseSemantics::SValuePtr &data, const BaseSemantics::SValuePtr &cond) override;
};
 
} // namespace
} // namespace
} // namespace
} // namespace
 
#endif
#endif