?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
int: load constant call arguments as late as possible
[neatcc.git] / x64.c
blobd092fe1e894b02b7da6a8bded6db030c27b5e950
1 /* architecture-dependent code generation for x86_64 */
2 #include <stdlib.h>
3 #include "ncc.h"
4
5 /* x86-64 registers, without r8-r15 */
6 #define R_RAX 0x00
7 #define R_RCX 0x01
8 #define R_RDX 0x02
9 #define R_RBX 0x03
10 #define R_RSP 0x04
11 #define R_RBP 0x05
12 #define R_RSI 0x06
13 #define R_RDI 0x07
14
15 #define REG_RET R_RAX
16
17 /* x86 opcodes */
18 #define I_MOV 0x89
19 #define I_MOVI 0xc7
20 #define I_MOVIR 0xb8
21 #define I_MOVR 0x8b
22 #define I_MOVSXD 0x63
23 #define I_SHX 0xd3
24 #define I_CMP 0x3b
25 #define I_TST 0x85
26 #define I_LEA 0x8d
27 #define I_NOT 0xf7
28 #define I_CALL 0xff
29 #define I_MUL 0xf7
30 #define I_XOR 0x33
31 #define I_CQO 0x99
32 #define I_PUSH 0x50
33 #define I_POP 0x58
34
35 #define MIN(a, b) ((a) < (b) ? (a) : (b))
36 #define ALIGN(x, a) (((x) + (a) - 1) & ~((a) - 1))
37
38 int tmpregs[] = {0, 7, 6, 2, 1, 8, 9, 10, 11, 3, 12, 13, 14, 15};
39 int argregs[] = {7, 6, 2, 1, 8, 9};
40
41 #define OP2(o2, o1) (0x010000 | ((o2) << 8) | (o1))
42 #define O2(op) (((op) >> 8) & 0xff)
43 #define O1(op) ((op) & 0xff)
44 #define MODRM(m, r1, r2) ((m) << 6 | (r1) << 3 | (r2))
45 #define REX(r1, r2) (0x48 | (((r1) & 8) >> 1) | (((r2) & 8) >> 3))
46
47 static struct mem cs; /* generated code */
48
49 /* code generation functions */
50 static void os(void *s, int n)
51 {
52 mem_put(&cs, s, n);
53 }
54
55 static char *ointbuf(long n, int l)
56 {
57 static char buf[16];
58 int i;
59 for (i = 0; i < l; i++) {
60 buf[i] = n & 0xff;
61 n >>= 8;
62 }
63 return buf;
64 }
65
66 static void oi(long n, int l)
67 {
68 mem_put(&cs, ointbuf(n, l), l);
69 }
70
71 static void oi_at(long pos, long n, int l)
72 {
73 mem_cpy(&cs, pos, ointbuf(n, l), l);
74 }
75
76 static long opos(void)
77 {
78 return mem_len(&cs);
79 }
80
81 static void op_x(int op, int r1, int r2, int bt)
82 {
83 int sz = T_SZ(bt);
84 int rex = 0;
85 if (sz == 8)
86 rex |= 8;
87 if (sz == 1)
88 rex |= 0x40;
89 if (r1 & 0x8)
90 rex |= 4;
91 if (r2 & 0x8)
92 rex |= 1;
93 if (sz == 2)
94 oi(0x66, 1);
95 if (rex)
96 oi(rex | 0x40, 1);
97 if (op & 0x10000)
98 oi(O2(op), 1);
99 oi(sz == 1 ? O1(op) & ~0x1 : O1(op), 1);
100 }
101
102 #define op_mr op_rm
103
104 /* op_*(): r=reg, m=mem, i=imm, s=sym */
105 static void op_rm(int op, int src, int base, int off, int bt)
106 {
107 int dis = off == (char) off ? 1 : 4;
108 int mod = dis == 4 ? 2 : 1;
109 if (!off && (base & 7) != R_RBP)
110 mod = 0;
111 op_x(op, src, base, bt);
112 oi(MODRM(mod, src & 0x07, base & 0x07), 1);
113 if ((base & 7) == R_RSP)
114 oi(0x24, 1);
115 if (mod)
116 oi(off, dis);
117 }
118
119 static void op_rr(int op, int src, int dst, int bt)
120 {
121 op_x(op, src, dst, bt);
122 oi(MODRM(3, src & 0x07, dst & 0x07), 1);
123 }
124
125 #define movrx_bt(bt) (((bt) == 4) ? 4 : LONGSZ)
126
127 static int movrx_op(int bt, int mov)
128 {
129 int sz = T_SZ(bt);
130 if (sz == 4)
131 return bt & T_MSIGN ? I_MOVSXD : mov;
132 if (sz == 2)
133 return OP2(0x0f, bt & T_MSIGN ? 0xbf : 0xb7);
134 if (sz == 1)
135 return OP2(0x0f, bt & T_MSIGN ? 0xbe : 0xb6);
136 return mov;
137 }
138
139 static void mov_r2r(int rd, int r1, unsigned bt)
140 {
141 if (rd != r1 || T_SZ(bt) != LONGSZ)
142 op_rr(movrx_op(bt, I_MOVR), rd, r1, movrx_bt(bt));
143 }
144
145 static void i_push(int reg)
146 {
147 op_x(I_PUSH | (reg & 0x7), 0, reg, LONGSZ);
148 }
149
150 void i_mov(int rd, int rn)
151 {
152 op_rr(movrx_op(LONGSZ, I_MOVR), rd, rn, movrx_bt(LONGSZ));
153 }
154
155 static void i_add(int op, int rd, int r1, int r2)
156 {
157 /* opcode for O_ADD, O_SUB, O_AND, O_OR, O_XOR */
158 static int rx[] = {0003, 0053, 0043, 0013, 0063};
159 op_rr(rx[op & 0x0f], rd, r2, LONGSZ);
160 }
161
162 static void i_add_imm(int op, int rd, int rn, long n)
163 {
164 /* opcode for O_ADD, O_SUB, O_AND, O_OR, O_XOR */
165 static int rx[] = {0xc0, 0xe8, 0xe0, 0xc8, 0xf0};
166 unsigned char s[4] = {REX(0, rd), 0x83, rx[op & 0x0f] | (rd & 7), n & 0xff};
167 os((void *) s, 4);
168 }
169
170 static void i_num(int rd, long n)
171 {
172 if (!n) {
173 op_rr(I_XOR, rd, rd, 4);
174 return;
175 }
176 if (n < 0 && -n <= 0xffffffff) {
177 op_rr(I_MOVI, 0, rd, LONGSZ);
178 oi(n, 4);
179 } else {
180 int len = 8;
181 if (n > 0 && n <= 0xffffffff)
182 len = 4;
183 op_x(I_MOVIR + (rd & 7), 0, rd, len);
184 oi(n, len);
185 }
186 }
187
188 static void i_mul(int rd, int r1, int r2)
189 {
190 if (r2 != R_RDX)
191 i_num(R_RDX, 0);
192 op_rr(I_MUL, 4, r2, LONGSZ);
193 }
194
195 static void i_div(int op, int rd, int r1, int r2)
196 {
197 long bt = O_T(op);
198 if (r2 != R_RDX) {
199 if (bt & T_MSIGN)
200 op_x(I_CQO, R_RAX, R_RDX, LONGSZ);
201 else
202 i_num(R_RDX, 0);
203 }
204 op_rr(I_MUL, bt & T_MSIGN ? 7 : 6, r2, LONGSZ);
205 }
206
207 static void i_tst(int rn, int rm)
208 {
209 op_rr(I_TST, rn, rm, LONGSZ);
210 }
211
212 static void i_cmp(int rn, int rm)
213 {
214 op_rr(I_CMP, rn, rm, LONGSZ);
215 }
216
217 static void i_cmp_imm(int rn, long n)
218 {
219 unsigned char s[4] = {REX(0, rn), 0x83, 0xf8 | rn, n & 0xff};
220 os(s, 4);
221 }
222
223 static void i_shl(int op, int rd, int r1, int rs)
224 {
225 long bt = O_T(op);
226 int sm = 4;
227 if ((op & 0x0f) == 1)
228 sm = bt & T_MSIGN ? 7 : 5;
229 op_rr(I_SHX, sm, rd, LONGSZ);
230 }
231
232 static void i_shl_imm(int op, int rd, int rn, long n)
233 {
234 long bt = O_T(op);
235 int sm = (op & 0x1) ? (bt & T_MSIGN ? 0xf8 : 0xe8) : 0xe0;
236 char s[4] = {REX(0, rn), 0xc1, sm | (rn & 7), n & 0xff};
237 os(s, 4);
238 }
239
240 static void i_neg(int rd)
241 {
242 op_rr(I_NOT, 3, rd, LONGSZ);
243 }
244
245 static void i_not(int rd)
246 {
247 op_rr(I_NOT, 2, rd, LONGSZ);
248 }
249
250 static int i_cond(long op)
251 {
252 /* lt, ge, eq, ne, le, gt */
253 static int ucond[] = {0x92, 0x93, 0x94, 0x95, 0x96, 0x97};
254 static int scond[] = {0x9c, 0x9d, 0x94, 0x95, 0x9e, 0x9f};
255 long bt = O_T(op);
256 return bt & T_MSIGN ? scond[op & 0x0f] : ucond[op & 0x0f];
257 }
258
259 static void i_set(long op, int rd)
260 {
261 char set[] = "\x0f\x00\xc0";
262 set[1] = i_cond(op);
263 os(set, 3); /* setl al */
264 os("\x48\x0f\xb6\xc0", 4); /* movzx rax, al */
265 }
266
267 static void i_lnot(int rd)
268 {
269 char cmp[] = "\x00\x83\xf8\x00";
270 cmp[0] = REX(0, rd);
271 cmp[2] |= rd & 7;
272 os(cmp, 4); /* cmp rax, 0 */
273 i_set(O_EQ, rd);
274 }
275
276 static void jx(int x, int nbytes)
277 {
278 char op[2] = {0x0f};
279 if (nbytes == 1) {
280 op[0] = 0x70 | (x & 0x0f);
281 os(op, 1); /* jx $addr */
282 } else {
283 op[1] = x;
284 os(op, 2); /* jx $addr */
285 }
286 }
287
288 /* generate cmp or tst before a conditional jump */
289 static void i_jcmp(long op, long rn, long rm)
290 {
291 if (op & O_JZ)
292 i_tst(rn, rn);
293 if (op & O_JCC) {
294 if (op & O_NUM)
295 i_cmp_imm(rn, rm);
296 else
297 i_cmp(rn, rm);
298 }
299 }
300
301 /* generate a jump instruction and return the of its displacement */
302 static long i_jmp(long op, int nb)
303 {
304 if (op & O_JZ)
305 jx(O_C(op) == O_JZ ? 0x84 : 0x85, nb);
306 else if (op & O_JCC)
307 jx(i_cond(op) & ~0x10, nb);
308 else
309 os(nb == 1 ? "\xeb" : "\xe9", 1);
310 oi(0, nb);
311 return opos() - nb;
312 }
313
314 /* the length of a jump instruction opcode */
315 static int i_jlen(long op, int nb)
316 {
317 if (op & (O_JZ | O_JCC))
318 return nb ? 2 : 1;
319 return 1;
320 }
321
322 /* zero extend */
323 static void i_zx(int rd, int r1, int bits)
324 {
325 if (bits & 0x07) {
326 i_shl_imm(O_SHL, rd, rd, LONGSZ * 8 - bits);
327 i_shl_imm(O_SHR, rd, rd, LONGSZ * 8 - bits);
328 } else {
329 mov_r2r(rd, r1, bits >> 3);
330 }
331 }
332
333 /* sign extend */
334 static void i_sx(int rd, int r1, int bits)
335 {
336 mov_r2r(rd, r1, T_MSIGN | (bits >> 3));
337 }
338
339 static void i_cast(int rd, int rn, int bt)
340 {
341 if (T_SZ(bt) == 8) {
342 if (rd != rn)
343 i_mov(rd, rn);
344 } else {
345 if (bt & T_MSIGN)
346 i_sx(rd, rn, T_SZ(bt) * 8);
347 else
348 i_zx(rd, rn, T_SZ(bt) * 8);
349 }
350 }
351
352 static void i_add_anyimm(int rd, int rn, long n)
353 {
354 op_rm(I_LEA, rd, rn, n, LONGSZ);
355 }
356
357 static long *rel_sym; /* relocation symbols */
358 static long *rel_flg; /* relocation flags */
359 static long *rel_off; /* relocation offsets */
360 static long rel_n, rel_sz; /* relocation count */
361
362 static long lab_sz; /* label count */
363 static long *lab_loc; /* label offsets in cs */
364 static long jmp_n, jmp_sz; /* jump count */
365 static long *jmp_off; /* jump offsets */
366 static long *jmp_dst; /* jump destinations */
367 static long *jmp_op; /* jump opcode */
368 static long jmp_ret; /* the position of the last return jmp */
369
370 static void lab_add(long id)
371 {
372 while (id >= lab_sz) {
373 int lab_n = lab_sz;
374 lab_sz = MAX(128, lab_sz * 2);
375 lab_loc = mextend(lab_loc, lab_n, lab_sz, sizeof(*lab_loc));
376 }
377 lab_loc[id] = opos();
378 }
379
380 static void jmp_add(long op, long off, long dst)
381 {
382 if (jmp_n == jmp_sz) {
383 jmp_sz = MAX(128, jmp_sz * 2);
384 jmp_off = mextend(jmp_off, jmp_n, jmp_sz, sizeof(*jmp_off));
385 jmp_dst = mextend(jmp_dst, jmp_n, jmp_sz, sizeof(*jmp_dst));
386 jmp_op = mextend(jmp_op, jmp_n, jmp_sz, sizeof(*jmp_op));
387 }
388 jmp_off[jmp_n] = off;
389 jmp_dst[jmp_n] = dst;
390 jmp_op[jmp_n] = op;
391 jmp_n++;
392 }
393
394 void i_label(long id)
395 {
396 lab_add(id + 1);
397 }
398
399 static void i_rel(long sym, long flg, long off)
400 {
401 if (rel_n == rel_sz) {
402 rel_sz = MAX(128, rel_sz * 2);
403 rel_sym = mextend(rel_sym, rel_n, rel_sz, sizeof(*rel_sym));
404 rel_flg = mextend(rel_flg, rel_n, rel_sz, sizeof(*rel_flg));
405 rel_off = mextend(rel_off, rel_n, rel_sz, sizeof(*rel_off));
406 }
407 rel_sym[rel_n] = sym;
408 rel_flg[rel_n] = flg;
409 rel_off[rel_n] = off;
410 rel_n++;
411 }
412
413 static void i_sym(int rd, int sym, int off)
414 {
415 int sz = X64_ABS_RL & OUT_RL32 ? 4 : LONGSZ;
416 if (X64_ABS_RL & OUT_RLSX)
417 op_rr(I_MOVI, 0, rd, sz);
418 else
419 op_x(I_MOVIR + (rd & 7), 0, rd, sz);
420 i_rel(sym, OUT_CS | X64_ABS_RL, opos());
421 oi(off, sz);
422 }
423
424 static void i_saveargs(long sargs)
425 {
426 int i;
427 os("\x58", 1); /* pop rax */
428 for (i = N_ARGS - 1; i >= 0; i--)
429 if ((1 << argregs[i]) & sargs)
430 i_push(argregs[i]);
431 os("\x50", 1); /* push rax */
432 }
433
434 static void i_saveregs(long sregs, long sregs_pos, int st)
435 {
436 int nsregs = 0;
437 int i;
438 for (i = 0; i < N_TMPS; i++)
439 if ((1 << tmpregs[i]) & sregs)
440 op_rm(st ? I_MOV : I_MOVR, tmpregs[i], REG_FP,
441 sregs_pos + nsregs++ * ULNG, ULNG);
442 }
443
444 void i_wrap(int argc, long sargs, long spsub, int initfp, long sregs, long sregs_pos)
445 {
446 long body_n;
447 void *body;
448 long diff; /* prologue length */
449 int nsargs = 0; /* number of saved arguments */
450 int mod16; /* 16-byte alignment */
451 int i;
452 /* removing the last jmp to the epilogue */
453 if (jmp_ret + i_jlen(O_JMP, 4) + 4 == opos()) {
454 mem_cut(&cs, jmp_ret);
455 jmp_n--;
456 }
457 lab_add(0); /* the return label */
458 body_n = mem_len(&cs);
459 body = mem_get(&cs);
460 /* generating function prologue */
461 if (sargs)
462 i_saveargs(sargs);
463 if (initfp) {
464 os("\x55", 1); /* push rbp */
465 os("\x48\x89\xe5", 3); /* mov rbp, rsp */
466 }
467 for (i = 0; i < N_ARGS; i++)
468 if ((1 << argregs[i]) & sargs)
469 nsargs++;
470 mod16 = (spsub + nsargs * LONGSZ) % 16; /* forcing 16-byte alignment */
471 if (spsub) {
472 os("\x48\x81\xec", 3);
473 spsub = spsub + (16 - mod16);
474 oi(spsub, 4);
475 }
476 i_saveregs(sregs, sregs_pos, 1); /* saving registers */
477 diff = mem_len(&cs);
478 mem_put(&cs, body, body_n);
479 free(body);
480 /* generating function epilogue */
481 i_saveregs(sregs, sregs_pos, 0); /* restoring saved registers */
482 if (initfp)
483 os("\xc9", 1); /* leave */
484 if (sargs) {
485 os("\xc2", 1); /* ret n */
486 oi(nsargs * LONGSZ, 2);
487 } else {
488 os("\xc3", 1); /* ret */
489 }
490 /* adjusting code offsets */
491 for (i = 0; i < rel_n; i++)
492 rel_off[i] += diff;
493 for (i = 0; i < jmp_n; i++)
494 jmp_off[i] += diff;
495 for (i = 0; i < lab_sz; i++)
496 lab_loc[i] += diff;
497 }
498
499 /* introduce shorter jumps, if possible */
500 static void i_shortjumps(int *nb)
501 {
502 long off = 0; /* current code offset */
503 long dif = 0; /* the difference after changing jump instructions */
504 int rel = 0; /* current relocation */
505 int lab = 1; /* current label */
506 long c_len = mem_len(&cs);
507 char *c = mem_get(&cs);
508 int i;
509 for (i = 0; i < jmp_n; i++)
510 nb[i] = abs(lab_loc[jmp_dst[i]] - jmp_off[i]) < 0x70 ? 1 : 4;
511 for (i = 0; i < jmp_n; i++) {
512 long cur = jmp_off[i] - i_jlen(jmp_op[i], 4);
513 while (rel < rel_n && rel_off[rel] <= cur)
514 rel_off[rel++] += dif;
515 while (lab < lab_sz && lab_loc[lab] <= cur)
516 lab_loc[lab++] += dif;
517 mem_put(&cs, c + off, cur - off);
518 jmp_off[i] = i_jmp(jmp_op[i], nb[i]);
519 off = cur + i_jlen(jmp_op[i], 4) + 4;
520 dif = mem_len(&cs) - off;
521 }
522 while (rel < rel_n)
523 rel_off[rel++] += dif;
524 while (lab < lab_sz)
525 lab_loc[lab++] += dif;
526 lab_loc[0] += dif;
527 mem_put(&cs, c + off, c_len - off);
528 free(c);
529 }
530
531 void i_code(char **c, long *c_len, long **rsym, long **rflg, long **roff, long *rcnt)
532 {
533 int *nb; /* number of bytes necessary for jump displacements */
534 int i;
535 /* more compact jmp instructions */
536 nb = malloc(jmp_n * sizeof(nb[0]));
537 for (i = 0; i < jmp_n; i++)
538 nb[i] = 4;
539 i_shortjumps(nb);
540 for (i = 0; i < jmp_n; i++) /* filling jmp destinations */
541 oi_at(jmp_off[i], lab_loc[jmp_dst[i]] -
542 jmp_off[i] - nb[i], nb[i]);
543 free(nb);
544 *c_len = mem_len(&cs);
545 *c = mem_get(&cs);
546 *rsym = rel_sym;
547 *rflg = rel_flg;
548 *roff = rel_off;
549 *rcnt = rel_n;
550 rel_sym = NULL;
551 rel_flg = NULL;
552 rel_off = NULL;
553 rel_n = 0;
554 rel_sz = 0;
555 jmp_n = 0;
556 }
557
558 void i_done(void)
559 {
560 free(jmp_off);
561 free(jmp_dst);
562 free(jmp_op);
563 free(lab_loc);
564 }
565
566 long i_reg(long op, long *rd, long *r1, long *r2, long *tmp)
567 {
568 int oc = O_C(op);
569 *rd = 0;
570 *r1 = 0;
571 *r2 = 0;
572 *tmp = 0;
573 if (oc & O_MOV) {
574 *rd = R_TMPS;
575 *r1 = oc & (O_NUM | O_SYM) ? 0 : R_TMPS;
576 return 0;
577 }
578 if (oc & O_ADD) {
579 *r1 = R_TMPS;
580 *r2 = oc & O_NUM ? (oc == O_ADD ? 32 : 8) : R_TMPS;
581 return 0;
582 }
583 if (oc & O_SHL) {
584 if (oc & O_NUM) {
585 *r1 = R_TMPS;
586 *r2 = 8;
587 } else {
588 *r2 = 1 << R_RCX;
589 *r1 = R_TMPS & ~*r2;
590 }
591 return 0;
592 }
593 if (oc & O_MUL) {
594 if (oc & O_NUM)
595 return 1;
596 *rd = oc == O_MOD ? (1 << R_RDX) : (1 << R_RAX);
597 *r1 = (1 << R_RAX);
598 *r2 = R_TMPS & ~*rd & ~*r1;
599 if (oc == O_DIV)
600 *r2 &= ~(1 << R_RDX);
601 *tmp = (1 << R_RDX) | (1 << R_RAX);
602 return 0;
603 }
604 if (oc & O_CMP) {
605 *rd = 1 << R_RAX;
606 *r1 = R_TMPS;
607 *r2 = oc & O_NUM ? 8 : R_TMPS;
608 return 0;
609 }
610 if (oc & O_UOP) {
611 *r1 = R_TMPS;
612 if (oc == O_LNOT)
613 *rd = 1 << R_RAX;
614 else
615 *rd = R_TMPS;
616 return 0;
617 }
618 if (oc == O_MSET) {
619 *rd = 1 << R_RDI;
620 *r1 = 1 << R_RAX;
621 *r2 = 1 << R_RCX;
622 *tmp = (1 << R_RDI) | (1 << R_RCX);
623 return 0;
624 }
625 if (oc == O_MCPY) {
626 *rd = 1 << R_RDI;
627 *r1 = 1 << R_RSI;
628 *r2 = 1 << R_RCX;
629 *tmp = (1 << R_RDI) | (1 << R_RSI) | (1 << R_RCX);
630 return 0;
631 }
632 if (oc == O_RET) {
633 *rd = (1 << REG_RET);
634 return 0;
635 }
636 if (oc & O_CALL) {
637 *rd = (1 << REG_RET);
638 *r1 = oc & O_SYM ? 0 : R_TMPS;
639 *tmp = R_TMPS & ~R_PERM;
640 return 0;
641 }
642 if (oc & (O_LD | O_ST)) {
643 *rd = R_TMPS;
644 *r1 = R_TMPS;
645 *r2 = oc & O_NUM ? 0 : R_TMPS;
646 return 0;
647 }
648 if (oc & O_JZ) {
649 *rd = R_TMPS;
650 return 0;
651 }
652 if (oc & O_JCC) {
653 *rd = R_TMPS;
654 *r1 = oc & O_NUM ? 8 : R_TMPS;
655 return 0;
656 }
657 if (oc == O_JMP)
658 return 0;
659 return 1;
660 }
661
662 int i_imm(long lim, long n)
663 {
664 long max = (1 << (lim - 1)) - 1;
665 return n <= max && n + 1 >= -max;
666 }
667
668 long i_ins(long op, long r0, long r1, long r2)
669 {
670 long oc = O_C(op);
671 long bt = O_T(op);
672 if (oc & O_ADD) {
673 if (oc & O_NUM) {
674 if (r0 == r1 && r2 <= 127 && r2 >= -128)
675 i_add_imm(op, r1, r1, r2);
676 else
677 i_add_anyimm(r0, r1, r2);
678 } else {
679 i_add(op, r1, r1, r2);
680 }
681 }
682 if (oc & O_SHL) {
683 if (oc & O_NUM)
684 i_shl_imm(op, r1, r1, r2);
685 else
686 i_shl(op, r1, r1, r2);
687 }
688 if (oc & O_MUL) {
689 if (oc == O_MUL)
690 i_mul(R_RAX, r1, r2);
691 if (oc == O_DIV)
692 i_div(op, R_RAX, r1, r2);
693 if (oc == O_MOD)
694 i_div(op, R_RDX, r1, r2);
695 return 0;
696 }
697 if (oc & O_CMP) {
698 if (oc & O_NUM)
699 i_cmp_imm(r1, r2);
700 else
701 i_cmp(r1, r2);
702 i_set(op, r0);
703 return 0;
704 }
705 if (oc & O_UOP) { /* uop */
706 if (oc == O_NEG)
707 i_neg(r1);
708 if (oc == O_NOT)
709 i_not(r1);
710 if (oc == O_LNOT)
711 i_lnot(r1);
712 return 0;
713 }
714 if (oc == O_CALL) {
715 op_rr(I_CALL, 2, r1, LONGSZ);
716 return 0;
717 }
718 if (oc == (O_CALL | O_SYM)) {
719 os("\xe8", 1); /* call $x */
720 i_rel(r1, OUT_CS | OUT_RLREL, opos());
721 oi(-4 + r2, 4);
722 return 0;
723 }
724 if (oc == (O_MOV | O_SYM)) {
725 i_sym(r0, r1, r2);
726 return 0;
727 }
728 if (oc == (O_MOV | O_NUM)) {
729 i_num(r0, r1);
730 return 0;
731 }
732 if (oc == O_MSET) {
733 os("\xfc\xf3\xaa", 3); /* cld; rep stosb */
734 return 0;
735 }
736 if (oc == O_MCPY) {
737 os("\xfc\xf3\xa4", 3); /* cld; rep movs */
738 return 0;
739 }
740 if (oc == O_RET) {
741 jmp_ret = opos();
742 jmp_add(O_JMP, i_jmp(op, 4), 0);
743 return 0;
744 }
745 if (oc == (O_LD | O_NUM)) {
746 op_rm(movrx_op(bt, I_MOVR), r0, r1, r2, movrx_bt(bt));
747 return 0;
748 }
749 if (oc == (O_ST | O_NUM)) {
750 op_rm(I_MOV, r0, r1, r2, bt);
751 return 0;
752 }
753 if (oc == O_MOV) {
754 i_cast(r0, r1, bt);
755 return 0;
756 }
757 if (oc & O_JXX) {
758 i_jcmp(op, r0, r1);
759 jmp_add(op, i_jmp(op, 4), r2 + 1);
760 return 0;
761 }
762 return 1;
763 }
A small ARM/x86(_64) C compiler