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