src/library/assembler-intrinsics-i386.cpp

   1 #include "assembler-intrinsics-i386.hpp"
   2 #include "serialization.hpp"
   3 #include <stdexcept>
   4
   5 namespace assembler_intrinsics
   6 {
   7         const I386::reg I386::reg_none(255);
   8         const I386::reg I386::reg_ax(0);
   9         const I386::reg I386::reg_bx(3);
  10         const I386::reg I386::reg_cx(1);
  11         const I386::reg I386::reg_dx(2);
  12         const I386::reg I386::reg_bp(5);
  13         const I386::reg I386::reg_sp(4);
  14         const I386::reg I386::reg_si(6);
  15         const I386::reg I386::reg_di(7);
  16         const I386::reg I386::reg_r8(8);
  17         const I386::reg I386::reg_r9(9);
  18         const I386::reg I386::reg_r10(10);
  19         const I386::reg I386::reg_r11(11);
  20         const I386::reg I386::reg_r12(12);
  21         const I386::reg I386::reg_r13(13);
  22         const I386::reg I386::reg_r14(14);
  23         const I386::reg I386::reg_r15(15);
  24         const I386::reg I386::reg_rip(254);
  25
  26         const I386::reg i386_r0(0);
  27         const I386::reg i386_r1(1);
  28         const I386::reg i386_r2(2);
  29         const I386::reg i386_r3(3);
  30         const I386::reg i386_r4(4);
  31         const I386::reg i386_r5(5);
  32         const I386::reg i386_r6(6);
  33         const I386::reg i386_r7(7);
  34
  35         I386::reg::reg(uint8_t _val)
  36         {
  37                 val = _val;
  38         }
  39
  40         I386::ref I386::reg::operator[](int32_t off) const
  41         {
  42                 if(val < 16)
  43                         return ref::reg_off(*this, off);
  44                 else if(val == 254)
  45                         return I386::ref::rip_off(off);
  46                 else
  47                         throw std::runtime_error("Bad register offset-base");
  48         }
  49
  50         I386::sib_scale_intermediate I386::reg::operator*(uint8_t scale) const
  51         {
  52                 return sib_scale_intermediate(*this, scale);
  53         }
  54
  55         I386::ref I386::reg::operator[](const reg r) const
  56         {
  57                 return ref::sib(*this, r, 1);
  58         }
  59
  60         I386::ref I386::reg::operator[](sib_scale_intermediate r) const
  61         {
  62                 return ref::sib(*this, r.index, r.scale);
  63         }
  64
  65         I386::ref I386::reg::operator[](sib_scale_off_intermediate r) const
  66         {
  67                 return ref::sib(*this, r.index, r.scale, r.offset);
  68         }
  69
  70         I386::sib_scale_off_intermediate I386::reg::operator+(int32_t off) const
  71         {
  72                 return sib_scale_off_intermediate(*this, 1, off);
  73         }
  74
  75         bool I386::reg::hbit() { return (val & 8); }
  76         uint8_t I386::reg::lbits() { return val & 7; }
  77         uint8_t I386::reg::num() { return val & 15; }
  78         bool I386::reg::valid(bool amd64) { return (val < (amd64 ? 16 : 8)); }
  79         bool I386::reg::is_none() { return (val == 255); }
  80
  81         I386::sib_scale_off_intermediate::sib_scale_off_intermediate(reg _idx, uint8_t _scale, int32_t _offset)
  82                 : index(_idx), scale(_scale), offset(_offset)
  83         {
  84         }
  85
  86         I386::sib_scale_intermediate::sib_scale_intermediate(reg _idx, uint8_t _scale)
  87                 : index(_idx), scale(_scale)
  88         {
  89         }
  90
  91         I386::sib_scale_off_intermediate I386::sib_scale_intermediate::operator+(int32_t off) const
  92         {
  93                 return sib_scale_off_intermediate(index, scale, off);
  94         }
  95
  96
  97         void check_register(I386::reg r, bool amd64)
  98         {
  99                 if(!r.valid(amd64))
 100                         throw std::runtime_error("Illegal register");
 101         }
 102
 103         void I386::label(assembler::label& l)
 104         {
 105                 a._label(l);
 106         }
 107
 108         I386::low::low(bool _need_amd64, uint8_t _rex_prefix, std::vector<uint8_t> _ref)
 109                 : needs_amd64(_need_amd64), rex(_rex_prefix), mref(_ref)
 110         {
 111                 if(rex) needs_amd64 = true;
 112         }
 113         bool I386::low::need_amd64() { return needs_amd64; }
 114         bool I386::low::has_rex() { return (rex != 0); }
 115         uint8_t I386::low::rex_prefix() { return rex; }
 116         std::vector<uint8_t> I386::low::bytes() { return mref; }
 117
 118         void I386::low::emit_rex(assembler::assembler& a)
 119         {
 120                 if(has_rex()) a(rex);
 121         }
 122
 123         void I386::low::emit_bytes(assembler::assembler& a)
 124         {
 125                 for(auto i : mref) a(i);
 126         }
 127
 128         I386::ref::ref()
 129         {
 130         }
 131
 132         I386::ref::ref(reg r)
 133         {
 134                 if(!r.valid(true))
 135                         throw std::runtime_error("Illegal register");
 136                 needs_amd64 = r.hbit();
 137                 rex = r.hbit() ? 1 : 0;
 138                 mref.push_back(0xC0 + r.lbits());
 139         }
 140
 141         I386::ref::ref(sib_scale_intermediate r)
 142         {
 143                 *this = sib(reg_none, r.index, r.scale);
 144         }
 145
 146         I386::ref::ref(sib_scale_off_intermediate r)
 147         {
 148                 *this = sib(reg_none, r.index, r.scale, r.offset);
 149         }
 150
 151         I386::ref I386::ref::reg_off(reg r, int32_t off)
 152         {
 153                 if(!r.valid(true))
 154                         throw std::runtime_error("Illegal register");
 155                 bool need_off = (off != 0);
 156                 bool need_loff = (off < -128 || off > 127);
 157                 I386::ref x;
 158                 x.needs_amd64 = r.hbit();
 159                 x.rex = r.hbit() ? 1 : 0;
 160                 if(r.lbits() == 5)
 161                         need_off = true;        //EBP and R13 always need offset.
 162                 uint8_t rtype = need_loff ? 2 : (need_off ? 1 : 0);
 163                 if(r.lbits() == 4) {
 164                         //SIB is required for these.
 165                         x.mref.push_back(0x04 + rtype * 0x40);
 166                         x.mref.push_back(0x24);
 167                 } else {
 168                         x.mref.push_back(r.lbits() + rtype * 0x40);
 169                 }
 170                 size_t bytes = x.mref.size();
 171                 if(need_loff) {
 172                         x.mref.resize(bytes + 4);
 173                         serialization::s32l(&x.mref[bytes], off);
 174                 } else if(need_off) {
 175                         x.mref.resize(bytes + 1);
 176                         serialization::s8l(&x.mref[bytes], off);
 177                 }
 178                 return x;
 179         }
 180
 181         I386::ref I386::ref::rip_off(int32_t off)
 182         {
 183                 I386::ref x;
 184                 x.needs_amd64 = true;
 185                 x.mref.resize(5);
 186                 x.mref[0] = 0x05;
 187                 serialization::s32l(&x.mref[1], off);
 188                 x.rex = 0;
 189                 return x;
 190         }
 191
 192         I386::ref I386::ref::sib(reg base, reg index, uint8_t scale, int32_t off)
 193         {
 194                 I386::ref x;
 195                 if(!base.is_none() && !base.valid(true))
 196                         throw std::runtime_error("Illegal base in SIB");
 197                 if((!index.is_none() && !index.valid(true)) || index.num() == 4)
 198                         throw std::runtime_error("Illegal index in SIB");
 199                 uint8_t ss = 0;
 200                 switch(scale) {
 201                 case 1: ss = 0; break;
 202                 case 2: ss = 1; break;
 203                 case 4: ss = 2; break;
 204                 case 8: ss = 3; break;
 205                 default: throw std::runtime_error("Illegal scale in SIB");
 206                 };
 207
 208                 bool need_off = (off != 0);
 209                 bool need_loff = (off < -128 || off > 127);
 210                 if(base.is_none()) {
 211                         //Base is the offset.
 212                         x.mref.push_back(0x04);                         //SIB coming, no offset
 213                         x.mref.push_back(ss * 64 + index.lbits() + 5);  //Base is "EBP".
 214                         need_loff = true;
 215                 } else {
 216                         if(base.num() == 5)
 217                                 need_off = true;        //This always needs offset.
 218                         uint8_t rtype = need_loff ? 2 : (need_off ? 1 : 0);
 219                         x.mref.push_back(0x04 + rtype * 0x40);          //SIB coming.
 220                         x.mref.push_back(ss * 64 + index.lbits() * 8 + base.lbits());
 221                 }
 222                 x.rex = 0;
 223                 if(!base.is_none()) x.rex |= (base.hbit() ? 1 : 0);
 224                 if(!index.is_none()) x.rex |= (index.hbit() ? 2 : 0);
 225                 x.needs_amd64 = (x.rex != 0);
 226                 size_t bytes = x.mref.size();
 227                 if(need_loff) {
 228                         x.mref.resize(bytes + 4);
 229                         serialization::s32l(&x.mref[bytes], off);
 230                 } else if(need_off) {
 231                         x.mref.resize(bytes + 1);
 232                         serialization::s8l(&x.mref[bytes], off);
 233                 }
 234                 return x;
 235         }
 236
 237         I386::low I386::ref::operator()(reg r, bool set_size_flag, bool amd64)
 238         {
 239                 check_register(r, amd64);
 240                 auto c = mref;
 241                 c[0] |= r.lbits() * 8;
 242                 uint8_t _rex = rex;
 243                 if(r.hbit()) _rex+=4;                   //Set R
 244                 if(set_size_flag && amd64) _rex+=8;     //Set S if needed.
 245                 if(_rex) _rex+=0x40;                    //Ret rex prefix bits.
 246                 if((_rex || needs_amd64) && !amd64)
 247                         throw std::runtime_error("Illegal memory reference for i386");
 248                 return low(needs_amd64, _rex, c);
 249         }
 250
 251         void I386::ref::emit(assembler::assembler& a, bool set_size_flag, bool amd64, reg r, uint8_t op1)
 252         {
 253                 auto xref = (*this)(r, set_size_flag, amd64);
 254                 xref.emit_rex(a);
 255                 a(op1);
 256                 xref.emit_bytes(a);
 257         }
 258
 259         void I386::ref::emit(assembler::assembler& a, bool set_size_flag, bool amd64, reg r, uint8_t op1,
 260                 uint8_t op2)
 261         {
 262                 auto xref = (*this)(r, set_size_flag, amd64);
 263                 xref.emit_rex(a);
 264                 a(op1, op2);
 265                 xref.emit_bytes(a);
 266         }
 267
 268         I386::I386(assembler::assembler& _a, bool _amd64)
 269                 : a(_a), amd64(_amd64)
 270         {
 271         }
 272
 273         bool I386::is_amd64()
 274         {
 275                 return amd64;
 276         }
 277
 278         //Is i386?
 279         bool I386::is_i386()
 280         {
 281                 return !amd64;
 282         }
 283
 284         //Get word size.
 285         uint8_t I386::wordsize()
 286         {
 287                 return amd64 ? 8 : 4;
 288         }
 289
 290         //PUSH NWORD <reg>
 291         void I386::push_reg(reg r)
 292         {
 293                 check_register(r, amd64);
 294                 if(amd64 && r.hbit()) a(0x41);
 295                 a(0x50 + r.lbits());
 296         }
 297         //POP NWORD <reg>
 298         void I386::pop_reg(reg r)
 299         {
 300                 check_register(r, amd64);
 301                 if(amd64 && r.hbit()) a(0x41);
 302                 a(0x58 + r.lbits());
 303         }
 304         //MOV NWORD <reg>,<regmem>
 305         void I386::mov_reg_regmem(reg r, I386::ref mem)
 306         {
 307                 mem.emit(a, true, amd64, r, 0x8B);
 308         }
 309         //XOR NWORD <reg>,<regmem>
 310         void I386::xor_reg_regmem(reg r, I386::ref mem)
 311         {
 312                 mem.emit(a, true, amd64, r, 0x33);
 313         }
 314
 315         //LEA <reg>,<mem>
 316         void I386::lea_reg_mem(reg r, I386::ref mem)
 317         {
 318                 mem.emit(a, true, amd64, r, 0x8D);
 319         }
 320
 321         //AND NWORD <regmem>, imm
 322         void I386::and_regmem_imm(I386::ref mem, int32_t imm)
 323         {
 324                 mem.emit(a, true, amd64, i386_r4, 0x81);
 325                 a(assembler::vle<int32_t>(imm));
 326         }
 327
 328         //SHL NWORD <regmem>, imm
 329         void I386::shl_regmem_imm(I386::ref mem, uint8_t imm)
 330         {
 331                 mem.emit(a, true, amd64, i386_r4, 0xC1);
 332                 a(imm);
 333         }
 334
 335         //SHL BYTE <regmem>, imm
 336         void I386::shl_regmem_imm8(ref mem, uint8_t imm)
 337         {
 338                 mem.emit(a, true, amd64, i386_r4, 0xC0);
 339                 a(imm);
 340         }
 341
 342         //ADD NWORD <regmem>, imm
 343         void I386::add_regmem_imm(I386::ref mem, int32_t imm)
 344         {
 345                 mem.emit(a, true, amd64, i386_r0, 0x81);
 346                 a(assembler::vle<int32_t>(imm));
 347         }
 348
 349         //ADD NWORD <reg>,<regmem>
 350         void I386::add_reg_regmem(reg r, I386::ref mem)
 351         {
 352                 mem.emit(a, true, amd64, r, 0x03);
 353         }
 354
 355         //MOV BYTE <regmem>, imm
 356         void I386::mov_regmem_imm8(I386::ref mem, uint8_t imm)
 357         {
 358                 mem.emit(a, false, amd64, i386_r0, 0xC6);
 359                 a(imm);
 360         }
 361
 362         //MOV DWORD <regmem>, imm
 363         void I386::mov_regmem_imm32(I386::ref mem, uint32_t imm)
 364         {
 365                 mem.emit(a, false, amd64, i386_r0, 0xC7);
 366                 a(assembler::vle<uint32_t>(imm));
 367         }
 368
 369         //MOV NWORD <reg>, imm.
 370         void I386::mov_reg_imm(reg r, size_t imm)
 371         {
 372                 check_register(r, amd64);
 373                 if(amd64) a(0x48 | (r.hbit() ? 1 : 0));
 374                 a(0xB8 + r.lbits());
 375                 a(assembler::vle<size_t>(imm));
 376         }
 377
 378         //CMP NWORD <regmem>, imm
 379         void I386::cmp_regmem_imm(I386::ref mem, int32_t imm)
 380         {
 381                 mem.emit(a, true, amd64, i386_r7, 0x81);
 382                 a(assembler::vle<int32_t>(imm));
 383         }
 384
 385         //MOV WORD <regmem>, <reg>
 386         void I386::mov_regmem_reg16(I386::ref mem, reg r)
 387         {
 388                 a(0x66);
 389                 mem.emit(a, false, amd64, r, 0x89);
 390         }
 391
 392         //MOV BYTE <regmem>, <reg>
 393         void I386::mov_regmem_reg8(ref mem, reg r)
 394         {
 395                 mem.emit(a, false, amd64, r, 0x88);
 396         }
 397
 398         //MOV WORD <reg>, <regmem>
 399         void I386::mov_reg_regmem16(reg r, I386::ref mem)
 400         {
 401                 a(0x66);
 402                 mem.emit(a, false, amd64, r, 0x8B);
 403         }
 404
 405         //MOV BYTE <reg>, <regmem>
 406         void I386::mov_reg_regmem8(reg r, ref mem)
 407         {
 408                 mem.emit(a, false, amd64, r, 0x8A);
 409         }
 410
 411         //OR BYTE <regmem>, imm
 412         void I386::or_regmem_imm8(I386::ref mem, uint8_t imm)
 413         {
 414                 mem.emit(a, false, amd64, i386_r1, 0x80);
 415                 a(imm);
 416         }
 417
 418         //AND BYTE <regmem>, imm
 419         void I386::and_regmem_imm8(I386::ref mem, uint8_t imm)
 420         {
 421                 mem.emit(a, false, amd64, i386_r4, 0x80);
 422                 a(imm);
 423         }
 424
 425         //INC NWORD <regmem>
 426         void I386::inc_regmem(I386::ref mem)
 427         {
 428                 mem.emit(a, true, amd64, i386_r0, 0xFF);
 429         }
 430
 431         //TEST BYTE <regmem>, imm
 432         void I386::test_regmem_imm8(I386::ref mem, uint8_t imm)
 433         {
 434                 mem.emit(a, false, amd64, i386_r0, 0xF6);
 435                 a(imm);
 436         }
 437
 438         //CMP BYTE <regmem>, imm
 439         void I386::cmp_regmem_imm8(I386::ref mem, uint8_t imm)
 440         {
 441                 mem.emit(a, false, amd64, i386_r7, 0x80);
 442                 a(imm);
 443         }
 444
 445         //MOV NWORD <reg>, <addr>.
 446         void I386::mov_reg_addr(reg r, assembler::label& l)
 447         {
 448                 if(amd64) a(0x48 + (r.hbit() ? 1 : 0));
 449                 a(0xB8 + r.lbits());
 450                 address(l);
 451         }
 452
 453         //NEG BYTE <regmem>
 454         void I386::neg_regmem8(ref mem)
 455         {
 456                 mem.emit(a, false, amd64, i386_r3, 0xF6);
 457         }
 458
 459         //ADD BYTE <regmem>, imm
 460         void I386::add_regmem_imm8(ref mem, uint8_t imm)
 461         {
 462                 mem.emit(a, false, amd64, i386_r0, 0x80);
 463                 a(imm);
 464         }
 465
 466         //OR BYTE <regmem>, <reg>
 467         void I386::or_regmem_reg8(ref mem, reg r)
 468         {
 469                 mem.emit(a, false, amd64, r, 0x08);
 470         }
 471
 472         //CALL <addr>
 473         void I386::call_addr(assembler::label& l)
 474         {
 475                 if(amd64) {
 476                         call_regmem(reg_rip[2]);
 477                         a(0xEB, 0x08);  //JMP +8
 478                         address(l);
 479                 } else {
 480                         a(0xE8, assembler::relocation_tag(assembler::i386_reloc_rel32, l), assembler::pad_tag(4));
 481                 }
 482         }
 483
 484         //CALL <regmem>
 485         void I386::call_regmem(I386::ref mem)
 486         {
 487                 mem.emit(a, false, amd64, i386_r2, 0xFF);
 488         }
 489
 490         //JMP <regmem>
 491         void I386::jmp_regmem(I386::ref mem)
 492         {
 493                 mem.emit(a, false, amd64, i386_r4, 0xFF);
 494         }
 495
 496         //SETNZ <regmem>
 497         void I386::setnz_regmem(I386::ref mem)
 498         {
 499                 mem.emit(a, false, amd64, i386_r0, 0x0F, 0x95);
 500         }
 501
 502         //JNZ SHORT <label>
 503         void I386::jnz_short(assembler::label& l)
 504         {
 505                 a(0x75, assembler::relocation_tag(assembler::i386_reloc_rel8, l), 0x00);
 506         }
 507
 508         //JZ SHORT <label>
 509         void I386::jz_short(assembler::label& l)
 510         {
 511                 a(0x74, assembler::relocation_tag(assembler::i386_reloc_rel8, l), 0x00);
 512         }
 513
 514         //JMP SHORT <label>
 515         void I386::jmp_short(assembler::label& l)
 516         {
 517                 a(0xEB, assembler::relocation_tag(assembler::i386_reloc_rel8, l), 0x00);
 518         }
 519
 520         //JMP LONG <label>
 521         void I386::jmp_long(assembler::label& l)
 522         {
 523                 a(0xE9, assembler::relocation_tag(assembler::i386_reloc_rel32, l), assembler::pad_tag(4));
 524         }
 525
 526         //JZ LONG <label>
 527         void I386::jz_long(assembler::label& l)
 528         {
 529                 a(0x0F, 0x84, assembler::relocation_tag(assembler::i386_reloc_rel32, l), assembler::pad_tag(4));
 530         }
 531
 532         //JAE SHORT <label>
 533         void I386::jae_short(assembler::label& l)
 534         {
 535                 a(0x73, assembler::relocation_tag(assembler::i386_reloc_rel8, l), 0x00);
 536         }
 537
 538         //JAE LONG <label>
 539         void I386::jae_long(assembler::label& l)
 540         {
 541                 a(0x0F, 0x83, assembler::relocation_tag(assembler::i386_reloc_rel32, l), assembler::pad_tag(4));
 542         }
 543
 544         void I386::ret()
 545         {
 546                 a(0xC3);
 547         }
 548
 549         void I386::address(assembler::label& l)
 550         {
 551                 a(assembler::relocation_tag((amd64 ? assembler::i386_reloc_abs64 : assembler::i386_reloc_abs32), l),
 552                         assembler::pad_tag(wordsize()));
 553         }
 554 }