Config.h

#ifndef ROSE_BinaryAnalysis_Partitioner2_Config_H
#define ROSE_BinaryAnalysis_Partitioner2_Config_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS

#include <Rose/FileSystem.h>
#include <Rose/BinaryAnalysis/Partitioner2/Function.h>
#include <Sawyer/Map.h>
#include <Sawyer/Optional.h>
#include <Rose/SourceLocation.h>
#include <set>
#include <string>

namespace Rose {
namespace BinaryAnalysis {
namespace Partitioner2 {

class BasicBlockConfig {
    rose_addr_t address_ = 0;
    std::string comment_;
    Sawyer::Optional<rose_addr_t> finalInsnVa_;
    std::set<rose_addr_t> successorVas_;
    SourceLocation sourceLocation_;

public:
    // default constructor needed by some STL containers
    BasicBlockConfig() {}

    explicit BasicBlockConfig(rose_addr_t va): address_(va) {}

    rose_addr_t address() const { return address_; }

    const std::string& comment() const { return comment_; }
    BasicBlockConfig& comment(const std::string &s) { comment_ = s; return *this; }
    const SourceLocation& sourceLocation() const { return sourceLocation_; }
    BasicBlockConfig& sourceLocation(const SourceLocation &loc) { sourceLocation_ = loc; return *this; }
    Sawyer::Optional<rose_addr_t> finalInstructionVa() const { return finalInsnVa_; }
    BasicBlockConfig& finalInstructionVa(const Sawyer::Optional<rose_addr_t> &va) { finalInsnVa_ = va; return *this; }
    const std::set<rose_addr_t>& successorVas() const { return successorVas_; }
    std::set<rose_addr_t>& successorVas() { return successorVas_; }
    BasicBlockConfig& successorVas(const std::set<rose_addr_t> &vas) { successorVas_ = vas; return *this; }
    BasicBlockConfig& insertSuccessorVa(rose_addr_t va) { successorVas_.insert(va); return *this; }
    BasicBlockConfig& clearSuccessorVas() { successorVas_.clear(); return *this; }
};


class DataBlockConfig {
    rose_addr_t address_;
    std::string name_;
    std::string comment_;
    SourceLocation sourceLocation_;

public:
    // Default constructor needed by some STL containers
    DataBlockConfig(): address_(0) {}

    explicit DataBlockConfig(rose_addr_t va): address_(va) {}

    rose_addr_t address() const { return address_; }

    const std::string &name() const { return name_; }
    DataBlockConfig& name(const std::string &s) { name_ = s; return *this; }
    const std::string& comment() const { return comment_; }
    DataBlockConfig& comment(const std::string &s) { comment_ = s; return *this; }
    const SourceLocation& sourceLocation() const { return sourceLocation_; }
    DataBlockConfig& sourceLocation(const SourceLocation &loc) { sourceLocation_ = loc; return *this; }
};


class FunctionConfig {
    Sawyer::Optional<rose_addr_t> address_;
    std::string name_, defaultName_, comment_;
    Sawyer::Optional<int64_t> stackDelta_;
    Sawyer::Optional<bool> mayReturn_;
    SourceLocation sourceLocation_;

public:
    // default constructor needed by some STL containers
    FunctionConfig() {}

    explicit FunctionConfig(rose_addr_t va, const std::string &name=""): address_(va), name_(name) {}
    explicit FunctionConfig(const std::string &name): name_(name) {}
    FunctionConfig(const Sawyer::Optional<rose_addr_t> &va, const std::string &name): address_(va), name_(name) {}
    Sawyer::Optional<rose_addr_t> address() const { return address_; }

    const std::string& name() const { return name_; }
    FunctionConfig& name(const std::string &s);
    const std::string& defaultName() const { return defaultName_; }
    FunctionConfig& defaultName(const std::string &s) { defaultName_ = s; return *this; }
    const std::string& comment() const { return comment_; }
    FunctionConfig& comment(const std::string &s) { comment_ = s; return *this; }
    const SourceLocation& sourceLocation() const { return sourceLocation_; }
    FunctionConfig& sourceLocation(const SourceLocation &loc) { sourceLocation_ = loc; return *this; }
    Sawyer::Optional<int64_t> stackDelta() const { return stackDelta_; }
    FunctionConfig& stackDelta(const Sawyer::Optional<int64_t> &n) { stackDelta_ = n; return *this; }
    Sawyer::Optional<bool> mayReturn() const { return mayReturn_; }
    FunctionConfig& mayReturn(const Sawyer::Optional<bool> &b) { mayReturn_ = b; return *this; }
};

class AddressConfig {
    rose_addr_t address_ = 0;
    std::string name_;
    std::string comment_;
    SourceLocation sourceLocation_;

public:
    // Default constructor needed by STL containers
    AddressConfig() {}

