fix-mixed-struct (patch by Pip Cet)
[tinycc.git] / i386-gen.c
blobf268c2bf7accf9e216f86d0f5a88c133c1452c88
1 /*
2 * X86 code generator for TCC
3 *
4 * Copyright (c) 2001-2004 Fabrice Bellard
5 *
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.
10 *
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.
15 *
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
19 */
21 #ifdef TARGET_DEFS_ONLY
23 /* number of available registers */
24 #define NB_REGS 4
25 #define NB_ASM_REGS 8
27 typedef int RegArgs;
29 /* a register can belong to several classes. The classes must be
30 sorted from more general to more precise (see gv2() code which does
31 assumptions on it). */
32 #define RC_INT 0x0001 /* generic integer register */
33 #define RC_FLOAT 0x0002 /* generic float register */
34 #define RC_EAX 0x0004
35 #define RC_ST0 0x0008
36 #define RC_ECX 0x0010
37 #define RC_EDX 0x0020
38 #define RC_IRET RC_EAX /* function return: integer register */
39 #define RC_LRET RC_EDX /* function return: second integer register */
40 #define RC_FRET RC_ST0 /* function return: float register */
42 /* pretty names for the registers */
43 enum {
44 TREG_EAX = 0,
45 TREG_ECX,
46 TREG_EDX,
47 TREG_ST0,
48 TREG_ESP = 4
49 };
51 /* return registers for function */
52 #define REG_IRET TREG_EAX /* single word int return register */
53 #define REG_LRET TREG_EDX /* second word return register (for long long) */
54 #define REG_FRET TREG_ST0 /* float return register */
56 /* defined if function parameters must be evaluated in reverse order */
57 #define INVERT_FUNC_PARAMS
59 /* defined if structures are passed as pointers. Otherwise structures
60 are directly pushed on stack. */
61 /* #define FUNC_STRUCT_PARAM_AS_PTR */
63 /* pointer size, in bytes */
64 #define PTR_SIZE 4
66 /* long double size and alignment, in bytes */
67 #define LDOUBLE_SIZE 12
68 #define LDOUBLE_ALIGN 4
69 /* maximum alignment (for aligned attribute support) */
70 #define MAX_ALIGN 8
73 #define psym oad
75 /******************************************************/
76 /* ELF defines */
78 #define EM_TCC_TARGET EM_386
80 /* relocation type for 32 bit data relocation */
81 #define R_DATA_32 R_386_32
82 #define R_DATA_PTR R_386_32
83 #define R_JMP_SLOT R_386_JMP_SLOT
84 #define R_COPY R_386_COPY
86 #define ELF_START_ADDR 0x08048000
87 #define ELF_PAGE_SIZE 0x1000
89 /******************************************************/
90 #else /* ! TARGET_DEFS_ONLY */
91 /******************************************************/
92 #include "tcc.h"
94 ST_DATA const int reg_classes[NB_REGS] = {
95 /* eax */ RC_INT | RC_EAX,
96 /* ecx */ RC_INT | RC_ECX,
97 /* edx */ RC_INT | RC_EDX,
98 /* st0 */ RC_FLOAT | RC_ST0,
99 };
101 static unsigned long func_sub_sp_offset;
102 static int func_ret_sub;
103 #ifdef CONFIG_TCC_BCHECK
104 static addr_t func_bound_offset;
105 #endif
107 /* XXX: make it faster ? */
108 ST_FUNC void g(int c)
110 int ind1;
111 ind1 = ind + 1;
112 if (ind1 > cur_text_section->data_allocated)
113 section_realloc(cur_text_section, ind1);
114 cur_text_section->data[ind] = c;
115 ind = ind1;
118 ST_FUNC void o(unsigned int c)
120 while (c) {
121 g(c);
122 c = c >> 8;
126 ST_FUNC void gen_le16(int v)
128 g(v);
129 g(v >> 8);
132 ST_FUNC void gen_le32(int c)
134 g(c);
135 g(c >> 8);
136 g(c >> 16);
137 g(c >> 24);
140 /* output a symbol and patch all calls to it */
141 ST_FUNC void gsym_addr(int t, int a)
143 int n, *ptr;
144 while (t) {
145 ptr = (int *)(cur_text_section->data + t);
146 n = *ptr; /* next value */
147 *ptr = a - t - 4;
148 t = n;
152 ST_FUNC void gsym(int t)
154 gsym_addr(t, ind);
157 /* psym is used to put an instruction with a data field which is a
158 reference to a symbol. It is in fact the same as oad ! */
159 #define psym oad
161 /* instruction + 4 bytes data. Return the address of the data */
162 ST_FUNC int oad(int c, int s)
164 int ind1;
166 o(c);
167 ind1 = ind + 4;
168 if (ind1 > cur_text_section->data_allocated)
169 section_realloc(cur_text_section, ind1);
170 *(int *)(cur_text_section->data + ind) = s;
171 s = ind;
172 ind = ind1;
173 return s;
176 /* output constant with relocation if 'r & VT_SYM' is true */
177 ST_FUNC void gen_addr32(int r, Sym *sym, int c)
179 if (r & VT_SYM)
180 greloc(cur_text_section, sym, ind, R_386_32);
181 gen_le32(c);
184 ST_FUNC void gen_addrpc32(int r, Sym *sym, int c)
186 if (r & VT_SYM)
187 greloc(cur_text_section, sym, ind, R_386_PC32);
188 gen_le32(c - 4);
191 /* generate a modrm reference. 'op_reg' contains the addtionnal 3
192 opcode bits */
193 static void gen_modrm(int op_reg, int r, Sym *sym, int c)
195 op_reg = op_reg << 3;
196 if ((r & VT_VALMASK) == VT_CONST) {
197 /* constant memory reference */
198 o(0x05 | op_reg);
199 gen_addr32(r, sym, c);
200 } else if ((r & VT_VALMASK) == VT_LOCAL) {
201 /* currently, we use only ebp as base */
202 if (c == (char)c) {
203 /* short reference */
204 o(0x45 | op_reg);
205 g(c);
206 } else {
207 oad(0x85 | op_reg, c);
209 } else {
210 g(0x00 | op_reg | (r & VT_VALMASK));
214 /* load 'r' from value 'sv' */
215 ST_FUNC void load(int r, SValue *sv)
217 int v, t, ft, fc, fr;
218 SValue v1;
220 #ifdef TCC_TARGET_PE
221 SValue v2;
222 sv = pe_getimport(sv, &v2);
223 #endif
225 fr = sv->r;
226 ft = sv->type.t;
227 fc = sv->c.ul;
229 v = fr & VT_VALMASK;
230 if (fr & VT_LVAL) {
231 if (v == VT_LLOCAL) {
232 v1.type.t = VT_INT;
233 v1.r = VT_LOCAL | VT_LVAL;
234 v1.c.ul = fc;
235 fr = r;
236 if (!(reg_classes[fr] & RC_INT))
237 fr = get_reg(RC_INT);
238 load(fr, &v1);
240 if ((ft & VT_BTYPE) == VT_FLOAT) {
241 o(0xd9); /* flds */
242 r = 0;
243 } else if ((ft & VT_BTYPE) == VT_DOUBLE) {
244 o(0xdd); /* fldl */
245 r = 0;
246 } else if ((ft & VT_BTYPE) == VT_LDOUBLE) {
247 o(0xdb); /* fldt */
248 r = 5;
249 } else if ((ft & VT_TYPE) == VT_BYTE || (ft & VT_TYPE) == VT_BOOL) {
250 o(0xbe0f); /* movsbl */
251 } else if ((ft & VT_TYPE) == (VT_BYTE | VT_UNSIGNED)) {
252 o(0xb60f); /* movzbl */
253 } else if ((ft & VT_TYPE) == VT_SHORT) {
254 o(0xbf0f); /* movswl */
255 } else if ((ft & VT_TYPE) == (VT_SHORT | VT_UNSIGNED)) {
256 o(0xb70f); /* movzwl */
257 } else {
258 o(0x8b); /* movl */
260 gen_modrm(r, fr, sv->sym, fc);
261 } else {
262 if (v == VT_CONST) {
263 o(0xb8 + r); /* mov $xx, r */
264 gen_addr32(fr, sv->sym, fc);
265 } else if (v == VT_LOCAL) {
266 if (fc) {
267 o(0x8d); /* lea xxx(%ebp), r */
268 gen_modrm(r, VT_LOCAL, sv->sym, fc);
269 } else {
270 o(0x89);
271 o(0xe8 + r); /* mov %ebp, r */
273 } else if (v == VT_CMP) {
274 oad(0xb8 + r, 0); /* mov $0, r */
275 o(0x0f); /* setxx %br */
276 o(fc);
277 o(0xc0 + r);
278 } else if (v == VT_JMP || v == VT_JMPI) {
279 t = v & 1;
280 oad(0xb8 + r, t); /* mov $1, r */
281 o(0x05eb); /* jmp after */
282 gsym(fc);
283 oad(0xb8 + r, t ^ 1); /* mov $0, r */
284 } else if (v != r) {
285 o(0x89);
286 o(0xc0 + r + v * 8); /* mov v, r */
291 /* store register 'r' in lvalue 'v' */
292 ST_FUNC void store(int r, SValue *v)
294 int fr, bt, ft, fc;
296 #ifdef TCC_TARGET_PE
297 SValue v2;
298 v = pe_getimport(v, &v2);
299 #endif
301 ft = v->type.t;
302 fc = v->c.ul;
303 fr = v->r & VT_VALMASK;
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 /* constant case */
358 if (vtop->r & VT_SYM) {
359 /* relocation case */
360 greloc(cur_text_section, vtop->sym,
361 ind + 1, R_386_PC32);
362 } else {
363 /* put an empty PC32 relocation */
364 put_elf_reloc(symtab_section, cur_text_section,
365 ind + 1, R_386_PC32, 0);
367 oad(0xe8 + is_jmp, vtop->c.ul - 4); /* call/jmp im */
368 } else {
369 /* otherwise, indirect call */
370 r = gv(RC_INT);
371 o(0xff); /* call/jmp *r */
372 o(0xd0 + r + (is_jmp << 4));
376 static uint8_t fastcall_regs[3] = { TREG_EAX, TREG_EDX, TREG_ECX };
377 static uint8_t fastcallw_regs[2] = { TREG_ECX, TREG_EDX };
379 ST_FUNC int regargs_nregs(RegArgs *args)
381 return *args;
384 /* Return the number of registers needed to return the struct, or 0 if
385 returning via struct pointer. */
386 ST_FUNC int gfunc_sret(CType *vt, int variadic, CType *ret, int *ret_align, int *regsize, RegArgs *args)
388 #ifdef TCC_TARGET_PE
389 int size, align;
391 *ret_align = 1; // Never have to re-align return values for x86
392 *regsize = 4;
393 size = type_size(vt, &align);
394 if (size > 8) {
395 *args = 0;
396 } else if (size > 4) {
397 ret->ref = NULL;
398 ret->t = VT_LLONG;
399 *args = 1;
400 } else {
401 ret->ref = NULL;
402 ret->t = VT_INT;
403 *args = 1;
405 #else
406 *ret_align = 1; // Never have to re-align return values for x86
407 *args = 0;
408 #endif
410 return *args != 0;
413 /* Generate function call. The function address is pushed first, then
414 all the parameters in call order. This functions pops all the
415 parameters and the function address. */
416 ST_FUNC void gfunc_call(int nb_args)
418 int size, align, r, args_size, i, func_call;
419 Sym *func_sym;
421 args_size = 0;
422 for(i = 0;i < nb_args; i++) {
423 if ((vtop->type.t & VT_BTYPE) == VT_STRUCT) {
424 size = type_size(&vtop->type, &align);
425 /* align to stack align size */
426 size = (size + 3) & ~3;
427 /* allocate the necessary size on stack */
428 oad(0xec81, size); /* sub $xxx, %esp */
429 /* generate structure store */
430 r = get_reg(RC_INT);
431 o(0x89); /* mov %esp, r */
432 o(0xe0 + r);
433 vset(&vtop->type, r | VT_LVAL, 0);
434 vswap();
435 vstore();
436 args_size += size;
437 } else if (is_float(vtop->type.t)) {
438 gv(RC_FLOAT); /* only one float register */
439 if ((vtop->type.t & VT_BTYPE) == VT_FLOAT)
440 size = 4;
441 else if ((vtop->type.t & VT_BTYPE) == VT_DOUBLE)
442 size = 8;
443 else
444 size = 12;
445 oad(0xec81, size); /* sub $xxx, %esp */
446 if (size == 12)
447 o(0x7cdb);
448 else
449 o(0x5cd9 + size - 4); /* fstp[s|l] 0(%esp) */
450 g(0x24);
451 g(0x00);
452 args_size += size;
453 } else {
454 /* simple type (currently always same size) */
455 /* XXX: implicit cast ? */
456 r = gv(RC_INT);
457 if ((vtop->type.t & VT_BTYPE) == VT_LLONG) {
458 size = 8;
459 o(0x50 + vtop->r2); /* push r */
460 } else {
461 size = 4;
463 o(0x50 + r); /* push r */
464 args_size += size;
466 vtop--;
468 save_regs(0); /* save used temporary registers */
469 func_sym = vtop->type.ref;
470 func_call = func_sym->a.func_call;
471 /* fast call case */
472 if ((func_call >= FUNC_FASTCALL1 && func_call <= FUNC_FASTCALL3) ||
473 func_call == FUNC_FASTCALLW) {
474 int fastcall_nb_regs;
475 uint8_t *fastcall_regs_ptr;
476 if (func_call == FUNC_FASTCALLW) {
477 fastcall_regs_ptr = fastcallw_regs;
478 fastcall_nb_regs = 2;
479 } else {
480 fastcall_regs_ptr = fastcall_regs;
481 fastcall_nb_regs = func_call - FUNC_FASTCALL1 + 1;
483 for(i = 0;i < fastcall_nb_regs; i++) {
484 if (args_size <= 0)
485 break;
486 o(0x58 + fastcall_regs_ptr[i]); /* pop r */
487 /* XXX: incorrect for struct/floats */
488 args_size -= 4;
491 #ifndef TCC_TARGET_PE
492 else if ((vtop->type.ref->type.t & VT_BTYPE) == VT_STRUCT)
493 args_size -= 4;
494 #endif
495 gcall_or_jmp(0);
497 if (args_size && func_call != FUNC_STDCALL)
498 gadd_sp(args_size);
499 vtop--;
502 #ifdef TCC_TARGET_PE
503 #define FUNC_PROLOG_SIZE 10
504 #else
505 #define FUNC_PROLOG_SIZE 9
506 #endif
508 /* generate function prolog of type 't' */
509 ST_FUNC void gfunc_prolog(CType *func_type)
511 int addr, align, size, func_call, fastcall_nb_regs;
512 int param_index, param_addr;
513 uint8_t *fastcall_regs_ptr;
514 Sym *sym;
515 CType *type;
517 sym = func_type->ref;
518 func_call = sym->a.func_call;
519 addr = 8;
520 loc = 0;
521 func_vc = 0;
523 if (func_call >= FUNC_FASTCALL1 && func_call <= FUNC_FASTCALL3) {
524 fastcall_nb_regs = func_call - FUNC_FASTCALL1 + 1;
525 fastcall_regs_ptr = fastcall_regs;
526 } else if (func_call == FUNC_FASTCALLW) {
527 fastcall_nb_regs = 2;
528 fastcall_regs_ptr = fastcallw_regs;
529 } else {
530 fastcall_nb_regs = 0;
531 fastcall_regs_ptr = NULL;
533 param_index = 0;
535 ind += FUNC_PROLOG_SIZE;
536 func_sub_sp_offset = ind;
537 /* if the function returns a structure, then add an
538 implicit pointer parameter */
539 func_vt = sym->type;
540 func_var = (sym->c == FUNC_ELLIPSIS);
541 #ifdef TCC_TARGET_PE
542 size = type_size(&func_vt,&align);
543 if (((func_vt.t & VT_BTYPE) == VT_STRUCT) && (size > 8)) {
544 #else
545 if ((func_vt.t & VT_BTYPE) == VT_STRUCT) {
546 #endif
547 /* XXX: fastcall case ? */
548 func_vc = addr;
549 addr += 4;
550 param_index++;
552 /* define parameters */
553 while ((sym = sym->next) != NULL) {
554 type = &sym->type;
555 size = type_size(type, &align);
556 size = (size + 3) & ~3;
557 #ifdef FUNC_STRUCT_PARAM_AS_PTR
558 /* structs are passed as pointer */
559 if ((type->t & VT_BTYPE) == VT_STRUCT) {
560 size = 4;
562 #endif
563 if (param_index < fastcall_nb_regs) {
564 /* save FASTCALL register */
565 loc -= 4;
566 o(0x89); /* movl */
567 gen_modrm(fastcall_regs_ptr[param_index], VT_LOCAL, NULL, loc);
568 param_addr = loc;
569 } else {
570 param_addr = addr;
571 addr += size;
573 sym_push(sym->v & ~SYM_FIELD, type,
574 VT_LOCAL | lvalue_type(type->t), param_addr);
575 param_index++;
577 func_ret_sub = 0;
578 /* pascal type call ? */
579 if (func_call == FUNC_STDCALL)
580 func_ret_sub = addr - 8;
581 #ifndef TCC_TARGET_PE
582 else if (func_vc)
583 func_ret_sub = 4;
584 #endif
586 #ifdef CONFIG_TCC_BCHECK
587 /* leave some room for bound checking code */
588 if (tcc_state->do_bounds_check) {
589 oad(0xb8, 0); /* lbound section pointer */
590 oad(0xb8, 0); /* call to function */
591 func_bound_offset = lbounds_section->data_offset;
593 #endif
596 /* generate function epilog */
597 ST_FUNC void gfunc_epilog(void)
599 addr_t v, saved_ind;
601 #ifdef CONFIG_TCC_BCHECK
602 if (tcc_state->do_bounds_check
603 && func_bound_offset != lbounds_section->data_offset) {
604 addr_t saved_ind;
605 addr_t *bounds_ptr;
606 Sym *sym_data;
607 /* add end of table info */
608 bounds_ptr = section_ptr_add(lbounds_section, sizeof(addr_t));
609 *bounds_ptr = 0;
610 /* generate bound local allocation */
611 saved_ind = ind;
612 ind = func_sub_sp_offset;
613 sym_data = get_sym_ref(&char_pointer_type, lbounds_section,
614 func_bound_offset, lbounds_section->data_offset);
615 greloc(cur_text_section, sym_data,
616 ind + 1, R_386_32);
617 oad(0xb8, 0); /* mov %eax, xxx */
618 gen_static_call(TOK___bound_local_new);
620 ind = saved_ind;
621 /* generate bound check local freeing */
622 o(0x5250); /* save returned value, if any */
623 greloc(cur_text_section, sym_data,
624 ind + 1, R_386_32);
625 oad(0xb8, 0); /* mov %eax, xxx */
626 gen_static_call(TOK___bound_local_delete);
628 o(0x585a); /* restore returned value, if any */
630 #endif
631 o(0xc9); /* leave */
632 if (func_ret_sub == 0) {
633 o(0xc3); /* ret */
634 } else {
635 o(0xc2); /* ret n */
636 g(func_ret_sub);
637 g(func_ret_sub >> 8);
639 /* align local size to word & save local variables */
641 v = (-loc + 3) & -4;
642 saved_ind = ind;
643 ind = func_sub_sp_offset - FUNC_PROLOG_SIZE;
644 #ifdef TCC_TARGET_PE
645 if (v >= 4096) {
646 oad(0xb8, v); /* mov stacksize, %eax */
647 gen_static_call(TOK___chkstk); /* call __chkstk, (does the stackframe too) */
648 } else
649 #endif
651 o(0xe58955); /* push %ebp, mov %esp, %ebp */
652 o(0xec81); /* sub esp, stacksize */
653 gen_le32(v);
654 #if FUNC_PROLOG_SIZE == 10
655 o(0x90); /* adjust to FUNC_PROLOG_SIZE */
656 #endif
658 ind = saved_ind;
661 /* generate a jump to a label */
662 ST_FUNC int gjmp(int t)
664 return psym(0xe9, t);
667 /* generate a jump to a fixed address */
668 ST_FUNC void gjmp_addr(int a)
670 int r;
671 r = a - ind - 2;
672 if (r == (char)r) {
673 g(0xeb);
674 g(r);
675 } else {
676 oad(0xe9, a - ind - 5);
680 /* generate a test. set 'inv' to invert test. Stack entry is popped */
681 ST_FUNC int gtst(int inv, int t)
683 int v, *p;
685 v = vtop->r & VT_VALMASK;
686 if (v == VT_CMP) {
687 /* fast case : can jump directly since flags are set */
688 g(0x0f);
689 t = psym((vtop->c.i - 16) ^ inv, t);
690 } else if (v == VT_JMP || v == VT_JMPI) {
691 /* && or || optimization */
692 if ((v & 1) == inv) {
693 /* insert vtop->c jump list in t */
694 p = &vtop->c.i;
695 while (*p != 0)
696 p = (int *)(cur_text_section->data + *p);
697 *p = t;
698 t = vtop->c.i;
699 } else {
700 t = gjmp(t);
701 gsym(vtop->c.i);
704 vtop--;
705 return t;
708 /* generate an integer binary operation */
709 ST_FUNC void gen_opi(int op)
711 int r, fr, opc, c;
713 switch(op) {
714 case '+':
715 case TOK_ADDC1: /* add with carry generation */
716 opc = 0;
717 gen_op8:
718 if ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST) {
719 /* constant case */
720 vswap();
721 r = gv(RC_INT);
722 vswap();
723 c = vtop->c.i;
724 if (c == (char)c) {
725 /* generate inc and dec for smaller code */
726 if (c==1 && opc==0) {
727 o (0x40 | r); // inc
728 } else if (c==1 && opc==5) {
729 o (0x48 | r); // dec
730 } else {
731 o(0x83);
732 o(0xc0 | (opc << 3) | r);
733 g(c);
735 } else {
736 o(0x81);
737 oad(0xc0 | (opc << 3) | r, c);
739 } else {
740 gv2(RC_INT, RC_INT);
741 r = vtop[-1].r;
742 fr = vtop[0].r;
743 o((opc << 3) | 0x01);
744 o(0xc0 + r + fr * 8);
746 vtop--;
747 if (op >= TOK_ULT && op <= TOK_GT) {
748 vtop->r = VT_CMP;
749 vtop->c.i = op;
751 break;
752 case '-':
753 case TOK_SUBC1: /* sub with carry generation */
754 opc = 5;
755 goto gen_op8;
756 case TOK_ADDC2: /* add with carry use */
757 opc = 2;
758 goto gen_op8;
759 case TOK_SUBC2: /* sub with carry use */
760 opc = 3;
761 goto gen_op8;
762 case '&':
763 opc = 4;
764 goto gen_op8;
765 case '^':
766 opc = 6;
767 goto gen_op8;
768 case '|':
769 opc = 1;
770 goto gen_op8;
771 case '*':
772 gv2(RC_INT, RC_INT);
773 r = vtop[-1].r;
774 fr = vtop[0].r;
775 vtop--;
776 o(0xaf0f); /* imul fr, r */
777 o(0xc0 + fr + r * 8);
778 break;
779 case TOK_SHL:
780 opc = 4;
781 goto gen_shift;
782 case TOK_SHR:
783 opc = 5;
784 goto gen_shift;
785 case TOK_SAR:
786 opc = 7;
787 gen_shift:
788 opc = 0xc0 | (opc << 3);
789 if ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST) {
790 /* constant case */
791 vswap();
792 r = gv(RC_INT);
793 vswap();
794 c = vtop->c.i & 0x1f;
795 o(0xc1); /* shl/shr/sar $xxx, r */
796 o(opc | r);
797 g(c);
798 } else {
799 /* we generate the shift in ecx */
800 gv2(RC_INT, RC_ECX);
801 r = vtop[-1].r;
802 o(0xd3); /* shl/shr/sar %cl, r */
803 o(opc | r);
805 vtop--;
806 break;
807 case '/':
808 case TOK_UDIV:
809 case TOK_PDIV:
810 case '%':
811 case TOK_UMOD:
812 case TOK_UMULL:
813 /* first operand must be in eax */
814 /* XXX: need better constraint for second operand */
815 gv2(RC_EAX, RC_ECX);
816 r = vtop[-1].r;
817 fr = vtop[0].r;
818 vtop--;
819 save_reg(TREG_EDX);
820 if (op == TOK_UMULL) {
821 o(0xf7); /* mul fr */
822 o(0xe0 + fr);
823 vtop->r2 = TREG_EDX;
824 r = TREG_EAX;
825 } else {
826 if (op == TOK_UDIV || op == TOK_UMOD) {
827 o(0xf7d231); /* xor %edx, %edx, div fr, %eax */
828 o(0xf0 + fr);
829 } else {
830 o(0xf799); /* cltd, idiv fr, %eax */
831 o(0xf8 + fr);
833 if (op == '%' || op == TOK_UMOD)
834 r = TREG_EDX;
835 else
836 r = TREG_EAX;
838 vtop->r = r;
839 break;
840 default:
841 opc = 7;
842 goto gen_op8;
846 /* generate a floating point operation 'v = t1 op t2' instruction. The
847 two operands are guaranted to have the same floating point type */
848 /* XXX: need to use ST1 too */
849 ST_FUNC void gen_opf(int op)
851 int a, ft, fc, swapped, r;
853 /* convert constants to memory references */
854 if ((vtop[-1].r & (VT_VALMASK | VT_LVAL)) == VT_CONST) {
855 vswap();
856 gv(RC_FLOAT);
857 vswap();
859 if ((vtop[0].r & (VT_VALMASK | VT_LVAL)) == VT_CONST)
860 gv(RC_FLOAT);
862 /* must put at least one value in the floating point register */
863 if ((vtop[-1].r & VT_LVAL) &&
864 (vtop[0].r & VT_LVAL)) {
865 vswap();
866 gv(RC_FLOAT);
867 vswap();
869 swapped = 0;
870 /* swap the stack if needed so that t1 is the register and t2 is
871 the memory reference */
872 if (vtop[-1].r & VT_LVAL) {
873 vswap();
874 swapped = 1;
876 if (op >= TOK_ULT && op <= TOK_GT) {
877 /* load on stack second operand */
878 load(TREG_ST0, vtop);
879 save_reg(TREG_EAX); /* eax is used by FP comparison code */
880 if (op == TOK_GE || op == TOK_GT)
881 swapped = !swapped;
882 else if (op == TOK_EQ || op == TOK_NE)
883 swapped = 0;
884 if (swapped)
885 o(0xc9d9); /* fxch %st(1) */
886 if (op == TOK_EQ || op == TOK_NE)
887 o(0xe9da); /* fucompp */
888 else
889 o(0xd9de); /* fcompp */
890 o(0xe0df); /* fnstsw %ax */
891 if (op == TOK_EQ) {
892 o(0x45e480); /* and $0x45, %ah */
893 o(0x40fC80); /* cmp $0x40, %ah */
894 } else if (op == TOK_NE) {
895 o(0x45e480); /* and $0x45, %ah */
896 o(0x40f480); /* xor $0x40, %ah */
897 op = TOK_NE;
898 } else if (op == TOK_GE || op == TOK_LE) {
899 o(0x05c4f6); /* test $0x05, %ah */
900 op = TOK_EQ;
901 } else {
902 o(0x45c4f6); /* test $0x45, %ah */
903 op = TOK_EQ;
905 vtop--;
906 vtop->r = VT_CMP;
907 vtop->c.i = op;
908 } else {
909 /* no memory reference possible for long double operations */
910 if ((vtop->type.t & VT_BTYPE) == VT_LDOUBLE) {
911 load(TREG_ST0, vtop);
912 swapped = !swapped;
915 switch(op) {
916 default:
917 case '+':
918 a = 0;
919 break;
920 case '-':
921 a = 4;
922 if (swapped)
923 a++;
924 break;
925 case '*':
926 a = 1;
927 break;
928 case '/':
929 a = 6;
930 if (swapped)
931 a++;
932 break;
934 ft = vtop->type.t;
935 fc = vtop->c.ul;
936 if ((ft & VT_BTYPE) == VT_LDOUBLE) {
937 o(0xde); /* fxxxp %st, %st(1) */
938 o(0xc1 + (a << 3));
939 } else {
940 /* if saved lvalue, then we must reload it */
941 r = vtop->r;
942 if ((r & VT_VALMASK) == VT_LLOCAL) {
943 SValue v1;
944 r = get_reg(RC_INT);
945 v1.type.t = VT_INT;
946 v1.r = VT_LOCAL | VT_LVAL;
947 v1.c.ul = fc;
948 load(r, &v1);
949 fc = 0;
952 if ((ft & VT_BTYPE) == VT_DOUBLE)
953 o(0xdc);
954 else
955 o(0xd8);
956 gen_modrm(a, r, vtop->sym, fc);
958 vtop--;
962 /* convert integers to fp 't' type. Must handle 'int', 'unsigned int'
963 and 'long long' cases. */
964 ST_FUNC void gen_cvt_itof(int t)
966 save_reg(TREG_ST0);
967 gv(RC_INT);
968 if ((vtop->type.t & VT_BTYPE) == VT_LLONG) {
969 /* signed long long to float/double/long double (unsigned case
970 is handled generically) */
971 o(0x50 + vtop->r2); /* push r2 */
972 o(0x50 + (vtop->r & VT_VALMASK)); /* push r */
973 o(0x242cdf); /* fildll (%esp) */
974 o(0x08c483); /* add $8, %esp */
975 } else if ((vtop->type.t & (VT_BTYPE | VT_UNSIGNED)) ==
976 (VT_INT | VT_UNSIGNED)) {
977 /* unsigned int to float/double/long double */
978 o(0x6a); /* push $0 */
979 g(0x00);
980 o(0x50 + (vtop->r & VT_VALMASK)); /* push r */
981 o(0x242cdf); /* fildll (%esp) */
982 o(0x08c483); /* add $8, %esp */
983 } else {
984 /* int to float/double/long double */
985 o(0x50 + (vtop->r & VT_VALMASK)); /* push r */
986 o(0x2404db); /* fildl (%esp) */
987 o(0x04c483); /* add $4, %esp */
989 vtop->r = TREG_ST0;
992 /* convert fp to int 't' type */
993 ST_FUNC void gen_cvt_ftoi(int t)
995 #ifndef COMMIT_4ad186c5ef61_IS_FIXED
996 /* a good version but it takes a more time to execute */
997 gv(RC_FLOAT);
998 save_reg(TREG_EAX);
999 save_reg(TREG_EDX);
1000 gen_static_call(TOK___tcc_cvt_ftol);
1001 vtop->r = TREG_EAX; /* mark reg as used */
1002 if (t == VT_LLONG)
1003 vtop->r2 = TREG_EDX;
1004 #else
1005 /* a new version with a bug: t2a = 44100312 */
1006 /*
1007 #include<stdio.h>
1008 int main() {
1009 int t1 = 176401255;
1010 float f = 0.25f;
1011 int t2a = (int)(t1 * f); // must be 44100313
1012 int t2b = (int)(t1 * (float)0.25f);
1013 printf("t2a=%d t2b=%d \n",t2a,t2b);
1014 return 0;
1016 */
1017 int bt = vtop->type.t & VT_BTYPE;
1018 if (bt == VT_FLOAT)
1019 vpush_global_sym(&func_old_type, TOK___fixsfdi);
1020 else if (bt == VT_LDOUBLE)
1021 vpush_global_sym(&func_old_type, TOK___fixxfdi);
1022 else
1023 vpush_global_sym(&func_old_type, TOK___fixdfdi);
1024 vswap();
1025 gfunc_call(1);
1026 vpushi(0);
1027 vtop->r = REG_IRET;
1028 vtop->r2 = REG_LRET;
1029 #endif
1032 /* convert from one floating point type to another */
1033 ST_FUNC void gen_cvt_ftof(int t)
1035 /* all we have to do on i386 is to put the float in a register */
1036 gv(RC_FLOAT);
1039 /* computed goto support */
1040 ST_FUNC void ggoto(void)
1042 gcall_or_jmp(1);
1043 vtop--;
1046 /* bound check support functions */
1047 #ifdef CONFIG_TCC_BCHECK
1049 /* generate a bounded pointer addition */
1050 ST_FUNC void gen_bounded_ptr_add(void)
1052 /* prepare fast i386 function call (args in eax and edx) */
1053 gv2(RC_EAX, RC_EDX);
1054 /* save all temporary registers */
1055 vtop -= 2;
1056 save_regs(0);
1057 /* do a fast function call */
1058 gen_static_call(TOK___bound_ptr_add);
1059 /* returned pointer is in eax */
1060 vtop++;
1061 vtop->r = TREG_EAX | VT_BOUNDED;
1062 /* address of bounding function call point */
1063 vtop->c.ul = (cur_text_section->reloc->data_offset - sizeof(Elf32_Rel));
1066 /* patch pointer addition in vtop so that pointer dereferencing is
1067 also tested */
1068 ST_FUNC void gen_bounded_ptr_deref(void)
1070 addr_t func;
1071 addr_t size, align;
1072 Elf32_Rel *rel;
1073 Sym *sym;
1075 size = 0;
1076 /* XXX: put that code in generic part of tcc */
1077 if (!is_float(vtop->type.t)) {
1078 if (vtop->r & VT_LVAL_BYTE)
1079 size = 1;
1080 else if (vtop->r & VT_LVAL_SHORT)
1081 size = 2;
1083 if (!size)
1084 size = type_size(&vtop->type, &align);
1085 switch(size) {
1086 case 1: func = TOK___bound_ptr_indir1; break;
1087 case 2: func = TOK___bound_ptr_indir2; break;
1088 case 4: func = TOK___bound_ptr_indir4; break;
1089 case 8: func = TOK___bound_ptr_indir8; break;
1090 case 12: func = TOK___bound_ptr_indir12; break;
1091 case 16: func = TOK___bound_ptr_indir16; break;
1092 default:
1093 tcc_error("unhandled size when dereferencing bounded pointer");
1094 func = 0;
1095 break;
1098 /* patch relocation */
1099 /* XXX: find a better solution ? */
1100 rel = (Elf32_Rel *)(cur_text_section->reloc->data + vtop->c.ul);
1101 sym = external_global_sym(func, &func_old_type, 0);
1102 if (!sym->c)
1103 put_extern_sym(sym, NULL, 0, 0);
1104 rel->r_info = ELF32_R_INFO(sym->c, ELF32_R_TYPE(rel->r_info));
1106 #endif
1108 /* Save the stack pointer onto the stack */
1109 ST_FUNC void gen_vla_sp_save(int addr) {
1110 /* mov %esp,addr(%ebp)*/
1111 o(0x89);
1112 gen_modrm(TREG_ESP, VT_LOCAL, NULL, addr);
1115 /* Restore the SP from a location on the stack */
1116 ST_FUNC void gen_vla_sp_restore(int addr) {
1117 o(0x8b);
1118 gen_modrm(TREG_ESP, VT_LOCAL, NULL, addr);
1121 /* Subtract from the stack pointer, and push the resulting value onto the stack */
1122 ST_FUNC void gen_vla_alloc(CType *type, int align) {
1123 #ifdef TCC_TARGET_PE
1124 /* alloca does more than just adjust %rsp on Windows */
1125 vpush_global_sym(&func_old_type, TOK_alloca);
1126 vswap(); /* Move alloca ref past allocation size */
1127 gfunc_call(1);
1128 #else
1129 int r;
1130 r = gv(RC_INT); /* allocation size */
1131 /* sub r,%rsp */
1132 o(0x2b);
1133 o(0xe0 | r);
1134 /* We align to 16 bytes rather than align */
1135 /* and ~15, %esp */
1136 o(0xf0e483);
1137 vpop();
1138 #endif
1141 /* end of X86 code generator */
1142 /*************************************************************/
1143 #endif
1144 /*************************************************************/