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