JumpTable.h

#ifndef ROSE_BinaryAnalysis_Partitioner2_JumpTable_H
#define ROSE_BinaryAnalysis_Partitioner2_JumpTable_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
#include <Rose/BinaryAnalysis/Partitioner2/MemoryTable.h>
 
namespace Rose {
namespace BinaryAnalysis {
namespace Partitioner2 {
 
class JumpTable: public MemoryTable {
public:
    using Ptr = JumpTablePtr;
    using ConstPtr = JumpTableConstPtr;
    enum class EntryType {
        ABSOLUTE,                                       
        TABLE_RELATIVE                                  
    };
    enum class EntryType {…};
 
    class Entries: public MemoryTable::Entries {
    public:
        using Ptr = std::shared_ptr<Entries>;
 
    private:
        std::vector<Address> targets_;
 
    protected:
        Entries();
    public:
        static Ptr instance();
 
    public:
        const std::vector<Address>& targets() const;
 
    public:
        size_t size() const override;
        bool maybeAppend(const MemoryTable*, Address entryAddr, const std::vector<uint8_t> &bytes) override;
        bool maybePrepend(const MemoryTable*, Address entryAddr, const std::vector<uint8_t> &bytes) override;
 
    private:
        // Parse a jump table entry and return the potential target address
        Address parseEntry(const JumpTable*, const std::vector<uint8_t> &bytes) const;
 
        // Test whether a potential target address is valid
        bool isValidTarget(const JumpTable*, Address target) const;
    };
    class Entries: public MemoryTable::Entries {…};
 
private:
    PartitionerConstPtr partitioner_;
    Address perEntryOffset_ = 0;
    EntryType entryType_ = EntryType::ABSOLUTE;
    AddressInterval targetLimits_;
 
protected:
    JumpTable(const PartitionerConstPtr&, const AddressInterval &tableLimits, size_t bytesPerEntry,
              Address perEntryOffset, EntryType);
public:
    static Ptr
    instance(const PartitionerConstPtr&, const AddressInterval &tableLimits, size_t bytesPerEntry,
             Address perEntryOffset, EntryType);
 
public:
    PartitionerConstPtr partitioner() const;
 
    Address perEntryOffset() const;
 
    EntryType entryType() const;
 
    AddressInterval targetLimits() const;
    void targetLimits(const AddressInterval&);
public:
    const std::vector<Address>& targets() const;
 
    std::set<Address> uniqueTargets() const;
 
public:
    void refineLocationLimits(const BasicBlockPtr&, Address probableTableAddr);
 
    void refineTargetLimits(const BasicBlockPtr&);
 
    void replaceBasicBlockSuccessors(const PartitionerConstPtr&, const BasicBlockPtr&) const;
 
    DataBlockPtr createDataBlock() const;
 
    void attachTableToBasicBlock(const BasicBlockPtr&) const;
};
class JumpTable: public MemoryTable {…};
 
} // namespace
} // namespace
} // namespace
 
#endif
#endif