MemoryTable.h

#ifndef ROSE_BinaryAnalysis_Partitioner2_MemoryTable_H
#define ROSE_BinaryAnalysis_Partitioner2_MemoryTable_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
#include <Rose/BinaryAnalysis/Partitioner2/BasicTypes.h>
 
#include <Rose/BinaryAnalysis/MemoryMap.h>
#include <Rose/Constants.h>
 
namespace Rose {
namespace BinaryAnalysis {
namespace Partitioner2 {
 
class MemoryTable {
public:
    using Ptr = MemoryTablePtr;
    using ConstPtr = MemoryTableConstPtr;
    class Entries {
    public:
        using Ptr = std::shared_ptr<Entries>;
 
        virtual ~Entries();
        Entries();
 
        bool empty() const;
 
        virtual size_t size() const = 0;
 
        virtual bool maybeAppend(const MemoryTable*, Address entryAddr, const std::vector<uint8_t> &bytes) = 0;
 
        virtual bool maybePrepend(const MemoryTable*, Address entryAddr, const std::vector<uint8_t> &bytes) = 0;
    };
    class Entries {…};
 
    class Storage {
    public:
        using Ptr = std::shared_ptr<Storage>;
 
        virtual ~Storage() {};
 
        virtual std::vector<uint8_t> read(Address, size_t nBytes) = 0;
    };
    class Storage {…};
 
private:
    AddressInterval tableLimits_;                       // limits for where the table could exist
    size_t bytesPerEntry_ = 4;                          // number of bytes in each table entry
    size_t maxSkippable_ = 0;                           // max invalid entries before reaching start of table
    size_t maxPreEntries_ = UNLIMITED;                  // max number of entries prior to initial start of table
 
    // After parsing
    Entries::Ptr entries_;                              // entries parsed for the table
    AddressInterval tableLocation_;                     // where the table actually exists
    size_t nPreEntries_ = 0;                            // entries before the original table start address
 
public:
    virtual ~MemoryTable();
protected:
    MemoryTable(const AddressInterval&, size_t bytesPerEntry, const Entries::Ptr &entries);
public:
    static Ptr instance(const AddressInterval &tableLimits, size_t bytesPerEntry, const Entries::Ptr &entries);
 
public:
    size_t maxInitialSkip() const;
    void maxInitialSkip(size_t);
    size_t maxPreEntries() const;
    void maxPreEntries(size_t);
    AddressInterval tableLimits() const;
    void tableLimits(const AddressInterval&);
    size_t bytesPerEntry() const;
 
    Entries::Ptr entries() const;
 
public:
    AddressInterval scan(const MemoryMap::Constraints&, Address probableTableAddr);
    AddressInterval scan(const PartitionerConstPtr&, const InstructionSemantics::BaseSemantics::RiscOperatorsPtr&,
                         Address probableTableAddr);
    AddressInterval scan(const Storage::Ptr&, Address probableTableAddr);
    AddressInterval location() const;
 
    bool empty() const;
 
    size_t nEntries() const;
 
    size_t nPreEntries() const;
};
class MemoryTable {…};
 
} // namespace
} // namespace
} // namespace
 
#endif
#endif