CodeInserter.h

#ifndef ROSE_BinaryAnalysis_CodeInserter_H
#define ROSE_BinaryAnalysis_CodeInserter_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS

#include <Rose/BinaryAnalysis/Partitioner2/BasicTypes.h>
#include <Sawyer/Map.h>

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 *insn)
            : originalVa(insn->get_address()) {}
    };

    typedef Sawyer::Container::Map<int, InstructionInfo> InstructionInfoMap;

protected:
    Partitioner2::PartitionerConstPtr partitioner_;     // not null
    AddressInterval chunkAllocationRegion_;             // where chunks can be allocated
    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 Diagnostics::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& 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