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
28 /* number of available registers */
35 /* a register can belong to several classes. The classes must be
36 sorted from more general to more precise (see gv2() code which does
37 assumptions on it). */
38 #define RC_INT 0x0001 /* generic integer register */
39 #define RC_FLOAT 0x0002 /* generic float register */
55 #define RC_IRET RC_R0 /* function return: integer register */
56 #define RC_LRET RC_R1 /* function return: second integer register */
57 #define RC_FRET RC_F0 /* function return: float register */
59 /* pretty names for the registers */
78 int reg_classes
[NB_REGS
] = {
79 /* r0 */ RC_INT
| RC_R0
,
80 /* r1 */ RC_INT
| RC_R1
,
81 /* r2 */ RC_INT
| RC_R2
,
82 /* r3 */ RC_INT
| RC_R3
,
83 /* r12 */ RC_INT
| RC_R12
,
84 /* f0 */ RC_FLOAT
| RC_F0
,
85 /* f1 */ RC_FLOAT
| RC_F1
,
86 /* f2 */ RC_FLOAT
| RC_F2
,
87 /* f3 */ RC_FLOAT
| RC_F3
,
89 /* d4/s8 */ RC_FLOAT
| RC_F4
,
90 /* d5/s10 */ RC_FLOAT
| RC_F5
,
91 /* d6/s12 */ RC_FLOAT
| RC_F6
,
92 /* d7/s14 */ RC_FLOAT
| RC_F7
,
96 static int two2mask(int a
,int b
) {
97 return (reg_classes
[a
]|reg_classes
[b
])&~(RC_INT
|RC_FLOAT
);
100 static int regmask(int r
) {
101 return reg_classes
[r
]&~(RC_INT
|RC_FLOAT
);
105 #define T2CPR(t) (((t) & VT_BTYPE) != VT_FLOAT ? 0x100 : 0)
108 /* return registers for function */
109 #define REG_IRET TREG_R0 /* single word int return register */
110 #define REG_LRET TREG_R1 /* second word return register (for long long) */
111 #define REG_FRET TREG_F0 /* float return register */
113 /* defined if function parameters must be evaluated in reverse order */
114 #define INVERT_FUNC_PARAMS
116 /* defined if structures are passed as pointers. Otherwise structures
117 are directly pushed on stack. */
118 //#define FUNC_STRUCT_PARAM_AS_PTR
120 #if defined(TCC_ARM_EABI) && defined(TCC_ARM_VFP)
121 static CType float_type
, double_type
, func_float_type
, func_double_type
;
124 /* pointer size, in bytes */
127 /* long double size and alignment, in bytes */
129 #define LDOUBLE_SIZE 8
133 #define LDOUBLE_SIZE 8
137 #define LDOUBLE_ALIGN 8
139 #define LDOUBLE_ALIGN 4
142 /* maximum alignment (for aligned attribute support) */
145 #define CHAR_IS_UNSIGNED
147 /******************************************************/
150 #define EM_TCC_TARGET EM_ARM
152 /* relocation type for 32 bit data relocation */
153 #define R_DATA_32 R_ARM_ABS32
154 #define R_JMP_SLOT R_ARM_JUMP_SLOT
155 #define R_COPY R_ARM_COPY
157 #define ELF_START_ADDR 0x00008000
158 #define ELF_PAGE_SIZE 0x1000
160 /******************************************************/
161 static unsigned long func_sub_sp_offset
,last_itod_magic
;
164 void o(unsigned long i
)
166 /* this is a good place to start adding big-endian support*/
170 if (!cur_text_section
)
171 error("compiler error! This happens f.ex. if the compiler\n"
172 "can't evaluate constant expressions outside of a function.");
173 if (ind1
> cur_text_section
->data_allocated
)
174 section_realloc(cur_text_section
, ind1
);
175 cur_text_section
->data
[ind
++] = i
&255;
177 cur_text_section
->data
[ind
++] = i
&255;
179 cur_text_section
->data
[ind
++] = i
&255;
181 cur_text_section
->data
[ind
++] = i
;
184 static unsigned long stuff_const(unsigned long op
,unsigned long c
)
187 unsigned long nc
= 0,negop
= 0;
197 case 0x1A00000: //mov
198 case 0x1E00000: //mvn
205 return (op
&0xF010F000)|((op
>>16)&0xF)|0x1E00000;
209 return (op
&0xF010F000)|((op
>>16)&0xF)|0x1A00000;
210 case 0x1C00000: //bic
215 case 0x1800000: //orr
217 return (op
&0xFFF0FFFF)|0x1E00000;
223 if(c
<256) /* catch undefined <<32 */
226 m
=(0xff>>i
)|(0xff<<(32-i
));
228 return op
|(i
<<7)|(c
<<i
)|(c
>>(32-i
));
238 void stuff_const_harder(unsigned long op
,unsigned long v
) {
244 unsigned long a
[16],nv
,no
,o2
,n2
;
247 o2
=(op
&0xfff0ffff)|((op
&0xf000)<<4);;
249 a
[i
]=(a
[i
-1]>>2)|(a
[i
-1]<<30);
251 for(j
=i
+4;i
<13+i
;i
++)
252 if((v
&(a
[i
]|a
[j
]))==v
) {
253 o(stuff_const(op
,v
&a
[i
]));
254 o(stuff_const(o2
,v
&a
[j
]));
261 for(j
=i
+4;i
<13+i
;i
++)
262 if((nv
&(a
[i
]|a
[j
]))==nv
) {
263 o(stuff_const(no
,nv
&a
[i
]));
264 o(stuff_const(n2
,nv
&a
[j
]));
269 for(k
=j
+4;k
<13+i
;i
++)
270 if((v
&(a
[i
]|a
[j
]|a
[k
]))==v
) {
271 o(stuff_const(op
,v
&a
[i
]));
272 o(stuff_const(o2
,v
&a
[j
]));
273 o(stuff_const(o2
,v
&a
[k
]));
280 for(k
=j
+4;k
<13+i
;i
++)
281 if((nv
&(a
[i
]|a
[j
]|a
[k
]))==nv
) {
282 o(stuff_const(no
,nv
&a
[i
]));
283 o(stuff_const(n2
,nv
&a
[j
]));
284 o(stuff_const(n2
,nv
&a
[k
]));
287 o(stuff_const(op
,v
&a
[0]));
288 o(stuff_const(o2
,v
&a
[4]));
289 o(stuff_const(o2
,v
&a
[8]));
290 o(stuff_const(o2
,v
&a
[12]));
294 unsigned long encbranch(int pos
,int addr
,int fail
)
298 if(addr
>=0x1000000 || addr
<-0x1000000) {
300 error("FIXME: function bigger than 32MB");
303 return 0x0A000000|(addr
&0xffffff);
306 int decbranch(int pos
)
309 x
=*(int *)(cur_text_section
->data
+ pos
);
316 /* output a symbol and patch all calls to it */
317 void gsym_addr(int t
, int a
)
322 x
=(unsigned long *)(cur_text_section
->data
+ t
);
325 *x
=0xE1A00000; // nop
328 *x
|= encbranch(lt
,a
,1);
339 static unsigned long vfpr(int r
)
341 if(r
<TREG_F0
|| r
>TREG_F7
)
342 error("compiler error! register %i is no vfp register",r
);
346 static unsigned long fpr(int r
)
348 if(r
<TREG_F0
|| r
>TREG_F3
)
349 error("compiler error! register %i is no fpa register",r
);
354 static unsigned long intr(int r
)
358 if((r
<0 || r
>4) && r
!=14)
359 error("compiler error! register %i is no int register",r
);
363 static void calcaddr(unsigned long *base
,int *off
,int *sgn
,int maxoff
,unsigned shift
)
365 if(*off
>maxoff
|| *off
&((1<<shift
)-1)) {
372 y
=stuff_const(x
,*off
&~maxoff
);
378 y
=stuff_const(x
,(*off
+maxoff
)&~maxoff
);
382 *off
=((*off
+maxoff
)&~maxoff
)-*off
;
385 stuff_const_harder(x
,*off
&~maxoff
);
390 static unsigned long mapcc(int cc
)
395 return 0x30000000; /* CC/LO */
397 return 0x20000000; /* CS/HS */
399 return 0x00000000; /* EQ */
401 return 0x10000000; /* NE */
403 return 0x90000000; /* LS */
405 return 0x80000000; /* HI */
407 return 0x40000000; /* MI */
409 return 0x50000000; /* PL */
411 return 0xB0000000; /* LT */
413 return 0xA0000000; /* GE */
415 return 0xD0000000; /* LE */
417 return 0xC0000000; /* GT */
419 error("unexpected condition code");
420 return 0xE0000000; /* AL */
423 static int negcc(int cc
)
452 error("unexpected condition code");
456 /* load 'r' from value 'sv' */
457 void load(int r
, SValue
*sv
)
459 int v
, ft
, fc
, fr
, sign
;
476 unsigned long base
=0xB; // fp
479 v1
.r
= VT_LOCAL
| VT_LVAL
;
481 load(base
=14 /* lr */, &v1
);
484 } else if(v
== VT_CONST
) {
492 } else if(v
< VT_CONST
) {
499 calcaddr(&base
,&fc
,&sign
,1020,2);
501 op
=0xED100A00; /* flds */
504 if ((ft
& VT_BTYPE
) != VT_FLOAT
)
505 op
|=0x100; /* flds -> fldd */
506 o(op
|(vfpr(r
)<<12)|(fc
>>2)|(base
<<16));
511 #if LDOUBLE_SIZE == 8
512 if ((ft
& VT_BTYPE
) != VT_FLOAT
)
515 if ((ft
& VT_BTYPE
) == VT_DOUBLE
)
517 else if ((ft
& VT_BTYPE
) == VT_LDOUBLE
)
520 o(op
|(fpr(r
)<<12)|(fc
>>2)|(base
<<16));
522 } else if((ft
& (VT_BTYPE
|VT_UNSIGNED
)) == VT_BYTE
523 || (ft
& VT_BTYPE
) == VT_SHORT
) {
524 calcaddr(&base
,&fc
,&sign
,255,0);
526 if ((ft
& VT_BTYPE
) == VT_SHORT
)
528 if ((ft
& VT_UNSIGNED
) == 0)
532 o(op
|(intr(r
)<<12)|(base
<<16)|((fc
&0xf0)<<4)|(fc
&0xf));
534 calcaddr(&base
,&fc
,&sign
,4095,0);
538 if ((ft
& VT_BTYPE
) == VT_BYTE
)
540 o(op
|(intr(r
)<<12)|fc
|(base
<<16));
546 op
=stuff_const(0xE3A00000|(intr(r
)<<12),sv
->c
.ul
);
547 if (fr
& VT_SYM
|| !op
) {
548 o(0xE59F0000|(intr(r
)<<12));
551 greloc(cur_text_section
, sv
->sym
, ind
, R_ARM_ABS32
);
556 } else if (v
== VT_LOCAL
) {
557 op
=stuff_const(0xE28B0000|(intr(r
)<<12),sv
->c
.ul
);
558 if (fr
& VT_SYM
|| !op
) {
559 o(0xE59F0000|(intr(r
)<<12));
561 if(fr
& VT_SYM
) // needed ?
562 greloc(cur_text_section
, sv
->sym
, ind
, R_ARM_ABS32
);
564 o(0xE08B0000|(intr(r
)<<12)|intr(r
));
568 } else if(v
== VT_CMP
) {
569 o(mapcc(sv
->c
.ul
)|0x3A00001|(intr(r
)<<12));
570 o(mapcc(negcc(sv
->c
.ul
))|0x3A00000|(intr(r
)<<12));
572 } else if (v
== VT_JMP
|| v
== VT_JMPI
) {
575 o(0xE3A00000|(intr(r
)<<12)|t
);
578 o(0xE3A00000|(intr(r
)<<12)|(t
^1));
580 } else if (v
< VT_CONST
) {
583 o(0xEEB00A40|(vfpr(r
)<<12)|vfpr(v
)|T2CPR(ft
)); /* fcpyX */
585 o(0xEE008180|(fpr(r
)<<12)|fpr(v
));
588 o(0xE1A00000|(intr(r
)<<12)|intr(v
));
592 error("load unimplemented!");
595 /* store register 'r' in lvalue 'v' */
596 void store(int r
, SValue
*sv
)
599 int v
, ft
, fc
, fr
, sign
;
614 if (fr
& VT_LVAL
|| fr
== VT_LOCAL
) {
615 unsigned long base
=0xb;
620 } else if(v
== VT_CONST
) {
631 calcaddr(&base
,&fc
,&sign
,1020,2);
633 op
=0xED000A00; /* fsts */
636 if ((ft
& VT_BTYPE
) != VT_FLOAT
)
637 op
|=0x100; /* fsts -> fstd */
638 o(op
|(vfpr(r
)<<12)|(fc
>>2)|(base
<<16));
643 #if LDOUBLE_SIZE == 8
644 if ((ft
& VT_BTYPE
) != VT_FLOAT
)
647 if ((ft
& VT_BTYPE
) == VT_DOUBLE
)
649 if ((ft
& VT_BTYPE
) == VT_LDOUBLE
)
652 o(op
|(fpr(r
)<<12)|(fc
>>2)|(base
<<16));
655 } else if((ft
& VT_BTYPE
) == VT_SHORT
) {
656 calcaddr(&base
,&fc
,&sign
,255,0);
660 o(op
|(intr(r
)<<12)|(base
<<16)|((fc
&0xf0)<<4)|(fc
&0xf));
662 calcaddr(&base
,&fc
,&sign
,4095,0);
666 if ((ft
& VT_BTYPE
) == VT_BYTE
)
668 o(op
|(intr(r
)<<12)|fc
|(base
<<16));
673 error("store unimplemented");
676 static void gadd_sp(int val
)
678 stuff_const_harder(0xE28DD000,val
);
681 /* 'is_jmp' is '1' if it is a jump */
682 static void gcall_or_jmp(int is_jmp
)
685 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
)) == VT_CONST
) {
688 x
=encbranch(ind
,ind
+vtop
->c
.ul
,0);
690 if (vtop
->r
& VT_SYM
) {
691 /* relocation case */
692 greloc(cur_text_section
, vtop
->sym
, ind
, R_ARM_PC24
);
694 put_elf_reloc(symtab_section
, cur_text_section
, ind
, R_ARM_PC24
, 0);
695 o(x
|(is_jmp
?0xE0000000:0xE1000000));
698 o(0xE28FE004); // add lr,pc,#4
699 o(0xE51FF004); // ldr pc,[pc,#-4]
700 if (vtop
->r
& VT_SYM
)
701 greloc(cur_text_section
, vtop
->sym
, ind
, R_ARM_ABS32
);
705 /* otherwise, indirect call */
708 o(0xE1A0E00F); // mov lr,pc
709 o(0xE1A0F000|intr(r
)); // mov pc,r
713 /* Generate function call. The function address is pushed first, then
714 all the parameters in call order. This functions pops all the
715 parameters and the function address. */
716 void gfunc_call(int nb_args
)
718 int size
, align
, r
, args_size
, i
;
720 signed char plan
[4][2]={{-1,-1},{-1,-1},{-1,-1},{-1,-1}};
721 int todo
=0xf, keep
, plan2
[4]={0,0,0,0};
723 r
= vtop
->r
& VT_VALMASK
;
724 if (r
== VT_CMP
|| (r
& ~1) == VT_JMP
)
727 if((vtop
[-nb_args
].type
.ref
->type
.t
& VT_BTYPE
) == VT_STRUCT
728 && type_size(&vtop
[-nb_args
].type
, &align
) <= 4) {
731 vtop
[-nb_args
]=vtop
[-nb_args
+1];
732 vtop
[-nb_args
+1]=tmp
;
737 vtop
->type
.t
= VT_LLONG
;
739 for(i
= nb_args
+ 1 ; i
-- ;) {
740 size
= type_size(&vtop
[-i
].type
, &align
);
741 if(args_size
& (align
-1)) {
743 vtop
->type
.t
= VT_VOID
; /* padding */
748 args_size
+= (size
+ 3) & -4;
753 for(i
= nb_args
; i
-- && args_size
< 16 ;) {
754 switch(vtop
[-i
].type
.t
& VT_BTYPE
) {
759 size
= type_size(&vtop
[-i
].type
, &align
);
760 size
= (size
+ 3) & -4;
764 plan
[nb_args
-1-i
][0]=args_size
/4;
766 if ((vtop
[-i
].type
.t
& VT_BTYPE
) == VT_LLONG
&& args_size
< 16) {
767 plan
[nb_args
-1-i
][1]=args_size
/4;
772 args_size
= keep
= 0;
773 for(i
= 0;i
< nb_args
; i
++) {
775 if ((vtop
->type
.t
& VT_BTYPE
) == VT_STRUCT
) {
776 size
= type_size(&vtop
->type
, &align
);
777 /* align to stack align size */
778 size
= (size
+ 3) & -4;
779 /* allocate the necessary size on stack */
781 /* generate structure store */
783 o(0xE1A0000D|(intr(r
)<<12));
784 vset(&vtop
->type
, r
| VT_LVAL
, 0);
789 } else if (is_float(vtop
->type
.t
)) {
791 r
=vfpr(gv(RC_FLOAT
))<<12;
793 if ((vtop
->type
.t
& VT_BTYPE
) != VT_FLOAT
)
796 r
|=0x101; /* fstms -> fstmd */
800 r
=fpr(gv(RC_FLOAT
))<<12;
801 if ((vtop
->type
.t
& VT_BTYPE
) == VT_FLOAT
)
803 else if ((vtop
->type
.t
& VT_BTYPE
) == VT_DOUBLE
)
813 o(0xED2D0100|r
|(size
>>2));
819 /* simple type (currently always same size) */
820 /* XXX: implicit cast ? */
822 if ((vtop
->type
.t
& VT_BTYPE
) == VT_LLONG
) {
825 if(nb_args
-i
<5 && plan
[nb_args
-i
-1][1]!=-1) {
826 s
=regmask(plan
[nb_args
-i
-1][1]);
827 todo
&=~(1<<plan
[nb_args
-i
-1][1]);
831 o(0xE52D0004|(intr(r
)<<12)); /* str r,[sp,#-4]! */
841 if(nb_args
-i
<5 && plan
[nb_args
-i
-1][0]!=-1) {
842 s
=regmask(plan
[nb_args
-i
-1][0]);
843 todo
&=~(1<<plan
[nb_args
-i
-1][0]);
846 if(vtop
->type
.t
== VT_VOID
) {
848 o(0xE24DD004); /* sub sp,sp,#4 */
854 o(0xE52D0004|(intr(r
)<<12)); /* str r,[sp,#-4]! */
867 save_regs(keep
); /* save used temporary registers */
888 func_sym
= vtop
->type
.ref
;
893 if((vtop
->type
.ref
->type
.t
& VT_BTYPE
) == VT_STRUCT
894 && type_size(&vtop
->type
.ref
->type
, &align
) <= 4)
896 store(REG_IRET
,vtop
-keep
);
900 else if(is_float(vtop
->type
.ref
->type
.t
)) {
901 if((vtop
->type
.ref
->type
.t
& VT_BTYPE
) == VT_FLOAT
) {
902 o(0xEE000A10); /* fmsr s0,r0 */
904 o(0xEE000B10); /* fmdlr d0,r0 */
905 o(0xEE201B10); /* fmdhr d0,r1 */
914 /* generate function prolog of type 't' */
915 void gfunc_prolog(CType
*func_type
)
918 int n
,addr
,size
,align
;
920 sym
= func_type
->ref
;
925 if((func_vt
.t
& VT_BTYPE
) == VT_STRUCT
926 && type_size(&func_vt
,&align
) > 4)
932 for(sym2
=sym
->next
;sym2
&& n
<4;sym2
=sym2
->next
) {
933 size
= type_size(&sym2
->type
, &align
);
936 o(0xE1A0C00D); /* mov ip,sp */
937 if(func_type
->ref
->c
== FUNC_ELLIPSIS
)
945 o(0xE92D0000|((1<<n
)-1)); /* save r0-r4 on stack if needed */
947 o(0xE92D5800); /* save fp, ip, lr */
948 o(0xE28DB00C); /* add fp, sp, #12 */
949 func_sub_sp_offset
= ind
;
950 o(0xE1A00000); /* nop, leave space for stack adjustment */
951 while ((sym
= sym
->next
)) {
954 size
= type_size(type
, &align
);
955 size
= (size
+ 3) & -4;
957 addr
= (addr
+ align
- 1) & -align
;
959 sym_push(sym
->v
& ~SYM_FIELD
, type
, VT_LOCAL
| VT_LVAL
, addr
);
967 /* generate function epilog */
968 void gfunc_epilog(void)
973 if(is_float(func_vt
.t
)) {
974 if((func_vt
.t
& VT_BTYPE
) == VT_FLOAT
)
975 o(0xEE100A10); /* fmrs r0, s0 */
977 o(0xEE100B10); /* fmrdl r0, d0 */
978 o(0xEE301B10); /* fmrdh r1, d0 */
982 o(0xE91BA800); /* restore fp, sp, pc */
983 diff
= (-loc
+ 3) & -4;
986 diff
= (diff
+ 7) & -8;
989 x
=stuff_const(0xE24BD000, diff
); /* sub sp,fp,# */
991 *(unsigned long *)(cur_text_section
->data
+ func_sub_sp_offset
) = x
;
995 o(0xE59FC004); /* ldr ip,[pc+4] */
996 o(0xE04BD00C); /* sub sp,fp,ip */
997 o(0xE1A0F00E); /* mov pc,lr */
999 *(unsigned long *)(cur_text_section
->data
+ func_sub_sp_offset
) = 0xE1000000|encbranch(func_sub_sp_offset
,addr
,1);
1004 /* generate a jump to a label */
1009 o(0xE0000000|encbranch(r
,t
,1));
1013 /* generate a jump to a fixed address */
1014 void gjmp_addr(int a
)
1019 /* generate a test. set 'inv' to invert test. Stack entry is popped */
1020 int gtst(int inv
, int t
)
1024 v
= vtop
->r
& VT_VALMASK
;
1027 op
=mapcc(inv
?negcc(vtop
->c
.i
):vtop
->c
.i
);
1028 op
|=encbranch(r
,t
,1);
1031 } else if (v
== VT_JMP
|| v
== VT_JMPI
) {
1032 if ((v
& 1) == inv
) {
1041 p
= decbranch(lp
=p
);
1043 x
= (unsigned long *)(cur_text_section
->data
+ lp
);
1045 *x
|= encbranch(lp
,t
,1);
1054 if (is_float(vtop
->type
.t
)) {
1057 o(0xEEB50A40|(vfpr(r
)<<12)|T2CPR(vtop
->type
.t
)); /* fcmpzX */
1058 o(0xEEF1FA10); /* fmstat */
1060 o(0xEE90F118|(fpr(r
)<<16));
1064 return gtst(inv
, t
);
1065 } else if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
) {
1066 /* constant jmp optimization */
1067 if ((vtop
->c
.i
!= 0) != inv
)
1071 o(0xE3300000|(intr(v
)<<16));
1074 return gtst(inv
, t
);
1081 /* generate an integer binary operation */
1082 void gen_opi(int op
)
1085 unsigned long opc
= 0,r
,fr
;
1093 case TOK_ADDC1
: /* add with carry generation */
1101 case TOK_SUBC1
: /* sub with carry generation */
1105 case TOK_ADDC2
: /* add with carry use */
1109 case TOK_SUBC2
: /* sub with carry use */
1126 gv2(RC_INT
, RC_INT
);
1130 o(0xE0000090|(intr(r
)<<16)|(intr(r
)<<8)|intr(fr
));
1162 gv2(RC_INT
, RC_INT
);
1163 r
=intr(vtop
[-1].r2
=get_reg(RC_INT
));
1165 vtop
[-1].r
=get_reg_ex(RC_INT
,regmask(c
));
1167 o(0xE0800090|(r
<<16)|(intr(vtop
->r
)<<12)|(intr(c
)<<8)|intr(vtop
[1].r
));
1176 if((vtop
[-1].r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
) {
1177 if(opc
== 4 || opc
== 5 || opc
== 0xc) {
1179 opc
|=2; // sub -> rsb
1182 if ((vtop
->r
& VT_VALMASK
) == VT_CMP
||
1183 (vtop
->r
& (VT_VALMASK
& ~1)) == VT_JMP
)
1188 opc
=0xE0000000|(opc
<<20)|(c
<<16);
1189 if((vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
) {
1191 x
=stuff_const(opc
|0x2000000,vtop
->c
.i
);
1193 r
=intr(vtop
[-1].r
=get_reg_ex(RC_INT
,regmask(vtop
[-1].r
)));
1198 fr
=intr(gv(RC_INT
));
1199 r
=intr(vtop
[-1].r
=get_reg_ex(RC_INT
,two2mask(vtop
->r
,vtop
[-1].r
)));
1203 if (op
>= TOK_ULT
&& op
<= TOK_GT
) {
1209 opc
=0xE1A00000|(opc
<<5);
1210 if ((vtop
->r
& VT_VALMASK
) == VT_CMP
||
1211 (vtop
->r
& (VT_VALMASK
& ~1)) == VT_JMP
)
1217 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
) {
1218 fr
=intr(vtop
[-1].r
=get_reg_ex(RC_INT
,regmask(vtop
[-1].r
)));
1219 c
= vtop
->c
.i
& 0x1f;
1220 o(opc
|(c
<<7)|(fr
<<12));
1222 fr
=intr(gv(RC_INT
));
1223 c
=intr(vtop
[-1].r
=get_reg_ex(RC_INT
,two2mask(vtop
->r
,vtop
[-1].r
)));
1224 o(opc
|(c
<<12)|(fr
<<8)|0x10);
1229 vpush_global_sym(&func_old_type
, func
);
1236 error("gen_opi %i unimplemented!",op
);
1241 static int is_zero(int i
)
1243 if((vtop
[i
].r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) != VT_CONST
)
1245 if (vtop
[i
].type
.t
== VT_FLOAT
)
1246 return (vtop
[i
].c
.f
== 0.f
);
1247 else if (vtop
[i
].type
.t
== VT_DOUBLE
)
1248 return (vtop
[i
].c
.d
== 0.0);
1249 return (vtop
[i
].c
.ld
== 0.l
);
1252 /* generate a floating point operation 'v = t1 op t2' instruction. The
1253 * two operands are guaranted to have the same floating point type */
1254 void gen_opf(int op
)
1258 x
=0xEE000A00|T2CPR(vtop
->type
.t
);
1276 x
|=0x810000; /* fsubX -> fnegX */
1289 if(op
< TOK_ULT
&& op
> TOK_GT
) {
1290 error("unknown fp op %x!",op
);
1296 case TOK_LT
: op
=TOK_GT
; break;
1297 case TOK_GE
: op
=TOK_ULE
; break;
1298 case TOK_LE
: op
=TOK_GE
; break;
1299 case TOK_GT
: op
=TOK_ULT
; break;
1302 x
|=0xB40040; /* fcmpX */
1303 if(op
!=TOK_EQ
&& op
!=TOK_NE
)
1304 x
|=0x80; /* fcmpX -> fcmpeX */
1307 o(x
|0x10000|(vfpr(gv(RC_FLOAT
))<<12)); /* fcmp(e)X -> fcmp(e)zX */
1309 x
|=vfpr(gv(RC_FLOAT
));
1311 o(x
|(vfpr(gv(RC_FLOAT
))<<12));
1314 o(0xEEF1FA10); /* fmstat */
1317 case TOK_LE
: op
=TOK_ULE
; break;
1318 case TOK_LT
: op
=TOK_ULT
; break;
1319 case TOK_UGE
: op
=TOK_GE
; break;
1320 case TOK_UGT
: op
=TOK_GT
; break;
1337 vtop
->r
=get_reg_ex(RC_FLOAT
,r
);
1340 o(x
|(vfpr(vtop
->r
)<<12));
1344 static int is_fconst()
1348 if((vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) != VT_CONST
)
1350 if (vtop
->type
.t
== VT_FLOAT
)
1352 else if (vtop
->type
.t
== VT_DOUBLE
)
1382 /* generate a floating point operation 'v = t1 op t2' instruction. The
1383 two operands are guaranted to have the same floating point type */
1384 void gen_opf(int op
)
1388 //fputs("gen_opf\n",stderr);
1394 #if LDOUBLE_SIZE == 8
1395 if ((vtop
->type
.t
& VT_BTYPE
) != VT_FLOAT
)
1398 if ((vtop
->type
.t
& VT_BTYPE
) == VT_DOUBLE
)
1400 else if ((vtop
->type
.t
& VT_BTYPE
) == VT_LDOUBLE
)
1411 r
=fpr(gv(RC_FLOAT
));
1418 r2
=fpr(gv(RC_FLOAT
));
1427 r
=fpr(gv(RC_FLOAT
));
1429 } else if(c1
&& c1
<=0xf) {
1432 r
=fpr(gv(RC_FLOAT
));
1437 r
=fpr(gv(RC_FLOAT
));
1439 r2
=fpr(gv(RC_FLOAT
));
1448 r
=fpr(gv(RC_FLOAT
));
1453 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
));
1477 if(op
>= TOK_ULT
&& op
<= TOK_GT
) {
1478 x
|=0xd0f110; // cmfe
1479 /* bug (intention?) in Linux FPU emulator
1480 doesn't set carry if equal */
1486 error("unsigned comparision on floats?");
1492 op
=TOK_ULE
; /* correct in unordered case only if AC bit in FPSR set */
1496 x
&=~0x400000; // cmfe -> cmf
1518 r
=fpr(gv(RC_FLOAT
));
1525 r2
=fpr(gv(RC_FLOAT
));
1527 vtop
[-1].r
= VT_CMP
;
1530 error("unknown fp op %x!",op
);
1534 if(vtop
[-1].r
== VT_CMP
)
1540 vtop
[-1].r
=get_reg_ex(RC_FLOAT
,two2mask(vtop
[-1].r
,c1
));
1544 o(x
|(r
<<16)|(c1
<<12)|r2
);
1548 /* convert integers to fp 't' type. Must handle 'int', 'unsigned int'
1549 and 'long long' cases. */
1550 void gen_cvt_itof(int t
)
1553 bt
=vtop
->type
.t
& VT_BTYPE
;
1554 if(bt
== VT_INT
|| bt
== VT_SHORT
|| bt
== VT_BYTE
) {
1557 r2
=vfpr(vtop
->r
=get_reg(RC_FLOAT
));
1558 o(0xEE000A10|(r
<<12)|(r2
<<16)); /* fmsr */
1560 if(!(vtop
->type
.t
& VT_UNSIGNED
))
1561 r2
|=0x80; /* fuitoX -> fsituX */
1562 o(0xEEB80A40|r2
|T2CPR(t
)); /* fYitoX*/
1564 r2
=fpr(vtop
->r
=get_reg(RC_FLOAT
));
1565 o(0xEE000190|(r2
<<16)|(r
<<12));
1566 if((vtop
->type
.t
& (VT_UNSIGNED
|VT_BTYPE
)) == (VT_UNSIGNED
|VT_INT
)) {
1568 o(0xE3500000|(r
<<12));
1569 r
=fpr(get_reg(RC_FLOAT
));
1570 if(last_itod_magic
) {
1571 off
=ind
+8-last_itod_magic
;
1576 o(0xBD1F8100|(r
<<12)|off
);
1579 last_itod_magic
=ind
;
1583 o(0xBE000180|(r2
<<16)|(r2
<<12)|r
);
1587 } else if(bt
== VT_LLONG
) {
1589 CType
*func_type
= &func_old_type
;
1592 func_type
= &func_double_type
;
1594 if((t
& VT_BTYPE
) == VT_FLOAT
) {
1596 func_type
= &func_float_type
;
1598 if(vtop
->type
.t
& VT_UNSIGNED
)
1604 if(vtop
->type
.t
& VT_UNSIGNED
)
1608 vpush_global_sym(func_type
, func
);
1615 error("unimplemented gen_cvt_itof %x!",vtop
->type
.t
);
1618 /* convert fp to int 't' type */
1619 void gen_cvt_ftoi(int t
)
1624 r2
=vtop
->type
.t
& VT_BTYPE
;
1627 r
=vfpr(gv(RC_FLOAT
));
1629 o(0xEEBC0A40|(r
<<12)|r
|T2CPR(r2
)); /* ftoXiY */
1630 r2
=intr(vtop
->r
=get_reg(RC_INT
));
1631 o(0xEE100A10|(r
<<16)|(r2
<<12));
1636 func
=TOK___fixunssfsi
;
1637 else if(r2
== VT_DOUBLE
)
1638 func
=TOK___fixunsdfsi
;
1639 else if(r2
== VT_LDOUBLE
)
1640 #if LDOUBLE_SIZE == 8
1641 func
=TOK___fixunsdfsi
;
1643 func
=TOK___fixunsxfsi
;
1646 r
=fpr(gv(RC_FLOAT
));
1647 r2
=intr(vtop
->r
=get_reg(RC_INT
));
1648 o(0xEE100170|(r2
<<12)|r
);
1652 } else if(t
== VT_LLONG
) { // unsigned handled in gen_cvt_ftoi1
1655 else if(r2
== VT_DOUBLE
)
1657 else if(r2
== VT_LDOUBLE
)
1658 #if LDOUBLE_SIZE == 8
1665 vpush_global_sym(&func_old_type
, func
);
1670 vtop
->r2
= REG_LRET
;
1674 error("unimplemented gen_cvt_ftoi!");
1677 /* convert from one floating point type to another */
1678 void gen_cvt_ftof(int t
)
1681 if(((vtop
->type
.t
& VT_BTYPE
) == VT_FLOAT
) != ((t
& VT_BTYPE
) == VT_FLOAT
)) {
1682 int r
=vfpr(gv(RC_FLOAT
));
1683 o(0xEEB70AC0|(r
<<12)|r
|T2CPR(vtop
->type
.t
));
1686 /* all we have to do on i386 and FPA ARM is to put the float in a register */
1691 /* computed goto support */
1698 /* end of ARM code generator */
1699 /*************************************************************/