?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
x86-64 bug fix: Fix stab generation for x86-64.
[tinycc.git] / arm-gen.c
blob67a6f852441b6af1221683d4f71fb4d122950671
1 /*
2 * ARMv4 code generator for TCC
3 *
4 * Copyright (c) 2003 Daniel Glöckner
5 *
6 * Based on i386-gen.c by Fabrice Bellard
7 *
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.
12 *
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.
17 *
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
21 */
22
23 #ifdef TCC_ARM_EABI
24 #define TCC_ARM_VFP
25 #endif
26
27
28 /* number of available registers */
29 #ifdef TCC_ARM_VFP
30 #define NB_REGS 13
31 #else
32 #define NB_REGS 9
33 #endif
34
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 */
40 #define RC_R0 0x0004
41 #define RC_R1 0x0008
42 #define RC_R2 0x0010
43 #define RC_R3 0x0020
44 #define RC_R12 0x0040
45 #define RC_F0 0x0080
46 #define RC_F1 0x0100
47 #define RC_F2 0x0200
48 #define RC_F3 0x0400
49 #ifdef TCC_ARM_VFP
50 #define RC_F4 0x0800
51 #define RC_F5 0x1000
52 #define RC_F6 0x2000
53 #define RC_F7 0x4000
54 #endif
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 */
58
59 /* pretty names for the registers */
60 enum {
61 TREG_R0 = 0,
62 TREG_R1,
63 TREG_R2,
64 TREG_R3,
65 TREG_R12,
66 TREG_F0,
67 TREG_F1,
68 TREG_F2,
69 TREG_F3,
70 #ifdef TCC_ARM_VFP
71 TREG_F4,
72 TREG_F5,
73 TREG_F6,
74 TREG_F7,
75 #endif
76 };
77
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,
88 #ifdef TCC_ARM_VFP
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,
93 #endif
94 };
95
96 static int two2mask(int a,int b) {
97 return (reg_classes[a]|reg_classes[b])&~(RC_INT|RC_FLOAT);
98 }
99
100 static int regmask(int r) {
101 return reg_classes[r]&~(RC_INT|RC_FLOAT);
102 }
103
104 #ifdef TCC_ARM_VFP
105 #define T2CPR(t) (((t) & VT_BTYPE) != VT_FLOAT ? 0x100 : 0)
106 #endif
107
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 */
112
113 #ifdef TCC_ARM_EABI
114 #define TOK___divdi3 TOK___aeabi_ldivmod
115 #define TOK___moddi3 TOK___aeabi_ldivmod
116 #define TOK___udivdi3 TOK___aeabi_uldivmod
117 #define TOK___umoddi3 TOK___aeabi_uldivmod
118 #endif
119
120 /* defined if function parameters must be evaluated in reverse order */
121 #define INVERT_FUNC_PARAMS
122
123 /* defined if structures are passed as pointers. Otherwise structures
124 are directly pushed on stack. */
125 //#define FUNC_STRUCT_PARAM_AS_PTR
126
127 #if defined(TCC_ARM_EABI) && defined(TCC_ARM_VFP)
128 static CType float_type, double_type, func_float_type, func_double_type;
129 #define func_ldouble_type func_double_type
130 #else
131 #define func_float_type func_old_type
132 #define func_double_type func_old_type
133 #define func_ldouble_type func_old_type
134 #endif
135
136 /* pointer size, in bytes */
137 #define PTR_SIZE 4
138
139 /* long double size and alignment, in bytes */
140 #ifdef TCC_ARM_VFP
141 #define LDOUBLE_SIZE 8
142 #endif
143
144 #ifndef LDOUBLE_SIZE
145 #define LDOUBLE_SIZE 8
146 #endif
147
148 #ifdef TCC_ARM_EABI
149 #define LDOUBLE_ALIGN 8
150 #else
151 #define LDOUBLE_ALIGN 4
152 #endif
153
154 /* maximum alignment (for aligned attribute support) */
155 #define MAX_ALIGN 8
156
157 #define CHAR_IS_UNSIGNED
158
159 /******************************************************/
160 /* ELF defines */
161
162 #define EM_TCC_TARGET EM_ARM
163
164 /* relocation type for 32 bit data relocation */
165 #define R_DATA_32 R_ARM_ABS32
166 #define R_JMP_SLOT R_ARM_JUMP_SLOT
167 #define R_COPY R_ARM_COPY
168
169 #define ELF_START_ADDR 0x00008000
170 #define ELF_PAGE_SIZE 0x1000
171
172 /******************************************************/
173 static unsigned long func_sub_sp_offset,last_itod_magic;
174 static int leaffunc;
175
176 void o(unsigned long i)
177 {
178 /* this is a good place to start adding big-endian support*/
179 int ind1;
180
181 ind1 = ind + 4;
182 if (!cur_text_section)
183 error("compiler error! This happens f.ex. if the compiler\n"
184 "can't evaluate constant expressions outside of a function.");
185 if (ind1 > cur_text_section->data_allocated)
186 section_realloc(cur_text_section, ind1);
187 cur_text_section->data[ind++] = i&255;
188 i>>=8;
189 cur_text_section->data[ind++] = i&255;
190 i>>=8;
191 cur_text_section->data[ind++] = i&255;
192 i>>=8;
193 cur_text_section->data[ind++] = i;
194 }
195
196 static unsigned long stuff_const(unsigned long op,unsigned long c)
197 {
198 int try_neg=0;
199 unsigned long nc = 0,negop = 0;
200
201 switch(op&0x1F00000)
202 {
203 case 0x800000: //add
204 case 0x400000: //sub
205 try_neg=1;
206 negop=op^0xC00000;
207 nc=-c;
208 break;
209 case 0x1A00000: //mov
210 case 0x1E00000: //mvn
211 try_neg=1;
212 negop=op^0x400000;
213 nc=~c;
214 break;
215 case 0x200000: //xor
216 if(c==~0)
217 return (op&0xF010F000)|((op>>16)&0xF)|0x1E00000;
218 break;
219 case 0x0: //and
220 if(c==~0)
221 return (op&0xF010F000)|((op>>16)&0xF)|0x1A00000;
222 case 0x1C00000: //bic
223 try_neg=1;
224 negop=op^0x1C00000;
225 nc=~c;
226 break;
227 case 0x1800000: //orr
228 if(c==~0)
229 return (op&0xFFF0FFFF)|0x1E00000;
230 break;
231 }
232 do {
233 unsigned long m;
234 int i;
235 if(c<256) /* catch undefined <<32 */
236 return op|c;
237 for(i=2;i<32;i+=2) {
238 m=(0xff>>i)|(0xff<<(32-i));
239 if(!(c&~m))
240 return op|(i<<7)|(c<<i)|(c>>(32-i));
241 }
242 op=negop;
243 c=nc;
244 } while(try_neg--);
245 return 0;
246 }
247
248
249 //only add,sub
250 void stuff_const_harder(unsigned long op,unsigned long v) {
251 unsigned long x;
252 x=stuff_const(op,v);
253 if(x)
254 o(x);
255 else {
256 unsigned long a[16],nv,no,o2,n2;
257 int i,j,k;
258 a[0]=0xff;
259 o2=(op&0xfff0ffff)|((op&0xf000)<<4);;
260 for(i=1;i<16;i++)
261 a[i]=(a[i-1]>>2)|(a[i-1]<<30);
262 for(i=0;i<12;i++)
263 for(j=i+4;i<13+i;i++)
264 if((v&(a[i]|a[j]))==v) {
265 o(stuff_const(op,v&a[i]));
266 o(stuff_const(o2,v&a[j]));
267 return;
268 }
269 no=op^0xC00000;
270 n2=o2^0xC00000;
271 nv=-v;
272 for(i=0;i<12;i++)
273 for(j=i+4;i<13+i;i++)
274 if((nv&(a[i]|a[j]))==nv) {
275 o(stuff_const(no,nv&a[i]));
276 o(stuff_const(n2,nv&a[j]));
277 return;
278 }
279 for(i=0;i<8;i++)
280 for(j=i+4;i<12;i++)
281 for(k=j+4;k<13+i;i++)
282 if((v&(a[i]|a[j]|a[k]))==v) {
283 o(stuff_const(op,v&a[i]));
284 o(stuff_const(o2,v&a[j]));
285 o(stuff_const(o2,v&a[k]));
286 return;
287 }
288 no=op^0xC00000;
289 nv=-v;
290 for(i=0;i<8;i++)
291 for(j=i+4;i<12;i++)
292 for(k=j+4;k<13+i;i++)
293 if((nv&(a[i]|a[j]|a[k]))==nv) {
294 o(stuff_const(no,nv&a[i]));
295 o(stuff_const(n2,nv&a[j]));
296 o(stuff_const(n2,nv&a[k]));
297 return;
298 }
299 o(stuff_const(op,v&a[0]));
300 o(stuff_const(o2,v&a[4]));
301 o(stuff_const(o2,v&a[8]));
302 o(stuff_const(o2,v&a[12]));
303 }
304 }
305
306 unsigned long encbranch(int pos,int addr,int fail)
307 {
308 addr-=pos+8;
309 addr/=4;
310 if(addr>=0x1000000 || addr<-0x1000000) {
311 if(fail)
312 error("FIXME: function bigger than 32MB");
313 return 0;
314 }
315 return 0x0A000000|(addr&0xffffff);
316 }
317
318 int decbranch(int pos)
319 {
320 int x;
321 x=*(int *)(cur_text_section->data + pos);
322 x&=0x00ffffff;
323 if(x&0x800000)
324 x-=0x1000000;
325 return x*4+pos+8;
326 }
327
328 /* output a symbol and patch all calls to it */
329 void gsym_addr(int t, int a)
330 {
331 unsigned long *x;
332 int lt;
333 while(t) {
334 x=(unsigned long *)(cur_text_section->data + t);
335 t=decbranch(lt=t);
336 if(a==lt+4)
337 *x=0xE1A00000; // nop
338 else {
339 *x &= 0xff000000;
340 *x |= encbranch(lt,a,1);
341 }
342 }
343 }
344
345 void gsym(int t)
346 {
347 gsym_addr(t, ind);
348 }
349
350 #ifdef TCC_ARM_VFP
351 static unsigned long vfpr(int r)
352 {
353 if(r<TREG_F0 || r>TREG_F7)
354 error("compiler error! register %i is no vfp register",r);
355 return r-5;
356 }
357 #else
358 static unsigned long fpr(int r)
359 {
360 if(r<TREG_F0 || r>TREG_F3)
361 error("compiler error! register %i is no fpa register",r);
362 return r-5;
363 }
364 #endif
365
366 static unsigned long intr(int r)
367 {
368 if(r==4)
369 return 12;
370 if((r<0 || r>4) && r!=14)
371 error("compiler error! register %i is no int register",r);
372 return r;
373 }
374
375 static void calcaddr(unsigned long *base,int *off,int *sgn,int maxoff,unsigned shift)
376 {
377 if(*off>maxoff || *off&((1<<shift)-1)) {
378 unsigned long x,y;
379 x=0xE280E000;
380 if(*sgn)
381 x=0xE240E000;
382 x|=(*base)<<16;
383 *base=14; // lr
384 y=stuff_const(x,*off&~maxoff);
385 if(y) {
386 o(y);
387 *off&=maxoff;
388 return;
389 }
390 y=stuff_const(x,(*off+maxoff)&~maxoff);
391 if(y) {
392 o(y);
393 *sgn=!*sgn;
394 *off=((*off+maxoff)&~maxoff)-*off;
395 return;
396 }
397 stuff_const_harder(x,*off&~maxoff);
398 *off&=maxoff;
399 }
400 }
401
402 static unsigned long mapcc(int cc)
403 {
404 switch(cc)
405 {
406 case TOK_ULT:
407 return 0x30000000; /* CC/LO */
408 case TOK_UGE:
409 return 0x20000000; /* CS/HS */
410 case TOK_EQ:
411 return 0x00000000; /* EQ */
412 case TOK_NE:
413 return 0x10000000; /* NE */
414 case TOK_ULE:
415 return 0x90000000; /* LS */
416 case TOK_UGT:
417 return 0x80000000; /* HI */
418 case TOK_Nset:
419 return 0x40000000; /* MI */
420 case TOK_Nclear:
421 return 0x50000000; /* PL */
422 case TOK_LT:
423 return 0xB0000000; /* LT */
424 case TOK_GE:
425 return 0xA0000000; /* GE */
426 case TOK_LE:
427 return 0xD0000000; /* LE */
428 case TOK_GT:
429 return 0xC0000000; /* GT */
430 }
431 error("unexpected condition code");
432 return 0xE0000000; /* AL */
433 }
434
435 static int negcc(int cc)
436 {
437 switch(cc)
438 {
439 case TOK_ULT:
440 return TOK_UGE;
441 case TOK_UGE:
442 return TOK_ULT;
443 case TOK_EQ:
444 return TOK_NE;
445 case TOK_NE:
446 return TOK_EQ;
447 case TOK_ULE:
448 return TOK_UGT;
449 case TOK_UGT:
450 return TOK_ULE;
451 case TOK_Nset:
452 return TOK_Nclear;
453 case TOK_Nclear:
454 return TOK_Nset;
455 case TOK_LT:
456 return TOK_GE;
457 case TOK_GE:
458 return TOK_LT;
459 case TOK_LE:
460 return TOK_GT;
461 case TOK_GT:
462 return TOK_LE;
463 }
464 error("unexpected condition code");
465 return TOK_NE;
466 }
467
468 /* load 'r' from value 'sv' */
469 void load(int r, SValue *sv)
470 {
471 int v, ft, fc, fr, sign;
472 unsigned long op;
473 SValue v1;
474
475 fr = sv->r;
476 ft = sv->type.t;
477 fc = sv->c.ul;
478
479 if(fc>=0)
480 sign=0;
481 else {
482 sign=1;
483 fc=-fc;
484 }
485
486 v = fr & VT_VALMASK;
487 if (fr & VT_LVAL) {
488 unsigned long base=0xB; // fp
489 if(v == VT_LLOCAL) {
490 v1.type.t = VT_PTR;
491 v1.r = VT_LOCAL | VT_LVAL;
492 v1.c.ul = sv->c.ul;
493 load(base=14 /* lr */, &v1);
494 fc=sign=0;
495 v=VT_LOCAL;
496 } else if(v == VT_CONST) {
497 v1.type.t = VT_PTR;
498 v1.r = fr&~VT_LVAL;
499 v1.c.ul = sv->c.ul;
500 v1.sym=sv->sym;
501 load(base=14, &v1);
502 fc=sign=0;
503 v=VT_LOCAL;
504 } else if(v < VT_CONST) {
505 base=intr(v);
506 fc=sign=0;
507 v=VT_LOCAL;
508 }
509 if(v == VT_LOCAL) {
510 if(is_float(ft)) {
511 calcaddr(&base,&fc,&sign,1020,2);
512 #ifdef TCC_ARM_VFP
513 op=0xED100A00; /* flds */
514 if(!sign)
515 op|=0x800000;
516 if ((ft & VT_BTYPE) != VT_FLOAT)
517 op|=0x100; /* flds -> fldd */
518 o(op|(vfpr(r)<<12)|(fc>>2)|(base<<16));
519 #else
520 op=0xED100100;
521 if(!sign)
522 op|=0x800000;
523 #if LDOUBLE_SIZE == 8
524 if ((ft & VT_BTYPE) != VT_FLOAT)
525 op|=0x8000;
526 #else
527 if ((ft & VT_BTYPE) == VT_DOUBLE)
528 op|=0x8000;
529 else if ((ft & VT_BTYPE) == VT_LDOUBLE)
530 op|=0x400000;
531 #endif
532 o(op|(fpr(r)<<12)|(fc>>2)|(base<<16));
533 #endif
534 } else if((ft & (VT_BTYPE|VT_UNSIGNED)) == VT_BYTE
535 || (ft & VT_BTYPE) == VT_SHORT) {
536 calcaddr(&base,&fc,&sign,255,0);
537 op=0xE1500090;
538 if ((ft & VT_BTYPE) == VT_SHORT)
539 op|=0x20;
540 if ((ft & VT_UNSIGNED) == 0)
541 op|=0x40;
542 if(!sign)
543 op|=0x800000;
544 o(op|(intr(r)<<12)|(base<<16)|((fc&0xf0)<<4)|(fc&0xf));
545 } else {
546 calcaddr(&base,&fc,&sign,4095,0);
547 op=0xE5100000;
548 if(!sign)
549 op|=0x800000;
550 if ((ft & VT_BTYPE) == VT_BYTE)
551 op|=0x400000;
552 o(op|(intr(r)<<12)|fc|(base<<16));
553 }
554 return;
555 }
556 } else {
557 if (v == VT_CONST) {
558 op=stuff_const(0xE3A00000|(intr(r)<<12),sv->c.ul);
559 if (fr & VT_SYM || !op) {
560 o(0xE59F0000|(intr(r)<<12));
561 o(0xEA000000);
562 if(fr & VT_SYM)
563 greloc(cur_text_section, sv->sym, ind, R_ARM_ABS32);
564 o(sv->c.ul);
565 } else
566 o(op);
567 return;
568 } else if (v == VT_LOCAL) {
569 op=stuff_const(0xE28B0000|(intr(r)<<12),sv->c.ul);
570 if (fr & VT_SYM || !op) {
571 o(0xE59F0000|(intr(r)<<12));
572 o(0xEA000000);
573 if(fr & VT_SYM) // needed ?
574 greloc(cur_text_section, sv->sym, ind, R_ARM_ABS32);
575 o(sv->c.ul);
576 o(0xE08B0000|(intr(r)<<12)|intr(r));
577 } else
578 o(op);
579 return;
580 } else if(v == VT_CMP) {
581 o(mapcc(sv->c.ul)|0x3A00001|(intr(r)<<12));
582 o(mapcc(negcc(sv->c.ul))|0x3A00000|(intr(r)<<12));
583 return;
584 } else if (v == VT_JMP || v == VT_JMPI) {
585 int t;
586 t = v & 1;
587 o(0xE3A00000|(intr(r)<<12)|t);
588 o(0xEA000000);
589 gsym(sv->c.ul);
590 o(0xE3A00000|(intr(r)<<12)|(t^1));
591 return;
592 } else if (v < VT_CONST) {
593 if(is_float(ft))
594 #ifdef TCC_ARM_VFP
595 o(0xEEB00A40|(vfpr(r)<<12)|vfpr(v)|T2CPR(ft)); /* fcpyX */
596 #else
597 o(0xEE008180|(fpr(r)<<12)|fpr(v));
598 #endif
599 else
600 o(0xE1A00000|(intr(r)<<12)|intr(v));
601 return;
602 }
603 }
604 error("load unimplemented!");
605 }
606
607 /* store register 'r' in lvalue 'v' */
608 void store(int r, SValue *sv)
609 {
610 SValue v1;
611 int v, ft, fc, fr, sign;
612 unsigned long op;
613
614 fr = sv->r;
615 ft = sv->type.t;
616 fc = sv->c.ul;
617
618 if(fc>=0)
619 sign=0;
620 else {
621 sign=1;
622 fc=-fc;
623 }
624
625 v = fr & VT_VALMASK;
626 if (fr & VT_LVAL || fr == VT_LOCAL) {
627 unsigned long base=0xb;
628 if(v < VT_CONST) {
629 base=intr(v);
630 v=VT_LOCAL;
631 fc=sign=0;
632 } else if(v == VT_CONST) {
633 v1.type.t = ft;
634 v1.r = fr&~VT_LVAL;
635 v1.c.ul = sv->c.ul;
636 v1.sym=sv->sym;
637 load(base=14, &v1);
638 fc=sign=0;
639 v=VT_LOCAL;
640 }
641 if(v == VT_LOCAL) {
642 if(is_float(ft)) {
643 calcaddr(&base,&fc,&sign,1020,2);
644 #ifdef TCC_ARM_VFP
645 op=0xED000A00; /* fsts */
646 if(!sign)
647 op|=0x800000;
648 if ((ft & VT_BTYPE) != VT_FLOAT)
649 op|=0x100; /* fsts -> fstd */
650 o(op|(vfpr(r)<<12)|(fc>>2)|(base<<16));
651 #else
652 op=0xED000100;
653 if(!sign)
654 op|=0x800000;
655 #if LDOUBLE_SIZE == 8
656 if ((ft & VT_BTYPE) != VT_FLOAT)
657 op|=0x8000;
658 #else
659 if ((ft & VT_BTYPE) == VT_DOUBLE)
660 op|=0x8000;
661 if ((ft & VT_BTYPE) == VT_LDOUBLE)
662 op|=0x400000;
663 #endif
664 o(op|(fpr(r)<<12)|(fc>>2)|(base<<16));
665 #endif
666 return;
667 } else if((ft & VT_BTYPE) == VT_SHORT) {
668 calcaddr(&base,&fc,&sign,255,0);
669 op=0xE14000B0;
670 if(!sign)
671 op|=0x800000;
672 o(op|(intr(r)<<12)|(base<<16)|((fc&0xf0)<<4)|(fc&0xf));
673 } else {
674 calcaddr(&base,&fc,&sign,4095,0);
675 op=0xE5000000;
676 if(!sign)
677 op|=0x800000;
678 if ((ft & VT_BTYPE) == VT_BYTE)
679 op|=0x400000;
680 o(op|(intr(r)<<12)|fc|(base<<16));
681 }
682 return;
683 }
684 }
685 error("store unimplemented");
686 }
687
688 static void gadd_sp(int val)
689 {
690 stuff_const_harder(0xE28DD000,val);
691 }
692
693 /* 'is_jmp' is '1' if it is a jump */
694 static void gcall_or_jmp(int is_jmp)
695 {
696 int r;
697 if ((vtop->r & (VT_VALMASK | VT_LVAL)) == VT_CONST) {
698 unsigned long x;
699 /* constant case */
700 x=encbranch(ind,ind+vtop->c.ul,0);
701 if(x) {
702 if (vtop->r & VT_SYM) {
703 /* relocation case */
704 greloc(cur_text_section, vtop->sym, ind, R_ARM_PC24);
705 } else
706 put_elf_reloc(symtab_section, cur_text_section, ind, R_ARM_PC24, 0);
707 o(x|(is_jmp?0xE0000000:0xE1000000));
708 } else {
709 if(!is_jmp)
710 o(0xE28FE004); // add lr,pc,#4
711 o(0xE51FF004); // ldr pc,[pc,#-4]
712 if (vtop->r & VT_SYM)
713 greloc(cur_text_section, vtop->sym, ind, R_ARM_ABS32);
714 o(vtop->c.ul);
715 }
716 } else {
717 /* otherwise, indirect call */
718 r = gv(RC_INT);
719 if(!is_jmp)
720 o(0xE1A0E00F); // mov lr,pc
721 o(0xE1A0F000|intr(r)); // mov pc,r
722 }
723 }
724
725 /* Generate function call. The function address is pushed first, then
726 all the parameters in call order. This functions pops all the
727 parameters and the function address. */
728 void gfunc_call(int nb_args)
729 {
730 int size, align, r, args_size, i;
731 Sym *func_sym;
732 signed char plan[4][2]={{-1,-1},{-1,-1},{-1,-1},{-1,-1}};
733 int todo=0xf, keep, plan2[4]={0,0,0,0};
734
735 r = vtop->r & VT_VALMASK;
736 if (r == VT_CMP || (r & ~1) == VT_JMP)
737 gv(RC_INT);
738 #ifdef TCC_ARM_EABI
739 if((vtop[-nb_args].type.ref->type.t & VT_BTYPE) == VT_STRUCT
740 && type_size(&vtop[-nb_args].type, &align) <= 4) {
741 SValue tmp;
742 tmp=vtop[-nb_args];
743 vtop[-nb_args]=vtop[-nb_args+1];
744 vtop[-nb_args+1]=tmp;
745 --nb_args;
746 }
747
748 vpushi(0);
749 vtop->type.t = VT_LLONG;
750 args_size = 0;
751 for(i = nb_args + 1 ; i-- ;) {
752 size = type_size(&vtop[-i].type, &align);
753 if(args_size & (align-1)) {
754 vpushi(0);
755 vtop->type.t = VT_VOID; /* padding */
756 vrott(i+2);
757 args_size += 4;
758 ++nb_args;
759 }
760 args_size += (size + 3) & -4;
761 }
762 vtop--;
763 #endif
764 args_size = 0;
765 for(i = nb_args ; i-- && args_size < 16 ;) {
766 switch(vtop[-i].type.t & VT_BTYPE) {
767 case VT_STRUCT:
768 case VT_FLOAT:
769 case VT_DOUBLE:
770 case VT_LDOUBLE:
771 size = type_size(&vtop[-i].type, &align);
772 size = (size + 3) & -4;
773 args_size += size;
774 break;
775 default:
776 plan[nb_args-1-i][0]=args_size/4;
777 args_size += 4;
778 if ((vtop[-i].type.t & VT_BTYPE) == VT_LLONG && args_size < 16) {
779 plan[nb_args-1-i][1]=args_size/4;
780 args_size += 4;
781 }
782 }
783 }
784 args_size = keep = 0;
785 for(i = 0;i < nb_args; i++) {
786 vnrott(keep+1);
787 if ((vtop->type.t & VT_BTYPE) == VT_STRUCT) {
788 size = type_size(&vtop->type, &align);
789 /* align to stack align size */
790 size = (size + 3) & -4;
791 /* allocate the necessary size on stack */
792 gadd_sp(-size);
793 /* generate structure store */
794 r = get_reg(RC_INT);
795 o(0xE1A0000D|(intr(r)<<12));
796 vset(&vtop->type, r | VT_LVAL, 0);
797 vswap();
798 vstore();
799 vtop--;
800 args_size += size;
801 } else if (is_float(vtop->type.t)) {
802 #ifdef TCC_ARM_VFP
803 r=vfpr(gv(RC_FLOAT))<<12;
804 size=4;
805 if ((vtop->type.t & VT_BTYPE) != VT_FLOAT)
806 {
807 size=8;
808 r|=0x101; /* fstms -> fstmd */
809 }
810 o(0xED2D0A01+r);
811 #else
812 r=fpr(gv(RC_FLOAT))<<12;
813 if ((vtop->type.t & VT_BTYPE) == VT_FLOAT)
814 size = 4;
815 else if ((vtop->type.t & VT_BTYPE) == VT_DOUBLE)
816 size = 8;
817 else
818 size = LDOUBLE_SIZE;
819
820 if (size == 12)
821 r|=0x400000;
822 else if(size == 8)
823 r|=0x8000;
824
825 o(0xED2D0100|r|(size>>2));
826 #endif
827 vtop--;
828 args_size += size;
829 } else {
830 int s;
831 /* simple type (currently always same size) */
832 /* XXX: implicit cast ? */
833 size=4;
834 if ((vtop->type.t & VT_BTYPE) == VT_LLONG) {
835 lexpand_nr();
836 s=RC_INT;
837 if(nb_args-i<5 && plan[nb_args-i-1][1]!=-1) {
838 s=regmask(plan[nb_args-i-1][1]);
839 todo&=~(1<<plan[nb_args-i-1][1]);
840 }
841 if(s==RC_INT) {
842 r = gv(s);
843 o(0xE52D0004|(intr(r)<<12)); /* str r,[sp,#-4]! */
844 vtop--;
845 } else {
846 plan2[keep]=s;
847 keep++;
848 vswap();
849 }
850 size = 8;
851 }
852 s=RC_INT;
853 if(nb_args-i<5 && plan[nb_args-i-1][0]!=-1) {
854 s=regmask(plan[nb_args-i-1][0]);
855 todo&=~(1<<plan[nb_args-i-1][0]);
856 }
857 #ifdef TCC_ARM_EABI
858 if(vtop->type.t == VT_VOID) {
859 if(s == RC_INT)
860 o(0xE24DD004); /* sub sp,sp,#4 */
861 vtop--;
862 } else
863 #endif
864 if(s == RC_INT) {
865 r = gv(s);
866 o(0xE52D0004|(intr(r)<<12)); /* str r,[sp,#-4]! */
867 vtop--;
868 } else {
869 plan2[keep]=s;
870 keep++;
871 }
872 args_size += size;
873 }
874 }
875 for(i=keep;i--;) {
876 gv(plan2[i]);
877 vrott(keep);
878 }
879 save_regs(keep); /* save used temporary registers */
880 keep++;
881 if(args_size) {
882 int n;
883 n=args_size/4;
884 if(n>4)
885 n=4;
886 todo&=((1<<n)-1);
887 if(todo) {
888 int i;
889 o(0xE8BD0000|todo);
890 for(i=0;i<4;i++)
891 if(todo&(1<<i)) {
892 vpushi(0);
893 vtop->r=i;
894 keep++;
895 }
896 }
897 args_size-=n*4;
898 }
899 vnrott(keep);
900 func_sym = vtop->type.ref;
901 gcall_or_jmp(0);
902 if (args_size)
903 gadd_sp(args_size);
904 #ifdef TCC_ARM_EABI
905 if((vtop->type.ref->type.t & VT_BTYPE) == VT_STRUCT
906 && type_size(&vtop->type.ref->type, &align) <= 4)
907 {
908 store(REG_IRET,vtop-keep);
909 ++keep;
910 }
911 #ifdef TCC_ARM_VFP
912 else if(is_float(vtop->type.ref->type.t)) {
913 if((vtop->type.ref->type.t & VT_BTYPE) == VT_FLOAT) {
914 o(0xEE000A10); /* fmsr s0,r0 */
915 } else {
916 o(0xEE000B10); /* fmdlr d0,r0 */
917 o(0xEE201B10); /* fmdhr d0,r1 */
918 }
919 }
920 #endif
921 #endif
922 vtop-=keep;
923 leaffunc = 0;
924 }
925
926 /* generate function prolog of type 't' */
927 void gfunc_prolog(CType *func_type)
928 {
929 Sym *sym,*sym2;
930 int n,addr,size,align;
931
932 sym = func_type->ref;
933 func_vt = sym->type;
934
935 n = 0;
936 addr = 0;
937 if((func_vt.t & VT_BTYPE) == VT_STRUCT
938 && type_size(&func_vt,&align) > 4)
939 {
940 func_vc = addr;
941 addr += 4;
942 n++;
943 }
944 for(sym2=sym->next;sym2 && n<4;sym2=sym2->next) {
945 size = type_size(&sym2->type, &align);
946 n += (size + 3) / 4;
947 }
948 o(0xE1A0C00D); /* mov ip,sp */
949 if(func_type->ref->c == FUNC_ELLIPSIS)
950 n=4;
951 if(n) {
952 if(n>4)
953 n=4;
954 #ifdef TCC_ARM_EABI
955 n=(n+1)&-2;
956 #endif
957 o(0xE92D0000|((1<<n)-1)); /* save r0-r4 on stack if needed */
958 }
959 o(0xE92D5800); /* save fp, ip, lr */
960 o(0xE28DB00C); /* add fp, sp, #12 */
961 func_sub_sp_offset = ind;
962 o(0xE1A00000); /* nop, leave space for stack adjustment */
963 while ((sym = sym->next)) {
964 CType *type;
965 type = &sym->type;
966 size = type_size(type, &align);
967 size = (size + 3) & -4;
968 #ifdef TCC_ARM_EABI
969 addr = (addr + align - 1) & -align;
970 #endif
971 sym_push(sym->v & ~SYM_FIELD, type, VT_LOCAL | lvalue_type(type->t), addr);
972 addr += size;
973 }
974 last_itod_magic=0;
975 leaffunc = 1;
976 loc = -12;
977 }
978
979 /* generate function epilog */
980 void gfunc_epilog(void)
981 {
982 unsigned long x;
983 int diff;
984 #ifdef TCC_ARM_EABI
985 if(is_float(func_vt.t)) {
986 if((func_vt.t & VT_BTYPE) == VT_FLOAT)
987 o(0xEE100A10); /* fmrs r0, s0 */
988 else {
989 o(0xEE100B10); /* fmrdl r0, d0 */
990 o(0xEE301B10); /* fmrdh r1, d0 */
991 }
992 }
993 #endif
994 o(0xE91BA800); /* restore fp, sp, pc */
995 diff = (-loc + 3) & -4;
996 #ifdef TCC_ARM_EABI
997 if(!leaffunc)
998 diff = (diff + 7) & -8;
999 #endif
1000 if(diff > 12) {
1001 x=stuff_const(0xE24BD000, diff); /* sub sp,fp,# */
1002 if(x)
1003 *(unsigned long *)(cur_text_section->data + func_sub_sp_offset) = x;
1004 else {
1005 unsigned long addr;
1006 addr=ind;
1007 o(0xE59FC004); /* ldr ip,[pc+4] */
1008 o(0xE04BD00C); /* sub sp,fp,ip */
1009 o(0xE1A0F00E); /* mov pc,lr */
1010 o(diff);
1011 *(unsigned long *)(cur_text_section->data + func_sub_sp_offset) = 0xE1000000|encbranch(func_sub_sp_offset,addr,1);
1012 }
1013 }
1014 }
1015
1016 /* generate a jump to a label */
1017 int gjmp(int t)
1018 {
1019 int r;
1020 r=ind;
1021 o(0xE0000000|encbranch(r,t,1));
1022 return r;
1023 }
1024
1025 /* generate a jump to a fixed address */
1026 void gjmp_addr(int a)
1027 {
1028 gjmp(a);
1029 }
1030
1031 /* generate a test. set 'inv' to invert test. Stack entry is popped */
1032 int gtst(int inv, int t)
1033 {
1034 int v, r;
1035 unsigned long op;
1036 v = vtop->r & VT_VALMASK;
1037 r=ind;
1038 if (v == VT_CMP) {
1039 op=mapcc(inv?negcc(vtop->c.i):vtop->c.i);
1040 op|=encbranch(r,t,1);
1041 o(op);
1042 t=r;
1043 } else if (v == VT_JMP || v == VT_JMPI) {
1044 if ((v & 1) == inv) {
1045 if(!vtop->c.i)
1046 vtop->c.i=t;
1047 else {
1048 unsigned long *x;
1049 int p,lp;
1050 if(t) {
1051 p = vtop->c.i;
1052 do {
1053 p = decbranch(lp=p);
1054 } while(p);
1055 x = (unsigned long *)(cur_text_section->data + lp);
1056 *x &= 0xff000000;
1057 *x |= encbranch(lp,t,1);
1058 }
1059 t = vtop->c.i;
1060 }
1061 } else {
1062 t = gjmp(t);
1063 gsym(vtop->c.i);
1064 }
1065 } else {
1066 if (is_float(vtop->type.t)) {
1067 r=gv(RC_FLOAT);
1068 #ifdef TCC_ARM_VFP
1069 o(0xEEB50A40|(vfpr(r)<<12)|T2CPR(vtop->type.t)); /* fcmpzX */
1070 o(0xEEF1FA10); /* fmstat */
1071 #else
1072 o(0xEE90F118|(fpr(r)<<16));
1073 #endif
1074 vtop->r = VT_CMP;
1075 vtop->c.i = TOK_NE;
1076 return gtst(inv, t);
1077 } else if ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST) {
1078 /* constant jmp optimization */
1079 if ((vtop->c.i != 0) != inv)
1080 t = gjmp(t);
1081 } else {
1082 v = gv(RC_INT);
1083 o(0xE3300000|(intr(v)<<16));
1084 vtop->r = VT_CMP;
1085 vtop->c.i = TOK_NE;
1086 return gtst(inv, t);
1087 }
1088 }
1089 vtop--;
1090 return t;
1091 }
1092
1093 /* generate an integer binary operation */
1094 void gen_opi(int op)
1095 {
1096 int c, func = 0;
1097 unsigned long opc = 0,r,fr;
1098 unsigned short retreg = REG_IRET;
1099
1100 c=0;
1101 switch(op) {
1102 case '+':
1103 opc = 0x8;
1104 c=1;
1105 break;
1106 case TOK_ADDC1: /* add with carry generation */
1107 opc = 0x9;
1108 c=1;
1109 break;
1110 case '-':
1111 opc = 0x4;
1112 c=1;
1113 break;
1114 case TOK_SUBC1: /* sub with carry generation */
1115 opc = 0x5;
1116 c=1;
1117 break;
1118 case TOK_ADDC2: /* add with carry use */
1119 opc = 0xA;
1120 c=1;
1121 break;
1122 case TOK_SUBC2: /* sub with carry use */
1123 opc = 0xC;
1124 c=1;
1125 break;
1126 case '&':
1127 opc = 0x0;
1128 c=1;
1129 break;
1130 case '^':
1131 opc = 0x2;
1132 c=1;
1133 break;
1134 case '|':
1135 opc = 0x18;
1136 c=1;
1137 break;
1138 case '*':
1139 gv2(RC_INT, RC_INT);
1140 r = vtop[-1].r;
1141 fr = vtop[0].r;
1142 vtop--;
1143 o(0xE0000090|(intr(r)<<16)|(intr(r)<<8)|intr(fr));
1144 return;
1145 case TOK_SHL:
1146 opc = 0;
1147 c=2;
1148 break;
1149 case TOK_SHR:
1150 opc = 1;
1151 c=2;
1152 break;
1153 case TOK_SAR:
1154 opc = 2;
1155 c=2;
1156 break;
1157 case '/':
1158 case TOK_PDIV:
1159 func=TOK___divsi3;
1160 c=3;
1161 break;
1162 case TOK_UDIV:
1163 func=TOK___udivsi3;
1164 c=3;
1165 break;
1166 case '%':
1167 #ifdef TCC_ARM_EABI
1168 func=TOK___aeabi_idivmod;
1169 retreg=REG_LRET;
1170 #else
1171 func=TOK___modsi3;
1172 #endif
1173 c=3;
1174 break;
1175 case TOK_UMOD:
1176 #ifdef TCC_ARM_EABI
1177 func=TOK___aeabi_uidivmod;
1178 retreg=REG_LRET;
1179 #else
1180 func=TOK___umodsi3;
1181 #endif
1182 c=3;
1183 break;
1184 case TOK_UMULL:
1185 gv2(RC_INT, RC_INT);
1186 r=intr(vtop[-1].r2=get_reg(RC_INT));
1187 c=vtop[-1].r;
1188 vtop[-1].r=get_reg_ex(RC_INT,regmask(c));
1189 vtop--;
1190 o(0xE0800090|(r<<16)|(intr(vtop->r)<<12)|(intr(c)<<8)|intr(vtop[1].r));
1191 return;
1192 default:
1193 opc = 0x15;
1194 c=1;
1195 break;
1196 }
1197 switch(c) {
1198 case 1:
1199 if((vtop[-1].r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST) {
1200 if(opc == 4 || opc == 5 || opc == 0xc) {
1201 vswap();
1202 opc|=2; // sub -> rsb
1203 }
1204 }
1205 if ((vtop->r & VT_VALMASK) == VT_CMP ||
1206 (vtop->r & (VT_VALMASK & ~1)) == VT_JMP)
1207 gv(RC_INT);
1208 vswap();
1209 c=intr(gv(RC_INT));
1210 vswap();
1211 opc=0xE0000000|(opc<<20)|(c<<16);
1212 if((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST) {
1213 unsigned long x;
1214 x=stuff_const(opc|0x2000000,vtop->c.i);
1215 if(x) {
1216 r=intr(vtop[-1].r=get_reg_ex(RC_INT,regmask(vtop[-1].r)));
1217 o(x|(r<<12));
1218 goto done;
1219 }
1220 }
1221 fr=intr(gv(RC_INT));
1222 r=intr(vtop[-1].r=get_reg_ex(RC_INT,two2mask(vtop->r,vtop[-1].r)));
1223 o(opc|(r<<12)|fr);
1224 done:
1225 vtop--;
1226 if (op >= TOK_ULT && op <= TOK_GT) {
1227 vtop->r = VT_CMP;
1228 vtop->c.i = op;
1229 }
1230 break;
1231 case 2:
1232 opc=0xE1A00000|(opc<<5);
1233 if ((vtop->r & VT_VALMASK) == VT_CMP ||
1234 (vtop->r & (VT_VALMASK & ~1)) == VT_JMP)
1235 gv(RC_INT);
1236 vswap();
1237 r=intr(gv(RC_INT));
1238 vswap();
1239 opc|=r;
1240 if ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST) {
1241 fr=intr(vtop[-1].r=get_reg_ex(RC_INT,regmask(vtop[-1].r)));
1242 c = vtop->c.i & 0x1f;
1243 o(opc|(c<<7)|(fr<<12));
1244 } else {
1245 fr=intr(gv(RC_INT));
1246 c=intr(vtop[-1].r=get_reg_ex(RC_INT,two2mask(vtop->r,vtop[-1].r)));
1247 o(opc|(c<<12)|(fr<<8)|0x10);
1248 }
1249 vtop--;
1250 break;
1251 case 3:
1252 vpush_global_sym(&func_old_type, func);
1253 vrott(3);
1254 gfunc_call(2);
1255 vpushi(0);
1256 vtop->r = retreg;
1257 break;
1258 default:
1259 error("gen_opi %i unimplemented!",op);
1260 }
1261 }
1262
1263 #ifdef TCC_ARM_VFP
1264 static int is_zero(int i)
1265 {
1266 if((vtop[i].r & (VT_VALMASK | VT_LVAL | VT_SYM)) != VT_CONST)
1267 return 0;
1268 if (vtop[i].type.t == VT_FLOAT)
1269 return (vtop[i].c.f == 0.f);
1270 else if (vtop[i].type.t == VT_DOUBLE)
1271 return (vtop[i].c.d == 0.0);
1272 return (vtop[i].c.ld == 0.l);
1273 }
1274
1275 /* generate a floating point operation 'v = t1 op t2' instruction. The
1276 * two operands are guaranted to have the same floating point type */
1277 void gen_opf(int op)
1278 {
1279 unsigned long x;
1280 int fneg=0,r;
1281 x=0xEE000A00|T2CPR(vtop->type.t);
1282 switch(op) {
1283 case '+':
1284 if(is_zero(-1))
1285 vswap();
1286 if(is_zero(0)) {
1287 vtop--;
1288 return;
1289 }
1290 x|=0x300000;
1291 break;
1292 case '-':
1293 x|=0x300040;
1294 if(is_zero(0)) {
1295 vtop--;
1296 return;
1297 }
1298 if(is_zero(-1)) {
1299 x|=0x810000; /* fsubX -> fnegX */
1300 vswap();
1301 vtop--;
1302 fneg=1;
1303 }
1304 break;
1305 case '*':
1306 x|=0x200000;
1307 break;
1308 case '/':
1309 x|=0x800000;
1310 break;
1311 default:
1312 if(op < TOK_ULT && op > TOK_GT) {
1313 error("unknown fp op %x!",op);
1314 return;
1315 }
1316 if(is_zero(-1)) {
1317 vswap();
1318 switch(op) {
1319 case TOK_LT: op=TOK_GT; break;
1320 case TOK_GE: op=TOK_ULE; break;
1321 case TOK_LE: op=TOK_GE; break;
1322 case TOK_GT: op=TOK_ULT; break;
1323 }
1324 }
1325 x|=0xB40040; /* fcmpX */
1326 if(op!=TOK_EQ && op!=TOK_NE)
1327 x|=0x80; /* fcmpX -> fcmpeX */
1328 if(is_zero(0)) {
1329 vtop--;
1330 o(x|0x10000|(vfpr(gv(RC_FLOAT))<<12)); /* fcmp(e)X -> fcmp(e)zX */
1331 } else {
1332 x|=vfpr(gv(RC_FLOAT));
1333 vswap();
1334 o(x|(vfpr(gv(RC_FLOAT))<<12));
1335 vtop--;
1336 }
1337 o(0xEEF1FA10); /* fmstat */
1338
1339 switch(op) {
1340 case TOK_LE: op=TOK_ULE; break;
1341 case TOK_LT: op=TOK_ULT; break;
1342 case TOK_UGE: op=TOK_GE; break;
1343 case TOK_UGT: op=TOK_GT; break;
1344 }
1345
1346 vtop->r = VT_CMP;
1347 vtop->c.i = op;
1348 return;
1349 }
1350 r=gv(RC_FLOAT);
1351 x|=vfpr(r);
1352 r=regmask(r);
1353 if(!fneg) {
1354 int r2;
1355 vswap();
1356 r2=gv(RC_FLOAT);
1357 x|=vfpr(r2)<<16;
1358 r|=regmask(r2);
1359 }
1360 vtop->r=get_reg_ex(RC_FLOAT,r);
1361 if(!fneg)
1362 vtop--;
1363 o(x|(vfpr(vtop->r)<<12));
1364 }
1365
1366 #else
1367 static int is_fconst()
1368 {
1369 long double f;
1370 int r;
1371 if((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) != VT_CONST)
1372 return 0;
1373 if (vtop->type.t == VT_FLOAT)
1374 f = vtop->c.f;
1375 else if (vtop->type.t == VT_DOUBLE)
1376 f = vtop->c.d;
1377 else
1378 f = vtop->c.ld;
1379 if(!ieee_finite(f))
1380 return 0;
1381 r=0x8;
1382 if(f<0.0) {
1383 r=0x18;
1384 f=-f;
1385 }
1386 if(f==0.0)
1387 return r;
1388 if(f==1.0)
1389 return r|1;
1390 if(f==2.0)
1391 return r|2;
1392 if(f==3.0)
1393 return r|3;
1394 if(f==4.0)
1395 return r|4;
1396 if(f==5.0)
1397 return r|5;
1398 if(f==0.5)
1399 return r|6;
1400 if(f==10.0)
1401 return r|7;
1402 return 0;
1403 }
1404
1405 /* generate a floating point operation 'v = t1 op t2' instruction. The
1406 two operands are guaranted to have the same floating point type */
1407 void gen_opf(int op)
1408 {
1409 unsigned long x;
1410 int r,r2,c1,c2;
1411 //fputs("gen_opf\n",stderr);
1412 vswap();
1413 c1 = is_fconst();
1414 vswap();
1415 c2 = is_fconst();
1416 x=0xEE000100;
1417 #if LDOUBLE_SIZE == 8
1418 if ((vtop->type.t & VT_BTYPE) != VT_FLOAT)
1419 x|=0x80;
1420 #else
1421 if ((vtop->type.t & VT_BTYPE) == VT_DOUBLE)
1422 x|=0x80;
1423 else if ((vtop->type.t & VT_BTYPE) == VT_LDOUBLE)
1424 x|=0x80000;
1425 #endif
1426 switch(op)
1427 {
1428 case '+':
1429 if(!c2) {
1430 vswap();
1431 c2=c1;
1432 }
1433 vswap();
1434 r=fpr(gv(RC_FLOAT));
1435 vswap();
1436 if(c2) {
1437 if(c2>0xf)
1438 x|=0x200000; // suf
1439 r2=c2&0xf;
1440 } else {
1441 r2=fpr(gv(RC_FLOAT));
1442 }
1443 break;
1444 case '-':
1445 if(c2) {
1446 if(c2<=0xf)
1447 x|=0x200000; // suf
1448 r2=c2&0xf;
1449 vswap();
1450 r=fpr(gv(RC_FLOAT));
1451 vswap();
1452 } else if(c1 && c1<=0xf) {
1453 x|=0x300000; // rsf
1454 r2=c1;
1455 r=fpr(gv(RC_FLOAT));
1456 vswap();
1457 } else {
1458 x|=0x200000; // suf
1459 vswap();
1460 r=fpr(gv(RC_FLOAT));
1461 vswap();
1462 r2=fpr(gv(RC_FLOAT));
1463 }
1464 break;
1465 case '*':
1466 if(!c2 || c2>0xf) {
1467 vswap();
1468 c2=c1;
1469 }
1470 vswap();
1471 r=fpr(gv(RC_FLOAT));
1472 vswap();
1473 if(c2 && c2<=0xf)
1474 r2=c2;
1475 else
1476 r2=fpr(gv(RC_FLOAT));
1477 x|=0x100000; // muf
1478 break;
1479 case '/':
1480 if(c2 && c2<=0xf) {
1481 x|=0x400000; // dvf
1482 r2=c2;
1483 vswap();
1484 r=fpr(gv(RC_FLOAT));
1485 vswap();
1486 } else if(c1 && c1<=0xf) {
1487 x|=0x500000; // rdf
1488 r2=c1;
1489 r=fpr(gv(RC_FLOAT));
1490 vswap();
1491 } else {
1492 x|=0x400000; // dvf
1493 vswap();
1494 r=fpr(gv(RC_FLOAT));
1495 vswap();
1496 r2=fpr(gv(RC_FLOAT));
1497 }
1498 break;
1499 default:
1500 if(op >= TOK_ULT && op <= TOK_GT) {
1501 x|=0xd0f110; // cmfe
1502 /* bug (intention?) in Linux FPU emulator
1503 doesn't set carry if equal */
1504 switch(op) {
1505 case TOK_ULT:
1506 case TOK_UGE:
1507 case TOK_ULE:
1508 case TOK_UGT:
1509 error("unsigned comparision on floats?");
1510 break;
1511 case TOK_LT:
1512 op=TOK_Nset;
1513 break;
1514 case TOK_LE:
1515 op=TOK_ULE; /* correct in unordered case only if AC bit in FPSR set */
1516 break;
1517 case TOK_EQ:
1518 case TOK_NE:
1519 x&=~0x400000; // cmfe -> cmf
1520 break;
1521 }
1522 if(c1 && !c2) {
1523 c2=c1;
1524 vswap();
1525 switch(op) {
1526 case TOK_Nset:
1527 op=TOK_GT;
1528 break;
1529 case TOK_GE:
1530 op=TOK_ULE;
1531 break;
1532 case TOK_ULE:
1533 op=TOK_GE;
1534 break;
1535 case TOK_GT:
1536 op=TOK_Nset;
1537 break;
1538 }
1539 }
1540 vswap();
1541 r=fpr(gv(RC_FLOAT));
1542 vswap();
1543 if(c2) {
1544 if(c2>0xf)
1545 x|=0x200000;
1546 r2=c2&0xf;
1547 } else {
1548 r2=fpr(gv(RC_FLOAT));
1549 }
1550 vtop[-1].r = VT_CMP;
1551 vtop[-1].c.i = op;
1552 } else {
1553 error("unknown fp op %x!",op);
1554 return;
1555 }
1556 }
1557 if(vtop[-1].r == VT_CMP)
1558 c1=15;
1559 else {
1560 c1=vtop->r;
1561 if(r2&0x8)
1562 c1=vtop[-1].r;
1563 vtop[-1].r=get_reg_ex(RC_FLOAT,two2mask(vtop[-1].r,c1));
1564 c1=fpr(vtop[-1].r);
1565 }
1566 vtop--;
1567 o(x|(r<<16)|(c1<<12)|r2);
1568 }
1569 #endif
1570
1571 /* convert integers to fp 't' type. Must handle 'int', 'unsigned int'
1572 and 'long long' cases. */
1573 void gen_cvt_itof1(int t)
1574 {
1575 int r,r2,bt;
1576 bt=vtop->type.t & VT_BTYPE;
1577 if(bt == VT_INT || bt == VT_SHORT || bt == VT_BYTE) {
1578 #ifndef TCC_ARM_VFP
1579 unsigned int dsize=0;
1580 #endif
1581 r=intr(gv(RC_INT));
1582 #ifdef TCC_ARM_VFP
1583 r2=vfpr(vtop->r=get_reg(RC_FLOAT));
1584 o(0xEE000A10|(r<<12)|(r2<<16)); /* fmsr */
1585 r2<<=12;
1586 if(!(vtop->type.t & VT_UNSIGNED))
1587 r2|=0x80; /* fuitoX -> fsituX */
1588 o(0xEEB80A40|r2|T2CPR(t)); /* fYitoX*/
1589 #else
1590 r2=fpr(vtop->r=get_reg(RC_FLOAT));
1591 if((t & VT_BTYPE) != VT_FLOAT)
1592 dsize=0x80; /* flts -> fltd */
1593 o(0xEE000110|dsize|(r2<<16)|(r<<12)); /* flts */
1594 if((vtop->type.t & (VT_UNSIGNED|VT_BTYPE)) == (VT_UNSIGNED|VT_INT)) {
1595 unsigned int off=0;
1596 o(0xE3500000|(r<<12)); /* cmp */
1597 r=fpr(get_reg(RC_FLOAT));
1598 if(last_itod_magic) {
1599 off=ind+8-last_itod_magic;
1600 off/=4;
1601 if(off>255)
1602 off=0;
1603 }
1604 o(0xBD1F0100|(r<<12)|off); /* ldflts */
1605 if(!off) {
1606 o(0xEA000000); /* b */
1607 last_itod_magic=ind;
1608 o(0x4F800000); /* 4294967296.0f */
1609 }
1610 o(0xBE000100|dsize|(r2<<16)|(r2<<12)|r); /* adflt */
1611 }
1612 #endif
1613 return;
1614 } else if(bt == VT_LLONG) {
1615 int func;
1616 CType *func_type = 0;
1617 if((t & VT_BTYPE) == VT_FLOAT) {
1618 func_type = &func_float_type;
1619 if(vtop->type.t & VT_UNSIGNED)
1620 func=TOK___floatundisf;
1621 else
1622 func=TOK___floatdisf;
1623 #if LDOUBLE_SIZE != 8
1624 } else if((t & VT_BTYPE) == VT_LDOUBLE) {
1625 func_type = &func_ldouble_type;
1626 if(vtop->type.t & VT_UNSIGNED)
1627 func=TOK___floatundixf;
1628 else
1629 func=TOK___floatdixf;
1630 } else if((t & VT_BTYPE) == VT_DOUBLE) {
1631 #else
1632 } else if((t & VT_BTYPE) == VT_DOUBLE || (t & VT_BTYPE) == VT_LDOUBLE) {
1633 #endif
1634 func_type = &func_double_type;
1635 if(vtop->type.t & VT_UNSIGNED)
1636 func=TOK___floatundidf;
1637 else
1638 func=TOK___floatdidf;
1639 }
1640 if(func_type) {
1641 vpush_global_sym(func_type, func);
1642 vswap();
1643 gfunc_call(1);
1644 vpushi(0);
1645 vtop->r=TREG_F0;
1646 return;
1647 }
1648 }
1649 error("unimplemented gen_cvt_itof %x!",vtop->type.t);
1650 }
1651
1652 /* convert fp to int 't' type */
1653 void gen_cvt_ftoi(int t)
1654 {
1655 int r,r2,u,func=0;
1656 u=t&VT_UNSIGNED;
1657 t&=VT_BTYPE;
1658 r2=vtop->type.t & VT_BTYPE;
1659 if(t==VT_INT) {
1660 #ifdef TCC_ARM_VFP
1661 r=vfpr(gv(RC_FLOAT));
1662 u=u?0:0x10000;
1663 o(0xEEBC0A40|(r<<12)|r|T2CPR(r2)); /* ftoXiY */
1664 r2=intr(vtop->r=get_reg(RC_INT));
1665 o(0xEE100A10|(r<<16)|(r2<<12));
1666 return;
1667 #else
1668 if(u) {
1669 if(r2 == VT_FLOAT)
1670 func=TOK___fixunssfsi;
1671 #if LDOUBLE_SIZE != 8
1672 else if(r2 == VT_LDOUBLE)
1673 func=TOK___fixunsxfsi;
1674 else if(r2 == VT_DOUBLE)
1675 #else
1676 else if(r2 == VT_LDOUBLE || r2 == VT_DOUBLE)
1677 #endif
1678 func=TOK___fixunsdfsi;
1679 } else {
1680 r=fpr(gv(RC_FLOAT));
1681 r2=intr(vtop->r=get_reg(RC_INT));
1682 o(0xEE100170|(r2<<12)|r);
1683 return;
1684 }
1685 #endif
1686 } else if(t == VT_LLONG) { // unsigned handled in gen_cvt_ftoi1
1687 if(r2 == VT_FLOAT)
1688 func=TOK___fixsfdi;
1689 #if LDOUBLE_SIZE != 8
1690 else if(r2 == VT_LDOUBLE)
1691 func=TOK___fixxfdi;
1692 else if(r2 == VT_DOUBLE)
1693 #else
1694 else if(r2 == VT_LDOUBLE || r2 == VT_DOUBLE)
1695 #endif
1696 func=TOK___fixdfdi;
1697 }
1698 if(func) {
1699 vpush_global_sym(&func_old_type, func);
1700 vswap();
1701 gfunc_call(1);
1702 vpushi(0);
1703 if(t == VT_LLONG)
1704 vtop->r2 = REG_LRET;
1705 vtop->r = REG_IRET;
1706 return;
1707 }
1708 error("unimplemented gen_cvt_ftoi!");
1709 }
1710
1711 /* convert from one floating point type to another */
1712 void gen_cvt_ftof(int t)
1713 {
1714 #ifdef TCC_ARM_VFP
1715 if(((vtop->type.t & VT_BTYPE) == VT_FLOAT) != ((t & VT_BTYPE) == VT_FLOAT)) {
1716 int r=vfpr(gv(RC_FLOAT));
1717 o(0xEEB70AC0|(r<<12)|r|T2CPR(vtop->type.t));
1718 }
1719 #else
1720 /* all we have to do on i386 and FPA ARM is to put the float in a register */
1721 gv(RC_FLOAT);
1722 #endif
1723 }
1724
1725 /* computed goto support */
1726 void ggoto(void)
1727 {
1728 gcall_or_jmp(1);
1729 vtop--;
1730 }
1731
1732 /* end of ARM code generator */
1733 /*************************************************************/
1734
Tiny C Compiler main repository