i386-gen.c

   1 /******************************************************/
   2 /* X86 code generator */
   3
   4
   5 /* number of available registers */
   6 #define NB_REGS             4
   7
   8 #define NB_REG_CLASSES      2
   9
  10 /* a register can belong to several classes */
  11 #define REG_CLASS_INT    0x0001
  12 #define REG_CLASS_FLOAT  0x0002
  13
  14 /* pretty names for the registers */
  15 enum {
  16     REG_EAX = 0,
  17     REG_ECX,
  18     REG_EDX,
  19     REG_ST0,
  20 };
  21
  22 int reg_classes[NB_REGS] = {
  23     REG_CLASS_INT,    /* eax */
  24     REG_CLASS_INT,    /* ecx */
  25     REG_CLASS_INT,    /* edx */
  26     REG_CLASS_FLOAT,  /* st0 */
  27 };
  28
  29 /* integer return register for functions */
  30 #define FUNC_RET_REG        0
  31 /* float return register for functions */
  32 #define FUNC_RET_FREG       3
  33
  34 /* defined if function parameters must be evaluated in reverse order */
  35 #define INVERT_FUNC_PARAMS
  36
  37 /* defined if structures are passed as pointers. Otherwise structures
  38    are directly pushed on stack. */
  39 //#define FUNC_STRUCT_PARAM_AS_PTR
  40
  41 /* function call context */
  42 typedef struct GFuncContext {
  43     int args_size;
  44 } GFuncContext;
  45
  46 /******************************************************/
  47
  48 void g(int c)
  49 {
  50     *(char *)ind++ = c;
  51 }
  52
  53 void o(int c)
  54 {
  55     while (c) {
  56         g(c);
  57         c = c / 256;
  58     }
  59 }
  60
  61 void gen_le32(int c)
  62 {
  63     g(c);
  64     g(c >> 8);
  65     g(c >> 16);
  66     g(c >> 24);
  67 }
  68
  69 /* add a new relocation entry to symbol 's' */
  70 void greloc(Sym *s, int addr, int type)
  71 {
  72     Reloc *p;
  73     p = malloc(sizeof(Reloc));
  74     if (!p)
  75         error("memory full");
  76     p->type = type;
  77     p->addr = addr;
  78     p->next = (Reloc *)s->c;
  79     s->c = (int)p;
  80 }
  81
  82 /* patch each relocation entry with value 'val' */
  83 void greloc_patch(Sym *s, int val)
  84 {
  85     Reloc *p, *p1;
  86
  87     p = (Reloc *)s->c;
  88     while (p != NULL) {
  89         p1 = p->next;
  90         switch(p->type) {
  91         case RELOC_ADDR32:
  92             *(int *)p->addr = val;
  93             break;
  94         case RELOC_REL32:
  95             *(int *)p->addr = val - p->addr - 4;
  96             break;
  97         }
  98         free(p);
  99         p = p1;
 100     }
 101     s->c = val;
 102     s->t &= ~VT_FORWARD;
 103 }
 104
 105 /* output a symbol and patch all calls to it */
 106 void gsym_addr(t, a)
 107 {
 108     int n;
 109     while (t) {
 110         n = *(int *)t; /* next value */
 111         *(int *)t = a - t - 4;
 112         t = n;
 113     }
 114 }
 115
 116 void gsym(t)
 117 {
 118     gsym_addr(t, ind);
 119 }
 120
 121 /* psym is used to put an instruction with a data field which is a
 122    reference to a symbol. It is in fact the same as oad ! */
 123 #define psym oad
 124
 125 /* instruction + 4 bytes data. Return the address of the data */
 126 int oad(int c, int s)
 127 {
 128     o(c);
 129     *(int *)ind = s;
 130     s = ind;
 131     ind = ind + 4;
 132     return s;
 133 }
 134
 135 /* output constant with relocation if 't & VT_FORWARD' is true */
 136 void gen_addr32(int c, int t)
 137 {
 138     if (!(t & VT_FORWARD)) {
 139         gen_le32(c);
 140     } else {
 141         greloc((Sym *)c, ind, RELOC_ADDR32);
 142         gen_le32(0);
 143     }
 144 }
 145
 146 /* XXX: generate correct pointer for forward references to functions */
 147 /* r = (ft, fc) */
 148 void load(int r, int ft, int fc)
 149 {
 150     int v, t;
 151
 152     v = ft & VT_VALMASK;
 153     if (ft & VT_LVAL) {
 154         if (v == VT_LLOCAL) {
 155             load(r, VT_LOCAL | VT_LVAL, fc);
 156             v = r;
 157         }
 158         if ((ft & VT_BTYPE) == VT_FLOAT) {
 159             o(0xd9); /* flds */
 160             r = 0;
 161         } else if ((ft & VT_BTYPE) == VT_DOUBLE) {
 162             o(0xdd); /* fldl */
 163             r = 0;
 164         } else if ((ft & VT_TYPE) == VT_BYTE)
 165             o(0xbe0f);   /* movsbl */
 166         else if ((ft & VT_TYPE) == (VT_BYTE | VT_UNSIGNED))
 167             o(0xb60f);   /* movzbl */
 168         else if ((ft & VT_TYPE) == VT_SHORT)
 169             o(0xbf0f);   /* movswl */
 170         else if ((ft & VT_TYPE) == (VT_SHORT | VT_UNSIGNED))
 171             o(0xb70f);   /* movzwl */
 172         else
 173             o(0x8b);     /* movl */
 174
 175         if (v == VT_CONST) {
 176             o(0x05 + r * 8); /* 0xXX, r */
 177             gen_addr32(fc, ft);
 178         } else if (v == VT_LOCAL) {
 179             oad(0x85 + r * 8, fc); /* xx(%ebp), r */
 180         } else {
 181             g(0x00 + r * 8 + v); /* (v), r */
 182         }
 183     } else {
 184         if (v == VT_CONST) {
 185             o(0xb8 + r); /* mov $xx, r */
 186             gen_addr32(fc, ft);
 187         } else if (v == VT_LOCAL) {
 188             o(0x8d);
 189             oad(0x85 + r * 8, fc); /* lea xxx(%ebp), r */
 190         } else if (v == VT_CMP) {
 191             oad(0xb8 + r, 0); /* mov $0, r */
 192             o(0x0f); /* setxx %br */
 193             o(fc);
 194             o(0xc0 + r);
 195         } else if (v == VT_JMP || v == VT_JMPI) {
 196             t = v & 1;
 197             oad(0xb8 + r, t); /* mov $1, r */
 198             oad(0xe9, 5); /* jmp after */
 199             gsym(fc);
 200             oad(0xb8 + r, t ^ 1); /* mov $0, r */
 201         } else if (v != r) {
 202             o(0x89);
 203             o(0xc0 + r + v * 8); /* mov v, r */
 204         }
 205     }
 206 }
 207
 208 /* (ft, fc) = r */
 209 /* WARNING: r must not be allocated on the stack */
 210 void store(r, ft, fc)
 211 {
 212     int fr, bt;
 213
 214     fr = ft & VT_VALMASK;
 215     bt = ft & VT_BTYPE;
 216     /* XXX: incorrect if reg to reg */
 217     if (bt == VT_FLOAT) {
 218         o(0xd9); /* fstps */
 219         r = 3;
 220     } else if (bt == VT_DOUBLE) {
 221         o(0xdd); /* fstpl */
 222         r = 3;
 223     } else {
 224         if (bt == VT_SHORT)
 225             o(0x66);
 226         if (bt == VT_BYTE)
 227             o(0x88);
 228         else
 229             o(0x89);
 230     }
 231     if (fr == VT_CONST) {
 232         o(0x05 + r * 8); /* mov r,xxx */
 233         gen_addr32(fc, ft);
 234     } else if (fr == VT_LOCAL) {
 235         oad(0x85 + r * 8, fc); /* mov r,xxx(%ebp) */
 236     } else if (ft & VT_LVAL) {
 237         g(fr + r * 8); /* mov r, (fr) */
 238     } else if (fr != r) {
 239         o(0xc0 + fr + r * 8); /* mov r, fr */
 240     }
 241 }
 242
 243 /* start function call and return function call context */
 244 void gfunc_start(GFuncContext *c)
 245 {
 246     c->args_size = 0;
 247 }
 248
 249 /* push function parameter which is in (vt, vc) */
 250 void gfunc_param(GFuncContext *c)
 251 {
 252     int size, align, ft, fc, r;
 253
 254     if ((vt & (VT_BTYPE | VT_LVAL)) == (VT_STRUCT | VT_LVAL)) {
 255         size = type_size(vt, &align);
 256         /* align to stack align size */
 257         size = (size + 3) & ~3;
 258         /* allocate the necessary size on stack */
 259         oad(0xec81, size); /* sub $xxx, %esp */
 260         /* generate structure store */
 261         r = get_reg(REG_CLASS_INT);
 262         o(0x89); /* mov %esp, r */
 263         o(0xe0 + r);
 264         ft = vt;
 265         fc = vc;
 266         vset(VT_INT | r, 0);
 267         vpush();
 268         vt = ft;
 269         vc = fc;
 270         vstore();
 271         c->args_size += size;
 272     } else if ((vt & VT_BTYPE) == VT_DOUBLE ||
 273                (vt & VT_BTYPE) == VT_FLOAT) {
 274         gv(); /* only one float register */
 275         if ((vt & VT_BTYPE) == VT_FLOAT)
 276             size = 4;
 277         else
 278             size = 8;
 279         oad(0xec81, size); /* sub $xxx, %esp */
 280         o(0x245cd9 + size - 4); /* fstp[s|l] 0(%esp) */
 281         g(0x00);
 282         c->args_size += 8;
 283     } else {
 284         /* simple type (currently always same size) */
 285         /* XXX: implicit cast ? */
 286         r = gv();
 287         o(0x50 + r); /* push r */
 288         c->args_size += 4;
 289     }
 290 }
 291
 292 /* generate function call with address in (vt, vc) and free function
 293    context */
 294 void gfunc_call(GFuncContext *c)
 295 {
 296     int r;
 297     if ((vt & (VT_VALMASK | VT_LVAL)) == VT_CONST) {
 298         /* constant case */
 299         /* forward reference */
 300         if (vt & VT_FORWARD) {
 301             greloc((Sym *)vc, ind + 1, RELOC_REL32);
 302             oad(0xe8, 0);
 303         } else {
 304             oad(0xe8, vc - ind - 5);
 305         }
 306     } else {
 307         /* otherwise, indirect call */
 308         r = gv();
 309         o(0xff); /* call *r */
 310         o(0xd0 + r);
 311     }
 312     if (c->args_size)
 313         oad(0xc481, c->args_size); /* add $xxx, %esp */
 314 }
 315
 316 int gjmp(int t)
 317 {
 318     return psym(0xe9, t);
 319 }
 320
 321 /* generate a test. set 'inv' to invert test */
 322 int gtst(int inv, int t)
 323 {
 324     int v, *p;
 325     v = vt & VT_VALMASK;
 326     if (v == VT_CMP) {
 327         /* fast case : can jump directly since flags are set */
 328         g(0x0f);
 329         t = psym((vc - 16) ^ inv, t);
 330     } else if (v == VT_JMP || v == VT_JMPI) {
 331         /* && or || optimization */
 332         if ((v & 1) == inv) {
 333             /* insert vc jump list in t */
 334             p = &vc;
 335             while (*p != 0)
 336                 p = (int *)*p;
 337             *p = t;
 338             t = vc;
 339         } else {
 340             t = gjmp(t);
 341             gsym(vc);
 342         }
 343     } else if ((vt & (VT_VALMASK | VT_LVAL)) == VT_CONST) {
 344         /* constant jmp optimization */
 345         if ((vc != 0) != inv)
 346             t = gjmp(t);
 347     } else {
 348         v = gv();
 349         o(0x85);
 350         o(0xc0 + v * 9);
 351         g(0x0f);
 352         t = psym(0x85 ^ inv, t);
 353     }
 354     return t;
 355 }
 356
 357 /* generate an integer binary operation 'v = r op fr' instruction and
 358    modifies (vt,vc) if needed */
 359 void gen_opi(int op, int r, int fr)
 360 {
 361     int t;
 362     if (op == '+') {
 363         o(0x01);
 364         o(0xc0 + r + fr * 8);
 365     } else if (op == '-') {
 366         o(0x29);
 367         o(0xc0 + r + fr * 8);
 368     } else if (op == '&') {
 369         o(0x21);
 370         o(0xc0 + r + fr * 8);
 371     } else if (op == '^') {
 372         o(0x31);
 373         o(0xc0 + r + fr * 8);
 374     } else if (op == '|') {
 375         o(0x09);
 376         o(0xc0 + r + fr * 8);
 377     } else if (op == '*') {
 378         o(0xaf0f); /* imul fr, r */
 379         o(0xc0 + fr + r * 8);
 380     } else if (op == TOK_SHL | op == TOK_SHR | op == TOK_SAR) {
 381         /* op2 is %ecx */
 382         if (fr != 1) {
 383             if (r == 1) {
 384                 r = fr;
 385                 fr = 1;
 386                 o(0x87); /* xchg r, %ecx */
 387                 o(0xc1 + r * 8);
 388             } else
 389                 move_reg(1, fr);
 390         }
 391         o(0xd3); /* shl/shr/sar %cl, r */
 392         if (op == TOK_SHL)
 393             o(0xe0 + r);
 394         else if (op == TOK_SHR)
 395             o(0xe8 + r);
 396         else
 397             o(0xf8 + r);
 398         vt = (vt & VT_TYPE) | r;
 399     } else if (op == '/' | op == TOK_UDIV | op == TOK_PDIV |
 400                op == '%' | op == TOK_UMOD) {
 401         save_reg(2); /* save edx */
 402         t = save_reg_forced(fr); /* save fr and get op2 location */
 403         move_reg(0, r); /* op1 is %eax */
 404         if (op == TOK_UDIV | op == TOK_UMOD) {
 405             o(0xf7d231); /* xor %edx, %edx, div t(%ebp), %eax */
 406             oad(0xb5, t);
 407         } else {
 408             o(0xf799); /* cltd, idiv t(%ebp), %eax */
 409             oad(0xbd, t);
 410         }
 411         if (op == '%' | op == TOK_UMOD)
 412             r = 2;
 413         else
 414             r = 0;
 415         vt = (vt & VT_TYPE) | r;
 416     } else {
 417         o(0x39);
 418         o(0xc0 + r + fr * 8); /* cmp fr, r */
 419         vset(VT_CMP, op);
 420     }
 421 }
 422
 423 /* generate a floating point operation 'v = t1 op t2' instruction and
 424    modifies (vt,vc) if needed */
 425 /* NOTE: floats can only be lvalues */
 426 void gen_opf(int op)
 427 {
 428     int a, ft, fc, swapped, r;
 429
 430     /* must put at least one value in the floating point register */
 431     if ((vstack_ptr[-4] & VT_LVAL) &&
 432         (vstack_ptr[-2] & VT_LVAL)) {
 433         vswap();
 434         vpop(&vt, &vc);
 435         gv();
 436         vpush();
 437         vswap();
 438     }
 439     if (op >= TOK_EQ && op <= TOK_GT) {
 440         /* load on stack second operand */
 441         load(REG_ST0, vstack_ptr[-2], vstack_ptr[-1]);
 442         if (op == TOK_GE || op == TOK_GT)
 443             o(0xc9d9); /* fxch %st(1) */
 444         o(0xe9da); /* fucompp */
 445         o(0xe0df); /* fnstsw %ax */
 446         if (op == TOK_EQ) {
 447             o(0x45e480); /* and $0x45, %ah */
 448             o(0x40fC80); /* cmp $0x40, %ah */
 449         } else if (op == TOK_NE) {
 450             o(0x45e480); /* and $0x45, %ah */
 451             o(0x40f480); /* xor $0x40, %ah */
 452             op = TOK_NE;
 453         } else if (op == TOK_GE || op == TOK_LE) {
 454             o(0x05c4f6); /* test $0x05, %ah */
 455             op = TOK_EQ;
 456         } else {
 457             o(0x45c4f6); /* test $0x45, %ah */
 458             op = TOK_EQ;
 459         }
 460         vstack_ptr[-4] = (vstack_ptr[-4] & VT_TYPE) | VT_CMP;
 461         vstack_ptr[-3] = op;
 462     } else {
 463         /* swap the stack if needed so that t1 is the register and t2 is
 464            the memory reference */
 465         swapped = 0;
 466         if (vstack_ptr[-4] & VT_LVAL) {
 467             vswap();
 468             swapped = 1;
 469         }
 470
 471         switch(op) {
 472         default:
 473         case '+':
 474             a = 0;
 475             break;
 476         case '-':
 477             a = 0x20;
 478             if (swapped)
 479                 a += 8;
 480             break;
 481         case '*':
 482             a = 0x08;
 483             break;
 484         case '/':
 485             a = 0x30;
 486             if (swapped)
 487                 a += 8;
 488             break;
 489         }
 490         ft = vstack_ptr[-2];
 491         fc = vstack_ptr[-1];
 492         if ((ft & VT_BTYPE) == VT_DOUBLE)
 493             o(0xdc);
 494         else
 495             o(0xd8);
 496
 497         r = ft & VT_VALMASK;
 498         if (r == VT_CONST) {
 499             o(0x05 + a);
 500             gen_addr32(fc, ft);
 501         } else if (r == VT_LOCAL) {
 502         oad(0x85 + a, fc);
 503         } else {
 504             g(0x00 + a + r);
 505         }
 506     }
 507     vstack_ptr -= 2;
 508     vpop(&vt, &vc);
 509 }
 510
 511 /* convert integers to floating point (float or double) */
 512 void gen_cvtf(int t)
 513 {
 514     if ((vt & (VT_BTYPE | VT_UNSIGNED)) == (VT_INT | VT_UNSIGNED)) {
 515         /* unsigned int to float/double */
 516         o(0x6a); /* push $0 */
 517         g(0x00);
 518         o(0x50 + (vt & VT_VALMASK)); /* push r */
 519         o(0x242cdf); /* fildll (%esp) */
 520         o(0x08c483); /* add $8, %esp */
 521     } else {
 522         /* int to float/double */
 523         o(0x50 + (vt & VT_VALMASK)); /* push r */
 524         o(0x2404db); /* fildl (%esp) */
 525         o(0x04c483); /* add $4, %esp */
 526     }
 527 }
 528
 529 /* end of X86 code generator */
 530 /*************************************************************/
 531