StackVariable.h

#ifndef ROSE_BinaryAnalysis_Variables_StackVariable_H
#define ROSE_BinaryAnalysis_Variables_StackVariable_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
 
#include <Rose/BinaryAnalysis/Partitioner2/BasicTypes.h>
#include <Rose/BinaryAnalysis/Variables/BaseVariable.h>
 
#include <Sawyer/IntervalMap.h>
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
#include <boost/serialization/access.hpp>
#endif
 
namespace Rose {
namespace BinaryAnalysis {
namespace Variables {
 
class StackVariable: public BaseVariable {
public:
    enum class Purpose {
        RETURN_ADDRESS,                                 
        FRAME_POINTER,                                  
        STACK_POINTER,                                  
        SPILL_AREA,                                     
        NORMAL,                                         
        UNKNOWN,                                        
        OTHER                                           
    };
 
    struct Boundary {
        int64_t stackOffset = 0;                        
        std::vector<InstructionAccess> definingInsns;   
        Purpose purpose = Purpose::UNKNOWN;             
    };
 
    using Boundaries = std::vector<Boundary>;
 
private:
    Partitioner2::FunctionPtr function_;                // Function in which local variable exists
    int64_t stackOffset_ = 0;                           // Offset w.r.t. function's initial stack pointer
    Purpose purpose_ = Purpose::UNKNOWN;
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
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(stackOffset_);
        if (version >= 1)
            s & BOOST_SERIALIZATION_NVP(purpose_);
    }
#endif
 
public:
    StackVariable();
 
    StackVariable(const Partitioner2::FunctionPtr&, int64_t stackOffset, Address maxSizeBytes, Purpose,
                  const std::vector<InstructionAccess> &definingInstructions = std::vector<InstructionAccess>(),
                  const std::string &name = "");
 
    StackVariable(const StackVariable&);
    StackVariable& operator=(const StackVariable&);
    ~StackVariable();
 
    Partitioner2::FunctionPtr function() const;
    void function(const Partitioner2::FunctionPtr&);
    int64_t stackOffset() const;
    void stackOffset(int64_t offset);
    Purpose purpose() const;
    void purpose(Purpose p);
    const std::string& setDefaultName();
 
    bool operator==(const StackVariable &other) const;
    bool operator!=(const StackVariable &other) const;
    OffsetInterval interval() const;
 
    static Boundary& insertBoundary(Boundaries& /*in,out*/, int64_t stackOffset, const InstructionAccess&);
    static Boundary& insertBoundaryImplied(Boundaries&/*in,out*/, int64_t stackOffset);
    static void printBoundary(std::ostream&, const Boundary&, const std::string &prefix = "");
 
    void print(std::ostream&) const;
    std::string toString() const;
    explicit operator bool() const {
        return !interval().isEmpty();
    }
 
    bool operator!() const {
        return interval().isEmpty();
    }
 
    friend std::ostream& operator<<(std::ostream&, const Rose::BinaryAnalysis::Variables::StackVariable&);
};
 
using StackVariables = Sawyer::Container::IntervalMap<OffsetInterval, StackVariable>;
 
void print(const StackVariables&, const Partitioner2::PartitionerConstPtr&, std::ostream &out, const std::string &prefix = "");
 
} // namespace
} // namespace
} // namespace
 
// Class versions must be at global scope
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
BOOST_CLASS_VERSION(Rose::BinaryAnalysis::Variables::StackVariable, 1);
#endif
 
#endif
#endif