← Back to branch summary

~ubuntu-branches/ubuntu/feisty/fpc/feisty

« back to all changes in this revision

Viewing changes to compiler/powerpc/cgcpu.pas

  • Committer: Bazaar Package Importer
  • Author(s): Torsten Werner
  • Date: 2007-01-27 20:08:50 UTC
  • mfrom: (1.2.3 upstream)
  • Revision ID: james.westby@ubuntu.com-20070127200850-9mrptaqqjsx9nwa7
Tags: 2.0.4-5
* Fixed Build-Depends.
* Add myself to Uploaders in debian/control.
* Make sure that the sources are really patched before building them.
* Build unit 'libc' on powerpc too.

Show diffs side-by-side

added added

removed removed

Lines of Context:
compiler/powerpc/cgcpu.pas
1
1
{
2
 
    $Id: cgcpu.pas,v 1.196 2005/03/25 21:55:43 jonas Exp $
3
2
    Copyright (c) 1998-2002 by Florian Klaempfl
4
3
 
5
4
    This unit implements the code generator for the PowerPC
98
97
        procedure a_jmp_cond(list : taasmoutput;cond : TOpCmp;l: tasmlabel);
99
98
 
100
99
        procedure g_intf_wrapper(list: TAAsmoutput; procdef: tprocdef; const labelname: string; ioffset: longint);override;
 
100
 
 
101
        function g_darwin_indirect_sym_load(list: taasmoutput; const symname: string): tregister;
 
102
 
101
103
      private
102
104
 
103
105
        (* NOT IN USE: *)
105
107
        (* NOT IN USE: *)
106
108
        procedure g_return_from_proc_mac(list : taasmoutput;parasize : aint);
107
109
 
 
110
        { clear out potential overflow bits from 8 or 16 bit operations  }
 
111
        { the upper 24/16 bits of a register after an operation          }
 
112
        procedure maybeadjustresult(list: taasmoutput; op: TOpCg; size: tcgsize; dst: tregister);
108
113
 
109
114
        { Make sure ref is a valid reference for the PowerPC and sets the }
110
115
        { base to the value of the index if (base = R_NO).                }
165
170
        inherited init_register_allocators;
166
171
        if target_info.system=system_powerpc_darwin then
167
172
          begin
 
173
{
168
174
            if pi_needs_got in current_procinfo.flags then
169
175
              begin
170
176
                current_procinfo.got:=NR_R31;
175
181
                   RS_R21,RS_R20,RS_R19,RS_R18,RS_R17,RS_R16,RS_R15,
176
182
                   RS_R14,RS_R13],first_int_imreg,[]);
177
183
              end
178
 
            else
 
184
            else}
