src/interface/disassembler.cpp

   1 #include "interface/disassembler.hpp"
   2 #include <stdexcept>
   3 #include <iostream>
   4
   5 namespace
   6 {
   7         template<typename T, bool be> T fetch_generic(std::function<unsigned char()> fetchpc)
   8         {
   9                 size_t b = sizeof(T);
  10                 T res = 0;
  11                 for(size_t i = 0; i < b; i++) {
  12                         size_t bit = 8 * (be ? (b - i - 1) : i);
  13                         res |= (static_cast<T>(fetchpc()) << bit);
  14                 }
  15                 return res;
  16         }
  17 }
  18
  19 disassembler::disassembler(const std::string& _name)
  20 {
  21         disasms()[name = _name] = this;
  22 }
  23
  24 disassembler::~disassembler()
  25 {
  26         disasms().erase(name);
  27 }
  28
  29 disassembler& disassembler::byname(const std::string& name)
  30 {
  31         if(disasms().count(name))
  32                 return *disasms()[name];
  33         throw std::runtime_error("No such disassembler known");
  34 }
  35
  36 std::set<std::string> disassembler::list()
  37 {
  38         std::set<std::string> r;
  39         for(auto& i : disasms())
  40                 r.insert(i.first);
  41         return r;
  42 }
  43
  44 std::map<std::string, disassembler*>& disassembler::disasms()
  45 {
  46         static std::map<std::string, disassembler*> x;
  47         return x;
  48 }
  49
  50 template<> int8_t disassembler::fetch_le(std::function<unsigned char()> fetchpc)
  51 {
  52         return fetch_generic<int8_t, false>(fetchpc);
  53 }
  54
  55 template<> uint8_t disassembler::fetch_le(std::function<unsigned char()> fetchpc)
  56 {
  57         return fetch_generic<uint8_t, false>(fetchpc);
  58 }
  59
  60 template<> int16_t disassembler::fetch_le(std::function<unsigned char()> fetchpc)
  61 {
  62         return fetch_generic<int16_t, false>(fetchpc);
  63 }
  64
  65 template<> uint16_t disassembler::fetch_le(std::function<unsigned char()> fetchpc)
  66 {
  67         return fetch_generic<uint16_t, false>(fetchpc);
  68 }
  69
  70 template<> int32_t disassembler::fetch_le(std::function<unsigned char()> fetchpc)
  71 {
  72         return fetch_generic<int32_t, false>(fetchpc);
  73 }
  74
  75 template<> uint32_t disassembler::fetch_le(std::function<unsigned char()> fetchpc)
  76 {
  77         return fetch_generic<uint32_t, false>(fetchpc);
  78 }
  79
  80 template<> int64_t disassembler::fetch_le(std::function<unsigned char()> fetchpc)
  81 {
  82         return fetch_generic<int64_t, false>(fetchpc);
  83 }
  84
  85 template<> uint64_t disassembler::fetch_le(std::function<unsigned char()> fetchpc)
  86 {
  87         return fetch_generic<uint64_t, false>(fetchpc);
  88 }
  89
  90 template<> int8_t disassembler::fetch_be(std::function<unsigned char()> fetchpc)
  91 {
  92         return fetch_generic<int8_t, true>(fetchpc);
  93 }
  94
  95 template<> uint8_t disassembler::fetch_be(std::function<unsigned char()> fetchpc)
  96 {
  97         return fetch_generic<uint8_t, true>(fetchpc);
  98 }
  99
 100 template<> int16_t disassembler::fetch_be(std::function<unsigned char()> fetchpc)
 101 {
 102         return fetch_generic<int16_t, true>(fetchpc);
 103 }
 104
 105 template<> uint16_t disassembler::fetch_be(std::function<unsigned char()> fetchpc)
 106 {
 107         return fetch_generic<uint16_t, true>(fetchpc);
 108 }
 109
 110 template<> int32_t disassembler::fetch_be(std::function<unsigned char()> fetchpc)
 111 {
 112         return fetch_generic<int32_t, true>(fetchpc);
 113 }
 114
 115 template<> uint32_t disassembler::fetch_be(std::function<unsigned char()> fetchpc)
 116 {
 117         return fetch_generic<uint32_t, true>(fetchpc);
 118 }
 119
 120 template<> int64_t disassembler::fetch_be(std::function<unsigned char()> fetchpc)
 121 {
 122         return fetch_generic<int64_t, true>(fetchpc);
 123 }
 124
 125 template<> uint64_t disassembler::fetch_be(std::function<unsigned char()> fetchpc)
 126 {
 127         return fetch_generic<uint64_t, true>(fetchpc);
 128 }