Function.h

#ifndef ROSE_Partitioner2_Function_H
#define ROSE_Partitioner2_Function_H

#include <BaseSemantics2.h>
#include <BinaryCallingConvention.h>
#include <BinaryStackDelta.h>
#include <Partitioner2/BasicTypes.h>
#include <Partitioner2/DataBlock.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<DataBlock::Ptr> 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::Definition::Ptr ccDefinition_;   // best definition or null
    StackDelta::Analysis stackDeltaAnalysis_;           // analysis computing stack deltas for each block and whole function
    InstructionSemantics2::BaseSemantics::SValuePtr stackDeltaOverride_; // special value to override stack delta analysis

    // 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 > 0)
            s & BOOST_SERIALIZATION_NVP(reasonComment_);
    }
#endif
    
protected:
    // Needed for serialization
    Function()
        : entryVa_(0), reasons_(0), isFrozen_(false) {}

    // Use instance() instead
    explicit Function(rose_addr_t entryVa, const std::string &name, unsigned reasons)
        : entryVa_(entryVa), name_(name), reasons_(reasons), isFrozen_(false) {
        bblockVas_.insert(entryVa);
    }

public:
    static Ptr instance(rose_addr_t entryVa, const std::string &name="", unsigned reasons=0) {
        return Ptr(new Function(entryVa, name, reasons));
    }
    static Ptr instance(rose_addr_t entryVa, unsigned reasons) {
        return Ptr(new Function(entryVa, "", reasons));
    }
    rose_addr_t address() const { return entryVa_; }

    const std::string& name() const { return name_; }
    void name(const std::string &name) { name_ = name; }
    const std::string& demangledName() const;
    void demangledName(const std::string &name) { demangledName_ = name; }
    const std::string& comment() const { return comment_; }
    void comment(const std::string &s) { comment_ = s; }
    unsigned reasons() const { return reasons_; }
    void reasons(unsigned reasons) { reasons_ = reasons; }
    void insertReasons(unsigned reasons) { reasons_ = (reasons_ & 0xffff0000) | reasons; }

    void eraseReasons(unsigned reasons) { reasons_ &= ~((0xffff0000 & reasons) | ((reasons & 0xffff) != 0 ? 0xffff : 0x0)); }
    const std::string& reasonComment() const { return reasonComment_; }
    void reasonComment(const std::string &s) { reasonComment_ = s; }
    const std::set<rose_addr_t>& basicBlockAddresses() const { return bblockVas_; }

    bool ownsBasicBlock(rose_addr_t bblockVa) const {
        return bblockVas_.find(bblockVa) != bblockVas_.end();
    }

    bool insertBasicBlock(rose_addr_t bblockVa) {
        ASSERT_forbid(isFrozen_);
        bool wasInserted = bblockVas_.insert(bblockVa).second;
        if (wasInserted)
            clearCache();
        return wasInserted;
    }

    void eraseBasicBlock(rose_addr_t bblockVa) {        // no-op if not existing
        ASSERT_forbid(isFrozen_);
        ASSERT_forbid2(bblockVa==entryVa_, "function entry block cannot be removed");
        clearCache();
        bblockVas_.erase(bblockVa);
    }

    const std::vector<DataBlock::Ptr>& dataBlocks() const { return dblocks_; }

    bool insertDataBlock(const DataBlock::Ptr&);

    void eraseDataBlock(const DataBlock::Ptr&);

    bool isFrozen() const { return isFrozen_; }

    bool isThunk() const;

    size_t nBasicBlocks() const { return bblockVas_.size(); }

    size_t nDataBlocks() const { return dblocks_.size(); }

    InstructionSemantics2::BaseSemantics::SValuePtr stackDelta() const;
    int64_t stackDeltaConcrete() const;
    InstructionSemantics2::BaseSemantics::SValuePtr stackDeltaOverride() const;
    void stackDeltaOverride(const InstructionSemantics2::BaseSemantics::SValuePtr &delta);
    const StackDelta::Analysis& stackDeltaAnalysis() const { return stackDeltaAnalysis_; }
    StackDelta::Analysis& stackDeltaAnalysis() { return stackDeltaAnalysis_; }
    const CallingConvention::Analysis& callingConventionAnalysis() const { return ccAnalysis_; }
    CallingConvention::Analysis& callingConventionAnalysis() { return ccAnalysis_; }
    CallingConvention::Definition::Ptr callingConventionDefinition() { return ccDefinition_; }
    void callingConventionDefinition(const CallingConvention::Definition::Ptr &ccdef) { ccDefinition_ = ccdef; }
    std::string printableName() const;

    const Sawyer::Cached<bool>& isNoop() const { return isNoop_; }

private:
    friend class Partitioner;
    void freeze() { isFrozen_ = true; }
    void thaw() { isFrozen_ = false; }
};

typedef Sawyer::Container::Map<rose_addr_t, Function::Ptr> Functions;
typedef Sawyer::Container::Set<Function::Ptr> FunctionSet;

} // namespace
} // namespace
} // namespace

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

#endif