Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | Download | RSS feed

  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. /* number of available registers */
  24. #define NB_REGS             9
  25.  
  26. /* a register can belong to several classes. The classes must be
  27.    sorted from more general to more precise (see gv2() code which does
  28.    assumptions on it). */
  29. #define RC_INT     0x0001 /* generic integer register */
  30. #define RC_FLOAT   0x0002 /* generic float register */
  31. #define RC_R0      0x0004
  32. #define RC_R1      0x0008
  33. #define RC_R2      0x0010
  34. #define RC_R3      0x0020
  35. #define RC_R12     0x0040
  36. #define RC_F0      0x0080
  37. #define RC_F1      0x0100
  38. #define RC_F2      0x0200
  39. #define RC_F3      0x0400
  40. #define RC_IRET    RC_R0  /* function return: integer register */
  41. #define RC_LRET    RC_R1  /* function return: second integer register */
  42. #define RC_FRET    RC_F0  /* function return: float register */
  43.  
  44. /* pretty names for the registers */
  45. enum {
  46.     TREG_R0 = 0,
  47.     TREG_R1,
  48.     TREG_R2,
  49.     TREG_R3,
  50.     TREG_R12,
  51.     TREG_F0,
  52.     TREG_F1,
  53.     TREG_F2,
  54.     TREG_F3,
  55. };
  56.  
  57. int reg_classes[NB_REGS] = {
  58.     /* r0 */ RC_INT | RC_R0,
  59.     /* r1 */ RC_INT | RC_R1,
  60.     /* r2 */ RC_INT | RC_R2,
  61.     /* r3 */ RC_INT | RC_R3,
  62.     /* r12 */ RC_INT | RC_R12,
  63.     /* f0 */ RC_FLOAT | RC_F0,
  64.     /* f1 */ RC_FLOAT | RC_F1,
  65.     /* f2 */ RC_FLOAT | RC_F2,
  66.     /* f3 */ RC_FLOAT | RC_F3,
  67. };
  68.  
  69. static int two2mask(int a,int b) {
  70.   return (reg_classes[a]|reg_classes[b])&~(RC_INT|RC_FLOAT);
  71. }
  72.  
  73. static int regmask(int r) {
  74.   return reg_classes[r]&~(RC_INT|RC_FLOAT);
  75. }
  76.  
  77. /* return registers for function */
  78. #define REG_IRET TREG_R0 /* single word int return register */
  79. #define REG_LRET TREG_R1 /* second word return register (for long long) */
  80. #define REG_FRET TREG_F0 /* float return register */
  81.  
  82. /* defined if function parameters must be evaluated in reverse order */
  83. #define INVERT_FUNC_PARAMS
  84.  
  85. /* defined if structures are passed as pointers. Otherwise structures
  86.    are directly pushed on stack. */
  87. //#define FUNC_STRUCT_PARAM_AS_PTR
  88.  
  89. /* pointer size, in bytes */
  90. #define PTR_SIZE 4
  91.  
  92. /* long double size and alignment, in bytes */
  93. #define LDOUBLE_SIZE  8
  94. #define LDOUBLE_ALIGN 4
  95. /* maximum alignment (for aligned attribute support) */
  96. #define MAX_ALIGN     8
  97.  
  98. #define CHAR_IS_UNSIGNED
  99.  
  100. /******************************************************/
  101. /* ELF defines */
  102.  
  103. #define EM_TCC_TARGET EM_ARM
  104.  
  105. /* relocation type for 32 bit data relocation */
  106. #define R_DATA_32   R_ARM_ABS32
  107. #define R_JMP_SLOT  R_ARM_JUMP_SLOT
  108. #define R_COPY      R_ARM_COPY
  109.  
  110. #define ELF_START_ADDR 0x00008000
  111. #define ELF_PAGE_SIZE  0x1000
  112.  
  113. /******************************************************/
  114. static unsigned long func_sub_sp_offset,last_itod_magic;
  115.  
  116. void o(unsigned long i)
  117. {
  118.   /* this is a good place to start adding big-endian support*/
  119.   int ind1;
  120.  
  121.   ind1 = ind + 4;
  122.   if (!cur_text_section)
  123.     error("compiler error! This happens f.ex. if the compiler\n"
  124.          "can't evaluate constant expressions outside of a function.");
  125.   if (ind1 > cur_text_section->data_allocated)
  126.     section_realloc(cur_text_section, ind1);
  127.   cur_text_section->data[ind++] = i&255;
  128.   i>>=8;
  129.   cur_text_section->data[ind++] = i&255;
  130.   i>>=8;
  131.   cur_text_section->data[ind++] = i&255;
  132.   i>>=8;
  133.   cur_text_section->data[ind++] = i;
  134. }
  135.  
  136. static unsigned long stuff_const(unsigned long op,unsigned long c)
  137. {
  138.   int try_neg=0;
  139.   unsigned long nc = 0,negop = 0;
  140.  
  141.   switch(op&0x1F00000)
  142.   {
  143.     case 0x800000: //add
  144.     case 0x400000: //sub
  145.       try_neg=1;
  146.       negop=op^0xC00000;
  147.       nc=-c;
  148.       break;
  149.     case 0x1A00000: //mov
  150.     case 0x1E00000: //mvn
  151.       try_neg=1;
  152.       negop=op^0x400000;
  153.       nc=~c;
  154.       break;
  155.     case 0x200000: //xor
  156.       if(c==~0)
  157.         return (op&0xF010F000)|((op>>16)&0xF)|0x1E00000;
  158.       break;
  159.     case 0x0: //and
  160.       if(c==~0)
  161.         return (op&0xF010F000)|((op>>16)&0xF)|0x1A00000;
  162.     case 0x1C00000: //bic
  163.       try_neg=1;
  164.       negop=op^0x1C00000;
  165.       nc=~c;
  166.       break;
  167.     case 0x1800000: //orr
  168.       if(c==~0)
  169.         return (op&0xFFF0FFFF)|0x1E00000;
  170.       break;
  171.   }
  172.   do {
  173.     unsigned long m;
  174.     int i;
  175.     if(c<256) /* catch undefined <<32 */
  176.       return op|c;
  177.     for(i=2;i<32;i+=2) {
  178.       m=(0xff>>i)|(0xff<<(32-i));
  179.       if(!(c&~m))
  180.         return op|(i<<7)|(c<<i)|(c>>(32-i));
  181.     }
  182.     op=negop;
  183.     c=nc;
  184.   } while(try_neg--);
  185.   return 0;
  186. }
  187.  
  188.  
  189. //only add,sub
  190. void stuff_const_harder(unsigned long op,unsigned long v) {
  191.   unsigned long x;
  192.   x=stuff_const(op,v);
  193.   if(x)
  194.     o(x);
  195.   else {
  196.     unsigned long a[16],nv,no,o2,n2;
  197.     int i,j,k;
  198.     a[0]=0xff;
  199.     o2=(op&0xfff0ffff)|((op&0xf000)<<4);;
  200.     for(i=1;i<16;i++)
  201.       a[i]=(a[i-1]>>2)|(a[i-1]<<30);
  202.     for(i=0;i<12;i++)
  203.       for(j=i+4;i<13+i;i++)
  204.         if((v&(a[i]|a[j]))==v) {
  205.           o(stuff_const(op,v&a[i]));
  206.           o(stuff_const(o2,v&a[j]));
  207.           return;
  208.         }
  209.     no=op^0xC00000;
  210.     n2=o2^0xC00000;
  211.     nv=-v;
  212.     for(i=0;i<12;i++)
  213.       for(j=i+4;i<13+i;i++)
  214.         if((nv&(a[i]|a[j]))==nv) {
  215.           o(stuff_const(no,nv&a[i]));
  216.           o(stuff_const(n2,nv&a[j]));
  217.           return;
  218.         }
  219.     for(i=0;i<8;i++)
  220.       for(j=i+4;i<12;i++)
  221.         for(k=j+4;k<13+i;i++)
  222.           if((v&(a[i]|a[j]|a[k]))==v) {
  223.             o(stuff_const(op,v&a[i]));
  224.             o(stuff_const(o2,v&a[j]));
  225.             o(stuff_const(o2,v&a[k]));
  226.             return;
  227.           }
  228.     no=op^0xC00000;
  229.     nv=-v;
  230.     for(i=0;i<8;i++)
  231.       for(j=i+4;i<12;i++)
  232.         for(k=j+4;k<13+i;i++)
  233.           if((nv&(a[i]|a[j]|a[k]))==nv) {
  234.             o(stuff_const(no,nv&a[i]));
  235.             o(stuff_const(n2,nv&a[j]));
  236.             o(stuff_const(n2,nv&a[k]));
  237.             return;
  238.           }
  239.     o(stuff_const(op,v&a[0]));
  240.     o(stuff_const(o2,v&a[4]));
  241.     o(stuff_const(o2,v&a[8]));
  242.     o(stuff_const(o2,v&a[12]));
  243.   }
  244. }
  245.  
  246. unsigned long encbranch(int pos,int addr,int fail)
  247. {
  248.   addr-=pos+8;
  249.   addr/=4;
  250.   if(addr>=0x1000000 || addr<-0x1000000) {
  251.     if(fail)
  252.       error("FIXME: function bigger than 32MB");
  253.     return 0;
  254.   }
  255.   return 0x0A000000|(addr&0xffffff);
  256. }
  257.  
  258. int decbranch(int pos)
  259. {
  260.   int x;
  261.   x=*(int *)(cur_text_section->data + pos);
  262.   x&=0x00ffffff;
  263.   if(x&0x800000)
  264.     x-=0x1000000;
  265.   return x*4+pos+8;
  266. }
  267.  
  268. /* output a symbol and patch all calls to it */
  269. void gsym_addr(int t, int a)
  270. {
  271.   unsigned long *x;
  272.   int lt;
  273.   while(t) {
  274.     x=(unsigned long *)(cur_text_section->data + t);
  275.     t=decbranch(lt=t);
  276.     if(a==lt+4)
  277.       *x=0xE1A00000; // nop
  278.     else {
  279.       *x &= 0xff000000;
  280.       *x |= encbranch(lt,a,1);
  281.     }
  282.   }
  283. }
  284.  
  285. void gsym(int t)
  286. {
  287.   gsym_addr(t, ind);
  288. }
  289.  
  290. static unsigned long fpr(int r)
  291. {
  292.   if(r<TREG_F0 || r>TREG_F3)
  293.     error("compiler error! register %i is no fp register\n",r);
  294.   return r-5;
  295. }
  296.  
  297. static unsigned long intr(int r)
  298. {
  299.   if(r==4)
  300.     return 12;
  301.   if((r<0 || r>4) && r!=14)
  302.     error("compiler error! register %i is no int register\n",r);
  303.   return r;
  304. }
  305.  
  306. static void calcaddr(unsigned long *base,int *off,int *sgn,int maxoff,unsigned shift)
  307. {
  308.   if(*off>maxoff || *off&((1<<shift)-1)) {
  309.     unsigned long x,y;
  310.     x=0xE280E000;
  311.     if(*sgn)
  312.       x=0xE240E000;
  313.     x|=(*base)<<16;
  314.     *base=14; // lr
  315.     y=stuff_const(x,*off&~maxoff);
  316.     if(y) {
  317.       o(y);
  318.       *off&=maxoff;
  319.       return;
  320.     }
  321.     y=stuff_const(x,(*off+maxoff)&~maxoff);
  322.     if(y) {
  323.       o(y);
  324.       *sgn=!*sgn;
  325.       *off=((*off+maxoff)&~maxoff)-*off;
  326.       return;
  327.     }
  328.     stuff_const_harder(x,*off&~maxoff);
  329.     *off&=maxoff;
  330.   }
  331. }
  332.  
  333. static unsigned long mapcc(int cc)
  334. {
  335.   switch(cc)
  336.   {
  337.     case TOK_ULT:
  338.       return 0x30000000;
  339.     case TOK_UGE:
  340.       return 0x20000000;
  341.     case TOK_EQ:
  342.       return 0x00000000;
  343.     case TOK_NE:
  344.       return 0x10000000;
  345.     case TOK_ULE:
  346.       return 0x90000000;
  347.     case TOK_UGT:
  348.       return 0x80000000;
  349.     case TOK_LT:
  350.       return 0xB0000000;
  351.     case TOK_GE:
  352.       return 0xA0000000;
  353.     case TOK_LE:
  354.       return 0xD0000000;
  355.     case TOK_GT:
  356.       return 0xC0000000;
  357.   }
  358.   error("unexpected condition code");
  359.   return 0xE0000000;
  360. }
  361.  
  362. static int negcc(int cc)
  363. {
  364.   switch(cc)
  365.   {
  366.     case TOK_ULT:
  367.       return TOK_UGE;
  368.     case TOK_UGE:
  369.       return TOK_ULT;
  370.     case TOK_EQ:
  371.       return TOK_NE;
  372.     case TOK_NE:
  373.       return TOK_EQ;
  374.     case TOK_ULE:
  375.       return TOK_UGT;
  376.     case TOK_UGT:
  377.       return TOK_ULE;
  378.     case TOK_LT:
  379.       return TOK_GE;
  380.     case TOK_GE:
  381.       return TOK_LT;
  382.     case TOK_LE:
  383.       return TOK_GT;
  384.     case TOK_GT:
  385.       return TOK_LE;
  386.   }
  387.   error("unexpected condition code");
  388.   return TOK_NE;
  389. }
  390.  
  391. /* load 'r' from value 'sv' */
  392. void load(int r, SValue *sv)
  393. {
  394.   int v, ft, fc, fr, sign;
  395.   unsigned long op;
  396.   SValue v1;
  397.  
  398.   fr = sv->r;
  399.   ft = sv->type.t;
  400.   fc = sv->c.ul;
  401.  
  402.   if(fc>=0)
  403.     sign=0;
  404.   else {
  405.     sign=1;
  406.     fc=-fc;
  407.   }
  408.  
  409.   v = fr & VT_VALMASK;
  410.   if (fr & VT_LVAL) {
  411.     unsigned long base=0xB; // fp
  412.     if(v == VT_LLOCAL) {
  413.       v1.type.t = VT_PTR;
  414.       v1.r = VT_LOCAL | VT_LVAL;
  415.       v1.c.ul = sv->c.ul;
  416.       load(base=14 /* lr */, &v1);
  417.       fc=sign=0;
  418.       v=VT_LOCAL;
  419.     } else if(v == VT_CONST) {
  420.       v1.type.t = VT_PTR;
  421.       v1.r = fr&~VT_LVAL;
  422.       v1.c.ul = sv->c.ul;
  423.       v1.sym=sv->sym;
  424.       load(base=14, &v1);
  425.       fc=sign=0;
  426.       v=VT_LOCAL;
  427.     } else if(v < VT_CONST) {
  428.       base=intr(v);
  429.       fc=sign=0;
  430.       v=VT_LOCAL;
  431.     }
  432.     if(v == VT_LOCAL) {
  433.       if(is_float(ft)) {
  434.         calcaddr(&base,&fc,&sign,1020,2);
  435.         op=0xED100100;
  436.         if(!sign)
  437.           op|=0x800000;
  438. #if LDOUBLE_SIZE == 8
  439.         if ((ft & VT_BTYPE) != VT_FLOAT)
  440.           op|=0x8000;
  441. #else
  442.         if ((ft & VT_BTYPE) == VT_DOUBLE)
  443.           op|=0x8000;
  444.         else if ((ft & VT_BTYPE) == VT_LDOUBLE)
  445.           op|=0x400000;
  446. #endif
  447.         o(op|(fpr(r)<<12)|(fc>>2)|(base<<16));
  448.       } else if((ft & VT_TYPE) == VT_BYTE || (ft & VT_BTYPE) == VT_SHORT) {
  449.         calcaddr(&base,&fc,&sign,255,0);
  450.         op=0xE1500090;
  451.         if ((ft & VT_BTYPE) == VT_SHORT)
  452.           op|=0x20;
  453.         if ((ft & VT_UNSIGNED) == 0)
  454.           op|=0x40;
  455.         if(!sign)
  456.           op|=0x800000;
  457.         o(op|(intr(r)<<12)|(base<<16)|((fc&0xf0)<<4)|(fc&0xf));
  458.       } else {
  459.         calcaddr(&base,&fc,&sign,4095,0);
  460.         op=0xE5100000;
  461.         if(!sign)
  462.           op|=0x800000;
  463.         if ((ft & VT_BTYPE) == VT_BYTE)
  464.           op|=0x400000;
  465.         o(op|(intr(r)<<12)|fc|(base<<16));
  466.       }
  467.       return;
  468.     }
  469.   } else {
  470.     if (v == VT_CONST) {
  471.       op=stuff_const(0xE3A00000|(intr(r)<<12),sv->c.ul);
  472.       if (fr & VT_SYM || !op) {
  473.         o(0xE59F0000|(intr(r)<<12));
  474.         o(0xEA000000);
  475.         if(fr & VT_SYM)
  476.           greloc(cur_text_section, sv->sym, ind, R_ARM_ABS32);
  477.         o(sv->c.ul);
  478.       } else
  479.         o(op);
  480.       return;
  481.     } else if (v == VT_LOCAL) {
  482.       op=stuff_const(0xE28B0000|(intr(r)<<12),sv->c.ul);
  483.       if (fr & VT_SYM || !op) {
  484.         o(0xE59F0000|(intr(r)<<12));
  485.         o(0xEA000000);
  486.         if(fr & VT_SYM) // needed ?
  487.           greloc(cur_text_section, sv->sym, ind, R_ARM_ABS32);
  488.         o(sv->c.ul);
  489.         o(0xE08B0000|(intr(r)<<12)|intr(r));
  490.       } else
  491.         o(op);
  492.       return;
  493.     } else if(v == VT_CMP) {
  494.       o(mapcc(sv->c.ul)|0x3A00001|(intr(r)<<12));
  495.       o(mapcc(negcc(sv->c.ul))|0x3A00000|(intr(r)<<12));
  496.       return;
  497.     } else if (v == VT_JMP || v == VT_JMPI) {
  498.       int t;
  499.       t = v & 1;
  500.       o(0xE3A00000|(intr(r)<<12)|t);
  501.       o(0xEA000000);
  502.       gsym(sv->c.ul);
  503.       o(0xE3A00000|(intr(r)<<12)|(t^1));
  504.       return;
  505.     } else if (v < VT_CONST) {
  506.       if(is_float(ft))
  507.         o(0xEE008180|(fpr(r)<<12)|fpr(v));
  508.       else
  509.         o(0xE1A00000|(intr(r)<<12)|intr(v));
  510.       return;
  511.     }
  512.   }
  513.   error("load unimplemented!");
  514. }
  515.  
  516. /* store register 'r' in lvalue 'v' */
  517. void store(int r, SValue *sv)
  518. {
  519.   SValue v1;
  520.   int v, ft, fc, fr, sign;
  521.   unsigned long op;
  522.  
  523.   fr = sv->r;
  524.   ft = sv->type.t;
  525.   fc = sv->c.ul;
  526.  
  527.   if(fc>=0)
  528.     sign=0;
  529.   else {
  530.     sign=1;
  531.     fc=-fc;
  532.   }
  533.  
  534.   v = fr & VT_VALMASK;
  535.   if (fr & VT_LVAL || fr == VT_LOCAL) {
  536.     unsigned long base=0xb;
  537.     if(v < VT_CONST) {
  538.       base=intr(v);
  539.       v=VT_LOCAL;
  540.       fc=sign=0;
  541.     } else if(v == VT_CONST) {
  542.       v1.type.t = ft;
  543.       v1.r = fr&~VT_LVAL;
  544.       v1.c.ul = sv->c.ul;
  545.       v1.sym=sv->sym;
  546.       load(base=14, &v1);
  547.       fc=sign=0;
  548.       v=VT_LOCAL;  
  549.     }
  550.     if(v == VT_LOCAL) {
  551.        if(is_float(ft)) {
  552.         calcaddr(&base,&fc,&sign,1020,2);
  553.         op=0xED000100;
  554.         if(!sign)
  555.           op|=0x800000;
  556. #if LDOUBLE_SIZE == 8
  557.         if ((ft & VT_BTYPE) != VT_FLOAT)
  558.           op|=0x8000;
  559. #else
  560.         if ((ft & VT_BTYPE) == VT_DOUBLE)
  561.           op|=0x8000;
  562.         if ((ft & VT_BTYPE) == VT_LDOUBLE)
  563.           op|=0x400000;
  564. #endif
  565.         o(op|(fpr(r)<<12)|(fc>>2)|(base<<16));
  566.         return;
  567.       } else if((ft & VT_BTYPE) == VT_SHORT) {
  568.         calcaddr(&base,&fc,&sign,255,0);
  569.         op=0xE14000B0;
  570.         if(!sign)
  571.           op|=0x800000;
  572.         o(op|(intr(r)<<12)|(base<<16)|((fc&0xf0)<<4)|(fc&0xf));
  573.       } else {
  574.         calcaddr(&base,&fc,&sign,4095,0);
  575.         op=0xE5000000;
  576.         if(!sign)
  577.           op|=0x800000;
  578.         if ((ft & VT_BTYPE) == VT_BYTE)
  579.           op|=0x400000;
  580.         o(op|(intr(r)<<12)|fc|(base<<16));
  581.       }
  582.       return;
  583.     }
  584.   }
  585.   error("store unimplemented");
  586. }
  587.  
  588. static void gadd_sp(int val)
  589. {
  590.   stuff_const_harder(0xE28DD000,val);
  591. }
  592.  
  593. /* 'is_jmp' is '1' if it is a jump */
  594. static void gcall_or_jmp(int is_jmp)
  595. {
  596.   int r;
  597.   if ((vtop->r & (VT_VALMASK | VT_LVAL)) == VT_CONST) {
  598.     unsigned long x;
  599.     /* constant case */
  600.     x=encbranch(ind,ind+vtop->c.ul,0);
  601.     if(x) {
  602.       if (vtop->r & VT_SYM) {
  603.         /* relocation case */
  604.         greloc(cur_text_section, vtop->sym, ind, R_ARM_PC24);
  605.       } else
  606.         put_elf_reloc(symtab_section, cur_text_section, ind, R_ARM_PC24, 0);
  607.       o(x|(is_jmp?0xE0000000:0xE1000000));
  608.     } else {
  609.       if(!is_jmp)
  610.         o(0xE28FE004); // add lr,pc,#4
  611.       o(0xE51FF004);   // ldr pc,[pc,#-4]
  612.       if (vtop->r & VT_SYM)
  613.         greloc(cur_text_section, vtop->sym, ind, R_ARM_ABS32);
  614.       o(vtop->c.ul);
  615.     }
  616.   } else {
  617.     /* otherwise, indirect call */
  618.     r = gv(RC_INT);
  619.     if(!is_jmp)
  620.       o(0xE1A0E00F);       // mov lr,pc
  621.     o(0xE1A0F000|intr(r)); // mov pc,r
  622.   }
  623. }
  624.  
  625. /* Generate function call. The function address is pushed first, then
  626.    all the parameters in call order. This functions pops all the
  627.    parameters and the function address. */
  628. void gfunc_call(int nb_args)
  629. {
  630.   int size, align, r, args_size, i;
  631.   Sym *func_sym;
  632.   signed char plan[4][2]={{-1,-1},{-1,-1},{-1,-1},{-1,-1}};
  633.   int todo=0xf, keep, plan2[4]={0,0,0,0};
  634.  
  635.   r = vtop->r & VT_VALMASK;
  636.   if (r == VT_CMP || (r & ~1) == VT_JMP)
  637.     gv(RC_INT);
  638.   args_size = 0;
  639.   for(i = nb_args ; i-- && args_size < 16 ;) {
  640.     if ((vtop[-i].type.t & VT_BTYPE) == VT_STRUCT) {
  641.       size = type_size(&vtop[-i].type, &align);
  642.       size = (size + 3) & ~3;
  643.       args_size += size;
  644.     } else if ((vtop[-i].type.t & VT_BTYPE) == VT_FLOAT)
  645.       args_size += 4;
  646.     else if ((vtop[-i].type.t & VT_BTYPE) == VT_DOUBLE)
  647.       args_size += 8;
  648.     else if ((vtop[-i].type.t & VT_BTYPE) == VT_LDOUBLE)
  649.       args_size += LDOUBLE_SIZE;
  650.     else {
  651.       plan[nb_args-1-i][0]=args_size/4;
  652.       args_size += 4;
  653.       if ((vtop[-i].type.t & VT_BTYPE) == VT_LLONG && args_size < 16) {
  654.         plan[nb_args-1-i][1]=args_size/4;
  655.         args_size += 4;
  656.       }
  657.     }
  658.   }
  659.   args_size = keep = 0;
  660.   for(i = 0;i < nb_args; i++) {
  661.     vnrott(keep+1);
  662.     if ((vtop->type.t & VT_BTYPE) == VT_STRUCT) {
  663.       size = type_size(&vtop->type, &align);
  664.       /* align to stack align size */
  665.       size = (size + 3) & ~3;
  666.       /* allocate the necessary size on stack */
  667.       gadd_sp(-size);
  668.       /* generate structure store */
  669.       r = get_reg(RC_INT);
  670.       o(0xE1A0000D|(intr(r)<<12));
  671.       vset(&vtop->type, r | VT_LVAL, 0);
  672.       vswap();
  673.       vstore();
  674.       vtop--;
  675.       args_size += size;
  676.     } else if (is_float(vtop->type.t)) {
  677.       r=fpr(gv(RC_FLOAT))<<12;
  678.       if ((vtop->type.t & VT_BTYPE) == VT_FLOAT)
  679.         size = 4;
  680.       else if ((vtop->type.t & VT_BTYPE) == VT_DOUBLE)
  681.         size = 8;
  682.       else
  683.         size = LDOUBLE_SIZE;
  684.      
  685.       if (size == 12)
  686.         r|=0x400000;
  687.       else if(size == 8)
  688.         r|=0x8000;
  689.  
  690.       o(0xED2D0100|r|(size>>2));
  691.       vtop--;
  692.       args_size += size;
  693.     } else {
  694.       int s;
  695.       /* simple type (currently always same size) */
  696.       /* XXX: implicit cast ? */
  697.       size=4;
  698.       if ((vtop->type.t & VT_BTYPE) == VT_LLONG) {
  699.         lexpand_nr();
  700.         s=RC_INT;
  701.         if(nb_args-i<5 && plan[nb_args-i-1][1]!=-1) {
  702.           s=regmask(plan[nb_args-i-1][1]);
  703.           todo&=~(1<<plan[nb_args-i-1][1]);
  704.         }
  705.         if(s==RC_INT) {
  706.           r = gv(s);
  707.           o(0xE52D0004|(intr(r)<<12)); /* str r,[sp,#-4]! */
  708.           vtop--;
  709.         } else {
  710.           plan2[keep]=s;
  711.           keep++;
  712.           vswap();
  713.         }
  714.         size = 8;
  715.       }
  716.       s=RC_INT;
  717.       if(nb_args-i<5 && plan[nb_args-i-1][0]!=-1) {
  718.         s=regmask(plan[nb_args-i-1][0]);
  719.         todo&=~(1<<plan[nb_args-i-1][0]);
  720.       }
  721.       if(s==RC_INT) {
  722.         r = gv(s);
  723.         o(0xE52D0004|(intr(r)<<12)); /* str r,[sp,#-4]! */
  724.         vtop--;
  725.       } else {
  726.         plan2[keep]=s;
  727.         keep++;
  728.       }
  729.       args_size += size;
  730.     }
  731.   }
  732.   for(i=keep;i--;) {
  733.     gv(plan2[i]);
  734.     vrott(keep);
  735.   }
  736.   save_regs(keep); /* save used temporary registers */
  737.   keep++;
  738.   if(args_size) {
  739.     int n;
  740.     n=args_size/4;
  741.     if(n>4)
  742.       n=4;
  743.     todo&=((1<<n)-1);
  744.     if(todo) {
  745.       int i;
  746.       o(0xE8BD0000|todo);
  747.       for(i=0;i<4;i++)
  748.         if(todo&(1<<i)) {
  749.           vpushi(0);
  750.           vtop->r=i;
  751.           keep++;
  752.         }
  753.     }
  754.     args_size-=n*4;
  755.   }
  756.   vnrott(keep);
  757.   func_sym = vtop->type.ref;
  758.   gcall_or_jmp(0);
  759.   if (args_size)
  760.       gadd_sp(args_size);
  761.   vtop-=keep;
  762. }
  763.  
  764. /* generate function prolog of type 't' */
  765. void gfunc_prolog(CType *func_type)
  766. {
  767.   Sym *sym,*sym2;
  768.   int n,addr,size,align;
  769.  
  770.   sym = func_type->ref;
  771.   func_vt = sym->type;
  772.  
  773.   n=0;
  774.   addr=12;
  775.   if((func_vt.t & VT_BTYPE) == VT_STRUCT) {
  776.     func_vc = addr;
  777.     addr += 4;
  778.     n++;
  779.   }
  780.   for(sym2=sym->next;sym2 && n<4;sym2=sym2->next) {
  781.     size = type_size(&sym2->type, &align);
  782.     size = (size + 3) & ~3;
  783.     n+=size/4;
  784.   }
  785.   o(0xE1A0C00D); /* mov ip,sp */
  786.   if(func_type->ref->c == FUNC_ELLIPSIS)
  787.     n=4;
  788.   if(n) {
  789.     if(n>4)
  790.       n=4;
  791.     o(0xE92D0000|((1<<n)-1)); /* save r0-r4 on stack if needed */
  792.   }
  793.   o(0xE92D5800); /* save fp, ip, lr*/
  794.   o(0xE1A0B00D); /* mov fp,sp */
  795.   func_sub_sp_offset = ind;
  796.   o(0xE1A00000); /* nop, leave space for stack adjustment */
  797.   while ((sym = sym->next)) {
  798.     CType *type;
  799.     type = &sym->type;
  800.     sym_push(sym->v & ~SYM_FIELD, type, VT_LOCAL | VT_LVAL, addr);
  801.     size = type_size(type, &align);
  802.     size = (size + 3) & ~3;
  803.     addr += size;
  804.   }
  805.   last_itod_magic=0;
  806.   loc = 0;
  807. }
  808.  
  809. /* generate function epilog */
  810. void gfunc_epilog(void)
  811. {
  812.   unsigned long x;
  813.   o(0xE89BA800); /* restore fp, sp, pc */
  814.   if(loc) {
  815.     x=stuff_const(0xE24DD000, (-loc + 3) & -4); /* sub sp,sp,# */
  816.     if(x)
  817.       *(unsigned long *)(cur_text_section->data + func_sub_sp_offset) = x;
  818.     else {
  819.       unsigned long addr;
  820.       addr=ind;
  821.       o(0xE59FC004); /* ldr ip,[pc+4] */
  822.       o(0xE04DD00C); /* sub sp,sp,ip  */
  823.       o(0xE1A0F00E); /* mov pc,lr */
  824.       o((-loc + 3) & -4);
  825.       *(unsigned long *)(cur_text_section->data + func_sub_sp_offset) = 0xE1000000|encbranch(func_sub_sp_offset,addr,1);
  826.     }
  827.   }
  828. }
  829.  
  830. /* generate a jump to a label */
  831. int gjmp(int t)
  832. {
  833.   int r;
  834.   r=ind;
  835.   o(0xE0000000|encbranch(r,t,1));
  836.   return r;
  837. }
  838.  
  839. /* generate a jump to a fixed address */
  840. void gjmp_addr(int a)
  841. {
  842.   gjmp(a);
  843. }
  844.  
  845. /* generate a test. set 'inv' to invert test. Stack entry is popped */
  846. int gtst(int inv, int t)
  847. {
  848.   int v, r;
  849.   unsigned long op;
  850.   v = vtop->r & VT_VALMASK;
  851.   r=ind;
  852.   if (v == VT_CMP) {
  853.     op=mapcc(inv?negcc(vtop->c.i):vtop->c.i);
  854.     op|=encbranch(r,t,1);
  855.     o(op);
  856.     t=r;
  857.   } else if (v == VT_JMP || v == VT_JMPI) {
  858.     if ((v & 1) == inv) {
  859.       if(!vtop->c.i)
  860.         vtop->c.i=t;
  861.       else {
  862.         unsigned long *x;
  863.         int p,lp;
  864.         if(t) {
  865.           p = vtop->c.i;
  866.           do {
  867.             p = decbranch(lp=p);
  868.           } while(p);
  869.           x = (unsigned long *)(cur_text_section->data + lp);
  870.           *x &= 0xff000000;
  871.           *x |= encbranch(lp,t,1);
  872.         }
  873.         t = vtop->c.i;
  874.       }
  875.     } else {
  876.       t = gjmp(t);
  877.       gsym(vtop->c.i);
  878.     }
  879.   } else {
  880.     if (is_float(vtop->type.t)) {
  881.       r=gv(RC_FLOAT);
  882.       o(0xEE90F118|fpr(r)<<16);
  883.       vtop->r = VT_CMP;
  884.       vtop->c.i = TOK_NE;
  885.       return gtst(inv, t);
  886.     } else if ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST) {
  887.       /* constant jmp optimization */
  888.       if ((vtop->c.i != 0) != inv)
  889.         t = gjmp(t);
  890.     } else {
  891.       v = gv(RC_INT);
  892.       o(0xE3300000|(intr(v)<<16));
  893.       vtop->r = VT_CMP;
  894.       vtop->c.i = TOK_NE;
  895.       return gtst(inv, t);
  896.     }  
  897.   }
  898.   vtop--;
  899.   return t;
  900. }
  901.  
  902. /* generate an integer binary operation */
  903. void gen_opi(int op)
  904. {
  905.   int c, func = 0;
  906.   unsigned long opc = 0,r,fr;
  907.  
  908.   c=0;
  909.   switch(op) {
  910.     case '+':
  911.       opc = 0x8;
  912.       c=1;
  913.       break;
  914.     case TOK_ADDC1: /* add with carry generation */
  915.       opc = 0x9;
  916.       c=1;
  917.       break;
  918.     case '-':
  919.       opc = 0x4;
  920.       c=1;
  921.       break;
  922.     case TOK_SUBC1: /* sub with carry generation */
  923.       opc = 0x5;
  924.       c=1;
  925.       break;
  926.     case TOK_ADDC2: /* add with carry use */
  927.       opc = 0xA;
  928.       c=1;
  929.       break;
  930.     case TOK_SUBC2: /* sub with carry use */
  931.       opc = 0xC;
  932.       c=1;
  933.       break;
  934.     case '&':
  935.       opc = 0x0;
  936.       c=1;
  937.       break;
  938.     case '^':
  939.       opc = 0x2;
  940.       c=1;
  941.       break;
  942.     case '|':
  943.       opc = 0x18;
  944.       c=1;
  945.       break;
  946.     case '*':
  947.       gv2(RC_INT, RC_INT);
  948.       r = vtop[-1].r;
  949.       fr = vtop[0].r;
  950.       vtop--;
  951.       o(0xE0000090|(intr(r)<<16)|(intr(r)<<8)|intr(fr));
  952.       return;
  953.     case TOK_SHL:
  954.       opc = 0;
  955.       c=2;
  956.       break;
  957.     case TOK_SHR:
  958.       opc = 1;
  959.       c=2;
  960.       break;
  961.     case TOK_SAR:
  962.       opc = 2;
  963.       c=2;
  964.       break;
  965.     case '/':
  966.     case TOK_PDIV:
  967.       func=TOK___divsi3;
  968.       c=3;
  969.       break;
  970.     case TOK_UDIV:
  971.       func=TOK___udivsi3;
  972.       c=3;
  973.       break;
  974.     case '%':
  975.       func=TOK___modsi3;
  976.       c=3;
  977.       break;
  978.     case TOK_UMOD:
  979.       func=TOK___umodsi3;
  980.       c=3;
  981.       break;
  982.     case TOK_UMULL:
  983.       gv2(RC_INT, RC_INT);
  984.       r=intr(vtop[-1].r2=get_reg(RC_INT));
  985.       c=vtop[-1].r;
  986.       vtop[-1].r=get_reg_ex(RC_INT,regmask(c));
  987.       vtop--;
  988.       o(0xE0800090|(r<<16)|(intr(vtop->r)<<12)|(intr(c)<<8)|intr(vtop[1].r));
  989.       return;
  990.     default:
  991.       opc = 0x15;
  992.       c=1;
  993.       break;
  994.   }
  995.   switch(c) {
  996.     case 1:
  997.       if((vtop[-1].r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST) {
  998.         if(opc == 4 || opc == 5 || opc == 0xc) {
  999.           vswap();
  1000.           opc|=2; // sub -> rsb
  1001.         }
  1002.       }
  1003.       if ((vtop->r & VT_VALMASK) == VT_CMP ||
  1004.           (vtop->r & (VT_VALMASK & ~1)) == VT_JMP)
  1005.         gv(RC_INT);
  1006.       vswap();
  1007.       c=intr(gv(RC_INT));
  1008.       vswap();
  1009.       opc=0xE0000000|(opc<<20)|(c<<16);
  1010.       if((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST) {
  1011.         unsigned long x;
  1012.         x=stuff_const(opc|0x2000000,vtop->c.i);
  1013.         if(x) {
  1014.           r=intr(vtop[-1].r=get_reg_ex(RC_INT,regmask(vtop[-1].r)));
  1015.           o(x|(r<<12));
  1016.           goto done;
  1017.         }
  1018.       }
  1019.       fr=intr(gv(RC_INT));
  1020.       r=intr(vtop[-1].r=get_reg_ex(RC_INT,two2mask(vtop->r,vtop[-1].r)));
  1021.       o(opc|(r<<12)|fr);
  1022. done:
  1023.       vtop--;
  1024.       if (op >= TOK_ULT && op <= TOK_GT) {
  1025.         vtop->r = VT_CMP;
  1026.         vtop->c.i = op;
  1027.       }
  1028.       break;
  1029.     case 2:
  1030.       opc=0xE1A00000|(opc<<5);
  1031.       if ((vtop->r & VT_VALMASK) == VT_CMP ||
  1032.           (vtop->r & (VT_VALMASK & ~1)) == VT_JMP)
  1033.         gv(RC_INT);
  1034.       vswap();
  1035.       r=intr(gv(RC_INT));
  1036.       vswap();
  1037.       opc|=r;
  1038.       if ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST) {
  1039.         fr=intr(vtop[-1].r=get_reg_ex(RC_INT,regmask(vtop[-1].r)));
  1040.         c = vtop->c.i & 0x1f;
  1041.         o(opc|(c<<7)|(fr<<12));
  1042.       } else {
  1043.         fr=intr(gv(RC_INT));
  1044.         c=intr(vtop[-1].r=get_reg_ex(RC_INT,two2mask(vtop->r,vtop[-1].r)));
  1045.         o(opc|(c<<12)|(fr<<8)|0x10);
  1046.       }
  1047.       vtop--;
  1048.       break;
  1049.     case 3:
  1050.       vpush_global_sym(&func_old_type, func);
  1051.       vrott(3);
  1052.       gfunc_call(2);
  1053.       vpushi(0);
  1054.       vtop->r = REG_IRET;
  1055.       break;
  1056.     default:
  1057.       error("gen_opi %i unimplemented!",op);
  1058.   }
  1059. }
  1060.  
  1061. static int is_fconst()
  1062. {
  1063.   long double f;
  1064.   int r;
  1065.   if((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) != VT_CONST)
  1066.     return 0;
  1067.   if (vtop->type.t == VT_FLOAT)
  1068.     f = vtop->c.f;
  1069.   else if (vtop->type.t == VT_DOUBLE)
  1070.     f = vtop->c.d;
  1071.   else
  1072.     f = vtop->c.ld;
  1073.   if(!ieee_finite(f))
  1074.     return 0;
  1075.   r=0x8;
  1076.   if(f<0.0) {
  1077.     r=0x18;
  1078.     f=-f;
  1079.   }
  1080.   if(f==0.0)
  1081.     return r;
  1082.   if(f==1.0)
  1083.     return r|1;
  1084.   if(f==2.0)
  1085.     return r|2;
  1086.   if(f==3.0)
  1087.     return r|3;
  1088.   if(f==4.0)
  1089.     return r|4;
  1090.   if(f==5.0)
  1091.     return r|5;
  1092.   if(f==0.5)
  1093.     return r|6;
  1094.   if(f==10.0)
  1095.     return r|7;
  1096.   return 0;
  1097. }
  1098.  
  1099. /* generate a floating point operation 'v = t1 op t2' instruction. The
  1100.    two operands are guaranted to have the same floating point type */
  1101. void gen_opf(int op)
  1102. {
  1103.   unsigned long x;
  1104.   int r,r2,c1,c2;
  1105.   //fputs("gen_opf\n",stderr);
  1106.   vswap();
  1107.   c1 = is_fconst();
  1108.   vswap();
  1109.   c2 = is_fconst();
  1110.   x=0xEE000100;
  1111. #if LDOUBLE_SIZE == 8
  1112.   if ((vtop->type.t & VT_BTYPE) != VT_FLOAT)
  1113.     x|=0x80;
  1114. #else
  1115.   if ((vtop->type.t & VT_BTYPE) == VT_DOUBLE)
  1116.     x|=0x80;
  1117.   else if ((vtop->type.t & VT_BTYPE) == VT_LDOUBLE)
  1118.     x|=0x80000;
  1119. #endif
  1120.   switch(op)
  1121.   {
  1122.     case '+':
  1123.       if(!c2) {
  1124.         vswap();
  1125.         c2=c1;
  1126.       }
  1127.       vswap();
  1128.       r=fpr(gv(RC_FLOAT));
  1129.       vswap();
  1130.       if(c2) {
  1131.         if(c2>0xf)
  1132.           x|=0x200000; // suf
  1133.         r2=c2&0xf;
  1134.       } else {
  1135.         r2=fpr(gv(RC_FLOAT));
  1136.       }
  1137.       break;
  1138.     case '-':
  1139.       if(c2) {
  1140.         if(c2<=0xf)
  1141.           x|=0x200000; // suf
  1142.         r2=c2&0xf;
  1143.         vswap();
  1144.         r=fpr(gv(RC_FLOAT));
  1145.         vswap();
  1146.       } else if(c1 && c1<=0xf) {
  1147.         x|=0x300000; // rsf
  1148.         r2=c1;
  1149.         r=fpr(gv(RC_FLOAT));
  1150.         vswap();
  1151.       } else {
  1152.         x|=0x200000; // suf
  1153.         vswap();
  1154.         r=fpr(gv(RC_FLOAT));
  1155.         vswap();
  1156.         r2=fpr(gv(RC_FLOAT));
  1157.       }
  1158.       break;
  1159.     case '*':
  1160.       if(!c2 || c2>0xf) {
  1161.         vswap();
  1162.         c2=c1;
  1163.       }
  1164.       vswap();
  1165.       r=fpr(gv(RC_FLOAT));
  1166.       vswap();
  1167.       if(c2 && c2<=0xf)
  1168.         r2=c2;
  1169.       else
  1170.         r2=fpr(gv(RC_FLOAT));
  1171.       x|=0x100000; // muf
  1172.       break;
  1173.     case '/':
  1174.       if(c2 && c2<=0xf) {
  1175.         x|=0x400000; // dvf
  1176.         r2=c2;
  1177.         vswap();
  1178.         r=fpr(gv(RC_FLOAT));
  1179.         vswap();
  1180.       } else if(c1 && c1<=0xf) {
  1181.         x|=0x500000; // rdf
  1182.         r2=c1;
  1183.         r=fpr(gv(RC_FLOAT));
  1184.         vswap();
  1185.       } else {
  1186.         x|=0x400000; // dvf
  1187.         vswap();
  1188.         r=fpr(gv(RC_FLOAT));
  1189.         vswap();
  1190.         r2=fpr(gv(RC_FLOAT));
  1191.       }    
  1192.       break;
  1193.     default:
  1194.       if(op >= TOK_ULT && op <= TOK_GT) {
  1195.         x|=0xd0f110; // cmfe
  1196.         switch(op) {
  1197.           case TOK_ULT:
  1198.           case TOK_UGE:
  1199.           case TOK_ULE:
  1200.           case TOK_UGT:
  1201.             fputs("unsigned comparision on floats?\n",stderr);
  1202.             break;
  1203.           case TOK_LT:
  1204.             op=TOK_ULT;
  1205.             break;
  1206.           case TOK_GE:
  1207.             op=TOK_UGE;
  1208.             break;
  1209.           case TOK_LE:
  1210.             op=TOK_ULE;
  1211.             break;
  1212.           case TOK_GT:
  1213.             op=TOK_UGT;
  1214.             break;
  1215.           case TOK_EQ:
  1216.           case TOK_NE:
  1217.             x&=~0x400000; // cmfe -> cmf
  1218.             break;
  1219.         }
  1220.         if(c1 && !c2) {
  1221.           c2=c1;
  1222.           vswap();
  1223.           switch(op) {
  1224.             case TOK_ULT:
  1225.               op=TOK_UGT;
  1226.               break;
  1227.             case TOK_UGE:
  1228.               op=TOK_ULE;
  1229.               break;
  1230.             case TOK_ULE:
  1231.               op=TOK_UGE;
  1232.               break;
  1233.             case TOK_UGT:
  1234.               op=TOK_ULT;
  1235.               break;
  1236.           }
  1237.         }
  1238. // bug (intention?) in Linux FPU emulator
  1239. // doesn't set carry if equal
  1240.         if(op==TOK_ULT)
  1241.           op=TOK_LT;
  1242.         else if(op==TOK_UGE)
  1243.           op=TOK_GE;
  1244.         vswap();
  1245.         r=fpr(gv(RC_FLOAT));
  1246.         vswap();
  1247.         if(c2) {
  1248.           if(c2>0xf)
  1249.             x|=0x200000;
  1250.           r2=c2&0xf;
  1251.         } else {
  1252.           r2=fpr(gv(RC_FLOAT));
  1253.         }
  1254.         vtop[-1].r = VT_CMP;
  1255.         vtop[-1].c.i = op;
  1256.       } else {
  1257.         error("unknown fp op %x!\n",op);
  1258.         return;
  1259.       }
  1260.   }
  1261.   if(vtop[-1].r == VT_CMP)
  1262.     c1=15;
  1263.   else {
  1264.     c1=vtop->r;
  1265.     if(r2&0x8)
  1266.       c1=vtop[-1].r;
  1267.     vtop[-1].r=get_reg_ex(RC_FLOAT,two2mask(vtop[-1].r,c1));
  1268.     c1=fpr(vtop[-1].r);
  1269.   }
  1270.   vtop--;
  1271.   o(x|(r<<16)|(c1<<12)|r2);
  1272. }
  1273.  
  1274. /* convert integers to fp 't' type. Must handle 'int', 'unsigned int'
  1275.    and 'long long' cases. */
  1276. void gen_cvt_itof(int t)
  1277. {
  1278.   int r,r2,bt;
  1279.   bt=vtop->type.t & VT_BTYPE;
  1280.   if(bt == VT_INT || bt == VT_SHORT || bt == VT_BYTE) {
  1281.     r=intr(gv(RC_INT));
  1282.     r2=fpr(vtop->r=get_reg(RC_FLOAT));
  1283.     o(0xEE000190|(r2<<16)|(r<<12));
  1284.     if((vtop->type.t & (VT_UNSIGNED|VT_BTYPE)) == (VT_UNSIGNED|VT_INT)) {
  1285.       unsigned int off=0;
  1286.       o(0xE3500000|(r<<12));
  1287.       r=fpr(get_reg(RC_FLOAT));
  1288.       if(last_itod_magic) {
  1289.         off=ind+8-last_itod_magic;
  1290.         off/=4;
  1291.         if(off>255)
  1292.           off=0;
  1293.       }
  1294.       o(0xBD1F8100|(r<<12)|off);
  1295.       if(!off) {
  1296.         o(0xEA000001);
  1297.         last_itod_magic=ind;
  1298.         o(0x41F00000);
  1299.         o(0);
  1300.       }
  1301.       o(0xBE000180|(r2<<16)|(r2<<12)|r);
  1302.     }
  1303.     return;
  1304.   } else if(bt == VT_LLONG) {
  1305.     int func;
  1306.     if(vtop->type.t & VT_UNSIGNED)
  1307.       func=TOK___ulltold;
  1308.     else
  1309.       func=TOK___slltold;
  1310.     vpush_global_sym(&func_old_type, func);
  1311.     vswap();
  1312.     gfunc_call(1);
  1313.     vpushi(0);
  1314.     vtop->r=TREG_F0;
  1315.     return;
  1316.   }
  1317.   error("unimplemented gen_cvt_itof %x!",vtop->type.t);
  1318. }
  1319.  
  1320. /* convert fp to int 't' type */
  1321. void gen_cvt_ftoi(int t)
  1322. {
  1323.   int r,r2,u,func=0;
  1324.   u=t&VT_UNSIGNED;
  1325.   t&=VT_BTYPE;
  1326.   r2=vtop->type.t & VT_BTYPE;
  1327.   if(t==VT_INT) {
  1328.     if(u) {
  1329.       if(r2 == VT_FLOAT)
  1330.         func=TOK___fixunssfsi;
  1331.       else if(r2 == VT_DOUBLE)
  1332.         func=TOK___fixunsdfsi;
  1333.       else if(r2 == VT_LDOUBLE)
  1334. #if LDOUBLE_SIZE == 8
  1335.         func=TOK___fixunsdfsi;
  1336. #else
  1337.         func=TOK___fixunsxfsi;
  1338. #endif
  1339.     } else {
  1340.       r=fpr(gv(RC_FLOAT));
  1341.       r2=intr(vtop->r=get_reg(RC_INT));
  1342.       o(0xEE100170|(r2<<12)|r);
  1343.     return;
  1344.     }
  1345.   } else if(t == VT_LLONG) { // unsigned handled in gen_cvt_ftoi1
  1346.     if(r2 == VT_FLOAT)
  1347.       func=TOK___fixsfdi;
  1348.     else if(r2 == VT_DOUBLE)
  1349.       func=TOK___fixdfdi;
  1350.     else if(r2 == VT_LDOUBLE)
  1351. #if LDOUBLE_SIZE == 8
  1352.       func=TOK___fixdfdi;
  1353. #else
  1354.       func=TOK___fixxfdi;
  1355. #endif
  1356.     }
  1357.   if(func) {
  1358.     vpush_global_sym(&func_old_type, func);
  1359.     vswap();
  1360.     gfunc_call(1);
  1361.     vpushi(0);
  1362.     if(t == VT_LLONG)
  1363.       vtop->r2 = REG_LRET;
  1364.     vtop->r = REG_IRET;
  1365.     return;
  1366.   }
  1367.   error("unimplemented gen_cvt_ftoi!");
  1368. }
  1369.  
  1370. /* convert from one floating point type to another */
  1371. void gen_cvt_ftof(int t)
  1372. {
  1373.   /* all we have to do on i386 and ARM is to put the float in a register */
  1374.   gv(RC_FLOAT);
  1375. }
  1376.  
  1377. /* computed goto support */
  1378. void ggoto(void)
  1379. {
  1380.   gcall_or_jmp(1);
  1381.   vtop--;
  1382. }
  1383.  
  1384. /* end of ARM code generator */
  1385. /*************************************************************/
  1386.  
  1387.