arm-gen.c

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