gen.c

   1 #include <stdlib.h>
   2 #include <stdio.h>
   3 #include <string.h>
   4 #include "gen.h"
   5 #include "out.h"
   6 #include "tok.h"
   7
   8 #define LOC_REG         0x01
   9 #define LOC_MEM         0x02
  10 #define LOC_NUM         0x04
  11 #define LOC_SYM         0x08
  12 #define LOC_LOCAL       0x10
  13
  14 #define NREGS           16
  15
  16 #define REG_PC          15      /* program counter */
  17 #define REG_LR          14      /* link register */
  18 #define REG_SP          13      /* stack pointer */
  19 #define REG_TMP         12      /* temporary register */
  20 #define REG_FP          11      /* frame pointer register */
  21 #define REG_DP          10      /* data pointer register */
  22 #define REG_RET         0       /* returned value register */
  23
  24 #define MIN(a, b)               ((a) < (b) ? (a) : (b))
  25 #define ALIGN(x, a)             (((x) + (a) - 1) & ~((a) - 1))
  26
  27 static char cs[SECSIZE];        /* code segment */
  28 static int cslen;
  29 static char ds[SECSIZE];        /* data segment */
  30 static int dslen;
  31 static long bsslen;             /* bss segment size */
  32
  33 static int nogen;               /* don't generate code */
  34 static long sp;
  35 static long func_beg;
  36 static long maxsp;
  37
  38 #define TMP(i)          (((i) < ntmp) ? &tmps[ntmp - 1 - (i)] : NULL)
  39
  40 static struct tmp {
  41         long addr;
  42         char sym[NAMELEN];
  43         long off;       /* offset from a symbol or a local */
  44         unsigned loc;   /* variable location */
  45         unsigned bt;    /* type of address; zero when not a pointer */
  46 } tmps[MAXTMP];
  47 static int ntmp;
  48
  49 static int tmpsp;
  50
  51 static struct tmp *regs[NREGS];
  52 static int tmpregs[] = {4, 5, 6, 7, 8, 9, 0, 1, 2, 3};
  53 static int argregs[] = {0, 1, 2, 3};
  54
  55 #define I_AND           0x00
  56 #define I_EOR           0x01
  57 #define I_SUB           0x02
  58 #define I_RSB           0x03
  59 #define I_ADD           0x04
  60 #define I_TST           0x08
  61 #define I_CMP           0x0a
  62 #define I_ORR           0x0c
  63 #define I_MOV           0x0d
  64 #define I_MVN           0x0f
  65
  66 #define MAXRET                  (1 << 8)
  67
  68 static long ret[MAXRET];
  69 static int nret;
  70
  71 /* output div/mod functions */
  72 static int putdiv = 0;
  73
  74 static void os(void *s, int n)
  75 {
  76         memcpy(cs + cslen, s, n);
  77         cslen += n;
  78 }
  79
  80 static void oi(long n)
  81 {
  82         if (nogen)
  83                 return;
  84         *(int *) (cs + cslen) = n;
  85         cslen += 4;
  86 }
  87
  88 #define MAXNUMS         1024
  89
  90 /* data pool */
  91 static long num_offs[MAXNUMS];                  /* data immediate value */
  92 static char num_names[MAXNUMS][NAMELEN];        /* relocation data symbol name */
  93 static int nums;
  94
  95 static int pool_find(char *name, int off)
  96 {
  97         int i;
  98         for (i = 0; i < nums; i++)
  99                 if (!strcmp(name, num_names[i]) && off == num_offs[i])
 100                         return i;
 101         return -1;
 102 }
 103
 104 static int pool_num(long num)
 105 {
 106         int idx = pool_find("", num);
 107         if (idx < 0) {
 108                 idx = nums++;
 109                 num_offs[idx] = num;
 110                 num_names[idx][0] = '\0';
 111         }
 112         return idx << 2;
 113 }
 114
 115 static int pool_reloc(char *name, long off)
 116 {
 117         int idx = pool_find(name, off);
 118         if (idx < 0) {
 119                 idx = nums++;
 120                 num_offs[idx] = off;
 121                 strcpy(num_names[idx], name);
 122         }
 123         return idx << 2;
 124 }
 125
 126 static void pool_write(void)
 127 {
 128         int i;
 129         for (i = 0; i < nums; i++) {
 130                 if (num_names[i])
 131                         out_rel(num_names[i], OUT_CS, cslen);
 132                 oi(num_offs[i]);
 133         }
 134 }
 135
 136 /*
 137  * data processing:
 138  * +---------------------------------------+
 139  * |COND|00|I| op |S| Rn | Rd |  operand2  |
 140  * +---------------------------------------+
 141  *
 142  * S: set condition code
 143  * Rn: first operand
 144  * Rd: destination operand
 145  *
 146  * I=0 operand2=| shift  | Rm |
 147  * I=1 operand2=|rota|  imm   |
 148  */
 149 #define ADD(op, rd, rn, s, i, cond)     \
 150         (((cond) << 28) | ((i) << 25) | ((s) << 20) | \
 151                 ((op) << 21) | ((rn) << 16) | ((rd) << 12))
 152
 153 static int add_encimm(unsigned n)
 154 {
 155         int i = 0;
 156         while (i < 12 && (n >> ((4 + i) << 1)))
 157                 i++;
 158         return (n >> (i << 1)) | (((16 - i) & 0x0f) << 8);
 159 }
 160
 161 static int add_decimm(unsigned n)
 162 {
 163         int rot = (16 - ((n >> 8) & 0x0f)) & 0x0f;
 164         return (n & 0xff) << (rot << 1);
 165 }
 166
 167 static int add_rndimm(unsigned n)
 168 {
 169         int rot = (n >> 8) & 0x0f;
 170         int num = n & 0xff;
 171         if (rot == 0)
 172                 return n;
 173         if (num == 0xff) {
 174                 num = 0;
 175                 rot = (rot + 12) & 0x0f;
 176         }
 177         return ((num + 1) & 0xff) | (rot << 8);
 178 }
 179
 180 static void i_add(int op, int rd, int rn, int rm)
 181 {
 182         oi(ADD(op, rd, rn, 0, 0, 14) | rm);
 183 }
 184
 185 static void i_add_imm(int op, int rd, int rn, long n)
 186 {
 187         oi(ADD(op, rd, rn, 0, 1, 14) | add_encimm(n));
 188 }
 189
 190 static void i_ldr(int l, int rd, int rn, int off, int bt);
 191
 192 static void i_num(int rd, long n)
 193 {
 194         int neg = n < 0;
 195         int p = neg ? -n - 1 : n;
 196         int enc = add_encimm(p);
 197         if (p == add_decimm(enc)) {
 198                 oi(ADD(neg ? I_MVN : I_MOV, rd, 0, 0, 1, 14) | enc);
 199         } else {
 200                 if (!nogen) {
 201                         int off = pool_num(n);
 202                         i_ldr(1, rd, REG_DP, off, LONGSZ);
 203                 }
 204         }
 205 }
 206
 207 static void i_add_anyimm(int rd, int rn, long n)
 208 {
 209         int neg = n < 0;
 210         int imm = add_encimm(neg ? -n : n);
 211         if (imm == add_decimm(neg ? -n : n)) {
 212                 oi(ADD(neg ? I_SUB : I_ADD, rd, rn, 0, 1, 14) | imm);
 213         } else {
 214                 i_num(rd, n);
 215                 i_add(I_ADD, rd, rd, rn);
 216         }
 217 }
 218
 219 /*
 220  * multiply
 221  * +----------------------------------------+
 222  * |COND|000000|A|S| Rd | Rn | Rs |1001| Rm |
 223  * +----------------------------------------+
 224  *
 225  * Rd: destination
 226  * A: accumulate
 227  * C: set condition codes
 228  *
 229  * I=0 operand2=| shift  | Rm |
 230  * I=1 operand2=|rota|  imm   |
 231  */
 232 #define MUL(rd, rn, rs)         \
 233         ((14 << 28) | ((rd) << 16) | ((0) << 12) | ((rn) << 8) | ((9) << 4) | (rm))
 234
 235 static void i_mul(int rd, int rn, int rm)
 236 {
 237         oi(MUL(rd, rn, rm));
 238 }
 239
 240 static void i_cmp(int op, int rn, int rm)
 241 {
 242         oi(ADD(op, 0, rn, 1, 0, 14) | rm);
 243 }
 244
 245 static void i_cmp_imm(int op, int rn, long n)
 246 {
 247         oi(ADD(op, 0, rn, 1, 1, 14) | add_encimm(n));
 248 }
 249
 250 static void i_set(int cond, int rd)
 251 {
 252         oi(ADD(I_MOV, rd, 0, 0, 1, 14));
 253         oi(ADD(I_MOV, rd, 0, 0, 1, cond) | 1);
 254 }
 255
 256 #define SM_LSL          0
 257 #define SM_LSR          1
 258 #define SM_ASR          2
 259
 260 static void i_shl(int sm, int rd, int rm, int rs)
 261 {
 262         oi(ADD(I_MOV, rd, 0, 0, 0, 14) | (rs << 8) | (sm << 5) | (1 << 4) | rm);
 263 }
 264
 265 static void i_shl_imm(int sm, int rd, int rn, long n)
 266 {
 267         oi(ADD(I_MOV, rd, 0, 0, 0, 14) | (n << 7) | (sm << 5) | rn);
 268 }
 269
 270 static void i_mov(int op, int rd, int rn)
 271 {
 272         oi(ADD(op, rd, 0, 0, 0, 14) | rn);
 273 }
 274
 275 /*
 276  * single data transfer:
 277  * +------------------------------------------+
 278  * |COND|01|I|P|U|B|W|L| Rn | Rd |   offset   |
 279  * +------------------------------------------+
 280  *
 281  * I: immediate/offset
 282  * P: post/pre indexing
 283  * U: down/up
 284  * B: byte/word
 285  * W: writeback
 286  * L: store/load
 287  * Rn: base register
 288  * Rd: source/destination register
 289  *
 290  * I=0 offset=| immediate |
 291  * I=1 offset=| shift  | Rm |
 292  *
 293  * halfword and signed data transfer
 294  * +----------------------------------------------+
 295  * |COND|000|P|U|0|W|L| Rn | Rd |0000|1|S|H|1| Rm |
 296  * +----------------------------------------------+
 297  *
 298  * +----------------------------------------------+
 299  * |COND|000|P|U|1|W|L| Rn | Rd |off1|1|S|H|1|off2|
 300  * +----------------------------------------------+
 301  *
 302  * S: singed
 303  * H: halfword
 304  */
 305 #define LDR(l, rd, rn, b, u, p, w)              \
 306         ((14 << 28) | (1 << 26) | ((p) << 24) | ((b) << 22) | ((u) << 23) | \
 307         ((w) << 21) | ((l) << 20) | ((rn) << 16) | ((rd) << 12))
 308 #define LDRH(l, rd, rn, s, h, u, i)     \
 309         ((14 << 28) | (1 << 24) | ((u) << 23) | ((i) << 22) | ((l) << 20) | \
 310         ((rn) << 16) | ((rd) << 12) | ((s) << 6) | ((h) << 5) | (9 << 4))
 311
 312 static void i_ldr(int l, int rd, int rn, int off, int bt)
 313 {
 314         int b = BT_SZ(bt) == 1;
 315         int h = BT_SZ(bt) == 2;
 316         int s = l && (bt & BT_SIGNED);
 317         int half = h || (b && s);
 318         int maximm = half ? 0x100 : 0x1000;
 319         int neg = off < 0;
 320         if (neg)
 321                 off = -off;
 322         while (off >= maximm) {
 323                 int imm = add_encimm(off);
 324                 oi(ADD(neg ? I_SUB : I_ADD, REG_TMP, rn, 0, 1, 14) | imm);
 325                 rn = REG_TMP;
 326                 off -= add_decimm(imm);
 327         }
 328         if (!half)
 329                 oi(LDR(l, rd, rn, b, !neg, 1, 0) | off);
 330         else
 331                 oi(LDRH(l, rd, rn, s, h, !neg, 1) |
 332                         ((off & 0xf0) << 4) | (off & 0x0f));
 333 }
 334
 335 static void i_sym(int rd, char *sym, int off)
 336 {
 337         if (!nogen) {
 338                 int doff = pool_reloc(sym, off);
 339                 i_ldr(1, rd, REG_DP, doff, LONGSZ);
 340         }
 341 }
 342
 343 static void i_neg(int rd)
 344 {
 345         oi(ADD(I_RSB, rd, rd, 0, 1, 14));
 346 }
 347
 348 static void i_not(int rd)
 349 {
 350         oi(ADD(I_MVN, rd, 0, 0, 0, 14) | rd);
 351 }
 352
 353 static void i_lnot(int rd)
 354 {
 355         i_cmp(I_TST, rd, rd);
 356         oi(ADD(I_MOV, rd, 0, 0, 1, 14));
 357         oi(ADD(I_MOV, rd, 0, 0, 1, 0) | 1);
 358 }
 359
 360 /* rd = rd & ((1 << bits) - 1) */
 361 static void i_zx(int rd, int bits)
 362 {
 363         if (bits <= 8) {
 364                 oi(ADD(I_AND, rd, rd, 0, 1, 14) | add_encimm((1 << bits) - 1));
 365         } else {
 366                 i_shl_imm(SM_LSL, rd, rd, 32 - bits);
 367                 i_shl_imm(SM_LSR, rd, rd, 32 - bits);
 368         }
 369 }
 370
 371 static void i_sx(int rd, int bits)
 372 {
 373         i_shl_imm(SM_LSL, rd, rd, 32 - bits);
 374         i_shl_imm(SM_ASR, rd, rd, 32 - bits);
 375 }
 376
 377 /*
 378  * branch:
 379  * +-----------------------------------+
 380  * |COND|101|L|         offset         |
 381  * +-----------------------------------+
 382  *
 383  * L: link
 384  */
 385 #define BL(cond, l, o)  (((cond) << 28) | (5 << 25) | ((l) << 24) | \
 386                                 ((((o) - 8) >> 2) & 0x00ffffff))
 387
 388 static void i_b(long addr)
 389 {
 390         oi(BL(14, 0, addr - cslen));
 391 }
 392
 393 static void i_b_if(long addr, int rn, int z)
 394 {
 395         i_cmp(I_TST, rn, rn);
 396         oi(BL(z ? 0 : 1, 0, addr - cslen));
 397 }
 398
 399 static void i_b_fill(long *dst, int diff)
 400 {
 401         *dst = (*dst & 0xff000000) | (((diff - 8) >> 2) & 0x00ffffff);
 402 }
 403
 404 static void i_memcpy(int rd, int rs, int rn)
 405 {
 406         oi(ADD(I_SUB, rn, rn, 1, 1, 14) | 1);
 407         oi(BL(4, 0, 16));
 408         oi(LDR(1, REG_TMP, rs, 1, 1, 0, 0) | 1);
 409         oi(LDR(0, REG_TMP, rd, 1, 1, 0, 0) | 1);
 410         oi(BL(14, 0, -16));
 411 }
 412
 413 static void i_memset(int rd, int rs, int rn)
 414 {
 415         oi(ADD(I_SUB, rn, rn, 1, 1, 14) | 1);
 416         oi(BL(4, 0, 12));
 417         oi(LDR(0, rs, rd, 1, 1, 0, 0) | 1);
 418         oi(BL(14, 0, -12));
 419 }
 420
 421 static void i_call_reg(int rd)
 422 {
 423         i_mov(I_MOV, REG_LR, REG_PC);
 424         i_mov(I_MOV, REG_PC, rd);
 425 }
 426
 427 static void i_call(char *sym)
 428 {
 429         if (!nogen)
 430                 out_rel(sym, OUT_CS | OUT_REL24, cslen);
 431         oi(BL(14, 1, 0));
 432 }
 433
 434 static void i_prolog(void)
 435 {
 436         func_beg = cslen;
 437         nums = 0;
 438         oi(0xe1a0c00d);         /* mov   r12, sp */
 439         oi(0xe92d000f);         /* stmfd sp!, {r0-r3} */
 440         oi(0xe92d5ff0);         /* stmfd sp!, {r0-r11, r12, lr} */
 441         oi(0xe1a0b00d);         /* mov   fp, sp */
 442         oi(0xe24dd000);         /* sub   sp, sp, xx */
 443         oi(0xe28fa000);         /* add   dp, pc, xx */
 444 }
 445
 446 static void i_epilog(void)
 447 {
 448         int dpoff;
 449         oi(0xe89baff0);         /* ldmfd fp, {r4-r11, sp, pc} */
 450         dpoff = add_decimm(add_rndimm(add_encimm(cslen - func_beg - 28)));
 451         cslen = func_beg + dpoff + 28;
 452         maxsp = ALIGN(maxsp, 8);
 453         maxsp = add_decimm(add_rndimm(add_encimm(maxsp)));
 454         /* fill stack sub: sp = sp - xx */
 455         *(long *) (cs + func_beg + 16) |= add_encimm(maxsp);
 456         /* fill data ptr addition: dp = pc + xx */
 457         *(long *) (cs + func_beg + 20) |= add_encimm(dpoff);
 458         pool_write();
 459 }
 460
 461 static long sp_push(int size)
 462 {
 463         sp += size;
 464         if (sp > maxsp)
 465                 maxsp = sp;
 466         return sp;
 467 }
 468
 469 static void tmp_mem(struct tmp *tmp)
 470 {
 471         int src = tmp->addr;
 472         if (!(tmp->loc == LOC_REG))
 473                 return;
 474         if (tmpsp == -1)
 475                 tmpsp = sp;
 476         tmp->addr = -sp_push(LONGSZ);
 477         i_ldr(0, src, REG_FP, tmp->addr, LONGSZ);
 478         regs[src] = NULL;
 479         tmp->loc = LOC_MEM;
 480 }
 481
 482 static void num_cast(struct tmp *t, unsigned bt)
 483 {
 484         if (!(bt & BT_SIGNED) && BT_SZ(bt) != LONGSZ)
 485                 t->addr &= ((1l << (long) (BT_SZ(bt) * 8)) - 1);
 486         if (bt & BT_SIGNED && BT_SZ(bt) != LONGSZ &&
 487                                 t->addr > (1l << (BT_SZ(bt) * 8 - 1)))
 488                 t->addr = -((1l << (BT_SZ(bt) * 8)) - t->addr);
 489 }
 490
 491 static void tmp_reg(struct tmp *tmp, int dst, int deref)
 492 {
 493         int bt = tmp->bt;
 494         if (!tmp->bt)
 495                 deref = 0;
 496         if (deref)
 497                 tmp->bt = 0;
 498         if (tmp->loc == LOC_NUM) {
 499                 i_num(dst, tmp->addr);
 500                 tmp->addr = dst;
 501                 regs[dst] = tmp;
 502                 tmp->loc = LOC_REG;
 503         }
 504         if (tmp->loc == LOC_SYM) {
 505                 i_sym(dst, tmp->sym, tmp->off);
 506                 tmp->addr = dst;
 507                 regs[dst] = tmp;
 508                 tmp->loc = LOC_REG;
 509         }
 510         if (tmp->loc == LOC_REG) {
 511                 if (deref)
 512                         i_ldr(1, dst, tmp->addr, 0, bt);
 513                 else if (dst != tmp->addr)
 514                         i_mov(I_MOV, dst, tmp->addr);
 515                 regs[tmp->addr] = NULL;
 516         }
 517         if (tmp->loc == LOC_LOCAL) {
 518                 if (deref)
 519                         i_ldr(1, dst, REG_FP, tmp->addr + tmp->off, bt);
 520                 else
 521                         i_add_anyimm(dst, REG_FP, tmp->addr + tmp->off);
 522         }
 523         if (tmp->loc == LOC_MEM) {
 524                 i_ldr(1, dst, REG_FP, tmp->addr, LONGSZ);
 525                 if (deref)
 526                         i_ldr(1, dst, dst, 0, bt);
 527         }
 528         tmp->addr = dst;
 529         regs[dst] = tmp;
 530         tmp->loc = LOC_REG;
 531 }
 532
 533 static void reg_free(int reg)
 534 {
 535         int i;
 536         if (!regs[reg])
 537                 return;
 538         for (i = 0; i < ARRAY_SIZE(tmpregs); i++)
 539                 if (!regs[tmpregs[i]]) {
 540                         tmp_reg(regs[reg], tmpregs[i], 0);
 541                         return;
 542                 }
 543         tmp_mem(regs[reg]);
 544 }
 545
 546 static void reg_for(int reg, struct tmp *t)
 547 {
 548         if (regs[reg] && regs[reg] != t)
 549                 reg_free(reg);
 550 }
 551
 552 static void tmp_mv(struct tmp *t, int reg)
 553 {
 554         reg_for(reg, t);
 555         tmp_reg(t, reg, 0);
 556 }
 557
 558 static void tmp_to(struct tmp *t, int reg)
 559 {
 560         reg_for(reg, t);
 561         tmp_reg(t, reg, 1);
 562 }
 563
 564 static void tmp_drop(int n)
 565 {
 566         int i;
 567         for (i = ntmp - n; i < ntmp; i++)
 568                 if (tmps[i].loc == LOC_REG)
 569                         regs[tmps[i].addr] = NULL;
 570         ntmp -= n;
 571 }
 572
 573 static void tmp_pop(int reg)
 574 {
 575         struct tmp *t = TMP(0);
 576         tmp_to(t, reg);
 577         tmp_drop(1);
 578 }
 579
 580 static struct tmp *tmp_new(void)
 581 {
 582         return &tmps[ntmp++];
 583 }
 584
 585 static void tmp_push(int reg)
 586 {
 587         struct tmp *t = tmp_new();
 588         t->addr = reg;
 589         t->bt = 0;
 590         t->loc = LOC_REG;
 591         regs[reg] = t;
 592 }
 593
 594 void o_local(long addr)
 595 {
 596         struct tmp *t = tmp_new();
 597         t->addr = -addr;
 598         t->loc = LOC_LOCAL;
 599         t->bt = 0;
 600         t->off = 0;
 601 }
 602
 603 void o_num(long num)
 604 {
 605         struct tmp *t = tmp_new();
 606         t->addr = num;
 607         t->bt = 0;
 608         t->loc = LOC_NUM;
 609 }
 610
 611 void o_sym(char *name)
 612 {
 613         struct tmp *t = tmp_new();
 614         strcpy(t->sym, name);
 615         t->loc = LOC_SYM;
 616         t->bt = 0;
 617         t->off = 0;
 618 }
 619
 620 void o_tmpdrop(int n)
 621 {
 622         if (n == -1 || n > ntmp)
 623                 n = ntmp;
 624         tmp_drop(n);
 625         if (!ntmp) {
 626                 if (tmpsp != -1)
 627                         sp = tmpsp;
 628                 tmpsp = -1;
 629         }
 630 }
 631
 632 #define FORK_REG                0x00
 633
 634 /* make sure tmps remain intact after a conditional expression */
 635 void o_fork(void)
 636 {
 637         int i;
 638         for (i = 0; i < ntmp - 1; i++)
 639                 tmp_mem(&tmps[i]);
 640 }
 641
 642 void o_forkpush(void)
 643 {
 644         tmp_pop(FORK_REG);
 645 }
 646
 647 void o_forkjoin(void)
 648 {
 649         tmp_push(FORK_REG);
 650 }
 651
 652 void o_tmpswap(void)
 653 {
 654         struct tmp *t1 = TMP(0);
 655         struct tmp *t2 = TMP(1);
 656         struct tmp t;
 657         memcpy(&t, t1, sizeof(t));
 658         memcpy(t1, t2, sizeof(t));
 659         memcpy(t2, &t, sizeof(t));
 660         if (t1->loc == LOC_REG)
 661                 regs[t1->addr] = t1;
 662         if (t2->loc == LOC_REG)
 663                 regs[t2->addr] = t2;
 664 }
 665
 666 static int reg_get(int mask)
 667 {
 668         int i;
 669         for (i = 0; i < ARRAY_SIZE(tmpregs); i++)
 670                 if ((1 << tmpregs[i]) & mask && !regs[tmpregs[i]])
 671                         return tmpregs[i];
 672         for (i = 0; i < ARRAY_SIZE(tmpregs); i++)
 673                 if ((1 << tmpregs[i]) & mask) {
 674                         reg_free(tmpregs[i]);
 675                         return tmpregs[i];
 676                 }
 677         return 0;
 678 }
 679
 680 static int reg_fortmp(struct tmp *t, int notmask)
 681 {
 682        if (t->loc == LOC_REG && !(notmask & (1 << t->addr)))
 683                return t->addr;
 684        return reg_get(~notmask);
 685 }
 686
 687 static void tmp_copy(struct tmp *t1)
 688 {
 689         struct tmp *t2 = tmp_new();
 690         memcpy(t2, t1, sizeof(*t1));
 691         if (!(t1->loc & (LOC_REG | LOC_MEM)))
 692                 return;
 693         if (t1->loc == LOC_MEM) {
 694                 tmp_mv(t2, reg_get(~0));
 695         } else if (t1->loc == LOC_REG) {
 696                 t2->addr = reg_fortmp(t2, 1 << t1->addr);
 697                 i_mov(I_MOV, t2->addr, t1->addr);
 698                 regs[t2->addr] = t2;
 699         }
 700 }
 701
 702 void o_tmpcopy(void)
 703 {
 704         tmp_copy(TMP(0));
 705 }
 706
 707 void o_cast(unsigned bt)
 708 {
 709         struct tmp *t = TMP(0);
 710         if (!t->bt && t->loc == LOC_NUM) {
 711                 num_cast(t, bt);
 712                 return;
 713         }
 714         if (BT_SZ(bt) != LONGSZ) {
 715                 int reg = reg_fortmp(t, 0);
 716                 tmp_to(t, reg);
 717                 if (bt & BT_SIGNED)
 718                         i_sx(reg, BT_SZ(bt) * 8);
 719                 else
 720                         i_zx(reg, BT_SZ(bt) * 8);
 721         }
 722 }
 723
 724 void o_func_beg(char *name, int global)
 725 {
 726         out_sym(name, (global ? OUT_GLOB : 0) | OUT_CS, cslen, 0);
 727         i_prolog();
 728         sp = 0;
 729         maxsp = sp;
 730         ntmp = 0;
 731         tmpsp = -1;
 732         nret = 0;
 733         memset(regs, 0, sizeof(regs));
 734 }
 735
 736 void o_deref(unsigned bt)
 737 {
 738         struct tmp *t = TMP(0);
 739         if (t->bt)
 740                 tmp_to(t, reg_fortmp(t, 0));
 741         t->bt = bt;
 742 }
 743
 744 void o_load(void)
 745 {
 746         struct tmp *t = TMP(0);
 747         tmp_to(t, reg_fortmp(t, 0));
 748 }
 749
 750 #define TMP_NUM(t)      ((t)->loc == LOC_NUM && !(t)->bt)
 751 #define LOCAL_PTR(t)    ((t)->loc == LOC_LOCAL && !(t)->bt)
 752 #define SYM_PTR(t)      ((t)->loc == LOC_SYM && !(t)->bt)
 753
 754 int o_popnum(long *c)
 755 {
 756         struct tmp *t = TMP(0);
 757         if (!TMP_NUM(t))
 758                 return 1;
 759         *c = t->addr;
 760         tmp_drop(1);
 761         return 0;
 762 }
 763
 764 void o_ret(int rets)
 765 {
 766         if (rets)
 767                 tmp_pop(REG_RET);
 768         else
 769                 i_num(REG_RET, 0);
 770         ret[nret++] = o_jmp(0);
 771 }
 772
 773 void o_func_end(void)
 774 {
 775         int i;
 776         for (i = 0; i < nret; i++)
 777                 o_filljmp(ret[i]);
 778         i_epilog();
 779 }
 780
 781 long o_mklocal(int size)
 782 {
 783         return sp_push(ALIGN(size, LONGSZ));
 784 }
 785
 786 void o_rmlocal(long addr, int sz)
 787 {
 788         sp = addr - sz;
 789 }
 790
 791 long o_arg2loc(int i)
 792 {
 793         return -(10 + i) << 2;
 794 }
 795
 796 void o_assign(unsigned bt)
 797 {
 798         struct tmp *t1 = TMP(0);
 799         struct tmp *t2 = TMP(1);
 800         int r1 = reg_fortmp(t1, 0);
 801         int r2 = reg_fortmp(t2, 1 << r1);
 802         int off = 0;
 803         tmp_to(t1, r1);
 804         if (t2->bt)
 805                 tmp_to(t2, r2);
 806         if (t2->loc == LOC_LOCAL) {
 807                 r2 = REG_FP;
 808                 off = t2->addr + t2->off;
 809         } else {
 810                 tmp_to(t2, r2);
 811         }
 812         tmp_drop(2);
 813         i_ldr(0, r1, r2, off, bt);
 814         tmp_push(r1);
 815 }
 816
 817 static long cu(int op, long i)
 818 {
 819         switch (op & 0xff) {
 820         case O_NEG:
 821                 return -i;
 822         case O_NOT:
 823                 return ~i;
 824         case O_LNOT:
 825                 return !i;
 826         }
 827         return 0;
 828 }
 829
 830 static int c_uop(int op)
 831 {
 832         struct tmp *t1 = TMP(0);
 833         if (!TMP_NUM(t1))
 834                 return 1;
 835         tmp_drop(1);
 836         o_num(cu(op, t1->addr));
 837         return 0;
 838 }
 839
 840 static long cb(int op, long a, long b)
 841 {
 842         switch (op & 0xff) {
 843         case O_ADD:
 844                 return a + b;
 845         case O_SUB:
 846                 return a - b;
 847         case O_AND:
 848                 return a & b;
 849         case O_OR:
 850                 return a | b;
 851         case O_XOR:
 852                 return a ^ b;
 853         case O_MUL:
 854                 return a * b;
 855         case O_DIV:
 856                 return a / b;
 857         case O_MOD:
 858                 return a % b;
 859         case O_SHL:
 860                 return a << b;
 861         case O_SHR:
 862                 if (op & O_SIGNED)
 863                         return a >> b;
 864                 else
 865                         return (unsigned long) a >> b;
 866         case O_LT:
 867                 return a < b;
 868         case O_GT:
 869                 return a > b;
 870         case O_LE:
 871                 return a <= b;
 872         case O_GE:
 873                 return a >= b;
 874         case O_EQ:
 875                 return a == b;
 876         case O_NEQ:
 877                 return a != b;
 878         }
 879         return 0;
 880 }
 881
 882 static int c_bop(int op)
 883 {
 884         struct tmp *t1 = TMP(0);
 885         struct tmp *t2 = TMP(1);
 886         int locals = LOCAL_PTR(t1) + LOCAL_PTR(t2);
 887         int syms = SYM_PTR(t1) + SYM_PTR(t2);
 888         int nums = TMP_NUM(t1) + TMP_NUM(t2);
 889         if (syms + locals == 2 || syms + nums + locals != 2)
 890                 return 1;
 891         if (nums == 1)
 892                 if ((op & 0xff) != O_ADD && ((op & 0xff) != O_SUB || TMP_NUM(t2)))
 893                         return 1;
 894         if (nums == 1) {
 895                 long o1 = TMP_NUM(t1) ? t1->addr : t1->off;
 896                 long o2 = TMP_NUM(t2) ? t2->addr : t2->off;
 897                 long ret = cb(op, o2, o1);
 898                 if (!TMP_NUM(t1))
 899                         o_tmpswap();
 900                 t2->off = ret;
 901                 tmp_drop(1);
 902         } else {
 903                 long ret = cb(op, t2->addr, t1->addr);
 904                 tmp_drop(2);
 905                 o_num(ret);
 906         }
 907         return 0;
 908 }
 909
 910 void o_uop(int op)
 911 {
 912         int r1 = reg_fortmp(TMP(0), 0);
 913         if (!c_uop(op))
 914                 return;
 915         tmp_to(TMP(0), r1);
 916         switch (op & 0xff) {
 917         case O_NEG:
 918                 i_neg(r1);
 919                 break;
 920         case O_NOT:
 921                 i_not(r1);
 922                 break;
 923         case O_LNOT:
 924                 i_lnot(r1);
 925                 break;
 926         }
 927 }
 928
 929 static void bin_regs(int *r1, int *r2)
 930 {
 931         struct tmp *t2 = TMP(0);
 932         struct tmp *t1 = TMP(1);
 933         *r2 = reg_fortmp(t2, 0);
 934         tmp_to(t2, *r2);
 935         *r1 = reg_fortmp(t1, 1 << *r2);
 936         tmp_pop(*r2);
 937         tmp_pop(*r1);
 938 }
 939
 940 static int bop_imm(int *r1, long *n, int swap)
 941 {
 942         struct tmp *t1 = TMP(0);
 943         struct tmp *t2 = TMP(1);
 944         if (!TMP_NUM(t1) && (!swap || !TMP_NUM(t2)))
 945                 return 1;
 946         *n = TMP_NUM(t1) ? t1->addr : t2->addr;
 947         if (*n < 0 || add_decimm(add_encimm(*n)) != *n)
 948                 return 1;
 949         if (!TMP_NUM(t1))
 950                 o_tmpswap();
 951         *r1 = reg_fortmp(t2, 0);
 952         tmp_drop(1);
 953         tmp_pop(*r1);
 954         return 0;
 955 }
 956
 957 static void bin_add(int op)
 958 {
 959         /* opcode for O_ADD, O_SUB, O_AND, O_OR, O_XOR */
 960         static int rx[] = {I_ADD, I_SUB, I_AND, I_ORR, I_EOR};
 961         int r1, r2;
 962         long n;
 963         if (!bop_imm(&r1, &n, (op & 0xff) != O_SUB)) {
 964                 i_add_imm(rx[op & 0x0f], r1, r1, n);
 965         } else {
 966                 bin_regs(&r1, &r2);
 967                 i_add(rx[op & 0x0f], r1, r1, r2);
 968         }
 969         tmp_push(r1);
 970 }
 971
 972 static void bin_shx(int op)
 973 {
 974         int sm = SM_LSL;
 975         int r1, r2;
 976         long n;
 977         if ((op & 0x0f) == 1)
 978                 sm = op & O_SIGNED ? SM_ASR : SM_LSR;
 979         if (!bop_imm(&r1, &n, 0)) {
 980                 i_shl_imm(sm, r1, r1, n);
 981         } else {
 982                 bin_regs(&r1, &r2);
 983                 i_shl(sm, r1, r1, r2);
 984         }
 985         tmp_push(r1);
 986 }
 987
 988 static int log2a(unsigned long n)
 989 {
 990         int i = 0;
 991         for (i = 0; i < LONGSZ * 8; i++)
 992                 if (n & (1u << i))
 993                         break;
 994         if (i == LONGSZ * 8 || !(n >> (i + 1)))
 995                 return i;
 996         return -1;
 997 }
 998
 999 /* optimized version of mul/div/mod for powers of two */
