Changeset 3814


Ignore:
Timestamp:
Apr 11, 2014, 2:11:50 AM (4 years ago)
Author:
ksherdy
Message:

Odds and ends.

Location:
proto/s2k/trunk/framework
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • proto/s2k/trunk/framework/output/cpplang/grep/grep.hpp

    r3799 r3814  
    5656        IDISA_INLINE void do_block(struct Basis_bits & basis_bits, struct Lex & lex)
    5757        {
     58                BitBlock temp0;
     59                temp0 = simd<1>::constant<1>();
    5860                BitBlock temp1;
    5961                temp1 = simd_andc(basis_bits.bit_1,basis_bits.bit_0);
     
    105107        IDISA_INLINE void do_final_block(struct Basis_bits & basis_bits, struct Lex & lex, BitBlock & EOF_mask)
    106108        {
     109                BitBlock temp0;
     110                temp0 = simd<1>::constant<1>();
    107111                BitBlock temp1;
    108112                temp1 = simd_andc(basis_bits.bit_1,basis_bits.bit_0);
  • proto/s2k/trunk/framework/output/cpplang/idisa/idisa.hpp

    r3799 r3814  
    3232        IDISA_INLINE void do_block()
    3333        {
    34                 BitBlock a;
    35                 BitBlock b;
    36                 BitBlock c;
    37                 BitBlock k;
     34                BitBlock arg1;
     35                BitBlock arg2;
     36                BitBlock arg3;
     37                BitBlock shift_mask;
    3838                BitBlock r;
    39                 a = simd<2>::constant<1>();
    40                 print_register<BitBlock>("a", a);
    41                 b = simd<2>::constant<0>();
    42                 print_register<BitBlock>("b", b);
    43                 r = simd<1>::add(a,b);
    44                 print_register<BitBlock>("r", r);
    45                 r = simd<2>::sub(a,b);
    46                 print_register<BitBlock>("r", r);
    47                 r = simd<4>::mult(a,b);
    48                 print_register<BitBlock>("r", r);
    49                 r = simd<8>::eq(a,b);
    50                 print_register<BitBlock>("r", r);
    51                 r = simd<16>::gt(a,b);
    52                 print_register<BitBlock>("r", r);
    53                 r = simd<32>::ugt(a,b);
    54                 print_register<BitBlock>("r", r);
    55                 r = simd<4>::lt(a,b);
     39                int f;
     40                int val1;
     41                int val2;
     42                int val3;
     43                int val4;
     44                int val5;
     45                int val6;
     46                int val7;
     47                int val8;
     48                int val9;
     49                int val10;
     50                int val11;
     51                int val12;
     52                int val13;
     53                int val14;
     54                int val15;
     55                int val16;
     56                int shuffle_mask;
     57                int sh;
     58                arg1 = simd<64>::constant<1>();
     59                print_register<BitBlock>("arg1", arg1);
     60                arg2 = simd<128>::constant<0>();
     61                print_register<BitBlock>("arg2", arg2);
     62                arg3 = simd<128>::constant<0>();
     63                print_register<BitBlock>("arg3", arg3);
     64                shift_mask = simd<128>::constant<2>();
     65                print_register<BitBlock>("shift_mask", shift_mask);
     66                simd<2>::slli<1>(arg1);
     67                simd<4>::slli<2>(arg1);
     68                simd<128>::slli<4>(arg1);
     69                simd<2>::srli<1>(arg1);
     70                simd<4>::srli<2>(arg1);
     71                simd<128>::srli<4>(arg1);
     72                simd<1>::constant<0>();
     73                simd<2>::constant<2>();
     74                simd<2>::constant<1>();
     75                simd<2>::constant<4>();
     76                simd<16>::constant<1>();
     77                simd<32>::constant<4>();
     78                simd<64>::constant<4>();
     79                simd<128>::constant<8>();
     80                r = simd_nor(arg1,arg2);
     81                print_register<BitBlock>("r", r);
     82                r = simd_not(arg1);
     83                print_register<BitBlock>("r", r);
     84                r = simd_andc(arg1,arg2);
     85                print_register<BitBlock>("r", r);
     86                r = simd_or(arg1,arg2);
     87                print_register<BitBlock>("r", r);
     88                r = simd_and(arg1,arg2);
     89                print_register<BitBlock>("r", r);
     90                r = simd_xor(arg1,arg2);
     91                print_register<BitBlock>("r", r);
     92                r = simd<1>::max(arg1,arg2);
     93                print_register<BitBlock>("r", r);
     94                r = simd<2>::max(arg1,arg2);
     95                print_register<BitBlock>("r", r);
     96                r = simd<4>::max(arg1,arg2);
     97                print_register<BitBlock>("r", r);
     98                r = simd<8>::max(arg1,arg2);
     99                print_register<BitBlock>("r", r);
     100                r = simd<16>::max(arg1,arg2);
     101                print_register<BitBlock>("r", r);
     102                r = simd<32>::max(arg1,arg2);
     103                print_register<BitBlock>("r", r);
     104                r = simd<64>::max(arg1,arg2);
     105                print_register<BitBlock>("r", r);
     106                r = simd<128>::max(arg1,arg2);
     107                print_register<BitBlock>("r", r);
     108                r = simd<1>::mult(arg1,arg2);
     109                print_register<BitBlock>("r", r);
     110                r = simd<2>::gt(arg1,arg2);
     111                print_register<BitBlock>("r", r);
     112                r = simd<4>::umult(arg1,arg2);
     113                print_register<BitBlock>("r", r);
     114                r = simd<8>::ult(arg1,arg2);
     115                print_register<BitBlock>("r", r);
     116                r = simd<8>::all(arg1);
     117                print_register<BitBlock>("r", r);
     118                r = simd<2>::add_hl(arg1);
     119                print_register<BitBlock>("r", r);
     120                r = simd<1>::ctz(arg1);
     121                print_register<BitBlock>("r", r);
     122                r = simd<128>::sll(arg1,shift_mask);
     123                print_register<BitBlock>("r", r);
     124                r = simd<2>::sub(arg1,arg2);
     125                print_register<BitBlock>("r", r);
     126                r = simd<8>::ugt(arg1,arg2);
     127                print_register<BitBlock>("r", r);
     128                r = simd<32>::xor_hl(arg1);
     129                print_register<BitBlock>("r", r);
     130                r = simd<128>::popcount(arg1);
     131                print_register<BitBlock>("r", r);
     132                r = simd<2>::any(arg1);
     133                print_register<BitBlock>("r", r);
     134                r = simd<4>::any(arg1);
     135                print_register<BitBlock>("r", r);
     136                r = simd<8>::any(arg1);
     137                print_register<BitBlock>("r", r);
     138                r = simd<16>::any(arg1);
     139                print_register<BitBlock>("r", r);
     140                r = simd<32>::any(arg1);
     141                print_register<BitBlock>("r", r);
     142                r = simd<64>::any(arg1);
     143                print_register<BitBlock>("r", r);
     144                r = simd<128>::any(arg1);
     145                print_register<BitBlock>("r", r);
     146                r = simd<128>::neg(arg1);
     147                print_register<BitBlock>("r", r);
     148                r = simd<1>::ifh(arg1,arg2,arg3);
     149                print_register<BitBlock>("r", r);
     150                r = simd<64>::vsrl(arg1,shift_mask);
     151                print_register<BitBlock>("r", r);
     152                r = simd<128>::vsrl(arg1,shift_mask);
     153                print_register<BitBlock>("r", r);
     154                r = simd<2>::add_hl(arg1);
     155                print_register<BitBlock>("r", r);
     156                r = simd<128>::add_hl(arg1);
     157                print_register<BitBlock>("r", r);
     158                r = simd<128>::srl(arg1,shift_mask);
     159                print_register<BitBlock>("r", r);
     160                r = simd<64>::vsll(arg1,shift_mask);
     161                print_register<BitBlock>("r", r);
     162                r = simd<128>::vsll(arg1,shift_mask);
     163                print_register<BitBlock>("r", r);
     164                r = simd<128>::min(arg1,arg2);
     165                print_register<BitBlock>("r", r);
     166                r = simd<128>::lomask();
     167                print_register<BitBlock>("r", r);
     168                r = simd<32>::umin(arg1,arg2);
     169                print_register<BitBlock>("r", r);
     170                r = simd<128>::umin(arg1,arg2);
     171                print_register<BitBlock>("r", r);
     172                r = simd<16>::abs(arg1);
     173                print_register<BitBlock>("r", r);
     174                r = simd<1>::eq(arg1,arg2);
     175                print_register<BitBlock>("r", r);
     176                r = simd<16>::eq(arg1,arg2);
     177                print_register<BitBlock>("r", r);
     178                r = simd<128>::eq(arg1,arg2);
     179                print_register<BitBlock>("r", r);
     180                r = simd<2>::srai<1>(arg1);
     181                print_register<BitBlock>("r", r);
     182                r = simd<16>::lt(arg1,arg2);
     183                print_register<BitBlock>("r", r);
     184                r = simd<128>::himask();
     185                print_register<BitBlock>("r", r);
     186                r = simd<1>::add(arg1,arg2);
     187                print_register<BitBlock>("r", r);
     188                r = simd<128>::umax(arg1,arg2);
     189                print_register<BitBlock>("r", r);
     190                r = hsimd<128>::umin_hl(arg1,arg2);
     191                print_register<BitBlock>("r", r);
     192                r = hsimd<2>::add_hl(arg1,arg2);
     193                print_register<BitBlock>("r", r);
     194                r = hsimd<128>::add_hl(arg1,arg2);
     195                print_register<BitBlock>("r", r);
     196                r = hsimd<2>::packss(arg1,arg2);
     197                print_register<BitBlock>("r", r);
     198                r = hsimd<128>::packss(arg1,arg2);
     199                print_register<BitBlock>("r", r);
     200                r = hsimd<2>::packl(arg1,arg2);
     201                print_register<BitBlock>("r", r);
     202                r = hsimd<128>::packl(arg1,arg2);
     203                print_register<BitBlock>("r", r);
     204                r = hsimd<64>::packh(arg1,arg2);
     205                print_register<BitBlock>("r", r);
     206                r = hsimd<2>::min_hl(arg1,arg2);
     207                print_register<BitBlock>("r", r);
     208                r = hsimd<128>::packus(arg1,arg2);
     209                print_register<BitBlock>("r", r);
     210                r = esimd<16>::mergel(arg1,arg2);
     211                print_register<BitBlock>("r", r);
     212                r = esimd<64>::mergeh(arg1,arg2);
     213                print_register<BitBlock>("r", r);
     214                r = esimd<64>::zeroextendh(arg1);
     215                print_register<BitBlock>("r", r);
     216                r = esimd<1>::zeroextendl(arg1);
     217                print_register<BitBlock>("r", r);
     218                r = esimd<1>::signextendh(arg1);
     219                print_register<BitBlock>("r", r);
     220                r = esimd<1>::signextendl(arg1);
     221                print_register<BitBlock>("r", r);
     222                r = esimd<64>::signextendl(arg1);
     223                print_register<BitBlock>("r", r);
     224                r = mvmd<16>::shufflei<2>(arg1);
     225                print_register<BitBlock>("r", r);
     226                r = mvmd<32>::shufflei<4>(arg1);
     227                print_register<BitBlock>("r", r);
     228                r = mvmd<64>::shufflei<2>(arg1);
     229                print_register<BitBlock>("r", r);
     230                r = mvmd<2>::dsrli<1>(arg1,arg2);
     231                print_register<BitBlock>("r", r);
     232                r = mvmd<16>::dsrli<2>(arg1,arg2);
     233                print_register<BitBlock>("r", r);
     234                r = mvmd<1>::fill16(val1,val2,val3,val4,val5,val6,val7,val8,val9,val10,val11,val12,val13,val14,val15,val16);
     235                print_register<BitBlock>("r", r);
     236                r = mvmd<2>::fill16(val1,val2,val3,val4,val5,val6,val7,val8,val9,val10,val11,val12,val13,val14,val15,val16);
     237                print_register<BitBlock>("r", r);
     238                r = mvmd<4>::fill16(val1,val2,val3,val4,val5,val6,val7,val8,val9,val10,val11,val12,val13,val14,val15,val16);
     239                print_register<BitBlock>("r", r);
     240                r = mvmd<8>::fill16(val1,val2,val3,val4,val5,val6,val7,val8,val9,val10,val11,val12,val13,val14,val15,val16);
     241                print_register<BitBlock>("r", r);
     242                r = mvmd<8>::fill(val1);
     243                print_register<BitBlock>("r", r);
     244                r = mvmd<16>::fill(val1);
     245                print_register<BitBlock>("r", r);
     246                r = mvmd<64>::splat<1>(arg1);
     247                print_register<BitBlock>("r", r);
     248                r = mvmd<128>::splat<0>(arg1);
     249                print_register<BitBlock>("r", r);
     250                r = mvmd<2>::insert<0>(arg1,val1);
     251                print_register<BitBlock>("r", r);
     252                r = mvmd<4>::insert<1>(arg1,val1);
     253                print_register<BitBlock>("r", r);
     254                r = mvmd<16>::fill4(val1,val2,val3,val4);
     255                print_register<BitBlock>("r", r);
     256                r = mvmd<32>::fill4(val1,val2,val3,val4);
     257                print_register<BitBlock>("r", r);
     258                r = mvmd<64>::srli<1>(arg1);
     259                print_register<BitBlock>("r", r);
     260                r = mvmd<128>::srli<2>(arg1);
     261                print_register<BitBlock>("r", r);
     262                r = mvmd<4>::fill2(val1,val2);
     263                print_register<BitBlock>("r", r);
     264                r = mvmd<8>::fill2(val1,val2);
     265                print_register<BitBlock>("r", r);
     266                r = mvmd<2>::dslli<1>(arg1,arg2);
     267                print_register<BitBlock>("r", r);
     268                r = mvmd<4>::dslli<4>(arg1,arg2);
     269                print_register<BitBlock>("r", r);
     270                r = mvmd<2>::dsrli<1>(arg1,arg2);
     271                print_register<BitBlock>("r", r);
     272                r = mvmd<4>::dsrli<4>(arg1,arg2);
     273                print_register<BitBlock>("r", r);
     274                r = mvmd<64>::slli<1>(arg1);
     275                print_register<BitBlock>("r", r);
     276                r = mvmd<128>::slli<2>(arg1);
     277                print_register<BitBlock>("r", r);
     278                r = mvmd<4>::fill8(val1,val2,val3,val4,val5,val6,val7,val8);
     279                print_register<BitBlock>("r", r);
     280                r = mvmd<8>::fill8(val1,val2,val3,val4,val5,val6,val7,val8);
    56281                print_register<BitBlock>("r", r);
    57282        }
  • proto/s2k/trunk/framework/src/application/generators/ApplicationGenerator.java

    r3788 r3814  
    4040               
    4141                // Transformation configurations to support multiple backends
    42                 toolchain.s2k.lang.BuiltinEncoder s2kBuiltinsEncoder  = null;
     42                toolchain.s2k.lang.S2KBuiltinEncoder s2kBuiltinsEncoder  = null;
    4343                toolchain.b2k.lang.AbstractBuiltinEncoder b2kBuiltinsEncoder  = null;
    4444                AbstractCodeGenerator globalDefsGenerator                                                                       = null;
  • proto/s2k/trunk/framework/src/test/s2k/TestHarness.java

    r3700 r3814  
    2525import test.helpers.AssertNodePairComparator;
    2626import toolchain.s2k.lang.S2KBuiltin2CPP;
    27 import toolchain.s2k.lang.BuiltinEncoder;
     27import toolchain.s2k.lang.S2KBuiltinEncoder;
    2828import toolchain.s2k.lang.carrySet.CarrySetBuiltin2CPP;
    2929import toolchain.s2k.lang.carrySet.CarrySetEncoder;
Note: See TracChangeset for help on using the changeset viewer.