x86_64/elf: only variadic calls need rax
[tinycc.git] / i386-gen.c
blobeace2dfa26c58defd6b8baf9271d3dada57673d1
1 /*
2 * X86 code generator for TCC
3 *
4 * Copyright (c) 2001-2004 Fabrice Bellard
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 #ifdef TARGET_DEFS_ONLY
23 /* number of available registers */
24 #define NB_REGS 4
25 #define NB_ASM_REGS 8
27 /* a register can belong to several classes. The classes must be
28 sorted from more general to more precise (see gv2() code which does
29 assumptions on it). */
30 #define RC_INT 0x0001 /* generic integer register */
31 #define RC_FLOAT 0x0002 /* generic float register */
32 #define RC_EAX 0x0004
33 #define RC_ST0 0x0008
34 #define RC_ECX 0x0010
35 #define RC_EDX 0x0020
36 #define RC_IRET RC_EAX /* function return: integer register */
37 #define RC_LRET RC_EDX /* function return: second integer register */
38 #define RC_FRET RC_ST0 /* function return: float register */
40 /* pretty names for the registers */
41 enum {
42 TREG_EAX = 0,
43 TREG_ECX,
44 TREG_EDX,
45 TREG_ST0,
46 TREG_ESP = 4
49 /* return registers for function */
50 #define REG_IRET TREG_EAX /* single word int return register */
51 #define REG_LRET TREG_EDX /* second word return register (for long long) */
52 #define REG_FRET TREG_ST0 /* float return register */
54 /* defined if function parameters must be evaluated in reverse order */
55 #define INVERT_FUNC_PARAMS
57 /* defined if structures are passed as pointers. Otherwise structures
58 are directly pushed on stack. */
59 /* #define FUNC_STRUCT_PARAM_AS_PTR */
61 /* pointer size, in bytes */
62 #define PTR_SIZE 4
64 /* long double size and alignment, in bytes */
65 #define LDOUBLE_SIZE 12
66 #define LDOUBLE_ALIGN 4
67 /* maximum alignment (for aligned attribute support) */
68 #define MAX_ALIGN 8
71 #define psym oad
73 /******************************************************/
74 /* ELF defines */
76 #define EM_TCC_TARGET EM_386
78 /* relocation type for 32 bit data relocation */
79 #define R_DATA_32 R_386_32
80 #define R_DATA_PTR R_386_32
81 #define R_JMP_SLOT R_386_JMP_SLOT
82 #define R_COPY R_386_COPY
84 #define ELF_START_ADDR 0x08048000
85 #define ELF_PAGE_SIZE 0x1000
87 /******************************************************/
88 #else /* ! TARGET_DEFS_ONLY */
89 /******************************************************/
90 #include "tcc.h"
92 ST_DATA const int reg_classes[NB_REGS] = {
93 /* eax */ RC_INT | RC_EAX,
94 /* ecx */ RC_INT | RC_ECX,
95 /* edx */ RC_INT | RC_EDX,
96 /* st0 */ RC_FLOAT | RC_ST0,
99 static unsigned long func_sub_sp_offset;
100 static int func_ret_sub;
101 #ifdef CONFIG_TCC_BCHECK
102 static addr_t func_bound_offset;
103 #endif
105 /* XXX: make it faster ? */
106 ST_FUNC void g(int c)
108 int ind1;
109 ind1 = ind + 1;
110 if (ind1 > cur_text_section->data_allocated)
111 section_realloc(cur_text_section, ind1);
112 cur_text_section->data[ind] = c;
113 ind = ind1;
116 ST_FUNC void o(unsigned int c)
118 while (c) {
119 g(c);
120 c = c >> 8;
124 ST_FUNC void gen_le16(int v)
126 g(v);
127 g(v >> 8);
130 ST_FUNC void gen_le32(int c)
132 g(c);
133 g(c >> 8);
134 g(c >> 16);
135 g(c >> 24);
138 /* output a symbol and patch all calls to it */
139 ST_FUNC void gsym_addr(int t, int a)
141 while (t) {
142 unsigned char *ptr = cur_text_section->data + t;
143 uint32_t n = read32le(ptr); /* next value */
144 write32le(ptr, a - t - 4);
145 t = n;
149 ST_FUNC void gsym(int t)
151 gsym_addr(t, ind);
154 /* psym is used to put an instruction with a data field which is a
155 reference to a symbol. It is in fact the same as oad ! */
156 #define psym oad
158 /* instruction + 4 bytes data. Return the address of the data */
159 ST_FUNC int oad(int c, int s)
161 int ind1;
163 o(c);
164 ind1 = ind + 4;
165 if (ind1 > cur_text_section->data_allocated)
166 section_realloc(cur_text_section, ind1);
167 write32le(cur_text_section->data + ind, s);
168 s = ind;
169 ind = ind1;
170 return s;
173 /* output constant with relocation if 'r & VT_SYM' is true */
174 ST_FUNC void gen_addr32(int r, Sym *sym, int c)
176 if (r & VT_SYM)
177 greloc(cur_text_section, sym, ind, R_386_32);
178 gen_le32(c);
181 ST_FUNC void gen_addrpc32(int r, Sym *sym, int c)
183 if (r & VT_SYM)
184 greloc(cur_text_section, sym, ind, R_386_PC32);
185 gen_le32(c - 4);
188 /* generate a modrm reference. 'op_reg' contains the addtionnal 3
189 opcode bits */
190 static void gen_modrm(int op_reg, int r, Sym *sym, int c)
192 op_reg = op_reg << 3;
193 if ((r & VT_VALMASK) == VT_CONST) {
194 /* constant memory reference */
195 o(0x05 | op_reg);
196 gen_addr32(r, sym, c);
197 } else if ((r & VT_VALMASK) == VT_LOCAL) {
198 /* currently, we use only ebp as base */
199 if (c == (char)c) {
200 /* short reference */
201 o(0x45 | op_reg);
202 g(c);
203 } else {
204 oad(0x85 | op_reg, c);
206 } else {
207 g(0x00 | op_reg | (r & VT_VALMASK));
211 /* load 'r' from value 'sv' */
212 ST_FUNC void load(int r, SValue *sv)
214 int v, t, ft, fc, fr;
215 SValue v1;
217 #ifdef TCC_TARGET_PE
218 SValue v2;
219 sv = pe_getimport(sv, &v2);
220 #endif
222 fr = sv->r;
223 ft = sv->type.t;
224 fc = sv->c.i;
226 ft &= ~(VT_VOLATILE | VT_CONSTANT);
228 v = fr & VT_VALMASK;
229 if (fr & VT_LVAL) {
230 if (v == VT_LLOCAL) {
231 v1.type.t = VT_INT;
232 v1.r = VT_LOCAL | VT_LVAL;
233 v1.c.i = fc;
234 fr = r;
235 if (!(reg_classes[fr] & RC_INT))
236 fr = get_reg(RC_INT);
237 load(fr, &v1);
239 if ((ft & VT_BTYPE) == VT_FLOAT) {
240 o(0xd9); /* flds */
241 r = 0;
242 } else if ((ft & VT_BTYPE) == VT_DOUBLE) {
243 o(0xdd); /* fldl */
244 r = 0;
245 } else if ((ft & VT_BTYPE) == VT_LDOUBLE) {
246 o(0xdb); /* fldt */
247 r = 5;
248 } else if ((ft & VT_TYPE) == VT_BYTE || (ft & VT_TYPE) == VT_BOOL) {
249 o(0xbe0f); /* movsbl */
250 } else if ((ft & VT_TYPE) == (VT_BYTE | VT_UNSIGNED)) {
251 o(0xb60f); /* movzbl */
252 } else if ((ft & VT_TYPE) == VT_SHORT) {
253 o(0xbf0f); /* movswl */
254 } else if ((ft & VT_TYPE) == (VT_SHORT | VT_UNSIGNED)) {
255 o(0xb70f); /* movzwl */
256 } else {
257 o(0x8b); /* movl */
259 gen_modrm(r, fr, sv->sym, fc);
260 } else {
261 if (v == VT_CONST) {
262 o(0xb8 + r); /* mov $xx, r */
263 gen_addr32(fr, sv->sym, fc);
264 } else if (v == VT_LOCAL) {
265 if (fc) {
266 o(0x8d); /* lea xxx(%ebp), r */
267 gen_modrm(r, VT_LOCAL, sv->sym, fc);
268 } else {
269 o(0x89);
270 o(0xe8 + r); /* mov %ebp, r */
272 } else if (v == VT_CMP) {
273 oad(0xb8 + r, 0); /* mov $0, r */
274 o(0x0f); /* setxx %br */
275 o(fc);
276 o(0xc0 + r);
277 } else if (v == VT_JMP || v == VT_JMPI) {
278 t = v & 1;
279 oad(0xb8 + r, t); /* mov $1, r */
280 o(0x05eb); /* jmp after */
281 gsym(fc);
282 oad(0xb8 + r, t ^ 1); /* mov $0, r */
283 } else if (v != r) {
284 o(0x89);
285 o(0xc0 + r + v * 8); /* mov v, r */
290 /* store register 'r' in lvalue 'v' */
291 ST_FUNC void store(int r, SValue *v)
293 int fr, bt, ft, fc;
295 #ifdef TCC_TARGET_PE
296 SValue v2;
297 v = pe_getimport(v, &v2);
298 #endif
300 ft = v->type.t;
301 fc = v->c.i;
302 fr = v->r & VT_VALMASK;
303 ft &= ~(VT_VOLATILE | VT_CONSTANT);
304 bt = ft & VT_BTYPE;
305 /* XXX: incorrect if float reg to reg */
306 if (bt == VT_FLOAT) {
307 o(0xd9); /* fsts */
308 r = 2;
309 } else if (bt == VT_DOUBLE) {
310 o(0xdd); /* fstpl */
311 r = 2;
312 } else if (bt == VT_LDOUBLE) {
313 o(0xc0d9); /* fld %st(0) */
314 o(0xdb); /* fstpt */
315 r = 7;
316 } else {
317 if (bt == VT_SHORT)
318 o(0x66);
319 if (bt == VT_BYTE || bt == VT_BOOL)
320 o(0x88);
321 else
322 o(0x89);
324 if (fr == VT_CONST ||
325 fr == VT_LOCAL ||
326 (v->r & VT_LVAL)) {
327 gen_modrm(r, v->r, v->sym, fc);
328 } else if (fr != r) {
329 o(0xc0 + fr + r * 8); /* mov r, fr */
333 static void gadd_sp(int val)
335 if (val == (char)val) {
336 o(0xc483);
337 g(val);
338 } else {
339 oad(0xc481, val); /* add $xxx, %esp */
343 static void gen_static_call(int v)
345 Sym *sym;
347 sym = external_global_sym(v, &func_old_type, 0);
348 oad(0xe8, -4);
349 greloc(cur_text_section, sym, ind-4, R_386_PC32);
352 /* 'is_jmp' is '1' if it is a jump */
353 static void gcall_or_jmp(int is_jmp)
355 int r;
356 if ((vtop->r & (VT_VALMASK | VT_LVAL)) == VT_CONST) {
357 int rt;
358 /* constant case */
359 if (vtop->r & VT_SYM) {
360 /* relocation case */
361 greloc(cur_text_section, vtop->sym,
362 ind + 1, R_386_PC32);
363 } else {
364 /* put an empty PC32 relocation */
365 put_elf_reloc(symtab_section, cur_text_section,
366 ind + 1, R_386_PC32, 0);
368 oad(0xe8 + is_jmp, vtop->c.i - 4); /* call/jmp im */
369 /* extend the return value to the whole register if necessary
370 visual studio and gcc do not always set the whole eax register
371 when assigning the return value of a function */
372 rt = vtop->type.ref->type.t;
373 switch (rt & VT_BTYPE) {
374 case VT_BYTE:
375 if (rt & VT_UNSIGNED) {
376 o(0xc0b60f); /* movzx %al, %eax */
378 else {
379 o(0xc0be0f); /* movsx %al, %eax */
381 break;
382 case VT_SHORT:
383 if (rt & VT_UNSIGNED) {
384 o(0xc0b70f); /* movzx %ax, %eax */
386 else {
387 o(0xc0bf0f); /* movsx %ax, %eax */
389 break;
390 default:
391 break;
393 } else {
394 /* otherwise, indirect call */
395 r = gv(RC_INT);
396 o(0xff); /* call/jmp *r */
397 o(0xd0 + r + (is_jmp << 4));
401 static uint8_t fastcall_regs[3] = { TREG_EAX, TREG_EDX, TREG_ECX };
402 static uint8_t fastcallw_regs[2] = { TREG_ECX, TREG_EDX };
404 /* Return the number of registers needed to return the struct, or 0 if
405 returning via struct pointer. */
406 ST_FUNC int gfunc_sret(CType *vt, int variadic, CType *ret, int *ret_align, int *regsize)
408 #ifdef TCC_TARGET_PE
409 int size, align;
411 *ret_align = 1; // Never have to re-align return values for x86
412 *regsize = 4;
413 size = type_size(vt, &align);
414 if (size > 8) {
415 return 0;
416 } else if (size > 4) {
417 ret->ref = NULL;
418 ret->t = VT_LLONG;
419 return 1;
420 } else {
421 ret->ref = NULL;
422 ret->t = VT_INT;
423 return 1;
425 #else
426 *ret_align = 1; // Never have to re-align return values for x86
427 return 0;
428 #endif
431 /* Generate function call. The function address is pushed first, then
432 all the parameters in call order. This functions pops all the
433 parameters and the function address. */
434 ST_FUNC void gfunc_call(int nb_args)
436 int size, align, r, args_size, i, func_call;
437 Sym *func_sym;
439 args_size = 0;
440 for(i = 0;i < nb_args; i++) {
441 if ((vtop->type.t & VT_BTYPE) == VT_STRUCT) {
442 size = type_size(&vtop->type, &align);
443 /* align to stack align size */
444 size = (size + 3) & ~3;
445 /* allocate the necessary size on stack */
446 oad(0xec81, size); /* sub $xxx, %esp */
447 /* generate structure store */
448 r = get_reg(RC_INT);
449 o(0x89); /* mov %esp, r */
450 o(0xe0 + r);
451 vset(&vtop->type, r | VT_LVAL, 0);
452 vswap();
453 vstore();
454 args_size += size;
455 } else if (is_float(vtop->type.t)) {
456 gv(RC_FLOAT); /* only one float register */
457 if ((vtop->type.t & VT_BTYPE) == VT_FLOAT)
458 size = 4;
459 else if ((vtop->type.t & VT_BTYPE) == VT_DOUBLE)
460 size = 8;
461 else
462 size = 12;
463 oad(0xec81, size); /* sub $xxx, %esp */
464 if (size == 12)
465 o(0x7cdb);
466 else
467 o(0x5cd9 + size - 4); /* fstp[s|l] 0(%esp) */
468 g(0x24);
469 g(0x00);
470 args_size += size;
471 } else {
472 /* simple type (currently always same size) */
473 /* XXX: implicit cast ? */
474 r = gv(RC_INT);
475 if ((vtop->type.t & VT_BTYPE) == VT_LLONG) {
476 size = 8;
477 o(0x50 + vtop->r2); /* push r */
478 } else {
479 size = 4;
481 o(0x50 + r); /* push r */
482 args_size += size;
484 vtop--;
486 save_regs(0); /* save used temporary registers */
487 func_sym = vtop->type.ref;
488 func_call = func_sym->a.func_call;
489 /* fast call case */
490 if ((func_call >= FUNC_FASTCALL1 && func_call <= FUNC_FASTCALL3) ||
491 func_call == FUNC_FASTCALLW) {
492 int fastcall_nb_regs;
493 uint8_t *fastcall_regs_ptr;
494 if (func_call == FUNC_FASTCALLW) {
495 fastcall_regs_ptr = fastcallw_regs;
496 fastcall_nb_regs = 2;
497 } else {
498 fastcall_regs_ptr = fastcall_regs;
499 fastcall_nb_regs = func_call - FUNC_FASTCALL1 + 1;
501 for(i = 0;i < fastcall_nb_regs; i++) {
502 if (args_size <= 0)
503 break;
504 o(0x58 + fastcall_regs_ptr[i]); /* pop r */
505 /* XXX: incorrect for struct/floats */
506 args_size -= 4;
509 #ifndef TCC_TARGET_PE
510 else if ((vtop->type.ref->type.t & VT_BTYPE) == VT_STRUCT)
511 args_size -= 4;
512 #endif
513 gcall_or_jmp(0);
515 if (args_size && func_call != FUNC_STDCALL)
516 gadd_sp(args_size);
517 vtop--;
520 #ifdef TCC_TARGET_PE
521 #define FUNC_PROLOG_SIZE 10
522 #else
523 #define FUNC_PROLOG_SIZE 9
524 #endif
526 /* generate function prolog of type 't' */
527 ST_FUNC void gfunc_prolog(CType *func_type)
529 int addr, align, size, func_call, fastcall_nb_regs;
530 int param_index, param_addr;
531 uint8_t *fastcall_regs_ptr;
532 Sym *sym;
533 CType *type;
535 sym = func_type->ref;
536 func_call = sym->a.func_call;
537 addr = 8;
538 loc = 0;
539 func_vc = 0;
541 if (func_call >= FUNC_FASTCALL1 && func_call <= FUNC_FASTCALL3) {
542 fastcall_nb_regs = func_call - FUNC_FASTCALL1 + 1;
543 fastcall_regs_ptr = fastcall_regs;
544 } else if (func_call == FUNC_FASTCALLW) {
545 fastcall_nb_regs = 2;
546 fastcall_regs_ptr = fastcallw_regs;
547 } else {
548 fastcall_nb_regs = 0;
549 fastcall_regs_ptr = NULL;
551 param_index = 0;
553 ind += FUNC_PROLOG_SIZE;
554 func_sub_sp_offset = ind;
555 /* if the function returns a structure, then add an
556 implicit pointer parameter */
557 func_vt = sym->type;
558 func_var = (sym->c == FUNC_ELLIPSIS);
559 #ifdef TCC_TARGET_PE
560 size = type_size(&func_vt,&align);
561 if (((func_vt.t & VT_BTYPE) == VT_STRUCT) && (size > 8)) {
562 #else
563 if ((func_vt.t & VT_BTYPE) == VT_STRUCT) {
564 #endif
565 /* XXX: fastcall case ? */
566 func_vc = addr;
567 addr += 4;
568 param_index++;
570 /* define parameters */
571 while ((sym = sym->next) != NULL) {
572 type = &sym->type;
573 size = type_size(type, &align);
574 size = (size + 3) & ~3;
575 #ifdef FUNC_STRUCT_PARAM_AS_PTR
576 /* structs are passed as pointer */
577 if ((type->t & VT_BTYPE) == VT_STRUCT) {
578 size = 4;
580 #endif
581 if (param_index < fastcall_nb_regs) {
582 /* save FASTCALL register */
583 loc -= 4;
584 o(0x89); /* movl */
585 gen_modrm(fastcall_regs_ptr[param_index], VT_LOCAL, NULL, loc);
586 param_addr = loc;
587 } else {
588 param_addr = addr;
589 addr += size;
591 sym_push(sym->v & ~SYM_FIELD, type,
592 VT_LOCAL | lvalue_type(type->t), param_addr);
593 param_index++;
595 func_ret_sub = 0;
596 /* pascal type call ? */
597 if (func_call == FUNC_STDCALL)
598 func_ret_sub = addr - 8;
599 #ifndef TCC_TARGET_PE
600 else if (func_vc)
601 func_ret_sub = 4;
602 #endif
604 #ifdef CONFIG_TCC_BCHECK
605 /* leave some room for bound checking code */
606 if (tcc_state->do_bounds_check) {
607 oad(0xb8, 0); /* lbound section pointer */
608 oad(0xb8, 0); /* call to function */
609 func_bound_offset = lbounds_section->data_offset;
611 #endif
614 /* generate function epilog */
615 ST_FUNC void gfunc_epilog(void)
617 addr_t v, saved_ind;
619 #ifdef CONFIG_TCC_BCHECK
620 if (tcc_state->do_bounds_check
621 && func_bound_offset != lbounds_section->data_offset) {
622 addr_t saved_ind;
623 addr_t *bounds_ptr;
624 Sym *sym_data;
625 /* add end of table info */
626 bounds_ptr = section_ptr_add(lbounds_section, sizeof(addr_t));
627 *bounds_ptr = 0;
628 /* generate bound local allocation */
629 saved_ind = ind;
630 ind = func_sub_sp_offset;
631 sym_data = get_sym_ref(&char_pointer_type, lbounds_section,
632 func_bound_offset, lbounds_section->data_offset);
633 greloc(cur_text_section, sym_data,
634 ind + 1, R_386_32);
635 oad(0xb8, 0); /* mov %eax, xxx */
636 gen_static_call(TOK___bound_local_new);
638 ind = saved_ind;
639 /* generate bound check local freeing */
640 o(0x5250); /* save returned value, if any */
641 greloc(cur_text_section, sym_data,
642 ind + 1, R_386_32);
643 oad(0xb8, 0); /* mov %eax, xxx */
644 gen_static_call(TOK___bound_local_delete);
646 o(0x585a); /* restore returned value, if any */
648 #endif
649 o(0xc9); /* leave */
650 if (func_ret_sub == 0) {
651 o(0xc3); /* ret */
652 } else {
653 o(0xc2); /* ret n */
654 g(func_ret_sub);
655 g(func_ret_sub >> 8);
657 /* align local size to word & save local variables */
659 v = (-loc + 3) & -4;
660 saved_ind = ind;
661 ind = func_sub_sp_offset - FUNC_PROLOG_SIZE;
662 #ifdef TCC_TARGET_PE
663 if (v >= 4096) {
664 oad(0xb8, v); /* mov stacksize, %eax */
665 gen_static_call(TOK___chkstk); /* call __chkstk, (does the stackframe too) */
666 } else
667 #endif
669 o(0xe58955); /* push %ebp, mov %esp, %ebp */
670 o(0xec81); /* sub esp, stacksize */
671 gen_le32(v);
672 #if FUNC_PROLOG_SIZE == 10
673 o(0x90); /* adjust to FUNC_PROLOG_SIZE */
674 #endif
676 ind = saved_ind;
679 /* generate a jump to a label */
680 ST_FUNC int gjmp(int t)
682 return psym(0xe9, t);
685 /* generate a jump to a fixed address */
686 ST_FUNC void gjmp_addr(int a)
688 int r;
689 r = a - ind - 2;
690 if (r == (char)r) {
691 g(0xeb);
692 g(r);
693 } else {
694 oad(0xe9, a - ind - 5);
698 /* generate a test. set 'inv' to invert test. Stack entry is popped */
699 ST_FUNC int gtst(int inv, int t)
701 int v = vtop->r & VT_VALMASK;
702 if (v == VT_CMP) {
703 /* fast case : can jump directly since flags are set */
704 g(0x0f);
705 t = psym((vtop->c.i - 16) ^ inv, t);
706 } else if (v == VT_JMP || v == VT_JMPI) {
707 /* && or || optimization */
708 if ((v & 1) == inv) {
709 /* insert vtop->c jump list in t */
710 uint32_t n1, n = vtop->c.i;
711 if (n) {
712 while ((n1 = read32le(cur_text_section->data + n)))
713 n = n1;
714 write32le(cur_text_section->data + n, t);
715 t = vtop->c.i;
717 } else {
718 t = gjmp(t);
719 gsym(vtop->c.i);
722 vtop--;
723 return t;
726 /* generate an integer binary operation */
727 ST_FUNC void gen_opi(int op)
729 int r, fr, opc, c;
731 switch(op) {
732 case '+':
733 case TOK_ADDC1: /* add with carry generation */
734 opc = 0;
735 gen_op8:
736 if ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST) {
737 /* constant case */
738 vswap();
739 r = gv(RC_INT);
740 vswap();
741 c = vtop->c.i;
742 if (c == (char)c) {
743 /* generate inc and dec for smaller code */
744 if (c==1 && opc==0) {
745 o (0x40 | r); // inc
746 } else if (c==1 && opc==5) {
747 o (0x48 | r); // dec
748 } else {
749 o(0x83);
750 o(0xc0 | (opc << 3) | r);
751 g(c);
753 } else {
754 o(0x81);
755 oad(0xc0 | (opc << 3) | r, c);
757 } else {
758 gv2(RC_INT, RC_INT);
759 r = vtop[-1].r;
760 fr = vtop[0].r;
761 o((opc << 3) | 0x01);
762 o(0xc0 + r + fr * 8);
764 vtop--;
765 if (op >= TOK_ULT && op <= TOK_GT) {
766 vtop->r = VT_CMP;
767 vtop->c.i = op;
769 break;
770 case '-':
771 case TOK_SUBC1: /* sub with carry generation */
772 opc = 5;
773 goto gen_op8;
774 case TOK_ADDC2: /* add with carry use */
775 opc = 2;
776 goto gen_op8;
777 case TOK_SUBC2: /* sub with carry use */
778 opc = 3;
779 goto gen_op8;
780 case '&':
781 opc = 4;
782 goto gen_op8;
783 case '^':
784 opc = 6;
785 goto gen_op8;
786 case '|':
787 opc = 1;
788 goto gen_op8;
789 case '*':
790 gv2(RC_INT, RC_INT);
791 r = vtop[-1].r;
792 fr = vtop[0].r;
793 vtop--;
794 o(0xaf0f); /* imul fr, r */
795 o(0xc0 + fr + r * 8);
796 break;
797 case TOK_SHL:
798 opc = 4;
799 goto gen_shift;
800 case TOK_SHR:
801 opc = 5;
802 goto gen_shift;
803 case TOK_SAR:
804 opc = 7;
805 gen_shift:
806 opc = 0xc0 | (opc << 3);
807 if ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST) {
808 /* constant case */
809 vswap();
810 r = gv(RC_INT);
811 vswap();
812 c = vtop->c.i & 0x1f;
813 o(0xc1); /* shl/shr/sar $xxx, r */
814 o(opc | r);
815 g(c);
816 } else {
817 /* we generate the shift in ecx */
818 gv2(RC_INT, RC_ECX);
819 r = vtop[-1].r;
820 o(0xd3); /* shl/shr/sar %cl, r */
821 o(opc | r);
823 vtop--;
824 break;
825 case '/':
826 case TOK_UDIV:
827 case TOK_PDIV:
828 case '%':
829 case TOK_UMOD:
830 case TOK_UMULL:
831 /* first operand must be in eax */
832 /* XXX: need better constraint for second operand */
833 gv2(RC_EAX, RC_ECX);
834 r = vtop[-1].r;
835 fr = vtop[0].r;
836 vtop--;
837 save_reg(TREG_EDX);
838 if (op == TOK_UMULL) {
839 o(0xf7); /* mul fr */
840 o(0xe0 + fr);
841 vtop->r2 = TREG_EDX;
842 r = TREG_EAX;
843 } else {
844 if (op == TOK_UDIV || op == TOK_UMOD) {
845 o(0xf7d231); /* xor %edx, %edx, div fr, %eax */
846 o(0xf0 + fr);
847 } else {
848 o(0xf799); /* cltd, idiv fr, %eax */
849 o(0xf8 + fr);
851 if (op == '%' || op == TOK_UMOD)
852 r = TREG_EDX;
853 else
854 r = TREG_EAX;
856 vtop->r = r;
857 break;
858 default:
859 opc = 7;
860 goto gen_op8;
864 /* generate a floating point operation 'v = t1 op t2' instruction. The
865 two operands are guaranted to have the same floating point type */
866 /* XXX: need to use ST1 too */
867 ST_FUNC void gen_opf(int op)
869 int a, ft, fc, swapped, r;
871 /* convert constants to memory references */
872 if ((vtop[-1].r & (VT_VALMASK | VT_LVAL)) == VT_CONST) {
873 vswap();
874 gv(RC_FLOAT);
875 vswap();
877 if ((vtop[0].r & (VT_VALMASK | VT_LVAL)) == VT_CONST)
878 gv(RC_FLOAT);
880 /* must put at least one value in the floating point register */
881 if ((vtop[-1].r & VT_LVAL) &&
882 (vtop[0].r & VT_LVAL)) {
883 vswap();
884 gv(RC_FLOAT);
885 vswap();
887 swapped = 0;
888 /* swap the stack if needed so that t1 is the register and t2 is
889 the memory reference */
890 if (vtop[-1].r & VT_LVAL) {
891 vswap();
892 swapped = 1;
894 if (op >= TOK_ULT && op <= TOK_GT) {
895 /* load on stack second operand */
896 load(TREG_ST0, vtop);
897 save_reg(TREG_EAX); /* eax is used by FP comparison code */
898 if (op == TOK_GE || op == TOK_GT)
899 swapped = !swapped;
900 else if (op == TOK_EQ || op == TOK_NE)
901 swapped = 0;
902 if (swapped)
903 o(0xc9d9); /* fxch %st(1) */
904 if (op == TOK_EQ || op == TOK_NE)
905 o(0xe9da); /* fucompp */
906 else
907 o(0xd9de); /* fcompp */
908 o(0xe0df); /* fnstsw %ax */
909 if (op == TOK_EQ) {
910 o(0x45e480); /* and $0x45, %ah */
911 o(0x40fC80); /* cmp $0x40, %ah */
912 } else if (op == TOK_NE) {
913 o(0x45e480); /* and $0x45, %ah */
914 o(0x40f480); /* xor $0x40, %ah */
915 op = TOK_NE;
916 } else if (op == TOK_GE || op == TOK_LE) {
917 o(0x05c4f6); /* test $0x05, %ah */
918 op = TOK_EQ;
919 } else {
920 o(0x45c4f6); /* test $0x45, %ah */
921 op = TOK_EQ;
923 vtop--;
924 vtop->r = VT_CMP;
925 vtop->c.i = op;
926 } else {
927 /* no memory reference possible for long double operations */
928 if ((vtop->type.t & VT_BTYPE) == VT_LDOUBLE) {
929 load(TREG_ST0, vtop);
930 swapped = !swapped;
933 switch(op) {
934 default:
935 case '+':
936 a = 0;
937 break;
938 case '-':
939 a = 4;
940 if (swapped)
941 a++;
942 break;
943 case '*':
944 a = 1;
945 break;
946 case '/':
947 a = 6;
948 if (swapped)
949 a++;
950 break;
952 ft = vtop->type.t;
953 fc = vtop->c.i;
954 if ((ft & VT_BTYPE) == VT_LDOUBLE) {
955 o(0xde); /* fxxxp %st, %st(1) */
956 o(0xc1 + (a << 3));
957 } else {
958 /* if saved lvalue, then we must reload it */
959 r = vtop->r;
960 if ((r & VT_VALMASK) == VT_LLOCAL) {
961 SValue v1;
962 r = get_reg(RC_INT);
963 v1.type.t = VT_INT;
964 v1.r = VT_LOCAL | VT_LVAL;
965 v1.c.i = fc;
966 load(r, &v1);
967 fc = 0;
970 if ((ft & VT_BTYPE) == VT_DOUBLE)
971 o(0xdc);
972 else
973 o(0xd8);
974 gen_modrm(a, r, vtop->sym, fc);
976 vtop--;
980 /* convert integers to fp 't' type. Must handle 'int', 'unsigned int'
981 and 'long long' cases. */
982 ST_FUNC void gen_cvt_itof(int t)
984 save_reg(TREG_ST0);
985 gv(RC_INT);
986 if ((vtop->type.t & VT_BTYPE) == VT_LLONG) {
987 /* signed long long to float/double/long double (unsigned case
988 is handled generically) */
989 o(0x50 + vtop->r2); /* push r2 */
990 o(0x50 + (vtop->r & VT_VALMASK)); /* push r */
991 o(0x242cdf); /* fildll (%esp) */
992 o(0x08c483); /* add $8, %esp */
993 } else if ((vtop->type.t & (VT_BTYPE | VT_UNSIGNED)) ==
994 (VT_INT | VT_UNSIGNED)) {
995 /* unsigned int to float/double/long double */
996 o(0x6a); /* push $0 */
997 g(0x00);
998 o(0x50 + (vtop->r & VT_VALMASK)); /* push r */
999 o(0x242cdf); /* fildll (%esp) */
1000 o(0x08c483); /* add $8, %esp */
1001 } else {
1002 /* int to float/double/long double */
1003 o(0x50 + (vtop->r & VT_VALMASK)); /* push r */
1004 o(0x2404db); /* fildl (%esp) */
1005 o(0x04c483); /* add $4, %esp */
1007 vtop->r = TREG_ST0;
1010 /* convert fp to int 't' type */
1011 ST_FUNC void gen_cvt_ftoi(int t)
1013 #ifndef COMMIT_4ad186c5ef61_IS_FIXED
1014 /* a good version but it takes a more time to execute */
1015 gv(RC_FLOAT);
1016 save_reg(TREG_EAX);
1017 save_reg(TREG_EDX);
1018 gen_static_call(TOK___tcc_cvt_ftol);
1019 vtop->r = TREG_EAX; /* mark reg as used */
1020 if (t == VT_LLONG)
1021 vtop->r2 = TREG_EDX;
1022 #else
1023 /* a new version with a bug: t2a = 44100312 */
1025 #include<stdio.h>
1026 int main() {
1027 int t1 = 176401255;
1028 float f = 0.25f;
1029 int t2a = (int)(t1 * f); // must be 44100313
1030 int t2b = (int)(t1 * (float)0.25f);
1031 printf("t2a=%d t2b=%d \n",t2a,t2b);
1032 return 0;
1035 int bt = vtop->type.t & VT_BTYPE;
1036 if (bt == VT_FLOAT)
1037 vpush_global_sym(&func_old_type, TOK___fixsfdi);
1038 else if (bt == VT_LDOUBLE)
1039 vpush_global_sym(&func_old_type, TOK___fixxfdi);
1040 else
1041 vpush_global_sym(&func_old_type, TOK___fixdfdi);
1042 vswap();
1043 gfunc_call(1);
1044 vpushi(0);
1045 vtop->r = REG_IRET;
1046 vtop->r2 = REG_LRET;
1047 #endif
1050 /* convert from one floating point type to another */
1051 ST_FUNC void gen_cvt_ftof(int t)
1053 /* all we have to do on i386 is to put the float in a register */
1054 gv(RC_FLOAT);
1057 /* computed goto support */
1058 ST_FUNC void ggoto(void)
1060 gcall_or_jmp(1);
1061 vtop--;
1064 /* bound check support functions */
1065 #ifdef CONFIG_TCC_BCHECK
1067 /* generate a bounded pointer addition */
1068 ST_FUNC void gen_bounded_ptr_add(void)
1070 /* prepare fast i386 function call (args in eax and edx) */
1071 gv2(RC_EAX, RC_EDX);
1072 /* save all temporary registers */
1073 vtop -= 2;
1074 save_regs(0);
1075 /* do a fast function call */
1076 gen_static_call(TOK___bound_ptr_add);
1077 /* returned pointer is in eax */
1078 vtop++;
1079 vtop->r = TREG_EAX | VT_BOUNDED;
1080 /* address of bounding function call point */
1081 vtop->c.i = (cur_text_section->reloc->data_offset - sizeof(Elf32_Rel));
1084 /* patch pointer addition in vtop so that pointer dereferencing is
1085 also tested */
1086 ST_FUNC void gen_bounded_ptr_deref(void)
1088 addr_t func;
1089 int size, align;
1090 Elf32_Rel *rel;
1091 Sym *sym;
1093 size = 0;
1094 /* XXX: put that code in generic part of tcc */
1095 if (!is_float(vtop->type.t)) {
1096 if (vtop->r & VT_LVAL_BYTE)
1097 size = 1;
1098 else if (vtop->r & VT_LVAL_SHORT)
1099 size = 2;
1101 if (!size)
1102 size = type_size(&vtop->type, &align);
1103 switch(size) {
1104 case 1: func = TOK___bound_ptr_indir1; break;
1105 case 2: func = TOK___bound_ptr_indir2; break;
1106 case 4: func = TOK___bound_ptr_indir4; break;
1107 case 8: func = TOK___bound_ptr_indir8; break;
1108 case 12: func = TOK___bound_ptr_indir12; break;
1109 case 16: func = TOK___bound_ptr_indir16; break;
1110 default:
1111 tcc_error("unhandled size when dereferencing bounded pointer");
1112 func = 0;
1113 break;
1116 /* patch relocation */
1117 /* XXX: find a better solution ? */
1118 rel = (Elf32_Rel *)(cur_text_section->reloc->data + vtop->c.i);
1119 sym = external_global_sym(func, &func_old_type, 0);
1120 if (!sym->c)
1121 put_extern_sym(sym, NULL, 0, 0);
1122 rel->r_info = ELF32_R_INFO(sym->c, ELF32_R_TYPE(rel->r_info));
1124 #endif
1126 /* Save the stack pointer onto the stack */
1127 ST_FUNC void gen_vla_sp_save(int addr) {
1128 /* mov %esp,addr(%ebp)*/
1129 o(0x89);
1130 gen_modrm(TREG_ESP, VT_LOCAL, NULL, addr);
1133 /* Restore the SP from a location on the stack */
1134 ST_FUNC void gen_vla_sp_restore(int addr) {
1135 o(0x8b);
1136 gen_modrm(TREG_ESP, VT_LOCAL, NULL, addr);
1139 /* Subtract from the stack pointer, and push the resulting value onto the stack */
1140 ST_FUNC void gen_vla_alloc(CType *type, int align) {
1141 #ifdef TCC_TARGET_PE
1142 /* alloca does more than just adjust %rsp on Windows */
1143 vpush_global_sym(&func_old_type, TOK_alloca);
1144 vswap(); /* Move alloca ref past allocation size */
1145 gfunc_call(1);
1146 #else
1147 int r;
1148 r = gv(RC_INT); /* allocation size */
1149 /* sub r,%rsp */
1150 o(0x2b);
1151 o(0xe0 | r);
1152 /* We align to 16 bytes rather than align */
1153 /* and ~15, %esp */
1154 o(0xf0e483);
1155 vpop();
1156 #endif
1159 /* end of X86 code generator */
1160 /*************************************************************/
1161 #endif
1162 /*************************************************************/