179
185
              rg[R_INTREGISTER]:=trgcpu.create(R_INTREGISTER,R_SUBWHOLE,
180
186
                [RS_R2,RS_R3,RS_R4,RS_R5,RS_R6,RS_R7,RS_R8,
181
187
                 RS_R9,RS_R10,RS_R11,RS_R12,RS_R31,RS_R30,RS_R29,
353
359
        l1: tasmsymbol;
354
360
      begin
355
361
        { function declared in the current unit? }
356
 
        result := objectlibrary.getasmsymbol(s);
 
362
        { doesn't work correctly, because this will also return a hit if we }
 
363
        { previously took the address of an external procedure. It doesn't  }
 
364
        { really matter, the linker will remove all unnecessary stubs.      }
 
365
{        result := objectlibrary.getasmsymbol(s);
357
366
        if not(assigned(result)) then
358
 
          begin
 
367
          begin }
359
368
            stubname := 'L'+s+'$stub';
360
369
            result := objectlibrary.getasmsymbol(stubname);
361
 
          end;
 
370
{          end; }
362
371
        if assigned(result) then
363
372
          exit;
364
373
 
546
555
       var
547
556
         instr: taicpu;
548
557
       begin
549
 
         case tosize of
550
 
           OS_8:
551
 
             instr := taicpu.op_reg_reg_const_const_const(A_RLWINM,
552
 
               reg2,reg1,0,31-8+1,31);
553
 
           OS_S8:
554
 
             instr := taicpu.op_reg_reg(A_EXTSB,reg2,reg1);
555
 
           OS_16:
556
 
             instr := taicpu.op_reg_reg_const_const_const(A_RLWINM,
557
 
               reg2,reg1,0,31-16+1,31);
558
 
           OS_S16:
559
 
             instr := taicpu.op_reg_reg(A_EXTSH,reg2,reg1);
560
 
           OS_32,OS_S32:
561
 
             instr := taicpu.op_reg_reg(A_MR,reg2,reg1);
562
 
           else internalerror(2002090901);
563
 
         end;
 
558
         if (tcgsize2size[fromsize] > tcgsize2size[tosize]) or
 
559
            ((tcgsize2size[fromsize] = tcgsize2size[tosize]) and
 
560
             (fromsize <> tosize)) or
 
561
            { needs to mask out the sign in the top 16 bits }
 
562
            ((fromsize = OS_S8) and
 
563
             (tosize = OS_16)) then
 
564
           case tosize of
 
565
             OS_8:
 
566
               instr := taicpu.op_reg_reg_const_const_const(A_RLWINM,
 
567
                 reg2,reg1,0,31-8+1,31);
 
568
             OS_S8:
 
569
               instr := taicpu.op_reg_reg(A_EXTSB,reg2,reg1);
 
570
             OS_16:
 
571
               instr := taicpu.op_reg_reg_const_const_const(A_RLWINM,
 
572
                 reg2,reg1,0,31-16+1,31);
 
573
             OS_S16:
 
574
               instr := taicpu.op_reg_reg(A_EXTSH,reg2,reg1);
 
575
             OS_32,OS_S32:
 
576
               instr := taicpu.op_reg_reg(A_MR,reg2,reg1);
 
577
             else internalerror(2002090901);
 
578
           end
 
579
         else
 
580
           instr := taicpu.op_reg_reg(A_MR,reg2,reg1);
 
581
 
564
582
         list.concat(instr);
565
583
         rg[R_INTREGISTER].add_move_instruction(instr);
566
584
       end;
641
659
         end;
642
660
 
643
661
 
 
662
    procedure tcgppc.maybeadjustresult(list: taasmoutput; op: TOpCg; size: tcgsize; dst: tregister);
 
663
      const
 
664
        overflowops = [OP_MUL,OP_SHL,OP_ADD,OP_SUB,OP_NOT,OP_NEG];
 
665
      begin
 
666
        if (op in overflowops) and
 
667
           (size in [OS_8,OS_S8,OS_16,OS_S16]) then
 
668
          a_load_reg_reg(list,OS_32,size,dst,dst);
 
669
      end;
 
670
 
 
671
 
644
672
    procedure tcgppc.a_op_const_reg_reg(list: taasmoutput; op: TOpCg;
645
673
                       size: tcgsize; a: aint; src, dst: tregister);
646
674
      var
679
707
              begin
680
708
                case op of
681
709
                  OP_OR:
682
 
                    list.concat(taicpu.op_reg_const(A_LI,dst,-1));
 
710
                    case size of
 
711
                      OS_8, OS_S8:
 
712
                        list.concat(taicpu.op_reg_const(A_LI,dst,255));
 
713
                      OS_16, OS_S16:
 
714
                        a_load_const_reg(list,OS_16,65535,dst);
 
715
                      else
 
716
                        list.concat(taicpu.op_reg_const(A_LI,dst,-1));
 
717
                    end;
683
718
                  OP_XOR:
684
 
                    list.concat(taicpu.op_reg_reg(A_NOT,dst,src));
 
719
                    case size of
 
720
                      OS_8, OS_S8:
 
721
                        list.concat(taicpu.op_reg_reg_const(A_XORI,dst,src,255));
 
722
                      OS_16, OS_S16:
 
723
                        list.concat(taicpu.op_reg_reg_const(A_XORI,dst,src,65535));
 
724
                      else
 
725
                        list.concat(taicpu.op_reg_reg(A_NOT,dst,src));
 
726
                    end;
685
727
                  OP_AND:
686
728
                    a_load_reg_reg(list,size,size,src,dst);
687
729
                end;
691
733
               ((op <> OP_AND) or
692
734
                not gotrlwi) then
693
735
              begin
 
736
                if ((size = OS_8) and
 
737
                    (byte(a) <> a)) or
 
738
                   ((size = OS_S8) and
 
739
                    (shortint(a) <> a)) then
 
740
                  internalerror(200604142);
694
741
                list.concat(taicpu.op_reg_reg_const(oplo,dst,src,word(a)));
 
742
                { and/or/xor -> cannot overflow in high 16 bits }
695
743
                exit;
696
744
              end;
697
745
            { all basic constant instructions also have a shifted form that }
701
749
               (not(op = OP_AND) or
702
750
                not gotrlwi) then
703
751
              begin
 
752
                if (size in [OS_8,OS_S8,OS_16,OS_S16]) then
 
753
                  internalerror(200604141);
704
754
                list.concat(taicpu.op_reg_reg_const(ophi,dst,src,word(a shr 16)));
705
755
                exit;
706
756
              end;
715
765
                  (a <= high(smallint)) then
716
766
             begin
717
767
               list.concat(taicpu.op_reg_reg_const(A_ADDI,dst,src,smallint(a)));
 
768
               maybeadjustresult(list,op,size,dst);
718
769
               exit;
719
770
             end;
720
771
 
811
862
            a_load_const_reg(list,OS_32,a,scratchreg);
812
863
            a_op_reg_reg_reg(list,op,OS_32,scratchreg,src,dst);
813
864
          end;
 
865
        maybeadjustresult(list,op,size,dst);
814
866
      end;
815
867
 
816
868
 
835
887
           else
836
888
             list.concat(taicpu.op_reg_reg_reg(op_reg_reg_opcg2asmop[op],dst,src2,src1));
837
889
         end;
 
890
         maybeadjustresult(list,op,size,dst);
838
891
       end;
839
892
 
840
893
 
1094
1147
 
1095
1148
        { save link register? }
1096
1149
        if not (po_assembler in current_procinfo.procdef.procoptions) then
1097
 
          if (pi_do_call in current_procinfo.flags) then
 
1150
          if (pi_do_call in current_procinfo.flags) or
 
1151
             ([cs_lineinfo,cs_debuginfo] * aktmoduleswitches <> []) then
1098
1152
            begin
1099
1153
               { save return address... }
1100
1154
               list.concat(taicpu.op_reg(A_MFLR,NR_R0));
1175
1229
                 end;
1176
1230
               end;
1177
1231
 
1178
 
             { compute end of gpr save area }
1179
 
             a_op_const_reg(list,OP_ADD,OS_ADDR,href.offset+8,NR_R12);
1180
 
          end;
 
1232
             { compute start of gpr save area }
 
1233
             inc(href.offset,4);
 
1234
          end
 
1235
        else
 
1236
          { compute start of gpr save area }
 
1237
          reference_reset_base(href,NR_R12,-4);
1181
1238
 
1182
1239
        { save gprs and fetch GOT pointer }
1183
1240
        if usesgpr then
1191
1248
             else
1192
1249
               a_call_name(objectlibrary.newasmsymbol('_savegpr_'+tostr(ord(firstreggpr)-ord(R_14)+14),AB_EXTERNAL,AT_FUNCTION))
1193
1250
             }
1194
 
            reference_reset_base(href,NR_R12,-4);
1195
1251
            for regcounter2:=RS_R13 to RS_R31 do
1196
1252
              begin
1197
1253
                if regcounter2 in rg[R_INTREGISTER].used_in_proc then
1198
1254
                  begin
1199
1255
                     usesgpr:=true;
1200
 
                     a_load_reg_ref(list,OS_INT,OS_INT,newreg(R_INTREGISTER,regcounter2,R_SUBNONE),href);
1201
 
                     dec(href.offset,4);
 
1256
                     if (regcounter2 <= RS_R22) or
 
1257
                        ((cs_littlesize in aktglobalswitches) and
 
1258
                         { with RS_R30 it's also already smaller, but too big a speed trade-off to make }
 
1259
                         (regcounter2 <= RS_R29)) then
 
1260
                       begin
 
1261
                         dec(href.offset,(RS_R31-regcounter2)*sizeof(aint));
 
1262
                         list.concat(taicpu.op_reg_ref(A_STMW,newreg(R_INTREGISTER,regcounter2,R_SUBNONE),href));
 
1263
                         break;
 
1264
                       end
 
1265
                     else
 
1266
                       begin
 
1267
                         a_load_reg_ref(list,OS_INT,OS_INT,newreg(R_INTREGISTER,regcounter2,R_SUBNONE),href);
 
1268
                         dec(href.offset,4);
 
1269
                       end;
1202
1270
                  end;
1203
1271
              end;
1204
1272
{
1218
1286
 
1219
1287
 
1220
1288
        { if we didn't get the GOT pointer till now, we've to calculate it now }
 
1289
(*
1221
1290
        if not(gotgot) and (pi_needs_got in current_procinfo.flags) then
1222
1291
          case target_info.system of
1223
1292
            system_powerpc_darwin:
1241
1310
                list.concat(taicpu.op_reg_reg(A_MFSPR,NR_R31,NR_LR));
1242
1311
              end;
1243
1312
          end;
 
1313
*)
1244
1314
        { save the CR if necessary ( !!! always done currently ) }
1245
1315
        { still need to find out where this has to be done for SystemV
1246
1316
        a_reg_alloc(list,R_0);
1336
1406
                if regcounter2 in rg[R_INTREGISTER].used_in_proc then
1337
1407
                  begin
1338
1408
                     usesgpr:=true;
1339
 
                     a_load_ref_reg(list,OS_INT,OS_INT,href,newreg(R_INTREGISTER,regcounter2,R_SUBNONE));
1340
 
                     dec(href.offset,4);
 
1409
                     if (regcounter2 <= RS_R22) or
 
1410
                        ((cs_littlesize in aktglobalswitches) and
 
1411
                         { with RS_R30 it's also already smaller, but too big a speed trade-off to make }
 
1412
                         (regcounter2 <= RS_R29)) then
 
1413
                       begin
 
1414
                         dec(href.offset,(RS_R31-regcounter2)*sizeof(aint));
 
1415
                         list.concat(taicpu.op_reg_ref(A_LMW,newreg(R_INTREGISTER,regcounter2,R_SUBNONE),href));
 
1416
                         break;
 
1417
                       end
 
1418
                     else
 
1419
                       begin
 
1420
                         a_load_ref_reg(list,OS_INT,OS_INT,href,newreg(R_INTREGISTER,regcounter2,R_SUBNONE));
 
1421
                         dec(href.offset,4);
 
1422
                       end;
1341
1423
                  end;
1342
1424
              end;
1343
1425
 
1580
1662
     const
1581
1663
         macosLinkageAreaSize = 24;
1582
1664
 
1583
 
     var 
 
1665
     var
1584
1666
         href : treference;
1585
1667
         registerSaveAreaSize : longint;
1586
1668
 
1776
1858
           { occurs, so now only ref.offset has to be loaded                         }
1777
1859
           else
1778
1860
             a_load_const_reg(list,OS_32,ref2.offset,r)
1779
 
         else if ref.index <> NR_NO Then
 
1861
         else if ref2.index <> NR_NO Then
1780
1862
           list.concat(taicpu.op_reg_reg_reg(A_ADD,r,ref2.base,ref2.index))
1781
1863
         else if (ref2.base <> NR_NO) and
1782
1864
                 (r <> ref2.base) then
1803
1885
        lab: tasmlabel;
1804
1886
        count, count2: aint;
1805
1887
        size: tcgsize;
 
1888
        copyreg: tregister;
1806
1889
 
1807
1890
      begin
1808
1891
{$ifdef extdebug}
1821
1904
              end
1822
1905
            else
1823
1906
              begin
1824
 
                a_reg_alloc(list,NR_F0);
1825
 
                a_loadfpu_ref_reg(list,OS_F64,source,NR_F0);
1826
 
                a_loadfpu_reg_ref(list,OS_F64,NR_F0,dest);
1827
 
                a_reg_dealloc(list,NR_F0);
 
1907
                copyreg := getfpuregister(list,OS_F64);
 
1908
                a_loadfpu_ref_reg(list,OS_F64,source,copyreg);
 
1909
                a_loadfpu_reg_ref(list,OS_F64,copyreg,dest);
1828
1910
              end;
1829
1911
            exit;
1830
1912
          end;
1874
1956
            list.concat(taicpu.op_reg_reg_const(A_SUBI,dst.base,dst.base,8));
1875
1957
            countreg := rg[R_INTREGISTER].getregister(list,R_SUBWHOLE);
1876
1958
            a_load_const_reg(list,OS_32,count,countreg);
1877
 
            { explicitely allocate R_0 since it can be used safely here }
1878
 
            { (for holding date that's being copied)                    }
1879
 
            a_reg_alloc(list,NR_F0);
 
1959
            copyreg := getfpuregister(list,OS_F64);
 
1960
            a_reg_sync(list,copyreg);
1880
1961
            objectlibrary.getlabel(lab);
1881
1962
            a_label(list, lab);
1882
1963
            list.concat(taicpu.op_reg_reg_const(A_SUBIC_,countreg,countreg,1));
1883
 
            list.concat(taicpu.op_reg_ref(A_LFDU,NR_F0,src));
1884
 
            list.concat(taicpu.op_reg_ref(A_STFDU,NR_F0,dst));
 
1964
            list.concat(taicpu.op_reg_ref(A_LFDU,copyreg,src));
 
1965
            list.concat(taicpu.op_reg_ref(A_STFDU,copyreg,dst));
1885
1966
            a_jmp(list,A_BC,C_NE,0,lab);
1886
 
            a_reg_dealloc(list,NR_F0);
 
1967
            a_reg_sync(list,copyreg);
1887
1968
            len := len mod 8;
1888
1969
          end;
1889
1970
 
1891
1972
        if count > 0 then
1892
1973
          { unrolled loop }
1893
1974
          begin
1894
 
            a_reg_alloc(list,NR_F0);
 
1975
            copyreg := getfpuregister(list,OS_F64);
1895
1976
            for count2 := 1 to count do
1896
1977
              begin
1897
 
                a_loadfpu_ref_reg(list,OS_F64,src,NR_F0);
1898
 
                a_loadfpu_reg_ref(list,OS_F64,NR_F0,dst);
 
1978
                a_loadfpu_ref_reg(list,OS_F64,src,copyreg);
 
1979
                a_loadfpu_reg_ref(list,OS_F64,copyreg,dst);
1899
1980
                inc(src.offset,8);
1900
1981
                inc(dst.offset,8);
1901
1982
              end;
1902
 
            a_reg_dealloc(list,NR_F0);
1903
1983
            len := len mod 8;
1904
1984
          end;
1905
1985
 
1985
2065
         if not ((def.deftype=pointerdef) or
1986
2066
                ((def.deftype=orddef) and
1987
2067
                 (torddef(def).typ in [u64bit,u16bit,u32bit,u8bit,uchar,
1988
 
                                                  bool8bit,bool16bit,bool32bit]))) then
 
2068
                                                  bool8bit,bool16bit,bool32bit,bool64bit]))) then
1989
2069
           begin
1990
2070
             list.concat(taicpu.op_reg(A_MCRXR,NR_CR7));
1991
2071
             a_jmp(list,A_BC,C_NO,7,hl)
2030
2110
      var
2031
2111
        make_global : boolean;
2032
2112
      begin
2033
 
        if procdef.proctypeoption<>potype_none then
 
2113
        if not(procdef.proctypeoption in [potype_function,potype_procedure]) then
2034
2114
          Internalerror(200006137);
2035
2115
        if not assigned(procdef._class) or
2036
2116
           (procdef.procoptions*[po_classmethod, po_staticmethod,
2061
2141
          end
2062
2142
        { case 0 }
2063
2143
        else
2064
 
          list.concat(taicpu.op_sym(A_B,objectlibrary.newasmsymbol(procdef.mangledname,AB_EXTERNAL,AT_FUNCTION)));
2065
 
 
 
2144
          if not(target_info.system = system_powerpc_darwin) then
 
2145
            list.concat(taicpu.op_sym(A_B,objectlibrary.newasmsymbol(procdef.mangledname,AB_EXTERNAL,AT_FUNCTION)))
 
2146
          else
 
2147
            list.concat(taicpu.op_sym(A_B,get_darwin_call_stub(procdef.mangledname)));
2066
2148
        List.concat(Tai_symbol_end.Createname(labelname));
2067
2149
      end;
2068
2150
 
2085
2167
      end;
2086
2168
 
2087
2169
 
 
2170
     function tcgppc.g_darwin_indirect_sym_load(list: taasmoutput; const symname: string): tregister;
 
2171
        var
 
2172
          l: tasmsymbol;
 
2173
          ref: treference;
 
2174
        begin
 
2175
          l:=objectlibrary.getasmsymbol('L'+symname+'$non_lazy_ptr');
 
2176
          if not(assigned(l)) then
 
2177
            begin
 
2178
              l:=objectlibrary.newasmsymbol('L'+symname+'$non_lazy_ptr',AB_COMMON,AT_DATA);
 
2179
              picdata.concat(tai_symbol.create(l,0));
 
2180
              picdata.concat(tai_const.create_indirect_sym(objectlibrary.newasmsymbol(symname,AB_EXTERNAL,AT_DATA)));
 
2181
              picdata.concat(tai_const.create_32bit(0));
 
2182
            end;
 
2183
          reference_reset_symbol(ref,l,0);
 
2184
{         ref.base:=current_procinfo.got;
 
2185
          ref.relsymbol:=current_procinfo.gotlabel;}
 
2186
          result := cg.getaddressregister(exprasmlist);
 
2187
          cg.a_load_ref_reg(list,OS_ADDR,OS_ADDR,ref,result);
 
2188
        end;
 
2189
 
2088
2190
    function tcgppc.fixref(list: taasmoutput; var ref: treference): boolean;
2089
2191
 
2090
2192
       var
2091
2193
         tmpreg: tregister;
2092
2194
       begin
2093
2195
         result := false;
 
2196
 
 
2197
         if (target_info.system = system_powerpc_darwin) and
 
2198
            assigned(ref.symbol) and
 
2199
            (ref.symbol.defbind = AB_EXTERNAL) then
 
2200
           begin
 
2201
             tmpreg := g_darwin_indirect_sym_load(list,ref.symbol.name);
 
2202
             if (ref.base = NR_NO) then
 
2203
               ref.base := tmpreg
 
2204
             else if (ref.index = NR_NO) then
 
2205
               ref.index := tmpreg
 
2206
             else
 
2207
               begin
 
2208
                 list.concat(taicpu.op_reg_reg_reg(A_ADD,tmpreg,ref.base,tmpreg));
 
2209
                 ref.base := tmpreg;
 
2210
               end;
 
2211
             ref.symbol := nil;
 
2212
           end;
 
2213
 
2094
2214
         if (ref.base = NR_NO) then
2095
2215
           begin
2096
2216
             ref.base := ref.index;
2097
 
             ref.base := NR_NO;
 
2217
             ref.index := NR_NO;
2098
2218
           end;
2099
2219
         if (ref.base <> NR_NO) then
2100
2220
           begin
2283
2403
        p: taicpu;
2284
2404
 
2285
2405
      begin
2286
 
        p := taicpu.op_sym(op,objectlibrary.newasmsymbol(l.name,AB_EXTERNAL,AT_FUNCTION));
 
2406
        p := taicpu.op_sym(op,l);
2287
2407
        if op <> A_B then
2288
2408
          create_cond_norm(c,crval,p.condition);
2289
2409
        p.is_jmp := true;
2399
2519
  cg := tcgppc.create;
2400
2520
  cg64 :=tcg64fppc.create;
2401
2521
end.
2402
 
{
2403
 
  $Log: cgcpu.pas,v $
2404
 
  Revision 1.196  2005/03/25 21:55:43  jonas
2405
 
    * removed some unused variables
2406
 
 
2407
 
  Revision 1.195  2005/02/14 17:13:10  peter
2408
 
    * truncate log
2409
 
 
2410
 
  Revision 1.194  2005/02/13 18:55:19  florian
2411
 
    + overflow checking for the arm
2412
 
 
2413
 
  Revision 1.193  2005/01/24 22:08:32  peter
2414
 
    * interface wrapper generation moved to cgobj
2415
 
    * generate interface wrappers after the module is parsed
2416
 
 
2417
 
  Revision 1.192  2005/01/13 22:02:40  jonas
2418
 
    * r2 can be used by the register allocator under Darwin
2419
 
    * merged the initialisations of the fpu register allocator for AIX and
2420
 
      SYSV
2421
 
 
2422
 
  Revision 1.191  2005/01/10 21:50:05  jonas
2423
 
    + support for passing records in registers under darwin
2424
 
    * tcgpara now also has an intsize field, which contains the size in
2425
 
      bytes of the whole parameter
2426
 
 
2427
 
  Revision 1.190  2005/01/05 19:01:53  karoly
2428
 
    * sysv abi also uses F0-F13 as volatile registers
2429
 
 
2430
 
}