x64.c

   1 /* architecture-dependent code generation for x86_64 */
   2 #include "tok.h"
   3 #include "gen.h"
   4 #include "out.h"
   5
   6 /* registers */
   7 #define R_RAX           0x00
   8 #define R_RCX           0x01
   9 #define R_RDX           0x02
  10 #define R_RBX           0x03
  11 #define R_RSP           0x04
  12 #define R_RBP           0x05
  13 #define R_RSI           0x06
  14 #define R_RDI           0x07
  15 /* x86_64 registers */
  16 #define R_R8            0x08
  17 #define R_R9            0x09
  18 #define R_R10           0x0a
  19 #define R_R11           0x0b
  20 #define R_R12           0x0c
  21 #define R_R13           0x0d
  22 #define R_R14           0x0e
  23 #define R_R15           0x0f
  24
  25 /* x86 opcodes */
  26 #define I_MOV           0x89
  27 #define I_MOVI          0xc7
  28 #define I_MOVIR         0xb8
  29 #define I_MOVR          0x8b
  30 #define I_MOVSXD        0x63
  31 #define I_SHX           0xd3
  32 #define I_CMP           0x3b
  33 #define I_TST           0x85
  34 #define I_LEA           0x8d
  35 #define I_NOT           0xf7
  36 #define I_CALL          0xff
  37 #define I_MUL           0xf7
  38 #define I_XOR           0x33
  39 #define I_TEST          0x85
  40 #define I_CQO           0x99
  41 #define I_PUSH          0x50
  42 #define I_POP           0x58
  43
  44 #define MIN(a, b)               ((a) < (b) ? (a) : (b))
  45 #define ALIGN(x, a)             (((x) + (a) - 1) & ~((a) - 1))
  46
  47 int tmpregs[] = {0, 7, 6, 2, 1, 8, 9, 10, 11, 3, 12, 13, 14, 15};
  48 int argregs[] = {7, 6, 2, 1, 8, 9};
  49
  50 #define OP2(o2, o1)             (0x010000 | ((o2) << 8) | (o1))
  51 #define O2(op)                  (((op) >> 8) & 0xff)
  52 #define O1(op)                  ((op) & 0xff)
  53 #define MODRM(m, r1, r2)        ((m) << 6 | (r1) << 3 | (r2))
  54 #define REX(r1, r2)             (0x48 | (((r1) & 8) >> 1) | (((r2) & 8) >> 3))
  55
  56 static void putint(char *s, long n, int l)
  57 {
  58         while (l--) {
  59                 *s++ = n;
  60                 n >>= 8;
  61         }
  62 }
  63
  64 static void op_x(int op, int r1, int r2, int bt)
  65 {
  66         int sz = BT_SZ(bt);
  67         int rex = 0;
  68         if (sz == 8)
  69                 rex |= 8;
  70         if (sz == 1)
  71                 rex |= 0x40;
  72         if (r1 & 0x8)
  73                 rex |= 4;
  74         if (r2 & 0x8)
  75                 rex |= 1;
  76         if (sz == 2)
  77                 oi(0x66, 1);
  78         if (rex)
  79                 oi(rex | 0x40, 1);
  80         if (op & 0x10000)
  81                 oi(O2(op), 1);
  82         oi(sz == 1 ? O1(op) & ~0x1 : O1(op), 1);
  83 }
  84
  85 #define op_mr           op_rm
  86
  87 /* op_*(): r=reg, m=mem, i=imm, s=sym */
  88 static void op_rm(int op, int src, int base, int off, int bt)
  89 {
  90         int dis = off == (char) off ? 1 : 4;
  91         int mod = dis == 4 ? 2 : 1;
  92         if (!off && (base & 7) != R_RBP)
  93                 mod = 0;
  94         op_x(op, src, base, bt);
  95         oi(MODRM(mod, src & 0x07, base & 0x07), 1);
  96         if ((base & 7) == R_RSP)
  97                 oi(0x24, 1);
  98         if (mod)
  99                 oi(off, dis);
 100 }
 101
 102 static void op_rr(int op, int src, int dst, int bt)
 103 {
 104         op_x(op, src, dst, bt);
 105         oi(MODRM(3, src & 0x07, dst & 0x07), 1);
 106 }
 107
 108 #define movrx_bt(bt)            (((bt) == 4) ? 4 : LONGSZ)
 109
 110 static int movrx_op(int bt, int mov)
 111 {
 112         int sz = BT_SZ(bt);
 113         if (sz == 4)
 114                 return bt & BT_SIGNED ? I_MOVSXD : mov;
 115         if (sz == 2)
 116                 return OP2(0x0f, bt & BT_SIGNED ? 0xbf : 0xb7);
 117         if (sz == 1)
 118                 return OP2(0x0f, bt & BT_SIGNED ? 0xbe : 0xb6);
 119         return mov;
 120 }
 121
 122 static void mov_r2r(int rd, int r1, unsigned bt)
 123 {
 124         if (rd != r1 || BT_SZ(bt) != LONGSZ)
 125                 op_rr(movrx_op(bt, I_MOVR), rd, r1, movrx_bt(bt));
 126 }
 127
 128 int i_imm(int op, long imm)
 129 {
 130         if ((op & 0xf0) == 0x20)
 131                 return 0;
 132         return imm <= 127 && imm >= -128;
 133 }
 134
 135 static void i_push(int reg)
 136 {
 137         op_x(I_PUSH | (reg & 0x7), 0, reg, LONGSZ);
 138 }
 139
 140 static void i_pop(int reg)
 141 {
 142         op_x(I_POP | (reg & 0x7), 0, reg, LONGSZ);
 143 }
 144
 145 void i_mov(int rd, int rn)
 146 {
 147         op_rr(movrx_op(LONGSZ, I_MOVR), rd, rn, movrx_bt(LONGSZ));
 148 }
 149
 150 void i_load(int rd, int rn, int off, int bt)
 151 {
 152         op_rm(movrx_op(bt, I_MOVR), rd, rn, off, movrx_bt(bt));
 153 }
 154
 155 void i_save(int rd, int rn, int off, int bt)
 156 {
 157         op_rm(I_MOV, rd, rn, off, bt);
 158 }
 159
 160 void i_reg(int op, int *rd, int *r1, int *r2, int *tmp)
 161 {
 162         *rd = 0;
 163         *r1 = R_TMPS;
 164         *r2 = op & O_IMM ? 0 : R_TMPS;
 165         *tmp = 0;
 166         if ((op & 0xf0) == 0x00)        /* add */
 167                 return;
 168         if ((op & 0xf0) == 0x10) {      /* shl */
 169                 if (~op & O_IMM) {
 170                         *r2 = 1 << R_RCX;
 171                         *r1 = R_TMPS & ~*r2;
 172                 }
 173                 return;
 174         }
 175         if ((op & 0xf0) == 0x20) {      /* mul */
 176                 *rd = (op & 0xff) == O_MOD ? (1 << R_RDX) : (1 << R_RAX);
 177                 *r1 = (1 << R_RAX);
 178                 *r2 = R_TMPS & ~*rd & ~*r1;
 179                 if ((op & 0xff) == O_DIV)
 180                         *r2 &= ~(1 << R_RDX);
 181                 *tmp = (1 << R_RDX) | (1 << R_RAX);
 182                 return;
 183         }
 184         if ((op & 0xf0) == 0x30) {      /* cmp */
 185                 *rd = 1 << R_RAX;
 186                 return;
 187         }
 188         if ((op & 0xf0) == 0x40) {      /* uop */
 189                 *r2 = 0;
 190                 if ((op & 0xff) == O_LNOT)
 191                         *r1 = 1 << R_RAX;
 192                 return;
 193         }
 194         if ((op & 0xf0) == 0x50) {      /* etc */
 195                 if (op == O_MSET) {
 196                         *rd = 1 << R_RDI;
 197                         *r1 = 1 << R_RAX;
 198                         *r2 = 1 << R_RCX;
 199                 }
 200                 if (op == O_MCPY) {
 201                         *rd = 1 << R_RDI;
 202                         *r1 = 1 << R_RSI;
 203                         *r2 = 1 << R_RCX;
 204                 }
 205                 if (op == O_SX || op == O_ZX || op == O_MOV) {
 206                         *rd = R_TMPS;
 207                         *r2 = 0;
 208                 }
 209                 return;
 210         }
 211 }
 212
 213 static void i_add(int op, int rd, int r1, int r2)
 214 {
 215         /* opcode for O_ADD, O_SUB, O_AND, O_OR, O_XOR */
 216         static int rx[] = {0003, 0053, 0043, 0013, 0063};
 217         op_rr(rx[op & 0x0f], rd, r2, LONGSZ);
 218 }
 219
 220 static void i_add_imm(int op, int rd, int rn, long n)
 221 {
 222         /* opcode for O_ADD, O_SUB, O_AND, O_OR, O_XOR */
 223         static int rx[] = {0xc0, 0xe8, 0xe0, 0xc8, 0xf0};
 224         unsigned char s[4] = {REX(0, rd), 0x83, rx[op & 0x0f] | (rd & 7), n & 0xff};
 225         os((void *) s, 4);
 226 }
 227
 228 void i_num(int rd, long n)
 229 {
 230         if (!n) {
 231                 op_rr(I_XOR, rd, rd, 4);
 232                 return;
 233         }
 234         if (n < 0 && -n <= 0xffffffff) {
 235                 op_rr(I_MOVI, 0, rd, LONGSZ);
 236                 oi(n, 4);
 237         } else {
 238                 int len = 8;
 239                 if (n > 0 && n <= 0xffffffff)
 240                         len = 4;
 241                 op_x(I_MOVIR + (rd & 7), 0, rd, len);
 242                 oi(n, len);
 243         }
 244 }
 245
 246 static void i_mul(int rd, int r1, int r2)
 247 {
 248         if (r2 != R_RDX)
 249                 i_num(R_RDX, 0);
 250         op_rr(I_MUL, 4, r2, LONGSZ);
 251 }
 252
 253 static void i_div(int op, int rd, int r1, int r2)
 254 {
 255         if (r2 != R_RDX) {
 256                 if (op & O_SIGNED)
 257                         op_x(I_CQO, R_RAX, R_RDX, LONGSZ);
 258                 else
 259                         i_num(R_RDX, 0);
 260         }
 261         op_rr(I_MUL, op & O_SIGNED ? 7 : 6, r2, LONGSZ);
 262 }
 263
 264 static void i_tst(int rn, int rm)
 265 {
 266         op_rr(I_TST, rn, rm, LONGSZ);
 267 }
 268
 269 static void i_cmp(int rn, int rm)
 270 {
 271         op_rr(I_CMP, rn, rm, LONGSZ);
 272 }
 273
 274 static void i_cmp_imm(int rn, long n)
 275 {
 276         unsigned char s[4] = {REX(0, rn), 0x83, 0xf8 | rn, n & 0xff};
 277         os(s, 4);
 278 }
 279
 280 static void i_shl(int op, int rd, int r1, int rs)
 281 {
 282         int sm = 4;
 283         if ((op & 0x0f) == 1)
 284                 sm = op & O_SIGNED ? 7 : 5;
 285         op_rr(I_SHX, sm, rd, LONGSZ);
 286 }
 287
 288 static void i_shl_imm(int op, int rd, int rn, long n)
 289 {
 290         int sm = (op & 0x1) ? (op & O_SIGNED ? 0xf8 : 0xe8) : 0xe0 ;
 291         char s[4] = {REX(0, rn), 0xc1, sm | (rn & 7), n & 0xff};
 292         os(s, 4);
 293 }
 294
 295 void i_sym(int rd, char *sym, int off)
 296 {
 297         int sz = X64_ABS_RL & OUT_RL32 ? 4 : LONGSZ;
 298         if (X64_ABS_RL & OUT_RLSX)
 299                 op_rr(I_MOVI, 0, rd, sz);
 300         else
 301                 op_x(I_MOVIR + (rd & 7), 0, rd, sz);
 302         if (!pass1)
 303                 out_rel(sym, OUT_CS | X64_ABS_RL, cslen);
 304         oi(off, sz);
 305 }
 306
 307 static void i_neg(int rd)
 308 {
 309         op_rr(I_NOT, 3, rd, LONGSZ);
 310 }
 311
 312 static void i_not(int rd)
 313 {
 314         op_rr(I_NOT, 2, rd, LONGSZ);
 315 }
 316
 317 /* for optimizing cmp + tst + jmp to cmp + jmp */
 318 #define OPT_ISCMP()             (last_set >= 0 && last_set + 7 == cslen)
 319 #define OPT_CCOND()             (cs[last_set + 1])
 320
 321 static long last_set = -1;
 322
 323 static void i_set(int op, int rd)
 324 {
 325         /* lt, gt, le, ge, eq, neq */
 326         static int ucond[] = {0x92, 0x97, 0x96, 0x93, 0x94, 0x95};
 327         static int scond[] = {0x9c, 0x9f, 0x9e, 0x9d, 0x94, 0x95};
 328         int cond = op & O_SIGNED ? scond[op & 0x0f] : ucond[op & 0x0f];
 329         char set[] = "\x0f\x00\xc0";
 330         set[1] = cond;
 331         last_set = cslen;
 332         os(set, 3);                     /* setl al */
 333         os("\x48\x0f\xb6\xc0", 4);      /* movzx rax, al */
 334 }
 335
 336 static void i_lnot(int rd)
 337 {
 338         if (OPT_ISCMP()) {
 339                 cs[last_set + 1] ^= 0x01;
 340         } else {
 341                 char cmp[] = "\x00\x83\xf8\x00";
 342                 cmp[0] = REX(0, rd);
 343                 cmp[2] |= rd & 7;
 344                 os(cmp, 4);             /* cmp rax, 0 */
 345                 i_set(O_EQ, rd);
 346         }
 347 }
 348
 349 static void jx(int x, int nbytes)
 350 {
 351         char op[2] = {0x0f};
 352         if (nbytes == 1) {
 353                 op[0] = 0x70 | (x & 0x0f);
 354                 os(op, 1);              /* jx $addr */
 355         } else {
 356                 op[1] = x;
 357                 os(op, 2);              /* jx $addr */
 358         }
 359         oi(0, nbytes);
 360 }
 361
 362 void i_jmp(int rn, int z, int nbytes)
 363 {
 364         if (!nbytes)
 365                 return;
 366         if (nbytes > 1)
 367                 nbytes = 4;
 368         if (rn >= 0) {
 369                 if (OPT_ISCMP()) {
 370                         int cond = OPT_CCOND();
 371                         cslen = last_set;
 372                         jx((!z ? cond : cond ^ 0x01) & ~0x10, nbytes);
 373                         last_set = -1;
 374                 } else {
 375                         i_tst(rn, rn);
 376                         jx(z ? 0x84 : 0x85, nbytes);
 377                 }
 378         } else {
 379                 os(nbytes == 1 ? "\xeb" : "\xe9", 1);           /* jmp $addr */
 380                 oi(0, nbytes);
 381         }
 382 }
 383
 384 long i_fill(long src, long dst, int nbytes)
 385 {
 386         if (!nbytes)
 387                 return 0;
 388         if (nbytes > 1)
 389                 nbytes = 4;
 390         putint((void *) (cs + src - nbytes), dst - src, nbytes);
 391         return dst - src;
 392 }
 393
 394 static void i_zx(int rd, int r1, int bits)
 395 {
 396         if (bits & 0x07) {
 397                 i_shl_imm(O_SHL, rd, rd, LONGSZ * 8 - bits);
 398                 i_shl_imm(O_SHR, rd, rd, LONGSZ * 8 - bits);
 399         } else {
 400                 mov_r2r(rd, r1, bits >> 3);
 401         }
 402 }
 403
 404 static void i_sx(int rd, int r1, int bits)
 405 {
 406         mov_r2r(rd, r1, BT_SIGNED | (bits >> 3));
 407 }
 408
 409 void i_op(int op, int rd, int r1, int r2)
 410 {
 411         if ((op & 0xf0) == 0x00)
 412                 i_add(op, r1, r1, r2);
 413         if ((op & 0xf0) == 0x10)
 414                 i_shl(op, r1, r1, r2);
 415         if ((op & 0xf0) == 0x20) {
 416                 if ((op & 0xff) == O_MUL)
 417                         i_mul(R_RAX, r1, r2);
 418                 if ((op & 0xff) == O_DIV)
 419                         i_div(op, R_RAX, r1, r2);
 420                 if ((op & 0xff) == O_MOD)
 421                         i_div(op, R_RDX, r1, r2);
 422                 return;
 423         }
 424         if ((op & 0xf0) == 0x30) {
 425                 i_cmp(r1, r2);
 426                 i_set(op, rd);
 427                 return;
 428         }
 429         if ((op & 0xf0) == 0x40) {      /* uop */
 430                 if ((op & 0xff) == O_NEG)
 431                         i_neg(r1);
 432                 if ((op & 0xff) == O_NOT)
 433                         i_not(r1);
 434                 if ((op & 0xff) == O_LNOT)
 435                         i_lnot(r1);
 436                 return;
 437         }
 438 }
 439
 440 static void i_add_anyimm(int rd, int rn, long n)
 441 {
 442         op_rm(I_LEA, rd, rn, n, LONGSZ);
 443 }
 444
 445 void i_op_imm(int op, int rd, int r1, long n)
 446 {
 447         if ((op & 0xf0) == 0x00) {      /* add */
 448                 if (rd == r1 && i_imm(O_ADD, n))
 449                         i_add_imm(op, rd, r1, n);
 450                 else
 451                         i_add_anyimm(rd, r1, n);
 452         }
 453         if ((op & 0xf0) == 0x10)        /* shl */
 454                 i_shl_imm(op, rd, r1, n);
 455         if ((op & 0xf0) == 0x20)        /* mul */
 456                 die("mul/imm not implemented");
 457         if ((op & 0xf0) == 0x30) {      /* cmp */
 458                 i_cmp_imm(r1, n);
 459                 i_set(op, rd);
 460         }
 461         if ((op & 0xf0) == 0x50) {      /* etc */
 462                 if ((op & 0xff) == O_ZX)
 463                         i_zx(rd, r1, n);
 464                 if ((op & 0xff) == O_SX)
 465                         i_sx(rd, r1, n);
 466                 if ((op & 0xff) == O_MOV)
 467                         i_mov(rd, r1);
 468         }
 469 }
 470
 471 void i_memcpy(int r0, int r1, int r2)
 472 {
 473         os("\xfc\xf3\xa4", 3);          /* cld; rep movs */
 474 }
 475
 476 void i_memset(int r0, int r1, int r2)
 477 {
 478         os("\xfc\xf3\xaa", 3);          /* cld; rep stosb */
 479 }
 480
 481 void i_call_reg(int rd)
 482 {
 483         op_rr(I_CALL, 2, rd, LONGSZ);
 484 }
 485
 486 void i_call(char *sym, int off)
 487 {
 488         os("\xe8", 1);          /* call $x */
 489         if (!pass1)
 490                 out_rel(sym, OUT_CS | OUT_RLREL, cslen);
 491         oi(-4 + off, 4);
 492 }
 493
 494 static int func_argc;
 495 static int func_varg;
 496 static int func_spsub;
 497 static int func_sargs;
 498 static int func_sregs;
 499 static int func_initfp;
 500 static int spsub_addr;
 501
 502 int i_args(void)
 503 {
 504         return 16;
 505 }
 506
 507 int i_sp(void)
 508 {
 509         int i;
 510         int n = 0;
 511         for (i = 0; i < N_TMPS; i++)
 512                 if ((1 << tmpregs[i]) & func_sregs)
 513                         n += 8;
 514         return -n;
 515 }
 516
 517 static void i_saveargs(void)
 518 {
 519         int i;
 520         os("\x58", 1);          /* pop rax */
 521         for (i = N_ARGS - 1; i >= 0; i--)
 522                 if ((1 << argregs[i]) & func_sargs)
 523                         i_push(argregs[i]);
 524         os("\x50", 1);          /* push rax */
 525 }
 526
 527 void i_prolog(int argc, int varg, int sargs, int sregs, int initfp, int subsp)
 528 {
 529         int i;
 530         last_set = -1;
 531         func_argc = argc;
 532         func_varg = varg;
 533         func_sargs = sargs;
 534         func_sregs = sregs;
 535         func_initfp = initfp;
 536         func_spsub = subsp;
 537         if (func_sargs)
 538                 i_saveargs();
 539         if (initfp) {
 540                 os("\x55", 1);                  /* push rbp */
 541                 os("\x48\x89\xe5", 3);          /* mov rbp, rsp */
 542         }
 543         if (func_sregs) {
 544                 for (i = N_TMPS - 1; i >= 0; i--)
 545                         if ((1 << tmpregs[i]) & func_sregs)
 546                                 i_push(tmpregs[i]);
 547         }
 548         if (func_spsub) {
 549                 os("\x48\x81\xec", 3);          /* sub rsp, $xxx */
 550                 spsub_addr = cslen;
 551                 oi(0, 4);
 552         }
 553 }
 554
 555 void i_epilog(int sp_max)
 556 {
 557         int diff;
 558         int nsregs = 0;
 559         int nsargs = 0;
 560         int i;
 561         for (i = 0; i < N_TMPS; i++)
 562                 if ((1 << tmpregs[i]) & func_sregs)
 563                         nsregs++;
 564         for (i = 0; i < N_ARGS; i++)
 565                 if ((1 << argregs[i]) & func_sargs)
 566                         nsargs++;
 567         diff = ALIGN(-sp_max - nsregs * LONGSZ, 16);
 568         /* forcing 16-byte alignment */
 569         diff = (nsregs + nsargs) & 1 ? diff + LONGSZ : diff;
 570         if (func_spsub && diff) {
 571                 i_add_anyimm(R_RSP, R_RBP, -nsregs * LONGSZ);
 572                 putint(cs + spsub_addr, diff, 4);
 573         }
 574         if (func_sregs) {
 575                 for (i = 0; i < N_TMPS; i++)
 576                         if ((1 << tmpregs[i]) & func_sregs)
 577                                 i_pop(tmpregs[i]);
 578         }
 579         if (func_initfp)
 580                 os("\xc9", 1);          /* leave */
 581         if (func_sargs) {
 582                 os("\xc2", 1);          /* ret n */
 583                 oi(nsargs * LONGSZ, 2);
 584         } else {
 585                 os("\xc3", 1);          /* ret */
 586         }
 587 }
 588
 589 void i_done(void)
 590 {
 591 }