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