Adding two more people to the RELICENSING file.
[tinycc.git] / i386-gen.c
blob8284cf0fb80c32900d1dfd3a4035214e0c2c0f80
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 /* 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
47 };
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,
97 };
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 int n, *ptr;
142 while (t) {
143 ptr = (int *)(cur_text_section->data + t);
144 n = *ptr; /* next value */
145 *ptr = a - t - 4;
146 t = n;
150 ST_FUNC void gsym(int t)
152 gsym_addr(t, ind);
155 /* psym is used to put an instruction with a data field which is a
156 reference to a symbol. It is in fact the same as oad ! */
157 #define psym oad
159 /* instruction + 4 bytes data. Return the address of the data */
160 ST_FUNC int oad(int c, int s)
162 int ind1;
164 o(c);
165 ind1 = ind + 4;
166 if (ind1 > cur_text_section->data_allocated)
167 section_realloc(cur_text_section, ind1);
168 *(int *)(cur_text_section->data + ind) = s;
169 s = ind;
170 ind = ind1;
171 return s;
174 /* output constant with relocation if 'r & VT_SYM' is true */
175 ST_FUNC void gen_addr32(int r, Sym *sym, int c)
177 if (r & VT_SYM)
178 greloc(cur_text_section, sym, ind, R_386_32);
179 gen_le32(c);
182 ST_FUNC void gen_addrpc32(int r, Sym *sym, int c)
184 if (r & VT_SYM)
185 greloc(cur_text_section, sym, ind, R_386_PC32);
186 gen_le32(c - 4);
189 /* generate a modrm reference. 'op_reg' contains the addtionnal 3
190 opcode bits */
191 static void gen_modrm(int op_reg, int r, Sym *sym, int c)
193 op_reg = op_reg << 3;
194 if ((r & VT_VALMASK) == VT_CONST) {
195 /* constant memory reference */
196 o(0x05 | op_reg);
197 gen_addr32(r, sym, c);
198 } else if ((r & VT_VALMASK) == VT_LOCAL) {
199 /* currently, we use only ebp as base */
200 if (c == (char)c) {
201 /* short reference */
202 o(0x45 | op_reg);
203 g(c);
204 } else {
205 oad(0x85 | op_reg, c);
207 } else {
208 g(0x00 | op_reg | (r & VT_VALMASK));
212 /* load 'r' from value 'sv' */
213 ST_FUNC void load(int r, SValue *sv)
215 int v, t, ft, fc, fr;
216 SValue v1;
218 #ifdef TCC_TARGET_PE
219 SValue v2;
220 sv = pe_getimport(sv, &v2);
221 #endif
223 fr = sv->r;
224 ft = sv->type.t;
225 fc = sv->c.ul;
227 v = fr & VT_VALMASK;
228 if (fr & VT_LVAL) {
229 if (v == VT_LLOCAL) {
230 v1.type.t = VT_INT;
231 v1.r = VT_LOCAL | VT_LVAL;
232 v1.c.ul = fc;
233 fr = r;
234 if (!(reg_classes[fr] & RC_INT))
235 fr = get_reg(RC_INT);
236 load(fr, &v1);
238 if ((ft & VT_BTYPE) == VT_FLOAT) {
239 o(0xd9); /* flds */
240 r = 0;
241 } else if ((ft & VT_BTYPE) == VT_DOUBLE) {
242 o(0xdd); /* fldl */
243 r = 0;
244 } else if ((ft & VT_BTYPE) == VT_LDOUBLE) {
245 o(0xdb); /* fldt */
246 r = 5;
247 } else if ((ft & VT_TYPE) == VT_BYTE || (ft & VT_TYPE) == VT_BOOL) {
248 o(0xbe0f); /* movsbl */
249 } else if ((ft & VT_TYPE) == (VT_BYTE | VT_UNSIGNED)) {
250 o(0xb60f); /* movzbl */
251 } else if ((ft & VT_TYPE) == VT_SHORT) {
252 o(0xbf0f); /* movswl */
253 } else if ((ft & VT_TYPE) == (VT_SHORT | VT_UNSIGNED)) {
254 o(0xb70f); /* movzwl */
255 } else {
256 o(0x8b); /* movl */
258 gen_modrm(r, fr, sv->sym, fc);
259 } else {
260 if (v == VT_CONST) {
261 o(0xb8 + r); /* mov $xx, r */
262 gen_addr32(fr, sv->sym, fc);
263 } else if (v == VT_LOCAL) {
264 if (fc) {
265 o(0x8d); /* lea xxx(%ebp), r */
266 gen_modrm(r, VT_LOCAL, sv->sym, fc);
267 } else {
268 o(0x89);
269 o(0xe8 + r); /* mov %ebp, r */
271 } else if (v == VT_CMP) {
272 oad(0xb8 + r, 0); /* mov $0, r */
273 o(0x0f); /* setxx %br */
274 o(fc);
275 o(0xc0 + r);
276 } else if (v == VT_JMP || v == VT_JMPI) {
277 t = v & 1;
278 oad(0xb8 + r, t); /* mov $1, r */
279 o(0x05eb); /* jmp after */
280 gsym(fc);
281 oad(0xb8 + r, t ^ 1); /* mov $0, r */
282 } else if (v != r) {
283 o(0x89);
284 o(0xc0 + r + v * 8); /* mov v, r */
289 /* store register 'r' in lvalue 'v' */
290 ST_FUNC void store(int r, SValue *v)
292 int fr, bt, ft, fc;
294 #ifdef TCC_TARGET_PE
295 SValue v2;
296 v = pe_getimport(v, &v2);
297 #endif
299 ft = v->type.t;
300 fc = v->c.ul;
301 fr = v->r & VT_VALMASK;
302 bt = ft & VT_BTYPE;
303 /* XXX: incorrect if float reg to reg */
304 if (bt == VT_FLOAT) {
305 o(0xd9); /* fsts */
306 r = 2;
307 } else if (bt == VT_DOUBLE) {
308 o(0xdd); /* fstpl */
309 r = 2;
310 } else if (bt == VT_LDOUBLE) {
311 o(0xc0d9); /* fld %st(0) */
312 o(0xdb); /* fstpt */
313 r = 7;
314 } else {
315 if (bt == VT_SHORT)
316 o(0x66);
317 if (bt == VT_BYTE || bt == VT_BOOL)
318 o(0x88);
319 else
320 o(0x89);
322 if (fr == VT_CONST ||
323 fr == VT_LOCAL ||
324 (v->r & VT_LVAL)) {
325 gen_modrm(r, v->r, v->sym, fc);
326 } else if (fr != r) {
327 o(0xc0 + fr + r * 8); /* mov r, fr */
331 static void gadd_sp(int val)
333 if (val == (char)val) {
334 o(0xc483);
335 g(val);
336 } else {
337 oad(0xc481, val); /* add $xxx, %esp */
341 static void gen_static_call(int v)
343 Sym *sym;
345 sym = external_global_sym(v, &func_old_type, 0);
346 oad(0xe8, -4);
347 greloc(cur_text_section, sym, ind-4, R_386_PC32);
350 /* 'is_jmp' is '1' if it is a jump */
351 static void gcall_or_jmp(int is_jmp)
353 int r;
354 if ((vtop->r & (VT_VALMASK | VT_LVAL)) == VT_CONST) {
355 /* constant case */
356 if (vtop->r & VT_SYM) {
357 /* relocation case */
358 greloc(cur_text_section, vtop->sym,
359 ind + 1, R_386_PC32);
360 } else {
361 /* put an empty PC32 relocation */
362 put_elf_reloc(symtab_section, cur_text_section,
363 ind + 1, R_386_PC32, 0);
365 oad(0xe8 + is_jmp, vtop->c.ul - 4); /* call/jmp im */
366 } else {
367 /* otherwise, indirect call */
368 r = gv(RC_INT);
369 o(0xff); /* call/jmp *r */
370 o(0xd0 + r + (is_jmp << 4));
374 static uint8_t fastcall_regs[3] = { TREG_EAX, TREG_EDX, TREG_ECX };
375 static uint8_t fastcallw_regs[2] = { TREG_ECX, TREG_EDX };
377 /* Return the number of registers needed to return the struct, or 0 if
378 returning via struct pointer. */
379 ST_FUNC int gfunc_sret(CType *vt, int variadic, CType *ret, int *ret_align, int *regsize)
381 #ifdef TCC_TARGET_PE
382 int size, align;
384 *ret_align = 1; // Never have to re-align return values for x86
385 *regsize = 4;
386 size = type_size(vt, &align);
387 if (size > 8) {
388 return 0;
389 } else if (size > 4) {
390 ret->ref = NULL;
391 ret->t = VT_LLONG;
392 return 1;
393 } else {
394 ret->ref = NULL;
395 ret->t = VT_INT;
396 return 1;
398 #else
399 *ret_align = 1; // Never have to re-align return values for x86
400 return 0;
401 #endif
404 /* Generate function call. The function address is pushed first, then
405 all the parameters in call order. This functions pops all the
406 parameters and the function address. */
407 ST_FUNC void gfunc_call(int nb_args)
409 int size, align, r, args_size, i, func_call;
410 Sym *func_sym;
412 args_size = 0;
413 for(i = 0;i < nb_args; i++) {
414 if ((vtop->type.t & VT_BTYPE) == VT_STRUCT) {
415 size = type_size(&vtop->type, &align);
416 /* align to stack align size */
417 size = (size + 3) & ~3;
418 /* allocate the necessary size on stack */
419 oad(0xec81, size); /* sub $xxx, %esp */
420 /* generate structure store */
421 r = get_reg(RC_INT);
422 o(0x89); /* mov %esp, r */
423 o(0xe0 + r);
424 vset(&vtop->type, r | VT_LVAL, 0);
425 vswap();
426 vstore();
427 args_size += size;
428 } else if (is_float(vtop->type.t)) {
429 gv(RC_FLOAT); /* only one float register */
430 if ((vtop->type.t & VT_BTYPE) == VT_FLOAT)
431 size = 4;
432 else if ((vtop->type.t & VT_BTYPE) == VT_DOUBLE)
433 size = 8;
434 else
435 size = 12;
436 oad(0xec81, size); /* sub $xxx, %esp */
437 if (size == 12)
438 o(0x7cdb);
439 else
440 o(0x5cd9 + size - 4); /* fstp[s|l] 0(%esp) */
441 g(0x24);
442 g(0x00);
443 args_size += size;
444 } else {
445 /* simple type (currently always same size) */
446 /* XXX: implicit cast ? */
447 r = gv(RC_INT);
448 if ((vtop->type.t & VT_BTYPE) == VT_LLONG) {
449 size = 8;
450 o(0x50 + vtop->r2); /* push r */
451 } else {
452 size = 4;
454 o(0x50 + r); /* push r */
455 args_size += size;
457 vtop--;
459 save_regs(0); /* save used temporary registers */
460 func_sym = vtop->type.ref;
461 func_call = func_sym->a.func_call;
462 /* fast call case */
463 if ((func_call >= FUNC_FASTCALL1 && func_call <= FUNC_FASTCALL3) ||
464 func_call == FUNC_FASTCALLW) {
465 int fastcall_nb_regs;
466 uint8_t *fastcall_regs_ptr;
467 if (func_call == FUNC_FASTCALLW) {
468 fastcall_regs_ptr = fastcallw_regs;
469 fastcall_nb_regs = 2;
470 } else {
471 fastcall_regs_ptr = fastcall_regs;
472 fastcall_nb_regs = func_call - FUNC_FASTCALL1 + 1;
474 for(i = 0;i < fastcall_nb_regs; i++) {
475 if (args_size <= 0)
476 break;
477 o(0x58 + fastcall_regs_ptr[i]); /* pop r */
478 /* XXX: incorrect for struct/floats */
479 args_size -= 4;
482 #ifndef TCC_TARGET_PE
483 else if ((vtop->type.ref->type.t & VT_BTYPE) == VT_STRUCT)
484 args_size -= 4;
485 #endif
486 gcall_or_jmp(0);
488 if (args_size && func_call != FUNC_STDCALL)
489 gadd_sp(args_size);
490 vtop--;
493 #ifdef TCC_TARGET_PE
494 #define FUNC_PROLOG_SIZE 10
495 #else
496 #define FUNC_PROLOG_SIZE 9
497 #endif
499 /* generate function prolog of type 't' */
500 ST_FUNC void gfunc_prolog(CType *func_type)
502 int addr, align, size, func_call, fastcall_nb_regs;
503 int param_index, param_addr;
504 uint8_t *fastcall_regs_ptr;
505 Sym *sym;
506 CType *type;
508 sym = func_type->ref;
509 func_call = sym->a.func_call;
510 addr = 8;
511 loc = 0;
512 func_vc = 0;
514 if (func_call >= FUNC_FASTCALL1 && func_call <= FUNC_FASTCALL3) {
515 fastcall_nb_regs = func_call - FUNC_FASTCALL1 + 1;
516 fastcall_regs_ptr = fastcall_regs;
517 } else if (func_call == FUNC_FASTCALLW) {
518 fastcall_nb_regs = 2;
519 fastcall_regs_ptr = fastcallw_regs;
520 } else {
521 fastcall_nb_regs = 0;
522 fastcall_regs_ptr = NULL;
524 param_index = 0;
526 ind += FUNC_PROLOG_SIZE;
527 func_sub_sp_offset = ind;
528 /* if the function returns a structure, then add an
529 implicit pointer parameter */
530 func_vt = sym->type;
531 func_var = (sym->c == FUNC_ELLIPSIS);
532 #ifdef TCC_TARGET_PE
533 size = type_size(&func_vt,&align);
534 if (((func_vt.t & VT_BTYPE) == VT_STRUCT) && (size > 8)) {
535 #else
536 if ((func_vt.t & VT_BTYPE) == VT_STRUCT) {
537 #endif
538 /* XXX: fastcall case ? */
539 func_vc = addr;
540 addr += 4;
541 param_index++;
543 /* define parameters */
544 while ((sym = sym->next) != NULL) {
545 type = &sym->type;
546 size = type_size(type, &align);
547 size = (size + 3) & ~3;
548 #ifdef FUNC_STRUCT_PARAM_AS_PTR
549 /* structs are passed as pointer */
550 if ((type->t & VT_BTYPE) == VT_STRUCT) {
551 size = 4;
553 #endif
554 if (param_index < fastcall_nb_regs) {
555 /* save FASTCALL register */
556 loc -= 4;
557 o(0x89); /* movl */
558 gen_modrm(fastcall_regs_ptr[param_index], VT_LOCAL, NULL, loc);
559 param_addr = loc;
560 } else {
561 param_addr = addr;
562 addr += size;
564 sym_push(sym->v & ~SYM_FIELD, type,
565 VT_LOCAL | lvalue_type(type->t), param_addr);
566 param_index++;
568 func_ret_sub = 0;
569 /* pascal type call ? */
570 if (func_call == FUNC_STDCALL)
571 func_ret_sub = addr - 8;
572 #ifndef TCC_TARGET_PE
573 else if (func_vc)
574 func_ret_sub = 4;
575 #endif
577 #ifdef CONFIG_TCC_BCHECK
578 /* leave some room for bound checking code */
579 if (tcc_state->do_bounds_check) {
580 oad(0xb8, 0); /* lbound section pointer */
581 oad(0xb8, 0); /* call to function */
582 func_bound_offset = lbounds_section->data_offset;
584 #endif
587 /* generate function epilog */
588 ST_FUNC void gfunc_epilog(void)
590 addr_t v, saved_ind;
592 #ifdef CONFIG_TCC_BCHECK
593 if (tcc_state->do_bounds_check
594 && func_bound_offset != lbounds_section->data_offset) {
595 addr_t saved_ind;
596 addr_t *bounds_ptr;
597 Sym *sym_data;
598 /* add end of table info */
599 bounds_ptr = section_ptr_add(lbounds_section, sizeof(addr_t));
600 *bounds_ptr = 0;
601 /* generate bound local allocation */
602 saved_ind = ind;
603 ind = func_sub_sp_offset;
604 sym_data = get_sym_ref(&char_pointer_type, lbounds_section,
605 func_bound_offset, lbounds_section->data_offset);
606 greloc(cur_text_section, sym_data,
607 ind + 1, R_386_32);
608 oad(0xb8, 0); /* mov %eax, xxx */
609 gen_static_call(TOK___bound_local_new);
611 ind = saved_ind;
612 /* generate bound check local freeing */
613 o(0x5250); /* save returned value, if any */
614 greloc(cur_text_section, sym_data,
615 ind + 1, R_386_32);
616 oad(0xb8, 0); /* mov %eax, xxx */
617 gen_static_call(TOK___bound_local_delete);
619 o(0x585a); /* restore returned value, if any */
621 #endif
622 o(0xc9); /* leave */
623 if (func_ret_sub == 0) {
624 o(0xc3); /* ret */
625 } else {
626 o(0xc2); /* ret n */
627 g(func_ret_sub);
628 g(func_ret_sub >> 8);
630 /* align local size to word & save local variables */
632 v = (-loc + 3) & -4;
633 saved_ind = ind;
634 ind = func_sub_sp_offset - FUNC_PROLOG_SIZE;
635 #ifdef TCC_TARGET_PE
636 if (v >= 4096) {
637 oad(0xb8, v); /* mov stacksize, %eax */
638 gen_static_call(TOK___chkstk); /* call __chkstk, (does the stackframe too) */
639 } else
640 #endif
642 o(0xe58955); /* push %ebp, mov %esp, %ebp */
643 o(0xec81); /* sub esp, stacksize */
644 gen_le32(v);
645 #if FUNC_PROLOG_SIZE == 10
646 o(0x90); /* adjust to FUNC_PROLOG_SIZE */
647 #endif
649 ind = saved_ind;
652 /* generate a jump to a label */
653 ST_FUNC int gjmp(int t)
655 return psym(0xe9, t);
658 /* generate a jump to a fixed address */
659 ST_FUNC void gjmp_addr(int a)
661 int r;
662 r = a - ind - 2;
663 if (r == (char)r) {
664 g(0xeb);
665 g(r);
666 } else {
667 oad(0xe9, a - ind - 5);
671 /* generate a test. set 'inv' to invert test. Stack entry is popped */
672 ST_FUNC int gtst(int inv, int t)
674 int v, *p;
676 v = vtop->r & VT_VALMASK;
677 if (v == VT_CMP) {
678 /* fast case : can jump directly since flags are set */
679 g(0x0f);
680 t = psym((vtop->c.i - 16) ^ inv, t);
681 } else if (v == VT_JMP || v == VT_JMPI) {
682 /* && or || optimization */
683 if ((v & 1) == inv) {
684 /* insert vtop->c jump list in t */
685 p = &vtop->c.i;
686 while (*p != 0)
687 p = (int *)(cur_text_section->data + *p);
688 *p = t;
689 t = vtop->c.i;
690 } else {
691 t = gjmp(t);
692 gsym(vtop->c.i);
695 vtop--;
696 return t;
699 /* generate an integer binary operation */
700 ST_FUNC void gen_opi(int op)
702 int r, fr, opc, c;
704 switch(op) {
705 case '+':
706 case TOK_ADDC1: /* add with carry generation */
707 opc = 0;
708 gen_op8:
709 if ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST) {
710 /* constant case */
711 vswap();
712 r = gv(RC_INT);
713 vswap();
714 c = vtop->c.i;
715 if (c == (char)c) {
716 /* generate inc and dec for smaller code */
717 if (c==1 && opc==0) {
718 o (0x40 | r); // inc
719 } else if (c==1 && opc==5) {
720 o (0x48 | r); // dec
721 } else {
722 o(0x83);
723 o(0xc0 | (opc << 3) | r);
724 g(c);
726 } else {
727 o(0x81);
728 oad(0xc0 | (opc << 3) | r, c);
730 } else {
731 gv2(RC_INT, RC_INT);
732 r = vtop[-1].r;
733 fr = vtop[0].r;
734 o((opc << 3) | 0x01);
735 o(0xc0 + r + fr * 8);
737 vtop--;
738 if (op >= TOK_ULT && op <= TOK_GT) {
739 vtop->r = VT_CMP;
740 vtop->c.i = op;
742 break;
743 case '-':
744 case TOK_SUBC1: /* sub with carry generation */
745 opc = 5;
746 goto gen_op8;
747 case TOK_ADDC2: /* add with carry use */
748 opc = 2;
749 goto gen_op8;
750 case TOK_SUBC2: /* sub with carry use */
751 opc = 3;
752 goto gen_op8;
753 case '&':
754 opc = 4;
755 goto gen_op8;
756 case '^':
757 opc = 6;
758 goto gen_op8;
759 case '|':
760 opc = 1;
761 goto gen_op8;
762 case '*':
763 gv2(RC_INT, RC_INT);
764 r = vtop[-1].r;
765 fr = vtop[0].r;
766 vtop--;
767 o(0xaf0f); /* imul fr, r */
768 o(0xc0 + fr + r * 8);
769 break;
770 case TOK_SHL:
771 opc = 4;
772 goto gen_shift;
773 case TOK_SHR:
774 opc = 5;
775 goto gen_shift;
776 case TOK_SAR:
777 opc = 7;
778 gen_shift:
779 opc = 0xc0 | (opc << 3);
780 if ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST) {
781 /* constant case */
782 vswap();
783 r = gv(RC_INT);
784 vswap();
785 c = vtop->c.i & 0x1f;
786 o(0xc1); /* shl/shr/sar $xxx, r */
787 o(opc | r);
788 g(c);
789 } else {
790 /* we generate the shift in ecx */
791 gv2(RC_INT, RC_ECX);
792 r = vtop[-1].r;
793 o(0xd3); /* shl/shr/sar %cl, r */
794 o(opc | r);
796 vtop--;
797 break;
798 case '/':
799 case TOK_UDIV:
800 case TOK_PDIV:
801 case '%':
802 case TOK_UMOD:
803 case TOK_UMULL:
804 /* first operand must be in eax */
805 /* XXX: need better constraint for second operand */
806 gv2(RC_EAX, RC_ECX);
807 r = vtop[-1].r;
808 fr = vtop[0].r;
809 vtop--;
810 save_reg(TREG_EDX);
811 if (op == TOK_UMULL) {
812 o(0xf7); /* mul fr */
813 o(0xe0 + fr);
814 vtop->r2 = TREG_EDX;
815 r = TREG_EAX;
816 } else {
817 if (op == TOK_UDIV || op == TOK_UMOD) {
818 o(0xf7d231); /* xor %edx, %edx, div fr, %eax */
819 o(0xf0 + fr);
820 } else {
821 o(0xf799); /* cltd, idiv fr, %eax */
822 o(0xf8 + fr);
824 if (op == '%' || op == TOK_UMOD)
825 r = TREG_EDX;
826 else
827 r = TREG_EAX;
829 vtop->r = r;
830 break;
831 default:
832 opc = 7;
833 goto gen_op8;
837 /* generate a floating point operation 'v = t1 op t2' instruction. The
838 two operands are guaranted to have the same floating point type */
839 /* XXX: need to use ST1 too */
840 ST_FUNC void gen_opf(int op)
842 int a, ft, fc, swapped, r;
844 /* convert constants to memory references */
845 if ((vtop[-1].r & (VT_VALMASK | VT_LVAL)) == VT_CONST) {
846 vswap();
847 gv(RC_FLOAT);
848 vswap();
850 if ((vtop[0].r & (VT_VALMASK | VT_LVAL)) == VT_CONST)
851 gv(RC_FLOAT);
853 /* must put at least one value in the floating point register */
854 if ((vtop[-1].r & VT_LVAL) &&
855 (vtop[0].r & VT_LVAL)) {
856 vswap();
857 gv(RC_FLOAT);
858 vswap();
860 swapped = 0;
861 /* swap the stack if needed so that t1 is the register and t2 is
862 the memory reference */
863 if (vtop[-1].r & VT_LVAL) {
864 vswap();
865 swapped = 1;
867 if (op >= TOK_ULT && op <= TOK_GT) {
868 /* load on stack second operand */
869 load(TREG_ST0, vtop);
870 save_reg(TREG_EAX); /* eax is used by FP comparison code */
871 if (op == TOK_GE || op == TOK_GT)
872 swapped = !swapped;
873 else if (op == TOK_EQ || op == TOK_NE)
874 swapped = 0;
875 if (swapped)
876 o(0xc9d9); /* fxch %st(1) */
877 if (op == TOK_EQ || op == TOK_NE)
878 o(0xe9da); /* fucompp */
879 else
880 o(0xd9de); /* fcompp */
881 o(0xe0df); /* fnstsw %ax */
882 if (op == TOK_EQ) {
883 o(0x45e480); /* and $0x45, %ah */
884 o(0x40fC80); /* cmp $0x40, %ah */
885 } else if (op == TOK_NE) {
886 o(0x45e480); /* and $0x45, %ah */
887 o(0x40f480); /* xor $0x40, %ah */
888 op = TOK_NE;
889 } else if (op == TOK_GE || op == TOK_LE) {
890 o(0x05c4f6); /* test $0x05, %ah */
891 op = TOK_EQ;
892 } else {
893 o(0x45c4f6); /* test $0x45, %ah */
894 op = TOK_EQ;
896 vtop--;
897 vtop->r = VT_CMP;
898 vtop->c.i = op;
899 } else {
900 /* no memory reference possible for long double operations */
901 if ((vtop->type.t & VT_BTYPE) == VT_LDOUBLE) {
902 load(TREG_ST0, vtop);
903 swapped = !swapped;
906 switch(op) {
907 default:
908 case '+':
909 a = 0;
910 break;
911 case '-':
912 a = 4;
913 if (swapped)
914 a++;
915 break;
916 case '*':
917 a = 1;
918 break;
919 case '/':
920 a = 6;
921 if (swapped)
922 a++;
923 break;
925 ft = vtop->type.t;
926 fc = vtop->c.ul;
927 if ((ft & VT_BTYPE) == VT_LDOUBLE) {
928 o(0xde); /* fxxxp %st, %st(1) */
929 o(0xc1 + (a << 3));
930 } else {
931 /* if saved lvalue, then we must reload it */
932 r = vtop->r;
933 if ((r & VT_VALMASK) == VT_LLOCAL) {
934 SValue v1;
935 r = get_reg(RC_INT);
936 v1.type.t = VT_INT;
937 v1.r = VT_LOCAL | VT_LVAL;
938 v1.c.ul = fc;
939 load(r, &v1);
940 fc = 0;
943 if ((ft & VT_BTYPE) == VT_DOUBLE)
944 o(0xdc);
945 else
946 o(0xd8);
947 gen_modrm(a, r, vtop->sym, fc);
949 vtop--;
953 /* convert integers to fp 't' type. Must handle 'int', 'unsigned int'
954 and 'long long' cases. */
955 ST_FUNC void gen_cvt_itof(int t)
957 save_reg(TREG_ST0);
958 gv(RC_INT);
959 if ((vtop->type.t & VT_BTYPE) == VT_LLONG) {
960 /* signed long long to float/double/long double (unsigned case
961 is handled generically) */
962 o(0x50 + vtop->r2); /* push r2 */
963 o(0x50 + (vtop->r & VT_VALMASK)); /* push r */
964 o(0x242cdf); /* fildll (%esp) */
965 o(0x08c483); /* add $8, %esp */
966 } else if ((vtop->type.t & (VT_BTYPE | VT_UNSIGNED)) ==
967 (VT_INT | VT_UNSIGNED)) {
968 /* unsigned int to float/double/long double */
969 o(0x6a); /* push $0 */
970 g(0x00);
971 o(0x50 + (vtop->r & VT_VALMASK)); /* push r */
972 o(0x242cdf); /* fildll (%esp) */
973 o(0x08c483); /* add $8, %esp */
974 } else {
975 /* int to float/double/long double */
976 o(0x50 + (vtop->r & VT_VALMASK)); /* push r */
977 o(0x2404db); /* fildl (%esp) */
978 o(0x04c483); /* add $4, %esp */
980 vtop->r = TREG_ST0;
983 /* convert fp to int 't' type */
984 ST_FUNC void gen_cvt_ftoi(int t)
986 #ifndef COMMIT_4ad186c5ef61_IS_FIXED
987 /* a good version but it takes a more time to execute */
988 gv(RC_FLOAT);
989 save_reg(TREG_EAX);
990 save_reg(TREG_EDX);
991 gen_static_call(TOK___tcc_cvt_ftol);
992 vtop->r = TREG_EAX; /* mark reg as used */
993 if (t == VT_LLONG)
994 vtop->r2 = TREG_EDX;
995 #else
996 /* a new version with a bug: t2a = 44100312 */
997 /*
998 #include<stdio.h>
999 int main() {
1000 int t1 = 176401255;
1001 float f = 0.25f;
1002 int t2a = (int)(t1 * f); // must be 44100313
1003 int t2b = (int)(t1 * (float)0.25f);
1004 printf("t2a=%d t2b=%d \n",t2a,t2b);
1005 return 0;
1007 */
1008 int bt = vtop->type.t & VT_BTYPE;
1009 if (bt == VT_FLOAT)
1010 vpush_global_sym(&func_old_type, TOK___fixsfdi);
1011 else if (bt == VT_LDOUBLE)
1012 vpush_global_sym(&func_old_type, TOK___fixxfdi);
1013 else
1014 vpush_global_sym(&func_old_type, TOK___fixdfdi);
1015 vswap();
1016 gfunc_call(1);
1017 vpushi(0);
1018 vtop->r = REG_IRET;
1019 vtop->r2 = REG_LRET;
1020 #endif
1023 /* convert from one floating point type to another */
1024 ST_FUNC void gen_cvt_ftof(int t)
1026 /* all we have to do on i386 is to put the float in a register */
1027 gv(RC_FLOAT);
1030 /* computed goto support */
1031 ST_FUNC void ggoto(void)
1033 gcall_or_jmp(1);
1034 vtop--;
1037 /* bound check support functions */
1038 #ifdef CONFIG_TCC_BCHECK
1040 /* generate a bounded pointer addition */
1041 ST_FUNC void gen_bounded_ptr_add(void)
1043 /* prepare fast i386 function call (args in eax and edx) */
1044 gv2(RC_EAX, RC_EDX);
1045 /* save all temporary registers */
1046 vtop -= 2;
1047 save_regs(0);
1048 /* do a fast function call */
1049 gen_static_call(TOK___bound_ptr_add);
1050 /* returned pointer is in eax */
1051 vtop++;
1052 vtop->r = TREG_EAX | VT_BOUNDED;
1053 /* address of bounding function call point */
1054 vtop->c.ul = (cur_text_section->reloc->data_offset - sizeof(Elf32_Rel));
1057 /* patch pointer addition in vtop so that pointer dereferencing is
1058 also tested */
1059 ST_FUNC void gen_bounded_ptr_deref(void)
1061 addr_t func;
1062 addr_t size, align;
1063 Elf32_Rel *rel;
1064 Sym *sym;
1066 size = 0;
1067 /* XXX: put that code in generic part of tcc */
1068 if (!is_float(vtop->type.t)) {
1069 if (vtop->r & VT_LVAL_BYTE)
1070 size = 1;
1071 else if (vtop->r & VT_LVAL_SHORT)
1072 size = 2;
1074 if (!size)
1075 size = type_size(&vtop->type, &align);
1076 switch(size) {
1077 case 1: func = TOK___bound_ptr_indir1; break;
1078 case 2: func = TOK___bound_ptr_indir2; break;
1079 case 4: func = TOK___bound_ptr_indir4; break;
1080 case 8: func = TOK___bound_ptr_indir8; break;
1081 case 12: func = TOK___bound_ptr_indir12; break;
1082 case 16: func = TOK___bound_ptr_indir16; break;
1083 default:
1084 tcc_error("unhandled size when dereferencing bounded pointer");
1085 func = 0;
1086 break;
1089 /* patch relocation */
1090 /* XXX: find a better solution ? */
1091 rel = (Elf32_Rel *)(cur_text_section->reloc->data + vtop->c.ul);
1092 sym = external_global_sym(func, &func_old_type, 0);
1093 if (!sym->c)
1094 put_extern_sym(sym, NULL, 0, 0);
1095 rel->r_info = ELF32_R_INFO(sym->c, ELF32_R_TYPE(rel->r_info));
1097 #endif
1099 /* Save the stack pointer onto the stack */
1100 ST_FUNC void gen_vla_sp_save(int addr) {
1101 /* mov %esp,addr(%ebp)*/
1102 o(0x89);
1103 gen_modrm(TREG_ESP, VT_LOCAL, NULL, addr);
1106 /* Restore the SP from a location on the stack */
1107 ST_FUNC void gen_vla_sp_restore(int addr) {
1108 o(0x8b);
1109 gen_modrm(TREG_ESP, VT_LOCAL, NULL, addr);
1112 /* Subtract from the stack pointer, and push the resulting value onto the stack */
1113 ST_FUNC void gen_vla_alloc(CType *type, int align) {
1114 #ifdef TCC_TARGET_PE
1115 /* alloca does more than just adjust %rsp on Windows */
1116 vpush_global_sym(&func_old_type, TOK_alloca);
1117 vswap(); /* Move alloca ref past allocation size */
1118 gfunc_call(1);
1119 #else
1120 int r;
1121 r = gv(RC_INT); /* allocation size */
1122 /* sub r,%rsp */
1123 o(0x2b);
1124 o(0xe0 | r);
1125 /* We align to 16 bytes rather than align */
1126 /* and ~15, %esp */
1127 o(0xf0e483);
1128 vpop();
1129 #endif
1132 /* end of X86 code generator */
1133 /*************************************************************/
1134 #endif
1135 /*************************************************************/