HotPatch.h

#ifndef ROSE_BinaryAnalysis_HotPatch_H
#define ROSE_BinaryAnalysis_HotPatch_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS

#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/SValue.h>
#include <Rose/BinaryAnalysis/HotPatch.h>
#include <Rose/BinaryAnalysis/SmtSolver.h>
#include <Sawyer/Message.h>

#include <boost/serialization/access.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/serialization/shared_ptr.hpp>

namespace Rose {
namespace BinaryAnalysis {

class HotPatch {
public:
    static Sawyer::Message::Facility mlog;

    class Record {
    public:
        enum Type {
            PATCH_REGISTER,                             
            PATCH_NONE                                  
        };

        enum Behavior {
            MATCH_CONTINUE,                             
            MATCH_BREAK                                 
        };

    private:
        Type type_;                                     // record type
        RegisterDescriptor register_;                   // register to be modified for PATCH_REGISTER types.
        InstructionSemantics::BaseSemantics::SValuePtr oldValue_; // value to match
        InstructionSemantics::BaseSemantics::SValuePtr newValue_; // replacement value
        Behavior behavior_;                             // whether to continue matching more records

#ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
    private:
        friend class boost::serialization::access;

        template<class S>
        void serialize(S &s, const unsigned /*version*/) {
            s & BOOST_SERIALIZATION_NVP(type_);
            s & BOOST_SERIALIZATION_NVP(register_);
            s & BOOST_SERIALIZATION_NVP(oldValue_);
            s & BOOST_SERIALIZATION_NVP(newValue_);
            s & BOOST_SERIALIZATION_NVP(behavior_);
        }
#endif

    public:
        Record()
            : type_(PATCH_NONE), behavior_(MATCH_CONTINUE) {}

        Record(RegisterDescriptor reg, const InstructionSemantics::BaseSemantics::SValuePtr &oldValue,
               const InstructionSemantics::BaseSemantics::SValuePtr &newValue, Behavior behavior = MATCH_CONTINUE)
            : type_(PATCH_REGISTER), register_(reg), oldValue_(oldValue), newValue_(newValue), behavior_(behavior) {
            ASSERT_not_null(newValue);
        }

        Type type() const {
            return type_;
        }

        RegisterDescriptor reg() const {
            return register_;
        }
        void reg(RegisterDescriptor r) {
            register_ = r;
        }
        InstructionSemantics::BaseSemantics::SValuePtr oldValue() const {
            return oldValue_;
        }
        void oldValue(const InstructionSemantics::BaseSemantics::SValuePtr &v) {
            oldValue_ = v;
        }
        InstructionSemantics::BaseSemantics::SValuePtr newValue() const {
            return newValue_;
        }
        void newValue(const InstructionSemantics::BaseSemantics::SValuePtr &v) {
            newValue_ = v;
        }
        Behavior behavior() const {
            return behavior_;
        }
        void behavior(Behavior b) {
            behavior_ = b;
        }
    };
    

    typedef std::vector<Record> Records;

private:
    Records records_;

    // Serialization
#ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
private:
    friend class boost::serialization::access;

    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        s & BOOST_SERIALIZATION_NVP(records_);
    }
#endif

public:
    const Records& records() const {
        return records_;
    }
    Records& records() {
        return records_;
    }
    size_t nRecords() const {
        return records_.size();
    }

    void clear() {
        records_.clear();
    }
    
    size_t append(const Record &record) {
        records_.push_back(record);
        return records_.size() - 1;
    }

    const Record& operator[](size_t idx) const {
        ASSERT_require(idx < records_.size());
        return records_[idx];
    }
    Record& operator[](size_t idx) {
        ASSERT_require(idx < records_.size());
        return records_[idx];
    }
    size_t apply(const InstructionSemantics::BaseSemantics::RiscOperatorsPtr&) const;
    size_t operator()(const InstructionSemantics::BaseSemantics::RiscOperatorsPtr &ops) const {
        return apply(ops);
    }
    static void initDiagnostics();
};


} // namespace
} // namespace

#endif
#endif