StackDelta.h

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

#include <Rose/BinaryAnalysis/Disassembler/BasicTypes.h>
#include <Rose/BinaryAnalysis/Partitioner2/BasicTypes.h>
#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics.h>
#include <Sawyer/Map.h>

#include <boost/serialization/access.hpp>

namespace Rose {
namespace BinaryAnalysis {

// Forwards
namespace Partitioner2 {
    namespace DataFlow {
        class InterproceduralPredicate;
    }
}

namespace StackDelta {

// FIXME[Robb Matzke 2015-11-17]: add to Diagnostics.C and dummy functions.
void initDiagnostics();

extern Sawyer::Message::Facility mlog;

class Analysis {
public:
    typedef Sawyer::Container::Map<rose_addr_t, InstructionSemantics::BaseSemantics::SValuePtr> DeltasPerAddress;
    typedef std::pair<InstructionSemantics::BaseSemantics::SValuePtr,
                      InstructionSemantics::BaseSemantics::SValuePtr> SValuePair;
    typedef Sawyer::Container::Map<rose_addr_t, SValuePair> SValuePairPerAddress;

private:
    InstructionSemantics::BaseSemantics::DispatcherPtr cpu_;
    Sawyer::Optional<rose_addr_t> initialConcreteStackPointer_; // where to start

    bool hasResults_;                                   // Are the following data members initialized?
    bool didConverge_;                                  // Are the following data membeers valid (else only approximations)?

    SValuePair functionStackPtrs_;                      // Initial and final stack pointers
    InstructionSemantics::BaseSemantics::SValuePtr functionDelta_; // Stack delta for entire function
    
    SValuePairPerAddress bblockStackPtrs_;              // Per-basic block initial and final stack pointers
    DeltasPerAddress bblockDeltas_;                     // Stack delta per basic block (net effect of BB on stack ptr)

    SValuePairPerAddress insnStackPtrs_;                // Per-instruction initial and final stack pointers
    DeltasPerAddress insnDeltas_;                       // Stack delta per instruction (net effect of insn on stack ptr)

#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(cpu_);
        s & BOOST_SERIALIZATION_NVP(initialConcreteStackPointer_);
        s & BOOST_SERIALIZATION_NVP(hasResults_);
        s & BOOST_SERIALIZATION_NVP(didConverge_);
        s & BOOST_SERIALIZATION_NVP(functionStackPtrs_);
        s & BOOST_SERIALIZATION_NVP(functionDelta_);
        s & BOOST_SERIALIZATION_NVP(bblockStackPtrs_);
        s & BOOST_SERIALIZATION_NVP(bblockDeltas_);
        s & BOOST_SERIALIZATION_NVP(insnStackPtrs_);
        s & BOOST_SERIALIZATION_NVP(insnDeltas_);
    }
#endif
    
public:
    Analysis()
        : hasResults_(false), didConverge_(false) {}

    explicit Analysis(const Disassembler::BasePtr &d)
        : hasResults_(false), didConverge_(false) {
        init(d);
    }

    explicit Analysis(const InstructionSemantics::BaseSemantics::DispatcherPtr &cpu)
        : cpu_(cpu), hasResults_(false), didConverge_(false) {}

    Sawyer::Optional<rose_addr_t> initialConcreteStackPointer() const { return initialConcreteStackPointer_; }
    void initialConcreteStackPointer(const Sawyer::Optional<rose_addr_t> &val) { initialConcreteStackPointer_ = val; }
    void
    analyzeFunction(const Partitioner2::PartitionerConstPtr&, const Partitioner2::FunctionPtr&,
                    Partitioner2::DataFlow::InterproceduralPredicate&);

    bool hasResults() const { return hasResults_; }

    bool didConverge() const { return didConverge_; }

    void clearResults();

    void clearStackPointers();

    void clearStackDeltas();

    void clearNonResults();

    SValuePair functionStackPointers() const { return functionStackPtrs_; }

    InstructionSemantics::BaseSemantics::SValuePtr functionStackDelta() const { return functionDelta_; }

    int64_t functionStackDeltaConcrete() const;

    SValuePair basicBlockStackPointers(rose_addr_t basicBlockAddress) const;

    InstructionSemantics::BaseSemantics::SValuePtr basicBlockStackDelta(rose_addr_t basicBlockAddress) const;

    InstructionSemantics::BaseSemantics::SValuePtr basicBlockInputStackDeltaWrtFunction(rose_addr_t basicBlockAddress) const;
    InstructionSemantics::BaseSemantics::SValuePtr basicBlockOutputStackDeltaWrtFunction(rose_addr_t basicBlockAddress) const;
    int64_t basicBlockStackDeltaConcrete(rose_addr_t basicBlockAddress) const;

    SValuePair instructionStackPointers(SgAsmInstruction*) const;

    InstructionSemantics::BaseSemantics::SValuePtr instructionStackDelta(SgAsmInstruction*) const;

    InstructionSemantics::BaseSemantics::SValuePtr instructionInputStackDeltaWrtFunction(SgAsmInstruction*) const;
    InstructionSemantics::BaseSemantics::SValuePtr instructionOutputStackDeltaWrtFunction(SgAsmInstruction*) const;
    int64_t instructionStackDeltaConcrete(SgAsmInstruction*) const;

    void saveAnalysisResults(SgAsmFunction*) const;

    static void clearAstStackDeltas(SgNode*);

    InstructionSemantics::BaseSemantics::DispatcherPtr cpu() const { return cpu_; }

    static int64_t toInt(const InstructionSemantics::BaseSemantics::SValuePtr&);

    void print(std::ostream&) const;

public:
    // Used internally. Do not document with doxygen.
    void adjustInstruction(SgAsmInstruction*,
                           const InstructionSemantics::BaseSemantics::SValuePtr &spIn,
                           const InstructionSemantics::BaseSemantics::SValuePtr &spOut,
                           const InstructionSemantics::BaseSemantics::SValuePtr &delta);

private:
    void init(const Disassembler::BasePtr&);
};

std::ostream& operator<<(std::ostream&, const Analysis&);

} // namespace
} // namespace
} // namespace

#endif
#endif