show an error msg if no input file
[neatcc.git] / gen.c
blobdf3377f0a3119d4ac4a6759ab7eaff77ab35be83
1 #include <stdlib.h>
2 #include <string.h>
3 #include "gen.h"
4 #include "tok.h"
6 #define TMP_ADDR 0x0001
7 #define LOC_REG 0x0100
8 #define LOC_MEM 0x0200
9 #define LOC_NUM 0x0400
10 #define LOC_SYM 0x0800
11 #define LOC_LOCAL 0x1000
12 #define LOC_MASK 0xff00
14 #define R_RAX 0x00
15 #define R_RCX 0x01
16 #define R_RDX 0x02
17 #define R_RBX 0x03
18 #define R_RSP 0x04
19 #define R_RBP 0x05
20 #define R_RSI 0x06
21 #define R_RDI 0x07
22 #define R_R8 0x08
23 #define R_R9 0x09
24 #define R_R10 0x0a
25 #define R_R11 0x0b
26 #define R_R12 0x0c
27 #define R_R13 0x0d
28 #define R_R14 0x0e
29 #define R_R15 0x0f
30 #define NREGS 0x10
32 #define MOV_M2R 0x8b
33 #define MOV_R2X 0x89
34 #define MOV_I2X 0xc7
35 #define MOV_I2R 0xb8
36 #define ADD_R2X 0x03
37 #define SUB_R2X 0x2b
38 #define SHX_REG 0xd3
39 #define CMP_R2X 0x3b
40 #define LEA_M2R 0x8d
41 #define NEG_REG 0xf7
42 #define NOT_REG 0xf7
43 #define CALL_REG 0xff
44 #define MUL_A2X 0xf7
45 #define XOR_R2X 0x33
46 #define AND_R2X 0x23
47 #define OR_R2X 0x0b
48 #define TEST_R2R 0x85
50 #define MIN(a, b) ((a) < (b) ? (a) : (b))
52 #define R_BYTEMASK (1 << R_RAX | 1 << R_RDX | 1 << R_RCX)
53 #define TMP_BT(t) ((t)->flags & TMP_ADDR ? 8 : (t)->bt)
54 #define TMP_REG(t) ((t)->flags & LOC_REG ? (t)->addr : reg_get(~0))
55 #define TMP_REG2(t, r) ((t)->flags & LOC_REG && (t)->addr != r ? \
56 (t)->addr : reg_get(~(1 << r)))
57 #define TMP_BYTEREG(t) ((t)->flags & LOC_REG && \
58 (1 << (t)->addr) & R_BYTEMASK ? \
59 (t)->addr : reg_get(R_BYTEMASK))
60 #define BT_TMPBT(bt) (BT_SZ(bt) >= 4 ? (bt) : (bt) & BT_SIGNED | 4)
62 static char buf[SECSIZE];
63 static char *cur;
64 static int nogen;
65 static long sp;
66 static long spsub_addr;
67 static long maxsp;
69 static struct tmp {
70 long addr;
71 long off; /* used for LOC_SYM; offset from a symbol address */
72 unsigned flags;
73 unsigned bt;
74 } tmp[MAXTMP];
75 static int ntmp;
77 static int tmpsp;
79 static struct tmp *regs[NREGS];
80 static int tmpregs[] = {R_RAX, R_RDI, R_RSI, R_RDX, R_RCX, R_R8, R_R9};
82 #define MAXRET (1 << 8)
84 static long ret[MAXRET];
85 static int nret;
87 static long cmp_last;
88 static long cmp_setl;
90 static void putint(char *s, long n, int l)
92 if (nogen)
93 return;
94 while (l--) {
95 *s++ = n;
96 n >>= 8;
100 static void os(char *s, int n)
102 if (nogen)
103 return;
104 while (n--)
105 *cur++ = *s++;
108 static void oi(long n, int l)
110 while (l--) {
111 *cur++ = n;
112 n >>= 8;
116 static long codeaddr(void)
118 return cur - buf;
121 static void o_op(int *op, int nop, int r1, int r2, unsigned bt)
123 int rex = 0;
124 int i;
125 if (r1 & 0x8)
126 rex |= 4;
127 if (r2 & 0x8)
128 rex |= 1;
129 if (BT_SZ(bt) == 8)
130 rex |= 8;
131 if (rex || (bt & BT_SZMASK) == 8)
132 oi(0x40 | rex, 1);
133 if ((bt & BT_SZMASK) == 2)
134 oi(0x66, 1);
135 if ((bt & BT_SZMASK) == 1)
136 op[nop - 1] &= ~0x1;
137 for (i = 0; i < nop; i++)
138 oi(op[i], 1);
141 static void memop(int *op, int nop, int src, int base, int off, unsigned bt)
143 int dis = off == (char) off ? 1 : 4;
144 int mod = dis == 4 ? 2 : 1;
145 o_op(op, nop, src, base, bt);
146 if (!off)
147 mod = 0;
148 oi((mod << 6) | ((src & 0x07) << 3) | (base & 0x07), 1);
149 if (off)
150 oi(off, dis);
153 static void memop1(int op, int src, int base, int off, unsigned bt)
155 memop(&op, 1, src, base, off, bt);
158 static void regop(int *op, int nop, int src, int dst, unsigned bt)
160 o_op(op, nop, src, dst, bt);
161 oi((3 << 6) | (src << 3) | (dst & 0x07), 1);
164 static void regop1(int op, int src, int dst, unsigned bt)
166 regop(&op, 1, src, dst, bt);
169 static long sp_push(int size)
171 sp += size;
172 if (sp > maxsp)
173 maxsp = sp;
174 return sp;
177 #define LOC_NEW(f, l) (((f) & ~LOC_MASK) | (l))
179 static void tmp_mem(struct tmp *tmp)
181 int src = tmp->addr;
182 if (!(tmp->flags & LOC_REG))
183 return;
184 if (tmpsp == -1)
185 tmpsp = sp;
186 tmp->addr = -sp_push(8);
187 memop1(MOV_R2X, src, R_RBP, tmp->addr, BT_TMPBT(TMP_BT(tmp)));
188 regs[src] = NULL;
189 tmp->flags = LOC_NEW(tmp->flags, LOC_MEM);
192 static int *movxx_x2r(int bt)
194 static int movxx[2] = {0x0f};
195 if (BT_SZ(bt) == 1)
196 movxx[1] = bt & BT_SIGNED ? 0xbe : 0xb6;
197 else
198 movxx[1] = bt & BT_SIGNED ? 0xbf : 0xb7;
199 return movxx;
202 #define MOVSXD 0x63
204 static void mov_r2r(int r1, int r2, unsigned bt1, unsigned bt2)
206 int s1 = bt1 & BT_SIGNED;
207 int s2 = bt2 & BT_SIGNED;
208 int sz1 = BT_SZ(bt1);
209 int sz2 = BT_SZ(bt2);
210 if (sz2 < 4 && (sz1 >= sz2 && s1 != s2)) {
211 regop(movxx_x2r(bt2), 2, r1, r2, 4);
212 return;
214 if (sz1 == 4 && sz2 == 8) {
215 regop1(MOVSXD, r2, r1, sz2);
216 return;
218 if (r1 != r2 || sz1 > sz2)
219 regop1(MOV_R2X, r1, r2, BT_TMPBT(bt2));
222 static void mov_m2r(int dst, int base, int off, int bt1, int bt2)
224 if (BT_SZ(bt1) < 4) {
225 memop(movxx_x2r(bt1), 2, dst, base, off,
226 bt1 & BT_SIGNED && BT_SZ(bt2) == 8 ? 8 : 4);
227 mov_r2r(dst, dst, bt1, bt2);
228 } else {
229 memop1(MOV_M2R, dst, base, off, bt1);
230 mov_r2r(dst, dst, bt1, bt2);
234 static void num_cast(struct tmp *t, unsigned bt)
236 if (!(bt & BT_SIGNED) && BT_SZ(bt) != 8)
237 t->addr &= ((1l << (long) (BT_SZ(bt) * 8)) - 1);
238 if (bt & BT_SIGNED && BT_SZ(bt) != 8 &&
239 t->addr > (1l << (BT_SZ(bt) * 8 - 1)))
240 t->addr = -((1l << (BT_SZ(bt) * 8)) - t->addr);
241 t->bt = bt;
244 static void num_reg(int reg, unsigned bt, long num)
246 int op = MOV_I2R + (reg & 7);
247 if (BT_SZ(bt) == 8 && num >= 0 && num == (unsigned) num)
248 bt = 4;
249 o_op(&op, 1, 0, reg, bt);
250 oi(num, BT_SZ(bt));
253 static void tmp_reg(struct tmp *tmp, int dst, unsigned bt, int deref)
255 if (deref && tmp->flags & TMP_ADDR)
256 tmp->flags &= ~TMP_ADDR;
257 else
258 deref = 0;
259 if (tmp->flags & LOC_NUM) {
260 num_cast(tmp, bt);
261 tmp->bt = BT_TMPBT(bt);
262 num_reg(dst, tmp->bt, tmp->addr);
263 tmp->addr = dst;
264 regs[dst] = tmp;
265 tmp->flags = LOC_NEW(tmp->flags, LOC_REG);
267 if (tmp->flags & LOC_SYM) {
268 regop1(MOV_I2X, 0, dst, TMP_BT(tmp));
269 if (!nogen)
270 out_rela(tmp->addr, codeaddr(), 0);
271 oi(tmp->off, 4);
272 tmp->addr = dst;
273 regs[dst] = tmp;
274 tmp->flags = LOC_NEW(tmp->flags, LOC_REG);
276 if (tmp->flags & LOC_REG) {
277 if (deref)
278 mov_m2r(dst, tmp->addr, 0, tmp->bt, bt);
279 else
280 mov_r2r(tmp->addr, dst, TMP_BT(tmp),
281 tmp->flags & TMP_ADDR ? 8 : bt);
282 regs[tmp->addr] = NULL;
284 if (tmp->flags & LOC_LOCAL) {
285 if (deref)
286 mov_m2r(dst, R_RBP, tmp->addr, tmp->bt, bt);
287 else
288 memop1(LEA_M2R, dst, R_RBP, tmp->addr, 8);
290 if (tmp->flags & LOC_MEM) {
291 mov_m2r(dst, R_RBP, tmp->addr,
292 deref ? 8 : TMP_BT(tmp), deref ? 8 : bt);
293 if (deref)
294 mov_m2r(dst, dst, 0, tmp->bt, bt);
296 tmp->addr = dst;
297 tmp->bt = tmp->flags & TMP_ADDR ? bt : BT_TMPBT(bt);
298 regs[dst] = tmp;
299 tmp->flags = LOC_NEW(tmp->flags, LOC_REG);
302 static void reg_free(int reg)
304 int i;
305 if (!regs[reg])
306 return;
307 for (i = 0; i < ARRAY_SIZE(tmpregs); i++)
308 if (!regs[tmpregs[i]]) {
309 tmp_reg(regs[reg], tmpregs[i], regs[reg]->bt, 0);
310 return;
312 tmp_mem(regs[reg]);
315 static void reg_for(int reg, struct tmp *t)
317 if (regs[reg] && regs[reg] != t)
318 reg_free(reg);
321 static void tmp_pop_bt(unsigned bt, int reg)
323 struct tmp *t = &tmp[--ntmp];
324 reg_for(reg, t);
325 tmp_reg(t, reg, bt, 1);
326 regs[reg] = NULL;
329 static unsigned tmp_pop(int deref, int reg)
331 struct tmp *t = &tmp[--ntmp];
332 reg_for(reg, t);
333 tmp_reg(t, reg, deref ? t->bt : TMP_BT(t), deref);
334 regs[reg] = NULL;
335 return t->bt;
338 static struct tmp *tmp_new(void)
340 cmp_last = -1;
341 return &tmp[ntmp++];
344 static void tmp_push_reg(unsigned bt, unsigned reg)
346 struct tmp *t = tmp_new();
347 t->addr = reg;
348 t->bt = bt;
349 t->flags = LOC_REG;
350 regs[reg] = t;
353 void o_local(long addr, unsigned bt)
355 struct tmp *t = tmp_new();
356 t->addr = -addr;
357 t->bt = bt;
358 t->flags = LOC_LOCAL | TMP_ADDR;
361 void o_num(long num, unsigned bt)
363 struct tmp *t = tmp_new();
364 t->addr = num;
365 t->bt = bt;
366 t->flags = LOC_NUM;
369 void o_symaddr(long addr, unsigned bt)
371 struct tmp *t = tmp_new();
372 t->bt = bt;
373 t->addr = addr;
374 t->flags = LOC_SYM | TMP_ADDR;
375 t->off = 0;
378 void o_tmpdrop(int n)
380 int i;
381 cmp_last = -1;
382 if (n == -1 || n > ntmp)
383 n = ntmp;
384 ntmp -= n;
385 for (i = ntmp; i < ntmp + n; i++)
386 if (tmp[i].flags & LOC_REG)
387 regs[tmp[i].addr] = NULL;
388 if (!ntmp) {
389 if (tmpsp != -1)
390 sp = tmpsp;
391 tmpsp = -1;
395 #define FORK_REG R_RAX
397 void o_tmpfork(void)
399 struct tmp *t = &tmp[ntmp - 1];
400 reg_for(FORK_REG, t);
401 tmp_reg(t, FORK_REG, t->bt, 1);
402 o_tmpdrop(1);
405 void o_tmpjoin(void)
407 struct tmp *t = &tmp[ntmp - 1];
408 reg_for(FORK_REG, t);
409 tmp_reg(t, FORK_REG, t->bt, 1);
412 void o_tmpswap(void)
414 struct tmp *t1 = &tmp[ntmp - 1];
415 struct tmp *t2 = &tmp[ntmp - 2];
416 struct tmp t;
417 memcpy(&t, t1, sizeof(t));
418 memcpy(t1, t2, sizeof(t));
419 memcpy(t2, &t, sizeof(t));
422 static int reg_get(int mask)
424 int i;
425 for (i = 0; i < ARRAY_SIZE(tmpregs); i++)
426 if ((1 << tmpregs[i]) & mask && !regs[tmpregs[i]])
427 return tmpregs[i];
428 for (i = 0; i < ARRAY_SIZE(tmpregs); i++)
429 if ((1 << tmpregs[i]) & mask) {
430 reg_free(tmpregs[i]);
431 return tmpregs[i];
433 return 0;
436 void o_tmpcopy(void)
438 struct tmp *t1 = &tmp[ntmp - 1];
439 struct tmp *t2 = tmp_new();
440 memcpy(t2, t1, sizeof(*t1));
441 if (!(t1->flags & (LOC_REG | LOC_MEM)))
442 return;
443 if (t1->flags & LOC_MEM) {
444 tmp_reg(t2, reg_get(~0), t2->bt, 0);
445 } else if (t1->flags & LOC_REG) {
446 t2->addr = reg_get(~t1->addr);
447 regop1(MOV_R2X, t1->addr, t2->addr, BT_TMPBT(TMP_BT(t1)));
449 t2->flags = t1->flags;
452 void o_cast(unsigned bt)
454 struct tmp *t = &tmp[ntmp - 1];
455 int reg;
456 if (t->bt == bt)
457 return;
458 if (t->flags & LOC_NUM) {
459 num_cast(t, bt);
460 return;
462 reg = BT_SZ(bt) == 1 ? TMP_BYTEREG(t) : TMP_REG(t);
463 tmp_pop_bt(bt, reg);
464 tmp_push_reg(bt, reg);
467 long o_func_beg(char *name, int global)
469 long addr = out_func_beg(name, global);
470 cur = buf;
471 os("\x55", 1); /* push %rbp */
472 os("\x48\x89\xe5", 3); /* mov %rsp, %rbp */
473 sp = 0;
474 maxsp = 0;
475 ntmp = 0;
476 tmpsp = -1;
477 nret = 0;
478 cmp_last = -1;
479 memset(regs, 0, sizeof(regs));
480 os("\x48\x81\xec", 3); /* sub $xxx, %rsp */
481 spsub_addr = codeaddr();
482 oi(0, 4);
483 return addr;
486 void o_deref(unsigned bt)
488 struct tmp *t = &tmp[ntmp - 1];
489 if (t->flags & TMP_ADDR)
490 tmp_reg(t, TMP_REG(t), 8, 1);
491 t->bt = bt;
492 t->flags |= TMP_ADDR;
495 void o_load(void)
497 struct tmp *t = &tmp[ntmp - 1];
498 tmp_reg(t, TMP_REG(t), t->bt, 1);
501 static unsigned bt_op(unsigned bt1, unsigned bt2)
503 unsigned s1 = BT_SZ(bt1);
504 unsigned s2 = BT_SZ(bt2);
505 unsigned bt = (bt1 | bt2) & BT_SIGNED | (s1 > s2 ? s1 : s2);
506 return BT_TMPBT(bt);
509 #define TMP_CONST(t) ((t)->flags & LOC_NUM && !((t)->flags & TMP_ADDR))
510 #define LOCAL_PTR(t) ((t)->flags & LOC_LOCAL && !((t)->flags & TMP_ADDR))
511 #define SYM_PTR(t) ((t)->flags & LOC_LOCAL && !((t)->flags & TMP_ADDR))
513 int o_popnum(long *c)
515 struct tmp *t = &tmp[ntmp - 1];
516 if (!TMP_CONST(t))
517 return 1;
518 *c = t->addr;
519 o_tmpdrop(1);
520 return 0;
523 static int c_binop(long (*cop)(long a, long b, unsigned bt), unsigned bt)
525 struct tmp *t1 = &tmp[ntmp - 1];
526 struct tmp *t2 = &tmp[ntmp - 2];
527 int locals = LOCAL_PTR(t1) + LOCAL_PTR(t2);
528 int syms = SYM_PTR(t1) + SYM_PTR(t2);
529 int nums = TMP_CONST(t1) + TMP_CONST(t2);
530 if (syms == 2 || syms && locals || syms + nums + locals != 2)
531 return 1;
532 if (!bt) {
533 if (!locals)
534 bt = syms ? 8 : bt_op(t1->bt, t2->bt);
535 if (locals == 1)
536 bt = 8;
537 if (locals == 2)
538 bt = 4 | BT_SIGNED;
540 if (syms) {
541 long o1 = SYM_PTR(t1) ? t1->off : t1->addr;
542 long o2 = SYM_PTR(t2) ? t2->off : t2->addr;
543 long ret = cop(o2, o1, bt);
544 if (!SYM_PTR(t2))
545 o_tmpswap();
546 t2->off = ret;
547 o_tmpdrop(1);
548 } else {
549 long ret = cop(t2->addr, t1->addr, locals ? 4 | BT_SIGNED : bt);
550 o_tmpdrop(2);
551 if (locals == 1) {
552 o_local(-ret, bt);
553 o_addr();
554 } else {
555 o_num(ret, bt);
558 return 0;
561 static int c_op(long (*cop)(long a, unsigned bt), unsigned bt)
563 struct tmp *t1 = &tmp[ntmp - 1];
564 long ret;
565 if (!TMP_CONST(t1))
566 return 1;
567 if (!bt)
568 bt = t1->bt;
569 ret = cop(t1->addr, bt);
570 o_tmpdrop(1);
571 o_num(ret, bt);
572 return 0;
575 static void shx(int uop, int sop)
577 struct tmp *t = &tmp[ntmp - 2];
578 unsigned bt;
579 unsigned reg = TMP_REG2(t, R_RCX);
580 tmp_pop(1, R_RCX);
581 bt = tmp_pop(1, reg);
582 regop1(SHX_REG, bt & BT_SIGNED ? sop : uop, reg, BT_TMPBT(bt));
583 tmp_push_reg(bt, reg);
586 static long c_shl(long a, long b, unsigned bt)
588 return a << b;
591 void o_shl(void)
593 if (!c_binop(c_shl, 0))
594 return;
595 shx(4, 4);
598 static long c_shr(long a, long b, unsigned bt)
600 if (bt & BT_SIGNED)
601 return a >> b;
602 else
603 return (unsigned long) a >> b;
606 void o_shr(void)
608 if (!c_binop(c_shr, 0))
609 return;
610 shx(5, 7);
613 static int mulop(int uop, int sop, int reg)
615 struct tmp *t1 = &tmp[ntmp - 1];
616 struct tmp *t2 = &tmp[ntmp - 2];
617 int bt1 = TMP_BT(t1);
618 int bt2 = TMP_BT(t2);
619 int bt = bt_op(bt1, bt2);
620 if (t1->flags & LOC_REG && t1->addr != R_RAX && t1->addr != R_RDX)
621 reg = t1->addr;
622 reg_for(reg, t1);
623 tmp_reg(t1, reg, bt, 1);
624 reg_for(R_RAX, t2);
625 tmp_reg(t2, R_RAX, bt, 1);
626 if (reg != R_RDX) {
627 int cqo = 0x99;
628 reg_free(R_RDX);
629 if (bt & BT_SIGNED)
630 o_op(&cqo, 1, R_RAX, R_RDX, bt);
631 else
632 regop1(XOR_R2X, R_RDX, R_RDX, bt);
634 o_tmpdrop(2);
635 regop1(MUL_A2X, bt & BT_SIGNED ? sop : uop, reg, BT_TMPBT(bt2));
636 return bt;
639 static long c_mul(long a, long b, unsigned bt)
641 return a * b;
644 void o_mul(void)
646 int bt;
647 if (!c_binop(c_mul, 0))
648 return;
649 bt = mulop(4, 5, R_RDX);
650 tmp_push_reg(bt, R_RAX);
653 static long c_div(long a, long b, unsigned bt)
655 return a / b;
658 void o_div(void)
660 int bt;
661 if (!c_binop(c_div, 0))
662 return;
663 bt = mulop(6, 7, R_RCX);
664 tmp_push_reg(bt, R_RAX);
667 static long c_mod(long a, long b, unsigned bt)
669 return a % b;
672 void o_mod(void)
674 int bt;
675 if (!c_binop(c_mod, 0))
676 return;
677 bt = mulop(6, 7, R_RCX);
678 tmp_push_reg(bt, R_RDX);
681 void o_addr(void)
683 tmp[ntmp - 1].flags &= ~TMP_ADDR;
684 tmp[ntmp - 1].bt = 8;
687 void o_ret(unsigned bt)
689 if (bt)
690 tmp_pop_bt(bt, R_RAX);
691 else
692 os("\x31\xc0", 2); /* xor %eax, %eax */
693 ret[nret++] = o_jmp(0);
696 static int binop(int op, int *reg)
698 struct tmp *t1 = &tmp[ntmp - 1];
699 struct tmp *t2 = &tmp[ntmp - 2];
700 int r1;
701 unsigned bt;
702 r1 = TMP_REG(t1);
703 *reg = TMP_REG2(t2, r1);
704 bt = bt_op(t1->bt, t2->bt);
705 tmp_pop_bt(bt, r1);
706 tmp_pop_bt(bt, *reg);
707 regop1(op, *reg, r1, bt);
708 return bt;
711 static long c_add(long a, long b, unsigned bt)
713 return a + b;
716 void o_add(void)
718 int reg;
719 int bt;
720 if (!c_binop(c_add, 0))
721 return;
722 bt = binop(ADD_R2X, &reg);
723 tmp_push_reg(bt, reg);
726 static long c_xor(long a, long b, unsigned bt)
728 return a ^ b;
731 void o_xor(void)
733 int reg;
734 int bt;
735 if (!c_binop(c_xor, 0))
736 return;
737 bt = binop(XOR_R2X, &reg);
738 tmp_push_reg(bt, reg);
741 static long c_and(long a, long b, unsigned bt)
743 return a & b;
746 void o_and(void)
748 int reg;
749 int bt;
750 if (!c_binop(c_and, 0))
751 return;
752 bt = binop(AND_R2X, &reg);
753 tmp_push_reg(bt, reg);
756 static long c_or(long a, long b, unsigned bt)
758 return a | b;
761 void o_or(void)
763 int reg;
764 int bt;
765 if (!c_binop(c_or, 0))
766 return;
767 bt = binop(OR_R2X, &reg);
768 tmp_push_reg(bt, reg);
771 static long c_sub(long a, long b, unsigned bt)
773 return a - b;
776 void o_sub(void)
778 int reg;
779 int bt;
780 if (!c_binop(c_sub, 0))
781 return;
782 bt = binop(SUB_R2X, &reg);
783 tmp_push_reg(bt, reg);
786 static void o_cmp(int uop, int sop)
788 char set[] = "\x0f\x00\xc0";
789 int reg;
790 int bt = binop(CMP_R2X, &reg);
791 set[1] = bt & BT_SIGNED ? sop : uop;
792 reg_free(R_RAX);
793 cmp_setl = codeaddr();
794 os(set, 3); /* setl %al */
795 os("\x0f\xb6\xc0", 3); /* movzbl %al, %eax */
796 tmp_push_reg(4 | BT_SIGNED, R_RAX);
797 cmp_last = codeaddr();
800 static long c_lt(long a, long b, unsigned bt)
802 return a < b;
805 void o_lt(void)
807 if (!c_binop(c_lt, 4))
808 return;
809 o_cmp(0x92, 0x9c);
812 static long c_gt(long a, long b, unsigned bt)
814 return a > b;
817 void o_gt(void)
819 if (!c_binop(c_gt, 4))
820 return;
821 o_cmp(0x97, 0x9f);
824 static long c_le(long a, long b, unsigned bt)
826 return a <= b;
829 void o_le(void)
831 if (!c_binop(c_le, 4))
832 return;
833 o_cmp(0x96, 0x9e);
836 static long c_ge(long a, long b, unsigned bt)
838 return a >= b;
841 void o_ge(void)
843 if (!c_binop(c_ge, 4))
844 return;
845 o_cmp(0x93, 0x9d);
848 static long c_eq(long a, long b, unsigned bt)
850 return a == b;
853 void o_eq(void)
855 if (!c_binop(c_eq, 4))
856 return;
857 o_cmp(0x94, 0x94);
860 static long c_neq(long a, long b, unsigned bt)
862 return a != b;
865 void o_neq(void)
867 if (!c_binop(c_neq, 4))
868 return;
869 o_cmp(0x95, 0x95);
872 static long c_lnot(long a, unsigned bt)
874 return !a;
877 void o_lnot(void)
879 if (!c_op(c_lnot, 4))
880 return;
881 if (cmp_last == codeaddr()) {
882 buf[cmp_setl + 1] ^= 0x10;
883 } else {
884 o_num(0, 4 | BT_SIGNED);
885 o_eq();
889 static long c_neg(long a, unsigned bt)
891 return -a;
894 void o_neg(void)
896 struct tmp *t = &tmp[ntmp - 1];
897 int reg;
898 unsigned bt = BT_TMPBT(t->bt);
899 if (!c_op(c_neg, t->bt | BT_SIGNED))
900 return;
901 reg = TMP_REG(t);
902 tmp_pop_bt(bt, reg);
903 regop1(NEG_REG, 3, reg, bt);
904 tmp_push_reg(bt, reg);
907 static long c_not(long a, unsigned bt)
909 return ~a;
912 void o_not(void)
914 struct tmp *t = &tmp[ntmp - 1];
915 int reg;
916 unsigned bt = BT_TMPBT(t->bt);
917 if (!c_op(c_not, 0))
918 return;
919 reg = TMP_REG(t);
920 tmp_pop_bt(bt, reg);
921 regop1(NOT_REG, 2, reg, bt);
922 tmp_push_reg(t->bt, reg);
925 void o_func_end(void)
927 int i;
928 for (i = 0; i < nret; i++)
929 o_filljmp(ret[i]);
930 os("\xc9\xc3", 2); /* leave; ret; */
931 putint(buf + spsub_addr, (maxsp + 7) & ~0x07, 4);
932 out_func_end(buf, cur - buf);
935 long o_mklocal(int size)
937 return sp_push((size + 7) & ~0x07);
940 void o_rmlocal(long addr, int sz)
942 sp = addr - sz;
945 static int arg_regs[] = {R_RDI, R_RSI, R_RDX, R_RCX, R_R8, R_R9};
947 #define R_NARGS ARRAY_SIZE(arg_regs)
949 long o_arg(int i, unsigned bt)
951 long addr;
952 if (i < R_NARGS) {
953 addr = o_mklocal(BT_SZ(bt));
954 memop1(MOV_R2X, arg_regs[i], R_RBP, -addr, bt);
955 } else {
956 addr = -8 * (i - R_NARGS + 2);
958 return addr;
961 void o_assign(unsigned bt)
963 struct tmp *t1 = &tmp[ntmp - 1];
964 struct tmp *t2 = &tmp[ntmp - 2];
965 int r1 = BT_SZ(bt) > 1 ? TMP_REG(t1) : TMP_BYTEREG(t1);
966 int reg;
967 int off;
968 tmp_pop_bt(BT_TMPBT(bt), r1);
969 if (t2->flags & LOC_LOCAL) {
970 reg = R_RBP;
971 off = t2->addr;
972 o_tmpdrop(1);
973 } else {
974 reg = TMP_REG2(t2, r1);
975 off = 0;
976 tmp_pop(0, reg);
978 memop1(MOV_R2X, r1, reg, off, bt);
979 tmp_push_reg(bt, r1);
982 static void tmp_to(struct tmp *t, int reg)
984 reg_for(reg, t);
985 tmp_reg(t, reg, t->bt, 0);
988 void o_memcpy(int sz)
990 struct tmp *t0 = &tmp[ntmp];
991 struct tmp *t1 = &tmp[ntmp - 1];
992 struct tmp *t2 = &tmp[ntmp - 2];
993 o_num(sz, 4);
994 tmp_to(t0, R_RCX);
995 tmp_to(t1, R_RSI);
996 tmp_to(t2, R_RDI);
997 os("\xf3\xa4", 2); /* rep movs */
998 o_tmpdrop(2);
1001 void o_memset(int x, int sz)
1003 struct tmp *t0 = &tmp[ntmp + 1];
1004 struct tmp *t1 = &tmp[ntmp];
1005 struct tmp *t2 = &tmp[ntmp - 1];
1006 o_num(sz, 4);
1007 o_num(x, 4);
1008 tmp_to(t0, R_RAX);
1009 tmp_to(t1, R_RCX);
1010 tmp_to(t2, R_RDI);
1011 os("\xf3\xaa", 2); /* rep stosb */
1012 o_tmpdrop(2);
1015 long o_mklabel(void)
1017 return codeaddr();
1020 static long jx(int x, long addr)
1022 char op[2] = {0x0f};
1023 op[1] = x;
1024 os(op, 2); /* jx $addr */
1025 oi(addr - codeaddr() - 4, 4);
1026 return codeaddr() - 4;
1029 static long jxtest(int x, long addr)
1031 int bt = tmp_pop(1, R_RAX);
1032 regop1(TEST_R2R, R_RAX, R_RAX, bt);
1033 return jx(x, addr);
1036 static long jxcmp(long addr, int inv)
1038 int x;
1039 if (codeaddr() != cmp_last)
1040 return -1;
1041 o_tmpdrop(1);
1042 cur = buf + cmp_setl;
1043 x = (unsigned char) buf[cmp_setl + 1];
1044 return jx((inv ? x : x ^ 0x01) & ~0x10, addr);
1047 long o_jz(long addr)
1049 long ret = jxcmp(addr, 0);
1050 return ret != -1 ? ret : jxtest(0x84, addr);
1053 long o_jnz(long addr)
1055 long ret = jxcmp(addr, 1);
1056 return ret != -1 ? ret : jxtest(0x85, addr);
1059 long o_jmp(long addr)
1061 os("\xe9", 1); /* jmp $addr */
1062 oi(addr - codeaddr() - 4, 4);
1063 return codeaddr() - 4;
1066 void o_filljmp2(long addr, long jmpdst)
1068 putint(buf + addr, jmpdst - addr - 4, 4);
1071 void o_filljmp(long addr)
1073 o_filljmp2(addr, codeaddr());
1076 void o_call(int argc, unsigned *bt, unsigned ret_bt)
1078 int i;
1079 struct tmp *t;
1080 for (i = 0; i < ARRAY_SIZE(tmpregs); i++)
1081 if (regs[tmpregs[i]] && regs[tmpregs[i]] - tmp < ntmp - argc)
1082 tmp_mem(regs[tmpregs[i]]);
1083 if (argc > R_NARGS) {
1084 long addr = sp_push(8 * (argc - R_NARGS));
1085 for (i = argc - 1; i >= R_NARGS; --i) {
1086 int reg = TMP_REG(&tmp[ntmp - 1]);
1087 tmp_pop_bt(bt[i], reg);
1088 memop1(MOV_R2X, reg, R_RBP,
1089 -(addr - (i - R_NARGS) * 8), BT_TMPBT(bt[i]));
1092 for (i = MIN(argc, R_NARGS) - 1; i >= 0; i--)
1093 tmp_pop_bt(bt[i], arg_regs[i]);
1094 t = &tmp[ntmp - 1];
1095 if (t->flags & LOC_SYM) {
1096 os("\x31\xc0", 2); /* xor %eax, %eax */
1097 os("\xe8", 1); /* call $x */
1098 if (!nogen)
1099 out_rela(t->addr, codeaddr(), 1);
1100 oi(-4 + t->off, 4);
1101 o_tmpdrop(1);
1102 } else {
1103 tmp_pop(0, R_RAX);
1104 regop1(CALL_REG, 2, R_RAX, 4);
1106 if (ret_bt)
1107 tmp_push_reg(ret_bt, R_RAX);
1110 int o_nogen(void)
1112 return nogen++;
1115 void o_dogen(void)
1117 nogen = 0;
1120 void o_datset(long addr, int off, unsigned bt)
1122 struct tmp *t = &tmp[ntmp - 1];
1123 if (t->flags & LOC_NUM && !(t->flags & TMP_ADDR)) {
1124 num_cast(t, bt);
1125 out_datcpy(addr, off, (void *) &t->addr, BT_SZ(bt));
1127 if (t->flags & LOC_SYM && !(t->flags & TMP_ADDR)) {
1128 out_datrela(tmp->addr, addr, off);
1129 out_datcpy(addr, off, (void *) &t->off, BT_SZ(bt));
1131 o_tmpdrop(1);