Configuration.h

#ifndef ROSE_BinaryAnalysis_Partitioner2_Configuration_H
#define ROSE_BinaryAnalysis_Partitioner2_Configuration_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
#include <Rose/BinaryAnalysis/Partitioner2/BasicTypes.h>

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

namespace Rose {
namespace BinaryAnalysis {
namespace Partitioner2 {

class BasicBlockConfiguration {
    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
    BasicBlockConfiguration() {}

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

    rose_addr_t address() const { return address_; }

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


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

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

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

    rose_addr_t address() const { return address_; }

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


class FunctionConfiguration {
    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
    FunctionConfiguration() {}

    explicit FunctionConfiguration(rose_addr_t va, const std::string &name=""): address_(va), name_(name) {}
    explicit FunctionConfiguration(const std::string &name): name_(name) {}
    FunctionConfiguration(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_; }
    FunctionConfiguration& name(const std::string &s);
    const std::string& defaultName() const { return defaultName_; }
    FunctionConfiguration& defaultName(const std::string &s) { defaultName_ = s; return *this; }
    const std::string& comment() const { return comment_; }
    FunctionConfiguration& comment(const std::string &s) { comment_ = s; return *this; }
    const SourceLocation& sourceLocation() const { return sourceLocation_; }
    FunctionConfiguration& sourceLocation(const SourceLocation &loc) { sourceLocation_ = loc; return *this; }
    Sawyer::Optional<int64_t> stackDelta() const { return stackDelta_; }
    FunctionConfiguration& stackDelta(const Sawyer::Optional<int64_t> &n) { stackDelta_ = n; return *this; }
    Sawyer::Optional<bool> mayReturn() const { return mayReturn_; }
    FunctionConfiguration& mayReturn(const Sawyer::Optional<bool> &b) { mayReturn_ = b; return *this; }
};

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

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

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

    rose_addr_t address() const { return address_; }

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

class Configuration {
public:
    typedef Sawyer::Container::Map<rose_addr_t, BasicBlockConfiguration> BasicBlockConfigurations;
    typedef Sawyer::Container::Map<rose_addr_t, DataBlockConfiguration> DataBlockConfigurations;
    typedef Sawyer::Container::Map<rose_addr_t, FunctionConfiguration> FunctionConfigurationsByAddress;
    typedef Sawyer::Container::Map<std::string, FunctionConfiguration> FunctionConfigurationsByName;
    typedef Sawyer::Container::Map<rose_addr_t, AddressConfiguration> AddressConfigurations;

private:
    BasicBlockConfigurations bblockConfigurations_;
    DataBlockConfigurations dblockConfigurations_;
    FunctionConfigurationsByAddress functionConfigurationsByAddress_;
    FunctionConfigurationsByName functionConfigurationsByName_;
    AddressConfigurations addressConfigurations_;

public:
    static std::string fileFormatDoc();

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

    const BasicBlockConfigurations& basicBlocks() const { return bblockConfigurations_; }
    BasicBlockConfigurations& basicBlocks() { return bblockConfigurations_; }
    const BasicBlockConfiguration& basicBlock(rose_addr_t) const;

    const DataBlockConfigurations& dataBlocks() const { return dblockConfigurations_; }
    DataBlockConfigurations& dataBlocks() { return dblockConfigurations_; }
    const DataBlockConfiguration& dataBlock(rose_addr_t) const;

    const FunctionConfigurationsByAddress& functionConfigurationsByAddress() const { return functionConfigurationsByAddress_; }
    FunctionConfigurationsByAddress& functionConfigurationsByAddress() { return functionConfigurationsByAddress_; }
    const FunctionConfigurationsByName& functionConfigurationsByName() const { return functionConfigurationsByName_; }
    FunctionConfigurationsByName& functionConfigurationsByName() { return functionConfigurationsByName_; }
    const FunctionConfiguration& function(rose_addr_t) const;
    const FunctionConfiguration& function(const std::string &name) const;
    const AddressConfigurations& addresses() const { return addressConfigurations_; }
    AddressConfigurations& addresses() { return addressConfigurations_; }
    const AddressConfiguration& address(rose_addr_t) const;

    BasicBlockConfiguration& insertMaybeBasicBlock(rose_addr_t va);

    DataBlockConfiguration& insertMaybeDataBlock(rose_addr_t va);

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

    bool insertConfiguration(const BasicBlockConfiguration&);

    bool insertConfiguration(const DataBlockConfiguration&);

    bool insertConfiguration(const FunctionConfiguration&);

    bool insertConfiguration(const AddressConfiguration&);

    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 FunctionPtr&) 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 FunctionPtr&) const;
    Sawyer::Optional<bool> functionMayReturn(rose_addr_t functionVa) const;
    Sawyer::Optional<bool> functionMayReturn(const std::string &functionName) const;
    Sawyer::Optional<bool> functionMayReturn(const FunctionPtr&) 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