    explicit AddressConfig(rose_addr_t va)
        : address_(va) {}

    rose_addr_t address() const { return address_; }

    const std::string &name() const { return name_; }
    AddressConfig& name(const std::string &s) { name_ = s; return *this; }
    const std::string &comment() const { return comment_; }
    AddressConfig& comment(const std::string &s) { comment_ = s; return *this; }
    const SourceLocation& sourceLocation() const { return sourceLocation_; }
    AddressConfig& sourceLocation(const SourceLocation &loc) { sourceLocation_ = loc; return *this; }
};

class Configuration {
public:
    typedef Sawyer::Container::Map<rose_addr_t, BasicBlockConfig> BasicBlockConfigs;
    typedef Sawyer::Container::Map<rose_addr_t, DataBlockConfig> DataBlockConfigs;
    typedef Sawyer::Container::Map<rose_addr_t, FunctionConfig> FunctionConfigsByAddress;
    typedef Sawyer::Container::Map<std::string, FunctionConfig> FunctionConfigsByName;
    typedef Sawyer::Container::Map<rose_addr_t, AddressConfig> AddressConfigs;

private:
    BasicBlockConfigs bblockConfigs_;
    DataBlockConfigs dblockConfigs_;
    FunctionConfigsByAddress functionConfigsByAddress_;
    FunctionConfigsByName functionConfigsByName_;
    AddressConfigs addressConfigs_;

public:
    static std::string fileFormatDoc();

    void loadFromFile(const FileSystem::Path &fileName);

    const BasicBlockConfigs& basicBlocks() const { return bblockConfigs_; }
    BasicBlockConfigs& basicBlocks() { return bblockConfigs_; }
    const BasicBlockConfig& basicBlock(rose_addr_t) const;

    const DataBlockConfigs& dataBlocks() const { return dblockConfigs_; }
    DataBlockConfigs& dataBlocks() { return dblockConfigs_; }
    const DataBlockConfig& dataBlock(rose_addr_t) const;

    const FunctionConfigsByAddress& functionConfigsByAddress() const { return functionConfigsByAddress_; }
    FunctionConfigsByAddress& functionConfigsByAddress() { return functionConfigsByAddress_; }
    const FunctionConfigsByName& functionConfigsByName() const { return functionConfigsByName_; }
    FunctionConfigsByName& functionConfigsByName() { return functionConfigsByName_; }
    const FunctionConfig& function(rose_addr_t) const;
    const FunctionConfig& function(const std::string &name) const;
    const AddressConfigs& addresses() const { return addressConfigs_; }
    AddressConfigs& addresses() { return addressConfigs_; }
    const AddressConfig& address(rose_addr_t) const;

    BasicBlockConfig& insertMaybeBasicBlock(rose_addr_t va);

    DataBlockConfig& insertMaybeDataBlock(rose_addr_t va);

    FunctionConfig& insertMaybeFunction(rose_addr_t va, const std::string &name="");
    FunctionConfig& insertMaybeFunction(const std::string &name);
    AddressConfig& insertMaybeAddress(rose_addr_t va);

    bool insertConfiguration(const BasicBlockConfig&);

    bool insertConfiguration(const DataBlockConfig&);

    bool insertConfiguration(const FunctionConfig&);

    bool insertConfiguration(const AddressConfig&);

    std::string basicBlockComment(rose_addr_t bblockVa) const;

    Sawyer::Optional<rose_addr_t> basicBlockFinalInstructionVa(rose_addr_t bblockVa) const;

    std::set<rose_addr_t> basicBlockSuccessorVas(rose_addr_t bblockVa) const;

    std::string dataBlockName(rose_addr_t dblockVa) const;

    std::string dataBlockComment(rose_addr_t dblockVa) const;

    std::string functionName(rose_addr_t functionVa) const;

    std::string functionDefaultName(rose_addr_t functionVa) const;

    std::string functionComment(rose_addr_t functionVa) const;
    std::string functionComment(const std::string &functionName) const;
    std::string functionComment(const Function::Ptr&) const;
    Sawyer::Optional<int64_t> functionStackDelta(rose_addr_t functionVa) const;
    Sawyer::Optional<int64_t> functionStackDelta(const std::string &functionName) const;
    Sawyer::Optional<int64_t> functionStackDelta(const Function::Ptr&) const;
    Sawyer::Optional<bool> functionMayReturn(rose_addr_t functionVa) const;
    Sawyer::Optional<bool> functionMayReturn(const std::string &functionName) const;
    Sawyer::Optional<bool> functionMayReturn(const Function::Ptr&) const;
    std::string addressComment(rose_addr_t va) const;

    std::string comment(rose_addr_t va) const;

    void print(std::ostream&) const;
};

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

std::ostream& operator<<(std::ostream&, const Rose::BinaryAnalysis::Partitioner2::Configuration&);

#endif
#endif