arm-gen.c

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