tinycc/i386-gen.c

1034 lines
28 KiB
C
Raw Normal View History

2001-12-14 01:28:53 +03:00
/*
* X86 code generator for TCC
*
2004-10-28 01:38:03 +04:00
* Copyright (c) 2001-2004 Fabrice Bellard
2001-12-14 01:28:53 +03:00
*
2003-05-24 18:11:17 +04:00
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
2001-12-14 01:28:53 +03:00
*
2003-05-24 18:11:17 +04:00
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
2001-12-14 01:28:53 +03:00
*
2003-05-24 18:11:17 +04:00
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
2001-12-14 01:28:53 +03:00
*/
2001-12-13 00:16:34 +03:00
/* number of available registers */
#define NB_REGS 4
/* a register can belong to several classes. The classes must be
sorted from more general to more precise (see gv2() code which does
assumptions on it). */
#define RC_INT 0x0001 /* generic integer register */
#define RC_FLOAT 0x0002 /* generic float register */
#define RC_EAX 0x0004
#define RC_ST0 0x0008
#define RC_ECX 0x0010
#define RC_EDX 0x0020
#define RC_IRET RC_EAX /* function return: integer register */
#define RC_LRET RC_EDX /* function return: second integer register */
#define RC_FRET RC_ST0 /* function return: float register */
2001-12-13 00:16:34 +03:00
/* pretty names for the registers */
enum {
2002-12-08 17:34:48 +03:00
TREG_EAX = 0,
TREG_ECX,
TREG_EDX,
TREG_ST0,
2001-12-13 00:16:34 +03:00
};
int reg_classes[NB_REGS] = {
/* eax */ RC_INT | RC_EAX,
/* ecx */ RC_INT | RC_ECX,
/* edx */ RC_INT | RC_EDX,
/* st0 */ RC_FLOAT | RC_ST0,
2001-12-13 00:16:34 +03:00
};
/* return registers for function */
2002-12-08 17:34:48 +03:00
#define REG_IRET TREG_EAX /* single word int return register */
#define REG_LRET TREG_EDX /* second word return register (for long long) */
#define REG_FRET TREG_ST0 /* float return register */
2001-12-13 00:16:34 +03:00
/* defined if function parameters must be evaluated in reverse order */
#define INVERT_FUNC_PARAMS
/* defined if structures are passed as pointers. Otherwise structures
are directly pushed on stack. */
//#define FUNC_STRUCT_PARAM_AS_PTR
2001-12-14 01:28:53 +03:00
/* pointer size, in bytes */
#define PTR_SIZE 4
/* long double size and alignment, in bytes */
#define LDOUBLE_SIZE 12
#define LDOUBLE_ALIGN 4
2002-11-24 18:58:50 +03:00
/* maximum alignment (for aligned attribute support) */
#define MAX_ALIGN 8
2001-12-14 01:28:53 +03:00
/******************************************************/
/* ELF defines */
#define EM_TCC_TARGET EM_386
/* relocation type for 32 bit data relocation */
#define R_DATA_32 R_386_32
#define R_JMP_SLOT R_386_JMP_SLOT
#define R_COPY R_386_COPY
#define ELF_START_ADDR 0x08048000
#define ELF_PAGE_SIZE 0x1000
2001-12-13 00:16:34 +03:00
/******************************************************/
static unsigned long func_sub_sp_offset;
static unsigned long func_bound_offset;
2002-01-26 20:23:44 +03:00
static int func_ret_sub;
/* XXX: make it faster ? */
2001-12-13 00:16:34 +03:00
void g(int c)
{
int ind1;
ind1 = ind + 1;
if (ind1 > cur_text_section->data_allocated)
section_realloc(cur_text_section, ind1);
cur_text_section->data[ind] = c;
ind = ind1;
2001-12-13 00:16:34 +03:00
}
2004-10-05 02:06:22 +04:00
void o(unsigned int c)
2001-12-13 00:16:34 +03:00
{
while (c) {
g(c);
2004-10-05 02:06:22 +04:00
c = c >> 8;
2001-12-13 00:16:34 +03:00
}
}
void gen_le32(int c)
{
g(c);
g(c >> 8);
g(c >> 16);
g(c >> 24);
}
/* output a symbol and patch all calls to it */
void gsym_addr(int t, int a)
2001-12-13 00:16:34 +03:00
{
int n, *ptr;
2001-12-13 00:16:34 +03:00
while (t) {
ptr = (int *)(cur_text_section->data + t);
n = *ptr; /* next value */
*ptr = a - t - 4;
2001-12-13 00:16:34 +03:00
t = n;
}
}
void gsym(int t)
2001-12-13 00:16:34 +03:00
{
gsym_addr(t, ind);
}
/* psym is used to put an instruction with a data field which is a
reference to a symbol. It is in fact the same as oad ! */
#define psym oad
/* instruction + 4 bytes data. Return the address of the data */
2002-08-30 03:05:59 +04:00
static int oad(int c, int s)
2001-12-13 00:16:34 +03:00
{
int ind1;
2001-12-13 00:16:34 +03:00
o(c);
ind1 = ind + 4;
if (ind1 > cur_text_section->data_allocated)
section_realloc(cur_text_section, ind1);
*(int *)(cur_text_section->data + ind) = s;
2001-12-13 00:16:34 +03:00
s = ind;
ind = ind1;
2001-12-13 00:16:34 +03:00
return s;
}
/* output constant with relocation if 'r & VT_SYM' is true */
2002-08-30 03:05:59 +04:00
static void gen_addr32(int r, Sym *sym, int c)
2001-12-13 00:16:34 +03:00
{
2002-08-30 03:05:59 +04:00
if (r & VT_SYM)
greloc(cur_text_section, sym, ind, R_386_32);
gen_le32(c);
2001-12-13 00:16:34 +03:00
}
/* generate a modrm reference. 'op_reg' contains the addtionnal 3
opcode bits */
2002-08-30 03:05:59 +04:00
static void gen_modrm(int op_reg, int r, Sym *sym, int c)
{
op_reg = op_reg << 3;
if ((r & VT_VALMASK) == VT_CONST) {
/* constant memory reference */
o(0x05 | op_reg);
2002-08-30 03:05:59 +04:00
gen_addr32(r, sym, c);
} else if ((r & VT_VALMASK) == VT_LOCAL) {
/* currently, we use only ebp as base */
if (c == (char)c) {
/* short reference */
o(0x45 | op_reg);
g(c);
} else {
oad(0x85 | op_reg, c);
}
} else {
g(0x00 | op_reg | (r & VT_VALMASK));
}
}
2001-12-20 04:05:21 +03:00
/* load 'r' from value 'sv' */
void load(int r, SValue *sv)
2001-12-13 00:16:34 +03:00
{
2001-12-20 04:05:21 +03:00
int v, t, ft, fc, fr;
SValue v1;
2001-12-13 00:16:34 +03:00
2001-12-20 04:05:21 +03:00
fr = sv->r;
ft = sv->type.t;
2001-12-20 04:05:21 +03:00
fc = sv->c.ul;
v = fr & VT_VALMASK;
if (fr & VT_LVAL) {
2001-12-13 00:16:34 +03:00
if (v == VT_LLOCAL) {
v1.type.t = VT_INT;
2001-12-20 04:05:21 +03:00
v1.r = VT_LOCAL | VT_LVAL;
v1.c.ul = fc;
load(r, &v1);
fr = r;
2001-12-13 00:16:34 +03:00
}
if ((ft & VT_BTYPE) == VT_FLOAT) {
o(0xd9); /* flds */
r = 0;
} else if ((ft & VT_BTYPE) == VT_DOUBLE) {
o(0xdd); /* fldl */
r = 0;
2001-12-14 01:28:53 +03:00
} else if ((ft & VT_BTYPE) == VT_LDOUBLE) {
o(0xdb); /* fldt */
r = 5;
} else if ((ft & VT_TYPE) == VT_BYTE) {
2001-12-13 00:16:34 +03:00
o(0xbe0f); /* movsbl */
} else if ((ft & VT_TYPE) == (VT_BYTE | VT_UNSIGNED)) {
2001-12-13 00:16:34 +03:00
o(0xb60f); /* movzbl */
} else if ((ft & VT_TYPE) == VT_SHORT) {
2001-12-13 00:16:34 +03:00
o(0xbf0f); /* movswl */
} else if ((ft & VT_TYPE) == (VT_SHORT | VT_UNSIGNED)) {
2001-12-13 00:16:34 +03:00
o(0xb70f); /* movzwl */
} else {
2001-12-13 00:16:34 +03:00
o(0x8b); /* movl */
}
2002-08-30 03:05:59 +04:00
gen_modrm(r, fr, sv->sym, fc);
2001-12-13 00:16:34 +03:00
} else {
if (v == VT_CONST) {
o(0xb8 + r); /* mov $xx, r */
2002-08-30 03:05:59 +04:00
gen_addr32(fr, sv->sym, fc);
2001-12-13 00:16:34 +03:00
} else if (v == VT_LOCAL) {
o(0x8d); /* lea xxx(%ebp), r */
2002-08-30 03:05:59 +04:00
gen_modrm(r, VT_LOCAL, sv->sym, fc);
2001-12-13 00:16:34 +03:00
} else if (v == VT_CMP) {
oad(0xb8 + r, 0); /* mov $0, r */
o(0x0f); /* setxx %br */
o(fc);
o(0xc0 + r);
} else if (v == VT_JMP || v == VT_JMPI) {
t = v & 1;
oad(0xb8 + r, t); /* mov $1, r */
2002-09-09 02:06:11 +04:00
o(0x05eb); /* jmp after */
2001-12-13 00:16:34 +03:00
gsym(fc);
oad(0xb8 + r, t ^ 1); /* mov $0, r */
} else if (v != r) {
o(0x89);
o(0xc0 + r + v * 8); /* mov v, r */
}
}
}
2001-12-20 04:05:21 +03:00
/* store register 'r' in lvalue 'v' */
void store(int r, SValue *v)
2001-12-13 00:16:34 +03:00
{
2001-12-20 04:05:21 +03:00
int fr, bt, ft, fc;
2001-12-13 00:16:34 +03:00
ft = v->type.t;
2001-12-20 04:05:21 +03:00
fc = v->c.ul;
fr = v->r & VT_VALMASK;
2001-12-13 00:16:34 +03:00
bt = ft & VT_BTYPE;
/* XXX: incorrect if float reg to reg */
2001-12-13 00:16:34 +03:00
if (bt == VT_FLOAT) {
2001-12-18 00:56:48 +03:00
o(0xd9); /* fsts */
r = 2;
2001-12-13 00:16:34 +03:00
} else if (bt == VT_DOUBLE) {
o(0xdd); /* fstpl */
2001-12-18 00:56:48 +03:00
r = 2;
2001-12-14 01:28:53 +03:00
} else if (bt == VT_LDOUBLE) {
2001-12-18 00:56:48 +03:00
o(0xc0d9); /* fld %st(0) */
2001-12-14 01:28:53 +03:00
o(0xdb); /* fstpt */
r = 7;
2001-12-13 00:16:34 +03:00
} else {
if (bt == VT_SHORT)
o(0x66);
2005-04-17 17:15:31 +04:00
if (bt == VT_BYTE || bt == VT_BOOL)
2001-12-13 00:16:34 +03:00
o(0x88);
else
o(0x89);
}
if (fr == VT_CONST ||
fr == VT_LOCAL ||
(v->r & VT_LVAL)) {
2002-08-30 03:05:59 +04:00
gen_modrm(r, v->r, v->sym, fc);
2001-12-13 00:16:34 +03:00
} else if (fr != r) {
o(0xc0 + fr + r * 8); /* mov r, fr */
}
}
static void gadd_sp(int val)
{
if (val == (char)val) {
o(0xc483);
g(val);
} else {
oad(0xc481, val); /* add $xxx, %esp */
}
}
2002-11-03 03:43:01 +03:00
/* 'is_jmp' is '1' if it is a jump */
static void gcall_or_jmp(int is_jmp)
2001-12-13 00:16:34 +03:00
{
int r;
2001-12-20 04:05:21 +03:00
if ((vtop->r & (VT_VALMASK | VT_LVAL)) == VT_CONST) {
2001-12-13 00:16:34 +03:00
/* constant case */
if (vtop->r & VT_SYM) {
/* relocation case */
2002-08-30 03:05:59 +04:00
greloc(cur_text_section, vtop->sym,
ind + 1, R_386_PC32);
2001-12-13 00:16:34 +03:00
} else {
/* put an empty PC32 relocation */
put_elf_reloc(symtab_section, cur_text_section,
ind + 1, R_386_PC32, 0);
2001-12-13 00:16:34 +03:00
}
2002-11-03 03:43:01 +03:00
oad(0xe8 + is_jmp, vtop->c.ul - 4); /* call/jmp im */
2001-12-13 00:16:34 +03:00
} else {
/* otherwise, indirect call */
r = gv(RC_INT);
2002-11-03 03:43:01 +03:00
o(0xff); /* call/jmp *r */
o(0xd0 + r + (is_jmp << 4));
2001-12-13 00:16:34 +03:00
}
2002-11-03 03:43:01 +03:00
}
2004-10-18 04:14:40 +04:00
static uint8_t fastcall_regs[3] = { TREG_EAX, TREG_EDX, TREG_ECX };
2005-09-04 02:21:22 +04:00
static uint8_t fastcallw_regs[2] = { TREG_ECX, TREG_EDX };
2004-10-18 04:14:40 +04:00
2003-04-17 01:16:20 +04:00
/* Generate function call. The function address is pushed first, then
all the parameters in call order. This functions pops all the
parameters and the function address. */
void gfunc_call(int nb_args)
2002-11-03 03:43:01 +03:00
{
2004-10-18 04:14:40 +04:00
int size, align, r, args_size, i, func_call;
2003-04-17 01:16:20 +04:00
Sym *func_sym;
args_size = 0;
for(i = 0;i < nb_args; i++) {
if ((vtop->type.t & VT_BTYPE) == VT_STRUCT) {
size = type_size(&vtop->type, &align);
/* align to stack align size */
size = (size + 3) & ~3;
/* allocate the necessary size on stack */
oad(0xec81, size); /* sub $xxx, %esp */
/* generate structure store */
r = get_reg(RC_INT);
o(0x89); /* mov %esp, r */
o(0xe0 + r);
vset(&vtop->type, r | VT_LVAL, 0);
vswap();
vstore();
args_size += size;
} else if (is_float(vtop->type.t)) {
gv(RC_FLOAT); /* only one float register */
if ((vtop->type.t & VT_BTYPE) == VT_FLOAT)
size = 4;
else if ((vtop->type.t & VT_BTYPE) == VT_DOUBLE)
size = 8;
else
size = 12;
oad(0xec81, size); /* sub $xxx, %esp */
if (size == 12)
o(0x7cdb);
else
o(0x5cd9 + size - 4); /* fstp[s|l] 0(%esp) */
g(0x24);
g(0x00);
args_size += size;
} else {
/* simple type (currently always same size) */
/* XXX: implicit cast ? */
r = gv(RC_INT);
if ((vtop->type.t & VT_BTYPE) == VT_LLONG) {
size = 8;
o(0x50 + vtop->r2); /* push r */
} else {
size = 4;
}
o(0x50 + r); /* push r */
args_size += size;
}
vtop--;
}
save_regs(0); /* save used temporary registers */
func_sym = vtop->type.ref;
2004-10-18 04:14:40 +04:00
func_call = func_sym->r;
/* fast call case */
2005-09-04 02:21:22 +04:00
if ((func_call >= FUNC_FASTCALL1 && func_call <= FUNC_FASTCALL3) ||
func_call == FUNC_FASTCALLW) {
2004-10-18 04:14:40 +04:00
int fastcall_nb_regs;
2005-09-04 02:21:22 +04:00
uint8_t *fastcall_regs_ptr;
if (func_call == FUNC_FASTCALLW) {
fastcall_regs_ptr = fastcallw_regs;
fastcall_nb_regs = 2;
} else {
fastcall_regs_ptr = fastcall_regs;
fastcall_nb_regs = func_call - FUNC_FASTCALL1 + 1;
}
2004-10-18 04:14:40 +04:00
for(i = 0;i < fastcall_nb_regs; i++) {
if (args_size <= 0)
break;
2005-09-04 02:21:22 +04:00
o(0x58 + fastcall_regs_ptr[i]); /* pop r */
2004-10-18 04:14:40 +04:00
/* XXX: incorrect for struct/floats */
args_size -= 4;
}
}
2002-11-03 03:43:01 +03:00
gcall_or_jmp(0);
2004-10-18 04:14:40 +04:00
if (args_size && func_sym->r != FUNC_STDCALL)
2003-04-17 01:16:20 +04:00
gadd_sp(args_size);
vtop--;
2001-12-13 00:16:34 +03:00
}
2005-04-11 02:15:08 +04:00
#ifdef TCC_TARGET_PE
#define FUNC_PROLOG_SIZE 10
#else
#define FUNC_PROLOG_SIZE 9
#endif
/* generate function prolog of type 't' */
void gfunc_prolog(CType *func_type)
{
2004-10-18 04:14:40 +04:00
int addr, align, size, func_call, fastcall_nb_regs;
int param_index, param_addr;
2005-09-04 02:21:22 +04:00
uint8_t *fastcall_regs_ptr;
Sym *sym;
CType *type;
sym = func_type->ref;
2002-01-26 20:23:44 +03:00
func_call = sym->r;
addr = 8;
2004-10-18 04:14:40 +04:00
loc = 0;
if (func_call >= FUNC_FASTCALL1 && func_call <= FUNC_FASTCALL3) {
fastcall_nb_regs = func_call - FUNC_FASTCALL1 + 1;
2005-09-04 02:21:22 +04:00
fastcall_regs_ptr = fastcall_regs;
} else if (func_call == FUNC_FASTCALLW) {
fastcall_nb_regs = 2;
fastcall_regs_ptr = fastcallw_regs;
2004-10-18 04:14:40 +04:00
} else {
fastcall_nb_regs = 0;
2005-09-04 02:21:22 +04:00
fastcall_regs_ptr = NULL;
2004-10-18 04:14:40 +04:00
}
param_index = 0;
2005-04-11 02:15:08 +04:00
ind += FUNC_PROLOG_SIZE;
func_sub_sp_offset = ind;
/* if the function returns a structure, then add an
implicit pointer parameter */
func_vt = sym->type;
if ((func_vt.t & VT_BTYPE) == VT_STRUCT) {
2004-10-18 04:14:40 +04:00
/* XXX: fastcall case ? */
func_vc = addr;
addr += 4;
2004-10-18 04:14:40 +04:00
param_index++;
}
/* define parameters */
while ((sym = sym->next) != NULL) {
type = &sym->type;
size = type_size(type, &align);
size = (size + 3) & ~3;
#ifdef FUNC_STRUCT_PARAM_AS_PTR
/* structs are passed as pointer */
if ((type->t & VT_BTYPE) == VT_STRUCT) {
size = 4;
}
#endif
2004-10-18 04:14:40 +04:00
if (param_index < fastcall_nb_regs) {
/* save FASTCALL register */
loc -= 4;
o(0x89); /* movl */
2005-09-04 02:21:22 +04:00
gen_modrm(fastcall_regs_ptr[param_index], VT_LOCAL, NULL, loc);
2004-10-18 04:14:40 +04:00
param_addr = loc;
} else {
param_addr = addr;
addr += size;
}
sym_push(sym->v & ~SYM_FIELD, type,
VT_LOCAL | VT_LVAL, param_addr);
param_index++;
}
2002-01-26 20:23:44 +03:00
func_ret_sub = 0;
/* pascal type call ? */
if (func_call == FUNC_STDCALL)
func_ret_sub = addr - 8;
2004-10-18 04:14:40 +04:00
/* leave some room for bound checking code */
if (do_bounds_check) {
oad(0xb8, 0); /* lbound section pointer */
oad(0xb8, 0); /* call to function */
func_bound_offset = lbounds_section->data_offset;
}
}
/* generate function epilog */
void gfunc_epilog(void)
{
2005-04-11 02:15:08 +04:00
int v, saved_ind;
#ifdef CONFIG_TCC_BCHECK
if (do_bounds_check && func_bound_offset != lbounds_section->data_offset) {
int saved_ind;
int *bounds_ptr;
Sym *sym, *sym_data;
/* add end of table info */
bounds_ptr = section_ptr_add(lbounds_section, sizeof(int));
*bounds_ptr = 0;
/* generate bound local allocation */
saved_ind = ind;
2005-04-11 02:15:08 +04:00
ind = func_sub_sp_offset;
sym_data = get_sym_ref(&char_pointer_type, lbounds_section,
func_bound_offset, lbounds_section->data_offset);
greloc(cur_text_section, sym_data,
ind + 1, R_386_32);
oad(0xb8, 0); /* mov %eax, xxx */
sym = external_global_sym(TOK___bound_local_new, &func_old_type, 0);
greloc(cur_text_section, sym,
ind + 1, R_386_PC32);
oad(0xe8, -4);
ind = saved_ind;
/* generate bound check local freeing */
o(0x5250); /* save returned value, if any */
greloc(cur_text_section, sym_data,
ind + 1, R_386_32);
oad(0xb8, 0); /* mov %eax, xxx */
sym = external_global_sym(TOK___bound_local_delete, &func_old_type, 0);
greloc(cur_text_section, sym,
ind + 1, R_386_PC32);
oad(0xe8, -4);
o(0x585a); /* restore returned value, if any */
}
#endif
2002-01-26 20:23:44 +03:00
o(0xc9); /* leave */
if (func_ret_sub == 0) {
o(0xc3); /* ret */
} else {
o(0xc2); /* ret n */
g(func_ret_sub);
g(func_ret_sub >> 8);
}
/* align local size to word & save local variables */
2005-04-11 02:15:08 +04:00
v = (-loc + 3) & -4;
saved_ind = ind;
ind = func_sub_sp_offset - FUNC_PROLOG_SIZE;
#ifdef TCC_TARGET_PE
if (v >= 4096) {
Sym *sym = external_global_sym(TOK___chkstk, &func_old_type, 0);
oad(0xb8, v); /* mov stacksize, %eax */
oad(0xe8, -4); /* call __chkstk, (does the stackframe too) */
greloc(cur_text_section, sym, ind-4, R_386_PC32);
} else
#endif
{
o(0xe58955); /* push %ebp, mov %esp, %ebp */
o(0xec81); /* sub esp, stacksize */
gen_le32(v);
#if FUNC_PROLOG_SIZE == 10
o(0x90); /* adjust to FUNC_PROLOG_SIZE */
#endif
}
ind = saved_ind;
}
2002-02-10 19:13:14 +03:00
/* generate a jump to a label */
2001-12-13 00:16:34 +03:00
int gjmp(int t)
{
return psym(0xe9, t);
}
2002-02-10 19:13:14 +03:00
/* generate a jump to a fixed address */
void gjmp_addr(int a)
{
2002-09-09 02:06:11 +04:00
int r;
r = a - ind - 2;
if (r == (char)r) {
g(0xeb);
g(r);
} else {
oad(0xe9, a - ind - 5);
}
2002-02-10 19:13:14 +03:00
}
/* generate a test. set 'inv' to invert test. Stack entry is popped */
2001-12-13 00:16:34 +03:00
int gtst(int inv, int t)
{
int v, *p;
2002-11-24 18:58:50 +03:00
2001-12-20 04:05:21 +03:00
v = vtop->r & VT_VALMASK;
2001-12-13 00:16:34 +03:00
if (v == VT_CMP) {
/* fast case : can jump directly since flags are set */
g(0x0f);
2001-12-18 00:56:48 +03:00
t = psym((vtop->c.i - 16) ^ inv, t);
2001-12-13 00:16:34 +03:00
} else if (v == VT_JMP || v == VT_JMPI) {
/* && or || optimization */
if ((v & 1) == inv) {
/* insert vtop->c jump list in t */
2001-12-18 00:56:48 +03:00
p = &vtop->c.i;
2001-12-13 00:16:34 +03:00
while (*p != 0)
p = (int *)(cur_text_section->data + *p);
2001-12-13 00:16:34 +03:00
*p = t;
2001-12-18 00:56:48 +03:00
t = vtop->c.i;
2001-12-13 00:16:34 +03:00
} else {
t = gjmp(t);
2001-12-18 00:56:48 +03:00
gsym(vtop->c.i);
2001-12-13 00:16:34 +03:00
}
} else {
if (is_float(vtop->type.t) ||
(vtop->type.t & VT_BTYPE) == VT_LLONG) {
vpushi(0);
gen_op(TOK_NE);
}
if ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST) {
/* constant jmp optimization */
if ((vtop->c.i != 0) != inv)
t = gjmp(t);
} else {
v = gv(RC_INT);
o(0x85);
o(0xc0 + v * 9);
g(0x0f);
t = psym(0x85 ^ inv, t);
}
2001-12-13 00:16:34 +03:00
}
vtop--;
2001-12-13 00:16:34 +03:00
return t;
}
/* generate an integer binary operation */
void gen_opi(int op)
2001-12-13 00:16:34 +03:00
{
int r, fr, opc, c;
switch(op) {
case '+':
case TOK_ADDC1: /* add with carry generation */
opc = 0;
gen_op8:
if ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST) {
/* constant case */
vswap();
r = gv(RC_INT);
vswap();
c = vtop->c.i;
if (c == (char)c) {
/* XXX: generate inc and dec for smaller code ? */
o(0x83);
o(0xc0 | (opc << 3) | r);
g(c);
} else {
o(0x81);
oad(0xc0 | (opc << 3) | r, c);
}
} else {
gv2(RC_INT, RC_INT);
r = vtop[-1].r;
fr = vtop[0].r;
o((opc << 3) | 0x01);
o(0xc0 + r + fr * 8);
}
vtop--;
if (op >= TOK_ULT && op <= TOK_GT) {
vtop->r = VT_CMP;
vtop->c.i = op;
}
break;
case '-':
case TOK_SUBC1: /* sub with carry generation */
opc = 5;
goto gen_op8;
case TOK_ADDC2: /* add with carry use */
opc = 2;
goto gen_op8;
case TOK_SUBC2: /* sub with carry use */
opc = 3;
goto gen_op8;
case '&':
opc = 4;
goto gen_op8;
case '^':
opc = 6;
goto gen_op8;
case '|':
opc = 1;
goto gen_op8;
case '*':
gv2(RC_INT, RC_INT);
r = vtop[-1].r;
fr = vtop[0].r;
vtop--;
2001-12-13 00:16:34 +03:00
o(0xaf0f); /* imul fr, r */
o(0xc0 + fr + r * 8);
break;
case TOK_SHL:
opc = 4;
goto gen_shift;
case TOK_SHR:
opc = 5;
goto gen_shift;
case TOK_SAR:
opc = 7;
gen_shift:
opc = 0xc0 | (opc << 3);
if ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST) {
/* constant case */
vswap();
r = gv(RC_INT);
vswap();
c = vtop->c.i & 0x1f;
o(0xc1); /* shl/shr/sar $xxx, r */
o(opc | r);
g(c);
} else {
/* we generate the shift in ecx */
gv2(RC_INT, RC_ECX);
r = vtop[-1].r;
o(0xd3); /* shl/shr/sar %cl, r */
o(opc | r);
2001-12-13 00:16:34 +03:00
}
vtop--;
break;
case '/':
case TOK_UDIV:
case TOK_PDIV:
case '%':
case TOK_UMOD:
case TOK_UMULL:
/* first operand must be in eax */
/* XXX: need better constraint for second operand */
gv2(RC_EAX, RC_ECX);
r = vtop[-1].r;
fr = vtop[0].r;
vtop--;
2002-12-08 17:34:48 +03:00
save_reg(TREG_EDX);
if (op == TOK_UMULL) {
o(0xf7); /* mul fr */
o(0xe0 + fr);
2002-12-08 17:34:48 +03:00
vtop->r2 = TREG_EDX;
r = TREG_EAX;
2001-12-13 00:16:34 +03:00
} else {
if (op == TOK_UDIV || op == TOK_UMOD) {
o(0xf7d231); /* xor %edx, %edx, div fr, %eax */
o(0xf0 + fr);
} else {
o(0xf799); /* cltd, idiv fr, %eax */
o(0xf8 + fr);
}
if (op == '%' || op == TOK_UMOD)
2002-12-08 17:34:48 +03:00
r = TREG_EDX;
else
2002-12-08 17:34:48 +03:00
r = TREG_EAX;
2001-12-13 00:16:34 +03:00
}
2001-12-20 04:05:21 +03:00
vtop->r = r;
break;
default:
opc = 7;
goto gen_op8;
2001-12-13 00:16:34 +03:00
}
}
/* generate a floating point operation 'v = t1 op t2' instruction. The
two operands are guaranted to have the same floating point type */
/* XXX: need to use ST1 too */
2001-12-13 00:16:34 +03:00
void gen_opf(int op)
{
2002-01-26 20:23:44 +03:00
int a, ft, fc, swapped, r;
2001-12-13 00:16:34 +03:00
2001-12-18 00:56:48 +03:00
/* convert constants to memory references */
if ((vtop[-1].r & (VT_VALMASK | VT_LVAL)) == VT_CONST) {
2001-12-18 00:56:48 +03:00
vswap();
gv(RC_FLOAT);
2001-12-18 00:56:48 +03:00
vswap();
}
if ((vtop[0].r & (VT_VALMASK | VT_LVAL)) == VT_CONST)
gv(RC_FLOAT);
2001-12-18 00:56:48 +03:00
2001-12-13 00:16:34 +03:00
/* must put at least one value in the floating point register */
2001-12-20 04:05:21 +03:00
if ((vtop[-1].r & VT_LVAL) &&
(vtop[0].r & VT_LVAL)) {
2001-12-13 00:16:34 +03:00
vswap();
gv(RC_FLOAT);
2001-12-13 00:16:34 +03:00
vswap();
}
swapped = 0;
/* swap the stack if needed so that t1 is the register and t2 is
the memory reference */
if (vtop[-1].r & VT_LVAL) {
vswap();
swapped = 1;
}
if (op >= TOK_ULT && op <= TOK_GT) {
2001-12-13 00:16:34 +03:00
/* load on stack second operand */
2002-12-08 17:34:48 +03:00
load(TREG_ST0, vtop);
save_reg(TREG_EAX); /* eax is used by FP comparison code */
2001-12-13 00:16:34 +03:00
if (op == TOK_GE || op == TOK_GT)
swapped = !swapped;
else if (op == TOK_EQ || op == TOK_NE)
swapped = 0;
if (swapped)
2001-12-13 00:16:34 +03:00
o(0xc9d9); /* fxch %st(1) */
o(0xe9da); /* fucompp */
o(0xe0df); /* fnstsw %ax */
if (op == TOK_EQ) {
o(0x45e480); /* and $0x45, %ah */
o(0x40fC80); /* cmp $0x40, %ah */
} else if (op == TOK_NE) {
o(0x45e480); /* and $0x45, %ah */
o(0x40f480); /* xor $0x40, %ah */
op = TOK_NE;
} else if (op == TOK_GE || op == TOK_LE) {
o(0x05c4f6); /* test $0x05, %ah */
op = TOK_EQ;
} else {
o(0x45c4f6); /* test $0x45, %ah */
op = TOK_EQ;
}
vtop--;
2001-12-20 04:05:21 +03:00
vtop->r = VT_CMP;
2001-12-18 00:56:48 +03:00
vtop->c.i = op;
2001-12-13 00:16:34 +03:00
} else {
/* no memory reference possible for long double operations */
if ((vtop->type.t & VT_BTYPE) == VT_LDOUBLE) {
2002-12-08 17:34:48 +03:00
load(TREG_ST0, vtop);
swapped = !swapped;
}
2001-12-13 00:16:34 +03:00
switch(op) {
default:
case '+':
a = 0;
break;
case '-':
a = 4;
2001-12-13 00:16:34 +03:00
if (swapped)
a++;
2001-12-13 00:16:34 +03:00
break;
case '*':
a = 1;
2001-12-13 00:16:34 +03:00
break;
case '/':
a = 6;
2001-12-13 00:16:34 +03:00
if (swapped)
a++;
2001-12-13 00:16:34 +03:00
break;
}
ft = vtop->type.t;
2001-12-18 00:56:48 +03:00
fc = vtop->c.ul;
if ((ft & VT_BTYPE) == VT_LDOUBLE) {
o(0xde); /* fxxxp %st, %st(1) */
o(0xc1 + (a << 3));
2001-12-13 00:16:34 +03:00
} else {
2002-01-26 20:23:44 +03:00
/* if saved lvalue, then we must reload it */
r = vtop->r;
if ((r & VT_VALMASK) == VT_LLOCAL) {
SValue v1;
r = get_reg(RC_INT);
v1.type.t = VT_INT;
2002-01-26 20:23:44 +03:00
v1.r = VT_LOCAL | VT_LVAL;
v1.c.ul = fc;
load(r, &v1);
fc = 0;
}
if ((ft & VT_BTYPE) == VT_DOUBLE)
o(0xdc);
else
o(0xd8);
2002-08-30 03:05:59 +04:00
gen_modrm(a, r, vtop->sym, fc);
2001-12-13 00:16:34 +03:00
}
vtop--;
2001-12-13 00:16:34 +03:00
}
}
/* convert integers to fp 't' type. Must handle 'int', 'unsigned int'
and 'long long' cases. */
2001-12-18 00:56:48 +03:00
void gen_cvt_itof(int t)
2001-12-13 00:16:34 +03:00
{
2002-12-08 17:34:48 +03:00
save_reg(TREG_ST0);
gv(RC_INT);
if ((vtop->type.t & VT_BTYPE) == VT_LLONG) {
/* signed long long to float/double/long double (unsigned case
is handled generically) */
o(0x50 + vtop->r2); /* push r2 */
o(0x50 + (vtop->r & VT_VALMASK)); /* push r */
o(0x242cdf); /* fildll (%esp) */
o(0x08c483); /* add $8, %esp */
} else if ((vtop->type.t & (VT_BTYPE | VT_UNSIGNED)) ==
(VT_INT | VT_UNSIGNED)) {
2001-12-14 01:28:53 +03:00
/* unsigned int to float/double/long double */
2001-12-13 00:16:34 +03:00
o(0x6a); /* push $0 */
g(0x00);
2001-12-20 04:05:21 +03:00
o(0x50 + (vtop->r & VT_VALMASK)); /* push r */
2001-12-13 00:16:34 +03:00
o(0x242cdf); /* fildll (%esp) */
o(0x08c483); /* add $8, %esp */
} else {
2001-12-14 01:28:53 +03:00
/* int to float/double/long double */
2001-12-20 04:05:21 +03:00
o(0x50 + (vtop->r & VT_VALMASK)); /* push r */
2001-12-13 00:16:34 +03:00
o(0x2404db); /* fildl (%esp) */
o(0x04c483); /* add $4, %esp */
}
2002-12-08 17:34:48 +03:00
vtop->r = TREG_ST0;
2001-12-18 00:56:48 +03:00
}
/* convert fp to int 't' type */
/* XXX: handle long long case */
void gen_cvt_ftoi(int t)
{
int r, r2, size;
Sym *sym;
CType ushort_type;
ushort_type.t = VT_SHORT | VT_UNSIGNED;
2001-12-18 00:56:48 +03:00
gv(RC_FLOAT);
if (t != VT_INT)
2001-12-18 00:56:48 +03:00
size = 8;
else
size = 4;
o(0x2dd9); /* ldcw xxx */
2002-08-30 03:05:59 +04:00
sym = external_global_sym(TOK___tcc_int_fpu_control,
&ushort_type, VT_LVAL);
greloc(cur_text_section, sym,
ind, R_386_32);
gen_le32(0);
2001-12-18 00:56:48 +03:00
oad(0xec81, size); /* sub $xxx, %esp */
if (size == 4)
o(0x1cdb); /* fistpl */
else
o(0x3cdf); /* fistpll */
2001-12-18 00:56:48 +03:00
o(0x24);
o(0x2dd9); /* ldcw xxx */
2002-08-30 03:05:59 +04:00
sym = external_global_sym(TOK___tcc_fpu_control,
&ushort_type, VT_LVAL);
greloc(cur_text_section, sym,
ind, R_386_32);
gen_le32(0);
r = get_reg(RC_INT);
2001-12-18 00:56:48 +03:00
o(0x58 + r); /* pop r */
if (size == 8) {
if (t == VT_LLONG) {
vtop->r = r; /* mark reg as used */
r2 = get_reg(RC_INT);
o(0x58 + r2); /* pop r2 */
vtop->r2 = r2;
} else {
o(0x04c483); /* add $4, %esp */
}
}
2001-12-20 04:05:21 +03:00
vtop->r = r;
2001-12-13 00:16:34 +03:00
}
2001-12-18 00:56:48 +03:00
/* convert from one floating point type to another */
void gen_cvt_ftof(int t)
{
/* all we have to do on i386 is to put the float in a register */
gv(RC_FLOAT);
2001-12-18 00:56:48 +03:00
}
2002-11-03 03:43:01 +03:00
/* computed goto support */
void ggoto(void)
{
gcall_or_jmp(1);
vtop--;
}
/* bound check support functions */
#ifdef CONFIG_TCC_BCHECK
/* generate a bounded pointer addition */
void gen_bounded_ptr_add(void)
{
Sym *sym;
/* prepare fast i386 function call (args in eax and edx) */
gv2(RC_EAX, RC_EDX);
/* save all temporary registers */
vtop -= 2;
save_regs(0);
/* do a fast function call */
sym = external_global_sym(TOK___bound_ptr_add, &func_old_type, 0);
greloc(cur_text_section, sym,
ind + 1, R_386_PC32);
oad(0xe8, -4);
/* returned pointer is in eax */
vtop++;
2002-12-08 17:34:48 +03:00
vtop->r = TREG_EAX | VT_BOUNDED;
/* address of bounding function call point */
vtop->c.ul = (cur_text_section->reloc->data_offset - sizeof(Elf32_Rel));
}
/* patch pointer addition in vtop so that pointer dereferencing is
also tested */
void gen_bounded_ptr_deref(void)
{
int func;
int size, align;
Elf32_Rel *rel;
Sym *sym;
size = 0;
/* XXX: put that code in generic part of tcc */
if (!is_float(vtop->type.t)) {
if (vtop->r & VT_LVAL_BYTE)
size = 1;
else if (vtop->r & VT_LVAL_SHORT)
size = 2;
}
if (!size)
size = type_size(&vtop->type, &align);
switch(size) {
case 1: func = TOK___bound_ptr_indir1; break;
case 2: func = TOK___bound_ptr_indir2; break;
case 4: func = TOK___bound_ptr_indir4; break;
case 8: func = TOK___bound_ptr_indir8; break;
case 12: func = TOK___bound_ptr_indir12; break;
case 16: func = TOK___bound_ptr_indir16; break;
default:
error("unhandled size when derefencing bounded pointer");
func = 0;
break;
}
/* patch relocation */
/* XXX: find a better solution ? */
rel = (Elf32_Rel *)(cur_text_section->reloc->data + vtop->c.ul);
sym = external_global_sym(func, &func_old_type, 0);
if (!sym->c)
2002-07-28 03:08:29 +04:00
put_extern_sym(sym, NULL, 0, 0);
rel->r_info = ELF32_R_INFO(sym->c, ELF32_R_TYPE(rel->r_info));
}
#endif
2001-12-13 00:16:34 +03:00
/* end of X86 code generator */
/*************************************************************/