2 * ARMv4 code generator for TCC
4 * Copyright (c) 2003 Daniel Glöckner
6 * Based on i386-gen.c by Fabrice Bellard
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2 of the License, or (at your option) any later version.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 #ifdef TARGET_DEFS_ONLY
26 #ifndef TCC_ARM_VFP // Avoid useless warning
31 /* number of available registers */
38 /* a register can belong to several classes. The classes must be
39 sorted from more general to more precise (see gv2() code which does
40 assumptions on it). */
41 #define RC_INT 0x0001 /* generic integer register */
42 #define RC_FLOAT 0x0002 /* generic float register */
58 #define RC_IRET RC_R0 /* function return: integer register */
59 #define RC_LRET RC_R1 /* function return: second integer register */
60 #define RC_FRET RC_F0 /* function return: float register */
62 /* pretty names for the registers */
82 #define T2CPR(t) (((t) & VT_BTYPE) != VT_FLOAT ? 0x100 : 0)
85 /* return registers for function */
86 #define REG_IRET TREG_R0 /* single word int return register */
87 #define REG_LRET TREG_R1 /* second word return register (for long long) */
88 #define REG_FRET TREG_F0 /* float return register */
91 #define TOK___divdi3 TOK___aeabi_ldivmod
92 #define TOK___moddi3 TOK___aeabi_ldivmod
93 #define TOK___udivdi3 TOK___aeabi_uldivmod
94 #define TOK___umoddi3 TOK___aeabi_uldivmod
97 /* defined if function parameters must be evaluated in reverse order */
98 #define INVERT_FUNC_PARAMS
100 /* defined if structures are passed as pointers. Otherwise structures
101 are directly pushed on stack. */
102 //#define FUNC_STRUCT_PARAM_AS_PTR
104 #if defined(TCC_ARM_EABI) && defined(TCC_ARM_VFP)
105 #ifdef NEED_FLOAT_TYPES
106 static CType float_type
, double_type
, func_float_type
, func_double_type
;
107 #define func_ldouble_type func_double_type
110 #define func_float_type func_old_type
111 #define func_double_type func_old_type
112 #define func_ldouble_type func_old_type
115 /* pointer size, in bytes */
118 /* long double size and alignment, in bytes */
120 #define LDOUBLE_SIZE 8
124 #define LDOUBLE_SIZE 8
128 #define LDOUBLE_ALIGN 8
130 #define LDOUBLE_ALIGN 4
133 /* maximum alignment (for aligned attribute support) */
136 #define CHAR_IS_UNSIGNED
138 /******************************************************/
141 #define EM_TCC_TARGET EM_ARM
143 /* relocation type for 32 bit data relocation */
144 #define R_DATA_32 R_ARM_ABS32
145 #define R_DATA_PTR R_ARM_ABS32
146 #define R_JMP_SLOT R_ARM_JUMP_SLOT
147 #define R_COPY R_ARM_COPY
149 #define ELF_START_ADDR 0x00008000
150 #define ELF_PAGE_SIZE 0x1000
152 /******************************************************/
153 #else /* ! TARGET_DEFS_ONLY */
154 /******************************************************/
157 ST_DATA
const int reg_classes
[NB_REGS
] = {
158 /* r0 */ RC_INT
| RC_R0
,
159 /* r1 */ RC_INT
| RC_R1
,
160 /* r2 */ RC_INT
| RC_R2
,
161 /* r3 */ RC_INT
| RC_R3
,
162 /* r12 */ RC_INT
| RC_R12
,
163 /* f0 */ RC_FLOAT
| RC_F0
,
164 /* f1 */ RC_FLOAT
| RC_F1
,
165 /* f2 */ RC_FLOAT
| RC_F2
,
166 /* f3 */ RC_FLOAT
| RC_F3
,
168 /* d4/s8 */ RC_FLOAT
| RC_F4
,
169 /* d5/s10 */ RC_FLOAT
| RC_F5
,
170 /* d6/s12 */ RC_FLOAT
| RC_F6
,
171 /* d7/s14 */ RC_FLOAT
| RC_F7
,
175 static int func_sub_sp_offset
, last_itod_magic
;
178 static int two2mask(int a
,int b
) {
179 return (reg_classes
[a
]|reg_classes
[b
])&~(RC_INT
|RC_FLOAT
);
182 static int regmask(int r
) {
183 return reg_classes
[r
]&~(RC_INT
|RC_FLOAT
);
186 /******************************************************/
190 /* this is a good place to start adding big-endian support*/
194 if (!cur_text_section
)
195 error("compiler error! This happens f.ex. if the compiler\n"
196 "can't evaluate constant expressions outside of a function.");
197 if (ind1
> cur_text_section
->data_allocated
)
198 section_realloc(cur_text_section
, ind1
);
199 cur_text_section
->data
[ind
++] = i
&255;
201 cur_text_section
->data
[ind
++] = i
&255;
203 cur_text_section
->data
[ind
++] = i
&255;
205 cur_text_section
->data
[ind
++] = i
;
208 static uint32_t stuff_const(uint32_t op
, uint32_t c
)
211 uint32_t nc
= 0, negop
= 0;
221 case 0x1A00000: //mov
222 case 0x1E00000: //mvn
229 return (op
&0xF010F000)|((op
>>16)&0xF)|0x1E00000;
233 return (op
&0xF010F000)|((op
>>16)&0xF)|0x1A00000;
234 case 0x1C00000: //bic
239 case 0x1800000: //orr
241 return (op
&0xFFF0FFFF)|0x1E00000;
247 if(c
<256) /* catch undefined <<32 */
250 m
=(0xff>>i
)|(0xff<<(32-i
));
252 return op
|(i
<<7)|(c
<<i
)|(c
>>(32-i
));
262 void stuff_const_harder(uint32_t op
, uint32_t v
) {
268 uint32_t a
[16], nv
, no
, o2
, n2
;
271 o2
=(op
&0xfff0ffff)|((op
&0xf000)<<4);;
273 a
[i
]=(a
[i
-1]>>2)|(a
[i
-1]<<30);
275 for(j
=i
<4?i
+12:15;j
>=i
+4;j
--)
276 if((v
&(a
[i
]|a
[j
]))==v
) {
277 o(stuff_const(op
,v
&a
[i
]));
278 o(stuff_const(o2
,v
&a
[j
]));
285 for(j
=i
<4?i
+12:15;j
>=i
+4;j
--)
286 if((nv
&(a
[i
]|a
[j
]))==nv
) {
287 o(stuff_const(no
,nv
&a
[i
]));
288 o(stuff_const(n2
,nv
&a
[j
]));
293 for(k
=i
<4?i
+12:15;k
>=j
+4;k
--)
294 if((v
&(a
[i
]|a
[j
]|a
[k
]))==v
) {
295 o(stuff_const(op
,v
&a
[i
]));
296 o(stuff_const(o2
,v
&a
[j
]));
297 o(stuff_const(o2
,v
&a
[k
]));
304 for(k
=i
<4?i
+12:15;k
>=j
+4;k
--)
305 if((nv
&(a
[i
]|a
[j
]|a
[k
]))==nv
) {
306 o(stuff_const(no
,nv
&a
[i
]));
307 o(stuff_const(n2
,nv
&a
[j
]));
308 o(stuff_const(n2
,nv
&a
[k
]));
311 o(stuff_const(op
,v
&a
[0]));
312 o(stuff_const(o2
,v
&a
[4]));
313 o(stuff_const(o2
,v
&a
[8]));
314 o(stuff_const(o2
,v
&a
[12]));
318 ST_FUNC
uint32_t encbranch(int pos
, int addr
, int fail
)
322 if(addr
>=0x1000000 || addr
<-0x1000000) {
324 error("FIXME: function bigger than 32MB");
327 return 0x0A000000|(addr
&0xffffff);
330 int decbranch(int pos
)
333 x
=*(uint32_t *)(cur_text_section
->data
+ pos
);
340 /* output a symbol and patch all calls to it */
341 void gsym_addr(int t
, int a
)
346 x
=(uint32_t *)(cur_text_section
->data
+ t
);
349 *x
=0xE1A00000; // nop
352 *x
|= encbranch(lt
,a
,1);
363 static uint32_t vfpr(int r
)
365 if(r
<TREG_F0
|| r
>TREG_F7
)
366 error("compiler error! register %i is no vfp register",r
);
370 static uint32_t fpr(int r
)
372 if(r
<TREG_F0
|| r
>TREG_F3
)
373 error("compiler error! register %i is no fpa register",r
);
378 static uint32_t intr(int r
)
382 if((r
<0 || r
>4) && r
!=14)
383 error("compiler error! register %i is no int register",r
);
387 static void calcaddr(uint32_t *base
, int *off
, int *sgn
, int maxoff
, unsigned shift
)
389 if(*off
>maxoff
|| *off
&((1<<shift
)-1)) {
396 y
=stuff_const(x
,*off
&~maxoff
);
402 y
=stuff_const(x
,(*off
+maxoff
)&~maxoff
);
406 *off
=((*off
+maxoff
)&~maxoff
)-*off
;
409 stuff_const_harder(x
,*off
&~maxoff
);
414 static uint32_t mapcc(int cc
)
419 return 0x30000000; /* CC/LO */
421 return 0x20000000; /* CS/HS */
423 return 0x00000000; /* EQ */
425 return 0x10000000; /* NE */
427 return 0x90000000; /* LS */
429 return 0x80000000; /* HI */
431 return 0x40000000; /* MI */
433 return 0x50000000; /* PL */
435 return 0xB0000000; /* LT */
437 return 0xA0000000; /* GE */
439 return 0xD0000000; /* LE */
441 return 0xC0000000; /* GT */
443 error("unexpected condition code");
444 return 0xE0000000; /* AL */
447 static int negcc(int cc
)
476 error("unexpected condition code");
480 /* load 'r' from value 'sv' */
481 void load(int r
, SValue
*sv
)
483 int v
, ft
, fc
, fr
, sign
;
500 uint32_t base
= 0xB; // fp
503 v1
.r
= VT_LOCAL
| VT_LVAL
;
505 load(base
=14 /* lr */, &v1
);
508 } else if(v
== VT_CONST
) {
516 } else if(v
< VT_CONST
) {
523 calcaddr(&base
,&fc
,&sign
,1020,2);
525 op
=0xED100A00; /* flds */
528 if ((ft
& VT_BTYPE
) != VT_FLOAT
)
529 op
|=0x100; /* flds -> fldd */
530 o(op
|(vfpr(r
)<<12)|(fc
>>2)|(base
<<16));
535 #if LDOUBLE_SIZE == 8
536 if ((ft
& VT_BTYPE
) != VT_FLOAT
)
539 if ((ft
& VT_BTYPE
) == VT_DOUBLE
)
541 else if ((ft
& VT_BTYPE
) == VT_LDOUBLE
)
544 o(op
|(fpr(r
)<<12)|(fc
>>2)|(base
<<16));
546 } else if((ft
& (VT_BTYPE
|VT_UNSIGNED
)) == VT_BYTE
547 || (ft
& VT_BTYPE
) == VT_SHORT
) {
548 calcaddr(&base
,&fc
,&sign
,255,0);
550 if ((ft
& VT_BTYPE
) == VT_SHORT
)
552 if ((ft
& VT_UNSIGNED
) == 0)
556 o(op
|(intr(r
)<<12)|(base
<<16)|((fc
&0xf0)<<4)|(fc
&0xf));
558 calcaddr(&base
,&fc
,&sign
,4095,0);
562 if ((ft
& VT_BTYPE
) == VT_BYTE
)
564 o(op
|(intr(r
)<<12)|fc
|(base
<<16));
570 op
=stuff_const(0xE3A00000|(intr(r
)<<12),sv
->c
.ul
);
571 if (fr
& VT_SYM
|| !op
) {
572 o(0xE59F0000|(intr(r
)<<12));
575 greloc(cur_text_section
, sv
->sym
, ind
, R_ARM_ABS32
);
580 } else if (v
== VT_LOCAL
) {
581 op
=stuff_const(0xE28B0000|(intr(r
)<<12),sv
->c
.ul
);
582 if (fr
& VT_SYM
|| !op
) {
583 o(0xE59F0000|(intr(r
)<<12));
585 if(fr
& VT_SYM
) // needed ?
586 greloc(cur_text_section
, sv
->sym
, ind
, R_ARM_ABS32
);
588 o(0xE08B0000|(intr(r
)<<12)|intr(r
));
592 } else if(v
== VT_CMP
) {
593 o(mapcc(sv
->c
.ul
)|0x3A00001|(intr(r
)<<12));
594 o(mapcc(negcc(sv
->c
.ul
))|0x3A00000|(intr(r
)<<12));
596 } else if (v
== VT_JMP
|| v
== VT_JMPI
) {
599 o(0xE3A00000|(intr(r
)<<12)|t
);
602 o(0xE3A00000|(intr(r
)<<12)|(t
^1));
604 } else if (v
< VT_CONST
) {
607 o(0xEEB00A40|(vfpr(r
)<<12)|vfpr(v
)|T2CPR(ft
)); /* fcpyX */
609 o(0xEE008180|(fpr(r
)<<12)|fpr(v
));
612 o(0xE1A00000|(intr(r
)<<12)|intr(v
));
616 error("load unimplemented!");
619 /* store register 'r' in lvalue 'v' */
620 void store(int r
, SValue
*sv
)
623 int v
, ft
, fc
, fr
, sign
;
638 if (fr
& VT_LVAL
|| fr
== VT_LOCAL
) {
644 } else if(v
== VT_CONST
) {
655 calcaddr(&base
,&fc
,&sign
,1020,2);
657 op
=0xED000A00; /* fsts */
660 if ((ft
& VT_BTYPE
) != VT_FLOAT
)
661 op
|=0x100; /* fsts -> fstd */
662 o(op
|(vfpr(r
)<<12)|(fc
>>2)|(base
<<16));
667 #if LDOUBLE_SIZE == 8
668 if ((ft
& VT_BTYPE
) != VT_FLOAT
)
671 if ((ft
& VT_BTYPE
) == VT_DOUBLE
)
673 if ((ft
& VT_BTYPE
) == VT_LDOUBLE
)
676 o(op
|(fpr(r
)<<12)|(fc
>>2)|(base
<<16));
679 } else if((ft
& VT_BTYPE
) == VT_SHORT
) {
680 calcaddr(&base
,&fc
,&sign
,255,0);
684 o(op
|(intr(r
)<<12)|(base
<<16)|((fc
&0xf0)<<4)|(fc
&0xf));
686 calcaddr(&base
,&fc
,&sign
,4095,0);
690 if ((ft
& VT_BTYPE
) == VT_BYTE
)
692 o(op
|(intr(r
)<<12)|fc
|(base
<<16));
697 error("store unimplemented");
700 static void gadd_sp(int val
)
702 stuff_const_harder(0xE28DD000,val
);
705 /* 'is_jmp' is '1' if it is a jump */
706 static void gcall_or_jmp(int is_jmp
)
709 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
)) == VT_CONST
) {
712 x
=encbranch(ind
,ind
+vtop
->c
.ul
,0);
714 if (vtop
->r
& VT_SYM
) {
715 /* relocation case */
716 greloc(cur_text_section
, vtop
->sym
, ind
, R_ARM_PC24
);
718 put_elf_reloc(symtab_section
, cur_text_section
, ind
, R_ARM_PC24
, 0);
719 o(x
|(is_jmp
?0xE0000000:0xE1000000));
722 o(0xE28FE004); // add lr,pc,#4
723 o(0xE51FF004); // ldr pc,[pc,#-4]
724 if (vtop
->r
& VT_SYM
)
725 greloc(cur_text_section
, vtop
->sym
, ind
, R_ARM_ABS32
);
729 /* otherwise, indirect call */
732 o(0xE1A0E00F); // mov lr,pc
733 o(0xE1A0F000|intr(r
)); // mov pc,r
737 /* Generate function call. The function address is pushed first, then
738 all the parameters in call order. This functions pops all the
739 parameters and the function address. */
740 void gfunc_call(int nb_args
)
742 int size
, align
, r
, args_size
, i
;
744 signed char plan
[4][2]={{-1,-1},{-1,-1},{-1,-1},{-1,-1}};
745 int todo
=0xf, keep
, plan2
[4]={0,0,0,0};
747 r
= vtop
->r
& VT_VALMASK
;
748 if (r
== VT_CMP
|| (r
& ~1) == VT_JMP
)
751 if((vtop
[-nb_args
].type
.ref
->type
.t
& VT_BTYPE
) == VT_STRUCT
752 && type_size(&vtop
[-nb_args
].type
, &align
) <= 4) {
755 vtop
[-nb_args
]=vtop
[-nb_args
+1];
756 vtop
[-nb_args
+1]=tmp
;
761 vtop
->type
.t
= VT_LLONG
;
763 for(i
= nb_args
+ 1 ; i
-- ;) {
764 size
= type_size(&vtop
[-i
].type
, &align
);
765 if(args_size
& (align
-1)) {
767 vtop
->type
.t
= VT_VOID
; /* padding */
772 args_size
+= (size
+ 3) & -4;
777 for(i
= nb_args
; i
-- && args_size
< 16 ;) {
778 switch(vtop
[-i
].type
.t
& VT_BTYPE
) {
783 size
= type_size(&vtop
[-i
].type
, &align
);
784 size
= (size
+ 3) & -4;
788 plan
[nb_args
-1-i
][0]=args_size
/4;
790 if ((vtop
[-i
].type
.t
& VT_BTYPE
) == VT_LLONG
&& args_size
< 16) {
791 plan
[nb_args
-1-i
][1]=args_size
/4;
796 args_size
= keep
= 0;
797 for(i
= 0;i
< nb_args
; i
++) {
799 if ((vtop
->type
.t
& VT_BTYPE
) == VT_STRUCT
) {
800 size
= type_size(&vtop
->type
, &align
);
801 /* align to stack align size */
802 size
= (size
+ 3) & -4;
803 /* allocate the necessary size on stack */
805 /* generate structure store */
807 o(0xE1A0000D|(intr(r
)<<12));
808 vset(&vtop
->type
, r
| VT_LVAL
, 0);
813 } else if (is_float(vtop
->type
.t
)) {
815 r
=vfpr(gv(RC_FLOAT
))<<12;
817 if ((vtop
->type
.t
& VT_BTYPE
) != VT_FLOAT
)
820 r
|=0x101; /* fstms -> fstmd */
824 r
=fpr(gv(RC_FLOAT
))<<12;
825 if ((vtop
->type
.t
& VT_BTYPE
) == VT_FLOAT
)
827 else if ((vtop
->type
.t
& VT_BTYPE
) == VT_DOUBLE
)
837 o(0xED2D0100|r
|(size
>>2));
843 /* simple type (currently always same size) */
844 /* XXX: implicit cast ? */
846 if ((vtop
->type
.t
& VT_BTYPE
) == VT_LLONG
) {
849 if(nb_args
-i
<5 && plan
[nb_args
-i
-1][1]!=-1) {
850 s
=regmask(plan
[nb_args
-i
-1][1]);
851 todo
&=~(1<<plan
[nb_args
-i
-1][1]);
855 o(0xE52D0004|(intr(r
)<<12)); /* str r,[sp,#-4]! */
865 if(nb_args
-i
<5 && plan
[nb_args
-i
-1][0]!=-1) {
866 s
=regmask(plan
[nb_args
-i
-1][0]);
867 todo
&=~(1<<plan
[nb_args
-i
-1][0]);
870 if(vtop
->type
.t
== VT_VOID
) {
872 o(0xE24DD004); /* sub sp,sp,#4 */
878 o(0xE52D0004|(intr(r
)<<12)); /* str r,[sp,#-4]! */
891 save_regs(keep
); /* save used temporary registers */
912 func_sym
= vtop
->type
.ref
;
917 if((vtop
->type
.ref
->type
.t
& VT_BTYPE
) == VT_STRUCT
918 && type_size(&vtop
->type
.ref
->type
, &align
) <= 4)
920 store(REG_IRET
,vtop
-keep
);
924 else if(is_float(vtop
->type
.ref
->type
.t
)) {
925 if((vtop
->type
.ref
->type
.t
& VT_BTYPE
) == VT_FLOAT
) {
926 o(0xEE000A10); /* fmsr s0,r0 */
928 o(0xEE000B10); /* fmdlr d0,r0 */
929 o(0xEE201B10); /* fmdhr d0,r1 */
938 /* generate function prolog of type 't' */
939 void gfunc_prolog(CType
*func_type
)
942 int n
,addr
,size
,align
;
944 sym
= func_type
->ref
;
949 if((func_vt
.t
& VT_BTYPE
) == VT_STRUCT
950 && type_size(&func_vt
,&align
) > 4)
956 for(sym2
=sym
->next
;sym2
&& n
<4;sym2
=sym2
->next
) {
957 size
= type_size(&sym2
->type
, &align
);
960 o(0xE1A0C00D); /* mov ip,sp */
961 if(func_type
->ref
->c
== FUNC_ELLIPSIS
)
969 o(0xE92D0000|((1<<n
)-1)); /* save r0-r4 on stack if needed */
971 o(0xE92D5800); /* save fp, ip, lr */
972 o(0xE28DB00C); /* add fp, sp, #12 */
973 func_sub_sp_offset
= ind
;
974 o(0xE1A00000); /* nop, leave space for stack adjustment */
975 while ((sym
= sym
->next
)) {
978 size
= type_size(type
, &align
);
979 size
= (size
+ 3) & -4;
981 addr
= (addr
+ align
- 1) & -align
;
983 sym_push(sym
->v
& ~SYM_FIELD
, type
, VT_LOCAL
| lvalue_type(type
->t
), addr
);
991 /* generate function epilog */
992 void gfunc_epilog(void)
997 if(is_float(func_vt
.t
)) {
998 if((func_vt
.t
& VT_BTYPE
) == VT_FLOAT
)
999 o(0xEE100A10); /* fmrs r0, s0 */
1001 o(0xEE100B10); /* fmrdl r0, d0 */
1002 o(0xEE301B10); /* fmrdh r1, d0 */
1006 o(0xE91BA800); /* restore fp, sp, pc */
1007 diff
= (-loc
+ 3) & -4;
1010 diff
= (diff
+ 7) & -8;
1013 x
=stuff_const(0xE24BD000, diff
); /* sub sp,fp,# */
1015 *(uint32_t *)(cur_text_section
->data
+ func_sub_sp_offset
) = x
;
1019 o(0xE59FC004); /* ldr ip,[pc+4] */
1020 o(0xE04BD00C); /* sub sp,fp,ip */
1021 o(0xE1A0F00E); /* mov pc,lr */
1023 *(uint32_t *)(cur_text_section
->data
+ func_sub_sp_offset
) = 0xE1000000|encbranch(func_sub_sp_offset
,addr
,1);
1028 /* generate a jump to a label */
1033 o(0xE0000000|encbranch(r
,t
,1));
1037 /* generate a jump to a fixed address */
1038 void gjmp_addr(int a
)
1043 /* generate a test. set 'inv' to invert test. Stack entry is popped */
1044 int gtst(int inv
, int t
)
1048 v
= vtop
->r
& VT_VALMASK
;
1051 op
=mapcc(inv
?negcc(vtop
->c
.i
):vtop
->c
.i
);
1052 op
|=encbranch(r
,t
,1);
1055 } else if (v
== VT_JMP
|| v
== VT_JMPI
) {
1056 if ((v
& 1) == inv
) {
1065 p
= decbranch(lp
=p
);
1067 x
= (uint32_t *)(cur_text_section
->data
+ lp
);
1069 *x
|= encbranch(lp
,t
,1);
1078 if (is_float(vtop
->type
.t
)) {
1081 o(0xEEB50A40|(vfpr(r
)<<12)|T2CPR(vtop
->type
.t
)); /* fcmpzX */
1082 o(0xEEF1FA10); /* fmstat */
1084 o(0xEE90F118|(fpr(r
)<<16));
1088 return gtst(inv
, t
);
1089 } else if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
) {
1090 /* constant jmp optimization */
1091 if ((vtop
->c
.i
!= 0) != inv
)
1095 o(0xE3300000|(intr(v
)<<16));
1098 return gtst(inv
, t
);
1105 /* generate an integer binary operation */
1106 void gen_opi(int op
)
1109 uint32_t opc
= 0, r
, fr
;
1110 unsigned short retreg
= REG_IRET
;
1118 case TOK_ADDC1
: /* add with carry generation */
1126 case TOK_SUBC1
: /* sub with carry generation */
1130 case TOK_ADDC2
: /* add with carry use */
1134 case TOK_SUBC2
: /* sub with carry use */
1151 gv2(RC_INT
, RC_INT
);
1155 o(0xE0000090|(intr(r
)<<16)|(intr(r
)<<8)|intr(fr
));
1180 func
=TOK___aeabi_idivmod
;
1189 func
=TOK___aeabi_uidivmod
;
1197 gv2(RC_INT
, RC_INT
);
1198 r
=intr(vtop
[-1].r2
=get_reg(RC_INT
));
1200 vtop
[-1].r
=get_reg_ex(RC_INT
,regmask(c
));
1202 o(0xE0800090|(r
<<16)|(intr(vtop
->r
)<<12)|(intr(c
)<<8)|intr(vtop
[1].r
));
1211 if((vtop
[-1].r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
) {
1212 if(opc
== 4 || opc
== 5 || opc
== 0xc) {
1214 opc
|=2; // sub -> rsb
1217 if ((vtop
->r
& VT_VALMASK
) == VT_CMP
||
1218 (vtop
->r
& (VT_VALMASK
& ~1)) == VT_JMP
)
1223 opc
=0xE0000000|(opc
<<20)|(c
<<16);
1224 if((vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
) {
1226 x
=stuff_const(opc
|0x2000000,vtop
->c
.i
);
1228 r
=intr(vtop
[-1].r
=get_reg_ex(RC_INT
,regmask(vtop
[-1].r
)));
1233 fr
=intr(gv(RC_INT
));
1234 r
=intr(vtop
[-1].r
=get_reg_ex(RC_INT
,two2mask(vtop
->r
,vtop
[-1].r
)));
1238 if (op
>= TOK_ULT
&& op
<= TOK_GT
) {
1244 opc
=0xE1A00000|(opc
<<5);
1245 if ((vtop
->r
& VT_VALMASK
) == VT_CMP
||
1246 (vtop
->r
& (VT_VALMASK
& ~1)) == VT_JMP
)
1252 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
) {
1253 fr
=intr(vtop
[-1].r
=get_reg_ex(RC_INT
,regmask(vtop
[-1].r
)));
1254 c
= vtop
->c
.i
& 0x1f;
1255 o(opc
|(c
<<7)|(fr
<<12));
1257 fr
=intr(gv(RC_INT
));
1258 c
=intr(vtop
[-1].r
=get_reg_ex(RC_INT
,two2mask(vtop
->r
,vtop
[-1].r
)));
1259 o(opc
|(c
<<12)|(fr
<<8)|0x10);
1264 vpush_global_sym(&func_old_type
, func
);
1271 error("gen_opi %i unimplemented!",op
);
1276 static int is_zero(int i
)
1278 if((vtop
[i
].r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) != VT_CONST
)
1280 if (vtop
[i
].type
.t
== VT_FLOAT
)
1281 return (vtop
[i
].c
.f
== 0.f
);
1282 else if (vtop
[i
].type
.t
== VT_DOUBLE
)
1283 return (vtop
[i
].c
.d
== 0.0);
1284 return (vtop
[i
].c
.ld
== 0.l
);
1287 /* generate a floating point operation 'v = t1 op t2' instruction. The
1288 * two operands are guaranted to have the same floating point type */
1289 void gen_opf(int op
)
1293 x
=0xEE000A00|T2CPR(vtop
->type
.t
);
1311 x
|=0x810000; /* fsubX -> fnegX */
1324 if(op
< TOK_ULT
&& op
> TOK_GT
) {
1325 error("unknown fp op %x!",op
);
1331 case TOK_LT
: op
=TOK_GT
; break;
1332 case TOK_GE
: op
=TOK_ULE
; break;
1333 case TOK_LE
: op
=TOK_GE
; break;
1334 case TOK_GT
: op
=TOK_ULT
; break;
1337 x
|=0xB40040; /* fcmpX */
1338 if(op
!=TOK_EQ
&& op
!=TOK_NE
)
1339 x
|=0x80; /* fcmpX -> fcmpeX */
1342 o(x
|0x10000|(vfpr(gv(RC_FLOAT
))<<12)); /* fcmp(e)X -> fcmp(e)zX */
1344 x
|=vfpr(gv(RC_FLOAT
));
1346 o(x
|(vfpr(gv(RC_FLOAT
))<<12));
1349 o(0xEEF1FA10); /* fmstat */
1352 case TOK_LE
: op
=TOK_ULE
; break;
1353 case TOK_LT
: op
=TOK_ULT
; break;
1354 case TOK_UGE
: op
=TOK_GE
; break;
1355 case TOK_UGT
: op
=TOK_GT
; break;
1372 vtop
->r
=get_reg_ex(RC_FLOAT
,r
);
1375 o(x
|(vfpr(vtop
->r
)<<12));
1379 static uint32_t is_fconst()
1383 if((vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) != VT_CONST
)
1385 if (vtop
->type
.t
== VT_FLOAT
)
1387 else if (vtop
->type
.t
== VT_DOUBLE
)
1417 /* generate a floating point operation 'v = t1 op t2' instruction. The
1418 two operands are guaranted to have the same floating point type */
1419 void gen_opf(int op
)
1421 uint32_t x
, r
, r2
, c1
, c2
;
1422 //fputs("gen_opf\n",stderr);
1428 #if LDOUBLE_SIZE == 8
1429 if ((vtop
->type
.t
& VT_BTYPE
) != VT_FLOAT
)
1432 if ((vtop
->type
.t
& VT_BTYPE
) == VT_DOUBLE
)
1434 else if ((vtop
->type
.t
& VT_BTYPE
) == VT_LDOUBLE
)
1445 r
=fpr(gv(RC_FLOAT
));
1452 r2
=fpr(gv(RC_FLOAT
));
1461 r
=fpr(gv(RC_FLOAT
));
1463 } else if(c1
&& c1
<=0xf) {
1466 r
=fpr(gv(RC_FLOAT
));
1471 r
=fpr(gv(RC_FLOAT
));
1473 r2
=fpr(gv(RC_FLOAT
));
1482 r
=fpr(gv(RC_FLOAT
));
1487 r2
=fpr(gv(RC_FLOAT
));
1495 r
=fpr(gv(RC_FLOAT
));
1497 } else if(c1
&& c1
<=0xf) {
1500 r
=fpr(gv(RC_FLOAT
));
1505 r
=fpr(gv(RC_FLOAT
));
1507 r2
=fpr(gv(RC_FLOAT
));
1511 if(op
>= TOK_ULT
&& op
<= TOK_GT
) {
1512 x
|=0xd0f110; // cmfe
1513 /* bug (intention?) in Linux FPU emulator
1514 doesn't set carry if equal */
1520 error("unsigned comparision on floats?");
1526 op
=TOK_ULE
; /* correct in unordered case only if AC bit in FPSR set */
1530 x
&=~0x400000; // cmfe -> cmf
1552 r
=fpr(gv(RC_FLOAT
));
1559 r2
=fpr(gv(RC_FLOAT
));
1561 vtop
[-1].r
= VT_CMP
;
1564 error("unknown fp op %x!",op
);
1568 if(vtop
[-1].r
== VT_CMP
)
1574 vtop
[-1].r
=get_reg_ex(RC_FLOAT
,two2mask(vtop
[-1].r
,c1
));
1578 o(x
|(r
<<16)|(c1
<<12)|r2
);
1582 /* convert integers to fp 't' type. Must handle 'int', 'unsigned int'
1583 and 'long long' cases. */
1584 ST_FUNC
void gen_cvt_itof1(int t
)
1588 bt
=vtop
->type
.t
& VT_BTYPE
;
1589 if(bt
== VT_INT
|| bt
== VT_SHORT
|| bt
== VT_BYTE
) {
1595 r2
=vfpr(vtop
->r
=get_reg(RC_FLOAT
));
1596 o(0xEE000A10|(r
<<12)|(r2
<<16)); /* fmsr */
1598 if(!(vtop
->type
.t
& VT_UNSIGNED
))
1599 r2
|=0x80; /* fuitoX -> fsituX */
1600 o(0xEEB80A40|r2
|T2CPR(t
)); /* fYitoX*/
1602 r2
=fpr(vtop
->r
=get_reg(RC_FLOAT
));
1603 if((t
& VT_BTYPE
) != VT_FLOAT
)
1604 dsize
=0x80; /* flts -> fltd */
1605 o(0xEE000110|dsize
|(r2
<<16)|(r
<<12)); /* flts */
1606 if((vtop
->type
.t
& (VT_UNSIGNED
|VT_BTYPE
)) == (VT_UNSIGNED
|VT_INT
)) {
1608 o(0xE3500000|(r
<<12)); /* cmp */
1609 r
=fpr(get_reg(RC_FLOAT
));
1610 if(last_itod_magic
) {
1611 off
=ind
+8-last_itod_magic
;
1616 o(0xBD1F0100|(r
<<12)|off
); /* ldflts */
1618 o(0xEA000000); /* b */
1619 last_itod_magic
=ind
;
1620 o(0x4F800000); /* 4294967296.0f */
1622 o(0xBE000100|dsize
|(r2
<<16)|(r2
<<12)|r
); /* adflt */
1626 } else if(bt
== VT_LLONG
) {
1628 CType
*func_type
= 0;
1629 if((t
& VT_BTYPE
) == VT_FLOAT
) {
1630 func_type
= &func_float_type
;
1631 if(vtop
->type
.t
& VT_UNSIGNED
)
1632 func
=TOK___floatundisf
;
1634 func
=TOK___floatdisf
;
1635 #if LDOUBLE_SIZE != 8
1636 } else if((t
& VT_BTYPE
) == VT_LDOUBLE
) {
1637 func_type
= &func_ldouble_type
;
1638 if(vtop
->type
.t
& VT_UNSIGNED
)
1639 func
=TOK___floatundixf
;
1641 func
=TOK___floatdixf
;
1642 } else if((t
& VT_BTYPE
) == VT_DOUBLE
) {
1644 } else if((t
& VT_BTYPE
) == VT_DOUBLE
|| (t
& VT_BTYPE
) == VT_LDOUBLE
) {
1646 func_type
= &func_double_type
;
1647 if(vtop
->type
.t
& VT_UNSIGNED
)
1648 func
=TOK___floatundidf
;
1650 func
=TOK___floatdidf
;
1653 vpush_global_sym(func_type
, func
);
1661 error("unimplemented gen_cvt_itof %x!",vtop
->type
.t
);
1664 /* convert fp to int 't' type */
1665 void gen_cvt_ftoi(int t
)
1671 r2
=vtop
->type
.t
& VT_BTYPE
;
1674 r
=vfpr(gv(RC_FLOAT
));
1676 o(0xEEBC0A40|(r
<<12)|r
|T2CPR(r2
)); /* ftoXiY */
1677 r2
=intr(vtop
->r
=get_reg(RC_INT
));
1678 o(0xEE100A10|(r
<<16)|(r2
<<12));
1683 func
=TOK___fixunssfsi
;
1684 #if LDOUBLE_SIZE != 8
1685 else if(r2
== VT_LDOUBLE
)
1686 func
=TOK___fixunsxfsi
;
1687 else if(r2
== VT_DOUBLE
)
1689 else if(r2
== VT_LDOUBLE
|| r2
== VT_DOUBLE
)
1691 func
=TOK___fixunsdfsi
;
1693 r
=fpr(gv(RC_FLOAT
));
1694 r2
=intr(vtop
->r
=get_reg(RC_INT
));
1695 o(0xEE100170|(r2
<<12)|r
);
1699 } else if(t
== VT_LLONG
) { // unsigned handled in gen_cvt_ftoi1
1702 #if LDOUBLE_SIZE != 8
1703 else if(r2
== VT_LDOUBLE
)
1705 else if(r2
== VT_DOUBLE
)
1707 else if(r2
== VT_LDOUBLE
|| r2
== VT_DOUBLE
)
1712 vpush_global_sym(&func_old_type
, func
);
1717 vtop
->r2
= REG_LRET
;
1721 error("unimplemented gen_cvt_ftoi!");
1724 /* convert from one floating point type to another */
1725 void gen_cvt_ftof(int t
)
1728 if(((vtop
->type
.t
& VT_BTYPE
) == VT_FLOAT
) != ((t
& VT_BTYPE
) == VT_FLOAT
)) {
1729 uint32_t r
= vfpr(gv(RC_FLOAT
));
1730 o(0xEEB70AC0|(r
<<12)|r
|T2CPR(vtop
->type
.t
));
1733 /* all we have to do on i386 and FPA ARM is to put the float in a register */
1738 /* computed goto support */
1745 /* end of ARM code generator */
1746 /*************************************************************/
1748 /*************************************************************/