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.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>

#include <boost/serialization/access.hpp>
#include <boost/serialization/set.hpp>
#include <boost/serialization/string.hpp>
#include <boost/serialization/vector.hpp>

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 &s, const unsigned version) {
        //s & boost::serialization::base_object<Sawyer::Attribute::Storage<> >(*this); -- not stored
        s & BOOST_SERIALIZATION_NVP(entryVa_);
        s & BOOST_SERIALIZATION_NVP(name_);
        s & BOOST_SERIALIZATION_NVP(demangledName_);
        s & BOOST_SERIALIZATION_NVP(comment_);
        s & BOOST_SERIALIZATION_NVP(reasons_);
        s & BOOST_SERIALIZATION_NVP(bblockVas_);
        s & BOOST_SERIALIZATION_NVP(dblocks_);
        s & BOOST_SERIALIZATION_NVP(isFrozen_);
        s & BOOST_SERIALIZATION_NVP(ccAnalysis_);
        s & BOOST_SERIALIZATION_NVP(ccDefinition_);
        s & BOOST_SERIALIZATION_NVP(stackDeltaAnalysis_);
        s & BOOST_SERIALIZATION_NVP(stackDeltaOverride_);
        if (version >= 1)
            s & BOOST_SERIALIZATION_NVP(reasonComment_);
        if (version >= 2)
            s & BOOST_SERIALIZATION_NVP(sourceLocation_);
    }
#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

// Class versions must be at global scope
BOOST_CLASS_VERSION(Rose::BinaryAnalysis::Partitioner2::Function, 2);

#endif
#endif