Correctly align and reclaim stack at function call
[tinycc.git] / arm-gen.c
blobab7b0bea50f78dc8e059f25258b13d8d7c5fe0ae
1 /*
2 * ARMv4 code generator for TCC
4 * Copyright (c) 2003 Daniel Glöckner
5 * Copyright (c) 2012 Thomas Preud'homme
7 * Based on i386-gen.c by Fabrice Bellard
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2 of the License, or (at your option) any later version.
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 #ifdef TARGET_DEFS_ONLY
26 #ifdef TCC_ARM_EABI
27 #ifndef TCC_ARM_VFP /* Avoid useless warning */
28 #define TCC_ARM_VFP
29 #endif
30 #endif
32 /* number of available registers */
33 #ifdef TCC_ARM_VFP
34 #define NB_REGS 13
35 #else
36 #define NB_REGS 9
37 #endif
39 #ifndef TCC_ARM_VERSION
40 # define TCC_ARM_VERSION 5
41 #endif
43 /* a register can belong to several classes. The classes must be
44 sorted from more general to more precise (see gv2() code which does
45 assumptions on it). */
46 #define RC_INT 0x0001 /* generic integer register */
47 #define RC_FLOAT 0x0002 /* generic float register */
48 #define RC_R0 0x0004
49 #define RC_R1 0x0008
50 #define RC_R2 0x0010
51 #define RC_R3 0x0020
52 #define RC_R12 0x0040
53 #define RC_F0 0x0080
54 #define RC_F1 0x0100
55 #define RC_F2 0x0200
56 #define RC_F3 0x0400
57 #ifdef TCC_ARM_VFP
58 #define RC_F4 0x0800
59 #define RC_F5 0x1000
60 #define RC_F6 0x2000
61 #define RC_F7 0x4000
62 #endif
63 #define RC_IRET RC_R0 /* function return: integer register */
64 #define RC_LRET RC_R1 /* function return: second integer register */
65 #define RC_FRET RC_F0 /* function return: float register */
67 /* pretty names for the registers */
68 enum {
69 TREG_R0 = 0,
70 TREG_R1,
71 TREG_R2,
72 TREG_R3,
73 TREG_R12,
74 TREG_F0,
75 TREG_F1,
76 TREG_F2,
77 TREG_F3,
78 #ifdef TCC_ARM_VFP
79 TREG_F4,
80 TREG_F5,
81 TREG_F6,
82 TREG_F7,
83 #endif
86 #ifdef TCC_ARM_VFP
87 #define T2CPR(t) (((t) & VT_BTYPE) != VT_FLOAT ? 0x100 : 0)
88 #endif
90 /* return registers for function */
91 #define REG_IRET TREG_R0 /* single word int return register */
92 #define REG_LRET TREG_R1 /* second word return register (for long long) */
93 #define REG_FRET TREG_F0 /* float return register */
95 #ifdef TCC_ARM_EABI
96 #define TOK___divdi3 TOK___aeabi_ldivmod
97 #define TOK___moddi3 TOK___aeabi_ldivmod
98 #define TOK___udivdi3 TOK___aeabi_uldivmod
99 #define TOK___umoddi3 TOK___aeabi_uldivmod
100 #endif
102 /* defined if function parameters must be evaluated in reverse order */
103 #define INVERT_FUNC_PARAMS
105 /* defined if structures are passed as pointers. Otherwise structures
106 are directly pushed on stack. */
107 /* #define FUNC_STRUCT_PARAM_AS_PTR */
109 /* pointer size, in bytes */
110 #define PTR_SIZE 4
112 /* long double size and alignment, in bytes */
113 #ifdef TCC_ARM_VFP
114 #define LDOUBLE_SIZE 8
115 #endif
117 #ifndef LDOUBLE_SIZE
118 #define LDOUBLE_SIZE 8
119 #endif
121 #ifdef TCC_ARM_EABI
122 #define LDOUBLE_ALIGN 8
123 #else
124 #define LDOUBLE_ALIGN 4
125 #endif
127 /* maximum alignment (for aligned attribute support) */
128 #define MAX_ALIGN 8
130 #define CHAR_IS_UNSIGNED
132 /******************************************************/
133 /* ELF defines */
135 #define EM_TCC_TARGET EM_ARM
137 /* relocation type for 32 bit data relocation */
138 #define R_DATA_32 R_ARM_ABS32
139 #define R_DATA_PTR R_ARM_ABS32
140 #define R_JMP_SLOT R_ARM_JUMP_SLOT
141 #define R_COPY R_ARM_COPY
143 #define ELF_START_ADDR 0x00008000
144 #define ELF_PAGE_SIZE 0x1000
146 /******************************************************/
147 #else /* ! TARGET_DEFS_ONLY */
148 /******************************************************/
149 #include "tcc.h"
151 ST_DATA const int reg_classes[NB_REGS] = {
152 /* r0 */ RC_INT | RC_R0,
153 /* r1 */ RC_INT | RC_R1,
154 /* r2 */ RC_INT | RC_R2,
155 /* r3 */ RC_INT | RC_R3,
156 /* r12 */ RC_INT | RC_R12,
157 /* f0 */ RC_FLOAT | RC_F0,
158 /* f1 */ RC_FLOAT | RC_F1,
159 /* f2 */ RC_FLOAT | RC_F2,
160 /* f3 */ RC_FLOAT | RC_F3,
161 #ifdef TCC_ARM_VFP
162 /* d4/s8 */ RC_FLOAT | RC_F4,
163 /* d5/s10 */ RC_FLOAT | RC_F5,
164 /* d6/s12 */ RC_FLOAT | RC_F6,
165 /* d7/s14 */ RC_FLOAT | RC_F7,
166 #endif
169 static int func_sub_sp_offset, last_itod_magic;
170 static int leaffunc;
172 #if defined(TCC_ARM_EABI) && defined(TCC_ARM_VFP)
173 static CType float_type, double_type, func_float_type, func_double_type;
174 ST_FUNC void arm_init_types(void)
176 float_type.t = VT_FLOAT;
177 double_type.t = VT_DOUBLE;
178 func_float_type.t = VT_FUNC;
179 func_float_type.ref = sym_push(SYM_FIELD, &float_type, FUNC_CDECL, FUNC_OLD);
180 func_double_type.t = VT_FUNC;
181 func_double_type.ref = sym_push(SYM_FIELD, &double_type, FUNC_CDECL, FUNC_OLD);
183 #else
184 #define func_float_type func_old_type
185 #define func_double_type func_old_type
186 #define func_ldouble_type func_old_type
187 ST_FUNC void arm_init_types(void) {}
188 #endif
190 static int two2mask(int a,int b) {
191 return (reg_classes[a]|reg_classes[b])&~(RC_INT|RC_FLOAT);
194 static int regmask(int r) {
195 return reg_classes[r]&~(RC_INT|RC_FLOAT);
198 /******************************************************/
200 void o(uint32_t i)
202 /* this is a good place to start adding big-endian support*/
203 int ind1;
205 ind1 = ind + 4;
206 if (!cur_text_section)
207 tcc_error("compiler error! This happens f.ex. if the compiler\n"
208 "can't evaluate constant expressions outside of a function.");
209 if (ind1 > cur_text_section->data_allocated)
210 section_realloc(cur_text_section, ind1);
211 cur_text_section->data[ind++] = i&255;
212 i>>=8;
213 cur_text_section->data[ind++] = i&255;
214 i>>=8;
215 cur_text_section->data[ind++] = i&255;
216 i>>=8;
217 cur_text_section->data[ind++] = i;
220 static uint32_t stuff_const(uint32_t op, uint32_t c)
222 int try_neg=0;
223 uint32_t nc = 0, negop = 0;
225 switch(op&0x1F00000)
227 case 0x800000: //add
228 case 0x400000: //sub
229 try_neg=1;
230 negop=op^0xC00000;
231 nc=-c;
232 break;
233 case 0x1A00000: //mov
234 case 0x1E00000: //mvn
235 try_neg=1;
236 negop=op^0x400000;
237 nc=~c;
238 break;
239 case 0x200000: //xor
240 if(c==~0)
241 return (op&0xF010F000)|((op>>16)&0xF)|0x1E00000;
242 break;
243 case 0x0: //and
244 if(c==~0)
245 return (op&0xF010F000)|((op>>16)&0xF)|0x1A00000;
246 case 0x1C00000: //bic
247 try_neg=1;
248 negop=op^0x1C00000;
249 nc=~c;
250 break;
251 case 0x1800000: //orr
252 if(c==~0)
253 return (op&0xFFF0FFFF)|0x1E00000;
254 break;
256 do {
257 uint32_t m;
258 int i;
259 if(c<256) /* catch undefined <<32 */
260 return op|c;
261 for(i=2;i<32;i+=2) {
262 m=(0xff>>i)|(0xff<<(32-i));
263 if(!(c&~m))
264 return op|(i<<7)|(c<<i)|(c>>(32-i));
266 op=negop;
267 c=nc;
268 } while(try_neg--);
269 return 0;
273 //only add,sub
274 void stuff_const_harder(uint32_t op, uint32_t v) {
275 uint32_t x;
276 x=stuff_const(op,v);
277 if(x)
278 o(x);
279 else {
280 uint32_t a[16], nv, no, o2, n2;
281 int i,j,k;
282 a[0]=0xff;
283 o2=(op&0xfff0ffff)|((op&0xf000)<<4);;
284 for(i=1;i<16;i++)
285 a[i]=(a[i-1]>>2)|(a[i-1]<<30);
286 for(i=0;i<12;i++)
287 for(j=i<4?i+12:15;j>=i+4;j--)
288 if((v&(a[i]|a[j]))==v) {
289 o(stuff_const(op,v&a[i]));
290 o(stuff_const(o2,v&a[j]));
291 return;
293 no=op^0xC00000;
294 n2=o2^0xC00000;
295 nv=-v;
296 for(i=0;i<12;i++)
297 for(j=i<4?i+12:15;j>=i+4;j--)
298 if((nv&(a[i]|a[j]))==nv) {
299 o(stuff_const(no,nv&a[i]));
300 o(stuff_const(n2,nv&a[j]));
301 return;
303 for(i=0;i<8;i++)
304 for(j=i+4;j<12;j++)
305 for(k=i<4?i+12:15;k>=j+4;k--)
306 if((v&(a[i]|a[j]|a[k]))==v) {
307 o(stuff_const(op,v&a[i]));
308 o(stuff_const(o2,v&a[j]));
309 o(stuff_const(o2,v&a[k]));
310 return;
312 no=op^0xC00000;
313 nv=-v;
314 for(i=0;i<8;i++)
315 for(j=i+4;j<12;j++)
316 for(k=i<4?i+12:15;k>=j+4;k--)
317 if((nv&(a[i]|a[j]|a[k]))==nv) {
318 o(stuff_const(no,nv&a[i]));
319 o(stuff_const(n2,nv&a[j]));
320 o(stuff_const(n2,nv&a[k]));
321 return;
323 o(stuff_const(op,v&a[0]));
324 o(stuff_const(o2,v&a[4]));
325 o(stuff_const(o2,v&a[8]));
326 o(stuff_const(o2,v&a[12]));
330 ST_FUNC uint32_t encbranch(int pos, int addr, int fail)
332 addr-=pos+8;
333 addr/=4;
334 if(addr>=0x1000000 || addr<-0x1000000) {
335 if(fail)
336 tcc_error("FIXME: function bigger than 32MB");
337 return 0;
339 return 0x0A000000|(addr&0xffffff);
342 int decbranch(int pos)
344 int x;
345 x=*(uint32_t *)(cur_text_section->data + pos);
346 x&=0x00ffffff;
347 if(x&0x800000)
348 x-=0x1000000;
349 return x*4+pos+8;
352 /* output a symbol and patch all calls to it */
353 void gsym_addr(int t, int a)
355 uint32_t *x;
356 int lt;
357 while(t) {
358 x=(uint32_t *)(cur_text_section->data + t);
359 t=decbranch(lt=t);
360 if(a==lt+4)
361 *x=0xE1A00000; // nop
362 else {
363 *x &= 0xff000000;
364 *x |= encbranch(lt,a,1);
369 void gsym(int t)
371 gsym_addr(t, ind);
374 #ifdef TCC_ARM_VFP
375 static uint32_t vfpr(int r)
377 if(r<TREG_F0 || r>TREG_F7)
378 tcc_error("compiler error! register %i is no vfp register",r);
379 return r-5;
381 #else
382 static uint32_t fpr(int r)
384 if(r<TREG_F0 || r>TREG_F3)
385 tcc_error("compiler error! register %i is no fpa register",r);
386 return r-5;
388 #endif
390 static uint32_t intr(int r)
392 if(r==4)
393 return 12;
394 if((r<0 || r>4) && r!=14)
395 tcc_error("compiler error! register %i is no int register",r);
396 return r;
399 static void calcaddr(uint32_t *base, int *off, int *sgn, int maxoff, unsigned shift)
401 if(*off>maxoff || *off&((1<<shift)-1)) {
402 uint32_t x, y;
403 x=0xE280E000;
404 if(*sgn)
405 x=0xE240E000;
406 x|=(*base)<<16;
407 *base=14; // lr
408 y=stuff_const(x,*off&~maxoff);
409 if(y) {
410 o(y);
411 *off&=maxoff;
412 return;
414 y=stuff_const(x,(*off+maxoff)&~maxoff);
415 if(y) {
416 o(y);
417 *sgn=!*sgn;
418 *off=((*off+maxoff)&~maxoff)-*off;
419 return;
421 stuff_const_harder(x,*off&~maxoff);
422 *off&=maxoff;
426 static uint32_t mapcc(int cc)
428 switch(cc)
430 case TOK_ULT:
431 return 0x30000000; /* CC/LO */
432 case TOK_UGE:
433 return 0x20000000; /* CS/HS */
434 case TOK_EQ:
435 return 0x00000000; /* EQ */
436 case TOK_NE:
437 return 0x10000000; /* NE */
438 case TOK_ULE:
439 return 0x90000000; /* LS */
440 case TOK_UGT:
441 return 0x80000000; /* HI */
442 case TOK_Nset:
443 return 0x40000000; /* MI */
444 case TOK_Nclear:
445 return 0x50000000; /* PL */
446 case TOK_LT:
447 return 0xB0000000; /* LT */
448 case TOK_GE:
449 return 0xA0000000; /* GE */
450 case TOK_LE:
451 return 0xD0000000; /* LE */
452 case TOK_GT:
453 return 0xC0000000; /* GT */
455 tcc_error("unexpected condition code");
456 return 0xE0000000; /* AL */
459 static int negcc(int cc)
461 switch(cc)
463 case TOK_ULT:
464 return TOK_UGE;
465 case TOK_UGE:
466 return TOK_ULT;
467 case TOK_EQ:
468 return TOK_NE;
469 case TOK_NE:
470 return TOK_EQ;
471 case TOK_ULE:
472 return TOK_UGT;
473 case TOK_UGT:
474 return TOK_ULE;
475 case TOK_Nset:
476 return TOK_Nclear;
477 case TOK_Nclear:
478 return TOK_Nset;
479 case TOK_LT:
480 return TOK_GE;
481 case TOK_GE:
482 return TOK_LT;
483 case TOK_LE:
484 return TOK_GT;
485 case TOK_GT:
486 return TOK_LE;
488 tcc_error("unexpected condition code");
489 return TOK_NE;
492 /* load 'r' from value 'sv' */
493 void load(int r, SValue *sv)
495 int v, ft, fc, fr, sign;
496 uint32_t op;
497 SValue v1;
499 fr = sv->r;
500 ft = sv->type.t;
501 fc = sv->c.ul;
503 if(fc>=0)
504 sign=0;
505 else {
506 sign=1;
507 fc=-fc;
510 v = fr & VT_VALMASK;
511 if (fr & VT_LVAL) {
512 uint32_t base = 0xB; // fp
513 if(v == VT_LLOCAL) {
514 v1.type.t = VT_PTR;
515 v1.r = VT_LOCAL | VT_LVAL;
516 v1.c.ul = sv->c.ul;
517 load(base=14 /* lr */, &v1);
518 fc=sign=0;
519 v=VT_LOCAL;
520 } else if(v == VT_CONST) {
521 v1.type.t = VT_PTR;
522 v1.r = fr&~VT_LVAL;
523 v1.c.ul = sv->c.ul;
524 v1.sym=sv->sym;
525 load(base=14, &v1);
526 fc=sign=0;
527 v=VT_LOCAL;
528 } else if(v < VT_CONST) {
529 base=intr(v);
530 fc=sign=0;
531 v=VT_LOCAL;
533 if(v == VT_LOCAL) {
534 if(is_float(ft)) {
535 calcaddr(&base,&fc,&sign,1020,2);
536 #ifdef TCC_ARM_VFP
537 op=0xED100A00; /* flds */
538 if(!sign)
539 op|=0x800000;
540 if ((ft & VT_BTYPE) != VT_FLOAT)
541 op|=0x100; /* flds -> fldd */
542 o(op|(vfpr(r)<<12)|(fc>>2)|(base<<16));
543 #else
544 op=0xED100100;
545 if(!sign)
546 op|=0x800000;
547 #if LDOUBLE_SIZE == 8
548 if ((ft & VT_BTYPE) != VT_FLOAT)
549 op|=0x8000;
550 #else
551 if ((ft & VT_BTYPE) == VT_DOUBLE)
552 op|=0x8000;
553 else if ((ft & VT_BTYPE) == VT_LDOUBLE)
554 op|=0x400000;
555 #endif
556 o(op|(fpr(r)<<12)|(fc>>2)|(base<<16));
557 #endif
558 } else if((ft & (VT_BTYPE|VT_UNSIGNED)) == VT_BYTE
559 || (ft & VT_BTYPE) == VT_SHORT) {
560 calcaddr(&base,&fc,&sign,255,0);
561 op=0xE1500090;
562 if ((ft & VT_BTYPE) == VT_SHORT)
563 op|=0x20;
564 if ((ft & VT_UNSIGNED) == 0)
565 op|=0x40;
566 if(!sign)
567 op|=0x800000;
568 o(op|(intr(r)<<12)|(base<<16)|((fc&0xf0)<<4)|(fc&0xf));
569 } else {
570 calcaddr(&base,&fc,&sign,4095,0);
571 op=0xE5100000;
572 if(!sign)
573 op|=0x800000;
574 if ((ft & VT_BTYPE) == VT_BYTE || (ft & VT_BTYPE) == VT_BOOL)
575 op|=0x400000;
576 o(op|(intr(r)<<12)|fc|(base<<16));
578 return;
580 } else {
581 if (v == VT_CONST) {
582 op=stuff_const(0xE3A00000|(intr(r)<<12),sv->c.ul);
583 if (fr & VT_SYM || !op) {
584 o(0xE59F0000|(intr(r)<<12));
585 o(0xEA000000);
586 if(fr & VT_SYM)
587 greloc(cur_text_section, sv->sym, ind, R_ARM_ABS32);
588 o(sv->c.ul);
589 } else
590 o(op);
591 return;
592 } else if (v == VT_LOCAL) {
593 op=stuff_const(0xE28B0000|(intr(r)<<12),sv->c.ul);
594 if (fr & VT_SYM || !op) {
595 o(0xE59F0000|(intr(r)<<12));
596 o(0xEA000000);
597 if(fr & VT_SYM) // needed ?
598 greloc(cur_text_section, sv->sym, ind, R_ARM_ABS32);
599 o(sv->c.ul);
600 o(0xE08B0000|(intr(r)<<12)|intr(r));
601 } else
602 o(op);
603 return;
604 } else if(v == VT_CMP) {
605 o(mapcc(sv->c.ul)|0x3A00001|(intr(r)<<12));
606 o(mapcc(negcc(sv->c.ul))|0x3A00000|(intr(r)<<12));
607 return;
608 } else if (v == VT_JMP || v == VT_JMPI) {
609 int t;
610 t = v & 1;
611 o(0xE3A00000|(intr(r)<<12)|t);
612 o(0xEA000000);
613 gsym(sv->c.ul);
614 o(0xE3A00000|(intr(r)<<12)|(t^1));
615 return;
616 } else if (v < VT_CONST) {
617 if(is_float(ft))
618 #ifdef TCC_ARM_VFP
619 o(0xEEB00A40|(vfpr(r)<<12)|vfpr(v)|T2CPR(ft)); /* fcpyX */
620 #else
621 o(0xEE008180|(fpr(r)<<12)|fpr(v));
622 #endif
623 else
624 o(0xE1A00000|(intr(r)<<12)|intr(v));
625 return;
628 tcc_error("load unimplemented!");
631 /* store register 'r' in lvalue 'v' */
632 void store(int r, SValue *sv)
634 SValue v1;
635 int v, ft, fc, fr, sign;
636 uint32_t op;
638 fr = sv->r;
639 ft = sv->type.t;
640 fc = sv->c.ul;
642 if(fc>=0)
643 sign=0;
644 else {
645 sign=1;
646 fc=-fc;
649 v = fr & VT_VALMASK;
650 if (fr & VT_LVAL || fr == VT_LOCAL) {
651 uint32_t base = 0xb;
652 if(v < VT_CONST) {
653 base=intr(v);
654 v=VT_LOCAL;
655 fc=sign=0;
656 } else if(v == VT_CONST) {
657 v1.type.t = ft;
658 v1.r = fr&~VT_LVAL;
659 v1.c.ul = sv->c.ul;
660 v1.sym=sv->sym;
661 load(base=14, &v1);
662 fc=sign=0;
663 v=VT_LOCAL;
665 if(v == VT_LOCAL) {
666 if(is_float(ft)) {
667 calcaddr(&base,&fc,&sign,1020,2);
668 #ifdef TCC_ARM_VFP
669 op=0xED000A00; /* fsts */
670 if(!sign)
671 op|=0x800000;
672 if ((ft & VT_BTYPE) != VT_FLOAT)
673 op|=0x100; /* fsts -> fstd */
674 o(op|(vfpr(r)<<12)|(fc>>2)|(base<<16));
675 #else
676 op=0xED000100;
677 if(!sign)
678 op|=0x800000;
679 #if LDOUBLE_SIZE == 8
680 if ((ft & VT_BTYPE) != VT_FLOAT)
681 op|=0x8000;
682 #else
683 if ((ft & VT_BTYPE) == VT_DOUBLE)
684 op|=0x8000;
685 if ((ft & VT_BTYPE) == VT_LDOUBLE)
686 op|=0x400000;
687 #endif
688 o(op|(fpr(r)<<12)|(fc>>2)|(base<<16));
689 #endif
690 return;
691 } else if((ft & VT_BTYPE) == VT_SHORT) {
692 calcaddr(&base,&fc,&sign,255,0);
693 op=0xE14000B0;
694 if(!sign)
695 op|=0x800000;
696 o(op|(intr(r)<<12)|(base<<16)|((fc&0xf0)<<4)|(fc&0xf));
697 } else {
698 calcaddr(&base,&fc,&sign,4095,0);
699 op=0xE5000000;
700 if(!sign)
701 op|=0x800000;
702 if ((ft & VT_BTYPE) == VT_BYTE || (ft & VT_BTYPE) == VT_BOOL)
703 op|=0x400000;
704 o(op|(intr(r)<<12)|fc|(base<<16));
706 return;
709 tcc_error("store unimplemented");
712 static void gadd_sp(int val)
714 stuff_const_harder(0xE28DD000,val);
717 /* 'is_jmp' is '1' if it is a jump */
718 static void gcall_or_jmp(int is_jmp)
720 int r;
721 if ((vtop->r & (VT_VALMASK | VT_LVAL)) == VT_CONST) {
722 uint32_t x;
723 /* constant case */
724 x=encbranch(ind,ind+vtop->c.ul,0);
725 if(x) {
726 if (vtop->r & VT_SYM) {
727 /* relocation case */
728 greloc(cur_text_section, vtop->sym, ind, R_ARM_PC24);
729 } else
730 put_elf_reloc(symtab_section, cur_text_section, ind, R_ARM_PC24, 0);
731 o(x|(is_jmp?0xE0000000:0xE1000000));
732 } else {
733 if(!is_jmp)
734 o(0xE28FE004); // add lr,pc,#4
735 o(0xE51FF004); // ldr pc,[pc,#-4]
736 if (vtop->r & VT_SYM)
737 greloc(cur_text_section, vtop->sym, ind, R_ARM_ABS32);
738 o(vtop->c.ul);
740 } else {
741 /* otherwise, indirect call */
742 r = gv(RC_INT);
743 if(!is_jmp)
744 o(0xE1A0E00F); // mov lr,pc
745 o(0xE1A0F000|intr(r)); // mov pc,r
749 /* Return 1 if this function returns via an sret pointer, 0 otherwise */
750 ST_FUNC int gfunc_sret(CType *vt, CType *ret, int *ret_align) {
751 #ifdef TCC_ARM_EABI
752 int size, align;
753 size = type_size(vt, &align);
754 if (size > 4) {
755 return 1;
756 } else {
757 *ret_align = 4;
758 ret->ref = NULL;
759 ret->t = VT_INT;
760 return 0;
762 #else
763 return 1;
764 #endif
767 #ifdef TCC_ARM_HARDFLOAT
768 /* Return whether a structure is an homogeneous float aggregate or not.
769 The answer is true if all the elements of the structure are of the same
770 primitive float type and there is less than 4 elements.
772 type: the type corresponding to the structure to be tested */
773 static int is_hgen_float_aggr(CType *type)
775 if ((type->t & VT_BTYPE) == VT_STRUCT) {
776 struct Sym *ref;
777 int btype, nb_fields = 0;
779 ref = type->ref;
780 btype = ref->type.t & VT_BTYPE;
781 if (btype == VT_FLOAT || btype == VT_DOUBLE) {
782 for(; ref && btype == (ref->type.t & VT_BTYPE); ref = ref->next, nb_fields++);
783 return !ref && nb_fields <= 4;
786 return 0;
789 struct avail_regs {
790 signed char avail[3]; /* 3 holes max with only float and double alignments */
791 int first_hole; /* first available hole */
792 int last_hole; /* last available hole (none if equal to first_hole) */
793 int first_free_reg; /* next free register in the sequence, hole excluded */
796 #define AVAIL_REGS_INITIALIZER (struct avail_regs) { { 0, 0, 0}, 0, 0, 0 }
798 /* Find suitable registers for a VFP Co-Processor Register Candidate (VFP CPRC
799 param) according to the rules described in the procedure call standard for
800 the ARM architecture (AAPCS). If found, the registers are assigned to this
801 VFP CPRC parameter. Registers are allocated in sequence unless a hole exists
802 and the parameter is a single float.
804 avregs: opaque structure to keep track of available VFP co-processor regs
805 align: alignment contraints for the param, as returned by type_size()
806 size: size of the parameter, as returned by type_size() */
807 int assign_vfpreg(struct avail_regs *avregs, int align, int size)
809 int first_reg = 0;
811 if (avregs->first_free_reg == -1)
812 return -1;
813 if (align >> 3) { /* double alignment */
814 first_reg = avregs->first_free_reg;
815 /* alignment contraint not respected so use next reg and record hole */
816 if (first_reg & 1)
817 avregs->avail[avregs->last_hole++] = first_reg++;
818 } else { /* no special alignment (float or array of float) */
819 /* if single float and a hole is available, assign the param to it */
820 if (size == 4 && avregs->first_hole != avregs->last_hole)
821 return avregs->avail[avregs->first_hole++];
822 else
823 first_reg = avregs->first_free_reg;
825 if (first_reg + size / 4 <= 16) {
826 avregs->first_free_reg = first_reg + size / 4;
827 return first_reg;
829 avregs->first_free_reg = -1;
830 return -1;
832 #endif
834 /* Parameters are classified according to how they are copied to their final
835 destination for the function call. Because the copying is performed class
836 after class according to the order in the union below, it is important that
837 some constraints about the order of the members of this union are respected:
838 - CORE_STRUCT_CLASS must come after STACK_CLASS;
839 - CORE_CLASS must come after STACK_CLASS, CORE_STRUCT_CLASS and
840 VFP_STRUCT_CLASS;
841 - VFP_STRUCT_CLASS must come after VFP_CLASS.
842 See the comment for the main loop in copy_params() for the reason. */
843 enum reg_class {
844 STACK_CLASS = 0,
845 CORE_STRUCT_CLASS,
846 VFP_CLASS,
847 VFP_STRUCT_CLASS,
848 CORE_CLASS,
849 NB_CLASSES
852 struct param_plan {
853 int start; /* first reg or addr used depending on the class */
854 int end; /* last reg used or next free addr depending on the class */
855 SValue *sval; /* pointer to SValue on the value stack */
856 struct param_plan *prev; /* previous element in this class */
859 struct plan {
860 struct param_plan *pplans; /* array of all the param plans */
861 struct param_plan *clsplans[NB_CLASSES]; /* per class lists of param plans */
864 #define add_param_plan(plan,pplan,class) \
865 do { \
866 pplan.prev = plan->clsplans[class]; \
867 plan->pplans[plan ## _nb] = pplan; \
868 plan->clsplans[class] = &plan->pplans[plan ## _nb++]; \
869 } while(0)
871 /* Assign parameters to registers and stack with alignment according to the
872 rules in the procedure call standard for the ARM architecture (AAPCS).
873 The overall assignment is recorded in an array of per parameter structures
874 called parameter plans. The parameter plans are also further organized in a
875 number of linked lists, one per class of parameter (see the comment for the
876 definition of union reg_class).
878 nb_args: number of parameters of the function for which a call is generated
879 variadic: whether the function is a variadic function or not
880 plan: the structure where the overall assignment is recorded
881 todo: a bitmap that record which core registers hold a parameter
883 Returns the amount of stack space needed for parameter passing
885 Note: this function allocated an array in plan->pplans with tcc_malloc. It
886 is the responsability of the caller to free this array once used (ie not
887 before copy_params). */
888 static int assign_regs(int nb_args, int variadic, struct plan *plan, int *todo)
890 int i, size, align;
891 int ncrn /* next core register number */, nsaa /* next stacked argument address*/;
892 int plan_nb = 0;
893 struct param_plan pplan;
894 #ifdef TCC_ARM_HARDFLOAT
895 struct avail_regs avregs = AVAIL_REGS_INITIALIZER;
896 #endif
898 ncrn = nsaa = 0;
899 *todo = 0;
900 plan->pplans = tcc_malloc(nb_args * sizeof(*plan->pplans));
901 memset(plan->clsplans, 0, sizeof(plan->clsplans));
902 for(i = nb_args; i-- ;) {
903 int j, start_vfpreg = 0;
904 size = type_size(&vtop[-i].type, &align);
905 switch(vtop[-i].type.t & VT_BTYPE) {
906 case VT_STRUCT:
907 case VT_FLOAT:
908 case VT_DOUBLE:
909 case VT_LDOUBLE:
910 #ifdef TCC_ARM_HARDFLOAT
911 if (!variadic) {
912 int is_hfa = 0; /* Homogeneous float aggregate */
914 if (is_float(vtop[-i].type.t)
915 || (is_hfa = is_hgen_float_aggr(&vtop[-i].type))) {
916 int end_vfpreg;
918 start_vfpreg = assign_vfpreg(&avregs, align, size);
919 end_vfpreg = start_vfpreg + ((size - 1) >> 2);
920 if (start_vfpreg >= 0) {
921 pplan = (struct param_plan) {start_vfpreg, end_vfpreg, &vtop[-i]};
922 if (is_hfa)
923 add_param_plan(plan, pplan, VFP_STRUCT_CLASS);
924 else
925 add_param_plan(plan, pplan, VFP_CLASS);
926 continue;
927 } else
928 break;
931 #endif
932 ncrn = (ncrn + (align-1)/4) & -(align/4);
933 size = (size + 3) & -4;
934 if (ncrn + size/4 <= 4 || (ncrn < 4 && start_vfpreg != -1)) {
935 /* The parameter is allocated both in core register and on stack. As
936 * such, it can be of either class: it would either be the last of
937 * CORE_STRUCT_CLASS or the first of STACK_CLASS. */
938 for (j = ncrn; j < 4 && j < ncrn + size / 4; j++)
939 *todo|=(1<<j);
940 pplan = (struct param_plan) {ncrn, j, &vtop[-i]};
941 add_param_plan(plan, pplan, CORE_STRUCT_CLASS);
942 ncrn += size/4;
943 if (ncrn > 4)
944 nsaa = (ncrn - 4) * 4;
945 } else {
946 ncrn = 4;
947 break;
949 continue;
950 default:
951 if (ncrn < 4) {
952 int is_long = (vtop[-i].type.t & VT_BTYPE) == VT_LLONG;
954 if (is_long) {
955 ncrn = (ncrn + 1) & -2;
956 if (ncrn == 4)
957 break;
959 pplan = (struct param_plan) {ncrn, ncrn, &vtop[-i]};
960 ncrn++;
961 if (is_long)
962 pplan.end = ncrn++;
963 add_param_plan(plan, pplan, CORE_CLASS);
964 continue;
967 nsaa = (nsaa + (align - 1)) & ~(align - 1);
968 pplan = (struct param_plan) {nsaa, nsaa + size, &vtop[-i]};
969 add_param_plan(plan, pplan, STACK_CLASS);
970 nsaa += size; /* size already rounded up before */
972 return nsaa;
975 #undef add_param_plan
977 /* Copy parameters to their final destination (core reg, VFP reg or stack) for
978 function call.
980 nb_args: number of parameters the function take
981 plan: the overall assignment plan for parameters
982 todo: a bitmap indicating what core reg will hold a parameter */
983 static void copy_params(int nb_args, struct plan *plan, int todo)
985 int size, align, r, i;
986 struct param_plan *pplan;
988 /* Several constraints require parameters to be copied in a specific order:
989 - structures are copied to the stack before being loaded in a reg;
990 - floats loaded to an odd numbered VFP reg are first copied to the
991 preceding even numbered VFP reg and then moved to the next VFP reg.
993 It is thus important that:
994 - structures assigned to core regs must be copied after parameters
995 assigned to the stack but before structures assigned to VFP regs because
996 a structure can lie partly in core registers and partly on the stack;
997 - parameters assigned to the stack and all structures be copied before
998 parameters assigned to a core reg since copying a parameter to the stack
999 require using a core reg;
1000 - parameters assigned to VFP regs be copied before structures assigned to
1001 VFP regs as the copy might use an even numbered VFP reg that already
1002 holds part of a structure. */
1003 for(i = 0; i < NB_CLASSES; i++) {
1004 for(pplan = plan->clsplans[i]; pplan; pplan = pplan->prev) {
1005 vpushv(pplan->sval);
1006 pplan->sval->r = pplan->sval->r2 = VT_CONST; /* disable entry */
1007 switch(i) {
1008 case STACK_CLASS:
1009 case CORE_STRUCT_CLASS:
1010 case VFP_STRUCT_CLASS:
1011 if ((pplan->sval->type.t & VT_BTYPE) == VT_STRUCT) {
1012 size = type_size(&pplan->sval->type, &align);
1013 /* align to stack align size */
1014 size = (size + 3) & ~3;
1015 if (i == STACK_CLASS && pplan->prev)
1016 size += pplan->start - pplan->prev->end; /* Add padding if any */
1017 /* allocate the necessary size on stack */
1018 gadd_sp(-size);
1019 /* generate structure store */
1020 r = get_reg(RC_INT);
1021 o(0xE1A0000D|(intr(r)<<12)); /* mov r, sp */
1022 vset(&vtop->type, r | VT_LVAL, 0);
1023 vswap();
1024 vstore(); /* memcpy to current sp */
1025 /* Homogeneous float aggregate are loaded to VFP registers
1026 immediately since there is no way of loading data in multiple
1027 non consecutive VFP registers as what is done for other
1028 structures (see the use of todo). */
1029 if (i == VFP_STRUCT_CLASS) {
1030 int first = pplan->start, nb = pplan->end - first + 1;
1031 /* vpop.32 {pplan->start, ..., pplan->end} */
1032 o(0xECBD0A00|(first&1)<<22|(first>>1)<<12|nb);
1033 /* No need to write the register used to a SValue since VFP regs
1034 cannot be used for gcall_or_jmp */
1036 } else {
1037 if (is_float(pplan->sval->type.t)) {
1038 #ifdef TCC_ARM_VFP
1039 r = vfpr(gv(RC_FLOAT)) << 12;
1040 if ((pplan->sval->type.t & VT_BTYPE) == VT_FLOAT)
1041 size = 4;
1042 else {
1043 size = 8;
1044 r |= 0x101; /* vpush.32 -> vpush.64 */
1046 o(0xED2D0A01 + r); /* vpush */
1047 #else
1048 r = fpr(gv(RC_FLOAT)) << 12;
1049 if ((pplan->sval->type.t & VT_BTYPE) == VT_FLOAT)
1050 size = 4;
1051 else if ((pplan->sval->type.t & VT_BTYPE) == VT_DOUBLE)
1052 size = 8;
1053 else
1054 size = LDOUBLE_SIZE;
1056 if (size == 12)
1057 r |= 0x400000;
1058 else if(size == 8)
1059 r|=0x8000;
1061 o(0xED2D0100|r|(size>>2)); /* some kind of vpush for FPA */
1062 #endif
1063 } else {
1064 /* simple type (currently always same size) */
1065 /* XXX: implicit cast ? */
1066 size=4;
1067 if ((pplan->sval->type.t & VT_BTYPE) == VT_LLONG) {
1068 lexpand_nr();
1069 size = 8;
1070 r = gv(RC_INT);
1071 o(0xE52D0004|(intr(r)<<12)); /* push r */
1072 vtop--;
1074 r = gv(RC_INT);
1075 o(0xE52D0004|(intr(r)<<12)); /* push r */
1077 if (i == STACK_CLASS && pplan->prev)
1078 gadd_sp(pplan->prev->end - pplan->start); /* Add padding if any */
1080 break;
1082 case VFP_CLASS:
1083 gv(regmask(TREG_F0 + (pplan->start >> 1)));
1084 if (pplan->start & 1) { /* Must be in upper part of double register */
1085 o(0xEEF00A40|((pplan->start>>1)<<12)|(pplan->start>>1)); /* vmov.f32 s(n+1), sn */
1086 vtop->r = VT_CONST; /* avoid being saved on stack by gv for next float */
1088 break;
1090 case CORE_CLASS:
1091 if ((pplan->sval->type.t & VT_BTYPE) == VT_LLONG) {
1092 lexpand_nr();
1093 gv(regmask(pplan->end));
1094 pplan->sval->r2 = vtop->r;
1095 vtop--;
1097 gv(regmask(pplan->start));
1098 /* Mark register as used so that gcall_or_jmp use another one
1099 (regs >=4 are free as never used to pass parameters) */
1100 pplan->sval->r = vtop->r;
1101 break;
1103 vtop--;
1107 /* Manually free remaining registers since next parameters are loaded
1108 * manually, without the help of gv(int). */
1109 save_regs(nb_args);
1111 if(todo) {
1112 o(0xE8BD0000|todo); /* pop {todo} */
1113 for(pplan = plan->clsplans[CORE_STRUCT_CLASS]; pplan; pplan = pplan->prev) {
1114 pplan->sval->r = pplan->start;
1115 if ((pplan->sval->type.t & VT_BTYPE) == VT_LLONG)
1116 pplan->sval->r2 = pplan->end;
1121 /* Generate function call. The function address is pushed first, then
1122 all the parameters in call order. This functions pops all the
1123 parameters and the function address. */
1124 void gfunc_call(int nb_args)
1126 int align, r, args_size;
1127 int variadic;
1128 int todo;
1129 struct plan plan;
1131 variadic = (vtop[-nb_args].type.ref->c == FUNC_ELLIPSIS);
1132 /* cannot let cpu flags if other instruction are generated. Also avoid leaving
1133 VT_JMP anywhere except on the top of the stack because it would complicate
1134 the code generator. */
1135 r = vtop->r & VT_VALMASK;
1136 if (r == VT_CMP || (r & ~1) == VT_JMP)
1137 gv(RC_INT);
1138 #ifdef TCC_ARM_EABI
1139 /* return type is a struct so caller of gfunc_call (unary(void) in tccgen.c)
1140 assumed it had to be passed by a pointer. Since it's less than 4 bytes, we
1141 can actually pass it directly in a register. */
1142 if((vtop[-nb_args].type.ref->type.t & VT_BTYPE) == VT_STRUCT
1143 && type_size(&vtop[-nb_args].type.ref->type, &align) <= 4) {
1144 SValue tmp;
1145 tmp=vtop[-nb_args];
1146 vtop[-nb_args]=vtop[-nb_args+1];
1147 vtop[-nb_args+1]=tmp;
1148 --nb_args;
1150 #endif
1152 args_size = assign_regs(nb_args, variadic, &plan, &todo);
1154 #ifdef TCC_ARM_EABI
1155 if (args_size & 7) { /* Stack must be 8 byte aligned at fct call for EABI */
1156 args_size = (args_size + 7) & ~7;
1157 o(0xE24DD004); /* sub sp, sp, #4 */
1159 #endif
1161 copy_params(nb_args, &plan, todo);
1162 tcc_free(plan.pplans);
1164 /* Move fct SValue on top as required by gcall_or_jmp */
1165 vrotb(nb_args + 1);
1166 gcall_or_jmp(0);
1167 if (args_size)
1168 gadd_sp(args_size); /* pop all parameters passed on the stack */
1169 #ifdef TCC_ARM_EABI
1170 if((vtop->type.ref->type.t & VT_BTYPE) == VT_STRUCT
1171 && type_size(&vtop->type.ref->type, &align) <= 4) {
1172 store(REG_IRET,vtop-nb_args-1);
1173 nb_args++;
1175 #ifdef TCC_ARM_VFP
1176 #ifdef TCC_ARM_HARDFLOAT
1177 else if(variadic && is_float(vtop->type.ref->type.t)) {
1178 #else
1179 else if(is_float(vtop->type.ref->type.t)) {
1180 #endif
1181 if((vtop->type.ref->type.t & VT_BTYPE) == VT_FLOAT) {
1182 o(0xEE000A10); /*vmov s0, r0 */
1183 } else {
1184 o(0xEE000B10); /* vmov.32 d0[0], r0 */
1185 o(0xEE201B10); /* vmov.32 d0[1], r1 */
1188 #endif
1189 #endif
1190 vtop -= nb_args + 1; /* Pop all params and fct address from value stack */
1191 leaffunc = 0; /* we are calling a function, so we aren't in a leaf function */
1194 /* generate function prolog of type 't' */
1195 void gfunc_prolog(CType *func_type)
1197 Sym *sym,*sym2;
1198 int n,nf,size,align, variadic, struct_ret = 0;
1199 #ifdef TCC_ARM_HARDFLOAT
1200 struct avail_regs avregs = AVAIL_REGS_INITIALIZER;
1201 #endif
1203 sym = func_type->ref;
1204 func_vt = sym->type;
1206 n = nf = 0;
1207 variadic = (func_type->ref->c == FUNC_ELLIPSIS);
1208 if((func_vt.t & VT_BTYPE) == VT_STRUCT
1209 && type_size(&func_vt,&align) > 4)
1211 n++;
1212 struct_ret = 1;
1213 func_vc = 12; /* Offset from fp of the place to store the result */
1215 for(sym2=sym->next;sym2 && (n<4 || nf<16);sym2=sym2->next) {
1216 size = type_size(&sym2->type, &align);
1217 #ifdef TCC_ARM_HARDFLOAT
1218 if (!variadic && (is_float(sym2->type.t)
1219 || is_hgen_float_aggr(&sym2->type))) {
1220 int tmpnf = assign_vfpreg(&avregs, align, size) + 1;
1221 nf = (tmpnf > nf) ? tmpnf : nf;
1222 } else
1223 #endif
1224 if (n < 4)
1225 n += (size + 3) / 4;
1227 o(0xE1A0C00D); /* mov ip,sp */
1228 if(variadic)
1229 n=4;
1230 if(n) {
1231 if(n>4)
1232 n=4;
1233 #ifdef TCC_ARM_EABI
1234 n=(n+1)&-2;
1235 #endif
1236 o(0xE92D0000|((1<<n)-1)); /* save r0-r4 on stack if needed */
1238 if (nf) {
1239 if (nf>16)
1240 nf=16;
1241 nf=(nf+1)&-2; /* nf => HARDFLOAT => EABI */
1242 o(0xED2D0A00|nf); /* save s0-s15 on stack if needed */
1244 o(0xE92D5800); /* save fp, ip, lr */
1245 o(0xE1A0B00D); /* mov fp, sp */
1246 func_sub_sp_offset = ind;
1247 o(0xE1A00000); /* nop, leave space for stack adjustment in epilogue */
1249 int addr, pn = struct_ret, sn = 0; /* pn=core, sn=stack */
1251 #ifdef TCC_ARM_HARDFLOAT
1252 func_vc += nf * 4;
1253 avregs = AVAIL_REGS_INITIALIZER;
1254 #endif
1255 while ((sym = sym->next)) {
1256 CType *type;
1257 type = &sym->type;
1258 size = type_size(type, &align);
1259 size = (size + 3) >> 2;
1260 align = (align + 3) & ~3;
1261 #ifdef TCC_ARM_HARDFLOAT
1262 if (!variadic && (is_float(sym->type.t)
1263 || is_hgen_float_aggr(&sym->type))) {
1264 int fpn = assign_vfpreg(&avregs, align, size << 2);
1265 if (fpn >= 0) {
1266 addr = fpn * 4;
1267 } else
1268 goto from_stack;
1269 } else
1270 #endif
1271 if (pn < 4) {
1272 #ifdef TCC_ARM_EABI
1273 pn = (pn + (align-1)/4) & -(align/4);
1274 #endif
1275 addr = (nf + pn) * 4;
1276 pn += size;
1277 if (!sn && pn > 4)
1278 sn = (pn - 4);
1279 } else {
1280 #ifdef TCC_ARM_HARDFLOAT
1281 from_stack:
1282 #endif
1283 #ifdef TCC_ARM_EABI
1284 sn = (sn + (align-1)/4) & -(align/4);
1285 #endif
1286 addr = (n + nf + sn) * 4;
1287 sn += size;
1289 sym_push(sym->v & ~SYM_FIELD, type, VT_LOCAL | lvalue_type(type->t), addr+12);
1292 last_itod_magic=0;
1293 leaffunc = 1;
1294 loc = 0;
1297 /* generate function epilog */
1298 void gfunc_epilog(void)
1300 uint32_t x;
1301 int diff;
1302 #ifdef TCC_ARM_EABI
1303 /* Useless but harmless copy of the float result into main register(s) in case
1304 of variadic function in the hardfloat variant */
1305 if(is_float(func_vt.t)) {
1306 if((func_vt.t & VT_BTYPE) == VT_FLOAT)
1307 o(0xEE100A10); /* fmrs r0, s0 */
1308 else {
1309 o(0xEE100B10); /* fmrdl r0, d0 */
1310 o(0xEE301B10); /* fmrdh r1, d0 */
1313 #endif
1314 o(0xE89BA800); /* restore fp, sp, pc */
1315 diff = (-loc + 3) & -4;
1316 #ifdef TCC_ARM_EABI
1317 if(!leaffunc)
1318 diff = ((diff + 11) & -8) - 4;
1319 #endif
1320 if(diff > 0) {
1321 x=stuff_const(0xE24BD000, diff); /* sub sp,fp,# */
1322 if(x)
1323 *(uint32_t *)(cur_text_section->data + func_sub_sp_offset) = x;
1324 else {
1325 int addr;
1326 addr=ind;
1327 o(0xE59FC004); /* ldr ip,[pc+4] */
1328 o(0xE04BD00C); /* sub sp,fp,ip */
1329 o(0xE1A0F00E); /* mov pc,lr */
1330 o(diff);
1331 *(uint32_t *)(cur_text_section->data + func_sub_sp_offset) = 0xE1000000|encbranch(func_sub_sp_offset,addr,1);
1336 /* generate a jump to a label */
1337 int gjmp(int t)
1339 int r;
1340 r=ind;
1341 o(0xE0000000|encbranch(r,t,1));
1342 return r;
1345 /* generate a jump to a fixed address */
1346 void gjmp_addr(int a)
1348 gjmp(a);
1351 /* generate a test. set 'inv' to invert test. Stack entry is popped */
1352 int gtst(int inv, int t)
1354 int v, r;
1355 uint32_t op;
1356 v = vtop->r & VT_VALMASK;
1357 r=ind;
1358 if (v == VT_CMP) {
1359 op=mapcc(inv?negcc(vtop->c.i):vtop->c.i);
1360 op|=encbranch(r,t,1);
1361 o(op);
1362 t=r;
1363 } else if (v == VT_JMP || v == VT_JMPI) {
1364 if ((v & 1) == inv) {
1365 if(!vtop->c.i)
1366 vtop->c.i=t;
1367 else {
1368 uint32_t *x;
1369 int p,lp;
1370 if(t) {
1371 p = vtop->c.i;
1372 do {
1373 p = decbranch(lp=p);
1374 } while(p);
1375 x = (uint32_t *)(cur_text_section->data + lp);
1376 *x &= 0xff000000;
1377 *x |= encbranch(lp,t,1);
1379 t = vtop->c.i;
1381 } else {
1382 t = gjmp(t);
1383 gsym(vtop->c.i);
1385 } else {
1386 if (is_float(vtop->type.t)) {
1387 r=gv(RC_FLOAT);
1388 #ifdef TCC_ARM_VFP
1389 o(0xEEB50A40|(vfpr(r)<<12)|T2CPR(vtop->type.t)); /* fcmpzX */
1390 o(0xEEF1FA10); /* fmstat */
1391 #else
1392 o(0xEE90F118|(fpr(r)<<16));
1393 #endif
1394 vtop->r = VT_CMP;
1395 vtop->c.i = TOK_NE;
1396 return gtst(inv, t);
1397 } else if ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST) {
1398 /* constant jmp optimization */
1399 if ((vtop->c.i != 0) != inv)
1400 t = gjmp(t);
1401 } else {
1402 v = gv(RC_INT);
1403 o(0xE3300000|(intr(v)<<16));
1404 vtop->r = VT_CMP;
1405 vtop->c.i = TOK_NE;
1406 return gtst(inv, t);
1409 vtop--;
1410 return t;
1413 /* generate an integer binary operation */
1414 void gen_opi(int op)
1416 int c, func = 0;
1417 uint32_t opc = 0, r, fr;
1418 unsigned short retreg = REG_IRET;
1420 c=0;
1421 switch(op) {
1422 case '+':
1423 opc = 0x8;
1424 c=1;
1425 break;
1426 case TOK_ADDC1: /* add with carry generation */
1427 opc = 0x9;
1428 c=1;
1429 break;
1430 case '-':
1431 opc = 0x4;
1432 c=1;
1433 break;
1434 case TOK_SUBC1: /* sub with carry generation */
1435 opc = 0x5;
1436 c=1;
1437 break;
1438 case TOK_ADDC2: /* add with carry use */
1439 opc = 0xA;
1440 c=1;
1441 break;
1442 case TOK_SUBC2: /* sub with carry use */
1443 opc = 0xC;
1444 c=1;
1445 break;
1446 case '&':
1447 opc = 0x0;
1448 c=1;
1449 break;
1450 case '^':
1451 opc = 0x2;
1452 c=1;
1453 break;
1454 case '|':
1455 opc = 0x18;
1456 c=1;
1457 break;
1458 case '*':
1459 gv2(RC_INT, RC_INT);
1460 r = vtop[-1].r;
1461 fr = vtop[0].r;
1462 vtop--;
1463 o(0xE0000090|(intr(r)<<16)|(intr(r)<<8)|intr(fr));
1464 return;
1465 case TOK_SHL:
1466 opc = 0;
1467 c=2;
1468 break;
1469 case TOK_SHR:
1470 opc = 1;
1471 c=2;
1472 break;
1473 case TOK_SAR:
1474 opc = 2;
1475 c=2;
1476 break;
1477 case '/':
1478 case TOK_PDIV:
1479 func=TOK___divsi3;
1480 c=3;
1481 break;
1482 case TOK_UDIV:
1483 func=TOK___udivsi3;
1484 c=3;
1485 break;
1486 case '%':
1487 #ifdef TCC_ARM_EABI
1488 func=TOK___aeabi_idivmod;
1489 retreg=REG_LRET;
1490 #else
1491 func=TOK___modsi3;
1492 #endif
1493 c=3;
1494 break;
1495 case TOK_UMOD:
1496 #ifdef TCC_ARM_EABI
1497 func=TOK___aeabi_uidivmod;
1498 retreg=REG_LRET;
1499 #else
1500 func=TOK___umodsi3;
1501 #endif
1502 c=3;
1503 break;
1504 case TOK_UMULL:
1505 gv2(RC_INT, RC_INT);
1506 r=intr(vtop[-1].r2=get_reg(RC_INT));
1507 c=vtop[-1].r;
1508 vtop[-1].r=get_reg_ex(RC_INT,regmask(c));
1509 vtop--;
1510 o(0xE0800090|(r<<16)|(intr(vtop->r)<<12)|(intr(c)<<8)|intr(vtop[1].r));
1511 return;
1512 default:
1513 opc = 0x15;
1514 c=1;
1515 break;
1517 switch(c) {
1518 case 1:
1519 if((vtop[-1].r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST) {
1520 if(opc == 4 || opc == 5 || opc == 0xc) {
1521 vswap();
1522 opc|=2; // sub -> rsb
1525 if ((vtop->r & VT_VALMASK) == VT_CMP ||
1526 (vtop->r & (VT_VALMASK & ~1)) == VT_JMP)
1527 gv(RC_INT);
1528 vswap();
1529 c=intr(gv(RC_INT));
1530 vswap();
1531 opc=0xE0000000|(opc<<20)|(c<<16);
1532 if((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST) {
1533 uint32_t x;
1534 x=stuff_const(opc|0x2000000,vtop->c.i);
1535 if(x) {
1536 r=intr(vtop[-1].r=get_reg_ex(RC_INT,regmask(vtop[-1].r)));
1537 o(x|(r<<12));
1538 goto done;
1541 fr=intr(gv(RC_INT));
1542 r=intr(vtop[-1].r=get_reg_ex(RC_INT,two2mask(vtop->r,vtop[-1].r)));
1543 o(opc|(r<<12)|fr);
1544 done:
1545 vtop--;
1546 if (op >= TOK_ULT && op <= TOK_GT) {
1547 vtop->r = VT_CMP;
1548 vtop->c.i = op;
1550 break;
1551 case 2:
1552 opc=0xE1A00000|(opc<<5);
1553 if ((vtop->r & VT_VALMASK) == VT_CMP ||
1554 (vtop->r & (VT_VALMASK & ~1)) == VT_JMP)
1555 gv(RC_INT);
1556 vswap();
1557 r=intr(gv(RC_INT));
1558 vswap();
1559 opc|=r;
1560 if ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST) {
1561 fr=intr(vtop[-1].r=get_reg_ex(RC_INT,regmask(vtop[-1].r)));
1562 c = vtop->c.i & 0x1f;
1563 o(opc|(c<<7)|(fr<<12));
1564 } else {
1565 fr=intr(gv(RC_INT));
1566 c=intr(vtop[-1].r=get_reg_ex(RC_INT,two2mask(vtop->r,vtop[-1].r)));
1567 o(opc|(c<<12)|(fr<<8)|0x10);
1569 vtop--;
1570 break;
1571 case 3:
1572 vpush_global_sym(&func_old_type, func);
1573 vrott(3);
1574 gfunc_call(2);
1575 vpushi(0);
1576 vtop->r = retreg;
1577 break;
1578 default:
1579 tcc_error("gen_opi %i unimplemented!",op);
1583 #ifdef TCC_ARM_VFP
1584 static int is_zero(int i)
1586 if((vtop[i].r & (VT_VALMASK | VT_LVAL | VT_SYM)) != VT_CONST)
1587 return 0;
1588 if (vtop[i].type.t == VT_FLOAT)
1589 return (vtop[i].c.f == 0.f);
1590 else if (vtop[i].type.t == VT_DOUBLE)
1591 return (vtop[i].c.d == 0.0);
1592 return (vtop[i].c.ld == 0.l);
1595 /* generate a floating point operation 'v = t1 op t2' instruction. The
1596 * two operands are guaranted to have the same floating point type */
1597 void gen_opf(int op)
1599 uint32_t x;
1600 int fneg=0,r;
1601 x=0xEE000A00|T2CPR(vtop->type.t);
1602 switch(op) {
1603 case '+':
1604 if(is_zero(-1))
1605 vswap();
1606 if(is_zero(0)) {
1607 vtop--;
1608 return;
1610 x|=0x300000;
1611 break;
1612 case '-':
1613 x|=0x300040;
1614 if(is_zero(0)) {
1615 vtop--;
1616 return;
1618 if(is_zero(-1)) {
1619 x|=0x810000; /* fsubX -> fnegX */
1620 vswap();
1621 vtop--;
1622 fneg=1;
1624 break;
1625 case '*':
1626 x|=0x200000;
1627 break;
1628 case '/':
1629 x|=0x800000;
1630 break;
1631 default:
1632 if(op < TOK_ULT || op > TOK_GT) {
1633 tcc_error("unknown fp op %x!",op);
1634 return;
1636 if(is_zero(-1)) {
1637 vswap();
1638 switch(op) {
1639 case TOK_LT: op=TOK_GT; break;
1640 case TOK_GE: op=TOK_ULE; break;
1641 case TOK_LE: op=TOK_GE; break;
1642 case TOK_GT: op=TOK_ULT; break;
1645 x|=0xB40040; /* fcmpX */
1646 if(op!=TOK_EQ && op!=TOK_NE)
1647 x|=0x80; /* fcmpX -> fcmpeX */
1648 if(is_zero(0)) {
1649 vtop--;
1650 o(x|0x10000|(vfpr(gv(RC_FLOAT))<<12)); /* fcmp(e)X -> fcmp(e)zX */
1651 } else {
1652 x|=vfpr(gv(RC_FLOAT));
1653 vswap();
1654 o(x|(vfpr(gv(RC_FLOAT))<<12));
1655 vtop--;
1657 o(0xEEF1FA10); /* fmstat */
1659 switch(op) {
1660 case TOK_LE: op=TOK_ULE; break;
1661 case TOK_LT: op=TOK_ULT; break;
1662 case TOK_UGE: op=TOK_GE; break;
1663 case TOK_UGT: op=TOK_GT; break;
1666 vtop->r = VT_CMP;
1667 vtop->c.i = op;
1668 return;
1670 r=gv(RC_FLOAT);
1671 x|=vfpr(r);
1672 r=regmask(r);
1673 if(!fneg) {
1674 int r2;
1675 vswap();
1676 r2=gv(RC_FLOAT);
1677 x|=vfpr(r2)<<16;
1678 r|=regmask(r2);
1680 vtop->r=get_reg_ex(RC_FLOAT,r);
1681 if(!fneg)
1682 vtop--;
1683 o(x|(vfpr(vtop->r)<<12));
1686 #else
1687 static uint32_t is_fconst()
1689 long double f;
1690 uint32_t r;
1691 if((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) != VT_CONST)
1692 return 0;
1693 if (vtop->type.t == VT_FLOAT)
1694 f = vtop->c.f;
1695 else if (vtop->type.t == VT_DOUBLE)
1696 f = vtop->c.d;
1697 else
1698 f = vtop->c.ld;
1699 if(!ieee_finite(f))
1700 return 0;
1701 r=0x8;
1702 if(f<0.0) {
1703 r=0x18;
1704 f=-f;
1706 if(f==0.0)
1707 return r;
1708 if(f==1.0)
1709 return r|1;
1710 if(f==2.0)
1711 return r|2;
1712 if(f==3.0)
1713 return r|3;
1714 if(f==4.0)
1715 return r|4;
1716 if(f==5.0)
1717 return r|5;
1718 if(f==0.5)
1719 return r|6;
1720 if(f==10.0)
1721 return r|7;
1722 return 0;
1725 /* generate a floating point operation 'v = t1 op t2' instruction. The
1726 two operands are guaranted to have the same floating point type */
1727 void gen_opf(int op)
1729 uint32_t x, r, r2, c1, c2;
1730 //fputs("gen_opf\n",stderr);
1731 vswap();
1732 c1 = is_fconst();
1733 vswap();
1734 c2 = is_fconst();
1735 x=0xEE000100;
1736 #if LDOUBLE_SIZE == 8
1737 if ((vtop->type.t & VT_BTYPE) != VT_FLOAT)
1738 x|=0x80;
1739 #else
1740 if ((vtop->type.t & VT_BTYPE) == VT_DOUBLE)
1741 x|=0x80;
1742 else if ((vtop->type.t & VT_BTYPE) == VT_LDOUBLE)
1743 x|=0x80000;
1744 #endif
1745 switch(op)
1747 case '+':
1748 if(!c2) {
1749 vswap();
1750 c2=c1;
1752 vswap();
1753 r=fpr(gv(RC_FLOAT));
1754 vswap();
1755 if(c2) {
1756 if(c2>0xf)
1757 x|=0x200000; // suf
1758 r2=c2&0xf;
1759 } else {
1760 r2=fpr(gv(RC_FLOAT));
1762 break;
1763 case '-':
1764 if(c2) {
1765 if(c2<=0xf)
1766 x|=0x200000; // suf
1767 r2=c2&0xf;
1768 vswap();
1769 r=fpr(gv(RC_FLOAT));
1770 vswap();
1771 } else if(c1 && c1<=0xf) {
1772 x|=0x300000; // rsf
1773 r2=c1;
1774 r=fpr(gv(RC_FLOAT));
1775 vswap();
1776 } else {
1777 x|=0x200000; // suf
1778 vswap();
1779 r=fpr(gv(RC_FLOAT));
1780 vswap();
1781 r2=fpr(gv(RC_FLOAT));
1783 break;
1784 case '*':
1785 if(!c2 || c2>0xf) {
1786 vswap();
1787 c2=c1;
1789 vswap();
1790 r=fpr(gv(RC_FLOAT));
1791 vswap();
1792 if(c2 && c2<=0xf)
1793 r2=c2;
1794 else
1795 r2=fpr(gv(RC_FLOAT));
1796 x|=0x100000; // muf
1797 break;
1798 case '/':
1799 if(c2 && c2<=0xf) {
1800 x|=0x400000; // dvf
1801 r2=c2;
1802 vswap();
1803 r=fpr(gv(RC_FLOAT));
1804 vswap();
1805 } else if(c1 && c1<=0xf) {
1806 x|=0x500000; // rdf
1807 r2=c1;
1808 r=fpr(gv(RC_FLOAT));
1809 vswap();
1810 } else {
1811 x|=0x400000; // dvf
1812 vswap();
1813 r=fpr(gv(RC_FLOAT));
1814 vswap();
1815 r2=fpr(gv(RC_FLOAT));
1817 break;
1818 default:
1819 if(op >= TOK_ULT && op <= TOK_GT) {
1820 x|=0xd0f110; // cmfe
1821 /* bug (intention?) in Linux FPU emulator
1822 doesn't set carry if equal */
1823 switch(op) {
1824 case TOK_ULT:
1825 case TOK_UGE:
1826 case TOK_ULE:
1827 case TOK_UGT:
1828 tcc_error("unsigned comparision on floats?");
1829 break;
1830 case TOK_LT:
1831 op=TOK_Nset;
1832 break;
1833 case TOK_LE:
1834 op=TOK_ULE; /* correct in unordered case only if AC bit in FPSR set */
1835 break;
1836 case TOK_EQ:
1837 case TOK_NE:
1838 x&=~0x400000; // cmfe -> cmf
1839 break;
1841 if(c1 && !c2) {
1842 c2=c1;
1843 vswap();
1844 switch(op) {
1845 case TOK_Nset:
1846 op=TOK_GT;
1847 break;
1848 case TOK_GE:
1849 op=TOK_ULE;
1850 break;
1851 case TOK_ULE:
1852 op=TOK_GE;
1853 break;
1854 case TOK_GT:
1855 op=TOK_Nset;
1856 break;
1859 vswap();
1860 r=fpr(gv(RC_FLOAT));
1861 vswap();
1862 if(c2) {
1863 if(c2>0xf)
1864 x|=0x200000;
1865 r2=c2&0xf;
1866 } else {
1867 r2=fpr(gv(RC_FLOAT));
1869 vtop[-1].r = VT_CMP;
1870 vtop[-1].c.i = op;
1871 } else {
1872 tcc_error("unknown fp op %x!",op);
1873 return;
1876 if(vtop[-1].r == VT_CMP)
1877 c1=15;
1878 else {
1879 c1=vtop->r;
1880 if(r2&0x8)
1881 c1=vtop[-1].r;
1882 vtop[-1].r=get_reg_ex(RC_FLOAT,two2mask(vtop[-1].r,c1));
1883 c1=fpr(vtop[-1].r);
1885 vtop--;
1886 o(x|(r<<16)|(c1<<12)|r2);
1888 #endif
1890 /* convert integers to fp 't' type. Must handle 'int', 'unsigned int'
1891 and 'long long' cases. */
1892 ST_FUNC void gen_cvt_itof1(int t)
1894 uint32_t r, r2;
1895 int bt;
1896 bt=vtop->type.t & VT_BTYPE;
1897 if(bt == VT_INT || bt == VT_SHORT || bt == VT_BYTE) {
1898 #ifndef TCC_ARM_VFP
1899 uint32_t dsize = 0;
1900 #endif
1901 r=intr(gv(RC_INT));
1902 #ifdef TCC_ARM_VFP
1903 r2=vfpr(vtop->r=get_reg(RC_FLOAT));
1904 o(0xEE000A10|(r<<12)|(r2<<16)); /* fmsr */
1905 r2|=r2<<12;
1906 if(!(vtop->type.t & VT_UNSIGNED))
1907 r2|=0x80; /* fuitoX -> fsituX */
1908 o(0xEEB80A40|r2|T2CPR(t)); /* fYitoX*/
1909 #else
1910 r2=fpr(vtop->r=get_reg(RC_FLOAT));
1911 if((t & VT_BTYPE) != VT_FLOAT)
1912 dsize=0x80; /* flts -> fltd */
1913 o(0xEE000110|dsize|(r2<<16)|(r<<12)); /* flts */
1914 if((vtop->type.t & (VT_UNSIGNED|VT_BTYPE)) == (VT_UNSIGNED|VT_INT)) {
1915 uint32_t off = 0;
1916 o(0xE3500000|(r<<12)); /* cmp */
1917 r=fpr(get_reg(RC_FLOAT));
1918 if(last_itod_magic) {
1919 off=ind+8-last_itod_magic;
1920 off/=4;
1921 if(off>255)
1922 off=0;
1924 o(0xBD1F0100|(r<<12)|off); /* ldflts */
1925 if(!off) {
1926 o(0xEA000000); /* b */
1927 last_itod_magic=ind;
1928 o(0x4F800000); /* 4294967296.0f */
1930 o(0xBE000100|dsize|(r2<<16)|(r2<<12)|r); /* adflt */
1932 #endif
1933 return;
1934 } else if(bt == VT_LLONG) {
1935 int func;
1936 CType *func_type = 0;
1937 if((t & VT_BTYPE) == VT_FLOAT) {
1938 func_type = &func_float_type;
1939 if(vtop->type.t & VT_UNSIGNED)
1940 func=TOK___floatundisf;
1941 else
1942 func=TOK___floatdisf;
1943 #if LDOUBLE_SIZE != 8
1944 } else if((t & VT_BTYPE) == VT_LDOUBLE) {
1945 func_type = &func_ldouble_type;
1946 if(vtop->type.t & VT_UNSIGNED)
1947 func=TOK___floatundixf;
1948 else
1949 func=TOK___floatdixf;
1950 } else if((t & VT_BTYPE) == VT_DOUBLE) {
1951 #else
1952 } else if((t & VT_BTYPE) == VT_DOUBLE || (t & VT_BTYPE) == VT_LDOUBLE) {
1953 #endif
1954 func_type = &func_double_type;
1955 if(vtop->type.t & VT_UNSIGNED)
1956 func=TOK___floatundidf;
1957 else
1958 func=TOK___floatdidf;
1960 if(func_type) {
1961 vpush_global_sym(func_type, func);
1962 vswap();
1963 gfunc_call(1);
1964 vpushi(0);
1965 vtop->r=TREG_F0;
1966 return;
1969 tcc_error("unimplemented gen_cvt_itof %x!",vtop->type.t);
1972 /* convert fp to int 't' type */
1973 void gen_cvt_ftoi(int t)
1975 uint32_t r, r2;
1976 int u, func = 0;
1977 u=t&VT_UNSIGNED;
1978 t&=VT_BTYPE;
1979 r2=vtop->type.t & VT_BTYPE;
1980 if(t==VT_INT) {
1981 #ifdef TCC_ARM_VFP
1982 r=vfpr(gv(RC_FLOAT));
1983 u=u?0:0x10000;
1984 o(0xEEBC0AC0|(r<<12)|r|T2CPR(r2)|u); /* ftoXizY */
1985 r2=intr(vtop->r=get_reg(RC_INT));
1986 o(0xEE100A10|(r<<16)|(r2<<12));
1987 return;
1988 #else
1989 if(u) {
1990 if(r2 == VT_FLOAT)
1991 func=TOK___fixunssfsi;
1992 #if LDOUBLE_SIZE != 8
1993 else if(r2 == VT_LDOUBLE)
1994 func=TOK___fixunsxfsi;
1995 else if(r2 == VT_DOUBLE)
1996 #else
1997 else if(r2 == VT_LDOUBLE || r2 == VT_DOUBLE)
1998 #endif
1999 func=TOK___fixunsdfsi;
2000 } else {
2001 r=fpr(gv(RC_FLOAT));
2002 r2=intr(vtop->r=get_reg(RC_INT));
2003 o(0xEE100170|(r2<<12)|r);
2004 return;
2006 #endif
2007 } else if(t == VT_LLONG) { // unsigned handled in gen_cvt_ftoi1
2008 if(r2 == VT_FLOAT)
2009 func=TOK___fixsfdi;
2010 #if LDOUBLE_SIZE != 8
2011 else if(r2 == VT_LDOUBLE)
2012 func=TOK___fixxfdi;
2013 else if(r2 == VT_DOUBLE)
2014 #else
2015 else if(r2 == VT_LDOUBLE || r2 == VT_DOUBLE)
2016 #endif
2017 func=TOK___fixdfdi;
2019 if(func) {
2020 vpush_global_sym(&func_old_type, func);
2021 vswap();
2022 gfunc_call(1);
2023 vpushi(0);
2024 if(t == VT_LLONG)
2025 vtop->r2 = REG_LRET;
2026 vtop->r = REG_IRET;
2027 return;
2029 tcc_error("unimplemented gen_cvt_ftoi!");
2032 /* convert from one floating point type to another */
2033 void gen_cvt_ftof(int t)
2035 #ifdef TCC_ARM_VFP
2036 if(((vtop->type.t & VT_BTYPE) == VT_FLOAT) != ((t & VT_BTYPE) == VT_FLOAT)) {
2037 uint32_t r = vfpr(gv(RC_FLOAT));
2038 o(0xEEB70AC0|(r<<12)|r|T2CPR(vtop->type.t));
2040 #else
2041 /* all we have to do on i386 and FPA ARM is to put the float in a register */
2042 gv(RC_FLOAT);
2043 #endif
2046 /* computed goto support */
2047 void ggoto(void)
2049 gcall_or_jmp(1);
2050 vtop--;
2053 /* Save the stack pointer onto the stack and return the location of its address */
2054 ST_FUNC void gen_vla_sp_save(int addr) {
2055 tcc_error("variable length arrays unsupported for this target");
2058 /* Restore the SP from a location on the stack */
2059 ST_FUNC void gen_vla_sp_restore(int addr) {
2060 tcc_error("variable length arrays unsupported for this target");
2063 /* Subtract from the stack pointer, and push the resulting value onto the stack */
2064 ST_FUNC void gen_vla_alloc(CType *type, int align) {
2065 tcc_error("variable length arrays unsupported for this target");
2068 /* end of ARM code generator */
2069 /*************************************************************/
2070 #endif
2071 /*************************************************************/