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