BinaryCodeInserter.h

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

#include <Partitioner2/Partitioner.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:
    const Rose::BinaryAnalysis::Partitioner2::Partitioner &partitioner_;
    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 Rose::BinaryAnalysis::Partitioner2::Partitioner &partitioner)
        : partitioner_(partitioner), minChunkAllocationSize_(8192), chunkAllocationAlignment_(4096),
          chunkAllocationName_("new code"), aggregationDirection_(AGGREGATE_PREDECESSORS | AGGREGATE_SUCCESSORS),
          nopPadding_(PAD_NOP_BACK) {
        ASSERT_not_null(partitioner.memoryMap());
        if (!partitioner.memoryMap()->isEmpty() &&
            partitioner.memoryMap()->hull().greatest() < AddressInterval::whole().greatest()) {
            chunkAllocationRegion_ = AddressInterval::hull(partitioner.memoryMap()->hull().greatest() + 1,
                                                           AddressInterval::whole().greatest());
        } else {
            chunkAllocationRegion_ = AddressInterval::whole();
        }
    }

    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 Rose::BinaryAnalysis::Partitioner2::BasicBlock::Ptr&,
                                          size_t startIdx, size_t nInsns, std::vector<uint8_t> replacement,
                                          const std::vector<Relocation> &relocations = std::vector<Relocation>());

    bool replaceInsnsAtFront(const Rose::BinaryAnalysis::Partitioner2::BasicBlock::Ptr &bb, size_t nInsns,
                             const std::vector<uint8_t> &replacement,
                             const std::vector<Relocation> &relocations = std::vector<Relocation>()) {
        return replaceBlockInsns(bb, 0, nInsns, replacement, relocations);
    }

    virtual bool replaceInsnsAtBack(const Rose::BinaryAnalysis::Partitioner2::BasicBlock::Ptr &bb, size_t nInsns,
                                    const std::vector<uint8_t> &replacement,
                                    const std::vector<Relocation> &relocations = std::vector<Relocation>()) {
        ASSERT_require(nInsns <= bb->nInstructions());
        return replaceBlockInsns(bb, bb->nInstructions()-nInsns, nInsns, replacement, relocations);
    }

    virtual bool prependInsns(const Rose::BinaryAnalysis::Partitioner2::BasicBlock::Ptr &bb,
                              const std::vector<uint8_t> &replacement,
                              const std::vector<Relocation> &relocations = std::vector<Relocation>()) {
        return replaceInsnsAtFront(bb, 0, replacement, relocations);
    }

    virtual bool appendInsns(const Rose::BinaryAnalysis::Partitioner2::BasicBlock::Ptr &bb,
                             const std::vector<uint8_t> &replacement,
                             const std::vector<Relocation> &relocations = std::vector<Relocation>()) {
        return replaceInsnsAtBack(bb, 0, replacement, relocations);
    }

    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 Rose::BinaryAnalysis::Partitioner2::BasicBlock::Ptr&,
                                                 size_t startIdx, size_t nDeleted);
};

} // namespace
} // namespace

#endif
#endif