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();
    bool shouldPrint(SgAsmInstruction*);
 
    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:
    BaseSemantics::SValuePtr protoval() const override;
    void solver(const SmtSolverPtr&) override;
    SmtSolverPtr solver() const override;
    BaseSemantics::StatePtr currentState() const override;
    void currentState(const BaseSemantics::StatePtr&) override;
    void print(std::ostream&, BaseSemantics::Formatter&) const override;
    size_t nInsns() const override;
    void nInsns(size_t n) override;
    SgAsmInstruction* currentInstruction() const override;
    void currentInstruction(SgAsmInstruction*) override;
    bool isNoopRead() const override;
    void isNoopRead(bool) override;
    void startInstruction(SgAsmInstruction*) override;
    void finishInstruction(SgAsmInstruction*) override;
    void comment(const std::string&) override;
 
    BaseSemantics::SValuePtr undefined_(size_t nbits) override;
    BaseSemantics::SValuePtr unspecified_(size_t nbits) override;
    BaseSemantics::SValuePtr number_(size_t nbits, uint64_t value) override;
    BaseSemantics::SValuePtr boolean_(bool value) override;
    BaseSemantics::SValuePtr bottom_(size_t nbits) override;
 
    BaseSemantics::SValuePtr filterCallTarget(const BaseSemantics::SValuePtr&) override;
    BaseSemantics::SValuePtr filterReturnTarget(const BaseSemantics::SValuePtr&) override;
    BaseSemantics::SValuePtr filterIndirectJumpTarget(const BaseSemantics::SValuePtr&) override;
    void hlt() override;
    void cpuid() override;
    BaseSemantics::SValuePtr rdtsc() override;
 
    // The actual RISC operators. These are pure virtual in the base class
    BaseSemantics::SValuePtr and_(const BaseSemantics::SValuePtr&, const BaseSemantics::SValuePtr&) override;
    BaseSemantics::SValuePtr or_(const BaseSemantics::SValuePtr&, const BaseSemantics::SValuePtr&) override;
    BaseSemantics::SValuePtr xor_(const BaseSemantics::SValuePtr&, const BaseSemantics::SValuePtr&) override;
    BaseSemantics::SValuePtr invert(const BaseSemantics::SValuePtr&) override;
    BaseSemantics::SValuePtr extract(const BaseSemantics::SValuePtr&, size_t begin_bit, size_t end_bit) override;
    BaseSemantics::SValuePtr concat(const BaseSemantics::SValuePtr&, const BaseSemantics::SValuePtr&) override;
    BaseSemantics::SValuePtr leastSignificantSetBit(const BaseSemantics::SValuePtr&) override;
    BaseSemantics::SValuePtr mostSignificantSetBit(const BaseSemantics::SValuePtr&) override;
    BaseSemantics::SValuePtr rotateLeft(const BaseSemantics::SValuePtr&, const BaseSemantics::SValuePtr&) override;
    BaseSemantics::SValuePtr rotateRight(const BaseSemantics::SValuePtr&, const BaseSemantics::SValuePtr&) override;
    BaseSemantics::SValuePtr shiftLeft(const BaseSemantics::SValuePtr&, const BaseSemantics::SValuePtr&) override;
    BaseSemantics::SValuePtr shiftRight(const BaseSemantics::SValuePtr&, const BaseSemantics::SValuePtr&) override;
    BaseSemantics::SValuePtr shiftRightArithmetic(const BaseSemantics::SValuePtr&,
                                                  const BaseSemantics::SValuePtr&) override;
    BaseSemantics::SValuePtr equalToZero(const BaseSemantics::SValuePtr&) override;
    BaseSemantics::SValuePtr iteWithStatus(const BaseSemantics::SValuePtr&, const BaseSemantics::SValuePtr&,
                                           const BaseSemantics::SValuePtr&, IteStatus&) override;
    BaseSemantics::SValuePtr unsignedExtend(const BaseSemantics::SValuePtr&, size_t nbits) override;
    BaseSemantics::SValuePtr signExtend(const BaseSemantics::SValuePtr&, size_t nbits) override;
    BaseSemantics::SValuePtr add(const BaseSemantics::SValuePtr&, const BaseSemantics::SValuePtr&) override;
    BaseSemantics::SValuePtr addWithCarries(const BaseSemantics::SValuePtr&, const BaseSemantics::SValuePtr&,
                                            const BaseSemantics::SValuePtr&,
                                            BaseSemantics::SValuePtr&/*out*/) override;
    BaseSemantics::SValuePtr negate(const BaseSemantics::SValuePtr&) override;
    BaseSemantics::SValuePtr signedDivide(const BaseSemantics::SValuePtr&, const BaseSemantics::SValuePtr&) override;
    BaseSemantics::SValuePtr signedModulo(const BaseSemantics::SValuePtr&, const BaseSemantics::SValuePtr&) override;
    BaseSemantics::SValuePtr signedMultiply(const BaseSemantics::SValuePtr&,
                                            const BaseSemantics::SValuePtr&) override;
    BaseSemantics::SValuePtr unsignedDivide(const BaseSemantics::SValuePtr&,
                                            const BaseSemantics::SValuePtr&) override;
    BaseSemantics::SValuePtr unsignedModulo(const BaseSemantics::SValuePtr&,
                                            const BaseSemantics::SValuePtr&) override;
    BaseSemantics::SValuePtr unsignedMultiply(const BaseSemantics::SValuePtr&,
                                              const BaseSemantics::SValuePtr&) override;
 
    void interrupt(int majr, int minr) override;
 
    BaseSemantics::SValuePtr fpFromInteger(const BaseSemantics::SValuePtr&, SgAsmFloatType*) override;
    BaseSemantics::SValuePtr fpToInteger(const BaseSemantics::SValuePtr&, SgAsmFloatType*,
                                         const BaseSemantics::SValuePtr&) override;
    BaseSemantics::SValuePtr fpConvert(const BaseSemantics::SValuePtr&, SgAsmFloatType*, SgAsmFloatType*) override;
    BaseSemantics::SValuePtr fpIsNan(const BaseSemantics::SValuePtr&, SgAsmFloatType*) override;
    BaseSemantics::SValuePtr fpIsDenormalized(const BaseSemantics::SValuePtr&, SgAsmFloatType*) override;
    BaseSemantics::SValuePtr fpIsZero(const BaseSemantics::SValuePtr&, SgAsmFloatType*) override;
    BaseSemantics::SValuePtr fpIsInfinity(const BaseSemantics::SValuePtr&, SgAsmFloatType*) override;
    BaseSemantics::SValuePtr fpSign(const BaseSemantics::SValuePtr&, SgAsmFloatType*) override;
    BaseSemantics::SValuePtr fpEffectiveExponent(const BaseSemantics::SValuePtr&, SgAsmFloatType*) override;
    BaseSemantics::SValuePtr fpAdd(const BaseSemantics::SValuePtr&, const BaseSemantics::SValuePtr&,
                                   SgAsmFloatType*) override;
    BaseSemantics::SValuePtr fpSubtract(const BaseSemantics::SValuePtr&, const BaseSemantics::SValuePtr&,
                                        SgAsmFloatType*) override;
    BaseSemantics::SValuePtr fpMultiply(const BaseSemantics::SValuePtr&, const BaseSemantics::SValuePtr&,
                                        SgAsmFloatType*) override;
    BaseSemantics::SValuePtr fpDivide(const BaseSemantics::SValuePtr&, const BaseSemantics::SValuePtr&,
                                      SgAsmFloatType*) override;
    BaseSemantics::SValuePtr fpSquareRoot(const BaseSemantics::SValuePtr&, SgAsmFloatType*) override;
    BaseSemantics::SValuePtr fpRoundTowardZero(const BaseSemantics::SValuePtr&, SgAsmFloatType*) override;
    
    BaseSemantics::SValuePtr readRegister(RegisterDescriptor,
                                          const BaseSemantics::SValuePtr &dflt) override;
    BaseSemantics::SValuePtr peekRegister(RegisterDescriptor,
                                          const BaseSemantics::SValuePtr &dflt) override;
    void writeRegister(RegisterDescriptor, const BaseSemantics::SValuePtr&) override;
    BaseSemantics::SValuePtr readMemory(RegisterDescriptor segreg, const BaseSemantics::SValuePtr &addr,
                                        const BaseSemantics::SValuePtr &dflt,
                                        const BaseSemantics::SValuePtr &cond) override;
    BaseSemantics::SValuePtr peekMemory(RegisterDescriptor segreg, const BaseSemantics::SValuePtr &addr,
                                        const BaseSemantics::SValuePtr &dflt) override;
    void writeMemory(RegisterDescriptor segreg, const BaseSemantics::SValuePtr &addr,
                     const BaseSemantics::SValuePtr &data, const BaseSemantics::SValuePtr &cond) override;
 
    BaseSemantics::SValuePtr peekOperand(size_t depth = 0) override;
    BaseSemantics::SValuePtr popOperand() override;
    void pushOperand(const BaseSemantics::SValue::Ptr &a) override;
};
 
} // namespace
} // namespace
} // namespace
} // namespace
 
#endif
#endif