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>
#include <boost/serialization/split_member.hpp>
 
namespace Rose {
namespace BinaryAnalysis {
 
// Forwards
namespace Partitioner2 {
    namespace DataFlow {
        class InterproceduralPredicate;
    }
}
 
namespace StackDelta {
 
void initDiagnostics();
 
extern Sawyer::Message::Facility mlog;
 
void initNamespace();
 
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
    SValuePairPerAddress insnFramePtrs_;                // Per-instruction initial and final frame pointers if known
    DeltasPerAddress insnSpDeltas_;                     // Stack delta per instruction (net effect of insn on stack ptr)
    bool hasConsistentFramePointer_ = false;            // Arch has FP register that's used as a frame pointer for this function
 
#ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serializeCommon(S &s, const unsigned version) {
        if (version < 1)
            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(insnSpDeltas_);
        if (version >= 2) {
            s & BOOST_SERIALIZATION_NVP(insnFramePtrs_);
            s & BOOST_SERIALIZATION_NVP(hasConsistentFramePointer_);
        }
    }
 
    template<class S>
    void save(S &s, const unsigned version) const {
        const_cast<Analysis*>(this)->serializeCommon(s, version);
        if (version >= 1) {
            std::string archName;
            InstructionSemantics::BaseSemantics::RiscOperators::Ptr ops;
            if (cpu_) {
                archName = Architecture::name(cpu_->architecture());
                ops = cpu_->operators();
            }
            s & BOOST_SERIALIZATION_NVP(archName);
            s & BOOST_SERIALIZATION_NVP(ops);
        }
    }
 
    template<class S>
    void load(S &s, const unsigned version) {
        serializeCommon(s, version);
        if (version >= 1) {
            std::string archName;
            InstructionSemantics::BaseSemantics::RiscOperators::Ptr ops;
            s & BOOST_SERIALIZATION_NVP(archName);
            s & BOOST_SERIALIZATION_NVP(ops);
            if (!archName.empty())
                cpu_ = Architecture::newInstructionDispatcher(archName, ops);
        }
    }
 
    BOOST_SERIALIZATION_SPLIT_MEMBER();
#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 clearFramePointers();
 
    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 instructionInputFrameDelta(SgAsmInstruction*) const;
    InstructionSemantics::BaseSemantics::SValuePtr instructionOutputFrameDelta(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 Sawyer::Optional<int64_t> toInt(const InstructionSemantics::BaseSemantics::SValuePtr&);
 
    bool hasConsistentFramePointer() const;
 
    void print(std::ostream&) const;
 
public:
    // Used internally. Do not document with doxygen.
    void adjustInstruction(SgAsmInstruction*,
                           const InstructionSemantics::BaseSemantics::SValuePtr &spIn,     // SP before execution
                           const InstructionSemantics::BaseSemantics::SValuePtr &spOut,    // SP after execution
                           const InstructionSemantics::BaseSemantics::SValuePtr &spDelta,  // spOut - spIn
                           const InstructionSemantics::BaseSemantics::SValuePtr &fpIn,     // FP before execution
                           const InstructionSemantics::BaseSemantics::SValuePtr &fpOut);   // FP after execution
 
private:
    void init(const Disassembler::BasePtr&);
};
 
std::ostream& operator<<(std::ostream&, const Analysis&);
 
} // namespace
} // namespace
} // namespace
 
// Class versions must be at global scope
BOOST_CLASS_VERSION(Rose::BinaryAnalysis::StackDelta::Analysis, 2);
 
#endif
#endif