BinaryAnalysis/CallingConvention/Analysis.h

#ifndef ROSE_BinaryAnalysis_CallingConvention_Analysis_H
#define ROSE_BinaryAnalysis_CallingConvention_Analysis_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
#include <Rose/BinaryAnalysis/CallingConvention/BasicTypes.h>
 
#include <Rose/BinaryAnalysis/RegisterParts.h>
#include <Rose/BinaryAnalysis/Variables.h>
 
#include <Sawyer/Optional.h>
 
namespace Rose {
namespace BinaryAnalysis {
namespace CallingConvention {
 
class Analysis {
private:
    InstructionSemantics::BaseSemantics::DispatcherPtr cpu_;
    RegisterDictionaryPtr regDict_;                     // Names for the register parts
    DefinitionPtr defaultCc_;                           // Default calling convention for called functions
 
    bool hasResults_;                                   // Are the following data members initialized?
    bool didConverge_;                                  // Are the following data members valid (else only approximations)?
    RegisterParts restoredRegisters_;                   // Registers accessed but restored
    RegisterParts inputRegisters_;                      // Registers that serve as possible input parameters
    RegisterParts outputRegisters_;                     // Registers that hold possible return values
    Variables::StackVariables inputStackParameters_;    // Stack variables serving as function inputs
    Variables::StackVariables outputStackParameters_;   // Stack variables serving as possible return values
    Sawyer::Optional<int64_t> stackDelta_;              // Change in stack across entire function
    // Don't forget to update clearResults() and serialize() if you add more.
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
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(regDict_);
        s & BOOST_SERIALIZATION_NVP(defaultCc_);
        s & BOOST_SERIALIZATION_NVP(hasResults_);
        s & BOOST_SERIALIZATION_NVP(didConverge_);
        s & BOOST_SERIALIZATION_NVP(restoredRegisters_);
        s & BOOST_SERIALIZATION_NVP(inputRegisters_);
        s & BOOST_SERIALIZATION_NVP(outputRegisters_);
        s & BOOST_SERIALIZATION_NVP(inputStackParameters_);
        s & BOOST_SERIALIZATION_NVP(outputStackParameters_);
        s & BOOST_SERIALIZATION_NVP(stackDelta_);
    }
#endif
 
public:
    Analysis();
    ~Analysis();
 
    explicit Analysis(const Disassembler::BasePtr&);
 
    explicit Analysis(const InstructionSemantics::BaseSemantics::DispatcherPtr&);
 
    DefinitionPtr defaultCallingConvention() const;
    void defaultCallingConvention(const DefinitionPtr&);
    void analyzeFunction(const Partitioner2::PartitionerConstPtr&, const Sawyer::SharedPointer<Partitioner2::Function>&);
 
    bool hasResults() const { return hasResults_; }
 
    bool didConverge() const { return didConverge_; }
 
    void clearResults();
 
    void clearNonResults();
 
    RegisterDictionaryPtr registerDictionary() const;
    void registerDictionary(const RegisterDictionaryPtr &d);
    const RegisterParts& calleeSavedRegisters() const { return restoredRegisters_; }
 
    const RegisterParts& inputRegisters() const { return inputRegisters_; }
 
    const RegisterParts& outputRegisters() const { return outputRegisters_; }
 
    const Variables::StackVariables& inputStackParameters() const { return inputStackParameters_; }
 
    const Variables::StackVariables& outputStackParameters() const { return outputStackParameters_; }
 
    Sawyer::Optional<int64_t> stackDelta() const { return stackDelta_; }
 
    bool match(const DefinitionPtr&) const;
 
    Dictionary match(const Dictionary&) const;
 
    void print(std::ostream&, bool multiLine=false) const;
 
private:
    // Finish constructing
    void init(const Disassembler::BasePtr&);
 
    // Recompute the restoredRegisters_ data member.
    void updateRestoredRegisters(const InstructionSemantics::BaseSemantics::StatePtr &initialState,
                                 const InstructionSemantics::BaseSemantics::StatePtr &finalState);
 
    // Recompute the inputRegisters_ data member after updateRestoredRegisters is computed.
    void updateInputRegisters(const InstructionSemantics::BaseSemantics::StatePtr &state);
 
    // Recompute the outputRegisters_ data member after updateRestoredRegisters is computed.
    void updateOutputRegisters(const InstructionSemantics::BaseSemantics::StatePtr &state);
 
    // Recompute the input and output stack variables
    void updateStackParameters(const Partitioner2::FunctionPtr &function,
                               const InstructionSemantics::BaseSemantics::StatePtr &initialState,
                               const InstructionSemantics::BaseSemantics::StatePtr &finalState);
 
    // Recomputes the stack delta
    void updateStackDelta(const InstructionSemantics::BaseSemantics::StatePtr &initialState,
                          const InstructionSemantics::BaseSemantics::StatePtr &finalState);
};
 
} // namespace
} // namespace
} // namespace
 
#endif
#endif