VLA code: minor fix
[tinycc.git] / i386-gen.c
Commit [+]AuthorDateLineData
25618c04 bellard2001-12-13 22:28:53 +00001/*
2 * X86 code generator for TCC
3 *
c9c05ca5 bellard2004-10-27 21:38:03 +00004 * Copyright (c) 2001-2004 Fabrice Bellard
25618c04 bellard2001-12-13 22:28:53 +00005 *
8f5e44a4 bellard2003-05-24 14:11:17 +00006 * 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.
25618c04 bellard2001-12-13 22:28:53 +000010 *
8f5e44a4 bellard2003-05-24 14:11:17 +000011 * 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.
25618c04 bellard2001-12-13 22:28:53 +000015 *
8f5e44a4 bellard2003-05-24 14:11:17 +000016 * 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
25618c04 bellard2001-12-13 22:28:53 +000019 */
39173894 bellard2001-12-12 21:16:34 +000020
88a3ccab grischka2009-12-20 01:53:49 +010021#ifdef TARGET_DEFS_ONLY
22
39173894 bellard2001-12-12 21:16:34 +000023/* number of available registers */
88a3ccab grischka2009-12-20 01:53:49 +010024#define NB_REGS 4
25#define NB_ASM_REGS 8
39173894 bellard2001-12-12 21:16:34 +000026
b7fed2f2 bellard2002-01-05 16:17:34 +000027/* 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). */
21c35b94 bellard2001-12-23 00:34:26 +000030#define RC_INT 0x0001 /* generic integer register */
31#define RC_FLOAT 0x0002 /* generic float register */
14658993 bellard2002-01-03 21:14:59 +000032#define RC_EAX 0x0004
b7fed2f2 bellard2002-01-05 16:17:34 +000033#define RC_ST0 0x0008
14658993 bellard2002-01-03 21:14:59 +000034#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 */
b7fed2f2 bellard2002-01-05 16:17:34 +000038#define RC_FRET RC_ST0 /* function return: float register */
39173894 bellard2001-12-12 21:16:34 +000039
40/* pretty names for the registers */
41enum {
b5259da4 bellard2002-12-08 14:34:48 +000042 TREG_EAX = 0,
43 TREG_ECX,
44 TREG_EDX,
45 TREG_ST0,
41b3c7a5 James Lyon2013-04-27 20:39:34 +010046 TREG_ESP = 4
39173894 bellard2001-12-12 21:16:34 +000047};
48
21c35b94 bellard2001-12-23 00:34:26 +000049/* return registers for function */
b5259da4 bellard2002-12-08 14:34:48 +000050#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 */
39173894 bellard2001-12-12 21:16:34 +000053
54/* defined if function parameters must be evaluated in reverse order */
55#define INVERT_FUNC_PARAMS
56
57/* defined if structures are passed as pointers. Otherwise structures
58 are directly pushed on stack. */
0bdbd49e Urs Janssen2013-02-17 00:48:51 +010059/* #define FUNC_STRUCT_PARAM_AS_PTR */
39173894 bellard2001-12-12 21:16:34 +000060
25618c04 bellard2001-12-13 22:28:53 +000061/* pointer size, in bytes */
62#define PTR_SIZE 4
63
64/* long double size and alignment, in bytes */
65#define LDOUBLE_SIZE 12
66#define LDOUBLE_ALIGN 4
d1e7e264 bellard2002-11-24 15:58:50 +000067/* maximum alignment (for aligned attribute support) */
68#define MAX_ALIGN 8
25618c04 bellard2001-12-13 22:28:53 +000069
88a3ccab grischka2009-12-20 01:53:49 +010070
71#define psym oad
72
4df5bd2e bellard2003-10-14 22:15:56 +000073/******************************************************/
74/* ELF defines */
75
76#define EM_TCC_TARGET EM_386
77
6cd36b12 bellard2002-07-14 14:38:33 +000078/* relocation type for 32 bit data relocation */
4df5bd2e bellard2003-10-14 22:15:56 +000079#define R_DATA_32 R_386_32
5dadff3d Shinichiro Hamaji2009-07-19 06:42:23 +090080#define R_DATA_PTR R_386_32
4df5bd2e bellard2003-10-14 22:15:56 +000081#define R_JMP_SLOT R_386_JMP_SLOT
82#define R_COPY R_386_COPY
83
84#define ELF_START_ADDR 0x08048000
85#define ELF_PAGE_SIZE 0x1000
6cd36b12 bellard2002-07-14 14:38:33 +000086
39173894 bellard2001-12-12 21:16:34 +000087/******************************************************/
88a3ccab grischka2009-12-20 01:53:49 +010088#else /* ! TARGET_DEFS_ONLY */
89/******************************************************/
90#include "tcc.h"
91
92ST_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};
39173894 bellard2001-12-12 21:16:34 +000098
a42941b1 bellard2002-07-27 14:06:11 +000099static unsigned long func_sub_sp_offset;
621b3fc3 bellard2002-01-26 17:23:44 +0000100static int func_ret_sub;
7fa712e0 grischka2009-12-19 22:22:43 +0100101#ifdef CONFIG_TCC_BCHECK
acef4ff2 seyko2015-03-26 07:47:45 +0300102static addr_t func_bound_offset;
7fa712e0 grischka2009-12-19 22:22:43 +0100103#endif
14799da8 bellard2002-01-03 22:43:10 +0000104
4891761b bellard2002-08-18 13:19:18 +0000105/* XXX: make it faster ? */
88a3ccab grischka2009-12-20 01:53:49 +0100106ST_FUNC void g(int c)
39173894 bellard2001-12-12 21:16:34 +0000107{
4891761b bellard2002-08-18 13:19:18 +0000108 int ind1;
109 ind1 = ind + 1;
110 if (ind1 > cur_text_section->data_allocated)
111 section_realloc(cur_text_section, ind1);
a42941b1 bellard2002-07-27 14:06:11 +0000112 cur_text_section->data[ind] = c;
4891761b bellard2002-08-18 13:19:18 +0000113 ind = ind1;
39173894 bellard2001-12-12 21:16:34 +0000114}
115
88a3ccab grischka2009-12-20 01:53:49 +0100116ST_FUNC void o(unsigned int c)
39173894 bellard2001-12-12 21:16:34 +0000117{
118 while (c) {
119 g(c);
3bd3c71f bellard2004-10-04 22:06:22 +0000120 c = c >> 8;
39173894 bellard2001-12-12 21:16:34 +0000121 }
122}
123
88a3ccab grischka2009-12-20 01:53:49 +0100124ST_FUNC void gen_le16(int v)
1308e8eb grischka2009-12-19 22:08:37 +0100125{
126 g(v);
127 g(v >> 8);
128}
129
88a3ccab grischka2009-12-20 01:53:49 +0100130ST_FUNC void gen_le32(int c)
39173894 bellard2001-12-12 21:16:34 +0000131{
132 g(c);
133 g(c >> 8);
134 g(c >> 16);
135 g(c >> 24);
136}
137
39173894 bellard2001-12-12 21:16:34 +0000138/* output a symbol and patch all calls to it */
88a3ccab grischka2009-12-20 01:53:49 +0100139ST_FUNC void gsym_addr(int t, int a)
39173894 bellard2001-12-12 21:16:34 +0000140{
a42941b1 bellard2002-07-27 14:06:11 +0000141 int n, *ptr;
39173894 bellard2001-12-12 21:16:34 +0000142 while (t) {
a42941b1 bellard2002-07-27 14:06:11 +0000143 ptr = (int *)(cur_text_section->data + t);
144 n = *ptr; /* next value */
145 *ptr = a - t - 4;
39173894 bellard2001-12-12 21:16:34 +0000146 t = n;
147 }
148}
149
88a3ccab grischka2009-12-20 01:53:49 +0100150ST_FUNC void gsym(int t)
39173894 bellard2001-12-12 21:16:34 +0000151{
152 gsym_addr(t, ind);
153}
154
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
158
159/* instruction + 4 bytes data. Return the address of the data */
88a3ccab grischka2009-12-20 01:53:49 +0100160ST_FUNC int oad(int c, int s)
39173894 bellard2001-12-12 21:16:34 +0000161{
4891761b bellard2002-08-18 13:19:18 +0000162 int ind1;
163
39173894 bellard2001-12-12 21:16:34 +0000164 o(c);
4891761b bellard2002-08-18 13:19:18 +0000165 ind1 = ind + 4;
166 if (ind1 > cur_text_section->data_allocated)
167 section_realloc(cur_text_section, ind1);
a42941b1 bellard2002-07-27 14:06:11 +0000168 *(int *)(cur_text_section->data + ind) = s;
39173894 bellard2001-12-12 21:16:34 +0000169 s = ind;
4891761b bellard2002-08-18 13:19:18 +0000170 ind = ind1;
39173894 bellard2001-12-12 21:16:34 +0000171 return s;
172}
173
6cd36b12 bellard2002-07-14 14:38:33 +0000174/* output constant with relocation if 'r & VT_SYM' is true */
88a3ccab grischka2009-12-20 01:53:49 +0100175ST_FUNC void gen_addr32(int r, Sym *sym, int c)
39173894 bellard2001-12-12 21:16:34 +0000176{
d2115bfb bellard2002-08-29 23:05:59 +0000177 if (r & VT_SYM)
178 greloc(cur_text_section, sym, ind, R_386_32);
179 gen_le32(c);
39173894 bellard2001-12-12 21:16:34 +0000180}
181
88a3ccab grischka2009-12-20 01:53:49 +0100182ST_FUNC void gen_addrpc32(int r, Sym *sym, int c)
1308e8eb grischka2009-12-19 22:08:37 +0100183{
184 if (r & VT_SYM)
185 greloc(cur_text_section, sym, ind, R_386_PC32);
186 gen_le32(c - 4);
187}
188
21c35b94 bellard2001-12-23 00:34:26 +0000189/* generate a modrm reference. 'op_reg' contains the addtionnal 3
190 opcode bits */
d2115bfb bellard2002-08-29 23:05:59 +0000191static void gen_modrm(int op_reg, int r, Sym *sym, int c)
21c35b94 bellard2001-12-23 00:34:26 +0000192{
193 op_reg = op_reg << 3;
194 if ((r & VT_VALMASK) == VT_CONST) {
195 /* constant memory reference */
196 o(0x05 | op_reg);
d2115bfb bellard2002-08-29 23:05:59 +0000197 gen_addr32(r, sym, c);
21c35b94 bellard2001-12-23 00:34:26 +0000198 } 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);
206 }
207 } else {
208 g(0x00 | op_reg | (r & VT_VALMASK));
209 }
210}
211
f7181903 bellard2001-12-20 01:05:21 +0000212/* load 'r' from value 'sv' */
88a3ccab grischka2009-12-20 01:53:49 +0100213ST_FUNC void load(int r, SValue *sv)
39173894 bellard2001-12-12 21:16:34 +0000214{
f7181903 bellard2001-12-20 01:05:21 +0000215 int v, t, ft, fc, fr;
216 SValue v1;
39173894 bellard2001-12-12 21:16:34 +0000217
5b113f3e grischka2009-11-13 17:14:05 +0100218#ifdef TCC_TARGET_PE
2341ee51 grischka2010-01-14 20:55:51 +0100219 SValue v2;
220 sv = pe_getimport(sv, &v2);
5b113f3e grischka2009-11-13 17:14:05 +0100221#endif
2341ee51 grischka2010-01-14 20:55:51 +0100222
f7181903 bellard2001-12-20 01:05:21 +0000223 fr = sv->r;
9620fd18 bellard2002-11-18 21:46:44 +0000224 ft = sv->type.t;
f7181903 bellard2001-12-20 01:05:21 +0000225 fc = sv->c.ul;
226
227 v = fr & VT_VALMASK;
228 if (fr & VT_LVAL) {
39173894 bellard2001-12-12 21:16:34 +0000229 if (v == VT_LLOCAL) {
9620fd18 bellard2002-11-18 21:46:44 +0000230 v1.type.t = VT_INT;
f7181903 bellard2001-12-20 01:05:21 +0000231 v1.r = VT_LOCAL | VT_LVAL;
232 v1.c.ul = fc;
21c35b94 bellard2001-12-23 00:34:26 +0000233 fr = r;
9527c494
DG
Daniel Glöckner2012-01-23 01:41:36 +0100234 if (!(reg_classes[fr] & RC_INT))
235 fr = get_reg(RC_INT);
236 load(fr, &v1);
39173894 bellard2001-12-12 21:16:34 +0000237 }
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;
25618c04 bellard2001-12-13 22:28:53 +0000244 } else if ((ft & VT_BTYPE) == VT_LDOUBLE) {
245 o(0xdb); /* fldt */
246 r = 5;
f6b50558 Thomas Preud'homme2013-06-14 16:18:16 +0200247 } else if ((ft & VT_TYPE) == VT_BYTE || (ft & VT_TYPE) == VT_BOOL) {
39173894 bellard2001-12-12 21:16:34 +0000248 o(0xbe0f); /* movsbl */
264dbcfe bellard2002-07-13 15:55:16 +0000249 } else if ((ft & VT_TYPE) == (VT_BYTE | VT_UNSIGNED)) {
39173894 bellard2001-12-12 21:16:34 +0000250 o(0xb60f); /* movzbl */
264dbcfe bellard2002-07-13 15:55:16 +0000251 } else if ((ft & VT_TYPE) == VT_SHORT) {
39173894 bellard2001-12-12 21:16:34 +0000252 o(0xbf0f); /* movswl */
264dbcfe bellard2002-07-13 15:55:16 +0000253 } else if ((ft & VT_TYPE) == (VT_SHORT | VT_UNSIGNED)) {
39173894 bellard2001-12-12 21:16:34 +0000254 o(0xb70f); /* movzwl */
264dbcfe bellard2002-07-13 15:55:16 +0000255 } else {
39173894 bellard2001-12-12 21:16:34 +0000256 o(0x8b); /* movl */
264dbcfe bellard2002-07-13 15:55:16 +0000257 }
d2115bfb bellard2002-08-29 23:05:59 +0000258 gen_modrm(r, fr, sv->sym, fc);
39173894 bellard2001-12-12 21:16:34 +0000259 } else {
260 if (v == VT_CONST) {
261 o(0xb8 + r); /* mov $xx, r */
d2115bfb bellard2002-08-29 23:05:59 +0000262 gen_addr32(fr, sv->sym, fc);
39173894 bellard2001-12-12 21:16:34 +0000263 } else if (v == VT_LOCAL) {
ab24aaec
KS
Kirill Smelkov2012-11-16 00:04:56 +0400264 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 */
270 }
39173894 bellard2001-12-12 21:16:34 +0000271 } 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 */
3748975f bellard2002-09-08 22:06:11 +0000279 o(0x05eb); /* jmp after */
39173894 bellard2001-12-12 21:16:34 +0000280 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 */
285 }
286 }
287}
288
f7181903 bellard2001-12-20 01:05:21 +0000289/* store register 'r' in lvalue 'v' */
88a3ccab grischka2009-12-20 01:53:49 +0100290ST_FUNC void store(int r, SValue *v)
39173894 bellard2001-12-12 21:16:34 +0000291{
f7181903 bellard2001-12-20 01:05:21 +0000292 int fr, bt, ft, fc;
39173894 bellard2001-12-12 21:16:34 +0000293
5b113f3e grischka2009-11-13 17:14:05 +0100294#ifdef TCC_TARGET_PE
2341ee51 grischka2010-01-14 20:55:51 +0100295 SValue v2;
296 v = pe_getimport(v, &v2);
5b113f3e grischka2009-11-13 17:14:05 +0100297#endif
2341ee51 grischka2010-01-14 20:55:51 +0100298
9620fd18 bellard2002-11-18 21:46:44 +0000299 ft = v->type.t;
f7181903 bellard2001-12-20 01:05:21 +0000300 fc = v->c.ul;
301 fr = v->r & VT_VALMASK;
39173894 bellard2001-12-12 21:16:34 +0000302 bt = ft & VT_BTYPE;
21c35b94 bellard2001-12-23 00:34:26 +0000303 /* XXX: incorrect if float reg to reg */
39173894 bellard2001-12-12 21:16:34 +0000304 if (bt == VT_FLOAT) {
2694c105 bellard2001-12-17 21:56:48 +0000305 o(0xd9); /* fsts */
306 r = 2;
39173894 bellard2001-12-12 21:16:34 +0000307 } else if (bt == VT_DOUBLE) {
308 o(0xdd); /* fstpl */
2694c105 bellard2001-12-17 21:56:48 +0000309 r = 2;
25618c04 bellard2001-12-13 22:28:53 +0000310 } else if (bt == VT_LDOUBLE) {
2694c105 bellard2001-12-17 21:56:48 +0000311 o(0xc0d9); /* fld %st(0) */
25618c04 bellard2001-12-13 22:28:53 +0000312 o(0xdb); /* fstpt */
313 r = 7;
39173894 bellard2001-12-12 21:16:34 +0000314 } else {
315 if (bt == VT_SHORT)
316 o(0x66);
09f4ce98 bellard2005-04-17 13:15:31 +0000317 if (bt == VT_BYTE || bt == VT_BOOL)
39173894 bellard2001-12-12 21:16:34 +0000318 o(0x88);
319 else
320 o(0x89);
321 }
21c35b94 bellard2001-12-23 00:34:26 +0000322 if (fr == VT_CONST ||
323 fr == VT_LOCAL ||
324 (v->r & VT_LVAL)) {
d2115bfb bellard2002-08-29 23:05:59 +0000325 gen_modrm(r, v->r, v->sym, fc);
39173894 bellard2001-12-12 21:16:34 +0000326 } else if (fr != r) {
327 o(0xc0 + fr + r * 8); /* mov r, fr */
328 }
329}
330
58af3a6c bellard2002-07-24 22:11:30 +0000331static void gadd_sp(int val)
332{
333 if (val == (char)val) {
334 o(0xc483);
335 g(val);
336 } else {
337 oad(0xc481, val); /* add $xxx, %esp */
338 }
339}
340
73faaea2 grischka2013-08-28 22:55:05 +0200341static void gen_static_call(int v)
342{
343 Sym *sym;
344
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);
348}
349
fde824b7 bellard2002-11-03 00:43:01 +0000350/* 'is_jmp' is '1' if it is a jump */
351static void gcall_or_jmp(int is_jmp)
39173894 bellard2001-12-12 21:16:34 +0000352{
353 int r;
f7181903 bellard2001-12-20 01:05:21 +0000354 if ((vtop->r & (VT_VALMASK | VT_LVAL)) == VT_CONST) {
39173894 bellard2001-12-12 21:16:34 +0000355 /* constant case */
6cd36b12 bellard2002-07-14 14:38:33 +0000356 if (vtop->r & VT_SYM) {
357 /* relocation case */
d2115bfb bellard2002-08-29 23:05:59 +0000358 greloc(cur_text_section, vtop->sym,
a42941b1 bellard2002-07-27 14:06:11 +0000359 ind + 1, R_386_PC32);
39173894 bellard2001-12-12 21:16:34 +0000360 } else {
431d6480 bellard2002-08-31 12:42:16 +0000361 /* put an empty PC32 relocation */
362 put_elf_reloc(symtab_section, cur_text_section,
363 ind + 1, R_386_PC32, 0);
39173894 bellard2001-12-12 21:16:34 +0000364 }
fde824b7 bellard2002-11-03 00:43:01 +0000365 oad(0xe8 + is_jmp, vtop->c.ul - 4); /* call/jmp im */
39173894 bellard2001-12-12 21:16:34 +0000366 } else {
367 /* otherwise, indirect call */
21c35b94 bellard2001-12-23 00:34:26 +0000368 r = gv(RC_INT);
fde824b7 bellard2002-11-03 00:43:01 +0000369 o(0xff); /* call/jmp *r */
370 o(0xd0 + r + (is_jmp << 4));
39173894 bellard2001-12-12 21:16:34 +0000371 }
fde824b7 bellard2002-11-03 00:43:01 +0000372}
373
72a88fba bellard2004-10-18 00:14:40 +0000374static uint8_t fastcall_regs[3] = { TREG_EAX, TREG_EDX, TREG_ECX };
e9c64e3f bellard2005-09-03 22:21:22 +0000375static uint8_t fastcallw_regs[2] = { TREG_ECX, TREG_EDX };
72a88fba bellard2004-10-18 00:14:40 +0000376
dcec8673
TP
Thomas Preud'homme2013-11-22 09:27:15 +0800377/* Return the number of registers needed to return the struct, or 0 if
378 returning via struct pointer. */
50899e30 Michael Matz2015-03-09 00:19:59 +0100379ST_FUNC int gfunc_sret(CType *vt, int variadic, CType *ret, int *ret_align, int *regsize)
be1b6ba7 grischka2013-04-30 00:33:34 +0200380{
2bbfaf43
JL
James Lyon2013-04-18 17:27:34 +0100381#ifdef TCC_TARGET_PE
382 int size, align;
be1b6ba7 grischka2013-04-30 00:33:34 +0200383
384 *ret_align = 1; // Never have to re-align return values for x86
50899e30 Michael Matz2015-03-09 00:19:59 +0100385 *regsize = 4;
2bbfaf43
JL
James Lyon2013-04-18 17:27:34 +0100386 size = type_size(vt, &align);
387 if (size > 8) {
dcec8673 Thomas Preud'homme2013-11-22 09:27:15 +0800388 return 0;
2bbfaf43
JL
James Lyon2013-04-18 17:27:34 +0100389 } else if (size > 4) {
390 ret->ref = NULL;
391 ret->t = VT_LLONG;
dcec8673 Thomas Preud'homme2013-11-22 09:27:15 +0800392 return 1;
2bbfaf43
JL
James Lyon2013-04-18 17:27:34 +0100393 } else {
394 ret->ref = NULL;
395 ret->t = VT_INT;
fbc88103 grischka2013-12-16 15:38:10 +0100396 return 1;
2bbfaf43
JL
James Lyon2013-04-18 17:27:34 +0100397 }
398#else
be1b6ba7 grischka2013-04-30 00:33:34 +0200399 *ret_align = 1; // Never have to re-align return values for x86
dcec8673 Thomas Preud'homme2013-11-22 09:27:15 +0800400 return 0;
2bbfaf43
JL
James Lyon2013-04-18 17:27:34 +0100401#endif
402}
403
214cccce bellard2003-04-16 21:16:20 +0000404/* 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. */
88a3ccab grischka2009-12-20 01:53:49 +0100407ST_FUNC void gfunc_call(int nb_args)
fde824b7 bellard2002-11-03 00:43:01 +0000408{
72a88fba bellard2004-10-18 00:14:40 +0000409 int size, align, r, args_size, i, func_call;
214cccce bellard2003-04-16 21:16:20 +0000410 Sym *func_sym;
411
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;
453 }
454 o(0x50 + r); /* push r */
455 args_size += size;
456 }
457 vtop--;
458 }
459 save_regs(0); /* save used temporary registers */
460 func_sym = vtop->type.ref;
3fe2a95d grischka2014-01-07 14:57:07 +0100461 func_call = func_sym->a.func_call;
72a88fba bellard2004-10-18 00:14:40 +0000462 /* fast call case */
e9c64e3f bellard2005-09-03 22:21:22 +0000463 if ((func_call >= FUNC_FASTCALL1 && func_call <= FUNC_FASTCALL3) ||
464 func_call == FUNC_FASTCALLW) {
72a88fba bellard2004-10-18 00:14:40 +0000465 int fastcall_nb_regs;
e9c64e3f bellard2005-09-03 22:21:22 +0000466 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;
473 }
72a88fba bellard2004-10-18 00:14:40 +0000474 for(i = 0;i < fastcall_nb_regs; i++) {
475 if (args_size <= 0)
476 break;
e9c64e3f bellard2005-09-03 22:21:22 +0000477 o(0x58 + fastcall_regs_ptr[i]); /* pop r */
72a88fba bellard2004-10-18 00:14:40 +0000478 /* XXX: incorrect for struct/floats */
479 args_size -= 4;
480 }
481 }
ae2ece93
JL
James Lyon2013-04-26 00:31:46 +0100482#ifndef TCC_TARGET_PE
483 else if ((vtop->type.ref->type.t & VT_BTYPE) == VT_STRUCT)
484 args_size -= 4;
485#endif
fde824b7 bellard2002-11-03 00:43:01 +0000486 gcall_or_jmp(0);
610fd475 grischka2009-06-17 02:11:13 +0200487
5342b32e grischka2007-12-19 17:36:42 +0000488 if (args_size && func_call != FUNC_STDCALL)
214cccce bellard2003-04-16 21:16:20 +0000489 gadd_sp(args_size);
fbc51a39 bellard2001-12-16 17:58:32 +0000490 vtop--;
39173894 bellard2001-12-12 21:16:34 +0000491}
492
9825011c bellard2005-04-10 22:15:08 +0000493#ifdef TCC_TARGET_PE
494#define FUNC_PROLOG_SIZE 10
495#else
496#define FUNC_PROLOG_SIZE 9
497#endif
498
14799da8 bellard2002-01-03 22:43:10 +0000499/* generate function prolog of type 't' */
88a3ccab grischka2009-12-20 01:53:49 +0100500ST_FUNC void gfunc_prolog(CType *func_type)
14799da8 bellard2002-01-03 22:43:10 +0000501{
72a88fba bellard2004-10-18 00:14:40 +0000502 int addr, align, size, func_call, fastcall_nb_regs;
503 int param_index, param_addr;
e9c64e3f bellard2005-09-03 22:21:22 +0000504 uint8_t *fastcall_regs_ptr;
14799da8 bellard2002-01-03 22:43:10 +0000505 Sym *sym;
9620fd18 bellard2002-11-18 21:46:44 +0000506 CType *type;
14799da8 bellard2002-01-03 22:43:10 +0000507
9620fd18 bellard2002-11-18 21:46:44 +0000508 sym = func_type->ref;
3fe2a95d grischka2014-01-07 14:57:07 +0100509 func_call = sym->a.func_call;
14799da8 bellard2002-01-03 22:43:10 +0000510 addr = 8;
72a88fba bellard2004-10-18 00:14:40 +0000511 loc = 0;
610fd475 grischka2009-06-17 02:11:13 +0200512 func_vc = 0;
513
72a88fba bellard2004-10-18 00:14:40 +0000514 if (func_call >= FUNC_FASTCALL1 && func_call <= FUNC_FASTCALL3) {
515 fastcall_nb_regs = func_call - FUNC_FASTCALL1 + 1;
e9c64e3f bellard2005-09-03 22:21:22 +0000516 fastcall_regs_ptr = fastcall_regs;
517 } else if (func_call == FUNC_FASTCALLW) {
518 fastcall_nb_regs = 2;
519 fastcall_regs_ptr = fastcallw_regs;
72a88fba bellard2004-10-18 00:14:40 +0000520 } else {
521 fastcall_nb_regs = 0;
e9c64e3f bellard2005-09-03 22:21:22 +0000522 fastcall_regs_ptr = NULL;
72a88fba bellard2004-10-18 00:14:40 +0000523 }
524 param_index = 0;
525
9825011c bellard2005-04-10 22:15:08 +0000526 ind += FUNC_PROLOG_SIZE;
527 func_sub_sp_offset = ind;
14799da8 bellard2002-01-03 22:43:10 +0000528 /* if the function returns a structure, then add an
529 implicit pointer parameter */
9620fd18 bellard2002-11-18 21:46:44 +0000530 func_vt = sym->type;
8efaa711 Thomas Preud'homme2014-01-06 22:27:39 +0800531 func_var = (sym->c == FUNC_ELLIPSIS);
2bbfaf43
JL
James Lyon2013-04-18 17:27:34 +0100532#ifdef TCC_TARGET_PE
533 size = type_size(&func_vt,&align);
534 if (((func_vt.t & VT_BTYPE) == VT_STRUCT) && (size > 8)) {
535#else
9620fd18 bellard2002-11-18 21:46:44 +0000536 if ((func_vt.t & VT_BTYPE) == VT_STRUCT) {
2bbfaf43 James Lyon2013-04-18 17:27:34 +0100537#endif
72a88fba bellard2004-10-18 00:14:40 +0000538 /* XXX: fastcall case ? */
14799da8 bellard2002-01-03 22:43:10 +0000539 func_vc = addr;
540 addr += 4;
72a88fba bellard2004-10-18 00:14:40 +0000541 param_index++;
14799da8 bellard2002-01-03 22:43:10 +0000542 }
543 /* define parameters */
544 while ((sym = sym->next) != NULL) {
9620fd18 bellard2002-11-18 21:46:44 +0000545 type = &sym->type;
9620fd18 bellard2002-11-18 21:46:44 +0000546 size = type_size(type, &align);
14799da8 bellard2002-01-03 22:43:10 +0000547 size = (size + 3) & ~3;
548#ifdef FUNC_STRUCT_PARAM_AS_PTR
549 /* structs are passed as pointer */
9620fd18 bellard2002-11-18 21:46:44 +0000550 if ((type->t & VT_BTYPE) == VT_STRUCT) {
14799da8 bellard2002-01-03 22:43:10 +0000551 size = 4;
552 }
553#endif
72a88fba bellard2004-10-18 00:14:40 +0000554 if (param_index < fastcall_nb_regs) {
555 /* save FASTCALL register */
556 loc -= 4;
557 o(0x89); /* movl */
e9c64e3f bellard2005-09-03 22:21:22 +0000558 gen_modrm(fastcall_regs_ptr[param_index], VT_LOCAL, NULL, loc);
72a88fba bellard2004-10-18 00:14:40 +0000559 param_addr = loc;
560 } else {
561 param_addr = addr;
562 addr += size;
563 }
564 sym_push(sym->v & ~SYM_FIELD, type,
2c657f66 Daniel Glöckner2008-08-20 01:44:12 +0200565 VT_LOCAL | lvalue_type(type->t), param_addr);
72a88fba bellard2004-10-18 00:14:40 +0000566 param_index++;
14799da8 bellard2002-01-03 22:43:10 +0000567 }
621b3fc3 bellard2002-01-26 17:23:44 +0000568 func_ret_sub = 0;
569 /* pascal type call ? */
570 if (func_call == FUNC_STDCALL)
571 func_ret_sub = addr - 8;
ae2ece93
JL
James Lyon2013-04-26 00:31:46 +0100572#ifndef TCC_TARGET_PE
573 else if (func_vc)
574 func_ret_sub = 4;
575#endif
72a88fba bellard2004-10-18 00:14:40 +0000576
7fa712e0 grischka2009-12-19 22:22:43 +0100577#ifdef CONFIG_TCC_BCHECK
b7fed2f2 bellard2002-01-05 16:17:34 +0000578 /* leave some room for bound checking code */
f9181416 grischka2009-05-11 18:45:44 +0200579 if (tcc_state->do_bounds_check) {
b7fed2f2 bellard2002-01-05 16:17:34 +0000580 oad(0xb8, 0); /* lbound section pointer */
581 oad(0xb8, 0); /* call to function */
a42941b1 bellard2002-07-27 14:06:11 +0000582 func_bound_offset = lbounds_section->data_offset;
b7fed2f2 bellard2002-01-05 16:17:34 +0000583 }
7fa712e0 grischka2009-12-19 22:22:43 +0100584#endif
14799da8 bellard2002-01-03 22:43:10 +0000585}
586
587/* generate function epilog */
88a3ccab grischka2009-12-20 01:53:49 +0100588ST_FUNC void gfunc_epilog(void)
14799da8 bellard2002-01-03 22:43:10 +0000589{
acef4ff2 seyko2015-03-26 07:47:45 +0300590 addr_t v, saved_ind;
9825011c bellard2005-04-10 22:15:08 +0000591
4226681d bellard2002-03-03 22:45:55 +0000592#ifdef CONFIG_TCC_BCHECK
f9181416 grischka2009-05-11 18:45:44 +0200593 if (tcc_state->do_bounds_check
594 && func_bound_offset != lbounds_section->data_offset) {
acef4ff2 seyko2015-03-26 07:47:45 +0300595 addr_t saved_ind;
596 addr_t *bounds_ptr;
73faaea2 grischka2013-08-28 22:55:05 +0200597 Sym *sym_data;
b7fed2f2 bellard2002-01-05 16:17:34 +0000598 /* add end of table info */
acef4ff2 seyko2015-03-26 07:47:45 +0300599 bounds_ptr = section_ptr_add(lbounds_section, sizeof(addr_t));
a42941b1 bellard2002-07-27 14:06:11 +0000600 *bounds_ptr = 0;
b7fed2f2 bellard2002-01-05 16:17:34 +0000601 /* generate bound local allocation */
602 saved_ind = ind;
9825011c bellard2005-04-10 22:15:08 +0000603 ind = func_sub_sp_offset;
9620fd18 bellard2002-11-18 21:46:44 +0000604 sym_data = get_sym_ref(&char_pointer_type, lbounds_section,
a42941b1 bellard2002-07-27 14:06:11 +0000605 func_bound_offset, lbounds_section->data_offset);
58af3a6c bellard2002-07-24 22:11:30 +0000606 greloc(cur_text_section, sym_data,
a42941b1 bellard2002-07-27 14:06:11 +0000607 ind + 1, R_386_32);
58af3a6c bellard2002-07-24 22:11:30 +0000608 oad(0xb8, 0); /* mov %eax, xxx */
73faaea2 grischka2013-08-28 22:55:05 +0200609 gen_static_call(TOK___bound_local_new);
610
b7fed2f2 bellard2002-01-05 16:17:34 +0000611 ind = saved_ind;
612 /* generate bound check local freeing */
613 o(0x5250); /* save returned value, if any */
58af3a6c bellard2002-07-24 22:11:30 +0000614 greloc(cur_text_section, sym_data,
a42941b1 bellard2002-07-27 14:06:11 +0000615 ind + 1, R_386_32);
58af3a6c bellard2002-07-24 22:11:30 +0000616 oad(0xb8, 0); /* mov %eax, xxx */
73faaea2 grischka2013-08-28 22:55:05 +0200617 gen_static_call(TOK___bound_local_delete);
618
b7fed2f2 bellard2002-01-05 16:17:34 +0000619 o(0x585a); /* restore returned value, if any */
620 }
4226681d bellard2002-03-03 22:45:55 +0000621#endif
621b3fc3 bellard2002-01-26 17:23:44 +0000622 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);
629 }
b7fed2f2 bellard2002-01-05 16:17:34 +0000630 /* align local size to word & save local variables */
9825011c bellard2005-04-10 22:15:08 +0000631
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) {
9825011c bellard2005-04-10 22:15:08 +0000637 oad(0xb8, v); /* mov stacksize, %eax */
73faaea2 grischka2013-08-28 22:55:05 +0200638 gen_static_call(TOK___chkstk); /* call __chkstk, (does the stackframe too) */
9825011c bellard2005-04-10 22:15:08 +0000639 } else
640#endif
641 {
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
648 }
649 ind = saved_ind;
14799da8 bellard2002-01-03 22:43:10 +0000650}
651
421911f9 bellard2002-02-10 16:13:14 +0000652/* generate a jump to a label */
88a3ccab grischka2009-12-20 01:53:49 +0100653ST_FUNC int gjmp(int t)
39173894 bellard2001-12-12 21:16:34 +0000654{
655 return psym(0xe9, t);
656}
657
421911f9 bellard2002-02-10 16:13:14 +0000658/* generate a jump to a fixed address */
88a3ccab grischka2009-12-20 01:53:49 +0100659ST_FUNC void gjmp_addr(int a)
421911f9 bellard2002-02-10 16:13:14 +0000660{
3748975f bellard2002-09-08 22:06:11 +0000661 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);
668 }
421911f9 bellard2002-02-10 16:13:14 +0000669}
670
fbc51a39 bellard2001-12-16 17:58:32 +0000671/* generate a test. set 'inv' to invert test. Stack entry is popped */
88a3ccab grischka2009-12-20 01:53:49 +0100672ST_FUNC int gtst(int inv, int t)
39173894 bellard2001-12-12 21:16:34 +0000673{
674 int v, *p;
d1e7e264 bellard2002-11-24 15:58:50 +0000675
f7181903 bellard2001-12-20 01:05:21 +0000676 v = vtop->r & VT_VALMASK;
39173894 bellard2001-12-12 21:16:34 +0000677 if (v == VT_CMP) {
678 /* fast case : can jump directly since flags are set */
679 g(0x0f);
2694c105 bellard2001-12-17 21:56:48 +0000680 t = psym((vtop->c.i - 16) ^ inv, t);
2437ccdc seyko2015-03-03 15:51:09 +0300681 } else if (v == VT_JMP || v == VT_JMPI) {
39173894 bellard2001-12-12 21:16:34 +0000682 /* && or || optimization */
683 if ((v & 1) == inv) {
fbc51a39 bellard2001-12-16 17:58:32 +0000684 /* insert vtop->c jump list in t */
2694c105 bellard2001-12-17 21:56:48 +0000685 p = &vtop->c.i;
39173894 bellard2001-12-12 21:16:34 +0000686 while (*p != 0)
a42941b1 bellard2002-07-27 14:06:11 +0000687 p = (int *)(cur_text_section->data + *p);
39173894 bellard2001-12-12 21:16:34 +0000688 *p = t;
2694c105 bellard2001-12-17 21:56:48 +0000689 t = vtop->c.i;
39173894 bellard2001-12-12 21:16:34 +0000690 } else {
691 t = gjmp(t);
2694c105 bellard2001-12-17 21:56:48 +0000692 gsym(vtop->c.i);
39173894 bellard2001-12-12 21:16:34 +0000693 }
39173894 bellard2001-12-12 21:16:34 +0000694 }
fbc51a39 bellard2001-12-16 17:58:32 +0000695 vtop--;
39173894 bellard2001-12-12 21:16:34 +0000696 return t;
697}
698
fbc51a39 bellard2001-12-16 17:58:32 +0000699/* generate an integer binary operation */
88a3ccab grischka2009-12-20 01:53:49 +0100700ST_FUNC void gen_opi(int op)
39173894 bellard2001-12-12 21:16:34 +0000701{
14658993 bellard2002-01-03 21:14:59 +0000702 int r, fr, opc, c;
fbc51a39 bellard2001-12-16 17:58:32 +0000703
14658993 bellard2002-01-03 21:14:59 +0000704 switch(op) {
705 case '+':
706 case TOK_ADDC1: /* add with carry generation */
707 opc = 0;
708 gen_op8:
6cd36b12 bellard2002-07-14 14:38:33 +0000709 if ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST) {
14658993 bellard2002-01-03 21:14:59 +0000710 /* constant case */
b7fed2f2 bellard2002-01-05 16:17:34 +0000711 vswap();
712 r = gv(RC_INT);
713 vswap();
14658993 bellard2002-01-03 21:14:59 +0000714 c = vtop->c.i;
715 if (c == (char)c) {
d3c43224
U
U-UNIT1\dennis2010-04-03 21:20:34 +0300716 /* 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);
725 }
14658993 bellard2002-01-03 21:14:59 +0000726 } else {
727 o(0x81);
728 oad(0xc0 | (opc << 3) | r, c);
729 }
730 } else {
b7fed2f2 bellard2002-01-05 16:17:34 +0000731 gv2(RC_INT, RC_INT);
732 r = vtop[-1].r;
733 fr = vtop[0].r;
14658993 bellard2002-01-03 21:14:59 +0000734 o((opc << 3) | 0x01);
735 o(0xc0 + r + fr * 8);
736 }
737 vtop--;
738 if (op >= TOK_ULT && op <= TOK_GT) {
9620fd18 bellard2002-11-18 21:46:44 +0000739 vtop->r = VT_CMP;
740 vtop->c.i = op;
14658993 bellard2002-01-03 21:14:59 +0000741 }
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 '*':
b7fed2f2 bellard2002-01-05 16:17:34 +0000763 gv2(RC_INT, RC_INT);
764 r = vtop[-1].r;
765 fr = vtop[0].r;
14658993 bellard2002-01-03 21:14:59 +0000766 vtop--;
39173894 bellard2001-12-12 21:16:34 +0000767 o(0xaf0f); /* imul fr, r */
768 o(0xc0 + fr + r * 8);
14658993 bellard2002-01-03 21:14:59 +0000769 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:
14658993 bellard2002-01-03 21:14:59 +0000779 opc = 0xc0 | (opc << 3);
6cd36b12 bellard2002-07-14 14:38:33 +0000780 if ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST) {
14658993 bellard2002-01-03 21:14:59 +0000781 /* constant case */
b7fed2f2 bellard2002-01-05 16:17:34 +0000782 vswap();
783 r = gv(RC_INT);
784 vswap();
14658993 bellard2002-01-03 21:14:59 +0000785 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 */
b7fed2f2 bellard2002-01-05 16:17:34 +0000791 gv2(RC_INT, RC_ECX);
792 r = vtop[-1].r;
14658993 bellard2002-01-03 21:14:59 +0000793 o(0xd3); /* shl/shr/sar %cl, r */
794 o(opc | r);
39173894 bellard2001-12-12 21:16:34 +0000795 }
14658993 bellard2002-01-03 21:14:59 +0000796 vtop--;
14658993 bellard2002-01-03 21:14:59 +0000797 break;
798 case '/':
799 case TOK_UDIV:
800 case TOK_PDIV:
801 case '%':
802 case TOK_UMOD:
803 case TOK_UMULL:
b7fed2f2 bellard2002-01-05 16:17:34 +0000804 /* 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;
14658993 bellard2002-01-03 21:14:59 +0000809 vtop--;
b5259da4 bellard2002-12-08 14:34:48 +0000810 save_reg(TREG_EDX);
14658993 bellard2002-01-03 21:14:59 +0000811 if (op == TOK_UMULL) {
812 o(0xf7); /* mul fr */
813 o(0xe0 + fr);
b5259da4 bellard2002-12-08 14:34:48 +0000814 vtop->r2 = TREG_EDX;
815 r = TREG_EAX;
39173894 bellard2001-12-12 21:16:34 +0000816 } else {
14658993 bellard2002-01-03 21:14:59 +0000817 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);
823 }
824 if (op == '%' || op == TOK_UMOD)
b5259da4 bellard2002-12-08 14:34:48 +0000825 r = TREG_EDX;
14658993 bellard2002-01-03 21:14:59 +0000826 else
b5259da4 bellard2002-12-08 14:34:48 +0000827 r = TREG_EAX;
39173894 bellard2001-12-12 21:16:34 +0000828 }
f7181903 bellard2001-12-20 01:05:21 +0000829 vtop->r = r;
14658993 bellard2002-01-03 21:14:59 +0000830 break;
831 default:
832 opc = 7;
833 goto gen_op8;
39173894 bellard2001-12-12 21:16:34 +0000834 }
835}
836
fbc51a39 bellard2001-12-16 17:58:32 +0000837/* generate a floating point operation 'v = t1 op t2' instruction. The
838 two operands are guaranted to have the same floating point type */
b7fed2f2 bellard2002-01-05 16:17:34 +0000839/* XXX: need to use ST1 too */
88a3ccab grischka2009-12-20 01:53:49 +0100840ST_FUNC void gen_opf(int op)
39173894 bellard2001-12-12 21:16:34 +0000841{
621b3fc3 bellard2002-01-26 17:23:44 +0000842 int a, ft, fc, swapped, r;
39173894 bellard2001-12-12 21:16:34 +0000843
2694c105 bellard2001-12-17 21:56:48 +0000844 /* convert constants to memory references */
14658993 bellard2002-01-03 21:14:59 +0000845 if ((vtop[-1].r & (VT_VALMASK | VT_LVAL)) == VT_CONST) {
2694c105 bellard2001-12-17 21:56:48 +0000846 vswap();
21c35b94 bellard2001-12-23 00:34:26 +0000847 gv(RC_FLOAT);
2694c105 bellard2001-12-17 21:56:48 +0000848 vswap();
849 }
14658993 bellard2002-01-03 21:14:59 +0000850 if ((vtop[0].r & (VT_VALMASK | VT_LVAL)) == VT_CONST)
21c35b94 bellard2001-12-23 00:34:26 +0000851 gv(RC_FLOAT);
2694c105 bellard2001-12-17 21:56:48 +0000852
39173894 bellard2001-12-12 21:16:34 +0000853 /* must put at least one value in the floating point register */
f7181903 bellard2001-12-20 01:05:21 +0000854 if ((vtop[-1].r & VT_LVAL) &&
855 (vtop[0].r & VT_LVAL)) {
39173894 bellard2001-12-12 21:16:34 +0000856 vswap();
21c35b94 bellard2001-12-23 00:34:26 +0000857 gv(RC_FLOAT);
39173894 bellard2001-12-12 21:16:34 +0000858 vswap();
859 }
264dbcfe bellard2002-07-13 15:55:16 +0000860 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;
866 }
14658993 bellard2002-01-03 21:14:59 +0000867 if (op >= TOK_ULT && op <= TOK_GT) {
39173894 bellard2001-12-12 21:16:34 +0000868 /* load on stack second operand */
b5259da4 bellard2002-12-08 14:34:48 +0000869 load(TREG_ST0, vtop);
870 save_reg(TREG_EAX); /* eax is used by FP comparison code */
39173894 bellard2001-12-12 21:16:34 +0000871 if (op == TOK_GE || op == TOK_GT)
264dbcfe bellard2002-07-13 15:55:16 +0000872 swapped = !swapped;
873 else if (op == TOK_EQ || op == TOK_NE)
874 swapped = 0;
875 if (swapped)
39173894 bellard2001-12-12 21:16:34 +0000876 o(0xc9d9); /* fxch %st(1) */
e0e9a2a2
TP
Thomas Preud'homme2013-12-31 23:40:21 +0800877 if (op == TOK_EQ || op == TOK_NE)
878 o(0xe9da); /* fucompp */
879 else
880 o(0xd9de); /* fcompp */
39173894 bellard2001-12-12 21:16:34 +0000881 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;
895 }
fbc51a39 bellard2001-12-16 17:58:32 +0000896 vtop--;
f7181903 bellard2001-12-20 01:05:21 +0000897 vtop->r = VT_CMP;
2694c105 bellard2001-12-17 21:56:48 +0000898 vtop->c.i = op;
39173894 bellard2001-12-12 21:16:34 +0000899 } else {
21c35b94 bellard2001-12-23 00:34:26 +0000900 /* no memory reference possible for long double operations */
9620fd18 bellard2002-11-18 21:46:44 +0000901 if ((vtop->type.t & VT_BTYPE) == VT_LDOUBLE) {
b5259da4 bellard2002-12-08 14:34:48 +0000902 load(TREG_ST0, vtop);
21c35b94 bellard2001-12-23 00:34:26 +0000903 swapped = !swapped;
904 }
39173894 bellard2001-12-12 21:16:34 +0000905
906 switch(op) {
907 default:
908 case '+':
909 a = 0;
910 break;
911 case '-':
21c35b94 bellard2001-12-23 00:34:26 +0000912 a = 4;
39173894 bellard2001-12-12 21:16:34 +0000913 if (swapped)
21c35b94 bellard2001-12-23 00:34:26 +0000914 a++;
39173894 bellard2001-12-12 21:16:34 +0000915 break;
916 case '*':
21c35b94 bellard2001-12-23 00:34:26 +0000917 a = 1;
39173894 bellard2001-12-12 21:16:34 +0000918 break;
919 case '/':
21c35b94 bellard2001-12-23 00:34:26 +0000920 a = 6;
39173894 bellard2001-12-12 21:16:34 +0000921 if (swapped)
21c35b94 bellard2001-12-23 00:34:26 +0000922 a++;
39173894 bellard2001-12-12 21:16:34 +0000923 break;
924 }
9620fd18 bellard2002-11-18 21:46:44 +0000925 ft = vtop->type.t;
2694c105 bellard2001-12-17 21:56:48 +0000926 fc = vtop->c.ul;
21c35b94 bellard2001-12-23 00:34:26 +0000927 if ((ft & VT_BTYPE) == VT_LDOUBLE) {
928 o(0xde); /* fxxxp %st, %st(1) */
929 o(0xc1 + (a << 3));
39173894 bellard2001-12-12 21:16:34 +0000930 } else {
621b3fc3 bellard2002-01-26 17:23:44 +0000931 /* 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);
9620fd18 bellard2002-11-18 21:46:44 +0000936 v1.type.t = VT_INT;
621b3fc3 bellard2002-01-26 17:23:44 +0000937 v1.r = VT_LOCAL | VT_LVAL;
938 v1.c.ul = fc;
939 load(r, &v1);
940 fc = 0;
941 }
942
21c35b94 bellard2001-12-23 00:34:26 +0000943 if ((ft & VT_BTYPE) == VT_DOUBLE)
944 o(0xdc);
945 else
946 o(0xd8);
d2115bfb bellard2002-08-29 23:05:59 +0000947 gen_modrm(a, r, vtop->sym, fc);
39173894 bellard2001-12-12 21:16:34 +0000948 }
fbc51a39 bellard2001-12-16 17:58:32 +0000949 vtop--;
39173894 bellard2001-12-12 21:16:34 +0000950 }
39173894 bellard2001-12-12 21:16:34 +0000951}
952
14658993 bellard2002-01-03 21:14:59 +0000953/* convert integers to fp 't' type. Must handle 'int', 'unsigned int'
954 and 'long long' cases. */
88a3ccab grischka2009-12-20 01:53:49 +0100955ST_FUNC void gen_cvt_itof(int t)
39173894 bellard2001-12-12 21:16:34 +0000956{
b5259da4 bellard2002-12-08 14:34:48 +0000957 save_reg(TREG_ST0);
21c35b94 bellard2001-12-23 00:34:26 +0000958 gv(RC_INT);
9620fd18 bellard2002-11-18 21:46:44 +0000959 if ((vtop->type.t & VT_BTYPE) == VT_LLONG) {
14658993 bellard2002-01-03 21:14:59 +0000960 /* 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 */
9620fd18 bellard2002-11-18 21:46:44 +0000966 } else if ((vtop->type.t & (VT_BTYPE | VT_UNSIGNED)) ==
14658993 bellard2002-01-03 21:14:59 +0000967 (VT_INT | VT_UNSIGNED)) {
25618c04 bellard2001-12-13 22:28:53 +0000968 /* unsigned int to float/double/long double */
39173894 bellard2001-12-12 21:16:34 +0000969 o(0x6a); /* push $0 */
970 g(0x00);
f7181903 bellard2001-12-20 01:05:21 +0000971 o(0x50 + (vtop->r & VT_VALMASK)); /* push r */
39173894 bellard2001-12-12 21:16:34 +0000972 o(0x242cdf); /* fildll (%esp) */
973 o(0x08c483); /* add $8, %esp */
974 } else {
25618c04 bellard2001-12-13 22:28:53 +0000975 /* int to float/double/long double */
f7181903 bellard2001-12-20 01:05:21 +0000976 o(0x50 + (vtop->r & VT_VALMASK)); /* push r */
39173894 bellard2001-12-12 21:16:34 +0000977 o(0x2404db); /* fildl (%esp) */
978 o(0x04c483); /* add $4, %esp */
979 }
b5259da4 bellard2002-12-08 14:34:48 +0000980 vtop->r = TREG_ST0;
2694c105 bellard2001-12-17 21:56:48 +0000981}
982
2694c105 bellard2001-12-17 21:56:48 +0000983/* convert fp to int 't' type */
88a3ccab grischka2009-12-20 01:53:49 +0100984ST_FUNC void gen_cvt_ftoi(int t)
2694c105 bellard2001-12-17 21:56:48 +0000985{
664c19ad seyko2015-03-04 16:25:51 +0300986 #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;
1006 }
1007 */
4ad186c5 grischka2014-01-06 19:07:08 +01001008 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;
664c19ad seyko2015-03-04 16:25:51 +03001020 #endif
39173894 bellard2001-12-12 21:16:34 +00001021}
1022
2694c105 bellard2001-12-17 21:56:48 +00001023/* convert from one floating point type to another */
88a3ccab grischka2009-12-20 01:53:49 +01001024ST_FUNC void gen_cvt_ftof(int t)
2694c105 bellard2001-12-17 21:56:48 +00001025{
1026 /* all we have to do on i386 is to put the float in a register */
21c35b94 bellard2001-12-23 00:34:26 +00001027 gv(RC_FLOAT);
2694c105 bellard2001-12-17 21:56:48 +00001028}
1029
fde824b7 bellard2002-11-03 00:43:01 +00001030/* computed goto support */
88a3ccab grischka2009-12-20 01:53:49 +01001031ST_FUNC void ggoto(void)
fde824b7 bellard2002-11-03 00:43:01 +00001032{
1033 gcall_or_jmp(1);
1034 vtop--;
1035}
1036
b7fed2f2 bellard2002-01-05 16:17:34 +00001037/* bound check support functions */
4226681d bellard2002-03-03 22:45:55 +00001038#ifdef CONFIG_TCC_BCHECK
264dbcfe bellard2002-07-13 15:55:16 +00001039
1040/* generate a bounded pointer addition */
88a3ccab grischka2009-12-20 01:53:49 +01001041ST_FUNC void gen_bounded_ptr_add(void)
b7fed2f2 bellard2002-01-05 16:17:34 +00001042{
1043 /* prepare fast i386 function call (args in eax and edx) */
1044 gv2(RC_EAX, RC_EDX);
1045 /* save all temporary registers */
264dbcfe bellard2002-07-13 15:55:16 +00001046 vtop -= 2;
1047 save_regs(0);
1048 /* do a fast function call */
73faaea2 grischka2013-08-28 22:55:05 +02001049 gen_static_call(TOK___bound_ptr_add);
264dbcfe bellard2002-07-13 15:55:16 +00001050 /* returned pointer is in eax */
1051 vtop++;
b5259da4 bellard2002-12-08 14:34:48 +00001052 vtop->r = TREG_EAX | VT_BOUNDED;
6cdecbe4 bellard2002-07-22 23:37:39 +00001053 /* address of bounding function call point */
a42941b1 bellard2002-07-27 14:06:11 +00001054 vtop->c.ul = (cur_text_section->reloc->data_offset - sizeof(Elf32_Rel));
b7fed2f2 bellard2002-01-05 16:17:34 +00001055}
1056
264dbcfe bellard2002-07-13 15:55:16 +00001057/* patch pointer addition in vtop so that pointer dereferencing is
1058 also tested */
88a3ccab grischka2009-12-20 01:53:49 +01001059ST_FUNC void gen_bounded_ptr_deref(void)
b7fed2f2 bellard2002-01-05 16:17:34 +00001060{
acef4ff2 seyko2015-03-26 07:47:45 +03001061 addr_t func;
1062 addr_t size, align;
6cdecbe4 bellard2002-07-22 23:37:39 +00001063 Elf32_Rel *rel;
1064 Sym *sym;
264dbcfe bellard2002-07-13 15:55:16 +00001065
1066 size = 0;
1067 /* XXX: put that code in generic part of tcc */
9620fd18 bellard2002-11-18 21:46:44 +00001068 if (!is_float(vtop->type.t)) {
264dbcfe bellard2002-07-13 15:55:16 +00001069 if (vtop->r & VT_LVAL_BYTE)
1070 size = 1;
1071 else if (vtop->r & VT_LVAL_SHORT)
1072 size = 2;
1073 }
1074 if (!size)
9620fd18 bellard2002-11-18 21:46:44 +00001075 size = type_size(&vtop->type, &align);
264dbcfe bellard2002-07-13 15:55:16 +00001076 switch(size) {
6cdecbe4 bellard2002-07-22 23:37:39 +00001077 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;
264dbcfe bellard2002-07-13 15:55:16 +00001083 default:
9c25ed13 Thomas Preud'homme2012-01-08 17:58:19 +01001084 tcc_error("unhandled size when dereferencing bounded pointer");
6cdecbe4 bellard2002-07-22 23:37:39 +00001085 func = 0;
264dbcfe bellard2002-07-13 15:55:16 +00001086 break;
b7fed2f2 bellard2002-01-05 16:17:34 +00001087 }
1088
6cdecbe4 bellard2002-07-22 23:37:39 +00001089 /* patch relocation */
1090 /* XXX: find a better solution ? */
a42941b1 bellard2002-07-27 14:06:11 +00001091 rel = (Elf32_Rel *)(cur_text_section->reloc->data + vtop->c.ul);
9620fd18 bellard2002-11-18 21:46:44 +00001092 sym = external_global_sym(func, &func_old_type, 0);
6cdecbe4 bellard2002-07-22 23:37:39 +00001093 if (!sym->c)
4c9c0ab1 bellard2002-07-27 23:08:29 +00001094 put_extern_sym(sym, NULL, 0, 0);
6cdecbe4 bellard2002-07-22 23:37:39 +00001095 rel->r_info = ELF32_R_INFO(sym->c, ELF32_R_TYPE(rel->r_info));
b7fed2f2 bellard2002-01-05 16:17:34 +00001096}
4226681d bellard2002-03-03 22:45:55 +00001097#endif
b7fed2f2 bellard2002-01-05 16:17:34 +00001098
41b3c7a5
JL
James Lyon2013-04-27 20:39:34 +01001099/* Save the stack pointer onto the stack */
1100ST_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);
1104}
1105
1106/* Restore the SP from a location on the stack */
1107ST_FUNC void gen_vla_sp_restore(int addr) {
1108 o(0x8b);
1109 gen_modrm(TREG_ESP, VT_LOCAL, NULL, addr);
1110}
1111
1112/* Subtract from the stack pointer, and push the resulting value onto the stack */
1113ST_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 vset(type, REG_IRET, 0);
1120#else
1121 int r;
1122 r = gv(RC_INT); /* allocation size */
1123 /* sub r,%rsp */
1124 o(0x2b);
1125 o(0xe0 | r);
1126 /* We align to 16 bytes rather than align */
1127 /* and ~15, %esp */
1128 o(0xf0e483);
41b3c7a5 James Lyon2013-04-27 20:39:34 +01001129 vpop();
41b3c7a5
JL
James Lyon2013-04-27 20:39:34 +01001130#endif
1131}
1132
39173894 bellard2001-12-12 21:16:34 +00001133/* end of X86 code generator */
1134/*************************************************************/
88a3ccab grischka2009-12-20 01:53:49 +01001135#endif
1136/*************************************************************/