il-gen.c

   1 /*
   2  *  CIL code generator for TCC
   3  *
   4  *  Copyright (c) 2002 Fabrice Bellard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 /* number of available registers */
  22 #define NB_REGS             3
  23
  24 /* a register can belong to several classes. The classes must be
  25    sorted from more general to more precise (see gv2() code which does
  26    assumptions on it). */
  27 #define RC_ST      0x0001  /* any stack entry */
  28 #define RC_ST0     0x0002  /* top of stack */
  29 #define RC_ST1     0x0004  /* top - 1 */
  30
  31 #define RC_INT     RC_ST
  32 #define RC_FLOAT   RC_ST
  33 #define RC_IRET    RC_ST0 /* function return: integer register */
  34 #define RC_LRET    RC_ST0 /* function return: second integer register */
  35 #define RC_FRET    RC_ST0 /* function return: float register */
  36
  37 /* pretty names for the registers */
  38 enum {
  39     REG_ST0 = 0,
  40     REG_ST1,
  41     REG_ST2,
  42 };
  43
  44 const int reg_classes[NB_REGS] = {
  45     /* ST0 */ RC_ST | RC_ST0,
  46     /* ST1 */ RC_ST | RC_ST1,
  47     /* ST2 */ RC_ST,
  48 };
  49
  50 /* return registers for function */
  51 #define REG_IRET REG_ST0 /* single word int return register */
  52 #define REG_LRET REG_ST0 /* second word return register (for long long) */
  53 #define REG_FRET REG_ST0 /* float return register */
  54
  55 /* defined if function parameters must be evaluated in reverse order */
  56 /* #define INVERT_FUNC_PARAMS */
  57
  58 /* defined if structures are passed as pointers. Otherwise structures
  59    are directly pushed on stack. */
  60 /* #define FUNC_STRUCT_PARAM_AS_PTR */
  61
  62 /* pointer size, in bytes */
  63 #define PTR_SIZE 4
  64
  65 /* long double size and alignment, in bytes */
  66 #define LDOUBLE_SIZE  8
  67 #define LDOUBLE_ALIGN 8
  68
  69 /* function call context */
  70 typedef struct GFuncContext {
  71     int func_call; /* func call type (FUNC_STDCALL or FUNC_CDECL) */
  72 } GFuncContext;
  73
  74 /******************************************************/
  75 /* opcode definitions */
  76
  77 #define IL_OP_PREFIX 0xFE
  78
  79 enum ILOPCodes {
  80 #define OP(name, str, n) IL_OP_ ## name = n,
  81 #include "il-opcodes.h"
  82 #undef OP
  83 };
  84
  85 char *il_opcodes_str[] = {
  86 #define OP(name, str, n) [n] = str,
  87 #include "il-opcodes.h"
  88 #undef OP
  89 };
  90
  91 /******************************************************/
  92
  93 /* arguments variable numbers start from there */
  94 #define ARG_BASE 0x70000000
  95
  96 static FILE *il_outfile;
  97
  98 static void out_byte(int c)
  99 {
 100     *(char *)ind++ = c;
 101 }
 102
 103 static void out_le32(int c)
 104 {
 105     out_byte(c);
 106     out_byte(c >> 8);
 107     out_byte(c >> 16);
 108     out_byte(c >> 24);
 109 }
 110
 111 static void init_outfile(void)
 112 {
 113     if (!il_outfile) {
 114         il_outfile = stdout;
 115         fprintf(il_outfile,
 116                 ".assembly extern mscorlib\n"
 117                 "{\n"
 118                 ".ver 1:0:2411:0\n"
 119                 "}\n\n");
 120     }
 121 }
 122
 123 static void out_op1(int op)
 124 {
 125     if (op & 0x100)
 126         out_byte(IL_OP_PREFIX);
 127     out_byte(op & 0xff);
 128 }
 129
 130 /* output an opcode with prefix */
 131 static void out_op(int op)
 132 {
 133     out_op1(op);
 134     fprintf(il_outfile, " %s\n", il_opcodes_str[op]);
 135 }
 136
 137 static void out_opb(int op, int c)
 138 {
 139     out_op1(op);
 140     out_byte(c);
 141     fprintf(il_outfile, " %s %d\n", il_opcodes_str[op], c);
 142 }
 143
 144 static void out_opi(int op, int c)
 145 {
 146     out_op1(op);
 147     out_le32(c);
 148     fprintf(il_outfile, " %s 0x%x\n", il_opcodes_str[op], c);
 149 }
 150
 151 /* XXX: not complete */
 152 static void il_type_to_str(char *buf, int buf_size,
 153                            int t, const char *varstr)
 154 {
 155     int bt;
 156     Sym *s, *sa;
 157     char buf1[256];
 158     const char *tstr;
 159
 160     t = t & VT_TYPE;
 161     bt = t & VT_BTYPE;
 162     buf[0] = '\0';
 163     if (t & VT_UNSIGNED)
 164         pstrcat(buf, buf_size, "unsigned ");
 165     switch(bt) {
 166     case VT_VOID:
 167         tstr = "void";
 168         goto add_tstr;
 169     case VT_BOOL:
 170         tstr = "bool";
 171         goto add_tstr;
 172     case VT_BYTE:
 173         tstr = "int8";
 174         goto add_tstr;
 175     case VT_SHORT:
 176         tstr = "int16";
 177         goto add_tstr;
 178     case VT_ENUM:
 179     case VT_INT:
 180     case VT_LONG:
 181         tstr = "int32";
 182         goto add_tstr;
 183     case VT_LLONG:
 184         tstr = "int64";
 185         goto add_tstr;
 186     case VT_FLOAT:
 187         tstr = "float32";
 188         goto add_tstr;
 189     case VT_DOUBLE:
 190     case VT_LDOUBLE:
 191         tstr = "float64";
 192     add_tstr:
 193         pstrcat(buf, buf_size, tstr);
 194         break;
 195     case VT_STRUCT:
 196         tcc_error("structures not handled yet");
 197         break;
 198     case VT_FUNC:
 199         s = sym_find((unsigned)t >> VT_STRUCT_SHIFT);
 200         il_type_to_str(buf, buf_size, s->t, varstr);
 201         pstrcat(buf, buf_size, "(");
 202         sa = s->next;
 203         while (sa != NULL) {
 204             il_type_to_str(buf1, sizeof(buf1), sa->t, NULL);
 205             pstrcat(buf, buf_size, buf1);
 206             sa = sa->next;
 207             if (sa)
 208                 pstrcat(buf, buf_size, ", ");
 209         }
 210         pstrcat(buf, buf_size, ")");
 211         goto no_var;
 212     case VT_PTR:
 213         s = sym_find((unsigned)t >> VT_STRUCT_SHIFT);
 214         pstrcpy(buf1, sizeof(buf1), "*");
 215         if (varstr)
 216             pstrcat(buf1, sizeof(buf1), varstr);
 217         il_type_to_str(buf, buf_size, s->t, buf1);
 218         goto no_var;
 219     }
 220     if (varstr) {
 221         pstrcat(buf, buf_size, " ");
 222         pstrcat(buf, buf_size, varstr);
 223     }
 224  no_var: ;
 225 }
 226
 227
 228 /* patch relocation entry with value 'val' */
 229 void greloc_patch1(Reloc *p, int val)
 230 {
 231 }
 232
 233 /* output a symbol and patch all calls to it */
 234 void gsym_addr(t, a)
 235 {
 236 }
 237
 238 /* output jump and return symbol */
 239 static int out_opj(int op, int c)
 240 {
 241     out_op1(op);
 242     out_le32(0);
 243     if (c == 0) {
 244         c = ind - (int)cur_text_section->data;
 245     }
 246     fprintf(il_outfile, " %s L%d\n", il_opcodes_str[op], c);
 247     return c;
 248 }
 249
 250 void gsym(int t)
 251 {
 252     fprintf(il_outfile, "L%d:\n", t);
 253 }
 254
 255 /* load 'r' from value 'sv' */
 256 void load(int r, SValue *sv)
 257 {
 258     int v, fc, ft;
 259
 260     v = sv->r & VT_VALMASK;
 261     fc = sv->c.i;
 262     ft = sv->t;
 263
 264     if (sv->r & VT_LVAL) {
 265         if (v == VT_LOCAL) {
 266             if (fc >= ARG_BASE) {
 267                 fc -= ARG_BASE;
 268                 if (fc >= 0 && fc <= 4) {
 269                     out_op(IL_OP_LDARG_0 + fc);
 270                 } else if (fc <= 0xff) {
 271                     out_opb(IL_OP_LDARG_S, fc);
 272                 } else {
 273                     out_opi(IL_OP_LDARG, fc);
 274                 }
 275             } else {
 276                 if (fc >= 0 && fc <= 4) {
 277                     out_op(IL_OP_LDLOC_0 + fc);
 278                 } else if (fc <= 0xff) {
 279                     out_opb(IL_OP_LDLOC_S, fc);
 280                 } else {
 281                     out_opi(IL_OP_LDLOC, fc);
 282                 }
 283             }
 284         } else if (v == VT_CONST) {
 285                 /* XXX: handle globals */
 286                 out_opi(IL_OP_LDSFLD, 0);
 287         } else {
 288             if ((ft & VT_BTYPE) == VT_FLOAT) {
 289                 out_op(IL_OP_LDIND_R4);
 290             } else if ((ft & VT_BTYPE) == VT_DOUBLE) {
 291                 out_op(IL_OP_LDIND_R8);
 292             } else if ((ft & VT_BTYPE) == VT_LDOUBLE) {
 293                 out_op(IL_OP_LDIND_R8);
 294             } else if ((ft & VT_TYPE) == VT_BYTE)
 295                 out_op(IL_OP_LDIND_I1);
 296             else if ((ft & VT_TYPE) == (VT_BYTE | VT_UNSIGNED))
 297                 out_op(IL_OP_LDIND_U1);
 298             else if ((ft & VT_TYPE) == VT_SHORT)
 299                 out_op(IL_OP_LDIND_I2);
 300             else if ((ft & VT_TYPE) == (VT_SHORT | VT_UNSIGNED))
 301                 out_op(IL_OP_LDIND_U2);
 302             else
 303                 out_op(IL_OP_LDIND_I4);
 304         }
 305     } else {
 306         if (v == VT_CONST) {
 307             /* XXX: handle globals */
 308             if (fc >= -1 && fc <= 8) {
 309                 out_op(IL_OP_LDC_I4_M1 + fc + 1);
 310             } else {
 311                 out_opi(IL_OP_LDC_I4, fc);
 312             }
 313         } else if (v == VT_LOCAL) {
 314             if (fc >= ARG_BASE) {
 315                 fc -= ARG_BASE;
 316                 if (fc <= 0xff) {
 317                     out_opb(IL_OP_LDARGA_S, fc);
 318                 } else {
 319                     out_opi(IL_OP_LDARGA, fc);
 320                 }
 321             } else {
 322                 if (fc <= 0xff) {
 323                     out_opb(IL_OP_LDLOCA_S, fc);
 324                 } else {
 325                     out_opi(IL_OP_LDLOCA, fc);
 326                 }
 327             }
 328         } else {
 329             /* XXX: do it */
 330         }
 331     }
 332 }
 333
 334 /* store register 'r' in lvalue 'v' */
 335 void store(int r, SValue *sv)
 336 {
 337     int v, fc, ft;
 338
 339     v = sv->r & VT_VALMASK;
 340     fc = sv->c.i;
 341     ft = sv->t;
 342     if (v == VT_LOCAL) {
 343         if (fc >= ARG_BASE) {
 344             fc -= ARG_BASE;
 345             /* XXX: check IL arg store semantics */
 346             if (fc <= 0xff) {
 347                 out_opb(IL_OP_STARG_S, fc);
 348             } else {
 349                 out_opi(IL_OP_STARG, fc);
 350             }
 351         } else {
 352             if (fc >= 0 && fc <= 4) {
 353                 out_op(IL_OP_STLOC_0 + fc);
 354             } else if (fc <= 0xff) {
 355                 out_opb(IL_OP_STLOC_S, fc);
 356             } else {
 357                 out_opi(IL_OP_STLOC, fc);
 358             }
 359         }
 360     } else if (v == VT_CONST) {
 361         /* XXX: handle globals */
 362         out_opi(IL_OP_STSFLD, 0);
 363     } else {
 364         if ((ft & VT_BTYPE) == VT_FLOAT)
 365             out_op(IL_OP_STIND_R4);
 366         else if ((ft & VT_BTYPE) == VT_DOUBLE)
 367             out_op(IL_OP_STIND_R8);
 368         else if ((ft & VT_BTYPE) == VT_LDOUBLE)
 369             out_op(IL_OP_STIND_R8);
 370         else if ((ft & VT_BTYPE) == VT_BYTE)
 371             out_op(IL_OP_STIND_I1);
 372         else if ((ft & VT_BTYPE) == VT_SHORT)
 373             out_op(IL_OP_STIND_I2);
 374         else
 375             out_op(IL_OP_STIND_I4);
 376     }
 377 }
 378
 379 /* start function call and return function call context */
 380 void gfunc_start(GFuncContext *c, int func_call)
 381 {
 382     c->func_call = func_call;
 383 }
 384
 385 /* push function parameter which is in (vtop->t, vtop->c). Stack entry
 386    is then popped. */
 387 void gfunc_param(GFuncContext *c)
 388 {
 389     if ((vtop->t & VT_BTYPE) == VT_STRUCT) {
 390         tcc_error("structures passed as value not handled yet");
 391     } else {
 392         /* simply push on stack */
 393         gv(RC_ST0);
 394     }
 395     vtop--;
 396 }
 397
 398 /* generate function call with address in (vtop->t, vtop->c) and free function
 399    context. Stack entry is popped */
 400 void gfunc_call(GFuncContext *c)
 401 {
 402     char buf[1024];
 403
 404     if ((vtop->r & (VT_VALMASK | VT_LVAL)) == VT_CONST) {
 405         /* XXX: more info needed from tcc */
 406         il_type_to_str(buf, sizeof(buf), vtop->t, "xxx");
 407         fprintf(il_outfile, " call %s\n", buf);
 408     } else {
 409         /* indirect call */
 410         gv(RC_INT);
 411         il_type_to_str(buf, sizeof(buf), vtop->t, NULL);
 412         fprintf(il_outfile, " calli %s\n", buf);
 413     }
 414     vtop--;
 415 }
 416
 417 /* generate function prolog of type 't' */
 418 void gfunc_prolog(int t)
 419 {
 420     int addr, u, func_call;
 421     Sym *sym;
 422     char buf[1024];
 423
 424     init_outfile();
 425
 426     /* XXX: pass function name to gfunc_prolog */
 427     il_type_to_str(buf, sizeof(buf), t, funcname);
 428     fprintf(il_outfile, ".method static %s il managed\n", buf);
 429     fprintf(il_outfile, "{\n");
 430     /* XXX: cannot do better now */
 431     fprintf(il_outfile, " .maxstack %d\n", NB_REGS);
 432     fprintf(il_outfile, " .locals (int32, int32, int32, int32, int32, int32, int32, int32)\n");
 433
 434     if (!strcmp(funcname, "main"))
 435         fprintf(il_outfile, " .entrypoint\n");
 436
 437     sym = sym_find((unsigned)t >> VT_STRUCT_SHIFT);
 438     func_call = sym->r;
 439
 440     addr = ARG_BASE;
 441     /* if the function returns a structure, then add an
 442        implicit pointer parameter */
 443     func_vt = sym->t;
 444     func_var = (sym->c == FUNC_ELLIPSIS);
 445     if ((func_vt & VT_BTYPE) == VT_STRUCT) {
 446         func_vc = addr;
 447         addr++;
 448     }
 449     /* define parameters */
 450     while ((sym = sym->next) != NULL) {
 451         u = sym->t;
 452         sym_push(sym->v & ~SYM_FIELD, u,
 453                  VT_LOCAL | lvalue_type(sym->type.t), addr);
 454         addr++;
 455     }
 456 }
 457
 458 /* generate function epilog */
 459 void gfunc_epilog(void)
 460 {
 461     out_op(IL_OP_RET);
 462     fprintf(il_outfile, "}\n\n");
 463 }
 464
 465 /* generate a jump to a label */
 466 int gjmp(int t)
 467 {
 468     return out_opj(IL_OP_BR, t);
 469 }
 470
 471 /* generate a jump to a fixed address */
 472 void gjmp_addr(int a)
 473 {
 474     /* XXX: handle syms */
 475     out_opi(IL_OP_BR, a);
 476 }
 477
 478 /* generate a test. set 'inv' to invert test. Stack entry is popped */
 479 int gtst(int inv, int t)
 480 {
 481     int v, *p, c;
 482
 483     v = vtop->r & VT_VALMASK;
 484     if (v == VT_CMP) {
 485         c = vtop->c.i ^ inv;
 486         switch(c) {
 487         case TOK_EQ:
 488             c = IL_OP_BEQ;
 489             break;
 490         case TOK_NE:
 491             c = IL_OP_BNE_UN;
 492             break;
 493         case TOK_LT:
 494             c = IL_OP_BLT;
 495             break;
 496         case TOK_LE:
 497             c = IL_OP_BLE;
 498             break;
 499         case TOK_GT:
 500             c = IL_OP_BGT;
 501             break;
 502         case TOK_GE:
 503             c = IL_OP_BGE;
 504             break;
 505         case TOK_ULT:
 506             c = IL_OP_BLT_UN;
 507             break;
 508         case TOK_ULE:
 509             c = IL_OP_BLE_UN;
 510             break;
 511         case TOK_UGT:
 512             c = IL_OP_BGT_UN;
 513             break;
 514         case TOK_UGE:
 515             c = IL_OP_BGE_UN;
 516             break;
 517         }
 518         t = out_opj(c, t);
 519     } else { /* VT_JMP || VT_JMPI */
 520         /* && or || optimization */
 521         if ((v & 1) == inv) {
 522             /* insert vtop->c jump list in t */
 523             p = &vtop->c.i;
 524             while (*p != 0)
 525                 p = (int *)*p;
 526             *p = t;
 527             t = vtop->c.i;
 528         } else {
 529             t = gjmp(t);
 530             gsym(vtop->c.i);
 531         }
 532     }
 533     vtop--;
 534     return t;
 535 }
 536
 537 /* generate an integer binary operation */
 538 void gen_opi(int op)
 539 {
 540     gv2(RC_ST1, RC_ST0);
 541     switch(op) {
 542     case '+':
 543         out_op(IL_OP_ADD);
 544         goto std_op;
 545     case '-':
 546         out_op(IL_OP_SUB);
 547         goto std_op;
 548     case '&':
 549         out_op(IL_OP_AND);
 550         goto std_op;
 551     case '^':
 552         out_op(IL_OP_XOR);
 553         goto std_op;
 554     case '|':
 555         out_op(IL_OP_OR);
 556         goto std_op;
 557     case '*':
 558         out_op(IL_OP_MUL);
 559         goto std_op;
 560     case TOK_SHL:
 561         out_op(IL_OP_SHL);
 562         goto std_op;
 563     case TOK_SHR:
 564         out_op(IL_OP_SHR_UN);
 565         goto std_op;
 566     case TOK_SAR:
 567         out_op(IL_OP_SHR);
 568         goto std_op;
 569     case '/':
 570     case TOK_PDIV:
 571         out_op(IL_OP_DIV);
 572         goto std_op;
 573     case TOK_UDIV:
 574         out_op(IL_OP_DIV_UN);
 575         goto std_op;
 576     case '%':
 577         out_op(IL_OP_REM);
 578         goto std_op;
 579     case TOK_UMOD:
 580         out_op(IL_OP_REM_UN);
 581     std_op:
 582         vtop--;
 583         vtop[0].r = REG_ST0;
 584         break;
 585     case TOK_EQ:
 586     case TOK_NE:
 587     case TOK_LT:
 588     case TOK_LE:
 589     case TOK_GT:
 590     case TOK_GE:
 591     case TOK_ULT:
 592     case TOK_ULE:
 593     case TOK_UGT:
 594     case TOK_UGE:
 595         vtop--;
 596         vtop[0].r = VT_CMP;
 597         vtop[0].c.i = op;
 598         break;
 599     }
 600 }
 601
 602 /* generate a floating point operation 'v = t1 op t2' instruction. The
 603    two operands are guaranted to have the same floating point type */
 604 void gen_opf(int op)
 605 {
 606     /* same as integer */
 607     gen_opi(op);
 608 }
 609
 610 /* convert integers to fp 't' type. Must handle 'int', 'unsigned int'
 611    and 'long long' cases. */
 612 void gen_cvt_itof(int t)
 613 {
 614     gv(RC_ST0);
 615     if (t == VT_FLOAT)
 616         out_op(IL_OP_CONV_R4);
 617     else
 618         out_op(IL_OP_CONV_R8);
 619 }
 620
 621 /* convert fp to int 't' type */
 622 /* XXX: handle long long case */
 623 void gen_cvt_ftoi(int t)
 624 {
 625     gv(RC_ST0);
 626     switch(t) {
 627     case VT_INT | VT_UNSIGNED:
 628         out_op(IL_OP_CONV_U4);
 629         break;
 630     case VT_LLONG:
 631         out_op(IL_OP_CONV_I8);
 632         break;
 633     case VT_LLONG | VT_UNSIGNED:
 634         out_op(IL_OP_CONV_U8);
 635         break;
 636     default:
 637         out_op(IL_OP_CONV_I4);
 638         break;
 639     }
 640 }
 641
 642 /* convert from one floating point type to another */
 643 void gen_cvt_ftof(int t)
 644 {
 645     gv(RC_ST0);
 646     if (t == VT_FLOAT) {
 647         out_op(IL_OP_CONV_R4);
 648     } else {
 649         out_op(IL_OP_CONV_R8);
 650     }
 651 }
 652
 653 /* end of CIL code generator */
 654 /*************************************************************/
 655