src/library/assembler.cpp

   1 #include "assembler.hpp"
   2 #include "serialization.hpp"
   3 #include <cstring>
   4 #include <iostream>
   5 #if !defined(_WIN32) && !defined(_WIN64)
   6 #define _USE_BSD
   7 #include <unistd.h>
   8 #include <sys/mman.h>
   9 #else
  10 #include <windows.h>
  11 #endif
  12
  13 #ifndef MAP_ANONYMOUS
  14 #ifdef MAP_ANON
  15 #define MAP_ANONYMOUS MAP_ANON
  16 #endif
  17 #endif
  18
  19 namespace assembler
  20 {
  21 assembler::assembler()
  22 {
  23 }
  24
  25 void assembler::_label(label& l)
  26 {
  27         l.set(data.size());
  28 }
  29
  30 void assembler::_label(label& l, const std::string& globalname)
  31 {
  32         l.set(data.size());
  33         globals[globalname] = &l;
  34 }
  35
  36 void assembler::byte(uint8_t b)
  37 {
  38         data.push_back(b);
  39 }
  40
  41 void assembler::byte(std::initializer_list<uint8_t> b)
  42 {
  43         for(auto i : b)
  44                 data.push_back(i);
  45 }
  46
  47 void assembler::byte(const uint8_t* b, size_t l)
  48 {
  49         for(size_t i = 0; i < l; i++)
  50                 data.push_back(b[i]);
  51 }
  52
  53 void assembler::relocation(std::function<void(uint8_t* location, size_t target, size_t source)> promise,
  54         const label& target)
  55 {
  56         reloc r;
  57         r.promise = promise;
  58         r.target = &target;
  59         r.source = data.size();
  60         relocs.push_back(r);
  61 }
  62
  63 void assembler::align(size_t multiple)
  64 {
  65         if(!multiple)
  66                 return;
  67         while(data.size() % multiple)
  68                 data.push_back(0);
  69 }
  70
  71 void assembler::pad(size_t amount)
  72 {
  73         for(size_t i = 0; i < amount; i++)
  74                 data.push_back(0);
  75 }
  76
  77 size_t assembler::size()
  78 {
  79         return data.size();
  80 }
  81
  82 std::map<std::string, void*> assembler::flush(void* base)
  83 {
  84         memcpy(base, &data[0], data.size());
  85         for(auto i : relocs) {
  86                 i.promise((uint8_t*)base + i.source, i.target->resolve((addr_t)base), (addr_t)base + i.source);
  87         }
  88         std::map<std::string, void*> ret;
  89         for(auto i : globals) {
  90                 ret[i.first] = reinterpret_cast<void*>(i.second->resolve((addr_t)base));
  91         }
  92         return ret;
  93 }
  94
  95 void i386_reloc_rel8(uint8_t* location, size_t target, size_t source)
  96 {
  97         int8_t d = target - source - 1;
  98         if(source + d + 1 != target) {
  99                 std::cerr << "Out-of-range offset: " << d << std::endl;
 100                 throw std::runtime_error("Relative reference (8-bit) out of range");
 101         }
 102         write8sle(location, d);
 103 }
 104
 105 void i386_reloc_rel16(uint8_t* location, size_t target, size_t source)
 106 {
 107         int16_t d = target - source - 2;
 108         if(source + d + 2 != target) {
 109                 std::cerr << "Out-of-range offset: " << d << std::endl;
 110                 throw std::runtime_error("Relative reference (16-bit) out of range");
 111         }
 112         write32sle(location, d);
 113 }
 114
 115 void i386_reloc_rel32(uint8_t* location, size_t target, size_t source)
 116 {
 117         int32_t d = target - source - 4;
 118         if(source + d + 4 != target) {
 119                 std::cerr << "Out-of-range offset: " << d << std::endl;
 120                 throw std::runtime_error("Relative reference (32-bit) out of range");
 121         }
 122         write32sle(location, d);
 123 }
 124
 125 void i386_reloc_abs32(uint8_t* location, size_t target, size_t source)
 126 {
 127         if(target > 0xFFFFFFFFU)
 128                 throw std::runtime_error("Absolute reference out of range");
 129         write32ule(location, target);
 130 }
 131
 132 void i386_reloc_abs64(uint8_t* location, size_t target, size_t source)
 133 {
 134         write64ule(location, target);
 135 }
 136
 137 uint8_t i386_modrm(uint8_t reg, uint8_t mod, uint8_t rm)
 138 {
 139         return (mod & 3) * 64 + (reg & 7) * 8 + (rm & 7);
 140 }
 141
 142 uint8_t i386_sib(uint8_t base, uint8_t index, uint8_t scale)
 143 {
 144         return (scale & 3) * 64 + (index & 7) * 8 + (base & 7);
 145 }
 146
 147
 148 dynamic_code::dynamic_code(size_t size)
 149 {
 150 #if !defined(_WIN32) && !defined(_WIN64)
 151         asize = (size + getpagesize() - 1) / getpagesize() * getpagesize();
 152         base = (uint8_t*)mmap(NULL, asize, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
 153         if(base == MAP_FAILED)
 154                 throw std::runtime_error("Failed to allocate memory for routine");
 155 #else
 156         asize = (size + 4095) >> 12 << 12;  //Windows is always i386/amd64, right?
 157         base = VirtualAlloc(NULL, asize, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
 158         if(!base)
 159                 throw std::runtime_error("Failed to allocate memory for routine");
 160 #endif
 161 }
 162
 163 dynamic_code::~dynamic_code()
 164 {
 165 #if !defined(_WIN32) && !defined(_WIN64)
 166         munmap(base, asize);
 167 #else
 168         VirtualFree(base, 0, MEM_RELEASE);
 169 #endif
 170 }
 171
 172 void dynamic_code::commit()
 173 {
 174 #if !defined(_WIN32) && !defined(_WIN64)
 175         if(mprotect(base, asize, PROT_READ | PROT_EXEC) < 0)
 176                 throw std::runtime_error("Failed to mark routine as executable");
 177 #else
 178         long unsigned dummy;
 179         if(!VirtualProtect(base, asize, PAGE_EXECUTE_READ, &dummy))
 180                 throw std::runtime_error("Failed to mark routine as executable");
 181 #endif
 182 }
 183
 184 uint8_t* dynamic_code::pointer() throw()
 185 {
 186         return reinterpret_cast<uint8_t*>(base);
 187 }
 188
 189 }
 190