FlatBuffers.h

#ifndef ROSE_BinaryAnalysis_Serialization_FlatBuffers_H
#define ROSE_BinaryAnalysis_Serialization_FlatBuffers_H
 
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
#ifdef ROSE_ENABLE_FLATBUFFERS
 
#include <Rose/BinaryAnalysis/Architecture/BasicTypes.h>
#include <Rose/BinaryAnalysis/MemoryMap.h>
#include <Rose/BinaryAnalysis/Partitioner2/BasicBlock.h>
#include <Rose/BinaryAnalysis/Partitioner2/BasicTypes.h>
#include <Rose/BinaryAnalysis/Partitioner2/Partitioner.h>
 
#include <rosePublicConfig.h>
 
#include <boost/filesystem/path.hpp>
 
#include <cstddef>
#include <cstdint>
#include <iosfwd>
#include <utility>
#include <vector>
 
#include <flatbuffers/flatbuffers.h>
 
#include <Rose/BinaryAnalysis/Serialization/FlatBufferSchema.h>
 
namespace Rose {
namespace BinaryAnalysis {
namespace Serialization {
 
namespace P2 = Rose::BinaryAnalysis::Partitioner2;
 
namespace FlatBuffers {
 
static constexpr uint32_t version = 1;
 
class Serializer {
  public:
    explicit Serializer(const P2::PartitionerConstPtr&);
    ~Serializer() = default;
 
    Serializer(const Serializer&)            = delete;
    Serializer& operator=(const Serializer&) = delete;
 
    template <typename T> using Handle = flatbuffers::Offset<T>;
 
    void save();
 
    std::pair<const uint8_t*, size_t> buffer() const;
 
    void write(std::ostream&) const;
 
    void write(const boost::filesystem::path&) const;
 
  private:
    P2::PartitionerConstPtr                         partitioner_;
    std::vector<char>                               bytes_;
    std::unique_ptr<flatbuffers::FlatBufferBuilder> builder_;
 
  protected:
    Handle<Architecture> architecture(const BinaryAnalysis::Architecture::BaseConstPtr& arch);
    Handle<Instruction>  instruction(const SgAsmInstruction* const& insn);
    Handle<BasicBlock>   basicBlock(const P2::BasicBlockPtr& bb);
    Handle<Function>     function(const P2::FunctionPtr& f);
    Handle<CfgEdge>      cfgEdge(const P2::ControlFlowGraph::Edge& e);
    Handle<Cfg>          cfg(const P2::ControlFlowGraph& cfg);
    Handle<Segment>      segment(const BinaryAnalysis::MemoryMap::Super::Node& seg);
    Handle<MemoryMap>    mmap(const BinaryAnalysis::MemoryMap& map);
    std::pair<Handle<InstructionList>, Handle<BasicBlockList>>
                         instructionsBasicBlocks(const std::vector<P2::BasicBlockPtr>& bbs);
    Handle<FunctionList> functions(const std::vector<P2::FunctionPtr>& funs);
    Handle<Root>         partitioner(/*partitioner_*/);
};
 
class Deserializer {
  public:
    Deserializer() = default;
 
    static Deserializer fromFile(const boost::filesystem::path&);
 
    static Deserializer fromStream(std::istream&);
 
    static Deserializer fromBytes(std::vector<char>&&);
 
    static Deserializer fromBytes(const std::vector<char>&);
 
    bool verify() const;
 
    void preferStoredBytes(bool prefer) { preferStoredBytes_ = prefer; }
 
    P2::PartitionerPtr load(const P2::BasePartitionerSettings& settings);
    // Load with default settings (useful in testing)
    P2::PartitionerPtr load();
 
  private:
    // Underlying bytes
    std::vector<char> bytes_;
 
    // Current partitioner
    P2::PartitionerPtr partitioner_;
 
    // Index ROSE instructions and basic blocks by start address.
    // This is needed because generally FlatBuffer structures use addresses as lightweight references.
    // For example, FlatBuffer basic blocks save their constituent instructions as a list of addresses.
    // We use external explicit maps (instead of the partitioner) so that the Deserializer can create detached
    // partitioner objects.
    std::unordered_map<Address, SgAsmInstruction*>   instructions_;
    std::unordered_map<Address, P2::BasicBlock::Ptr> basic_blocks_;
 
    bool preferStoredBytes_ = false;
 
    BinaryAnalysis::MemoryMap::Ptr mmap(const MemoryMap* map) const;
 
    SgAsmInstruction* disassembleFromBytes(Address addr, const flatbuffers::Vector<uint8_t>* bytes) const;
 
    // The instruction method makes no assumptions other than that the input pointer is non-null.
    void instruction(const Instruction* const& instr);
    // The basicBlock method assumes that all instructions have been discovered and that instructions_ is up-to-date.
    void basicBlock(const BasicBlock* const& bb);
    // The function method assumes that all basic blocks have been discovered and that basic_blocks_ is up-to-date.
    void function(const Function* const& fun);
    // The cfg method assumes that all functions and basic blocks have been discovered and that basic_blocks_ is
    // up-to-date.
    void cfg(const Cfg* const& cfg);
};
 
} // namespace FlatBuffers
} // namespace Serialization
} // namespace BinaryAnalysis
} // namespace Rose
 
#endif
#endif
#endif