Changeset 3807


Ignore:
Timestamp:
Apr 11, 2014, 1:38:23 AM (3 years ago)
Author:
ksherdy
Message:

Added 'flow' package to calls.

Location:
proto/s2k/trunk/framework/input/test
Files:
3 added
2 edited

Legend:

Unmodified
Added
Removed
  • proto/s2k/trunk/framework/input/test/b2k/statements/idisaFuncCall/idisa.b2k

    r3799 r3807  
    55    init
    66    {
    7         look_ahead = [0];
     7        look_ahead  = [0];
    88        look_behind = [0];
    9         carry_init = [0,0,1,1];
     9        carry_init  = [0,0,1,1];
    1010    }
    1111
     
    1313    {
    1414   
    15         BitBlock a;
    16         BitBlock b;
    17         BitBlock c;
    18         BitBlock k;
     15        BitBlock arg1;
     16        BitBlock arg2;
     17        BitBlock arg3;
     18        BitBlock shift_mask;           
    1919        BitBlock r;
    20 
    21         /*
    22         r = bitblock.any<128>(a);
    23         */
    24        
     20        int f;                          // field_type
     21       
     22        int val1;               // FieldType
     23        int val2;               // FieldType
     24        int val3;               // FieldType
     25        int val4;               // FieldType
     26       
     27        int val5;               // FieldType
     28        int val6;               // FieldType
     29        int val7;               // FieldType
     30        int val8;               // FieldType
     31       
     32        int val9;               // FieldType
     33        int val10;               // FieldType
     34        int val11;               // FieldType
     35        int val12;               // FieldType
     36       
     37        int val13;               // FieldType
     38        int val14;               // FieldType
     39        int val15;               // FieldType
     40        int val16;               // FieldType
     41       
     42        int shuffle_mask;               // uint64_t
     43        int sh;                 // uint16_t shift constant (immediate)
     44
     45                // KH:  We translates but we do not check for builtin signature conflicts.
     46                //      If a field width is specified it is ignored in translation.
     47                //      TODO - fix to limit field width to 1 only.
     48               
     49                // SIMD (opPatterns == 1)
     50                // C++: class_name<fw>::op<x>(data_type arg, ...)
     51                // C:   class_name_op_fw(data_type arg, ..., x)
     52                arg1 = simd.constant<64>(1);
     53                arg2 = simd.constant<128>(0);
     54                arg3 = simd.constant<128>(0);
     55                shift_mask = simd.constant<128>(2);
     56               
     57                // 2 .. BITBLOCK_SIZE
     58                simd.slli<2>(1,arg1);
     59                simd.slli<4>(2,arg1);
     60                simd.slli<128>(4, arg1);
     61                simd.srli<2>(1,arg1);
     62                simd.srli<4>(2,arg1);
     63                simd.srli<128>(4,arg1);
     64               
     65                // FieldType<C> immediate constant
     66                simd.constant<1>(0);
     67                simd.constant<2>(2);
     68                simd.constant<2>(1);
     69                simd.constant<2>(4);
     70                simd.constant<16>(1);
     71                simd.constant<32>(4);
     72                simd.constant<64>(4);
     73                simd.constant<128>(8);
     74               
     75                // SIMD logic operations (opPattern == 2)
     76                // C++: simd_op(data_type arg, ...)
     77                // C:   simd_op(data_type arg, ...)
     78                r = simd.nor<1>(arg1, arg2);
     79                r = simd.not<1>(arg1);
     80                r = simd.andc<1>(arg1, arg2);
     81                r = simd.or<1>(arg1, arg2);
     82                r = simd.and<1>(arg1, arg2);
     83                r = simd.xor<1>(arg1, arg2);
     84
     85                // SIMD operations             
     86                r = simd.max<1>(arg1, arg2);
     87                r = simd.max<2>(arg1, arg2);
     88                r = simd.max<4>(arg1, arg2);
     89                r = simd.max<8>(arg1, arg2);
     90                r = simd.max<16>(arg1, arg2);
     91                r = simd.max<32>(arg1, arg2);
     92                r = simd.max<64>(arg1, arg2);
     93                r = simd.max<128>(arg1, arg2);
     94                r = simd.mult<1>(arg1, arg2);
     95                r = simd.gt<2>(arg1, arg2);
     96                r = simd.umult<4>(arg1, arg2);
     97                r = simd.ult<8>(arg1, arg2);
     98                r = simd.all<8>(arg1);
     99               
     100                // 2 .. BITBLOCK_SIZE
     101                r = simd.add_hl<2>(arg1);
     102                r = simd.ctz<1>(arg1);
     103                r = simd.sll<128>(arg1, shift_mask);
     104                r = simd.sub<2>(arg1, arg2);
     105                r = simd.ugt<8>(arg1, arg2);
     106                r = simd.xor_hl<32>(arg1);
     107                r = simd.popcount<128>(arg1);
     108                r = simd.any<2>(arg1);
     109                r = simd.any<4>(arg1);
     110                r = simd.any<8>(arg1);
     111                r = simd.any<16>(arg1);
     112                r = simd.any<32>(arg1);
     113                r = simd.any<64>(arg1);
     114                r = simd.any<128>(arg1);
     115                r = simd.neg<128>(arg1);
     116                r = simd.ifh<1>(arg1, arg2, arg3);
     117                r = simd.vsrl<64>(arg1, shift_mask);
     118                r = simd.vsrl<128>(arg1, shift_mask);
     119                r = simd.add_hl<2>(arg1);
     120                r = simd.add_hl<128>(arg1);
     121                r = simd.srl<128>(arg1, shift_mask);
     122                r = simd.vsll<64>(arg1, shift_mask);
     123                r = simd.vsll<128>(arg1, shift_mask);
     124                r = simd.min<128>(arg1, arg2);
     125                r = simd.lomask<128>();
     126                r = simd.umin<32>(arg1, arg2);
     127                r = simd.umin<128>(arg1, arg2);
     128                r = simd.abs<16>(arg1);
     129                r = simd.eq<1>(arg1, arg2);
     130                r = simd.eq<16>(arg1, arg2);
     131                r = simd.eq<128>(arg1, arg2);           
     132                r = simd.srai<2>(1,arg1);
     133                r = simd.lt<16>(arg1, arg2);
     134                r = simd.himask<128>();
     135                r = simd.add<1>(arg1, arg2);
     136                r = simd.umax<128>(arg1, arg2);
     137
     138                r = hsimd.umin_hl<128>(arg1, arg2);
     139                r = hsimd.add_hl<2>(arg1, arg2);
     140                r = hsimd.add_hl<128>(arg1, arg2);
     141                r = hsimd.packss<2>(arg1, arg2);
     142                r = hsimd.packss<128>(arg1, arg2);
     143
     144                // FieldType<T> as return type
    25145                /*
    26                 r = simd.add(abs);
    27                 r = simd.neg(a);
    28                 r = simd.add_hl(a);
    29                 r = simd.xor_hl(a);
    30                 r = simd.slli(k);
    31                 r = simd.srli(k);
    32                 r = simd.srai(k);
    33                 r = simd.popcount(a);
    34                 r = simd.ctz(a);
    35                 r = simd.not<1>(a);             
    36                 r = simd.ifh<16>(a, b, c);
    37                 r = hsimd.add_hl<2>(a);                 
    38         r = simd.add(abs);
    39         */
    40                
     146                f = hsimd.signmask<4>(arg1);
     147                r = hsimd.signmask<8>(arg1);
     148                r = hsimd.signmask<16>(arg1);
     149                r = hsimd.signmask<32>(arg1);
     150                r = hsimd.signmask<64>(arg1);
     151                r = hsimd.signmask<128>(arg1);
     152                */
     153
     154                r = hsimd.packl<2>(arg1, arg2);
     155                r = hsimd.packl<128>(arg1, arg2);
     156                r = hsimd.packh<64>(arg1, arg2);
     157                r = hsimd.min_hl<2>(arg1, arg2);
     158                r = hsimd.packus<128>(arg1, arg2);
     159                r = esimd.mergel<16>(arg1, arg2);
     160                r = esimd.mergeh<64>(arg1, arg2);
     161                r = esimd.zeroextendh<64>(arg1);
     162                r = esimd.zeroextendl<1>(arg1);
     163                r = esimd.signextendh<1>(arg1);
     164                r = esimd.signextendl<1>(arg1);
     165                r = esimd.signextendl<64>(arg1);
     166
     167                r = mvmd.shufflei<16>(2,arg1);
     168                r = mvmd.shufflei<32>(4,arg1);
     169                r = mvmd.shufflei<64>(2,arg1);
     170
     171                r = mvmd.dsrli<2>(1, arg1, arg2);
     172                r = mvmd.dsrli<16>(2, arg1, arg2);
     173
     174                r = mvmd.fill16<1>(val1, val2, val3, val4, val5, val6, val7, val8, val9, val10, val11, val12, val13, val14, val15, val16);
     175                r = mvmd.fill16<2>(val1, val2, val3, val4, val5, val6, val7, val8, val9, val10, val11, val12, val13, val14, val15, val16);
     176                r = mvmd.fill16<4>(val1, val2, val3, val4, val5, val6, val7, val8, val9, val10, val11, val12, val13, val14, val15, val16);
     177                r = mvmd.fill16<8>(val1, val2, val3, val4, val5, val6, val7, val8, val9, val10, val11, val12, val13, val14, val15, val16);
     178
     179                r = mvmd.fill<8>(val1);
     180                r = mvmd.fill<16>(val1);
     181
    41182                /*
    42         r = simd.neg(a);
    43         r = simd.add_hl(a);
    44         r = simd.xor_hl(a);
    45         r = simd.slli(k);
    46         r = simd.srli(k);
    47         r = simd.srai(k);
    48         r = simd.popcount(a);
    49         r = simd.ctz(a);
    50         r = simd.if<128>(a,b,c);       
    51         */
    52        
    53                 a = simd.constant<2>(1);
    54                 b = simd.constant<2>(0);
    55                 r = simd.add<1>(a,b);
    56                 r = simd.sub<2>(a,b);
    57                 r = simd.mult<4>(a,b);
    58                 r = simd.eq<8>(a,b);
    59                 r = simd.gt<16>(a,b);
    60                 r = simd.ugt<32>(a,b);
    61                 r = simd.lt<4>(a,b);
    62                
     183                f = mvmd.extract<1>(1, arg1);
     184                f = mvmd.extract<4>(2, arg1);
     185                */
     186
     187                r = mvmd.splat<64>(1,arg1);
     188                r = mvmd.splat<128>(0,arg1);
     189
     190                r = mvmd.insert<2>(0, arg1, val1);
     191                r = mvmd.insert<4>(1, arg1, val1);
     192
     193                r = mvmd.fill4<16>(val1, val2, val3, val4);
     194                r = mvmd.fill4<32>(val1, val2, val3, val4);
     195
     196                r = mvmd.srli<64>(1,arg1);
     197                r = mvmd.srli<128>(2,arg1);
     198
     199                r = mvmd.fill2<4>(val1, val2);
     200                r = mvmd.fill2<8>(val1, val2);
     201
     202                r = mvmd.dslli<2>(1, arg1, arg2);
     203                r = mvmd.dslli<4>(4, arg1, arg2);
     204
     205                r = mvmd.dsrli<2>(1, arg1, arg2);
     206                r = mvmd.dsrli<4>(4, arg1, arg2);
     207
     208                r = mvmd.slli<64>(1,arg1);
     209                r = mvmd.slli<128>(2,arg1);
     210
     211                r = mvmd.fill8<4>(val1, val2, val3, val4, val5, val6, val7, val8);
     212                r = mvmd.fill8<8>(val1, val2, val3, val4, val5, val6, val7, val8);
     213
    63214    }
    64215
  • proto/s2k/trunk/framework/input/test/s2k/proto/grep/grep_header.s2k

    r3796 r3807  
    2828
    2929filter ClassifyBytes(struct Basis_bits basis_bits, struct Lex lex) {
     30
     31    stream temp0 = simd.constant<1>(1);
     32
    3033    stream temp1 = (basis_bits.bit_1 & (~ basis_bits.bit_0));
    3134    stream temp2 = (basis_bits.bit_2 & (~ basis_bits.bit_3));
Note: See TracChangeset for help on using the changeset viewer.