2 * X86 code generator for TCC
4 * Copyright (c) 2001, 2002 Fabrice Bellard
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program 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
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 /* number of available registers */
24 /* a register can belong to several classes. The classes must be
25 sorted from more general to more precise (see gv2() code which does
26 assumptions on it). */
27 #define RC_INT 0x0001 /* generic integer register */
28 #define RC_FLOAT 0x0002 /* generic float register */
33 #define RC_IRET RC_EAX /* function return: integer register */
34 #define RC_LRET RC_EDX /* function return: second integer register */
35 #define RC_FRET RC_ST0 /* function return: float register */
37 /* pretty names for the registers */
45 int reg_classes
[NB_REGS
] = {
46 /* eax */ RC_INT
| RC_EAX
,
47 /* ecx */ RC_INT
| RC_ECX
,
48 /* edx */ RC_INT
| RC_EDX
,
49 /* st0 */ RC_FLOAT
| RC_ST0
,
52 /* return registers for function */
53 #define REG_IRET TREG_EAX /* single word int return register */
54 #define REG_LRET TREG_EDX /* second word return register (for long long) */
55 #define REG_FRET TREG_ST0 /* float return register */
57 /* defined if function parameters must be evaluated in reverse order */
58 #define INVERT_FUNC_PARAMS
60 /* defined if structures are passed as pointers. Otherwise structures
61 are directly pushed on stack. */
62 //#define FUNC_STRUCT_PARAM_AS_PTR
64 /* pointer size, in bytes */
67 /* long double size and alignment, in bytes */
68 #define LDOUBLE_SIZE 12
69 #define LDOUBLE_ALIGN 4
70 /* maximum alignment (for aligned attribute support) */
73 /* relocation type for 32 bit data relocation */
74 #define R_DATA_32 R_386_32
76 /* function call context */
77 typedef struct GFuncContext
{
79 int func_call
; /* func call type (FUNC_STDCALL or FUNC_CDECL) */
82 /******************************************************/
84 static unsigned long func_sub_sp_offset
;
85 static unsigned long func_bound_offset
;
86 static int func_ret_sub
;
88 /* XXX: make it faster ? */
93 if (ind1
> cur_text_section
->data_allocated
)
94 section_realloc(cur_text_section
, ind1
);
95 cur_text_section
->data
[ind
] = c
;
115 /* output a symbol and patch all calls to it */
116 void gsym_addr(int t
, int a
)
120 ptr
= (int *)(cur_text_section
->data
+ t
);
121 n
= *ptr
; /* next value */
132 /* psym is used to put an instruction with a data field which is a
133 reference to a symbol. It is in fact the same as oad ! */
136 /* instruction + 4 bytes data. Return the address of the data */
137 static int oad(int c
, int s
)
143 if (ind1
> cur_text_section
->data_allocated
)
144 section_realloc(cur_text_section
, ind1
);
145 *(int *)(cur_text_section
->data
+ ind
) = s
;
151 /* output constant with relocation if 'r & VT_SYM' is true */
152 static void gen_addr32(int r
, Sym
*sym
, int c
)
155 greloc(cur_text_section
, sym
, ind
, R_386_32
);
159 /* generate a modrm reference. 'op_reg' contains the addtionnal 3
161 static void gen_modrm(int op_reg
, int r
, Sym
*sym
, int c
)
163 op_reg
= op_reg
<< 3;
164 if ((r
& VT_VALMASK
) == VT_CONST
) {
165 /* constant memory reference */
167 gen_addr32(r
, sym
, c
);
168 } else if ((r
& VT_VALMASK
) == VT_LOCAL
) {
169 /* currently, we use only ebp as base */
171 /* short reference */
175 oad(0x85 | op_reg
, c
);
178 g(0x00 | op_reg
| (r
& VT_VALMASK
));
183 /* load 'r' from value 'sv' */
184 void load(int r
, SValue
*sv
)
186 int v
, t
, ft
, fc
, fr
;
195 if (v
== VT_LLOCAL
) {
197 v1
.r
= VT_LOCAL
| VT_LVAL
;
202 if ((ft
& VT_BTYPE
) == VT_FLOAT
) {
205 } else if ((ft
& VT_BTYPE
) == VT_DOUBLE
) {
208 } else if ((ft
& VT_BTYPE
) == VT_LDOUBLE
) {
211 } else if ((ft
& VT_TYPE
) == VT_BYTE
) {
212 o(0xbe0f); /* movsbl */
213 } else if ((ft
& VT_TYPE
) == (VT_BYTE
| VT_UNSIGNED
)) {
214 o(0xb60f); /* movzbl */
215 } else if ((ft
& VT_TYPE
) == VT_SHORT
) {
216 o(0xbf0f); /* movswl */
217 } else if ((ft
& VT_TYPE
) == (VT_SHORT
| VT_UNSIGNED
)) {
218 o(0xb70f); /* movzwl */
222 gen_modrm(r
, fr
, sv
->sym
, fc
);
225 o(0xb8 + r
); /* mov $xx, r */
226 gen_addr32(fr
, sv
->sym
, fc
);
227 } else if (v
== VT_LOCAL
) {
228 o(0x8d); /* lea xxx(%ebp), r */
229 gen_modrm(r
, VT_LOCAL
, sv
->sym
, fc
);
230 } else if (v
== VT_CMP
) {
231 oad(0xb8 + r
, 0); /* mov $0, r */
232 o(0x0f); /* setxx %br */
235 } else if (v
== VT_JMP
|| v
== VT_JMPI
) {
237 oad(0xb8 + r
, t
); /* mov $1, r */
238 o(0x05eb); /* jmp after */
240 oad(0xb8 + r
, t
^ 1); /* mov $0, r */
243 o(0xc0 + r
+ v
* 8); /* mov v, r */
248 /* store register 'r' in lvalue 'v' */
249 void store(int r
, SValue
*v
)
255 fr
= v
->r
& VT_VALMASK
;
257 /* XXX: incorrect if float reg to reg */
258 if (bt
== VT_FLOAT
) {
261 } else if (bt
== VT_DOUBLE
) {
264 } else if (bt
== VT_LDOUBLE
) {
265 o(0xc0d9); /* fld %st(0) */
276 if (fr
== VT_CONST
||
279 gen_modrm(r
, v
->r
, v
->sym
, fc
);
280 } else if (fr
!= r
) {
281 o(0xc0 + fr
+ r
* 8); /* mov r, fr */
285 /* start function call and return function call context */
286 void gfunc_start(GFuncContext
*c
, int func_call
)
289 c
->func_call
= func_call
;
292 /* push function parameter which is in (vtop->t, vtop->c). Stack entry
294 void gfunc_param(GFuncContext
*c
)
298 if ((vtop
->type
.t
& VT_BTYPE
) == VT_STRUCT
) {
299 size
= type_size(&vtop
->type
, &align
);
300 /* align to stack align size */
301 size
= (size
+ 3) & ~3;
302 /* allocate the necessary size on stack */
303 oad(0xec81, size
); /* sub $xxx, %esp */
304 /* generate structure store */
306 o(0x89); /* mov %esp, r */
308 vset(&vtop
->type
, r
| VT_LVAL
, 0);
311 c
->args_size
+= size
;
312 } else if (is_float(vtop
->type
.t
)) {
313 gv(RC_FLOAT
); /* only one float register */
314 if ((vtop
->type
.t
& VT_BTYPE
) == VT_FLOAT
)
316 else if ((vtop
->type
.t
& VT_BTYPE
) == VT_DOUBLE
)
320 oad(0xec81, size
); /* sub $xxx, %esp */
324 o(0x5cd9 + size
- 4); /* fstp[s|l] 0(%esp) */
327 c
->args_size
+= size
;
329 /* simple type (currently always same size) */
330 /* XXX: implicit cast ? */
332 if ((vtop
->type
.t
& VT_BTYPE
) == VT_LLONG
) {
334 o(0x50 + vtop
->r2
); /* push r */
338 o(0x50 + r
); /* push r */
339 c
->args_size
+= size
;
344 static void gadd_sp(int val
)
346 if (val
== (char)val
) {
350 oad(0xc481, val
); /* add $xxx, %esp */
354 /* 'is_jmp' is '1' if it is a jump */
355 static void gcall_or_jmp(int is_jmp
)
358 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
)) == VT_CONST
) {
360 if (vtop
->r
& VT_SYM
) {
361 /* relocation case */
362 greloc(cur_text_section
, vtop
->sym
,
363 ind
+ 1, R_386_PC32
);
365 /* put an empty PC32 relocation */
366 put_elf_reloc(symtab_section
, cur_text_section
,
367 ind
+ 1, R_386_PC32
, 0);
369 oad(0xe8 + is_jmp
, vtop
->c
.ul
- 4); /* call/jmp im */
371 /* otherwise, indirect call */
373 o(0xff); /* call/jmp *r */
374 o(0xd0 + r
+ (is_jmp
<< 4));
378 /* generate function call with address in (vtop->t, vtop->c) and free function
379 context. Stack entry is popped */
380 void gfunc_call(GFuncContext
*c
)
383 if (c
->args_size
&& c
->func_call
== FUNC_CDECL
)
384 gadd_sp(c
->args_size
);
388 /* generate function prolog of type 't' */
389 void gfunc_prolog(CType
*func_type
)
391 int addr
, align
, size
, func_call
;
395 sym
= func_type
->ref
;
398 /* if the function returns a structure, then add an
399 implicit pointer parameter */
401 if ((func_vt
.t
& VT_BTYPE
) == VT_STRUCT
) {
405 /* define parameters */
406 while ((sym
= sym
->next
) != NULL
) {
408 sym_push(sym
->v
& ~SYM_FIELD
, type
,
409 VT_LOCAL
| VT_LVAL
, addr
);
410 size
= type_size(type
, &align
);
411 size
= (size
+ 3) & ~3;
412 #ifdef FUNC_STRUCT_PARAM_AS_PTR
413 /* structs are passed as pointer */
414 if ((type
->t
& VT_BTYPE
) == VT_STRUCT
) {
421 /* pascal type call ? */
422 if (func_call
== FUNC_STDCALL
)
423 func_ret_sub
= addr
- 8;
424 o(0xe58955); /* push %ebp, mov %esp, %ebp */
425 func_sub_sp_offset
= oad(0xec81, 0); /* sub $xxx, %esp */
426 /* leave some room for bound checking code */
427 if (do_bounds_check
) {
428 oad(0xb8, 0); /* lbound section pointer */
429 oad(0xb8, 0); /* call to function */
430 func_bound_offset
= lbounds_section
->data_offset
;
434 /* generate function epilog */
435 void gfunc_epilog(void)
437 #ifdef CONFIG_TCC_BCHECK
438 if (do_bounds_check
&& func_bound_offset
!= lbounds_section
->data_offset
) {
442 /* add end of table info */
443 bounds_ptr
= section_ptr_add(lbounds_section
, sizeof(int));
445 /* generate bound local allocation */
447 ind
= func_sub_sp_offset
+ 4;
448 sym_data
= get_sym_ref(&char_pointer_type
, lbounds_section
,
449 func_bound_offset
, lbounds_section
->data_offset
);
450 greloc(cur_text_section
, sym_data
,
452 oad(0xb8, 0); /* mov %eax, xxx */
453 sym
= external_global_sym(TOK___bound_local_new
, &func_old_type
, 0);
454 greloc(cur_text_section
, sym
,
455 ind
+ 1, R_386_PC32
);
458 /* generate bound check local freeing */
459 o(0x5250); /* save returned value, if any */
460 greloc(cur_text_section
, sym_data
,
462 oad(0xb8, 0); /* mov %eax, xxx */
463 sym
= external_global_sym(TOK___bound_local_delete
, &func_old_type
, 0);
464 greloc(cur_text_section
, sym
,
465 ind
+ 1, R_386_PC32
);
467 o(0x585a); /* restore returned value, if any */
471 if (func_ret_sub
== 0) {
476 g(func_ret_sub
>> 8);
478 /* align local size to word & save local variables */
479 *(int *)(cur_text_section
->data
+ func_sub_sp_offset
) = (-loc
+ 3) & -4;
482 /* generate a jump to a label */
485 return psym(0xe9, t
);
488 /* generate a jump to a fixed address */
489 void gjmp_addr(int a
)
497 oad(0xe9, a
- ind
- 5);
501 /* generate a test. set 'inv' to invert test. Stack entry is popped */
502 int gtst(int inv
, int t
)
506 v
= vtop
->r
& VT_VALMASK
;
508 /* fast case : can jump directly since flags are set */
510 t
= psym((vtop
->c
.i
- 16) ^ inv
, t
);
511 } else if (v
== VT_JMP
|| v
== VT_JMPI
) {
512 /* && or || optimization */
513 if ((v
& 1) == inv
) {
514 /* insert vtop->c jump list in t */
517 p
= (int *)(cur_text_section
->data
+ *p
);
525 if (is_float(vtop
->type
.t
)) {
529 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
) {
530 /* constant jmp optimization */
531 if ((vtop
->c
.i
!= 0) != inv
)
538 t
= psym(0x85 ^ inv
, t
);
545 /* generate an integer binary operation */
552 case TOK_ADDC1
: /* add with carry generation */
555 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
) {
562 /* XXX: generate inc and dec for smaller code ? */
564 o(0xc0 | (opc
<< 3) | r
);
568 oad(0xc0 | (opc
<< 3) | r
, c
);
574 o((opc
<< 3) | 0x01);
575 o(0xc0 + r
+ fr
* 8);
578 if (op
>= TOK_ULT
&& op
<= TOK_GT
) {
584 case TOK_SUBC1
: /* sub with carry generation */
587 case TOK_ADDC2
: /* add with carry use */
590 case TOK_SUBC2
: /* sub with carry use */
607 o(0xaf0f); /* imul fr, r */
608 o(0xc0 + fr
+ r
* 8);
619 opc
= 0xc0 | (opc
<< 3);
620 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
) {
625 c
= vtop
->c
.i
& 0x1f;
626 o(0xc1); /* shl/shr/sar $xxx, r */
630 /* we generate the shift in ecx */
633 o(0xd3); /* shl/shr/sar %cl, r */
644 /* first operand must be in eax */
645 /* XXX: need better constraint for second operand */
651 if (op
== TOK_UMULL
) {
652 o(0xf7); /* mul fr */
657 if (op
== TOK_UDIV
|| op
== TOK_UMOD
) {
658 o(0xf7d231); /* xor %edx, %edx, div fr, %eax */
661 o(0xf799); /* cltd, idiv fr, %eax */
664 if (op
== '%' || op
== TOK_UMOD
)
677 /* generate a floating point operation 'v = t1 op t2' instruction. The
678 two operands are guaranted to have the same floating point type */
679 /* XXX: need to use ST1 too */
682 int a
, ft
, fc
, swapped
, r
;
684 /* convert constants to memory references */
685 if ((vtop
[-1].r
& (VT_VALMASK
| VT_LVAL
)) == VT_CONST
) {
690 if ((vtop
[0].r
& (VT_VALMASK
| VT_LVAL
)) == VT_CONST
)
693 /* must put at least one value in the floating point register */
694 if ((vtop
[-1].r
& VT_LVAL
) &&
695 (vtop
[0].r
& VT_LVAL
)) {
701 /* swap the stack if needed so that t1 is the register and t2 is
702 the memory reference */
703 if (vtop
[-1].r
& VT_LVAL
) {
707 if (op
>= TOK_ULT
&& op
<= TOK_GT
) {
708 /* load on stack second operand */
709 load(TREG_ST0
, vtop
);
710 save_reg(TREG_EAX
); /* eax is used by FP comparison code */
711 if (op
== TOK_GE
|| op
== TOK_GT
)
713 else if (op
== TOK_EQ
|| op
== TOK_NE
)
716 o(0xc9d9); /* fxch %st(1) */
717 o(0xe9da); /* fucompp */
718 o(0xe0df); /* fnstsw %ax */
720 o(0x45e480); /* and $0x45, %ah */
721 o(0x40fC80); /* cmp $0x40, %ah */
722 } else if (op
== TOK_NE
) {
723 o(0x45e480); /* and $0x45, %ah */
724 o(0x40f480); /* xor $0x40, %ah */
726 } else if (op
== TOK_GE
|| op
== TOK_LE
) {
727 o(0x05c4f6); /* test $0x05, %ah */
730 o(0x45c4f6); /* test $0x45, %ah */
737 /* no memory reference possible for long double operations */
738 if ((vtop
->type
.t
& VT_BTYPE
) == VT_LDOUBLE
) {
739 load(TREG_ST0
, vtop
);
764 if ((ft
& VT_BTYPE
) == VT_LDOUBLE
) {
765 o(0xde); /* fxxxp %st, %st(1) */
768 /* if saved lvalue, then we must reload it */
770 if ((r
& VT_VALMASK
) == VT_LLOCAL
) {
774 v1
.r
= VT_LOCAL
| VT_LVAL
;
780 if ((ft
& VT_BTYPE
) == VT_DOUBLE
)
784 gen_modrm(a
, r
, vtop
->sym
, fc
);
790 /* convert integers to fp 't' type. Must handle 'int', 'unsigned int'
791 and 'long long' cases. */
792 void gen_cvt_itof(int t
)
796 if ((vtop
->type
.t
& VT_BTYPE
) == VT_LLONG
) {
797 /* signed long long to float/double/long double (unsigned case
798 is handled generically) */
799 o(0x50 + vtop
->r2
); /* push r2 */
800 o(0x50 + (vtop
->r
& VT_VALMASK
)); /* push r */
801 o(0x242cdf); /* fildll (%esp) */
802 o(0x08c483); /* add $8, %esp */
803 } else if ((vtop
->type
.t
& (VT_BTYPE
| VT_UNSIGNED
)) ==
804 (VT_INT
| VT_UNSIGNED
)) {
805 /* unsigned int to float/double/long double */
806 o(0x6a); /* push $0 */
808 o(0x50 + (vtop
->r
& VT_VALMASK
)); /* push r */
809 o(0x242cdf); /* fildll (%esp) */
810 o(0x08c483); /* add $8, %esp */
812 /* int to float/double/long double */
813 o(0x50 + (vtop
->r
& VT_VALMASK
)); /* push r */
814 o(0x2404db); /* fildl (%esp) */
815 o(0x04c483); /* add $4, %esp */
820 /* convert fp to int 't' type */
821 /* XXX: handle long long case */
822 void gen_cvt_ftoi(int t
)
828 ushort_type
.t
= VT_SHORT
| VT_UNSIGNED
;
836 o(0x2dd9); /* ldcw xxx */
837 sym
= external_global_sym(TOK___tcc_int_fpu_control
,
838 &ushort_type
, VT_LVAL
);
839 greloc(cur_text_section
, sym
,
843 oad(0xec81, size
); /* sub $xxx, %esp */
845 o(0x1cdb); /* fistpl */
847 o(0x3cdf); /* fistpll */
849 o(0x2dd9); /* ldcw xxx */
850 sym
= external_global_sym(TOK___tcc_fpu_control
,
851 &ushort_type
, VT_LVAL
);
852 greloc(cur_text_section
, sym
,
857 o(0x58 + r
); /* pop r */
860 vtop
->r
= r
; /* mark reg as used */
861 r2
= get_reg(RC_INT
);
862 o(0x58 + r2
); /* pop r2 */
865 o(0x04c483); /* add $4, %esp */
871 /* convert from one floating point type to another */
872 void gen_cvt_ftof(int t
)
874 /* all we have to do on i386 is to put the float in a register */
878 /* computed goto support */
885 /* bound check support functions */
886 #ifdef CONFIG_TCC_BCHECK
888 /* generate a bounded pointer addition */
889 void gen_bounded_ptr_add(void)
893 /* prepare fast i386 function call (args in eax and edx) */
895 /* save all temporary registers */
898 /* do a fast function call */
899 sym
= external_global_sym(TOK___bound_ptr_add
, &func_old_type
, 0);
900 greloc(cur_text_section
, sym
,
901 ind
+ 1, R_386_PC32
);
903 /* returned pointer is in eax */
905 vtop
->r
= TREG_EAX
| VT_BOUNDED
;
906 /* address of bounding function call point */
907 vtop
->c
.ul
= (cur_text_section
->reloc
->data_offset
- sizeof(Elf32_Rel
));
910 /* patch pointer addition in vtop so that pointer dereferencing is
912 void gen_bounded_ptr_deref(void)
920 /* XXX: put that code in generic part of tcc */
921 if (!is_float(vtop
->type
.t
)) {
922 if (vtop
->r
& VT_LVAL_BYTE
)
924 else if (vtop
->r
& VT_LVAL_SHORT
)
928 size
= type_size(&vtop
->type
, &align
);
930 case 1: func
= TOK___bound_ptr_indir1
; break;
931 case 2: func
= TOK___bound_ptr_indir2
; break;
932 case 4: func
= TOK___bound_ptr_indir4
; break;
933 case 8: func
= TOK___bound_ptr_indir8
; break;
934 case 12: func
= TOK___bound_ptr_indir12
; break;
935 case 16: func
= TOK___bound_ptr_indir16
; break;
937 error("unhandled size when derefencing bounded pointer");
942 /* patch relocation */
943 /* XXX: find a better solution ? */
944 rel
= (Elf32_Rel
*)(cur_text_section
->reloc
->data
+ vtop
->c
.ul
);
945 sym
= external_global_sym(func
, &func_old_type
, 0);
947 put_extern_sym(sym
, NULL
, 0, 0);
948 rel
->r_info
= ELF32_R_INFO(sym
->c
, ELF32_R_TYPE(rel
->r_info
));
952 /* end of X86 code generator */
953 /*************************************************************/