VariableFinder.h

#ifndef ROSE_BinaryAnalysis_Variables_VariableFinder_H
#define ROSE_BinaryAnalysis_Variables_VariableFinder_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
 
#include <Rose/BinaryAnalysis/BasicTypes.h>
#include <Rose/BinaryAnalysis/Variables/GlobalVariable.h>
#include <Rose/BinaryAnalysis/Variables/StackVariable.h>
 
#include <Sawyer/CommandLine.h>
 
#include <chrono>
 
class SgAsmInstruction;
 
namespace Rose {
namespace BinaryAnalysis {
namespace Variables {
 
class VariableFinder {
public:
    struct Settings {
        std::chrono::seconds gvarMethod1MaxTimePerFunction;
 
        Settings()
            : gvarMethod1MaxTimePerFunction(30) {}
    };
 
    using Ptr = VariableFinderPtr;
    using ConstPtr = VariableFinderConstPtr;
private:
    Settings settings_;
 
protected:
    explicit VariableFinder(const Settings&);
public:
    ~VariableFinder();
 
public:
    static Ptr instance(const Settings &settings = Settings());
 
    const Settings& settings() const { return settings_; }
    Settings& settings() { return settings_; }
    static Sawyer::CommandLine::SwitchGroup commandLineSwitches(Settings&);
 
    StackVariables findStackVariables(const Partitioner2::PartitionerConstPtr&, const Partitioner2::FunctionPtr&);
    StackVariables findStackVariables(const Partitioner2::PartitionerConstPtr&, SgAsmInstruction*);
    GlobalVariables findGlobalVariables(const Partitioner2::PartitionerConstPtr&);
 
    void evict(const Partitioner2::FunctionPtr&);
    void evict(const Partitioner2::PartitionerConstPtr&);
    bool isCached(const Partitioner2::FunctionPtr&);
 
    StackFrame detectFrameAttributes(const Partitioner2::PartitionerConstPtr&, const Partitioner2::FunctionPtr&,
                                     StackVariable::Boundaries&/*in,out*/);
 
//    /** Initilialize offsets for function prologue.
//     *
//     *  At the start of a function, we sometimes know where certain things are on the stack and their sizes. For instance, for
//     *  powerpc after the function prologue sets up the stack frame, we know that the stack frame header contain two 4-byte
//     *  quantities: the pointer to the parent frame, and the LR save area for callees and therefore we can add the three offsets
//     *  that delimit the boundaries of these two "variables". */
//    void initializeFrameBoundaries(const StackFrame&, const Partitioner2::PartitionerConstPtr&, const Partitioner2::FunctionPtr&,
//                                   StackVariable::Boundaries &boundaries /*in,out*/);
//
//    /** Find stack variable addresses.
//     *
//     *  Given an instruction, look for operand subexpressions that reference memory based from a stack frame pointer, such as
//     *  x86 "mov eax, [ebp - 12]". Returns the set of offsets from the frame pointer. */
//    std::set<int64_t> findFrameOffsets(const StackFrame&, const Partitioner2::PartitionerConstPtr&, SgAsmInstruction*);
//
//    /** Function that owns an instruction.
//     *
//     *  Given an instruction, return one of the owning functions chosen arbitrarily.  This is the method used by the version
//     *  of @ref findStackVariables that takes an instruction argument. */
//    Partitioner2::FunctionPtr functionForInstruction(const Partitioner2::PartitionerConstPtr&, SgAsmInstruction*);
//
    AddressToAddresses findGlobalVariableVas(const Partitioner2::PartitionerConstPtr&);
 
    std::set<Address> findConstants(const SymbolicExpression::Ptr&);
 
    std::set<Address> findConstants(SgAsmInstruction*);
 
    std::set<SymbolicExpression::Ptr> getMemoryAddresses(const InstructionSemantics::BaseSemantics::MemoryCellStatePtr&);
 
    std::set<Address> findAddressConstants(const InstructionSemantics::BaseSemantics::MemoryCellStatePtr&);
 
    void removeOutliers(const StackFrame&, StackVariable::Boundaries &sortedBoundaries /*in,out*/);
 
    static bool regionContainsInstructions(const Partitioner2::PartitionerConstPtr&, const AddressInterval&);
 
    static bool regionIsFullyMapped(const Partitioner2::PartitionerConstPtr&, const AddressInterval&);
 
    static bool regionIsFullyReadWrite(const Partitioner2::PartitionerConstPtr&, const AddressInterval&);
 
private:
    // Searches for global variables using a per-function data-flow analysis and distinguishing between global variable
    // addresses based on which instructions wrote to those addresses. The data-flow is inter-procedural only for calls to
    // certain functions (such as the x86 get_pc_thunk variety of functions).
    //
    // The return value is a list of global variable addresses and the instructions at which each global variable address
    // was detected.
    AddressToAddresses findGlobalVariableVasMethod1(const Partitioner2::PartitionerConstPtr&);
 
    // Searches for global variables by running each instruction individually in symbolic semantics and then searching
    // the memory state addresses. All constants found in address expressions are gathered together.
    //
    // The return value is a list of global variable addresses and the instructions at which each global address was detected.
    AddressToAddresses findGlobalVariableVasMethod2(const Partitioner2::PartitionerConstPtr&);
 
    // Searches for global variables by looking for constants in instruction ASTs.
    //
    // The retun value is the list of constants and the instructions in which each constant appeared.
    AddressToAddresses findGlobalVariableVasMethod3(const Partitioner2::PartitionerConstPtr&);
 
    // Merge one set of addresses and their defining instructions into another.
    static void merge(AddressToAddresses&, const AddressToAddresses&);
};
 
} // namespace
} // namespace
} // namespace
 
#endif
#endif