Variables.h

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

#include <Rose/BinaryAnalysis/InstructionSemantics2/BaseSemantics/Types.h>
#include <Rose/BinaryAnalysis/InstructionSemantics2/BaseSemantics/MemoryCellState.h>
#include <Rose/BinaryAnalysis/Partitioner2/BasicTypes.h>
#include <Rose/BinaryAnalysis/SymbolicExpr.h>

#include <Sawyer/IntervalMap.h>
#include <Sawyer/Message.h>
#include <Sawyer/Optional.h>
#include <Sawyer/Set.h>

#include <boost/serialization/access.hpp>
#include <boost/serialization/split_member.hpp>

namespace Rose {
namespace BinaryAnalysis {

namespace Variables {

// Basic types

typedef Sawyer::Container::Set<rose_addr_t> AddressSet;

typedef std::map<int64_t /*offset*/, AddressSet> OffsetToAddresses;

typedef std::map<rose_addr_t /*globalVa*/, AddressSet /*insns*/> AddressToAddresses;

typedef Sawyer::Container::Interval<int64_t> OffsetInterval;

// Global variables

extern Sawyer::Message::Facility mlog;

// Global utilities

void initDiagnostics();

std::string offsetStr(int64_t offset);

std::string sizeStr(uint64_t size);

// Base class for variable descriptors

class BaseVariable {
    rose_addr_t maxSizeBytes_;                      // maximum possible size of this variable in bytes
    AddressSet insnVas_;                            // instructions where the variable was detected that reference the variable
    InstructionSemantics2::BaseSemantics::InputOutputPropertySet ioProperties_; 
    std::string name_;                              // optional variable name

#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(maxSizeBytes_);
        s & BOOST_SERIALIZATION_NVP(insnVas_);
        s & BOOST_SERIALIZATION_NVP(ioProperties_);
        s & BOOST_SERIALIZATION_NVP(name_);
    }
#endif
    
protected:
    BaseVariable()
        : maxSizeBytes_(0) {}

    BaseVariable(size_t maxSizeBytes, const AddressSet &definingInstructionVas, const std::string &name)
        // following arithmetic is to work around lack of SSIZE_MAX on windows. The maxSizeBytes should not be more than the
        // maximum value of the signed type with the same conversion rank.
        : maxSizeBytes_(std::min(maxSizeBytes, ((size_t)(1) << (8*sizeof(size_t)-1))-1)),
          insnVas_(definingInstructionVas), name_(name) {}

public:
    rose_addr_t maxSizeBytes() const { return maxSizeBytes_; }
    void maxSizeBytes(rose_addr_t size);
    const AddressSet& definingInstructionVas() const { return insnVas_; }
    AddressSet& definingInstructionVas() { return insnVas_; }
    void definingInstructionVas(const AddressSet &vas) { insnVas_ = vas; }
    const InstructionSemantics2::BaseSemantics::InputOutputPropertySet& ioProperties() const { return ioProperties_; }
    InstructionSemantics2::BaseSemantics::InputOutputPropertySet& ioProperties() { return ioProperties_; }
    void ioProperties(const InstructionSemantics2::BaseSemantics::InputOutputPropertySet &set) { ioProperties_ = set; }
    const std::string& name() const { return name_; }
    void name(const std::string &s) { name_ = s; }
};

// Local variable descriptors

class StackVariable: public BaseVariable {
    Partitioner2::FunctionPtr function_;            // function in which local variable exists
    int64_t frameOffset_;                           // offset where variable is located in the function's stack frame

#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_BASE_OBJECT_NVP(BaseVariable);
        s & BOOST_SERIALIZATION_NVP(function_);
        s & BOOST_SERIALIZATION_NVP(frameOffset_);
    }
#endif
        
public:
    StackVariable();

    StackVariable(const Partitioner2::FunctionPtr&, int64_t frameOffset, rose_addr_t maxSizeBytes,
                  const AddressSet &definingInstructionVas = AddressSet(), const std::string &name = "");

    ~StackVariable();

    Partitioner2::FunctionPtr function() const;
    void function(const Partitioner2::FunctionPtr&);
    int64_t frameOffset() const { return frameOffset_; }
    void frameOffset(int64_t offset) { frameOffset_ = offset; }
    const std::string& setDefaultName();

