Function.h

#ifndef ROSE_BinaryAnalysis_Partitioner2_Function_H
#define ROSE_BinaryAnalysis_Partitioner2_Function_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
#include <Rose/BinaryAnalysis/Partitioner2/BasicTypes.h>
 
#include <Rose/BinaryAnalysis/CallingConvention/Analysis.h>
#include <Rose/BinaryAnalysis/CallingConvention/Definition.h>
#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics.h>
#include <Rose/BinaryAnalysis/StackDelta.h>
#include <Rose/SourceLocation.h>
 
#include <Sawyer/Attribute.h>
#include <Sawyer/Cached.h>
#include <Sawyer/Map.h>
#include <Sawyer/Set.h>
#include <Sawyer/SharedPointer.h>
 
#ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
#include <boost/serialization/access.hpp>
#endif
 
namespace Rose {
namespace BinaryAnalysis {
namespace Partitioner2 {
 
typedef Sawyer::SharedPointer<class Function> FunctionPtr;
 
class Function: public Sawyer::SharedObject, public Sawyer::Attribute::Storage<> {
public:
    enum Ownership { OWN_UNOWNED=0,                     
                     OWN_EXPLICIT,                      
                     OWN_PROVISIONAL,                   
    };
 
    typedef FunctionPtr Ptr;
 
private:
    rose_addr_t entryVa_;                               // entry address; destination for calls to this function
    std::string name_;                                  // optional function name
    std::string demangledName_;                         // optional demangled name
    std::string comment_;                               // optional multi-line, plain-text, commment
    unsigned reasons_;                                  // reason bits from SgAsmFunction::FunctionReason
    std::string reasonComment_;                         // additional commentary about reasons_
    std::set<rose_addr_t> bblockVas_;                   // addresses of basic blocks
    std::vector<DataBlockPtr> dblocks_;                 // data blocks owned by this function, sorted by starting address
    bool isFrozen_;                                     // true if function is represented by the CFG
    CallingConvention::Analysis ccAnalysis_;            // analysis computing how registers etc. are used
    CallingConvention::DefinitionPtr ccDefinition_;     // best definition or null
    StackDelta::Analysis stackDeltaAnalysis_;           // analysis computing stack deltas for each block and whole function
    InstructionSemantics::BaseSemantics::SValuePtr stackDeltaOverride_; // special value to override stack delta analysis
    SourceLocation sourceLocation_;                     // corresponding location of function in source code if known
 
    // The following members are caches either because their value is seldom needed and expensive to compute, or because the
    // value is best computed at a higher layer (e.g., in the partitioner) yet it makes the most sense to store it here. Make
    // sure clearCache() resets these to initial values.
    Sawyer::Cached<bool> isNoop_;
 
    void clearCache() {
        isNoop_.clear();
    }
 
#ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
private:
    friend class boost::serialization::access;
    template<class S> void serialize(S&, unsigned version);
#endif
    
public:
    ~Function();
 
protected:
    // Needed for serialization
    Function();
 
    // Use instance() instead
    explicit Function(rose_addr_t entryVa, const std::string &name, unsigned reasons);
 
public:
    static Ptr instance(rose_addr_t entryVa, const std::string &name="", unsigned reasons=0);
    static Ptr instance(rose_addr_t entryVa, unsigned reasons);
    rose_addr_t address() const;
 
    const std::string& name() const;
    void name(const std::string&);
    const std::string& demangledName() const;
    void demangledName(const std::string&);
    const std::string& comment() const;
    void comment(const std::string&);
    const SourceLocation& sourceLocation() const;
    void sourceLocation(const SourceLocation&);
    unsigned reasons() const;
    void reasons(unsigned);
    void insertReasons(unsigned reasons);
 
    void eraseReasons(unsigned reasons);
 
    const std::string& reasonComment() const;
    void reasonComment(const std::string&);
    const std::set<rose_addr_t>& basicBlockAddresses() const;
 
    bool ownsBasicBlock(rose_addr_t bblockVa) const;
 
    bool insertBasicBlock(rose_addr_t bblockVa);
 
    void eraseBasicBlock(rose_addr_t bblockVa);         // no-op if not existing
 
    const std::vector<DataBlockPtr>& dataBlocks() const;
 
    bool insertDataBlock(const DataBlockPtr&);
 
    DataBlockPtr eraseDataBlock(const DataBlockPtr&);
 
    DataBlockPtr dataBlockExists(const DataBlockPtr&) const;
 
    AddressIntervalSet dataAddresses() const;
 
    bool isFrozen() const;
 
    bool isThunk() const;
 
    size_t nBasicBlocks() const;
 
    size_t nDataBlocks() const;
 
    InstructionSemantics::BaseSemantics::SValuePtr stackDelta() const;
    int64_t stackDeltaConcrete() const;
    InstructionSemantics::BaseSemantics::SValuePtr stackDeltaOverride() const;
    void stackDeltaOverride(const InstructionSemantics::BaseSemantics::SValuePtr &delta);
    const StackDelta::Analysis& stackDeltaAnalysis() const;
    StackDelta::Analysis& stackDeltaAnalysis();
    const CallingConvention::Analysis& callingConventionAnalysis() const;
    CallingConvention::Analysis& callingConventionAnalysis();
    CallingConvention::DefinitionPtr callingConventionDefinition();
    void callingConventionDefinition(const CallingConvention::DefinitionPtr&);
    std::string printableName() const;
 
    const Sawyer::Cached<bool>& isNoop() const;
 
private:
    friend class Partitioner;
    void freeze();
    void thaw();
 
    // Find an equivalent data block and replace it with the specified data block, or insert the specified data block
    void replaceOrInsertDataBlock(const DataBlockPtr&);
};
 
} // namespace
} // namespace
} // namespace
 
#endif
#endif