NoOperation.h

#ifndef ROSE_BinaryAnalysis_NoOperation_H
#define ROSE_BinaryAnalysis_NoOperation_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
 
#include <Rose/BinaryAnalysis/Disassembler/BasicTypes.h>
#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics.h>
#include <Sawyer/Message.h>
 
namespace Rose {
namespace BinaryAnalysis {
 
class NoOperation {
public:
    typedef Sawyer::Container::Interval<size_t> IndexInterval;
 
    typedef std::vector<IndexInterval> IndexIntervals;
 
    class StateNormalizer: public Sawyer::SharedObject {
    protected:
        size_t ignorePoppedMemory_;
        StateNormalizer(): ignorePoppedMemory_(8192) {}
    public:
        virtual ~StateNormalizer() {}
 
        typedef Sawyer::SharedPointer<StateNormalizer> Ptr;
 
        static Ptr instance() {
            return Ptr(new StateNormalizer);
        }
 
        size_t ignorePoppedMemory() const { return ignorePoppedMemory_; }
        void ignorePoppedMemory(size_t nbytes) { ignorePoppedMemory_ = nbytes; }
        virtual InstructionSemantics::BaseSemantics::StatePtr
        initialState(const InstructionSemantics::BaseSemantics::DispatcherPtr&, SgAsmInstruction *firstInsn);
 
        virtual std::string toString(const InstructionSemantics::BaseSemantics::DispatcherPtr&,
                                     const InstructionSemantics::BaseSemantics::StatePtr&);
    };
 
private:
    InstructionSemantics::BaseSemantics::DispatcherPtr cpu_;
    StateNormalizer::Ptr normalizer_;
    Sawyer::Optional<rose_addr_t> initialSp_;
    bool ignoreTerminalBranches_ = true;
 
public:
    static Sawyer::Message::Facility mlog;              
public:
    NoOperation();
 
    explicit NoOperation(const InstructionSemantics::BaseSemantics::DispatcherPtr &cpu)
        : cpu_(cpu), normalizer_(StateNormalizer::instance()) {}
 
    explicit NoOperation(const BinaryAnalysis::Disassembler::BasePtr&);
 
    StateNormalizer::Ptr stateNormalizer() const { return normalizer_; }
    void stateNormalizer(const StateNormalizer::Ptr &f) { normalizer_ = f; }
    const Sawyer::Optional<rose_addr_t> initialStackPointer() const { return initialSp_; }
    void initialStackPointer(const Sawyer::Optional<rose_addr_t> &v) { initialSp_ = v; }
    bool ignoreTerminalBranches() const { return ignoreTerminalBranches_; }
    void ignoreTerminalBranches(bool b) { ignoreTerminalBranches_ = b; }
    bool isNoop(SgAsmInstruction*) const;
 
    bool isNoop(const std::vector<SgAsmInstruction*>&) const;
 
    IndexIntervals findNoopSubsequences(const std::vector<SgAsmInstruction*>&) const;
 
    static IndexIntervals largestEarliestNonOverlapping(const IndexIntervals&);
 
    static std::vector<bool> toVector(const IndexIntervals&, size_t size=0);
 
    static void initDiagnostics();
 
protected:
    InstructionSemantics::BaseSemantics::StatePtr initialState(SgAsmInstruction *firstInsn) const;
    std::string normalizeState(const InstructionSemantics::BaseSemantics::StatePtr&) const;
};
 
} // namespace
} // namespace
 
#endif
#endif