    bool operator==(const StackVariable &other) const;
    bool operator!=(const StackVariable &other) const;
    OffsetInterval interval() const;

    void print(std::ostream&) const;
    std::string toString() const;
    friend std::ostream& operator<<(std::ostream&, const Rose::BinaryAnalysis::Variables::StackVariable&);
};

using StackVariables = Sawyer::Container::IntervalMap<OffsetInterval, StackVariable>;

void print(const StackVariables&, const Partitioner2::Partitioner&, std::ostream &out, const std::string &prefix = "");

// Global variable descriptors

class GlobalVariable: public BaseVariable {
    rose_addr_t address_;                               // starting (lowest) virtual address

#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_BASE_OBJECT_NVP(BaseVariable);
        s & BOOST_SERIALIZATION_NVP(address_);
    }
#endif
    
public:
    GlobalVariable();

    GlobalVariable(rose_addr_t startingAddress, rose_addr_t maxSizeBytes,
                   const AddressSet &definingInstructionVas = AddressSet(), const std::string &name = "");

    rose_addr_t address() const { return address_; }
    void address(rose_addr_t va) { address_ = va; }
    const std::string& setDefaultName();

    bool operator==(const GlobalVariable &other) const;
    bool operator!=(const GlobalVariable &other) const;
    AddressInterval interval() const;

    void print(std::ostream&) const;
    std::string toString() const;
    friend std::ostream& operator<<(std::ostream&, const Rose::BinaryAnalysis::Variables::GlobalVariable&);
};

typedef Sawyer::Container::IntervalMap<AddressInterval, GlobalVariable> GlobalVariables;

void print(const GlobalVariables&,const Partitioner2::Partitioner&, std::ostream &out, const std::string &prefix = "");

// Analyzer

using VariableFinderPtr = Sawyer::SharedPointer<class VariableFinder>;

class VariableFinder: public Sawyer::SharedObject {
public:
    struct Settings {};

    using Ptr = VariableFinderPtr;

private:
    Settings settings_;

protected:
    explicit VariableFinder(const Settings&);

public:
    static Ptr instance(const Settings &settings = Settings());

    const Settings& settings() const { return settings_; }
    Settings& settings() { return settings_; }
    StackVariables findStackVariables(const Partitioner2::Partitioner&, const Partitioner2::FunctionPtr&);
    StackVariables findStackVariables(const Partitioner2::Partitioner&, SgAsmInstruction*);
    GlobalVariables findGlobalVariables(const Partitioner2::Partitioner&);

    void evict(const Partitioner2::FunctionPtr&);
    void evict(const Partitioner2::Partitioner&);
    bool isCached(const Partitioner2::FunctionPtr&);

    Sawyer::Optional<uint64_t> functionFrameSize(const Partitioner2::Partitioner&, const Partitioner2::FunctionPtr&);

    static RegisterDescriptor frameOrStackPointer(const Partitioner2::Partitioner&);

    OffsetInterval referencedFrameArea(const Partitioner2::Partitioner&,
                                       const InstructionSemantics2::BaseSemantics::RiscOperatorsPtr&,
                                       const SymbolicExpr::Ptr &address, size_t nBytes);

    std::set<int64_t> findStackOffsets(const Partitioner2::Partitioner&, SgAsmInstruction*);

    Partitioner2::FunctionPtr functionForInstruction(const Partitioner2::Partitioner&, SgAsmInstruction*);

    AddressToAddresses findGlobalVariableVas(const Partitioner2::Partitioner&);

    std::set<rose_addr_t> findConstants(const SymbolicExpr::Ptr&);

    std::set<rose_addr_t> findConstants(SgAsmInstruction*);

    std::set<SymbolicExpr::Ptr> getMemoryAddresses(const InstructionSemantics2::BaseSemantics::MemoryCellStatePtr&);

    std::set<rose_addr_t> findAddressConstants(const InstructionSemantics2::BaseSemantics::MemoryCellStatePtr&);

    InstructionSemantics2::BaseSemantics::SValuePtr
    symbolicAddress(const Partitioner2::Partitioner&, const StackVariable&,
                    const InstructionSemantics2::BaseSemantics::RiscOperatorsPtr&);
};

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

#endif
#endif