x86.c

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