CodeInserter.h

#ifndef ROSE_BinaryAnalysis_CodeInserter_H
#define ROSE_BinaryAnalysis_CodeInserter_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
 
#include <Rose/BinaryAnalysis/AddressIntervalSet.h>
#include <Rose/BinaryAnalysis/Partitioner2/BasicTypes.h>
 
#include <Sawyer/Map.h>
#include <Sawyer/Message.h>
 
class SgAsmInstruction;
 
namespace Rose {
namespace BinaryAnalysis {
 
namespace Commit {
enum Boolean {
    NO,                                                 
    YES                                                 
};
} // namespace
 
class CodeInserter {
public:
    enum AggregationDirection {
        AGGREGATE_PREDECESSORS  = 0x00000001,           
        AGGREGATE_SUCCESSORS    = 0x00000002            
    };
 
    enum NopPadding {
        PAD_NOP_BACK,                                   
        PAD_NOP_FRONT,                                  
        PAD_RANDOM_BACK                                 
    };
 
    enum RelocType {
        RELOC_INDEX_ABS_LE32,                           
        RELOC_INDEX_ABS_LE32HI,                         
        RELOC_INDEX_ABS_BE32,                           
        RELOC_ADDR_REL_LE32,                            
        RELOC_ADDR_REL_BE32,                            
        RELOC_INSN_ABS_LE32,                            
        RELOC_INSN_REL_LE32,                            
        RELOC_INSN_REL_BE32                             
    };
 
    struct Relocation {
        size_t offset;                                  
        RelocType type;                                 
        rose_addr_t value;                              
        Relocation(size_t offset, RelocType type, rose_addr_t value)
            : offset(offset), type(type), value(value) {}
    };
 
    struct InstructionInfo {
        rose_addr_t originalVa;                         
        Sawyer::Optional<rose_addr_t> newVaOffset;      
        explicit InstructionInfo(SgAsmInstruction*);
    };
 
    typedef Sawyer::Container::Map<int, InstructionInfo> InstructionInfoMap;
 
protected:
    Partitioner2::PartitionerConstPtr partitioner_;     // not null
    AddressInterval chunkAllocationRegion_;             // restricts addresses where new free-space chunks can be mapped
    size_t minChunkAllocationSize_;                     // size of each chunk in bytes (also the alignment)
    size_t chunkAllocationAlignment_;                   // alignment for allocating large chunks
    std::string chunkAllocationName_;                   // name to give new areas of the memory map
    AddressIntervalSet allocatedChunks_;                // large allocated chunks that populate freeSpace_
    AddressIntervalSet freeSpace_;                      // parts of mapped memory serving as free space for allocations
    unsigned aggregationDirection_;                     // AggregationDirection bits
    NopPadding nopPadding_;                             // where to add no-op padding
 
public:
    static Sawyer::Message::Facility mlog;
 
public:
    explicit CodeInserter(const Partitioner2::PartitionerConstPtr&);
    ~CodeInserter();
 
    static void initDiagnostics();
 
    const AddressInterval& chunkAllocationRegion() const { return chunkAllocationRegion_; }
    void chunkAllocationRegion(const AddressInterval& i) { chunkAllocationRegion_ = i; }
    const AddressIntervalSet& mappedFreeSpace() const { return freeSpace_; }
    AddressIntervalSet& mappedFreeSpace() { return freeSpace_; }
    void mappedFreeSpace(const AddressIntervalSet &x) { freeSpace_ = x; }
    const AddressIntervalSet& allocatedChunks() const { return allocatedChunks_; }
 
    size_t minChunkAllocationSize() const { return minChunkAllocationSize_; }
    void minChunkAllocationSize(size_t n) { minChunkAllocationSize_ = n; }
    size_t chunkAllocationAlignment() const { return chunkAllocationAlignment_; }
    void chunkAllocationAlignment(size_t n);
    const std::string& chunkAllocationName() const { return chunkAllocationName_; }
    void chunkAllocationName(const std::string &s) { chunkAllocationName_ = s; }
    unsigned aggregationDirection() const { return aggregationDirection_; }
    void aggregationDirection(unsigned d) { aggregationDirection_ = d; }
    NopPadding nopPadding() const { return nopPadding_; }
    void nopPadding(NopPadding p) { nopPadding_ = p; }
    virtual bool replaceBlockInsns(const Partitioner2::BasicBlockPtr&,
                                   size_t startIdx, size_t nInsns, std::vector<uint8_t> replacement,
                                   const std::vector<Relocation> &relocations = std::vector<Relocation>());
 
    bool replaceInsnsAtFront(const Partitioner2::BasicBlockPtr&, size_t nInsns, const std::vector<uint8_t> &replacement,
                             const std::vector<Relocation> &relocations = std::vector<Relocation>());
 
    virtual bool replaceInsnsAtBack(const Partitioner2::BasicBlockPtr&, size_t nInsns, const std::vector<uint8_t> &replacement,
                                    const std::vector<Relocation> &relocations = std::vector<Relocation>());
 
    virtual bool prependInsns(const Partitioner2::BasicBlockPtr&, const std::vector<uint8_t> &replacement,
                              const std::vector<Relocation> &relocations = std::vector<Relocation>());
 
    virtual bool appendInsns(const Partitioner2::BasicBlockPtr&, const std::vector<uint8_t> &replacement,
                             const std::vector<Relocation> &relocations = std::vector<Relocation>());
 
    virtual bool replaceInsns(const std::vector<SgAsmInstruction*> &toReplace, const std::vector<uint8_t> &replacement,
                              const std::vector<Relocation> &relocations = std::vector<Relocation>());
 
    virtual void fillWithNops(const AddressIntervalSet &where);
 
    virtual void fillWithRandom(const AddressIntervalSet &where);
 
    virtual std::vector<uint8_t> encodeJump(rose_addr_t srcVa, rose_addr_t tgtVa);
 
    virtual std::vector<uint8_t> applyRelocations(rose_addr_t startVa, std::vector<uint8_t> replacement,
                                                  const std::vector<Relocation> &relocations, size_t relocStart,
                                                  const InstructionInfoMap &insnInfoMap);
 
    virtual AddressInterval allocateMemory(size_t nBytes, rose_addr_t jmpTargetVa, Commit::Boolean commit = Commit::YES);
 
    void commitAllocation(const AddressInterval &where, Commit::Boolean commit = Commit::YES);
 
    AddressIntervalSet instructionLocations(const std::vector<SgAsmInstruction*>&);
 
    virtual bool replaceByOverwrite(const AddressIntervalSet &toReplaceVas, const AddressInterval &entryInterval,
                                    const std::vector<uint8_t> &replacement, const std::vector<Relocation> &relocations,
                                    size_t relocStart, const InstructionInfoMap &insnInfoMap);
 
    virtual bool replaceByTransfer(const AddressIntervalSet &toReplaceVas, const AddressInterval &entryInterval,
                                   const std::vector<SgAsmInstruction*> &toReplace, const std::vector<uint8_t> &replacement,
                                   const std::vector<Relocation> &relocations, size_t relocStart,
                                   const InstructionInfoMap &insnInfoMap);
 
    InstructionInfoMap computeInstructionInfoMap(const Partitioner2::BasicBlockPtr&,
                                                 size_t startIdx, size_t nDeleted);
};
 
} // namespace
} // namespace
 
#endif
#endif