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 /* number of available registers */
26 /* a register can belong to several classes. The classes must be
27 sorted from more general to more precise (see gv2() code which does
28 assumptions on it). */
29 #define RC_INT 0x0001 /* generic integer register */
30 #define RC_FLOAT 0x0002 /* generic float register */
40 #define RC_IRET RC_R0 /* function return: integer register */
41 #define RC_LRET RC_R1 /* function return: second integer register */
42 #define RC_FRET RC_F0 /* function return: float register */
44 /* pretty names for the registers */
57 int reg_classes
[NB_REGS
] = {
58 /* r0 */ RC_INT
| RC_R0
,
59 /* r1 */ RC_INT
| RC_R1
,
60 /* r2 */ RC_INT
| RC_R2
,
61 /* r3 */ RC_INT
| RC_R3
,
62 /* r12 */ RC_INT
| RC_R12
,
63 /* f0 */ RC_FLOAT
| RC_F0
,
64 /* f1 */ RC_FLOAT
| RC_F1
,
65 /* f2 */ RC_FLOAT
| RC_F2
,
66 /* f3 */ RC_FLOAT
| RC_F3
,
69 static int two2mask(int a
,int b
) {
70 return (reg_classes
[a
]|reg_classes
[b
])&~(RC_INT
|RC_FLOAT
);
73 static int regmask(int r
) {
74 return reg_classes
[r
]&~(RC_INT
|RC_FLOAT
);
77 /* return registers for function */
78 #define REG_IRET TREG_R0 /* single word int return register */
79 #define REG_LRET TREG_R1 /* second word return register (for long long) */
80 #define REG_FRET TREG_F0 /* float return register */
82 /* defined if function parameters must be evaluated in reverse order */
83 #define INVERT_FUNC_PARAMS
85 /* defined if structures are passed as pointers. Otherwise structures
86 are directly pushed on stack. */
87 //#define FUNC_STRUCT_PARAM_AS_PTR
89 /* pointer size, in bytes */
92 /* long double size and alignment, in bytes */
93 #define LDOUBLE_SIZE 8
94 #define LDOUBLE_ALIGN 4
95 /* maximum alignment (for aligned attribute support) */
98 #define CHAR_IS_UNSIGNED
100 /******************************************************/
103 #define EM_TCC_TARGET EM_ARM
105 /* relocation type for 32 bit data relocation */
106 #define R_DATA_32 R_ARM_ABS32
107 #define R_JMP_SLOT R_ARM_JUMP_SLOT
108 #define R_COPY R_ARM_COPY
110 #define ELF_START_ADDR 0x00008000
111 #define ELF_PAGE_SIZE 0x1000
113 /******************************************************/
114 static unsigned long func_sub_sp_offset
,last_itod_magic
;
116 void o(unsigned long i
)
118 /* this is a good place to start adding big-endian support*/
122 if (ind1
> cur_text_section
->data_allocated
)
123 section_realloc(cur_text_section
, ind1
);
124 cur_text_section
->data
[ind
++] = i
&255;
126 cur_text_section
->data
[ind
++] = i
&255;
128 cur_text_section
->data
[ind
++] = i
&255;
130 cur_text_section
->data
[ind
++] = i
;
133 static unsigned long stuff_const(unsigned long op
,unsigned long c
)
136 unsigned long nc
,negop
;
145 case 0x1A00000: //mov
146 case 0x1E00000: //mvn
153 return (op
&0xF010F000)|((op
>>16)&0xF)|0x1E00000;
157 return (op
&0xF010F000)|((op
>>16)&0xF)|0x1A00000;
158 case 0x1C00000: //bic
163 case 0x1800000: //orr
165 return (op
&0xFFF0FFFF)|0x1E00000;
171 if(c
<256) /* catch undefined <<32 */
174 m
=(0xff>>i
)|(0xff<<(32-i
));
176 return op
|(i
<<7)|(c
<<i
)|(c
>>(32-i
));
186 void stuff_const_harder(unsigned long op
,unsigned long v
) {
192 unsigned long a
[16],nv
,no
,o2
,n2
;
195 o2
=(op
&0xfff0ffff)|((op
&0xf000)<<4);;
197 a
[i
]=(a
[i
-1]>>2)|(a
[i
-1]<<30);
199 for(j
=i
+4;i
<13+i
;i
++)
200 if((v
&(a
[i
]|a
[j
]))==v
) {
201 o(stuff_const(op
,v
&a
[i
]));
202 o(stuff_const(o2
,v
&a
[j
]));
209 for(j
=i
+4;i
<13+i
;i
++)
210 if((nv
&(a
[i
]|a
[j
]))==nv
) {
211 o(stuff_const(no
,nv
&a
[i
]));
212 o(stuff_const(n2
,nv
&a
[j
]));
217 for(k
=j
+4;k
<13+i
;i
++)
218 if((v
&(a
[i
]|a
[j
]|a
[k
]))==v
) {
219 o(stuff_const(op
,v
&a
[i
]));
220 o(stuff_const(o2
,v
&a
[j
]));
221 o(stuff_const(o2
,v
&a
[k
]));
228 for(k
=j
+4;k
<13+i
;i
++)
229 if((nv
&(a
[i
]|a
[j
]|a
[k
]))==nv
) {
230 o(stuff_const(no
,nv
&a
[i
]));
231 o(stuff_const(n2
,nv
&a
[j
]));
232 o(stuff_const(n2
,nv
&a
[k
]));
235 o(stuff_const(op
,v
&a
[0]));
236 o(stuff_const(o2
,v
&a
[4]));
237 o(stuff_const(o2
,v
&a
[8]));
238 o(stuff_const(o2
,v
&a
[12]));
242 unsigned long encbranch(int pos
,int addr
,int fail
)
246 if(addr
>=0x1000000 || addr
<-0x1000000) {
248 error("FIXME: function bigger than 32MB");
251 return 0x0A000000|(addr
&0xffffff);
254 int decbranch(int pos
)
257 x
=*(int *)(cur_text_section
->data
+ pos
);
264 /* output a symbol and patch all calls to it */
265 void gsym_addr(int t
, int a
)
270 x
=(unsigned long *)(cur_text_section
->data
+ t
);
273 *x
=0xE1A00000; // nop
276 *x
|= encbranch(lt
,a
,1);
286 static unsigned long fpr(int r
)
291 static unsigned long intr(int r
)
296 static void calcaddr(unsigned long *base
,int *off
,int *sgn
,int maxoff
,unsigned shift
)
298 if(*off
>maxoff
|| *off
&((1<<shift
)-1)) {
305 y
=stuff_const(x
,*off
&~maxoff
);
311 y
=stuff_const(x
,(*off
+maxoff
)&~maxoff
);
315 *off
=((*off
+maxoff
)&~maxoff
)-*off
;
318 stuff_const_harder(x
,*off
&~maxoff
);
323 static unsigned long mapcc(int cc
)
348 error("unexpected condition code");
352 static int negcc(int cc
)
377 error("unexpected condition code");
381 /* load 'r' from value 'sv' */
382 void load(int r
, SValue
*sv
)
384 int v
, ft
, fc
, fr
, sign
;
401 unsigned long base
=0xB; // fp
404 v1
.r
= VT_LOCAL
| VT_LVAL
;
406 load(base
=14 /* lr */, &v1
);
409 } else if(v
== VT_CONST
) {
417 } else if(v
< VT_CONST
) {
424 calcaddr(&base
,&fc
,&sign
,1020,2);
428 if ((ft
& VT_BTYPE
) != VT_FLOAT
)
430 o(op
|(fpr(r
)<<12)|(fc
>>2)|(base
<<16));
431 } else if((ft
& VT_TYPE
) == VT_BYTE
|| (ft
& VT_BTYPE
) == VT_SHORT
) {
432 calcaddr(&base
,&fc
,&sign
,255,0);
434 if ((ft
& VT_BTYPE
) == VT_SHORT
)
436 if ((ft
& VT_UNSIGNED
) == 0)
440 o(op
|(intr(r
)<<12)|(base
<<16)|((fc
&0xf0)<<4)|(fc
&0xf));
442 calcaddr(&base
,&fc
,&sign
,4095,0);
446 if ((ft
& VT_BTYPE
) == VT_BYTE
)
448 o(op
|(intr(r
)<<12)|fc
|(base
<<16));
454 op
=stuff_const(0xE3A00000|(intr(r
)<<12),sv
->c
.ul
);
455 if (fr
& VT_SYM
|| !op
) {
456 o(0xE59F0000|(intr(r
)<<12));
459 greloc(cur_text_section
, sv
->sym
, ind
, R_ARM_ABS32
);
464 } else if (v
== VT_LOCAL
) {
465 op
=stuff_const(0xE28B0000|(intr(r
)<<12),sv
->c
.ul
);
466 if (fr
& VT_SYM
|| !op
) {
467 o(0xE59F0000|(intr(r
)<<12));
469 if(fr
& VT_SYM
) // needed ?
470 greloc(cur_text_section
, sv
->sym
, ind
, R_ARM_ABS32
);
472 o(0xE08B0000|(intr(r
)<<12)|intr(r
));
476 } else if(v
== VT_CMP
) {
477 o(mapcc(sv
->c
.ul
)|0x3A00001|(intr(r
)<<12));
478 o(mapcc(negcc(sv
->c
.ul
))|0x3A00000|(intr(r
)<<12));
480 } else if (v
== VT_JMP
|| v
== VT_JMPI
) {
483 o(0xE3A00000|(intr(r
)<<12)|t
);
486 o(0xE3A00000|(intr(r
)<<12)|(t
^1));
488 } else if (v
< VT_CONST
) {
490 o(0xEE008180|(fpr(r
)<<12)|fpr(v
));
492 o(0xE1A00000|(intr(r
)<<12)|intr(v
));
496 error("load unimplemented!");
499 /* store register 'r' in lvalue 'v' */
500 void store(int r
, SValue
*sv
)
503 int v
, ft
, fc
, fr
, sign
;
518 if (fr
& VT_LVAL
|| fr
== VT_LOCAL
) {
519 unsigned long base
=0xb;
524 } else if(v
== VT_CONST
) {
535 calcaddr(&base
,&fc
,&sign
,1020,2);
539 if ((ft
& VT_BTYPE
) != VT_FLOAT
)
541 o(op
|(fpr(r
)<<12)|(fc
>>2)|(base
<<16));
543 } else if((ft
& VT_BTYPE
) == VT_SHORT
) {
544 calcaddr(&base
,&fc
,&sign
,255,0);
548 o(op
|(intr(r
)<<12)|(base
<<16)|((fc
&0xf0)<<4)|(fc
&0xf));
550 calcaddr(&base
,&fc
,&sign
,4095,0);
554 if ((ft
& VT_BTYPE
) == VT_BYTE
)
556 o(op
|(intr(r
)<<12)|fc
|(base
<<16));
561 error("store unimplemented");
564 static void gadd_sp(int val
)
566 stuff_const_harder(0xE28DD000,val
);
569 /* 'is_jmp' is '1' if it is a jump */
570 static void gcall_or_jmp(int is_jmp
)
573 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
)) == VT_CONST
) {
576 x
=encbranch(ind
,ind
+vtop
->c
.ul
,0);
578 if (vtop
->r
& VT_SYM
) {
579 /* relocation case */
580 greloc(cur_text_section
, vtop
->sym
, ind
, R_ARM_PC24
);
582 put_elf_reloc(symtab_section
, cur_text_section
, ind
, R_ARM_PC24
, 0);
583 o(x
|(is_jmp
?0xE0000000:0xE1000000));
586 o(0xE28FE004); // add lr,pc,#4
587 o(0xE51FF004); // ldr pc,[pc,#-4]
588 if (vtop
->r
& VT_SYM
)
589 greloc(cur_text_section
, vtop
->sym
, ind
, R_ARM_ABS32
);
593 /* otherwise, indirect call */
596 o(0xE1A0E00F); // mov lr,pc
597 o(0xE1A0F000|intr(r
)); // mov pc,r
601 /* Generate function call. The function address is pushed first, then
602 all the parameters in call order. This functions pops all the
603 parameters and the function address. */
604 void gfunc_call(int nb_args
)
606 int size
, align
, r
, args_size
, i
;
610 for(i
= 0;i
< nb_args
; i
++) {
611 if ((vtop
->type
.t
& VT_BTYPE
) == VT_STRUCT
) {
612 size
= type_size(&vtop
->type
, &align
);
613 /* align to stack align size */
614 size
= (size
+ 3) & ~3;
615 /* allocate the necessary size on stack */
617 /* generate structure store */
619 o(0xE1A0000D|(intr(r
)<<12));
620 vset(&vtop
->type
, r
| VT_LVAL
, 0);
624 } else if (is_float(vtop
->type
.t
)) {
625 r
=fpr(gv(RC_FLOAT
))<<12;
626 if ((vtop
->type
.t
& VT_BTYPE
) == VT_FLOAT
)
628 else if ((vtop
->type
.t
& VT_BTYPE
) == VT_DOUBLE
)
641 /* simple type (currently always same size) */
642 /* XXX: implicit cast ? */
644 if ((vtop
->type
.t
& VT_BTYPE
) == VT_LLONG
) {
646 o(0xE52D0004|(intr(vtop
->r2
)<<12)); /* str r2,[sp,#-4]! */
650 o(0xE52D0004|(intr(vtop
->r
)<<12)); /* str r,[sp,#-4]! */
655 save_regs(0); /* save used temporary registers */
661 o(0xE8BD0000|((1<<n
)-1));
664 func_sym
= vtop
->type
.ref
;
671 /* generate function prolog of type 't' */
672 void gfunc_prolog(CType
*func_type
)
675 int n
,addr
,size
,align
;
677 sym
= func_type
->ref
;
682 if((func_vt
.t
& VT_BTYPE
) == VT_STRUCT
) {
687 for(sym2
=sym
->next
;sym2
&& n
<4;sym2
=sym2
->next
) {
688 size
= type_size(&sym2
->type
, &align
);
689 size
= (size
+ 3) & ~3;
692 o(0xE1A0C00D); /* mov ip,sp */
693 if(func_type
->ref
->c
== FUNC_ELLIPSIS
)
698 o(0xE92D0000|((1<<n
)-1)); /* save r0-r4 on stack if needed */
700 o(0xE92D5800); /* save fp, ip, lr*/
701 o(0xE1A0B00D); /* mov fp,sp */
702 func_sub_sp_offset
= ind
;
703 o(0xE1A00000); /* nop, leave space for stack adjustment */
704 while ((sym
= sym
->next
)) {
707 sym_push(sym
->v
& ~SYM_FIELD
, type
, VT_LOCAL
| VT_LVAL
, addr
);
708 size
= type_size(type
, &align
);
709 size
= (size
+ 3) & ~3;
715 /* generate function epilog */
716 void gfunc_epilog(void)
719 o(0xE89BA800); /* restore fp, sp, pc */
721 x
=stuff_const(0xE24DD000, (-loc
+ 3) & -4); /* sub sp,sp,# */
723 *(unsigned long *)(cur_text_section
->data
+ func_sub_sp_offset
) = x
;
727 o(0xE59FC004); /* ldr ip,[pc+4] */
728 o(0xE04DD00C); /* sub sp,sp,ip */
729 o(0xE1A0F00E); /* mov pc,lr */
731 *(unsigned long *)(cur_text_section
->data
+ func_sub_sp_offset
) = 0xE1000000|encbranch(func_sub_sp_offset
,addr
,1);
736 /* generate a jump to a label */
741 o(0xE0000000|encbranch(r
,t
,1));
745 /* generate a jump to a fixed address */
746 void gjmp_addr(int a
)
751 /* generate a test. set 'inv' to invert test. Stack entry is popped */
752 int gtst(int inv
, int t
)
756 v
= vtop
->r
& VT_VALMASK
;
759 op
=mapcc(inv
?negcc(vtop
->c
.i
):vtop
->c
.i
);
760 op
|=encbranch(r
,t
,1);
763 } else if (v
== VT_JMP
|| v
== VT_JMPI
) {
764 if ((v
& 1) == inv
) {
775 x
= (unsigned long *)(cur_text_section
->data
+ lp
);
777 *x
|= encbranch(lp
,t
,1);
786 if (is_float(vtop
->type
.t
)) {
788 o(0xEE90F118|fpr(r
)<<16);
792 } else if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
) {
793 /* constant jmp optimization */
794 if ((vtop
->c
.i
!= 0) != inv
)
798 o(0xE3300000|(intr(v
)<<16));
808 /* generate an integer binary operation */
812 unsigned long opc
,r
,fr
;
820 case TOK_ADDC1
: /* add with carry generation */
828 case TOK_SUBC1
: /* sub with carry generation */
832 case TOK_ADDC2
: /* add with carry use */
836 case TOK_SUBC2
: /* sub with carry use */
857 o(0xE0000090|(intr(r
)<<16)|(intr(r
)<<8)|intr(fr
));
890 r
=intr(vtop
[-1].r2
=get_reg(RC_INT
));
892 vtop
[-1].r
=get_reg_ex(RC_INT
,regmask(c
));
894 o(0xE0800090|(r
<<16)|(intr(vtop
->r
)<<12)|(intr(c
)<<8)|intr(vtop
[1].r
));
902 if((vtop
[-1].r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
) {
903 if(opc
== 4 || opc
== 5 || opc
== 0xc) {
905 opc
|=2; // sub -> rsb
911 opc
=0xE0000000|(opc
<<20)|(c
<<16);
912 if((vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
) {
914 x
=stuff_const(opc
|0x2000000,vtop
->c
.i
);
916 r
=intr(vtop
[-1].r
=get_reg_ex(RC_INT
,regmask(vtop
[-1].r
)));
922 r
=intr(vtop
[-1].r
=get_reg_ex(RC_INT
,two2mask(vtop
->r
,vtop
[-1].r
)));
926 if (op
>= TOK_ULT
&& op
<= TOK_GT
) {
932 opc
=0xE1A00000|(opc
<<5);
937 if ((vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) == VT_CONST
) {
938 fr
=intr(vtop
[-1].r
=get_reg_ex(RC_INT
,regmask(vtop
[-1].r
)));
939 c
= vtop
->c
.i
& 0x1f;
940 o(opc
|(c
<<7)|(fr
<<12));
943 c
=intr(vtop
[-1].r
=get_reg_ex(RC_INT
,two2mask(vtop
->r
,vtop
[-1].r
)));
944 o(opc
|(c
<<12)|(fr
<<8)|0x10);
949 vpush_global_sym(&func_old_type
, func
);
956 error("gen_opi %i unimplemented!",op
);
960 static int is_fconst()
964 if((vtop
->r
& (VT_VALMASK
| VT_LVAL
| VT_SYM
)) != VT_CONST
)
966 if (vtop
->type
.t
== VT_FLOAT
)
968 else if (vtop
->type
.t
== VT_DOUBLE
)
998 /* generate a floating point operation 'v = t1 op t2' instruction. The
999 two operands are guaranted to have the same floating point type */
1000 void gen_opf(int op
)
1004 //fputs("gen_opf\n",stderr);
1018 r
=fpr(gv(RC_FLOAT
));
1025 r2
=fpr(gv(RC_FLOAT
));
1034 r
=fpr(gv(RC_FLOAT
));
1036 } else if(c1
&& c1
<=0xf) {
1039 r
=fpr(gv(RC_FLOAT
));
1044 r
=fpr(gv(RC_FLOAT
));
1046 r2
=fpr(gv(RC_FLOAT
));
1055 r
=fpr(gv(RC_FLOAT
));
1060 r2
=fpr(gv(RC_FLOAT
));
1068 r
=fpr(gv(RC_FLOAT
));
1070 } else if(c1
&& c1
<=0xf) {
1073 r
=fpr(gv(RC_FLOAT
));
1078 r
=fpr(gv(RC_FLOAT
));
1080 r2
=fpr(gv(RC_FLOAT
));
1084 if(op
>= TOK_ULT
&& op
<= TOK_GT
) {
1090 fputs("unsigned comparision on floats?\n",stderr
);
1125 r
=fpr(gv(RC_FLOAT
));
1132 r2
=fpr(gv(RC_FLOAT
));
1134 vtop
[-1].r
= VT_CMP
;
1137 error("unknown fp op %x!\n",op
);
1141 if(vtop
[-1].r
== VT_CMP
)
1147 vtop
[-1].r
=get_reg_ex(RC_FLOAT
,two2mask(vtop
[-1].r
,c1
));
1151 o(x
|(r
<<16)|(c1
<<12)|r2
);
1154 /* convert integers to fp 't' type. Must handle 'int', 'unsigned int'
1155 and 'long long' cases. */
1156 void gen_cvt_itof(int t
)
1160 r2
=fpr(vtop
->r
=get_reg(RC_FLOAT
));
1161 bt
=vtop
->type
.t
& VT_BTYPE
;
1162 if(bt
== VT_INT
|| bt
== VT_SHORT
|| bt
== VT_BYTE
) {
1163 o(0xEE000190|(r2
<<16)|(r
<<12));
1164 if((vtop
->type
.t
& (VT_UNSIGNED
|VT_BTYPE
)) == (VT_UNSIGNED
|VT_INT
)) {
1166 o(0xE3500000|(r
<<12));
1167 r
=fpr(get_reg(RC_FLOAT
));
1168 if(last_itod_magic
) {
1169 off
=ind
+8-last_itod_magic
;
1174 o(0xBD1F8100|(r
<<12)|off
);
1177 last_itod_magic
=ind
;
1181 o(0xBE000180|(r2
<<16)|(r2
<<12)|r
);
1184 } else if(bt
== VT_LLONG
) {
1188 o(0xe52d0004|(r
<<12)); //str r0, [sp, -#4]!
1189 o(0xe3500000|(r3
<<16)); //cmp r1, #0
1190 o(0xa3800102|(r3
<<16)|(r3
<<12)); //orrge r1, r1, #0x80000000
1191 o(0xe59f0014|(r
<<12)); //ldr r0, [pc, #20]
1192 o(0xe52d0004|(r3
<<12)); //str r1, [sp, -#4]!
1193 o(0xe52d0004|(r
<<12)); //str r0, [sp, -#4]!
1194 o(0xecfd0103|(r2
<<12)); //ldfe f0, [sp], #12
1195 r
=fpr(get_reg(RC_FLOAT
));
1196 if((vtop
->type
.t
& VT_UNSIGNED
) != VT_UNSIGNED
)
1198 o(0xaddf0101|(r
<<12)|x
); //ldf(ge)e f1, [pc, #4]
1199 o(0xae280100|(r2
<<16)|(r2
<<12)|r
|x
); //suf(ge)e f0, f0, f1
1200 o(0xea000002); //b pc+8
1201 o(0x403e);o(0x80000000);o(0);
1203 o(0xbe280100|(r2
<<16)|(r2
<<12)|r
); //suflte f0, f0, f1
1207 error("unimplemented gen_cvt_itof %x!",vtop
->type
.t
);
1210 /* convert fp to int 't' type */
1211 void gen_cvt_ftoi(int t
)
1216 r
=fpr(gv(RC_FLOAT
));
1217 r2
=intr(vtop
->r
=get_reg(RC_INT
));
1220 u
=fpr(get_reg(RC_FLOAT
));
1221 o(0xed9f0100|(u
<<12));
1224 o(0xee90f110|(r
<<12)|u
);
1225 o(0x2e200180|(r
<<16)|(r
<<12)|u
);
1226 o(0x2e200180|(r
<<16)|(r
<<12)|u
);
1227 o(0xee100150|(r2
<<12)|u
);
1229 o(0xEE100170|(r
<<12)|r
);
1231 } else if(t
==VT_LLONG
) {
1234 R
=intr(vtop
->r2
=get_reg(RC_INT
));
1243 r2
=intr(get_reg(RC_INT
));
1244 o(0xed6d0103|(r
<<12));
1246 o(0xe8bd0000|(1<<Q
)|(1<<R
));
1248 o(0xe20e0902|(r2
<<12));
1253 o(0xb3a00000|(R
<<12));
1254 o(0xb3a00000|(Q
<<12));
1256 o(0xba000000|(u
?5:9));
1258 o(0xaa000000|(u
?5:3));
1259 o(0xe1b000a0|(R
<<12)|R
);
1260 o(0xe1a00060|(Q
<<12)|Q
);
1264 o(0x13a00000|(R
<<12));
1265 o(0x13a00000|(Q
<<12));
1267 o(0xe3500000|(r2
<<12));
1269 o(0xe2700000|(Q
<<16)|(Q
<<12));
1270 o(0xe2e00000|(R
<<16)|(R
<<12));
1274 error("unimplemented gen_cvt_ftoi!");
1277 /* convert from one floating point type to another */
1278 void gen_cvt_ftof(int t
)
1280 /* all we have to do on i386 and ARM is to put the float in a register */
1284 /* computed goto support */
1291 /* end of ARM code generator */
1292 /*************************************************************/