1000 static int mul_2(int op)
1001 {
1002         struct tmp *t1 = TMP(0);
1003         struct tmp *t2 = TMP(1);
1004         long n;
1005         int r2;
1006         int p;
1007         if ((op & 0xff) == O_MUL && t2->loc == LOC_NUM && !t2->bt)
1008                 o_tmpswap();
1009         if (t1->loc != LOC_NUM || t1->bt)
1010                 return 1;
1011         n = t1->addr;
1012         p = log2a(n);
1013         if (n && p == -1)
1014                 return 1;
1015         if ((op & 0xff) == O_MUL) {
1016                 tmp_drop(1);
1017                 if (n == 1)
1018                         return 0;
1019                 if (n == 0) {
1020                         tmp_drop(1);
1021                         o_num(0);
1022                         return 0;
1023                 }
1024                 r2 = reg_fortmp(t2, 0);
1025                 tmp_to(t2, r2);
1026                 i_shl_imm(SM_LSL, r2, r2, p);
1027                 return 0;
1028         }
1029         if (op == O_DIV) {
1030                 tmp_drop(1);
1031                 if (n == 1)
1032                         return 0;
1033                 r2 = reg_fortmp(t2, 0);
1034                 tmp_to(t2, r2);
1035                 i_shl_imm(op & O_SIGNED ? SM_ASR : SM_LSR, r2, r2, p);
1036                 return 0;
1037         }
1038         if (op == O_MOD) {
1039                 tmp_drop(1);
1040                 if (n == 1) {
1041                         tmp_drop(1);
1042                         o_num(0);
1043                         return 0;
1044                 }
1045                 r2 = reg_fortmp(t2, 0);
1046                 tmp_to(t2, r2);
1047                 i_zx(r2, p);
1048                 return 0;
1049         }
1050         return 1;
1051 }
1052
1053 static void bin_div(int op)
1054 {
1055         struct tmp *t2 = TMP(0);
1056         struct tmp *t1 = TMP(1);
1057         char *func;
1058         int i;
1059         putdiv = 1;
1060         if ((op & 0xff) == O_DIV)
1061                 func = op & O_SIGNED ? "__divdi3" : "__udivdi3";
1062         else
1063                 func = op & O_SIGNED ? "__moddi3" : "__umoddi3";
1064         for (i = 0; i < ARRAY_SIZE(argregs); i++)
1065                 if (regs[argregs[i]] && regs[argregs[i]] - tmps < ntmp - 2)
1066                         tmp_mem(regs[argregs[i]]);
1067         tmp_to(t1, argregs[0]);
1068         tmp_to(t2, argregs[1]);
1069         tmp_drop(2);
1070         i_call(func);
1071         tmp_push(REG_RET);
1072 }
1073
1074 static void bin_mul(int op)
1075 {
1076         int r1, r2;
1077         if (!mul_2(op))
1078                 return;
1079         if ((op & 0xff) == O_DIV || (op & 0xff) == O_MOD) {
1080                 bin_div(op);
1081         } else {
1082                 bin_regs(&r1, &r2);
1083                 i_mul(r1, r1, r2);
1084                 tmp_push(r1);
1085         }
1086 }
1087
1088 static void bin_cmp(int op)
1089 {
1090         /* lt, gt, le, ge, eq, neq */
1091         static int ucond[] = {3, 8, 9, 2, 0, 1};
1092         static int scond[] = {11, 12, 13, 10, 0, 1};
1093         int r1, r2;
1094         long n;
1095         if (!bop_imm(&r1, &n, 0)) {
1096                 i_cmp_imm(I_CMP, r1, n);
1097         } else {
1098                 bin_regs(&r1, &r2);
1099                 i_cmp(I_CMP, r1, r2);
1100         }
1101         i_set(op & O_SIGNED ? scond[op & 0x0f] : ucond[op & 0x0f], r1);
1102         tmp_push(r1);
1103 }
1104
1105 void o_bop(int op)
1106 {
1107         if (!c_bop(op))
1108                 return;
1109         if ((op & 0xf0) == 0x00)
1110                 bin_add(op);
1111         if ((op & 0xf0) == 0x10)
1112                 bin_shx(op);
1113         if ((op & 0xf0) == 0x20)
1114                 bin_mul(op);
1115         if ((op & 0xf0) == 0x30)
1116                 bin_cmp(op);
1117 }
1118
1119 static void load_regs2(int *r0, int *r1, int *r2)
1120 {
1121         struct tmp *t0 = TMP(0);
1122         struct tmp *t1 = TMP(1);
1123         struct tmp *t2 = TMP(2);
1124         *r0 = reg_fortmp(t0, 0);
1125         *r1 = reg_fortmp(t1, 1 << *r0);
1126         *r2 = reg_fortmp(t2, (1 << *r0) | (1 << *r1));
1127         tmp_to(t0, *r0);
1128         tmp_to(t1, *r1);
1129         tmp_to(t2, *r2);
1130 }
1131
1132 void o_memcpy(void)
1133 {
1134         int rd, rs, rn;
1135         load_regs2(&rn, &rs, &rd);
1136         i_memcpy(rd, rs, rn);
1137         tmp_drop(2);
1138 }
1139
1140 void o_memset(void)
1141 {
1142         int rd, rs, rn;
1143         load_regs2(&rn, &rs, &rd);
1144         i_memset(rd, rs, rn);
1145         tmp_drop(2);
1146 }
1147
1148 long o_mklabel(void)
1149 {
1150         return cslen;
1151 }
1152
1153 static long jxz(long addr, int z)
1154 {
1155         int r = reg_fortmp(TMP(0), 0);
1156         tmp_pop(r);
1157         i_b_if(addr, r, z);
1158         return cslen - 4;
1159 }
1160
1161 long o_jz(long addr)
1162 {
1163         return jxz(addr, 1);
1164 }
1165
1166 long o_jnz(long addr)
1167 {
1168         return jxz(addr, 0);
1169 }
1170
1171 long o_jmp(long addr)
1172 {
1173         i_b(addr);
1174         return cslen - 4;
1175 }
1176
1177 void o_filljmp2(long addr, long jmpdst)
1178 {
1179         i_b_fill((void *) cs + addr, jmpdst - addr);
1180 }
1181
1182 void o_filljmp(long addr)
1183 {
1184         o_filljmp2(addr, cslen);
1185 }
1186
1187 void o_call(int argc, int rets)
1188 {
1189         struct tmp *t;
1190         int i;
1191         int aregs = MIN(ARRAY_SIZE(argregs), argc);
1192         for (i = 0; i < ARRAY_SIZE(argregs); i++)
1193                 if (regs[argregs[i]] && regs[argregs[i]] - tmps < ntmp - argc)
1194                         tmp_mem(regs[argregs[i]]);
1195         if (argc > aregs) {
1196                 sp_push(LONGSZ * (argc - aregs));
1197                 for (i = argc - 1; i >= aregs; --i) {
1198                         int reg = reg_fortmp(TMP(0), 0);
1199                         tmp_pop(reg);
1200                         i_ldr(0, reg, REG_SP, (i - aregs) * LONGSZ, LONGSZ);
1201                 }
1202         }
1203         for (i = aregs - 1; i >= 0; --i)
1204                 tmp_to(TMP(aregs - i - 1), argregs[i]);
1205         tmp_drop(aregs);
1206         t = TMP(0);
1207         if (t->loc == LOC_SYM && !t->bt) {
1208                 i_call(t->sym);
1209                 tmp_drop(1);
1210         } else {
1211                 int reg = t->loc == LOC_REG ? t->addr : REG_TMP;
1212                 tmp_pop(reg);
1213                 i_call_reg(reg);
1214         }
1215         if (rets)
1216                 tmp_push(REG_RET);
1217 }
1218
1219 void o_nogen(void)
1220 {
1221         nogen++;
1222 }
1223
1224 void o_dogen(void)
1225 {
1226         nogen--;
1227 }
1228
1229 void o_mkbss(char *name, int size, int global)
1230 {
1231         out_sym(name, OUT_BSS | (global ? OUT_GLOB : 0), bsslen, size);
1232         bsslen += ALIGN(size, LONGSZ);
1233 }
1234
1235 #define MAXDATS         (1 << 10)
1236 static char dat_names[MAXDATS][NAMELEN];
1237 static int dat_offs[MAXDATS];
1238 static int ndats;
1239
1240 void err(char *msg);
1241 void *o_mkdat(char *name, int size, int global)
1242 {
1243         void *addr = ds + dslen;
1244         int idx = ndats++;
1245         if (idx >= MAXDATS)
1246                 err("nomem: MAXDATS reached!\n");
1247         strcpy(dat_names[idx], name);
1248         dat_offs[idx] = dslen;
1249         out_sym(name, OUT_DS | (global ? OUT_GLOB : 0), dslen, size);
1250         dslen += ALIGN(size, LONGSZ);
1251         return addr;
1252 }
1253
1254 static int dat_off(char *name)
1255 {
1256         int i;
1257         for (i = 0; i < ndats; i++)
1258                 if (!strcmp(name, dat_names[i]))
1259                         return dat_offs[i];
1260         return 0;
1261 }
1262
1263 void o_datset(char *name, int off, unsigned bt)
1264 {
1265         struct tmp *t = TMP(0);
1266         int sym_off = dat_off(name) + off;
1267         if (t->loc == LOC_NUM && !t->bt) {
1268                 num_cast(t, bt);
1269                 memcpy(ds + sym_off, &t->addr, BT_SZ(bt));
1270         }
1271         if (t->loc == LOC_SYM && !t->bt) {
1272                 out_rel(t->sym, OUT_DS, sym_off);
1273                 memcpy(ds + sym_off, &t->off, BT_SZ(bt));
1274         }
1275         tmp_drop(1);
1276 }
1277
1278 /* compiled division functions; div.s contains the source */
1279 static int udivdi3[] = {
1280         0xe3a02000, 0xe3a03000, 0xe1110001, 0x0a00000a,
1281         0xe1b0c211, 0xe2822001, 0x5afffffc, 0xe3a0c001,
1282         0xe2522001, 0x4a000004, 0xe1500211, 0x3afffffb,
1283         0xe0400211, 0xe083321c, 0xeafffff8, 0xe1a01000,
1284         0xe1a00003, 0xe1a0f00e,
1285 };
1286 static int umoddi3[] = {
1287         0xe92d4000, 0xebffffeb, 0xe1a00001, 0xe8bd8000,
1288 };
1289 static int divdi3[] = {
1290         0xe92d4030, 0xe1a04000, 0xe1a05001, 0xe1100000,
1291         0x42600000, 0xe1110001, 0x42611000, 0xebffffe1,
1292         0xe1340005, 0x42600000, 0xe1140004, 0x42611000,
1293         0xe8bd8030,
1294 };
1295 static int moddi3[] = {
1296         0xe92d4000, 0xebfffff0, 0xe1a00001, 0xe8bd8000,
1297 };
1298
1299 void o_write(int fd)
1300 {
1301         if (putdiv) {
1302                 out_sym("__udivdi3", OUT_CS, cslen, 0);
1303                 os(udivdi3, sizeof(udivdi3));
1304                 out_sym("__umoddi3", OUT_CS, cslen, 0);
1305                 os(umoddi3, sizeof(umoddi3));
1306                 out_sym("__divdi3", OUT_CS, cslen, 0);
1307                 os(divdi3, sizeof(divdi3));
1308                 out_sym("__moddi3", OUT_CS, cslen, 0);
1309                 os(moddi3, sizeof(moddi3));
1310         }
1311         out_write(fd, cs, cslen, ds, dslen);
1312 }