Changeset 1521


Ignore:
Timestamp:
Oct 9, 2011, 11:55:31 PM (8 years ago)
Author:
huah
Message:

new idisa library with bitblock128_t/bitblock256_t as simd type and uint64_t as integer type(only C++ implementation tested at this moment)

Location:
trunk/libgen
Files:
33 added
22 edited

Legend:

Unmodified
Added
Removed
  • trunk/libgen/Configure/OptParser.py

    r1369 r1521  
    2121                                                help="idisa file information")
    2222       
     23        parser.add_option("-b", "--body", dest="body", default="all",
     24                                                help="which content do you want to output into the idisa file")
     25       
    2326        return parser
  • trunk/libgen/Configure/configure.py

    r1494 r1521  
    11#configure file
     2
     3from IDISAOperations import AllOperations
    24
    35#SIMD instruction sets
     
    2426DefaultArch = SSE2
    2527
     28Body_Declaration = "declaration"
     29Body_Implementation = "implementation"
     30Body_All = "all"
     31
     32Macro_Idisa128_Hpp = r'''
     33#if defined USE_SSE3
     34#include "cpp/idisa_sse3.cpp"
     35#elif defined USE_SSSE3
     36#include "cpp/idisa_ssse3.cpp"
     37#elif defined USE_SSE4_1
     38#include "cpp/idisa_sse4_1.cpp"
     39#elif defined USE_SSE4_2
     40#include "cpp/idisa_sse4_2.cpp"
     41#else
     42#include "cpp/idisa_sse2.cpp"
     43#endif
     44'''
     45
     46Macro_Idisa256_Hpp = r'''
     47#include "cpp/idisa_avx.cpp"
     48'''
     49
    2650#Register sizes for different instruction sets
    2751RegisterSize = {MMX:64, SSE:128, SSE2:128, SSE3:128, SSSE3:128, SSE4:128, SSE4_a:128, SSE4_1:128, SSE4_2:128, AVX:256}
     
    3458SIMD_type = {MMX:"__m64", SSE:"__m128i", SSE2:"__m128i", SSE3:"__m128i", SSSE3:"__m128i", SSE4_a:"__m128i", SSE4_1:"__m128i", SSE4_2:"__m128i", AVX:"__m256"}
    3559
     60Bitblock_type = {MMX:"bitblock64_t", SSE:"bitblock128_t", SSE2:"bitblock128_t", SSE3:"bitblock128_t", SSSE3:"bitblock128_t", SSE4_1:"bitblock128_t", SSE4_2:"bitblock128_t",
     61                                AVX:"bitblock256_t"}
     62
    3663AVXBuiltInVecWrapper = "AVXBuiltInVecWrapper"
    3764AVXBuiltInHorWrapper = "AVXBuiltInHorWrapper"
     
    3966avx_select_hi128 = "avx_select_hi128"
    4067avx_general_combine256 = "avx_general_combine256"
    41 
    42 #IDISA_FUNCTION_SUPPORT = ["IDISA_CASTING"]
    43 
    44 #####################################################################
    45 #This is a list of all operations. The definition of each operation must follow one of the below formats
    46 #format_1(only for logic operations): opPattern = 2
    47 #simd_op(data_type arg, ...)
    48 #format_2: opPattern = 0
    49 #class_name<fw>::op(data_type arg, ...)
    50 #format_3: opPattern = 1
    51 #class_name<fw>::op<x>(data_type arg, ...)
    52 #format_4: opPattern = 3
    53 #class_name::op(data_type arg, ...)
    54 #####################################################################
    55 AllOperations = {
    56 
    57 #logic operations
    58 #fw should always be 1 for logic operations
    59 "and" : "SIMD_type simd_and(SIMD_type arg1, SIMD_type arg2)",
    60 "andc" : "SIMD_type simd_andc(SIMD_type arg1, SIMD_type arg2)",
    61 "or" : "SIMD_type simd_or(SIMD_type arg1, SIMD_type arg2)",
    62 "xor" : "SIMD_type simd_xor(SIMD_type arg1, SIMD_type arg2)",
    63 "not" : "SIMD_type simd_not(SIMD_type arg1)",
    64 "nor" : "SIMD_type simd_nor(SIMD_type arg1, SIMD_type arg2)",
    65 "simd_ifh" : "SIMD_type simd<fw>::ifh(SIMD_type arg1, SIMD_type arg2, SIMD_type arg3)",
    66 
    67 #constant and masking operations
    68 "simd_lomask" : "SIMD_type simd<fw>::lomask()",
    69 "simd_himask" : "SIMD_type simd<fw>::himask()",
    70 "simd_constant" : "SIMD_type simd<fw>::constant<val>()",
    71 
    72 #shifting operations
    73 "simd_srli" : "SIMD_type simd<fw>::srli<sh>(SIMD_type arg1)",
    74 "simd_srl" : "SIMD_type simd<fw>::srl(SIMD_type arg1, SIMD_type shift_mask)",
    75 "simd_slli" : "SIMD_type simd<fw>::slli<sh>(SIMD_type arg1)",
    76 "simd_sll" : "SIMD_type simd<fw>::sll(SIMD_type arg1, SIMD_type shift_mask)",
    77 "simd_srai" : "SIMD_type simd<fw>::srai<sh>(SIMD_type arg1)",
    78 "simd_sra" : "SIMD_type simd<fw>::sra(SIMD_type arg1, SIMD_type shift_mask)",
    79 
    80 #vertical operations
    81 "simd_add" : "SIMD_type simd<fw>::add(SIMD_type arg1, SIMD_type arg2)",
    82 "simd_sub" : "SIMD_type simd<fw>::sub(SIMD_type arg1, SIMD_type arg2)",
    83 "simd_umult" : "SIMD_type simd<fw>::umult(SIMD_type arg1, SIMD_type arg2)",
    84 "simd_mult" : "SIMD_type simd<fw>::mult(SIMD_type arg1, SIMD_type arg2)",
    85 "simd_eq" : "SIMD_type simd<fw>::eq(SIMD_type arg1, SIMD_type arg2)",
    86 "simd_gt" : "SIMD_type simd<fw>::gt(SIMD_type arg1, SIMD_type arg2)",
    87 "simd_ugt" : "SIMD_type simd<fw>::ugt(SIMD_type arg1, SIMD_type arg2)",
    88 "simd_lt" : "SIMD_type simd<fw>::lt(SIMD_type arg1, SIMD_type arg2)",
    89 "simd_ult" : "SIMD_type simd<fw>::ult(SIMD_type arg1, SIMD_type arg2)",
    90 "simd_max" : "SIMD_type simd<fw>::max(SIMD_type arg1, SIMD_type arg2)",
    91 "simd_umax" : "SIMD_type simd<fw>::umax(SIMD_type arg1, SIMD_type arg2)",
    92 "simd_min" : "SIMD_type simd<fw>::min(SIMD_type arg1, SIMD_type arg2)",
    93 "simd_umin" : "SIMD_type simd<fw>::umin(SIMD_type arg1, SIMD_type arg2)",
    94 "simd_abs" : "SIMD_type simd<fw>::abs(SIMD_type arg1)",
    95 "simd_neg" : "SIMD_type simd<fw>::neg(SIMD_type arg1)",
    96 "simd_add_hl" : "SIMD_type simd<fw>::add_hl(SIMD_type arg1)",
    97 "simd_sub_hl" : "SIMD_type simd<fw>::sub_hl(SIMD_type arg1)",
    98 "simd_xor_hl" : "SIMD_type simd<fw>::xor_hl(SIMD_type arg1)",
    99 "simd_popcount" : "SIMD_type simd<fw>::popcount(SIMD_type arg1)",
    100 "simd_ctz" : "SIMD_type simd<fw>::ctz(SIMD_type arg1)",
    101 
    102 #horizontal operations
    103 "hsimd_add_hl" : "SIMD_type hsimd<fw>::add_hl(SIMD_type arg1, SIMD_type arg2)",
    104 "hsimd_min_hl" : "SIMD_type hsimd<fw>::min_hl(SIMD_type arg1, SIMD_type arg2)",
    105 "hsimd_umin_hl" : "SIMD_type hsimd<fw>::umin_hl(SIMD_type arg1, SIMD_type arg2)",
    106 "hsimd_packh" : "SIMD_type hsimd<fw>::packh(SIMD_type arg1, SIMD_type arg2)",
    107 "hsimd_packl" : "SIMD_type hsimd<fw>::packl(SIMD_type arg1, SIMD_type arg2)",
    108 "hsimd_packus" : "SIMD_type hsimd<fw>::packus(SIMD_type arg1, SIMD_type arg2)",
    109 "hsimd_packss" : "SIMD_type hsimd<fw>::packss(SIMD_type arg1, SIMD_type arg2)",
    110 "hsimd_signmask": "int hsimd<fw>::signmask(SIMD_type arg1)",
    111 
    112 #expanding operations
    113 "esimd_mergeh" : "SIMD_type esimd<fw>::mergeh(SIMD_type arg1, SIMD_type arg2)",
    114 "esimd_mergel" : "SIMD_type esimd<fw>::mergel(SIMD_type arg1, SIMD_type arg2)",
    115 "esimd_merge" :  "void esimd<fw>::merge(SIMD_type arg1, SIMD_type arg2, SIMD_type &u, SIMD_type &v)",
    116 "esimd_multh" : "SIMD_type esimd<fw>::multh(SIMD_type arg1, SIMD_type arg2)",
    117 "esimd_multl" : "SIMD_type esimd<fw>::multl(SIMD_type arg1, SIMD_type arg2)",
    118 "esimd_signextendh" : "SIMD_type esimd<fw>::signextendh(SIMD_type arg1)",
    119 "esimd_signextendl" : "SIMD_type esimd<fw>::signextendl(SIMD_type arg1)",
    120 "esimd_zeroextendh" : "SIMD_type esimd<fw>::zeroextendh(SIMD_type arg1)",
    121 "esimd_zeroextendl" : "SIMD_type esimd<fw>::zeroextendl(SIMD_type arg1)",
    122 
    123 #movement operations
    124 "mvmd_fill" : "SIMD_type mvmd<fw>::fill(int val1)",
    125 "mvmd_fill2" : "SIMD_type mvmd<fw>::fill2(int val1, int val2)",
    126 "mvmd_fill4" : "SIMD_type mvmd<fw>::fill4(int val1, int val2, int val3, int val4)",
    127 "mvmd_fill8" : "SIMD_type mvmd<fw>::fill8(int val1, int val2, int val3, int val4, int val5, int val6, int val7, int val8)",
    128 "mvmd_fill16" : "SIMD_type mvmd<fw>::fill16(int val1, int val2, int val3, int val4, int val5, int val6, int val7, int val8, int val9, int val10, int val11, int val12, int val13, int val14, int val15, int val16)",
    129 "mvmd_splat" : "SIMD_type mvmd<fw>::splat<pos>(SIMD_type arg1)",
    130 "mvmd__slli" : "SIMD_type mvmd<fw>::slli<sh>(SIMD_type arg1)",
    131 "mvmd__srli" : "SIMD_type mvmd<fw>::srli<sh>(SIMD_type arg1)",
    132 "mvmd_shufflei" : "SIMD_type mvmd<fw>::shufflei<msk>(SIMD_type arg1)",
    133 "mvmd_dslli" : "SIMD_type mvmd<fw>::dslli<sh>(SIMD_type arg1, SIMD_type arg2)",
    134 "mvmd_dsrli" : "SIMD_type mvmd<fw>::dsrli<sh>(SIMD_type arg1, SIMD_type arg2)",
    135 "mvmd_shuffle" : "SIMD_type mvmd<fw>::shuffle(SIMD_type arg1, SIMD_type arg2)",
    136 
    137 #bitblock operations
    138 "bitblock_any" : "bool bitblock::any(SIMD_type arg1)",
    139 "bitblock_all" : "bool bitblock::all(SIMD_type arg1)",
    140 "bitblock_load_aligned" : "SIMD_type bitblock::load_aligned(SIMD_type* arg1)",
    141 "bitblock_load_unaligned" : "SIMD_type bitblock::load_unaligned(SIMD_type* arg1)",
    142 "bitblock_store_aligned" : "void bitblock::store_aligned(SIMD_type* arg1, SIMD_type arg2)",
    143 "bitblock_store_unaligned" : "void bitblock::store_unaligned(SIMD_type* arg1, SIMD_type arg2)",
    144 }
    145 
    146 ValueRanges = {
    147 
    148 #op : {"val_name":(min_val_name_repr, max_val_name_repr)}
    149 
    150 "simd_constant" : {"val":("-1*2**(fw-1)", "2**(fw-1)-1")},
    151 
    152 "simd_srli" : {"sh":("0", "fw")},
    153 
    154 "simd_slli" : {"sh":("0", "fw")},
    155 
    156 "simd_srai" : {"sh":("0", "fw")},
    157 
    158 "mvmd_fill" : {"val1":("-1*2**(fw-1)", "2**(fw-1)-1")},
    159 
    160 "mvmd_fill2" : {"val1":("-1*2**(fw-1)", "2**(fw-1)-1"), "val2":("-1*2**(fw-1)", "2**(fw-1)-1")},
    161 
    162 "mvmd_fill4" : {"val1":("-1*2**(fw-1)", "2**(fw-1)-1"), "val2":("-1*2**(fw-1)", "2**(fw-1)-1"), "val3":("-1*2**(fw-1)", "2**(fw-1)-1"), "val4":("-1*2**(fw-1)", "2**(fw-1)-1")},
    163 
    164 "mvmd_fill8" : {"val1":("-1*2**(fw-1)", "2**(fw-1)-1"), "val2":("-1*2**(fw-1)", "2**(fw-1)-1"), "val3":("-1*2**(fw-1)", "2**(fw-1)-1"), "val4":("-1*2**(fw-1)", "2**(fw-1)-1"), "val5":("-1*2**(fw-1)", "2**(fw-1)-1"), "val6":("-1*2**(fw-1)", "2**(fw-1)-1"), "val7":("-1*2**(fw-1)", "2**(fw-1)-1"), "val8":("-1*2**(fw-1)", "2**(fw-1)-1")},
    165 
    166 "mvmd_fill16" : {"val1":("-1*2**(fw-1)", "2**(fw-1)-1"), "val2":("-1*2**(fw-1)", "2**(fw-1)-1"), "val3":("-1*2**(fw-1)", "2**(fw-1)-1"), "val4":("-1*2**(fw-1)", "2**(fw-1)-1"), "val5":("-1*2**(fw-1)", "2**(fw-1)-1"), "val6":("-1*2**(fw-1)", "2**(fw-1)-1"), "val7":("-1*2**(fw-1)", "2**(fw-1)-1"), "val8":("-1*2**(fw-1)", "2**(fw-1)-1"), "val9":("-1*2**(fw-1)", "2**(fw-1)-1"), "val10":("-1*2**(fw-1)", "2**(fw-1)-1"), "val11":("-1*2**(fw-1)", "2**(fw-1)-1"), "val12":("-1*2**(fw-1)", "2**(fw-1)-1"), "val13":("-1*2**(fw-1)", "2**(fw-1)-1"), "val14":("-1*2**(fw-1)", "2**(fw-1)-1"), "val15":("-1*2**(fw-1)", "2**(fw-1)-1"), "val16":("-1*2**(fw-1)", "2**(fw-1)-1")},
    167 
    168 "mvmd_splat" : {"pos":("0", "curRegSize/fw-1")},
    169 
    170 "mvmd_slli" : {"sh":("0", "curRegSize/fw")},
    171 
    172 "mvmd_srli" : {"sh":("0", "curRegSize/fw")},
    173 
    174 "mvmd_shufflei" : {"msk":("0", "2**((curRegSize/fw)*int(math.log(curRegSize/fw, 2)))-1")},
    175 
    176 "mvmd_dslli" : {"sh":("0", "curRegSize/fw")},
    177 
    178 "mvmd_dsrli" : {"sh":("0", "curRegSize/fw")},
    179 }
  • trunk/libgen/Library_Generator/AVXInstructions.py

    r1494 r1521  
    66        "simd_and":\
    77        {
    8                 "Pattern":"_mm256_and_ps(arg1, arg2)",
    9                 "Fws":[1],
    10                 "ReturnType":"SIMD_type",
     8                "signature":"SIMD_type _mm256_and_ps(SIMD_type arg1, SIMD_type arg2)",
     9                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     10                "return_type":"SIMD_type",
     11                "fws":[1],
    1112        },
    1213        "simd_andc":\
    1314        {
    14                 "Pattern":"_mm256_andnot_ps(arg2, arg1)",
    15                 "Fws":[1],
    16                 "ReturnType":"SIMD_type",
     15                "signature":"SIMD_type _mm256_andnot_ps(SIMD_type arg2, SIMD_type arg1)",
     16                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     17                "return_type":"SIMD_type",
     18                "fws":[1],
    1719        },
    1820        "simd_or":\
    1921        {
    20                 "Pattern":"_mm256_or_ps(arg1, arg2)",
    21                 "Fws":[1],
    22                 "ReturnType":"SIMD_type",
     22                "signature":"SIMD_type _mm256_or_ps(SIMD_type arg1, SIMD_type arg2)",
     23                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     24                "return_type":"SIMD_type",
     25                "fws":[1],
    2326        },
    2427        "simd_xor":\
    2528        {
    26                 "Pattern":"_mm256_xor_ps(arg1, arg2)",
    27                 "Fws":[1],
    28                 "ReturnType":"SIMD_type",
     29                "signature":"SIMD_type _mm256_xor_ps(SIMD_type arg1, SIMD_type arg2)",
     30                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     31                "return_type":"SIMD_type",
     32                "fws":[1],
    2933        },
    3034        "simd_add":\
    3135        {
    32                 "Pattern":configure.AVXBuiltInVecWrapper + "(_mm_add_epi$fw$, arg1, arg2)",
    33                 "Fws":[8, 16, 32, 64],
    34                 "ReturnType":"SIMD_type",
     36                "signature":configure.AVXBuiltInVecWrapper + "(_mm_add_epi$fw$, arg1, arg2)",
     37                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     38                "return_type":"SIMD_type",
     39                "fws":[8, 16, 32, 64],
    3540        },
    3641        "simd_sub":\
    3742        {
    38                 "Pattern":configure.AVXBuiltInVecWrapper + "(_mm_sub_epi$fw$, arg1, arg2)",
    39                 "Fws":[8, 16, 32, 64],
    40                 "ReturnType":"SIMD_type",
     43                "signature":configure.AVXBuiltInVecWrapper + "(_mm_sub_epi$fw$, arg1, arg2)",
     44                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     45                "return_type":"SIMD_type",
     46                "fws":[8, 16, 32, 64],
    4147        },
    4248        "simd_umult":\
    4349        {
    44                 "Pattern":configure.AVXBuiltInVecWrapper + "(_mm_mul_epu$fw$, arg1, arg2)",
    45                 "Fws":[32],
    46                 "ReturnType":"SIMD_type",
     50                "signature":configure.AVXBuiltInVecWrapper + "(_mm_mul_epu$fw$, arg1, arg2)",
     51                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     52                "return_type":"SIMD_type",
     53                "fws":[32],
    4754        },
    4855        "simd_mult":\
    4956        {
    50                 "Pattern":configure.AVXBuiltInVecWrapper + "(_mm_mullo_epi$fw$, arg1, arg2)",
    51                 "Fws":[16, 32],
    52                 "ReturnType":"SIMD_type",
     57                "signature":configure.AVXBuiltInVecWrapper + "(_mm_mullo_epi$fw$, arg1, arg2)",
     58                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     59                "return_type":"SIMD_type",
     60                "fws":[16, 32],
    5361        },
    5462        "simd_eq":\
    5563        {
    56                 "Pattern":configure.AVXBuiltInVecWrapper + "(_mm_cmpeq_epi$fw$, arg1, arg2)",
    57                 "Fws":[8, 16, 32, 64],
    58                 "ReturnType":"SIMD_type",
     64                "signature":configure.AVXBuiltInVecWrapper + "(_mm_cmpeq_epi$fw$, arg1, arg2)",
     65                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     66                "return_type":"SIMD_type",
     67                "fws":[8, 16, 32, 64],
    5968        },
    6069        "simd_gt":\
    6170        {
    62                 "Pattern":configure.AVXBuiltInVecWrapper + "(_mm_cmpgt_epi$fw$, arg1, arg2)",
    63                 "Fws":[8, 16, 32, 64],
    64                 "ReturnType":"SIMD_type",
     71                "signature":configure.AVXBuiltInVecWrapper + "(_mm_cmpgt_epi$fw$, arg1, arg2)",
     72                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     73                "return_type":"SIMD_type",
     74                "fws":[8, 16, 32, 64],
    6575        },
    6676        "simd_max":\
    6777        {
    68                 "Pattern":configure.AVXBuiltInVecWrapper + "(_mm_max_epi$fw$, arg1, arg2)",
    69                 "Fws":[8, 16, 32],
    70                 "ReturnType":"SIMD_type",
     78                "signature":configure.AVXBuiltInVecWrapper + "(_mm_max_epi$fw$, arg1, arg2)",
     79                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     80                "return_type":"SIMD_type",
     81                "fws":[8, 16, 32],
    7182        },
    7283        "simd_umax":\
    7384        {
    74                 "Pattern":configure.AVXBuiltInVecWrapper + "(_mm_max_epu$fw$, arg1, arg2)",
    75                 "Fws":[8, 16, 32],
    76                 "ReturnType":"SIMD_type",
     85                "signature":configure.AVXBuiltInVecWrapper + "(_mm_max_epu$fw$, arg1, arg2)",
     86                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     87                "return_type":"SIMD_type",
     88                "fws":[8, 16, 32],
    7789        },
    7890        "simd_min":\
    7991        {
    80                 "Pattern":configure.AVXBuiltInVecWrapper + "(_mm_min_epi$fw$, arg1, arg2)",
    81                 "Fws":[8, 16, 32],
    82                 "ReturnType":"SIMD_type",
     92                "signature":configure.AVXBuiltInVecWrapper + "(_mm_min_epi$fw$, arg1, arg2)",
     93                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     94                "return_type":"SIMD_type",
     95                "fws":[8, 16, 32],
    8396        },
    8497        "simd_umin":\
    8598        {
    86                 "Pattern":configure.AVXBuiltInVecWrapper + "(_mm_min_epu$fw$, arg1, arg2)",
    87                 "Fws":[8, 16, 32],
    88                 "ReturnType":"SIMD_type",
     99                "signature":configure.AVXBuiltInVecWrapper + "(_mm_min_epu$fw$, arg1, arg2)",
     100                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     101                "return_type":"SIMD_type",
     102                "fws":[8, 16, 32],
    89103        },
    90104        "simd_srli":\
    91105        {
    92                 "Pattern":configure.AVXBuiltInVecWrapper + "(_mm_srli_epi$fw$, arg1, sh)",
    93                 "Fws":[16, 32, 64],
    94                 "ReturnType":"SIMD_type",
     106                "signature":configure.AVXBuiltInVecWrapper + "(_mm_srli_epi$fw$, arg1, sh)",
     107                "args_type":{"arg1":"SIMD_type", "sh":"signed_int(32)"},
     108                "return_type":"SIMD_type",
     109                "fws":[16, 32, 64],
    95110        },
    96111        "simd_slli":\
    97112        {
    98                 "Pattern":configure.AVXBuiltInVecWrapper + "(_mm_slli_epi$fw$, arg1, sh)",
    99                 "Fws":[16, 32, 64],
    100                 "ReturnType":"SIMD_type",
     113                "signature":configure.AVXBuiltInVecWrapper + "(_mm_slli_epi$fw$, arg1, sh)",
     114                "args_type":{"arg1":"SIMD_type", "sh":"signed_int(32)"},
     115                "return_type":"SIMD_type",
     116                "fws":[16, 32, 64],
    101117        },
    102118        "simd_srai":\
    103119        {
    104                 "Pattern":configure.AVXBuiltInVecWrapper + "(_mm_srai_epi$fw$, arg1, sh)",
    105                 "Fws":[16, 32],
    106                 "ReturnType":"SIMD_type",
     120                "signature":configure.AVXBuiltInVecWrapper + "(_mm_srai_epi$fw$, arg1, sh)",
     121                "args_type":{"arg1":"SIMD_type", "sh":"signed_int(32)"},
     122                "return_type":"SIMD_type",
     123                "fws":[16, 32],
    107124        },
    108125        "simd_constant":\
    109126        {
    110                 "Pattern":"(SIMD_type)_mm256_set1_epi$fw$(val)",
    111                 "Fws":[8, 16, 32],
    112                 "ReturnType":"SIMD_type",
     127                "signature":"SIMD_type (SIMD_type)_mm256_set1_epi$fw$(int val)",
     128                "args_type":{"val":"signed_int(32)"},
     129                "return_type":"SIMD_type",
     130                "fws":[8, 16, 32],
    113131        },
    114132        "simd_abs":\
    115133        {
    116                 "Pattern":configure.AVXBuiltInVecWrapper + "(_mm_abs_epi$fw$, arg1)",
    117                 "Fws":[8, 16, 32],
    118                 "ReturnType":"SIMD_type",
     134                "signature":configure.AVXBuiltInVecWrapper + "(_mm_abs_epi$fw$, arg1)",
     135                "args_type":{"arg1":"SIMD_type"},
     136                "return_type":"SIMD_type",
     137                "fws":[8, 16, 32],
    119138        },
    120139        "hsimd_add_hl":\
    121140        {
    122                 "Pattern":configure.AVXBuiltInHorWrapper + "(_mm_hadd_epi$fw/2$, arg1, arg2)",
    123                 "Fws":[32, 64],
    124                 "ReturnType":"SIMD_type",       
     141                "signature":configure.AVXBuiltInHorWrapper + "(_mm_hadd_epi$fw/2$, arg1, arg2)",
     142                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     143                "return_type":"SIMD_type",
     144                "fws":[32, 64],
    125145        },
    126146        "hsimd_packus":\
    127147        {
    128                 "Pattern":configure.AVXBuiltInHorWrapper + "(_mm_packus_epi$fw$, arg1, arg2)",
    129                 "Fws":[16, 32],
    130                 "ReturnType":"SIMD_type",
     148                "signature":configure.AVXBuiltInHorWrapper + "(_mm_packus_epi$fw$, arg1, arg2)",
     149                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     150                "return_type":"SIMD_type",
     151                "fws":[16, 32],
    131152        },
    132153        "hsimd_packss":\
    133154        {
    134                 "Pattern":configure.AVXBuiltInHorWrapper + "(_mm_packs_epi$fw$, arg1, arg2)",
    135                 "Fws":[16, 32],
    136                 "ReturnType":"SIMD_type",
     155                "signature":configure.AVXBuiltInHorWrapper + "(_mm_packs_epi$fw$, arg1, arg2)",
     156                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     157                "return_type":"SIMD_type",
     158                "fws":[16, 32],
    137159        },
    138160        "mvmd_fill":\
    139161        {
    140                 "Pattern":"(SIMD_type)_mm256_set1_epi$fw$(val1)",
    141                 "Fws":[8, 16, 32],
    142                 "ReturnType":"SIMD_type",
     162                "signature":"SIMD_type (SIMD_type)_mm256_set1_epi$fw$(int val1)",
     163                "args_type":{"val1":"signed_int(32)"},
     164                "return_type":"SIMD_type",
     165                "fws":[8, 16, 32],
    143166        },
    144167        "mvmd_fill4":\
    145168        {
    146                 "Pattern":"(SIMD_type)_mm256_set_epi$fw$(val1, val2, val3, val4, val1, val2, val3, val4)",
    147                 "Fws":[32],
    148                 "ReturnType":"SIMD_type",
     169                "signature":"SIMD_type (SIMD_type)_mm256_set_epi$fw$(int val1, int val2, int val3, int val4, int val1, int val2, int val3, int val4)",
     170                "args_type":{"val1":"signed_int(32)", "val2":"signed_int(32)", "val3":"signed_int(32)", "val4":"signed_int(32)"},
     171                "return_type":"SIMD_type",
     172                "fws":[32],
    149173        },
    150174        "mvmd_fill8":\
    151175        {
    152                 "Pattern":"(SIMD_type)_mm256_set_epi$fw$(val1, val2, val3, val4, val5, val6, val7, val8, val1, val2, val3, val4, val5, val6, val7, val8)",
    153                 "Fws":[16],
    154                 "ReturnType":"SIMD_type",
     176                "signature":"SIMD_type (SIMD_type)_mm256_set_epi$fw$(int val1, int val2, int val3, int val4, int val5, int val6, int val7, int val8, int val1, int val2, int val3, int val4, int val5, int val6, int val7, int val8)",
     177                "args_type":{"val1":"signed_int(32)", "val2":"signed_int(32)", "val3":"signed_int(32)", "val4":"signed_int(32)", \
     178                                        "val5":"signed_int(32)", "val6":"signed_int(32)", "val7":"signed_int(32)", "val8":"signed_int(32)"},
     179                "return_type":"SIMD_type",
     180                "fws":[16],
    155181        },
    156182        "mvmd_fill16":\
    157183        {
    158                 "Pattern":"(SIMD_type)_mm256_set_epi$fw$(val1, val2, val3, val4, val5, val6, val7, val8, val9, val10, val11, val12, val13, val14, val15, val16, val1, val2, val3, val4, val5, val6, val7, val8, val9, val10, val11, val12, val13, val14, val15, val16)",
    159                 "Fws":[8],
    160                 "ReturnType":"SIMD_type",
    161         },
    162         "bitblock_load_aligned":\
    163         {
    164                 "Pattern":"(SIMD_type)_mm256_load_si$fw$((__m256i const *)arg1)",
    165                 "Fws":[256],
    166                 "ReturnType":"SIMD_type",
    167         },
    168         "bitblock_load_unaligned":\
    169         {
    170                 "Pattern":"(SIMD_type)_mm256_loadu_si256((__m256i const *)arg1)",
    171                 "Fws":[256],
    172                 "ReturnType":"SIMD_type",
    173         },
    174         "bitblock_store_aligned":\
    175         {
    176                 "Pattern":"_mm256_store_ps((float *)arg1, arg2)",
    177                 "Fws":[256],
    178                 "ReturnType":"void",
    179         },
    180         "bitblock_store_unaligned":\
    181         {
    182                 "Pattern":"_mm256_storeu_ps((float *)arg1, arg2)",
    183                 "Fws":[256],
    184                 "ReturnType":"void",
     184                "signature":"SIMD_type (SIMD_type)_mm256_set_epi$fw$(int val1, int val2, int val3, int val4, int val5, int val6, int val7, int val8, int val9, int val10, int val11, int val12, int val13, int val14, int val15, int val16, int val1, int val2, int val3, int val4, int val5, int val6, int val7, int val8, int val9, int val10, int val11, int val12, int val13, int val14, int val15, int val16)",
     185                "args_type":{"val1":"signed_int(32)", "val2":"signed_int(32)", "val3":"signed_int(32)", "val4":"signed_int(32)", \
     186                                        "val5":"signed_int(32)", "val6":"signed_int(32)", "val7":"signed_int(32)", "val8":"signed_int(32)", \
     187                                        "val9":"signed_int(32)", "val10":"signed_int(32)", "val11":"signed_int(32)", "val12":"signed_int(32)", \
     188                                        "val13":"signed_int(32)", "val14":"signed_int(32)", "val15":"signed_int(32)", "val16":"signed_int(32)"},
     189                "return_type":"SIMD_type",
     190                "fws":[8],
    185191        },
    186192        "_mm256_set_epi32":\
    187193        {
    188                 "Pattern":"_mm256_set_epi32(val1, val2, val3, val4, val5, val6, val7, val8)",
    189                 "Fws":[32],
    190                 "ReturnType":"SIMD_type",
     194                "signature":"SIMD_type _mm256_set_epi32(int val1, int val2, int val3, int val4, int val5, int val6, int val7, int val8)",
     195                "args_type":{"val1":"signed_int(32)", "val2":"signed_int(32)", "val3":"signed_int(32)", "val4":"signed_int(32)", \
     196                                        "val5":"signed_int(32)", "val6":"signed_int(32)", "val7":"signed_int(32)", "val8":"signed_int(32)"},
     197                "return_type":"SIMD_type",
     198                "fws":[32],
    191199        },
    192200        "_mm256_castsi128_si256":\
    193201        {
    194                 "Pattern":"_mm256_castsi128_si256(arg1)",
    195                 "Fws":[256],
    196                 "ReturnType":"SIMD_type",
     202                "signature":"SIMD_type _mm256_castsi128_si256(__m128i arg1)",
     203                "args_type":{"arg1":"__m128i"},
     204                "return_type":"SIMD_type",
     205                "fws":[256],
    197206        },
    198207        "_mm_sad_epu8":\
    199208        {
    200                 "Pattern":"_mm_sad_epu8(arg1, arg2)",
    201                 "Fws":[8],
    202                 "ReturnType":"__m128i",
     209                "signature":"__m128i _mm_sad_epu8(__m128i arg1, __m128i arg2)",
     210                "args_type":{"arg1":"__m128i", "arg2":"__m128i"},
     211                "return_type":"__m128i",
     212                "fws":[8],
    203213        },
    204214        "_mm_set1_epi32":\
    205215        {
    206                 "Pattern":"_mm_set1_epi32(val1)",
    207                 "Fws":[32],
    208                 "ReturnType":"__m128i",
     216                "signature":"__m128i _mm_set1_epi32(int val1)",
     217                "args_type":{"val1":"signed_int(32)"},
     218                "return_type":"__m128i",
     219                "fws":[32],
    209220        },
    210221        "_mm_extract_epi8":\
    211222        {
    212                 "Pattern":"_mm_extract_epi8(arg1, pos)",
    213                 "Fws":[8],
    214                 "ReturnType":IntType,   
     223                "signature":"int _mm_extract_epi8(__m128i arg1, int pos)",
     224                "args_type":{"arg1":"__m128i", "pos":"signed_int(32)"},
     225                "return_type":"signed_int(32)",
     226                "fws":[8],
    215227        },
    216228        "_mm_extract_epi16":\
    217229        {
    218                 "Pattern":"_mm_extract_epi16(arg1, pos)",
    219                 "Fws":[16],
    220                 "ReturnType":IntType,   
     230                "signature":"int _mm_extract_epi16(__m128i arg1, int pos)",
     231                "args_type":{"arg1":"__m128i", "pos":"signed_int(32)"},
     232                "return_type":"signed_int(32)",
     233                "fws":[16],
    221234        },
    222235        "_mm_extract_epi32":\
    223236        {
    224                 "Pattern":"_mm_extract_epi32(arg1, pos)",
    225                 "Fws":[32],
    226                 "ReturnType":IntType,   
     237                "signature":"int _mm_extract_epi32(__m128i arg1, int pos)",
     238                "args_type":{"arg1":"__m128i", "pos":"signed_int(32)"},
     239                "return_type":"signed_int(32)",
     240                "fws":[32],
     241        },
     242        "_mm256_testz_si256":\
     243        {
     244                "signature":"int _mm256_testz_si256(SIMD_type arg1, SIMD_type arg1)",
     245                "args_type":{"arg1":"SIMD_type"},
     246                "return_type":"signed_int(32)",
     247                "fws":[256],
     248        },
     249        "_mm_movemask_epi8":\
     250        {
     251                "signature":"int _mm_movemask_epi8(__m128i arg1)",
     252                "args_type":{"arg1":"__m128i"},
     253                "return_type":"signed_int(32)",
     254                "fws":[8],
     255        },
     256        "_mm_unpackhi_epi8":\
     257        {
     258                "signature":"__m128i _mm_unpackhi_epi8(__m128i arg2, __m128i arg1)",
     259                "args_type":{"arg1":"__m128i", "arg2":"__m128i"},
     260                "return_type":"__m128i",
     261                "fws":[8],
     262        },
     263        "_mm_unpackhi_epi16":\
     264        {
     265                "signature":"__m128i _mm_unpackhi_epi16(__m128i arg2, __m128i arg1)",
     266                "args_type":{"arg1":"__m128i", "arg2":"__m128i"},
     267                "return_type":"__m128i",
     268                "fws":[16],
     269        },
     270        "_mm_unpackhi_epi32":\
     271        {
     272                "signature":"__m128i _mm_unpackhi_epi32(__m128i arg2, __m128i arg1)",
     273                "args_type":{"arg1":"__m128i", "arg2":"__m128i"},
     274                "return_type":"__m128i",
     275                "fws":[32],
     276        },
     277        "_mm_unpackhi_epi64":\
     278        {
     279                "signature":"__m128i _mm_unpackhi_epi64(__m128i arg2, __m128i arg1)",
     280                "args_type":{"arg1":"__m128i", "arg2":"__m128i"},
     281                "return_type":"__m128i",
     282                "fws":[64],
     283        },
     284        "_mm_unpacklo_epi8":\
     285        {
     286                "signature":"__m128i _mm_unpacklo_epi8(__m128i arg2, __m128i arg1)",
     287                "args_type":{"arg1":"__m128i", "arg2":"__m128i"},
     288                "return_type":"__m128i",
     289                "fws":[8],
     290        },
     291        "_mm_unpacklo_epi16":\
     292        {
     293                "signature":"__m128i _mm_unpacklo_epi16(__m128i arg2, __m128i arg1)",
     294                "args_type":{"arg1":"__m128i", "arg2":"__m128i"},
     295                "return_type":"__m128i",
     296                "fws":[16],
     297        },
     298        "_mm_unpacklo_epi32":\
     299        {
     300                "signature":"__m128i _mm_unpacklo_epi32(__m128i arg2, __m128i arg1)",
     301                "args_type":{"arg1":"__m128i", "arg2":"__m128i"},
     302                "return_type":"__m128i",
     303                "fws":[32],
     304        },
     305        "_mm_unpacklo_epi64":\
     306        {
     307                "signature":"__m128i _mm_unpacklo_epi64(__m128i arg2, __m128i arg1)",
     308                "args_type":{"arg1":"__m128i", "arg2":"__m128i"},
     309                "return_type":"__m128i",
     310                "fws":[64],
    227311        },
    228312}
    229 
    230 
  • trunk/libgen/Library_Generator/BuiltIns.py

    r1494 r1521  
    33import InstructionSet
    44import Utility
     5import StandardTypes
    56
    67from Utility import configure
     8
     9class BuiltInOperation:
     10       
     11        def __init__(self, arch, opSignature, args_type):
     12                opSignature = opSignature.strip()
     13                firstSpace = opSignature.find(" ")
     14                spacePos, leftBrac = firstSpace, -1
     15                while opSignature.find("(", spacePos) != -1:
     16                        leftBrac = opSignature.find("(", spacePos)
     17                        spacePos = leftBrac + 1
     18                rightBrac = opSignature.find(")", leftBrac)
     19                #print opSignature,
     20                self.arch = arch
     21                self.returnType = opSignature[:firstSpace]
     22                self.funcName = opSignature[firstSpace+1:leftBrac]
     23                opSignature = opSignature[leftBrac+1:rightBrac]
     24                self.argsType = args_type
     25                self.args = []
     26                for arg in opSignature.split(","):
     27                        arg0 = arg.strip()
     28                        self.args.append(arg0[arg0.find(" ")+1:])
     29                self.arguments = self.args
     30               
     31                #print self.funcName, self.arguments
     32       
     33        def GetCallingConvention(self):
     34                assert len(self.args) == len(self.arguments), "the number of arguments is not acceptable for the built-in " + self.funcName
     35                txt = self.funcName
     36                txt += "("
     37                for i in range(len(self.args)):
     38                        if StandardTypes.IsSignedIntType(self.argsType[self.args[i]]):
     39                                txt += "(" + StandardTypes.GetSignedIntType(self.argsType[self.args[i]], configure.RegisterSize[self.arch]) + ")" + "(" + self.arguments[i] + ")" + ", "
     40                        elif StandardTypes.IsUnsignedIntType(self.argsType[self.args[i]]):
     41                                txt += "(" + StandardTypes.GetUnsignedIntType(self.argsType[self.args[i]], configure.RegisterSize[self.arch]) + ")" + "(" + self.arguments[i] + ")" + ", "
     42                        elif StandardTypes.IsSIMDType(self.argsType[self.args[i]]):
     43                                txt += self.arguments[i] + ", "
     44                        else:
     45                                assert False, "unknown data type for built-ins"
     46                if len(self.args) > 0:
     47                        txt = txt[:len(txt)-2]
     48                txt += ")"
     49                return txt
    750
    851class BuiltIns:
     
    1154                self.builtInsTable = {}
    1255                self.builtInsTable = InstructionSet.Load(arch)
     56                self.builtInOperations = self.LoadBuiltInOperations(arch)
     57       
     58        def LoadBuiltInOperations(self, arch):
     59                builtInOperations = {}
     60                for opName in self.builtInsTable:
     61                        opSignature = self.builtInsTable[opName]["signature"]
     62                        args_type = self.builtInsTable[opName]["args_type"]
     63                        if arch != configure.AVX:
     64                                builtInOperations[opName] = BuiltInOperation(arch, opSignature, args_type)
     65                        elif configure.AVXBuiltInVecWrapper not in opSignature and configure.AVXBuiltInHorWrapper not in opSignature:
     66                                builtInOperations[opName] = BuiltInOperation(arch, opSignature, args_type)
     67                return builtInOperations
    1368       
    1469        def InterpretFw(self, operation, pattern):
     
    2277       
    2378        def PackAnAVXOperation(self, operation):
    24                 builtInPattern = self.builtInsTable[operation.fullName]["Pattern"]
     79                builtInPattern = self.builtInsTable[operation.fullName]["signature"]
    2580                argsList = [x.strip(" )") for x in builtInPattern[builtInPattern.find("(")+1:].split(",")]
    2681                sseBuiltInPattern = self.InterpretFw(operation, argsList[0])
    2782                numOfArgs = len(argsList) - 1
     83                regSize = configure.RegisterSize[operation.arch]
    2884               
    2985                #set the used function support
     
    60116                                        content += configure.avx_select_hi128 + "(" + argsList[i] + ")" + ", "
    61117                                        initCost += Utility.functionSupport[configure.avx_select_hi128]["cost"]
    62                                 content += argsList[numOfArgs] + ")" + ", "
     118                                dataType = self.builtInsTable[operation.fullName]["args_type"][argsList[numOfArgs]]
     119                                if StandardTypes.IsSignedIntType(dataType):
     120                                        content += "(" + StandardTypes.GetSignedIntType(dataType, regSize) + ")" + "(" + argsList[numOfArgs] + ")"
     121                                elif StandardTypes.IsUnsignedIntType(dataType):
     122                                        content += "(" + StandardTypes.GetUnsignedIntType(dataType, regSize) + ")" + "(" + argsList[numOfArgs] + ")"
     123                                else:
     124                                        content += argsList[numOfArgs]
     125                                content += ")" + ", "
     126                               
    63127                                content += sseBuiltInPattern + "("
    64128                                initCost += 1
     
    66130                                        content += configure.avx_select_lo128 + "(" + argsList[i] + ")" + ", "
    67131                                        initCost += Utility.functionSupport[configure.avx_select_lo128]["cost"]
    68                                 content += argsList[numOfArgs] + ")" + ")"
     132                                dataType = self.builtInsTable[operation.fullName]["args_type"][argsList[numOfArgs]]
     133                                if StandardTypes.IsSignedIntType(dataType):
     134                                        content += "(" + StandardTypes.GetSignedIntType(dataType, regSize) + ")" + "(" + argsList[numOfArgs] + ")"
     135                                elif StandardTypes.IsUnsignedIntType(dataType):
     136                                        content += "(" + StandardTypes.GetUnsignedIntType(dataType, regSize) + ")" + "(" + argsList[numOfArgs] + ")"
     137                                else:
     138                                        content += argsList[numOfArgs]
     139                                content += ")" + ")"
    69140                        else:
    70141                                print "No AVX wrappers for this operation", operation.fullName
     
    102173                        return content
    103174                else:
    104                         return self.InterpretFw(operation, builtInPattern)
     175                        content = self.builtInOperations[operation.fullName].GetCallingConvention()
     176                        content = content.replace("(SIMD_type)", "("+configure.Bitblock_type[operation.arch]+")")
     177                        return self.InterpretFw(operation, content)
    105178       
    106179        def PackAnOperation(self, operation):
     
    116189                        #return the intrinsic of operation with $fw$ replaced by real field width value
    117190                        #when there is no wrappers involved
    118                                 builtInPattern = self.builtInsTable[operation.fullName]["Pattern"]
    119                                 return self.InterpretFw(operation, builtInPattern)
     191                                #builtInPattern = self.builtInsTable[operation.fullName]["Pattern"]
     192                                callingConv = self.builtInOperations[operation.fullName].GetCallingConvention()
     193                                return self.InterpretFw(operation, callingConv)
    120194                       
    121195                elif isinstance(operation, str):
    122196                        #return only the intrinsic of operation
    123                         return self.builtInsTable[operation]["Pattern"]
     197                        return self.builtInOperations[str].GetCallingConvention()
    124198       
    125199        def PackAnOperationInC(self, operation):
    126200                cText = self.PackAnOperation(operation)
    127201                if isinstance(operation, Operation.Operation):
    128                         if self.builtInsTable[operation.fullName]["ReturnType"] != "void":
     202                        if self.builtInsTable[operation.fullName]["return_type"] != "void":
    129203                                return "return " + cText + ";\n"
    130204                        else:
    131205                                return cText + ";\n"
    132206                elif isinstance(operation, str):
    133                         if self.builtInsTable[operation]["ReturnType"] != "void":
     207                        if self.builtInsTable[operation]["return_type"] != "void":
    134208                                return "return " + cText + ";\n"
    135209                        else:
     
    139213                cppText = self.PackAnOperation(operation)
    140214                if isinstance(operation, Operation.Operation):
    141                         if self.builtInsTable[operation.fullName]["ReturnType"] != "void":
     215                        if self.builtInsTable[operation.fullName]["return_type"] != "void":
    142216                                return "{\n\treturn " + cppText + ";\n}\n"
    143217                        else:
    144218                                return "{\n\t" + cppText + ";\n}\n"
    145219                elif isinstance(operation, str):
    146                         if self.builtInsTable[operation]["ReturnType"] != "void":
     220                        if self.builtInsTable[operation]["return_type"] != "void":
    147221                                return "{\n\treturn " + cppText + ";\n}\n"
    148222                        else:
     
    157231                        if self.builtInsTable.has_key(operation.fullName) == False:
    158232                                return False
    159                         return operation.fieldWidth in self.builtInsTable[operation.fullName]["Fws"]
     233                        return operation.fieldWidth in self.builtInsTable[operation.fullName]["fws"]
    160234                elif isinstance(operation, str):
    161235                #If operation is just a string instance, only check whether the operation name is in the builtInsTable
     
    167241                '''
    168242                if isinstance(operation, Operation.Operation):
    169                         pattern = self.builtInsTable[operation.fullName]["Pattern"]
    170                         args = pattern[pattern.find("(")+1:]
    171                         if "arg" in args or "shift_mask" in args or "val1" in args:
     243                        args = [arg for arg in self.builtInsTable[operation.fullName]["args_type"]]
     244                        if "arg1" in args or "shift_mask" in args or "val1" in args:
    172245                                return False
    173246                        return True
     
    179252                '''
    180253                if isinstance(operation, Operation.Operation):
    181                         return self.builtInsTable[operation.fullName]["ReturnType"]
    182                 elif isinstance(operation, str):
    183                         return self.builtInsTable[operation]["ReturnType"]
     254                        return self.builtInsTable[operation.fullName]["return_type"]
     255                elif isinstance(operation, str):
     256                        return self.builtInsTable[operation]["return_type"]
    184257                return None
  • trunk/libgen/Library_Generator/CppFunctionSupport.py

    r1494 r1521  
    8383        ((__m128i)(_mm256_extractf128_ps(x, 1)))''',
    8484        "platform":[configure.AVX],
    85         "returnType":configure.SIMD_type[configure.AVX],
     85        "returnType":configure.SIMD_type[configure.SSE2],
    8686        "cost":1,
    8787        },
     
    9393        ((__m128i) _mm256_castps256_ps128(x))''',
    9494        "platform":[configure.AVX],
    95         "returnType":configure.SIMD_type[configure.AVX],
     95        "returnType":configure.SIMD_type[configure.SSE2],
    9696        "cost":1,
    9797        },
  • trunk/libgen/Library_Generator/CppTranslator.py

    r1494 r1521  
    44
    55import Utility
     6import StandardTypes
     7from Utility import configure
    68from Operation import Operation
    79from IDISAFunctionSupport import IDISAFunction
     
    2123                self.prevCall = self.calls
    2224                self.isCompileTimeConstant = True
    23                
    2425                #print "cur strategy is ", strategyBody
    2526               
     
    117118                #print "cur return type = ", returnType
    118119                if returnType == IntType:
    119                         return "int"
     120                        return "uint32_t"
    120121                elif returnType == LongType:
    121                         return "long long"
     122                        return "uint64_t"
    122123                elif returnType == "SIMD_type":
    123                         return "SIMD_type"
     124                        return configure.Bitblock_type[self.operation.arch]
    124125                else:
    125126                        return returnType
     
    231232                '''
    232233                codes = repr(tree.n)
    233                 return {"codes":codes, "returnType":IntType}
     234                return {"codes":codes, "returnType":StandardTypes.GetAppropriatePythonType(codes)}
    234235
    235236        binop = {"Add":"+", "Sub":"-", "Mult":"*", "Div":"/", "Mod":"%",\
     
    266267                return True
    267268
     269        def ParseFuncName(self, funcName):
     270                if "$fw$" in funcName:
     271                        funcName = funcName.replace("$fw$", str(self.operation.fieldWidth))
     272                return funcName
     273       
    268274        def IsCall(self, tree):
    269275                '''
     
    278284                returnType = funcRet["returnType"]
    279285
     286                #parse the funcName
     287                #funcName = self.ParseFuncName(funcName)
     288               
    280289                #Start to pack args
    281290                sz = len(tree.args)
     
    316325                                self.prevCall.append(op.fullName + "_" + str(Utility.curRegisterSize))
    317326                elif IDISAFunction.IsIDISAFunction(funcName):
    318                         (codes, returnType) = IDISAFunction().Parse(IDISAFunction(), funcName, argList)
     327                        (codes, returnType) = IDISAFunction(self.operation.arch).Parse(IDISAFunction(self.operation.arch), funcName, argList, self.operation.fieldWidth)
    319328                        #print "func is " + codes + " with type ", returnType
    320329                else:
     
    325334                                return {"codes":None, "returnType":None}
    326335                       
    327                         codes = Utility.CallingStatement(funcName, argList)
     336                        codes = Utility.CallingStatement(funcName, self.operation.arch, argList)
    328337                        returnType = None
    329338                        if Utility.builtIns.IsOperationBuiltIn(funcName) == True:
  • trunk/libgen/Library_Generator/IDISAFunctionSupport.py

    r1494 r1521  
     1import Utility
     2from Utility import configure
    13
    24class IDISAFunction:
    35   
    4     def __init__(self):
     6    def __init__(self, arch):
     7        self.arch = arch
    58        pass
    69
     
    1518   
    1619    @staticmethod
    17     def Parse(self, funcName, argsList):
    18         callMethod = getattr(self, "Is" + funcName.upper())   
     20    def Parse(self, funcName, argsList, fw=0):
     21        callMethod = getattr(self, "Is" + funcName.upper())
     22        argsList.append(fw)   
    1923        if callMethod:
    2024            return callMethod(argsList)
     
    2327
    2428    def IsIDISA_CASTING(self, argsList):
    25         assert len(argsList) == 2, "IDISA_CASTING can't accept these many arguments!"
     29        assert len(argsList)-1 == 2, "IDISA_CASTING can't accept these many arguments!"
    2630        returnType = str(argsList[0])
     31        returnType = configure.Bitblock_type[self.arch] if returnType == "SIMD_type" else returnType
    2732        codes = "(" + "(" + returnType + ")" + str(argsList[1]) + ")"
     33        return (codes, returnType)
     34   
     35    def IsIDISA_PACK(self, argsList):
     36        func = argsList[0]
     37        fw = argsList[-1]
     38        assert "$fw$" in func, "No $fw$ in function name!"
     39        func = func.replace("$fw$", str(fw))
     40        assert Utility.builtIns.IsOperationBuiltIn(func) == True, "This " + func + " is not a built-in!"
     41       
     42        returnType = Utility.builtIns.GetOperationReturnType(func)
     43        codes = func + "("
     44        for arg in argsList[1:-2]:
     45            codes += arg + "," + " "
     46        codes += argsList[-2] + ")"
    2847        return (codes, returnType)
    2948
  • trunk/libgen/Library_Generator/LibraryGenerator.py

    r1494 r1521  
    5959        #print '''\nThe codes are written in "''' + arch + "_" + lang + '''.h" under the same directory'''
    6060
    61 def Main(arch, lang, outfile):
     61def Main(arch, lang, outfile, whichContent):
    6262       
    6363        Init(arch, lang)
     
    6767        analysisResult = OperationSetAnalyzer.Analyze(operationSet)
    6868       
    69         UI.WriteCodes(analysisResult, arch, lang)
     69        UI.WriteCodes(analysisResult, arch, lang, outfile, whichContent)
    7070
    7171if __name__ == '__main__':
     
    7575       
    7676        if options.use_generator:
    77                 Main(options.arch.upper(), options.lang.upper(), options.idisa_file)
     77                Main(options.arch.upper(), options.lang.upper(), options.idisa_file, options.body.lower())
    7878        else:
    7979                print "idisa doesn't know what to do...[no input]"
  • trunk/libgen/Library_Generator/Operation.py

    r1494 r1521  
    44import math
    55
     6import StandardTypes
    67import Utility
    78from Utility import configure
     
    1011        definedOperations = {}
    1112        for opName in allOperations:
     13                #print allOperations[opName]
     14               
    1215                operationTmp = Operation(allOperations[opName], arch)
    1316                definedOperations[operationTmp.fullName] = {}
     
    1821                        #Add this operation object into the operationSet dictionary
    1922                        definedOperations[operation.fullName][fw] = operation
     23                        #ouput debug information
     24                        #DebugOut(operation)
     25       
     26        #sys.exit()
     27       
    2028        return definedOperations
     29
     30def DebugOut(operation):
     31        print "full name=", operation.fullName
     32        print "return_type=", operation.returnType
     33        print "arguments="
     34        for arg in operation.arguments:
     35                print arg.type, arg.name
     36        print "templated arguments="
     37        print operation.templateArg.type, operation.templateArg.name
     38        print "value range="
     39        print operation.valueRange
    2140
    2241class Operation:
     
    3655                self.arguments = []
    3756                self.templateArg = Utility.LibVariable("", "")
    38                 self.ParseOpDescription(opDescription, arch)
     57                self.ParseOpDescription(opDescription["signature"], arch)
    3958                self.fullName = ""
    4059                self.valueRange = {}
     
    4968                #call GetValueRange after we get the value for fullName
    5069                if fw > 0:
    51                         self.valueRange = self.GetValueRange(arch, fw)
    52        
    53         def GetValueRange(self, arch, fw):
    54                 if self.fullName not in configure.ValueRanges:
    55                         return {}
    56                 else:
    57                         valueRange = {}
    58                         for val in configure.ValueRanges[self.fullName]:
    59                                 ranges = configure.ValueRanges[self.fullName][val]
    60                                 minVal = eval(ranges[0].replace("fw", str(fw)).replace("curRegSize", str(configure.RegisterSize[arch])))
    61                                 maxVal = eval(ranges[1].replace("fw", str(fw)).replace("curRegSize", str(configure.RegisterSize[arch])))
    62                                 minVal = minVal if minVal>= -2**31 else -2*31
    63                                 maxVal = maxVal if maxVal<= 2**31-1 else 2**31-1
    64                                 valueRange[val] = {"min":minVal, "max":maxVal}
    65                         return valueRange
     70                        self.PostParsing(opDescription)
     71       
     72        def PostParsing(self, opDescription):
     73                regSize = configure.RegisterSize[self.arch]
     74                return_type = opDescription["return_type"]
     75                args_type = opDescription["args_type"]
     76                int_type = "unsigned_int(64)"
     77               
     78                if StandardTypes.IsSIMDType(return_type):
     79                        self.returnType = configure.Bitblock_type[self.arch]
     80                elif StandardTypes.IsUnsignedIntType(return_type):
     81                        # uint64_t is the standard type for integers throughout the idisa libraries
     82                        self.returnType = StandardTypes.GetUnsignedIntType(int_type, regSize)
     83               
     84                newArgs = []
     85                for i in range(len(self.arguments)):
     86                        arg = self.arguments[i]
     87                        argType = args_type[arg.name]
     88                        if StandardTypes.IsUnsignedIntType(argType):
     89                                (minV, maxV) = Utility.GetMinMax(StandardTypes.GetUnsignedIntType(argType, regSize, self.fieldWidth, False))
     90                                self.valueRange[arg.name] = {"min":minV, "max":maxV}
     91                                argType = StandardTypes.GetUnsignedIntType(int_type, regSize)
     92                        elif StandardTypes.IsRangeType(argType):
     93                                # for non-templated arguments, find an appropriate type
     94                                (minV, maxV) = Utility.GetMinMax(Utility.EvalStr(argType, regSize, self.fieldWidth))
     95                                self.valueRange[arg.name] = {"min":minV, "max":maxV}
     96                                argType = StandardTypes.GetUnsignedIntType(int_type, regSize)
     97                        else:
     98                                #it must be a SIMD_type
     99                                argType = configure.Bitblock_type[self.arch]
     100                        self.arguments[i].type = argType
     101               
     102                if self.opPattern == 1:
     103                        self.templateArg.type = StandardTypes.GetUnsignedIntType(int_type, regSize)
     104                        argType = args_type[self.templateArg.name]
     105                        if StandardTypes.IsUnsignedIntType(argType):
     106                                (minV, maxV) = Utility.GetMinMax(StandardTypes.GetUnsignedIntType(argType, regSize, self.fieldWidth, False))
     107                                self.valueRange[self.templateArg.name] = {"min":minV, "max":maxV}
     108                        elif StandardTypes.IsRangeType(argType):
     109                                (minV, maxV) = Utility.GetMinMax(Utility.EvalStr(argType, regSize, self.fieldWidth))
     110                                self.valueRange[self.templateArg.name] = {"min":minV, "max":maxV}
    66111       
    67112        def ParseOpDescription(self, opDescription, arch):
     
    137182                return cppText
    138183       
    139         def CallingStatementToCppText(self, fw, args=[], templateArg=""):
     184        def CallingStatementToCppText(self, fw, args=[], templateArg="", testingFlag=False):
    140185                #print "in args ", args, " self args", self.arguments, " cur op ", self.name, "curlen= ", len(args)
    141186                if len(args) != len(self.arguments):
     
    146191                if self.opPattern == 1:
    147192                        #simd<fw>::op<val>(...)
    148                         cppText += "<" + str(templateArg) + ">"
     193                        if testingFlag:
     194                                cppText += "<" + "(" + str(self.templateArg.type) + ")" + "(" + str(templateArg) + "UL)" + ">"
     195                        else:
     196                                cppText += "<" + str(templateArg) + ">"
    149197                elif self.opPattern == 2:
    150198                        cppText = self.name
     
    153201               
    154202                cppText += "("
    155                 for arg in args:
    156                         cppText += str(arg) + ", "
     203                for i in range(len(args)):
     204                        arg = args[i]
     205                        if StandardTypes.IsSIMDType(self.arguments[i].type):
     206                                cppText += str(arg) + ", "
     207                        else:
     208                                #cppText += "(" + str(self.arguments[i].type) + ")" + "(" + str(arg) + ")" + ", "
     209                                cppText += str(arg) + ", "
    157210                if len(args) > 0:
    158211                #if there is at least one argument
  • trunk/libgen/Library_Generator/SSE2Instructions.py

    r1458 r1521  
    55        "simd_and":\
    66        {
    7                 "Pattern":"_mm_and_si128(arg1, arg2)",
    8                 "Fws":[1],
    9                 "ReturnType":"SIMD_type",
     7                "signature":"SIMD_type _mm_and_si128(SIMD_type arg1, SIMD_type arg2)",
     8                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     9                "return_type":"SIMD_type",
     10                "fws":[1],
    1011        },
    1112        "simd_andc":\
    1213        {
    13                 "Pattern":"_mm_andnot_si128(arg2, arg1)",
    14                 "Fws":[1],
    15                 "ReturnType":"SIMD_type",
     14                "signature":"SIMD_type _mm_andnot_si128(SIMD_type arg2, SIMD_type arg1)",
     15                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     16                "return_type":"SIMD_type",
     17                "fws":[1],
    1618        },
    1719        "simd_or":\
    1820        {
    19                 "Pattern":"_mm_or_si128(arg1, arg2)",
    20                 "Fws":[1],
    21                 "ReturnType":"SIMD_type",
     21                "signature":"SIMD_type _mm_or_si128(SIMD_type arg1, SIMD_type arg2)",
     22                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     23                "return_type":"SIMD_type",
     24                "fws":[1],
    2225        },
    2326        "simd_xor":\
    2427        {
    25                 "Pattern":"_mm_xor_si128(arg1, arg2)",
    26                 "Fws":[1],
    27                 "ReturnType":"SIMD_type",
     28                "signature":"SIMD_type _mm_xor_si128(SIMD_type arg1, SIMD_type arg2)",
     29                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     30                "return_type":"SIMD_type",
     31                "fws":[1],
    2832        },
    2933        "simd_add":\
    3034        {
    31                 "Pattern":"_mm_add_epi$fw$(arg1, arg2)",
    32                 "Fws":[8, 16, 32, 64],
    33                 "ReturnType":"SIMD_type",
     35                "signature":"SIMD_type _mm_add_epi$fw$(SIMD_type arg1, SIMD_type arg2)",
     36                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     37                "return_type":"SIMD_type",
     38                "fws":[8, 16, 32, 64],
    3439        },
    3540        "simd_sub":\
    3641        {
    37                 "Pattern":"_mm_sub_epi$fw$(arg1, arg2)",
    38                 "Fws":[8, 16, 32, 64],
    39                 "ReturnType":"SIMD_type",
     42                "signature":"SIMD_type _mm_sub_epi$fw$(SIMD_type arg1, SIMD_type arg2)",
     43                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     44                "return_type":"SIMD_type",
     45                "fws":[8, 16, 32, 64],
    4046        },
    4147        "simd_umult":\
    4248        {
    43                 "Pattern":"_mm_mul_epu$fw$(arg1, arg2)",
    44                 "Fws":[32],
    45                 "ReturnType":"SIMD_type",
     49                "signature":"SIMD_type _mm_mul_epu$fw$(SIMD_type arg1, SIMD_type arg2)",
     50                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     51                "return_type":"SIMD_type",
     52                "fws":[32],
    4653        },
    4754        "simd_mult":\
    4855        {
    49                 "Pattern":"_mm_mullo_epi$fw$(arg1, arg2)",
    50                 "Fws":[16],
    51                 "ReturnType":"SIMD_type",
     56                "signature":"SIMD_type _mm_mullo_epi$fw$(SIMD_type arg1, SIMD_type arg2)",
     57                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     58                "return_type":"SIMD_type",
     59                "fws":[16],
    5260        },
    5361        "simd_eq":\
    5462        {
    55                 "Pattern":"_mm_cmpeq_epi$fw$(arg1, arg2)",
    56                 "Fws":[8, 16, 32],
    57                 "ReturnType":"SIMD_type",
     63                "signature":"SIMD_type _mm_cmpeq_epi$fw$(SIMD_type arg1, SIMD_type arg2)",
     64                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     65                "return_type":"SIMD_type",
     66                "fws":[8, 16, 32],
    5867        },
    5968        "simd_gt":\
    6069        {
    61                 "Pattern":"_mm_cmpgt_epi$fw$(arg1, arg2)",
    62                 "Fws":[8, 16, 32],
    63                 "ReturnType":"SIMD_type",
     70                "signature":"SIMD_type _mm_cmpgt_epi$fw$(SIMD_type arg1, SIMD_type arg2)",
     71                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     72                "return_type":"SIMD_type",
     73                "fws":[8, 16, 32],
    6474        },
    6575        "simd_max":\
    6676        {
    67                 "Pattern":"_mm_max_epi$fw$(arg1, arg2)",
    68                 "Fws":[16],
    69                 "ReturnType":"SIMD_type",
     77                "signature":"SIMD_type _mm_max_epi$fw$(SIMD_type arg1, SIMD_type arg2)",
     78                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     79                "return_type":"SIMD_type",
     80                "fws":[16],
    7081        },
    7182        "simd_umax":\
    7283        {
    73                 "Pattern":"_mm_max_epu$fw$(arg1, arg2)",
    74                 "Fws":[8],
    75                 "ReturnType":"SIMD_type",
     84                "signature":"SIMD_type _mm_max_epu$fw$(SIMD_type arg1, SIMD_type arg2)",
     85                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     86                "return_type":"SIMD_type",
     87                "fws":[8],
    7688        },
    7789        "simd_min":\
    7890        {
    79                 "Pattern":"_mm_min_epi$fw$(arg1, arg2)",
    80                 "Fws":[16],
    81                 "ReturnType":"SIMD_type",
     91                "signature":"SIMD_type _mm_min_epi$fw$(SIMD_type arg1, SIMD_type arg2)",
     92                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     93                "return_type":"SIMD_type",
     94                "fws":[16],
    8295        },
    8396        "simd_umin":\
    8497        {
    85                 "Pattern":"_mm_min_epu$fw$(arg1, arg2)",
    86                 "Fws":[8],
    87                 "ReturnType":"SIMD_type",
     98                "signature":"SIMD_type _mm_min_epu$fw$(SIMD_type arg1, SIMD_type arg2)",
     99                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     100                "return_type":"SIMD_type",
     101                "fws":[8],
    88102        },
    89103        "simd_srli":\
    90104        {
    91                 "Pattern":"_mm_srli_epi$fw$(arg1, sh)",
    92                 "Fws":[16, 32, 64],
    93                 "ReturnType":"SIMD_type",
     105                "signature":"SIMD_type _mm_srli_epi$fw$(SIMD_type arg1, int sh)",
     106                "args_type":{"arg1":"SIMD_type", "sh":"signed_int(32)"},
     107                "return_type":"SIMD_type",
     108                "fws":[16, 32, 64],
    94109        },
    95110        "simd_slli":\
    96111        {
    97                 "Pattern":"_mm_slli_epi$fw$(arg1, sh)",
    98                 "Fws":[16, 32, 64],
    99                 "ReturnType":"SIMD_type",
     112                "signature":"SIMD_type _mm_slli_epi$fw$(SIMD_type arg1, int sh)",
     113                "args_type":{"arg1":"SIMD_type", "sh":"signed_int(32)"},
     114                "return_type":"SIMD_type",
     115                "fws":[16, 32, 64],
    100116        },
    101117        "simd_srai":\
    102118        {
    103                 "Pattern":"_mm_srai_epi$fw$(arg1, sh)",
    104                 "Fws":[16, 32],
    105                 "ReturnType":"SIMD_type",
     119                "signature":"SIMD_type _mm_srai_epi$fw$(SIMD_type arg1, int sh)",
     120                "args_type":{"arg1":"SIMD_type", "sh":"signed_int(32)"},
     121                "return_type":"SIMD_type",
     122                "fws":[16, 32],
    106123        },
    107124        "simd_constant":\
    108125        {
    109                 "Pattern":"_mm_set1_epi$fw$(val)",
    110                 "Fws":[8, 16, 32],
    111                 "ReturnType":"SIMD_type",
     126                "signature":"SIMD_type _mm_set1_epi$fw$(int val)",
     127                "args_type":{"val":"signed_int(32)"},
     128                "return_type":"SIMD_type",
     129                "fws":[8, 16, 32],
    112130        },
    113131        "hsimd_packus":\
    114132        {
    115                 "Pattern":"_mm_packus_epi$fw$(arg2, arg1)",
    116                 "Fws":[16],
    117                 "ReturnType":"SIMD_type",
     133                "signature":"SIMD_type _mm_packus_epi$fw$(SIMD_type arg2, SIMD_type arg1)",
     134                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     135                "return_type":"SIMD_type",
     136                "fws":[16],
    118137        },
    119138        "hsimd_packss":\
    120139        {
    121                 "Pattern":"_mm_packs_epi$fw$(arg2, arg1)",
    122                 "Fws":[16, 32],
    123                 "ReturnType":"SIMD_type",
     140                "signature":"SIMD_type _mm_packs_epi$fw$(SIMD_type arg2, SIMD_type arg1)",
     141                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     142                "return_type":"SIMD_type",
     143                "fws":[16, 32],
    124144        },
    125145        "hsimd_signmask":\
    126146        {
    127                 "Pattern":"_mm_movemask_epi$fw$(arg1)",
    128                 "Fws":[8],
    129                 "ReturnType":IntType,
     147                "signature":"int _mm_movemask_epi$fw$(SIMD_type arg1)",
     148                "args_type":{"arg1":"SIMD_type"},
     149                "return_type":"signed_int(32)",
     150                "fws":[8],
    130151        },
    131152        "esimd_mergeh":\
    132153        {
    133                 "Pattern":"_mm_unpackhi_epi$fw$(arg2, arg1)",
    134                 "Fws":[8, 16, 32, 64],
    135                 "ReturnType":"SIMD_type",
     154                "signature":"SIMD_type _mm_unpackhi_epi$fw$(SIMD_type arg2, SIMD_type arg1)",
     155                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     156                "return_type":"SIMD_type",
     157                "fws":[8, 16, 32, 64],
    136158        },
    137159        "esimd_mergel":\
    138160        {
    139                 "Pattern":"_mm_unpacklo_epi$fw$(arg2, arg1)",
    140                 "Fws":[8, 16, 32, 64],
    141                 "ReturnType":"SIMD_type",
     161                "signature":"SIMD_type _mm_unpacklo_epi$fw$(SIMD_type arg2, SIMD_type arg1)",
     162                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     163                "return_type":"SIMD_type",
     164                "fws":[8, 16, 32, 64],
    142165        },
    143166        "mvmd_fill":\
    144167        {
    145                 "Pattern":"_mm_set1_epi$fw$(val1)",
    146                 "Fws":[8, 16, 32],
    147                 "ReturnType":"SIMD_type",
     168                "signature":"SIMD_type _mm_set1_epi$fw$(int val1)",
     169                "args_type":{"val1":"signed_int(32)"},
     170                "return_type":"SIMD_type",
     171                "fws":[8, 16, 32],
    148172        },
    149173        "mvmd_fill4":\
    150174        {
    151                 "Pattern":"_mm_set_epi$fw$(val1, val2, val3, val4)",
    152                 "Fws":[32],
    153                 "ReturnType":"SIMD_type",
     175                "signature":"SIMD_type _mm_set_epi$fw$(int val1, int val2, int val3, int val4)",
     176                "args_type":{"val1":"signed_int(32)", "val2":"signed_int(32)", "val3":"signed_int(32)", "val4":"signed_int(32)"},
     177                "return_type":"SIMD_type",
     178                "fws":[32],
    154179        },
    155180        "mvmd_fill8":\
    156181        {
    157                 "Pattern":"_mm_set_epi$fw$(val1, val2, val3, val4, val5, val6, val7, val8)",
    158                 "Fws":[16],
    159                 "ReturnType":"SIMD_type",
     182                "signature":"SIMD_type _mm_set_epi$fw$(int val1, int val2, int val3, int val4, int val5, int val6, int val7, int val8)",
     183                "args_type":{"val1":"signed_int(32)", "val2":"signed_int(32)", "val3":"signed_int(32)", "val4":"signed_int(32)", \
     184                                        "val5":"signed_int(32)", "val6":"signed_int(32)", "val7":"signed_int(32)", "val8":"signed_int(32)"},
     185                "return_type":"SIMD_type",
     186                "fws":[16],
    160187        },
    161188        "mvmd_fill16":\
    162189        {
    163                 "Pattern":"_mm_set_epi$fw$(val1, val2, val3, val4, val5, val6, val7, val8, val9, val10, val11, val12, val13, val14, val15, val16)",
    164                 "Fws":[8],
    165                 "ReturnType":"SIMD_type",
     190                "signature":"SIMD_type _mm_set_epi$fw$(int val1, int val2, int val3, int val4, int val5, int val6, int val7, int val8, \
     191                                        int val9, int val10, int val11, int val12, int val13, int val14, int val15, int val16)",
     192                "args_type":{"val1":"signed_int(32)", "val2":"signed_int(32)", "val3":"signed_int(32)", "val4":"signed_int(32)", \
     193                                        "val5":"signed_int(32)", "val6":"signed_int(32)", "val7":"signed_int(32)", "val8":"signed_int(32)", \
     194                                        "val9":"signed_int(32)", "val10":"signed_int(32)", "val11":"signed_int(32)", "val12":"signed_int(32)", \
     195                                        "val13":"signed_int(32)", "val14":"signed_int(32)", "val15":"signed_int(32)", "val16":"signed_int(32)"},
     196                "return_type":"SIMD_type",
     197                "fws":[8],
    166198        },
    167199        "mvmd_shufflei":\
    168200        {
    169                 "Pattern":"_mm_shuffle_epi$fw$(arg1, msk)",
    170                 "Fws":[32],
    171                 "ReturnType":"SIMD_type",
    172         },
    173         "bitblock_load_aligned":\
    174         {
    175                 "Pattern":"_mm_load_si$fw$(arg1)",
    176                 "Fws":[128],
    177                 "ReturnType":"SIMD_type",
    178         },
    179         "bitblock_load_unaligned":\
    180         {
    181                 "Pattern":"_mm_loadu_si$fw$(arg1)",
    182                 "Fws":[128],
    183                 "ReturnType":"SIMD_type",
    184         },
    185         "bitblock_store_aligned":\
    186         {
    187                 "Pattern":"_mm_store_si$fw$(arg1, arg2)",
    188                 "Fws":[128],
    189                 "ReturnType":"void",
    190         },
    191         "bitblock_store_unaligned":\
    192         {
    193                 "Pattern":"_mm_storeu_si$fw$(arg1, arg2)",
    194                 "Fws":[128],
    195                 "ReturnType":"void",
     201                "signature":"SIMD_type _mm_shuffle_epi$fw$(SIMD_type arg1, int msk)",
     202                "args_type":{"arg1":"SIMD_type", "msk":"signed_int(32)"},
     203                "return_type":"SIMD_type",
     204                "fws":[32],
    196205        },
    197206        "_mm_sll_epi64":\
    198207        {
    199                 "Pattern":"_mm_sll_epi64(arg1, sh)",
    200                 "Fws":[64],
    201                 "ReturnType":"SIMD_type",
     208                "signature":"SIMD_type _mm_sll_epi64(SIMD_type arg1, SIMD_type sh)",
     209                "args_type":{"arg1":"SIMD_type", "sh":"SIMD_type"},
     210                "return_type":"SIMD_type",
     211                "fws":[64],
    202212        },
    203213        "_mm_slli_si128":\
    204214        {
    205                 "Pattern":"_mm_slli_si128(arg1, arg2)",
    206                 "Fws":[128],
    207                 "ReturnType":"SIMD_type",
     215                "signature":"SIMD_type _mm_slli_si128(SIMD_type arg1, int sh)",
     216                "args_type":{"arg1":"SIMD_type", "sh":"signed_int(32)"},
     217                "return_type":"SIMD_type",
     218                "fws":[128],
    208219        },
    209220        "_mm_srl_epi64":\
    210221        {
    211                 "Pattern":"_mm_srl_epi64(arg1, sh)",
    212                 "Fws":[64],
    213                 "ReturnType":"SIMD_type",
     222                "signature":"SIMD_type _mm_srl_epi64(SIMD_type arg1, SIMD_type sh)",
     223                "args_type":{"arg1":"SIMD_type", "sh":"SIMD_type"},
     224                "return_type":"SIMD_type",
     225                "fws":[64],
    214226        },
    215227        "_mm_srli_si128":\
    216228        {
    217                 "Pattern":"_mm_srli_si128(arg1, arg2)",
    218                 "Fws":[128],
    219                 "ReturnType":"SIMD_type",
     229                "signature":"SIMD_type _mm_srli_si128(SIMD_type arg1, int sh)",
     230                "args_type":{"arg1":"SIMD_type", "sh":"signed_int(32)"},
     231                "return_type":"SIMD_type",
     232                "fws":[128],
    220233        },
    221234        "_mm_set_epi32":\
    222235        {
    223                 "Pattern":"_mm_set_epi32(val)",
    224                 "Fws":[32],
    225                 "ReturnType":"SIMD_type",
     236                "signature":"SIMD_type _mm_set_epi32(int val1, int val2, int val3, int val4)",
     237                "args_type":{"val1":"signed_int(32)", "val2":"signed_int(32)", "val3":"signed_int(32)", "val4":"signed_int(32)"},
     238                "return_type":"SIMD_type",
     239                "fws":[32],
    226240        },
    227241        "_mm_set1_epi32":\
    228242        {
    229                 "Pattern":"_mm_set1_epi32(val)",
    230                 "Fws":[32],
    231                 "ReturnType":"SIMD_type",
     243                "signature":"SIMD_type _mm_set1_epi32(int val1)",
     244                "args_type":{"val1":"signed_int(32)"},
     245                "return_type":"SIMD_type",
     246                "fws":[32],
    232247        },
    233248        "_mm_cvtsi32_si128":\
    234249        {
    235                 "Pattern":"_mm_cvtsi32_si128(val)",
    236                 "Fws":[128],
    237                 "ReturnType":"SIMD_type",
     250                "signature":"SIMD_type _mm_cvtsi32_si128(int val1)",
     251                "args_type":{"val1":"signed_int(32)"},
     252                "return_type":"SIMD_type",
     253                "fws":[128],
    238254        },
    239255        "_mm_shufflehi_epi16":\
    240256        {
    241                 "Pattern":"_mm_shufflehi_epi16(arg1, msk)",
    242                 "Fws":[16],
    243                 "ReturnType":"SIMD_type",
     257                "signature":"SIMD_type _mm_shufflehi_epi16(SIMD_type arg1, int msk)",
     258                "args_type":{"arg1":"SIMD_type", "msk":"signed_int(32)"},
     259                "return_type":"SIMD_type",
     260                "fws":[16],
    244261        },
    245262        "_mm_shufflelo_epi16":\
    246263        {
    247                 "Pattern":"_mm_shufflelo_epi16(arg1, msk)",
    248                 "Fws":[16],
    249                 "ReturnType":"SIMD_type",
     264                "signature":"SIMD_type _mm_shufflelo_epi16(SIMD_type arg1, int msk)",
     265                "args_type":{"arg1":"SIMD_type", "msk":"signed_int(32)"},
     266                "return_type":"SIMD_type",
     267                "fws":[16],
    250268        },
    251269        "_mm_sad_epu8":\
    252270        {
    253                 "Pattern":"_mm_sad_epu8(arg1, arg2)",
    254                 "Fws":[8],
    255                 "ReturnType":"SIMD_type",
     271                "signature":"SIMD_type _mm_sad_epu8(SIMD_type arg1, SIMD_type arg2)",
     272                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     273                "return_type":"SIMD_type",
     274                "fws":[8],
    256275        },
    257276        "_mm_extract_epi16":\
    258277        {
    259                 "Pattern":"_mm_extract_epi16(arg1, pos)",
    260                 "Fws":[16],
    261                 "ReturnType":"SIMD_type",
     278                "signature":"int _mm_extract_epi16(SIMD_type arg1, int pos)",
     279                "args_type":{"arg1":"SIMD_type", "pos":"signed_int(32)"},
     280                "return_type":"signed_int(32)",
     281                "fws":[16],
    262282        },
    263283}
  • trunk/libgen/Library_Generator/SSE3Instructions.py

    r1458 r1521  
    55        "simd_and":\
    66        {
    7                 "Pattern":"_mm_and_si128(arg1, arg2)",
    8                 "Fws":[1],
    9                 "ReturnType":"SIMD_type",
     7                "signature":"SIMD_type _mm_and_si128(SIMD_type arg1, SIMD_type arg2)",
     8                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     9                "return_type":"SIMD_type",
     10                "fws":[1],
    1011        },
    1112        "simd_andc":\
    1213        {
    13                 "Pattern":"_mm_andnot_si128(arg2, arg1)",
    14                 "Fws":[1],
    15                 "ReturnType":"SIMD_type",
     14                "signature":"SIMD_type _mm_andnot_si128(SIMD_type arg2, SIMD_type arg1)",
     15                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     16                "return_type":"SIMD_type",
     17                "fws":[1],
    1618        },
    1719        "simd_or":\
    1820        {
    19                 "Pattern":"_mm_or_si128(arg1, arg2)",
    20                 "Fws":[1],
    21                 "ReturnType":"SIMD_type",
     21                "signature":"SIMD_type _mm_or_si128(SIMD_type arg1, SIMD_type arg2)",
     22                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     23                "return_type":"SIMD_type",
     24                "fws":[1],
    2225        },
    2326        "simd_xor":\
    2427        {
    25                 "Pattern":"_mm_xor_si128(arg1, arg2)",
    26                 "Fws":[1],
    27                 "ReturnType":"SIMD_type",
     28                "signature":"SIMD_type _mm_xor_si128(SIMD_type arg1, SIMD_type arg2)",
     29                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     30                "return_type":"SIMD_type",
     31                "fws":[1],
    2832        },
    2933        "simd_add":\
    3034        {
    31                 "Pattern":"_mm_add_epi$fw$(arg1, arg2)",
    32                 "Fws":[8, 16, 32, 64],
    33                 "ReturnType":"SIMD_type",
     35                "signature":"SIMD_type _mm_add_epi$fw$(SIMD_type arg1, SIMD_type arg2)",
     36                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     37                "return_type":"SIMD_type",
     38                "fws":[8, 16, 32, 64],
    3439        },
    3540        "simd_sub":\
    3641        {
    37                 "Pattern":"_mm_sub_epi$fw$(arg1, arg2)",
    38                 "Fws":[8, 16, 32, 64],
    39                 "ReturnType":"SIMD_type",
     42                "signature":"SIMD_type _mm_sub_epi$fw$(SIMD_type arg1, SIMD_type arg2)",
     43                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     44                "return_type":"SIMD_type",
     45                "fws":[8, 16, 32, 64],
    4046        },
    4147        "simd_umult":\
    4248        {
    43                 "Pattern":"_mm_mul_epu$fw$(arg1, arg2)",
    44                 "Fws":[32],
    45                 "ReturnType":"SIMD_type",
     49                "signature":"SIMD_type _mm_mul_epu$fw$(SIMD_type arg1, SIMD_type arg2)",
     50                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     51                "return_type":"SIMD_type",
     52                "fws":[32],
    4653        },
    4754        "simd_mult":\
    4855        {
    49                 "Pattern":"_mm_mullo_epi$fw$(arg1, arg2)",
    50                 "Fws":[16],
    51                 "ReturnType":"SIMD_type",
     56                "signature":"SIMD_type _mm_mullo_epi$fw$(SIMD_type arg1, SIMD_type arg2)",
     57                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     58                "return_type":"SIMD_type",
     59                "fws":[16],
    5260        },
    5361        "simd_eq":\
    5462        {
    55                 "Pattern":"_mm_cmpeq_epi$fw$(arg1, arg2)",
    56                 "Fws":[8, 16, 32],
    57                 "ReturnType":"SIMD_type",
     63                "signature":"SIMD_type _mm_cmpeq_epi$fw$(SIMD_type arg1, SIMD_type arg2)",
     64                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     65                "return_type":"SIMD_type",
     66                "fws":[8, 16, 32],
    5867        },
    5968        "simd_gt":\
    6069        {
    61                 "Pattern":"_mm_cmpgt_epi$fw$(arg1, arg2)",
    62                 "Fws":[8, 16, 32],
    63                 "ReturnType":"SIMD_type",
     70                "signature":"SIMD_type _mm_cmpgt_epi$fw$(SIMD_type arg1, SIMD_type arg2)",
     71                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     72                "return_type":"SIMD_type",
     73                "fws":[8, 16, 32],
    6474        },
    6575        "simd_max":\
    6676        {
    67                 "Pattern":"_mm_max_epi$fw$(arg1, arg2)",
    68                 "Fws":[16],
    69                 "ReturnType":"SIMD_type",
     77                "signature":"SIMD_type _mm_max_epi$fw$(SIMD_type arg1, SIMD_type arg2)",
     78                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     79                "return_type":"SIMD_type",
     80                "fws":[16],
    7081        },
    7182        "simd_umax":\
    7283        {
    73                 "Pattern":"_mm_max_epu$fw$(arg1, arg2)",
    74                 "Fws":[8],
    75                 "ReturnType":"SIMD_type",
     84                "signature":"SIMD_type _mm_max_epu$fw$(SIMD_type arg1, SIMD_type arg2)",
     85                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     86                "return_type":"SIMD_type",
     87                "fws":[8],
    7688        },
    7789        "simd_min":\
    7890        {
    79                 "Pattern":"_mm_min_epi$fw$(arg1, arg2)",
    80                 "Fws":[16],
    81                 "ReturnType":"SIMD_type",
     91                "signature":"SIMD_type _mm_min_epi$fw$(SIMD_type arg1, SIMD_type arg2)",
     92                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     93                "return_type":"SIMD_type",
     94                "fws":[16],
    8295        },
    8396        "simd_umin":\
    8497        {
    85                 "Pattern":"_mm_min_epu$fw$(arg1, arg2)",
    86                 "Fws":[8],
    87                 "ReturnType":"SIMD_type",
     98                "signature":"SIMD_type _mm_min_epu$fw$(SIMD_type arg1, SIMD_type arg2)",
     99                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     100                "return_type":"SIMD_type",
     101                "fws":[8],
    88102        },
    89103        "simd_srli":\
    90104        {
    91                 "Pattern":"_mm_srli_epi$fw$(arg1, sh)",
    92                 "Fws":[16, 32, 64],
    93                 "ReturnType":"SIMD_type",
     105                "signature":"SIMD_type _mm_srli_epi$fw$(SIMD_type arg1, int sh)",
     106                "args_type":{"arg1":"SIMD_type", "sh":"signed_int(32)"},
     107                "return_type":"SIMD_type",
     108                "fws":[16, 32, 64],
    94109        },
    95110        "simd_slli":\
    96111        {
    97                 "Pattern":"_mm_slli_epi$fw$(arg1, sh)",
    98                 "Fws":[16, 32, 64],
    99                 "ReturnType":"SIMD_type",
     112                "signature":"SIMD_type _mm_slli_epi$fw$(SIMD_type arg1, int sh)",
     113                "args_type":{"arg1":"SIMD_type", "sh":"signed_int(32)"},
     114                "return_type":"SIMD_type",
     115                "fws":[16, 32, 64],
    100116        },
    101117        "simd_srai":\
    102118        {
    103                 "Pattern":"_mm_srai_epi$fw$(arg1, sh)",
    104                 "Fws":[16, 32],
    105                 "ReturnType":"SIMD_type",
     119                "signature":"SIMD_type _mm_srai_epi$fw$(SIMD_type arg1, int sh)",
     120                "args_type":{"arg1":"SIMD_type", "sh":"signed_int(32)"},
     121                "return_type":"SIMD_type",
     122                "fws":[16, 32],
    106123        },
    107124        "simd_constant":\
    108125        {
    109                 "Pattern":"_mm_set1_epi$fw$(val)",
    110                 "Fws":[8, 16, 32],
    111                 "ReturnType":"SIMD_type",
     126                "signature":"SIMD_type _mm_set1_epi$fw$(int val)",
     127                "args_type":{"val":"signed_int(32)"},
     128                "return_type":"SIMD_type",
     129                "fws":[8, 16, 32],
    112130        },
    113131        "hsimd_packus":\
    114132        {
    115                 "Pattern":"_mm_packus_epi$fw$(arg2, arg1)",
    116                 "Fws":[16],
    117                 "ReturnType":"SIMD_type",
     133                "signature":"SIMD_type _mm_packus_epi$fw$(SIMD_type arg2, SIMD_type arg1)",
     134                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     135                "return_type":"SIMD_type",
     136                "fws":[16],
    118137        },
    119138        "hsimd_packss":\
    120139        {
    121                 "Pattern":"_mm_packs_epi$fw$(arg2, arg1)",
    122                 "Fws":[16, 32],
    123                 "ReturnType":"SIMD_type",
     140                "signature":"SIMD_type _mm_packs_epi$fw$(SIMD_type arg2, SIMD_type arg1)",
     141                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     142                "return_type":"SIMD_type",
     143                "fws":[16, 32],
    124144        },
    125145        "hsimd_signmask":\
    126146        {
    127                 "Pattern":"_mm_movemask_epi$fw$(arg1)",
    128                 "Fws":[8],
    129                 "ReturnType":IntType,
     147                "signature":"int _mm_movemask_epi$fw$(SIMD_type arg1)",
     148                "args_type":{"arg1":"SIMD_type"},
     149                "return_type":"signed_int(32)",
     150                "fws":[8],
    130151        },
    131152        "esimd_mergeh":\
    132153        {
    133                 "Pattern":"_mm_unpackhi_epi$fw$(arg2, arg1)",
    134                 "Fws":[8, 16, 32, 64],
    135                 "ReturnType":"SIMD_type",
     154                "signature":"SIMD_type _mm_unpackhi_epi$fw$(SIMD_type arg2, SIMD_type arg1)",
     155                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     156                "return_type":"SIMD_type",
     157                "fws":[8, 16, 32, 64],
    136158        },
    137159        "esimd_mergel":\
    138160        {
    139                 "Pattern":"_mm_unpacklo_epi$fw$(arg2, arg1)",
    140                 "Fws":[8, 16, 32, 64],
    141                 "ReturnType":"SIMD_type",
     161                "signature":"SIMD_type _mm_unpacklo_epi$fw$(SIMD_type arg2, SIMD_type arg1)",
     162                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     163                "return_type":"SIMD_type",
     164                "fws":[8, 16, 32, 64],
    142165        },
    143166        "mvmd_fill":\
    144167        {
    145                 "Pattern":"_mm_set1_epi$fw$(val1)",
    146                 "Fws":[8, 16, 32],
    147                 "ReturnType":"SIMD_type",
     168                "signature":"SIMD_type _mm_set1_epi$fw$(int val1)",
     169                "args_type":{"val1":"signed_int(32)"},
     170                "return_type":"SIMD_type",
     171                "fws":[8, 16, 32],
    148172        },
    149173        "mvmd_fill4":\
    150174        {
    151                 "Pattern":"_mm_set_epi$fw$(val1, val2, val3, val4)",
    152                 "Fws":[32],
    153                 "ReturnType":"SIMD_type",
     175                "signature":"SIMD_type _mm_set_epi$fw$(int val1, int val2, int val3, int val4)",
     176                "args_type":{"val1":"signed_int(32)", "val2":"signed_int(32)", "val3":"signed_int(32)", "val4":"signed_int(32)"},
     177                "return_type":"SIMD_type",
     178                "fws":[32],
    154179        },
    155180        "mvmd_fill8":\
    156181        {
    157                 "Pattern":"_mm_set_epi$fw$(val1, val2, val3, val4, val5, val6, val7, val8)",
    158                 "Fws":[16],
    159                 "ReturnType":"SIMD_type",
     182                "signature":"SIMD_type _mm_set_epi$fw$(int val1, int val2, int val3, int val4, int val5, int val6, int val7, int val8)",
     183                "args_type":{"val1":"signed_int(32)", "val2":"signed_int(32)", "val3":"signed_int(32)", "val4":"signed_int(32)", \
     184                                        "val5":"signed_int(32)", "val6":"signed_int(32)", "val7":"signed_int(32)", "val8":"signed_int(32)"},
     185                "return_type":"SIMD_type",
     186                "fws":[16],
    160187        },
    161188        "mvmd_fill16":\
    162189        {
    163                 "Pattern":"_mm_set_epi$fw$(val1, val2, val3, val4, val5, val6, val7, val8, val9, val10, val11, val12, val13, val14, val15, val16)",
    164                 "Fws":[8],
    165                 "ReturnType":"SIMD_type",
     190                "signature":"SIMD_type _mm_set_epi$fw$(int val1, int val2, int val3, int val4, int val5, int val6, int val7, int val8, \
     191                                        int val9, int val10, int val11, int val12, int val13, int val14, int val15, int val16)",
     192                "args_type":{"val1":"signed_int(32)", "val2":"signed_int(32)", "val3":"signed_int(32)", "val4":"signed_int(32)", \
     193                                        "val5":"signed_int(32)", "val6":"signed_int(32)", "val7":"signed_int(32)", "val8":"signed_int(32)", \
     194                                        "val9":"signed_int(32)", "val10":"signed_int(32)", "val11":"signed_int(32)", "val12":"signed_int(32)", \
     195                                        "val13":"signed_int(32)", "val14":"signed_int(32)", "val15":"signed_int(32)", "val16":"signed_int(32)"},
     196                "return_type":"SIMD_type",
     197                "fws":[8],
    166198        },
    167199        "mvmd_shufflei":\
    168200        {
    169                 "Pattern":"_mm_shuffle_epi$fw$(arg1, msk)",
    170                 "Fws":[32],
    171                 "ReturnType":"SIMD_type",
    172         },
    173         "bitblock_load_aligned":\
    174         {
    175                 "Pattern":"_mm_load_si$fw$(arg1)",
    176                 "Fws":[128],
    177                 "ReturnType":"SIMD_type",
    178         },
    179         "bitblock_load_unaligned":\
    180         {
    181                 "Pattern":"_mm_lddqu_si$fw$ (arg1)",
    182                 "Fws":[128],
    183                 "ReturnType":"SIMD_type",
    184         },
    185         "bitblock_store_aligned":\
    186         {
    187                 "Pattern":"_mm_store_si$fw$(arg1, arg2)",
    188                 "Fws":[128],
    189                 "ReturnType":"void",
    190         },
    191         "bitblock_store_unaligned":\
    192         {
    193                 "Pattern":"_mm_storeu_si$fw$(arg1, arg2)",
    194                 "Fws":[128],
    195                 "ReturnType":"void",
     201                "signature":"SIMD_type _mm_shuffle_epi$fw$(SIMD_type arg1, int msk)",
     202                "args_type":{"arg1":"SIMD_type", "msk":"signed_int(32)"},
     203                "return_type":"SIMD_type",
     204                "fws":[32],
    196205        },
    197206        "_mm_sll_epi64":\
    198207        {
    199                 "Pattern":"_mm_sll_epi64(arg1, sh)",
    200                 "Fws":[64],
    201                 "ReturnType":"SIMD_type",
     208                "signature":"SIMD_type _mm_sll_epi64(SIMD_type arg1, SIMD_type sh)",
     209                "args_type":{"arg1":"SIMD_type", "sh":"SIMD_type"},
     210                "return_type":"SIMD_type",
     211                "fws":[64],
    202212        },
    203213        "_mm_slli_si128":\
    204214        {
    205                 "Pattern":"_mm_slli_si128(arg1, arg2)",
    206                 "Fws":[128],
    207                 "ReturnType":"SIMD_type",
     215                "signature":"SIMD_type _mm_slli_si128(SIMD_type arg1, int sh)",
     216                "args_type":{"arg1":"SIMD_type", "sh":"signed_int(32)"},
     217                "return_type":"SIMD_type",
     218                "fws":[128],
    208219        },
    209220        "_mm_srl_epi64":\
    210221        {
    211                 "Pattern":"_mm_srl_epi64(arg1, sh)",
    212                 "Fws":[64],
    213                 "ReturnType":"SIMD_type",
     222                "signature":"SIMD_type _mm_srl_epi64(SIMD_type arg1, SIMD_type sh)",
     223                "args_type":{"arg1":"SIMD_type", "sh":"SIMD_type"},
     224                "return_type":"SIMD_type",
     225                "fws":[64],
    214226        },
    215227        "_mm_srli_si128":\
    216228        {
    217                 "Pattern":"_mm_srli_si128(arg1, arg2)",
    218                 "Fws":[128],
    219                 "ReturnType":"SIMD_type",
     229                "signature":"SIMD_type _mm_srli_si128(SIMD_type arg1, int sh)",
     230                "args_type":{"arg1":"SIMD_type", "sh":"signed_int(32)"},
     231                "return_type":"SIMD_type",
     232                "fws":[128],
    220233        },
    221234        "_mm_set_epi32":\
    222235        {
    223                 "Pattern":"_mm_set_epi32(val)",
    224                 "Fws":[32],
    225                 "ReturnType":"SIMD_type",
     236                "signature":"SIMD_type _mm_set_epi32(int val1, int val2, int val3, int val4)",
     237                "args_type":{"val1":"signed_int(32)", "val2":"signed_int(32)", "val3":"signed_int(32)", "val4":"signed_int(32)"},
     238                "return_type":"SIMD_type",
     239                "fws":[32],
    226240        },
    227241        "_mm_set1_epi32":\
    228242        {
    229                 "Pattern":"_mm_set1_epi32(val)",
    230                 "Fws":[32],
    231                 "ReturnType":"SIMD_type",
     243                "signature":"SIMD_type _mm_set1_epi32(int val1)",
     244                "args_type":{"val1":"signed_int(32)"},
     245                "return_type":"SIMD_type",
     246                "fws":[32],
    232247        },
    233248        "_mm_cvtsi32_si128":\
    234249        {
    235                 "Pattern":"_mm_cvtsi32_si128(val)",
    236                 "Fws":[128],
    237                 "ReturnType":"SIMD_type",
     250                "signature":"SIMD_type _mm_cvtsi32_si128(int val1)",
     251                "args_type":{"val1":"signed_int(32)"},
     252                "return_type":"SIMD_type",
     253                "fws":[128],
    238254        },
    239255        "_mm_shufflehi_epi16":\
    240256        {
    241                 "Pattern":"_mm_shufflehi_epi16(arg1, msk)",
    242                 "Fws":[16],
    243                 "ReturnType":"SIMD_type",
     257                "signature":"SIMD_type _mm_shufflehi_epi16(SIMD_type arg1, int msk)",
     258                "args_type":{"arg1":"SIMD_type", "msk":"signed_int(32)"},
     259                "return_type":"SIMD_type",
     260                "fws":[16],
    244261        },
    245262        "_mm_shufflelo_epi16":\
    246263        {
    247                 "Pattern":"_mm_shufflelo_epi16(arg1, msk)",
    248                 "Fws":[16],
    249                 "ReturnType":"SIMD_type",
     264                "signature":"SIMD_type _mm_shufflelo_epi16(SIMD_type arg1, int msk)",
     265                "args_type":{"arg1":"SIMD_type", "msk":"signed_int(32)"},
     266                "return_type":"SIMD_type",
     267                "fws":[16],
    250268        },
    251269        "_mm_sad_epu8":\
    252270        {
    253                 "Pattern":"_mm_sad_epu8(arg1, arg2)",
    254                 "Fws":[8],
    255                 "ReturnType":"SIMD_type",
     271                "signature":"SIMD_type _mm_sad_epu8(SIMD_type arg1, SIMD_type arg2)",
     272                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     273                "return_type":"SIMD_type",
     274                "fws":[8],
    256275        },
    257276        "_mm_extract_epi16":\
    258277        {
    259                 "Pattern":"_mm_extract_epi16(arg1, pos)",
    260                 "Fws":[16],
    261                 "ReturnType":"SIMD_type",
     278                "signature":"int _mm_extract_epi16(SIMD_type arg1, int pos)",
     279                "args_type":{"arg1":"SIMD_type", "pos":"signed_int(32)"},
     280                "return_type":"signed_int(32)",
     281                "fws":[16],
    262282        },
    263283}
  • trunk/libgen/Library_Generator/SSE4_1Instructions.py

    r1494 r1521  
    55        "simd_and":\
    66        {
    7                 "Pattern":"_mm_and_si128(arg1, arg2)",
    8                 "Fws":[1],
    9                 "ReturnType":"SIMD_type",
     7                "signature":"SIMD_type _mm_and_si128(SIMD_type arg1, SIMD_type arg2)",
     8                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     9                "return_type":"SIMD_type",
     10                "fws":[1],
    1011        },
    1112        "simd_andc":\
    1213        {
    13                 "Pattern":"_mm_andnot_si128(arg2, arg1)",
    14                 "Fws":[1],
    15                 "ReturnType":"SIMD_type",
     14                "signature":"SIMD_type _mm_andnot_si128(SIMD_type arg2, SIMD_type arg1)",
     15                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     16                "return_type":"SIMD_type",
     17                "fws":[1],
    1618        },
    1719        "simd_or":\
    1820        {
    19                 "Pattern":"_mm_or_si128(arg1, arg2)",
    20                 "Fws":[1],
    21                 "ReturnType":"SIMD_type",
     21                "signature":"SIMD_type _mm_or_si128(SIMD_type arg1, SIMD_type arg2)",
     22                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     23                "return_type":"SIMD_type",
     24                "fws":[1],
    2225        },
    2326        "simd_xor":\
    2427        {
    25                 "Pattern":"_mm_xor_si128(arg1, arg2)",
    26                 "Fws":[1],
    27                 "ReturnType":"SIMD_type",
     28                "signature":"SIMD_type _mm_xor_si128(SIMD_type arg1, SIMD_type arg2)",
     29                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     30                "return_type":"SIMD_type",
     31                "fws":[1],
    2832        },
    2933        "simd_add":\
    3034        {
    31                 "Pattern":"_mm_add_epi$fw$(arg1, arg2)",
    32                 "Fws":[8, 16, 32, 64],
    33                 "ReturnType":"SIMD_type",
     35                "signature":"SIMD_type _mm_add_epi$fw$(SIMD_type arg1, SIMD_type arg2)",
     36                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     37                "return_type":"SIMD_type",
     38                "fws":[8, 16, 32, 64],
    3439        },
    3540        "simd_sub":\
    3641        {
    37                 "Pattern":"_mm_sub_epi$fw$(arg1, arg2)",
    38                 "Fws":[8, 16, 32, 64],
    39                 "ReturnType":"SIMD_type",
     42                "signature":"SIMD_type _mm_sub_epi$fw$(SIMD_type arg1, SIMD_type arg2)",
     43                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     44                "return_type":"SIMD_type",
     45                "fws":[8, 16, 32, 64],
    4046        },
    4147        "simd_umult":\
    4248        {
    43                 "Pattern":"_mm_mul_epu$fw$(arg1, arg2)",
    44                 "Fws":[32],
    45                 "ReturnType":"SIMD_type",
     49                "signature":"SIMD_type _mm_mul_epu$fw$(SIMD_type arg1, SIMD_type arg2)",
     50                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     51                "return_type":"SIMD_type",
     52                "fws":[32],
    4653        },
    4754        "simd_mult":\
    4855        {
    49                 "Pattern":"_mm_mullo_epi$fw$(arg1, arg2)",
    50                 "Fws":[16, 32],
    51                 "ReturnType":"SIMD_type",
     56                "signature":"SIMD_type _mm_mullo_epi$fw$(SIMD_type arg1, SIMD_type arg2)",
     57                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     58                "return_type":"SIMD_type",
     59                "fws":[16, 32],
    5260        },
    5361        "simd_eq":\
    5462        {
    55                 "Pattern":"_mm_cmpeq_epi$fw$(arg1, arg2)",
    56                 "Fws":[8, 16, 32, 64],
    57                 "ReturnType":"SIMD_type",
     63                "signature":"SIMD_type _mm_cmpeq_epi$fw$(SIMD_type arg1, SIMD_type arg2)",
     64                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     65                "return_type":"SIMD_type",
     66                "fws":[8, 16, 32, 64],
    5867        },
    5968        "simd_gt":\
    6069        {
    61                 "Pattern":"_mm_cmpgt_epi$fw$(arg1, arg2)",
    62                 "Fws":[8, 16, 32],
    63                 "ReturnType":"SIMD_type",
     70                "signature":"SIMD_type _mm_cmpgt_epi$fw$(SIMD_type arg1, SIMD_type arg2)",
     71                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     72                "return_type":"SIMD_type",
     73                "fws":[8, 16, 32],
    6474        },
    6575        "simd_max":\
    6676        {
    67                 "Pattern":"_mm_max_epi$fw$(arg1, arg2)",
    68                 "Fws":[8, 16, 32],
    69                 "ReturnType":"SIMD_type",
     77                "signature":"SIMD_type _mm_max_epi$fw$(SIMD_type arg1, SIMD_type arg2)",
     78                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     79                "return_type":"SIMD_type",
     80                "fws":[8, 16, 32],
    7081        },
    7182        "simd_umax":\
    7283        {
    73                 "Pattern":"_mm_max_epu$fw$(arg1, arg2)",
    74                 "Fws":[8, 16, 32],
    75                 "ReturnType":"SIMD_type",
     84                "signature":"SIMD_type _mm_max_epu$fw$(SIMD_type arg1, SIMD_type arg2)",
     85                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     86                "return_type":"SIMD_type",
     87                "fws":[8, 16, 32],
    7688        },
    7789        "simd_min":\
    7890        {
    79                 "Pattern":"_mm_min_epi$fw$(arg1, arg2)",
    80                 "Fws":[8, 16, 32],
    81                 "ReturnType":"SIMD_type",
     91                "signature":"SIMD_type _mm_min_epi$fw$(SIMD_type arg1, SIMD_type arg2)",
     92                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     93                "return_type":"SIMD_type",
     94                "fws":[8, 16, 32],
    8295        },
    8396        "simd_umin":\
    8497        {
    85                 "Pattern":"_mm_min_epu$fw$(arg1, arg2)",
    86                 "Fws":[8, 16, 32],
    87                 "ReturnType":"SIMD_type",
     98                "signature":"SIMD_type _mm_min_epu$fw$(SIMD_type arg1, SIMD_type arg2)",
     99                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     100                "return_type":"SIMD_type",
     101                "fws":[8, 16, 32],
    88102        },
    89103        "simd_srli":\
    90104        {
    91                 "Pattern":"_mm_srli_epi$fw$(arg1, sh)",
    92                 "Fws":[16, 32, 64],
    93                 "ReturnType":"SIMD_type",
     105                "signature":"SIMD_type _mm_srli_epi$fw$(SIMD_type arg1, int sh)",
     106                "args_type":{"arg1":"SIMD_type", "sh":"signed_int(32)"},
     107                "return_type":"SIMD_type",
     108                "fws":[16, 32, 64],
    94109        },
    95110        "simd_slli":\
    96111        {
    97                 "Pattern":"_mm_slli_epi$fw$(arg1, sh)",
    98                 "Fws":[16, 32, 64],
    99                 "ReturnType":"SIMD_type",
     112                "signature":"SIMD_type _mm_slli_epi$fw$(SIMD_type arg1, int sh)",
     113                "args_type":{"arg1":"SIMD_type", "sh":"signed_int(32)"},
     114                "return_type":"SIMD_type",
     115                "fws":[16, 32, 64],
    100116        },
    101117        "simd_srai":\
    102118        {
    103                 "Pattern":"_mm_srai_epi$fw$(arg1, sh)",
    104                 "Fws":[16, 32],
    105                 "ReturnType":"SIMD_type",
     119                "signature":"SIMD_type _mm_srai_epi$fw$(SIMD_type arg1, int sh)",
     120                "args_type":{"arg1":"SIMD_type", "sh":"signed_int(32)"},
     121                "return_type":"SIMD_type",
     122                "fws":[16, 32],
    106123        },
    107124        "simd_constant":\
    108125        {
    109                 "Pattern":"_mm_set1_epi$fw$(val)",
    110                 "Fws":[8, 16, 32],
    111                 "ReturnType":"SIMD_type",
     126                "signature":"SIMD_type _mm_set1_epi$fw$(int val)",
     127                "args_type":{"val":"signed_int(32)"},
     128                "return_type":"SIMD_type",
     129                "fws":[8, 16, 32],
    112130        },
    113131        "simd_abs":\
    114132        {
    115                 "Pattern":"_mm_abs_epi$fw$(arg1)",
    116                 "Fws":[8, 16, 32],
    117                 "ReturnType":"SIMD_type",
     133                "signature":"SIMD_type _mm_abs_epi$fw$(SIMD_type arg1)",
     134                "args_type":{"arg1":"SIMD_type"},
     135                "return_type":"SIMD_type",
     136                "fws":[8, 16, 32],
    118137        },
    119138        "hsimd_add_hl":\
    120139        {
    121                 "Pattern":"_mm_hadd_epi$fw/2$(arg2, arg1)",
    122                 "Fws":[32, 64],
    123                 "ReturnType":"SIMD_type",       
     140                "signature":"SIMD_type _mm_hadd_epi$fw/2$(SIMD_type arg2, SIMD_type arg1)",
     141                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     142                "return_type":"SIMD_type",
     143                "fws":[32, 64],
    124144        },
    125145        "hsimd_packus":\
    126146        {
    127                 "Pattern":"_mm_packus_epi$fw$(arg2, arg1)",
    128                 "Fws":[16, 32],
    129                 "ReturnType":"SIMD_type",
     147                "signature":"SIMD_type _mm_packus_epi$fw$(SIMD_type arg2, SIMD_type arg1)",
     148                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     149                "return_type":"SIMD_type",
     150                "fws":[16, 32],
    130151        },
    131152        "hsimd_packss":\
    132153        {
    133                 "Pattern":"_mm_packs_epi$fw$(arg2, arg1)",
    134                 "Fws":[16, 32],
    135                 "ReturnType":"SIMD_type",
     154                "signature":"SIMD_type _mm_packs_epi$fw$(SIMD_type arg2, SIMD_type arg1)",
     155                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     156                "return_type":"SIMD_type",
     157                "fws":[16, 32],
    136158        },
    137159        "hsimd_signmask":\
    138160        {
    139                 "Pattern":"_mm_movemask_epi$fw$(arg1)",
    140                 "Fws":[8],
    141                 "ReturnType":IntType,
     161                "signature":"int _mm_movemask_epi$fw$(SIMD_type arg1)",
     162                "args_type":{"arg1":"SIMD_type"},
     163                "return_type":"signed_int(32)",
     164                "fws":[8],
    142165        },
    143166        "esimd_mergeh":\
    144167        {
    145                 "Pattern":"_mm_unpackhi_epi$fw$(arg2, arg1)",
    146                 "Fws":[8, 16, 32, 64],
    147                 "ReturnType":"SIMD_type",
     168                "signature":"SIMD_type _mm_unpackhi_epi$fw$(SIMD_type arg2, SIMD_type arg1)",
     169                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     170                "return_type":"SIMD_type",
     171                "fws":[8, 16, 32, 64],
    148172        },
    149173        "esimd_mergel":\
    150174        {
    151                 "Pattern":"_mm_unpacklo_epi$fw$(arg2, arg1)",
    152                 "Fws":[8, 16, 32, 64],
    153                 "ReturnType":"SIMD_type",
     175                "signature":"SIMD_type _mm_unpacklo_epi$fw$(SIMD_type arg2, SIMD_type arg1)",
     176                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     177                "return_type":"SIMD_type",
     178                "fws":[8, 16, 32, 64],
    154179        },
    155180        "mvmd_fill":\
    156181        {
    157                 "Pattern":"_mm_set1_epi$fw$(val1)",
    158                 "Fws":[8, 16, 32],
    159                 "ReturnType":"SIMD_type",
     182                "signature":"SIMD_type _mm_set1_epi$fw$(int val1)",
     183                "args_type":{"val1":"signed_int(32)"},
     184                "return_type":"SIMD_type",
     185                "fws":[8, 16, 32],
    160186        },
    161187        "mvmd_fill4":\
    162188        {
    163                 "Pattern":"_mm_set_epi$fw$(val1, val2, val3, val4)",
    164                 "Fws":[32],
    165                 "ReturnType":"SIMD_type",
     189                "signature":"SIMD_type _mm_set_epi$fw$(int val1, int val2, int val3, int val4)",
     190                "args_type":{"val1":"signed_int(32)", "val2":"signed_int(32)", "val3":"signed_int(32)", "val4":"signed_int(32)"},
     191                "return_type":"SIMD_type",
     192                "fws":[32],
    166193        },
    167194        "mvmd_fill8":\
    168195        {
    169                 "Pattern":"_mm_set_epi$fw$(val1, val2, val3, val4, val5, val6, val7, val8)",
    170                 "Fws":[16],
    171                 "ReturnType":"SIMD_type",
     196                "signature":"SIMD_type _mm_set_epi$fw$(int val1, int val2, int val3, int val4, int val5, int val6, int val7, int val8)",
     197                "args_type":{"val1":"signed_int(32)", "val2":"signed_int(32)", "val3":"signed_int(32)", "val4":"signed_int(32)", \
     198                                        "val5":"signed_int(32)", "val6":"signed_int(32)", "val7":"signed_int(32)", "val8":"signed_int(32)"},
     199                "return_type":"SIMD_type",
     200                "fws":[16],
    172201        },
    173202        "mvmd_fill16":\
    174203        {
    175                 "Pattern":"_mm_set_epi$fw$(val1, val2, val3, val4, val5, val6, val7, val8, val9, val10, val11, val12, val13, val14, val15, val16)",
    176                 "Fws":[8],
    177                 "ReturnType":"SIMD_type",
     204                "signature":"SIMD_type _mm_set_epi$fw$(int val1, int val2, int val3, int val4, int val5, int val6, int val7, int val8, \
     205                                        int val9, int val10, int val11, int val12, int val13, int val14, int val15, int val16)",
     206                "args_type":{"val1":"signed_int(32)", "val2":"signed_int(32)", "val3":"signed_int(32)", "val4":"signed_int(32)", \
     207                                        "val5":"signed_int(32)", "val6":"signed_int(32)", "val7":"signed_int(32)", "val8":"signed_int(32)", \
     208                                        "val9":"signed_int(32)", "val10":"signed_int(32)", "val11":"signed_int(32)", "val12":"signed_int(32)", \
     209                                        "val13":"signed_int(32)", "val14":"signed_int(32)", "val15":"signed_int(32)", "val16":"signed_int(32)"},
     210                "return_type":"SIMD_type",
     211                "fws":[8],
    178212        },
    179213        "mvmd_shufflei":\
    180214        {
    181                 "Pattern":"_mm_shuffle_epi$fw$(arg1, msk)",
    182                 "Fws":[32],
    183                 "ReturnType":"SIMD_type",
     215                "signature":"SIMD_type _mm_shuffle_epi$fw$(SIMD_type arg1, int msk)",
     216                "args_type":{"arg1":"SIMD_type", "msk":"signed_int(32)"},
     217                "return_type":"SIMD_type",
     218                "fws":[32],
    184219        },
    185220        "mvmd_shuffle":\
    186221        {
    187                 "Pattern":"_mm_shuffle_epi$fw$(arg1, arg2)",
    188                 "Fws":[8],
    189                 "ReturnType":"SIMD_type",
    190         },
    191         "bitblock_load_aligned":\
    192         {
    193                 "Pattern":"_mm_load_si$fw$(arg1)",
    194                 "Fws":[128],
    195                 "ReturnType":"SIMD_type",
    196         },
    197         "bitblock_load_unaligned":\
    198         {
    199                 "Pattern":"_mm_lddqu_si$fw$ (arg1)",
    200                 "Fws":[128],
    201                 "ReturnType":"SIMD_type",
    202         },
    203         "bitblock_store_aligned":\
    204         {
    205                 "Pattern":"_mm_store_si$fw$(arg1, arg2)",
    206                 "Fws":[128],
    207                 "ReturnType":"void",
    208         },
    209         "bitblock_store_unaligned":\
    210         {
    211                 "Pattern":"_mm_storeu_si$fw$(arg1, arg2)",
    212                 "Fws":[128],
    213                 "ReturnType":"void",
     222                "signature":"SIMD_type _mm_shuffle_epi$fw$(SIMD_type arg1, SIMD_type arg2)",
     223                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     224                "return_type":"SIMD_type",
     225                "fws":[8],
    214226        },
    215227        "_mm_sll_epi64":\
    216228        {
    217                 "Pattern":"_mm_sll_epi64(arg1, sh)",
    218                 "Fws":[64],
    219                 "ReturnType":"SIMD_type",
     229                "signature":"SIMD_type _mm_sll_epi64(SIMD_type arg1, SIMD_type sh)",
     230                "args_type":{"arg1":"SIMD_type", "sh":"SIMD_type"},
     231                "return_type":"SIMD_type",
     232                "fws":[64],
    220233        },
    221234        "_mm_slli_si128":\
    222235        {
    223                 "Pattern":"_mm_slli_si128(arg1, arg2)",
    224                 "Fws":[128],
    225                 "ReturnType":"SIMD_type",
     236                "signature":"SIMD_type _mm_slli_si128(SIMD_type arg1, int sh)",
     237                "args_type":{"arg1":"SIMD_type", "sh":"signed_int(32)"},
     238                "return_type":"SIMD_type",
     239                "fws":[128],
    226240        },
    227241        "_mm_srl_epi64":\
    228242        {
    229                 "Pattern":"_mm_srl_epi64(arg1, sh)",
    230                 "Fws":[64],
    231                 "ReturnType":"SIMD_type",
     243                "signature":"SIMD_type _mm_srl_epi64(SIMD_type arg1, SIMD_type sh)",
     244                "args_type":{"arg1":"SIMD_type", "sh":"SIMD_type"},
     245                "return_type":"SIMD_type",
     246                "fws":[64],
    232247        },
    233248        "_mm_srli_si128":\
    234249        {
    235                 "Pattern":"_mm_srli_si128(arg1, arg2)",
    236                 "Fws":[128],
    237                 "ReturnType":"SIMD_type",
     250                "signature":"SIMD_type _mm_srli_si128(SIMD_type arg1, int sh)",
     251                "args_type":{"arg1":"SIMD_type", "sh":"signed_int(32)"},
     252                "return_type":"SIMD_type",
     253                "fws":[128],
    238254        },
    239255        "_mm_set_epi32":\
    240256        {
    241                 "Pattern":"_mm_set_epi32(val)",
    242                 "Fws":[32],
    243                 "ReturnType":"SIMD_type",
     257                "signature":"SIMD_type _mm_set_epi32(int val1, int val2, int val3, int val4)",
     258                "args_type":{"val1":"signed_int(32)", "val2":"signed_int(32)", "val3":"signed_int(32)", "val4":"signed_int(32)"},
     259                "return_type":"SIMD_type",
     260                "fws":[32],
    244261        },
    245262        "_mm_set1_epi32":\
    246263        {
    247                 "Pattern":"_mm_set1_epi32(val)",
    248                 "Fws":[32],
    249                 "ReturnType":"SIMD_type",
     264                "signature":"SIMD_type _mm_set1_epi32(int val1)",
     265                "args_type":{"val1":"signed_int(32)"},
     266                "return_type":"SIMD_type",
     267                "fws":[32],
    250268        },
    251269        "_mm_cvtsi32_si128":\
    252270        {
    253                 "Pattern":"_mm_cvtsi32_si128(val)",
    254                 "Fws":[128],
    255                 "ReturnType":"SIMD_type",
     271                "signature":"SIMD_type _mm_cvtsi32_si128(int val1)",
     272                "args_type":{"val1":"signed_int(32)"},
     273                "return_type":"SIMD_type",
     274                "fws":[128],
    256275        },
    257276        "_mm_shufflehi_epi16":\
    258277        {
    259                 "Pattern":"_mm_shufflehi_epi16(arg1, msk)",
    260                 "Fws":[16],
    261                 "ReturnType":"SIMD_type",
     278                "signature":"SIMD_type _mm_shufflehi_epi16(SIMD_type arg1, int msk)",
     279                "args_type":{"arg1":"SIMD_type", "msk":"signed_int(32)"},
     280                "return_type":"SIMD_type",
     281                "fws":[16],
    262282        },
    263283        "_mm_shufflelo_epi16":\
    264284        {
    265                 "Pattern":"_mm_shufflelo_epi16(arg1, msk)",
    266                 "Fws":[16],
    267                 "ReturnType":"SIMD_type",
     285                "signature":"SIMD_type _mm_shufflelo_epi16(SIMD_type arg1, int msk)",
     286                "args_type":{"arg1":"SIMD_type", "msk":"signed_int(32)"},
     287                "return_type":"SIMD_type",
     288                "fws":[16],
    268289        },
    269290        "_mm_sad_epu8":\
    270291        {
    271                 "Pattern":"_mm_sad_epu8(arg1, arg2)",
    272                 "Fws":[8],
    273                 "ReturnType":"SIMD_type",
     292                "signature":"SIMD_type _mm_sad_epu8(SIMD_type arg1, SIMD_type arg2)",
     293                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     294                "return_type":"SIMD_type",
     295                "fws":[8],
    274296        },
    275297        "_mm_hsub_epi16":\
    276298        {
    277                 "Pattern":"_mm_hsub_epi16(arg1, arg2)",
    278                 "Fws":[16],
    279                 "ReturnType":"SIMD_type",
     299                "signature":"SIMD_type _mm_hsub_epi16(SIMD_type arg1, SIMD_type arg2)",
     300                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     301                "return_type":"SIMD_type",
     302                "fws":[16],
    280303        },
    281304        "_mm_hsub_epi32":\
    282305        {
    283                 "Pattern":"_mm_hsub_epi32(arg1, arg2)",
    284                 "Fws":[32],
    285                 "ReturnType":"SIMD_type",
     306                "signature":"SIMD_type _mm_hsub_epi32(SIMD_type arg1, SIMD_type arg2)",
     307                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     308                "return_type":"SIMD_type",
     309                "fws":[32],
    286310        },
    287311        "_mm_sign_epi8":\
    288312        {
    289                 "Pattern":"_mm_sign_epi8(arg1, arg2)",
    290                 "Fws":[8],
    291                 "ReturnType":"SIMD_type",
     313                "signature":"SIMD_type _mm_sign_epi8(SIMD_type arg1, SIMD_type arg2)",
     314                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     315                "return_type":"SIMD_type",
     316                "fws":[8],
    292317        },
    293318        "_mm_sign_epi16":\
    294319        {
    295                 "Pattern":"_mm_sign_epi16(arg1, arg2)",
    296                 "Fws":[16],
    297                 "ReturnType":"SIMD_type",
     320                "signature":"SIMD_type _mm_sign_epi16(SIMD_type arg1, SIMD_type arg2)",
     321                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     322                "return_type":"SIMD_type",
     323                "fws":[16],
    298324        },
    299325        "_mm_sign_epi32":\
    300326        {
    301                 "Pattern":"_mm_sign_epi32(arg1, arg2)",
    302                 "Fws":[32],
    303                 "ReturnType":"SIMD_type",
     327                "signature":"SIMD_type _mm_sign_epi32(SIMD_type arg1, SIMD_type arg2)",
     328                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     329                "return_type":"SIMD_type",
     330                "fws":[32],
    304331        },
    305332        "_mm_blendv_epi8":\
    306333        {
    307                 "Pattern":"_mm_blendv_epi8(arg3, arg2, arg1)",
    308                 "Fws":[8],
    309                 "ReturnType":"SIMD_type",
     334                "signature":"SIMD_type _mm_blendv_epi8(SIMD_type arg3, SIMD_type arg2, SIMD_type arg1)",
     335                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type", "arg3":"SIMD_type"},
     336                "return_type":"SIMD_type",
     337                "fws":[8],
    310338        },
    311339        "_mm_extract_epi8":\
    312340        {
    313                 "Pattern":"_mm_extract_epi8(arg1, pos)",
    314                 "Fws":[8],
    315                 "ReturnType":"SIMD_type",
     341                "signature":"int _mm_extract_epi8(SIMD_type arg1, int pos)",
     342                "args_type":{"arg1":"SIMD_type", "pos":"signed_int(32)"},
     343                "return_type":"signed_int(32)",
     344                "fws":[8],
     345        },
     346        "_mm_extract_epi16":\
     347        {
     348                "signature":"int _mm_extract_epi16(SIMD_type arg1, int pos)",
     349                "args_type":{"arg1":"SIMD_type", "pos":"signed_int(32)"},
     350                "return_type":"signed_int(32)",
     351                "fws":[16],
    316352        },
    317353        "_mm_extract_epi32":\
    318354        {
    319                 "Pattern":"_mm_extract_epi32(arg1, pos)",
    320                 "Fws":[32],
    321                 "ReturnType":"SIMD_type",
    322         },
    323         "_mm_extract_epi16":\
    324         {
    325                 "Pattern":"_mm_extract_epi16(arg1, pos)",
    326                 "Fws":[16],
    327                 "ReturnType":"SIMD_type",
     355                "signature":"int _mm_extract_epi32(SIMD_type arg1, int pos)",
     356                "args_type":{"arg1":"SIMD_type", "pos":"signed_int(32)"},
     357                "return_type":"signed_int(32)",
     358                "fws":[32],
    328359        },
    329360        "_mm_cvtepi8_epi16":\
    330361        {
    331                 "Pattern":"_mm_cvtepi8_epi16(arg1)",
    332                 "Fws":[8],
    333                 "ReturnType":"SIMD_type",
     362                "signature":"SIMD_type _mm_cvtepi8_epi16(SIMD_type arg1)",
     363                "args_type":{"arg1":"SIMD_type"},
     364                "return_type":"SIMD_type",
     365                "fws":[8],
    334366        },
    335367        "_mm_cvtepi16_epi32":\
    336368        {
    337                 "Pattern":"_mm_cvtepi16_epi32(arg1)",
    338                 "Fws":[16],
    339                 "ReturnType":"SIMD_type",
     369                "signature":"SIMD_type _mm_cvtepi16_epi32(SIMD_type arg1)",
     370                "args_type":{"arg1":"SIMD_type"},
     371                "return_type":"SIMD_type",
     372                "fws":[16],
    340373        },
    341374        "_mm_cvtepi32_epi64":\
    342375        {
    343                 "Pattern":"_mm_cvtepi32_epi64(arg1)",
    344                 "Fws":[32],
    345                 "ReturnType":"SIMD_type",
     376                "signature":"SIMD_type _mm_cvtepi32_epi64(SIMD_type arg1)",
     377                "args_type":{"arg1":"SIMD_type"},
     378                "return_type":"SIMD_type",
     379                "fws":[32],
    346380        },
    347381        "_mm_cvtepu8_epi16":
    348382        {
    349                 "Pattern":"_mm_cvtepu8_epi16(arg1)",
    350                 "Fws":[8],
    351                 "ReturnType":"SIMD_type",
     383                "signature":"SIMD_type _mm_cvtepu8_epi16(SIMD_type arg1)",
     384                "args_type":{"arg1":"SIMD_type"},
     385                "return_type":"SIMD_type",
     386                "fws":[8],
    352387        },
    353388        "_mm_cvtepu16_epi32":
    354389        {
    355                 "Pattern":"_mm_cvtepu16_epi32(arg1)",
    356                 "Fws":[16],
    357                 "ReturnType":"SIMD_type",
     390                "signature":"SIMD_type _mm_cvtepu16_epi32(SIMD_type arg1)",
     391                "args_type":{"arg1":"SIMD_type"},
     392                "return_type":"SIMD_type",
     393                "fws":[16],
    358394        },
    359395        "_mm_cvtepu32_epi64":
    360396        {
    361                 "Pattern":"_mm_cvtepu32_epi64(arg1)",
    362                 "Fws":[32],
    363                 "ReturnType":"SIMD_type",
     397                "signature":"SIMD_type _mm_cvtepu32_epi64(SIMD_type arg1)",
     398                "args_type":{"arg1":"SIMD_type"},
     399                "return_type":"SIMD_type",
     400                "fws":[32],
    364401        },
    365402        "_mm_mul_epi32":
    366403        {
    367                 "Pattern":"_mm_mul_epi32(arg1, arg2)",
    368                 "Fws":[32],
    369                 "ReturnType":"SIMD_type",
    370         },
    371 #       "_mm_testz_si128":
    372 #       {
    373 #               "Pattern":"_mm_testz_si128(arg1, arg2)",
    374 #               "Fws":[128],
    375 #               "ReturnType":IntType,
    376 #       },
     404                "signature":"SIMD_type _mm_mul_epi32(SIMD_type arg1, SIMD_type arg2)",
     405                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     406                "return_type":"SIMD_type",
     407                "fws":[32],
     408        },
    377409}
  • trunk/libgen/Library_Generator/SSE4_2Instructions.py

    r1494 r1521  
    55        "simd_and":\
    66        {
    7                 "Pattern":"_mm_and_si128(arg1, arg2)",
    8                 "Fws":[1],
    9                 "ReturnType":"SIMD_type",
     7                "signature":"SIMD_type _mm_and_si128(SIMD_type arg1, SIMD_type arg2)",
     8                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     9                "return_type":"SIMD_type",
     10                "fws":[1],
    1011        },
    1112        "simd_andc":\
    1213        {
    13                 "Pattern":"_mm_andnot_si128(arg2, arg1)",
    14                 "Fws":[1],
    15                 "ReturnType":"SIMD_type",
     14                "signature":"SIMD_type _mm_andnot_si128(SIMD_type arg2, SIMD_type arg1)",
     15                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     16                "return_type":"SIMD_type",
     17                "fws":[1],
    1618        },
    1719        "simd_or":\
    1820        {
    19                 "Pattern":"_mm_or_si128(arg1, arg2)",
    20                 "Fws":[1],
    21                 "ReturnType":"SIMD_type",
     21                "signature":"SIMD_type _mm_or_si128(SIMD_type arg1, SIMD_type arg2)",
     22                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     23                "return_type":"SIMD_type",
     24                "fws":[1],
    2225        },
    2326        "simd_xor":\
    2427        {
    25                 "Pattern":"_mm_xor_si128(arg1, arg2)",
    26                 "Fws":[1],
    27                 "ReturnType":"SIMD_type",
     28                "signature":"SIMD_type _mm_xor_si128(SIMD_type arg1, SIMD_type arg2)",
     29                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     30                "return_type":"SIMD_type",
     31                "fws":[1],
    2832        },
    2933        "simd_add":\
    3034        {
    31                 "Pattern":"_mm_add_epi$fw$(arg1, arg2)",
    32                 "Fws":[8, 16, 32, 64],
    33                 "ReturnType":"SIMD_type",
     35                "signature":"SIMD_type _mm_add_epi$fw$(SIMD_type arg1, SIMD_type arg2)",
     36                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     37                "return_type":"SIMD_type",
     38                "fws":[8, 16, 32, 64],
    3439        },
    3540        "simd_sub":\
    3641        {
    37                 "Pattern":"_mm_sub_epi$fw$(arg1, arg2)",
    38                 "Fws":[8, 16, 32, 64],
    39                 "ReturnType":"SIMD_type",
     42                "signature":"SIMD_type _mm_sub_epi$fw$(SIMD_type arg1, SIMD_type arg2)",
     43                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     44                "return_type":"SIMD_type",
     45                "fws":[8, 16, 32, 64],
    4046        },
    4147        "simd_umult":\
    4248        {
    43                 "Pattern":"_mm_mul_epu$fw$(arg1, arg2)",
    44                 "Fws":[32],
    45                 "ReturnType":"SIMD_type",
     49                "signature":"SIMD_type _mm_mul_epu$fw$(SIMD_type arg1, SIMD_type arg2)",
     50                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     51                "return_type":"SIMD_type",
     52                "fws":[32],
    4653        },
    4754        "simd_mult":\
    4855        {
    49                 "Pattern":"_mm_mullo_epi$fw$(arg1, arg2)",
    50                 "Fws":[16, 32],
    51                 "ReturnType":"SIMD_type",
     56                "signature":"SIMD_type _mm_mullo_epi$fw$(SIMD_type arg1, SIMD_type arg2)",
     57                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     58                "return_type":"SIMD_type",
     59                "fws":[16, 32],
    5260        },
    5361        "simd_eq":\
    5462        {
    55                 "Pattern":"_mm_cmpeq_epi$fw$(arg1, arg2)",
    56                 "Fws":[8, 16, 32, 64],
    57                 "ReturnType":"SIMD_type",
     63                "signature":"SIMD_type _mm_cmpeq_epi$fw$(SIMD_type arg1, SIMD_type arg2)",
     64                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     65                "return_type":"SIMD_type",
     66                "fws":[8, 16, 32, 64],
    5867        },
    5968        "simd_gt":\
    6069        {
    61                 "Pattern":"_mm_cmpgt_epi$fw$(arg1, arg2)",
    62                 "Fws":[8, 16, 32, 64],
    63                 "ReturnType":"SIMD_type",
     70                "signature":"SIMD_type _mm_cmpgt_epi$fw$(SIMD_type arg1, SIMD_type arg2)",
     71                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     72                "return_type":"SIMD_type",
     73                "fws":[8, 16, 32, 64],
    6474        },
    6575        "simd_max":\
    6676        {
    67                 "Pattern":"_mm_max_epi$fw$(arg1, arg2)",
    68                 "Fws":[8, 16, 32],
    69                 "ReturnType":"SIMD_type",
     77                "signature":"SIMD_type _mm_max_epi$fw$(SIMD_type arg1, SIMD_type arg2)",
     78                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     79                "return_type":"SIMD_type",
     80                "fws":[8, 16, 32],
    7081        },
    7182        "simd_umax":\
    7283        {
    73                 "Pattern":"_mm_max_epu$fw$(arg1, arg2)",
    74                 "Fws":[8, 16, 32],
    75                 "ReturnType":"SIMD_type",
     84                "signature":"SIMD_type _mm_max_epu$fw$(SIMD_type arg1, SIMD_type arg2)",
     85                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     86                "return_type":"SIMD_type",
     87                "fws":[8, 16, 32],
    7688        },
    7789        "simd_min":\
    7890        {
    79                 "Pattern":"_mm_min_epi$fw$(arg1, arg2)",
    80                 "Fws":[8, 16, 32],
    81                 "ReturnType":"SIMD_type",
     91                "signature":"SIMD_type _mm_min_epi$fw$(SIMD_type arg1, SIMD_type arg2)",
     92                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     93                "return_type":"SIMD_type",
     94                "fws":[8, 16, 32],
    8295        },
    8396        "simd_umin":\
    8497        {
    85                 "Pattern":"_mm_min_epu$fw$(arg1, arg2)",
    86                 "Fws":[8, 16, 32],
    87                 "ReturnType":"SIMD_type",
     98                "signature":"SIMD_type _mm_min_epu$fw$(SIMD_type arg1, SIMD_type arg2)",
     99                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     100                "return_type":"SIMD_type",
     101                "fws":[8, 16, 32],
    88102        },
    89103        "simd_srli":\
    90104        {
    91                 "Pattern":"_mm_srli_epi$fw$(arg1, sh)",
    92                 "Fws":[16, 32, 64],
    93                 "ReturnType":"SIMD_type",
     105                "signature":"SIMD_type _mm_srli_epi$fw$(SIMD_type arg1, int sh)",
     106                "args_type":{"arg1":"SIMD_type", "sh":"signed_int(32)"},
     107                "return_type":"SIMD_type",
     108                "fws":[16, 32, 64],
    94109        },
    95110        "simd_slli":\
    96111        {
    97                 "Pattern":"_mm_slli_epi$fw$(arg1, sh)",
    98                 "Fws":[16, 32, 64],
    99                 "ReturnType":"SIMD_type",
     112                "signature":"SIMD_type _mm_slli_epi$fw$(SIMD_type arg1, int sh)",
     113                "args_type":{"arg1":"SIMD_type", "sh":"signed_int(32)"},
     114                "return_type":"SIMD_type",
     115                "fws":[16, 32, 64],
    100116        },
    101117        "simd_srai":\
    102118        {
    103                 "Pattern":"_mm_srai_epi$fw$(arg1, sh)",
    104                 "Fws":[16, 32],
    105                 "ReturnType":"SIMD_type",
     119                "signature":"SIMD_type _mm_srai_epi$fw$(SIMD_type arg1, int sh)",
     120                "args_type":{"arg1":"SIMD_type", "sh":"signed_int(32)"},
     121                "return_type":"SIMD_type",
     122                "fws":[16, 32],
    106123        },
    107124        "simd_constant":\
    108125        {
    109                 "Pattern":"_mm_set1_epi$fw$(val)",
    110                 "Fws":[8, 16, 32],
    111                 "ReturnType":"SIMD_type",
     126                "signature":"SIMD_type _mm_set1_epi$fw$(int val)",
     127                "args_type":{"val":"signed_int(32)"},
     128                "return_type":"SIMD_type",
     129                "fws":[8, 16, 32],
    112130        },
    113131        "simd_abs":\
    114132        {
    115                 "Pattern":"_mm_abs_epi$fw$(arg1)",
    116                 "Fws":[8, 16, 32],
    117                 "ReturnType":"SIMD_type",
     133                "signature":"SIMD_type _mm_abs_epi$fw$(SIMD_type arg1)",
     134                "args_type":{"arg1":"SIMD_type"},
     135                "return_type":"SIMD_type",
     136                "fws":[8, 16, 32],
    118137        },
    119138        "hsimd_add_hl":\
    120139        {
    121                 "Pattern":"_mm_hadd_epi$fw/2$(arg2, arg1)",
    122                 "Fws":[32, 64],
    123                 "ReturnType":"SIMD_type",       
     140                "signature":"SIMD_type _mm_hadd_epi$fw/2$(SIMD_type arg2, SIMD_type arg1)",
     141                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     142                "return_type":"SIMD_type",
     143                "fws":[32, 64],
    124144        },
    125145        "hsimd_packus":\
    126146        {
    127                 "Pattern":"_mm_packus_epi$fw$(arg2, arg1)",
    128                 "Fws":[16, 32],
    129                 "ReturnType":"SIMD_type",
     147                "signature":"SIMD_type _mm_packus_epi$fw$(SIMD_type arg2, SIMD_type arg1)",
     148                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     149                "return_type":"SIMD_type",
     150                "fws":[16, 32],
    130151        },
    131152        "hsimd_packss":\
    132153        {
    133                 "Pattern":"_mm_packs_epi$fw$(arg2, arg1)",
    134                 "Fws":[16, 32],
    135                 "ReturnType":"SIMD_type",
     154                "signature":"SIMD_type _mm_packs_epi$fw$(SIMD_type arg2, SIMD_type arg1)",
     155                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     156                "return_type":"SIMD_type",
     157                "fws":[16, 32],
    136158        },
    137159        "hsimd_signmask":\
    138160        {
    139                 "Pattern":"_mm_movemask_epi$fw$(arg1)",
    140                 "Fws":[8],
    141                 "ReturnType":IntType,
     161                "signature":"int _mm_movemask_epi$fw$(SIMD_type arg1)",
     162                "args_type":{"arg1":"SIMD_type"},
     163                "return_type":"signed_int(32)",
     164                "fws":[8],
    142165        },
    143166        "esimd_mergeh":\
    144167        {
    145                 "Pattern":"_mm_unpackhi_epi$fw$(arg2, arg1)",
    146                 "Fws":[8, 16, 32, 64],
    147                 "ReturnType":"SIMD_type",
     168                "signature":"SIMD_type _mm_unpackhi_epi$fw$(SIMD_type arg2, SIMD_type arg1)",
     169                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     170                "return_type":"SIMD_type",
     171                "fws":[8, 16, 32, 64],
    148172        },
    149173        "esimd_mergel":\
    150174        {
    151                 "Pattern":"_mm_unpacklo_epi$fw$(arg2, arg1)",
    152                 "Fws":[8, 16, 32, 64],
    153                 "ReturnType":"SIMD_type",
     175                "signature":"SIMD_type _mm_unpacklo_epi$fw$(SIMD_type arg2, SIMD_type arg1)",
     176                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     177                "return_type":"SIMD_type",
     178                "fws":[8, 16, 32, 64],
    154179        },
    155180        "mvmd_fill":\
    156181        {
    157                 "Pattern":"_mm_set1_epi$fw$(val1)",
    158                 "Fws":[8, 16, 32],
    159                 "ReturnType":"SIMD_type",
     182                "signature":"SIMD_type _mm_set1_epi$fw$(int val1)",
     183                "args_type":{"val1":"signed_int(32)"},
     184                "return_type":"SIMD_type",
     185                "fws":[8, 16, 32],
    160186        },
    161187        "mvmd_fill4":\
    162188        {
    163                 "Pattern":"_mm_set_epi$fw$(val1, val2, val3, val4)",
    164                 "Fws":[32],
    165                 "ReturnType":"SIMD_type",
     189                "signature":"SIMD_type _mm_set_epi$fw$(int val1, int val2, int val3, int val4)",
     190                "args_type":{"val1":"signed_int(32)", "val2":"signed_int(32)", "val3":"signed_int(32)", "val4":"signed_int(32)"},
     191                "return_type":"SIMD_type",
     192                "fws":[32],
    166193        },
    167194        "mvmd_fill8":\
    168195        {
    169                 "Pattern":"_mm_set_epi$fw$(val1, val2, val3, val4, val5, val6, val7, val8)",
    170                 "Fws":[16],
    171                 "ReturnType":"SIMD_type",
     196                "signature":"SIMD_type _mm_set_epi$fw$(int val1, int val2, int val3, int val4, int val5, int val6, int val7, int val8)",
     197                "args_type":{"val1":"signed_int(32)", "val2":"signed_int(32)", "val3":"signed_int(32)", "val4":"signed_int(32)", \
     198                                        "val5":"signed_int(32)", "val6":"signed_int(32)", "val7":"signed_int(32)", "val8":"signed_int(32)"},
     199                "return_type":"SIMD_type",
     200                "fws":[16],
    172201        },
    173202        "mvmd_fill16":\
    174203        {
    175                 "Pattern":"_mm_set_epi$fw$(val1, val2, val3, val4, val5, val6, val7, val8, val9, val10, val11, val12, val13, val14, val15, val16)",
    176                 "Fws":[8],
    177                 "ReturnType":"SIMD_type",
     204                "signature":"SIMD_type _mm_set_epi$fw$(int val1, int val2, int val3, int val4, int val5, int val6, int val7, int val8, \
     205                                        int val9, int val10, int val11, int val12, int val13, int val14, int val15, int val16)",
     206                "args_type":{"val1":"signed_int(32)", "val2":"signed_int(32)", "val3":"signed_int(32)", "val4":"signed_int(32)", \
     207                                        "val5":"signed_int(32)", "val6":"signed_int(32)", "val7":"signed_int(32)", "val8":"signed_int(32)", \
     208                                        "val9":"signed_int(32)", "val10":"signed_int(32)", "val11":"signed_int(32)", "val12":"signed_int(32)", \
     209                                        "val13":"signed_int(32)", "val14":"signed_int(32)", "val15":"signed_int(32)", "val16":"signed_int(32)"},
     210                "return_type":"SIMD_type",
     211                "fws":[8],
    178212        },
    179213        "mvmd_shufflei":\
    180214        {
    181                 "Pattern":"_mm_shuffle_epi$fw$(arg1, msk)",
    182                 "Fws":[32],
    183                 "ReturnType":"SIMD_type",
     215                "signature":"SIMD_type _mm_shuffle_epi$fw$(SIMD_type arg1, int msk)",
     216                "args_type":{"arg1":"SIMD_type", "msk":"signed_int(32)"},
     217                "return_type":"SIMD_type",
     218                "fws":[32],
    184219        },
    185220        "mvmd_shuffle":\
    186221        {
    187                 "Pattern":"_mm_shuffle_epi$fw$(arg1, arg2)",
    188                 "Fws":[8],
    189                 "ReturnType":"SIMD_type",
    190         },
    191         "bitblock_load_aligned":\
    192         {
    193                 "Pattern":"_mm_load_si$fw$(arg1)",
    194                 "Fws":[128],
    195                 "ReturnType":"SIMD_type",
    196         },
    197         "bitblock_load_unaligned":\
    198         {
    199                 "Pattern":"_mm_lddqu_si$fw$ (arg1)",
    200                 "Fws":[128],
    201                 "ReturnType":"SIMD_type",
    202         },
    203         "bitblock_store_aligned":\
    204         {
    205                 "Pattern":"_mm_store_si$fw$(arg1, arg2)",
    206                 "Fws":[128],
    207                 "ReturnType":"void",
    208         },
    209         "bitblock_store_unaligned":\
    210         {
    211                 "Pattern":"_mm_storeu_si$fw$(arg1, arg2)",
    212                 "Fws":[128],
    213                 "ReturnType":"void",
     222                "signature":"SIMD_type _mm_shuffle_epi$fw$(SIMD_type arg1, SIMD_type arg2)",
     223                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     224                "return_type":"SIMD_type",
     225                "fws":[8],
    214226        },
    215227        "_mm_sll_epi64":\
    216228        {
    217                 "Pattern":"_mm_sll_epi64(arg1, sh)",
    218                 "Fws":[64],
    219                 "ReturnType":"SIMD_type",
     229                "signature":"SIMD_type _mm_sll_epi64(SIMD_type arg1, SIMD_type sh)",
     230                "args_type":{"arg1":"SIMD_type", "sh":"SIMD_type"},
     231                "return_type":"SIMD_type",
     232                "fws":[64],
    220233        },
    221234        "_mm_slli_si128":\
    222235        {
    223                 "Pattern":"_mm_slli_si128(arg1, arg2)",
    224                 "Fws":[128],
    225                 "ReturnType":"SIMD_type",
     236                "signature":"SIMD_type _mm_slli_si128(SIMD_type arg1, int sh)",
     237                "args_type":{"arg1":"SIMD_type", "sh":"signed_int(32)"},
     238                "return_type":"SIMD_type",
     239                "fws":[128],
    226240        },
    227241        "_mm_srl_epi64":\
    228242        {
    229                 "Pattern":"_mm_srl_epi64(arg1, sh)",
    230                 "Fws":[64],
    231                 "ReturnType":"SIMD_type",
     243                "signature":"SIMD_type _mm_srl_epi64(SIMD_type arg1, SIMD_type sh)",
     244                "args_type":{"arg1":"SIMD_type", "sh":"SIMD_type"},
     245                "return_type":"SIMD_type",
     246                "fws":[64],
    232247        },
    233248        "_mm_srli_si128":\
    234249        {
    235                 "Pattern":"_mm_srli_si128(arg1, arg2)",
    236                 "Fws":[128],
    237                 "ReturnType":"SIMD_type",
     250                "signature":"SIMD_type _mm_srli_si128(SIMD_type arg1, int sh)",
     251                "args_type":{"arg1":"SIMD_type", "sh":"signed_int(32)"},
     252                "return_type":"SIMD_type",
     253                "fws":[128],
    238254        },
    239255        "_mm_set_epi32":\
    240256        {
    241                 "Pattern":"_mm_set_epi32(val)",
    242                 "Fws":[32],
    243                 "ReturnType":"SIMD_type",
     257                "signature":"SIMD_type _mm_set_epi32(int val1, int val2, int val3, int val4)",
     258                "args_type":{"val1":"signed_int(32)", "val2":"signed_int(32)", "val3":"signed_int(32)", "val4":"signed_int(32)"},
     259                "return_type":"SIMD_type",
     260                "fws":[32],
    244261        },
    245262        "_mm_set1_epi32":\
    246263        {
    247                 "Pattern":"_mm_set1_epi32(val)",
    248                 "Fws":[32],
    249                 "ReturnType":"SIMD_type",
     264                "signature":"SIMD_type _mm_set1_epi32(int val1)",
     265                "args_type":{"val1":"signed_int(32)"},
     266                "return_type":"SIMD_type",
     267                "fws":[32],
    250268        },
    251269        "_mm_cvtsi32_si128":\
    252270        {
    253                 "Pattern":"_mm_cvtsi32_si128(val)",
    254                 "Fws":[128],
    255                 "ReturnType":"SIMD_type",
     271                "signature":"SIMD_type _mm_cvtsi32_si128(int val1)",
     272                "args_type":{"val1":"signed_int(32)"},
     273                "return_type":"SIMD_type",
     274                "fws":[128],
    256275        },
    257276        "_mm_shufflehi_epi16":\
    258277        {
    259                 "Pattern":"_mm_shufflehi_epi16(arg1, msk)",
    260                 "Fws":[16],
    261                 "ReturnType":"SIMD_type",
     278                "signature":"SIMD_type _mm_shufflehi_epi16(SIMD_type arg1, int msk)",
     279                "args_type":{"arg1":"SIMD_type", "msk":"signed_int(32)"},
     280                "return_type":"SIMD_type",
     281                "fws":[16],
    262282        },
    263283        "_mm_shufflelo_epi16":\
    264284        {
    265                 "Pattern":"_mm_shufflelo_epi16(arg1, msk)",
    266                 "Fws":[16],
    267                 "ReturnType":"SIMD_type",
     285                "signature":"SIMD_type _mm_shufflelo_epi16(SIMD_type arg1, int msk)",
     286                "args_type":{"arg1":"SIMD_type", "msk":"signed_int(32)"},
     287                "return_type":"SIMD_type",
     288                "fws":[16],
    268289        },
    269290        "_mm_sad_epu8":\
    270291        {
    271                 "Pattern":"_mm_sad_epu8(arg1, arg2)",
    272                 "Fws":[8],
    273                 "ReturnType":"SIMD_type",
     292                "signature":"SIMD_type _mm_sad_epu8(SIMD_type arg1, SIMD_type arg2)",
     293                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     294                "return_type":"SIMD_type",
     295                "fws":[8],
    274296        },
    275297        "_mm_hsub_epi16":\
    276298        {
    277                 "Pattern":"_mm_hsub_epi16(arg1, arg2)",
    278                 "Fws":[16],
    279                 "ReturnType":"SIMD_type",
     299                "signature":"SIMD_type _mm_hsub_epi16(SIMD_type arg1, SIMD_type arg2)",
     300                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     301                "return_type":"SIMD_type",
     302                "fws":[16],
    280303        },
    281304        "_mm_hsub_epi32":\
    282305        {
    283                 "Pattern":"_mm_hsub_epi32(arg1, arg2)",
    284                 "Fws":[32],
    285                 "ReturnType":"SIMD_type",
     306                "signature":"SIMD_type _mm_hsub_epi32(SIMD_type arg1, SIMD_type arg2)",
     307                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     308                "return_type":"SIMD_type",
     309                "fws":[32],
    286310        },
    287311        "_mm_sign_epi8":\
    288312        {
    289                 "Pattern":"_mm_sign_epi8(arg1, arg2)",
    290                 "Fws":[8],
    291                 "ReturnType":"SIMD_type",
     313                "signature":"SIMD_type _mm_sign_epi8(SIMD_type arg1, SIMD_type arg2)",
     314                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     315                "return_type":"SIMD_type",
     316                "fws":[8],
    292317        },
    293318        "_mm_sign_epi16":\
    294319        {
    295                 "Pattern":"_mm_sign_epi16(arg1, arg2)",
    296                 "Fws":[16],
    297                 "ReturnType":"SIMD_type",
     320                "signature":"SIMD_type _mm_sign_epi16(SIMD_type arg1, SIMD_type arg2)",
     321                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     322                "return_type":"SIMD_type",
     323                "fws":[16],
    298324        },
    299325        "_mm_sign_epi32":\
    300326        {
    301                 "Pattern":"_mm_sign_epi32(arg1, arg2)",
    302                 "Fws":[32],
    303                 "ReturnType":"SIMD_type",
     327                "signature":"SIMD_type _mm_sign_epi32(SIMD_type arg1, SIMD_type arg2)",
     328                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     329                "return_type":"SIMD_type",
     330                "fws":[32],
    304331        },
    305332        "_mm_blendv_epi8":\
    306333        {
    307                 "Pattern":"_mm_blendv_epi8(arg3, arg2, arg1)",
    308                 "Fws":[8],
    309                 "ReturnType":"SIMD_type",
     334                "signature":"SIMD_type _mm_blendv_epi8(SIMD_type arg3, SIMD_type arg2, SIMD_type arg1)",
     335                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type", "arg3":"SIMD_type"},
     336                "return_type":"SIMD_type",
     337                "fws":[8],
    310338        },
    311339        "_mm_extract_epi8":\
    312340        {
    313                 "Pattern":"_mm_extract_epi8(arg1, pos)",
    314                 "Fws":[8],
    315                 "ReturnType":"SIMD_type",
     341                "signature":"int _mm_extract_epi8(SIMD_type arg1, int pos)",
     342                "args_type":{"arg1":"SIMD_type", "pos":"signed_int(32)"},
     343                "return_type":"signed_int(32)",
     344                "fws":[8],
    316345        },
    317346        "_mm_extract_epi16":\
    318347        {
    319                 "Pattern":"_mm_extract_epi16(arg1, pos)",
    320                 "Fws":[16],
    321                 "ReturnType":"SIMD_type",
     348                "signature":"int _mm_extract_epi16(SIMD_type arg1, int pos)",
     349                "args_type":{"arg1":"SIMD_type", "pos":"signed_int(32)"},
     350                "return_type":"signed_int(32)",
     351                "fws":[16],
     352        },
     353        "_mm_extract_epi32":\
     354        {
     355                "signature":"int _mm_extract_epi32(SIMD_type arg1, int pos)",
     356                "args_type":{"arg1":"SIMD_type", "pos":"signed_int(32)"},
     357                "return_type":"signed_int(32)",
     358                "fws":[32],
    322359        },
    323360        "_mm_cvtepi8_epi16":\
    324361        {
    325                 "Pattern":"_mm_cvtepi8_epi16(arg1)",
    326                 "Fws":[8],
    327                 "ReturnType":"SIMD_type",
     362                "signature":"SIMD_type _mm_cvtepi8_epi16(SIMD_type arg1)",
     363                "args_type":{"arg1":"SIMD_type"},
     364                "return_type":"SIMD_type",
     365                "fws":[8],
    328366        },
    329367        "_mm_cvtepi16_epi32":\
    330368        {
    331                 "Pattern":"_mm_cvtepi16_epi32(arg1)",
    332                 "Fws":[16],
    333                 "ReturnType":"SIMD_type",
     369                "signature":"SIMD_type _mm_cvtepi16_epi32(SIMD_type arg1)",
     370                "args_type":{"arg1":"SIMD_type"},
     371                "return_type":"SIMD_type",
     372                "fws":[16],
    334373        },
    335374        "_mm_cvtepi32_epi64":\
    336375        {
    337                 "Pattern":"_mm_cvtepi32_epi64(arg1)",
    338                 "Fws":[32],
    339                 "ReturnType":"SIMD_type",
     376                "signature":"SIMD_type _mm_cvtepi32_epi64(SIMD_type arg1)",
     377                "args_type":{"arg1":"SIMD_type"},
     378                "return_type":"SIMD_type",
     379                "fws":[32],
    340380        },
    341381        "_mm_cvtepu8_epi16":
    342382        {
    343                 "Pattern":"_mm_cvtepu8_epi16(arg1)",
    344                 "Fws":[8],
    345                 "ReturnType":"SIMD_type",
     383                "signature":"SIMD_type _mm_cvtepu8_epi16(SIMD_type arg1)",
     384                "args_type":{"arg1":"SIMD_type"},
     385                "return_type":"SIMD_type",
     386                "fws":[8],
    346387        },
    347388        "_mm_cvtepu16_epi32":
    348389        {
    349                 "Pattern":"_mm_cvtepu16_epi32(arg1)",
    350                 "Fws":[16],
    351                 "ReturnType":"SIMD_type",
     390                "signature":"SIMD_type _mm_cvtepu16_epi32(SIMD_type arg1)",
     391                "args_type":{"arg1":"SIMD_type"},
     392                "return_type":"SIMD_type",
     393                "fws":[16],
    352394        },
    353395        "_mm_cvtepu32_epi64":
    354396        {
    355                 "Pattern":"_mm_cvtepu32_epi64(arg1)",
    356                 "Fws":[32],
    357                 "ReturnType":"SIMD_type",
     397                "signature":"SIMD_type _mm_cvtepu32_epi64(SIMD_type arg1)",
     398                "args_type":{"arg1":"SIMD_type"},
     399                "return_type":"SIMD_type",
     400                "fws":[32],
    358401        },
    359402        "_mm_mul_epi32":
    360403        {
    361                 "Pattern":"_mm_mul_epi32(arg1, arg2)",
    362                 "Fws":[32],
    363                 "ReturnType":"SIMD_type",
     404                "signature":"SIMD_type _mm_mul_epi32(SIMD_type arg1, SIMD_type arg2)",
     405                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     406                "return_type":"SIMD_type",
     407                "fws":[32],
    364408        },
    365409}
  • trunk/libgen/Library_Generator/SSSE3Instructions.py

    r1494 r1521  
    55        "simd_and":\
    66        {
    7                 "Pattern":"_mm_and_si128(arg1, arg2)",
    8                 "Fws":[1],
    9                 "ReturnType":"SIMD_type",
     7                "signature":"SIMD_type _mm_and_si128(SIMD_type arg1, SIMD_type arg2)",
     8                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     9                "return_type":"SIMD_type",
     10                "fws":[1],
    1011        },
    1112        "simd_andc":\
    1213        {
    13                 "Pattern":"_mm_andnot_si128(arg2, arg1)",
    14                 "Fws":[1],
    15                 "ReturnType":"SIMD_type",
     14                "signature":"SIMD_type _mm_andnot_si128(SIMD_type arg2, SIMD_type arg1)",
     15                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     16                "return_type":"SIMD_type",
     17                "fws":[1],
    1618        },
    1719        "simd_or":\
    1820        {
    19                 "Pattern":"_mm_or_si128(arg1, arg2)",
    20                 "Fws":[1],
    21                 "ReturnType":"SIMD_type",
     21                "signature":"SIMD_type _mm_or_si128(SIMD_type arg1, SIMD_type arg2)",
     22                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     23                "return_type":"SIMD_type",
     24                "fws":[1],
    2225        },
    2326        "simd_xor":\
    2427        {
    25                 "Pattern":"_mm_xor_si128(arg1, arg2)",
    26                 "Fws":[1],
    27                 "ReturnType":"SIMD_type",
     28                "signature":"SIMD_type _mm_xor_si128(SIMD_type arg1, SIMD_type arg2)",
     29                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     30                "return_type":"SIMD_type",
     31                "fws":[1],
    2832        },
    2933        "simd_add":\
    3034        {
    31                 "Pattern":"_mm_add_epi$fw$(arg1, arg2)",
    32                 "Fws":[8, 16, 32, 64],
    33                 "ReturnType":"SIMD_type",
     35                "signature":"SIMD_type _mm_add_epi$fw$(SIMD_type arg1, SIMD_type arg2)",
     36                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     37                "return_type":"SIMD_type",
     38                "fws":[8, 16, 32, 64],
    3439        },
    3540        "simd_sub":\
    3641        {
    37                 "Pattern":"_mm_sub_epi$fw$(arg1, arg2)",
    38                 "Fws":[8, 16, 32, 64],
    39                 "ReturnType":"SIMD_type",
     42                "signature":"SIMD_type _mm_sub_epi$fw$(SIMD_type arg1, SIMD_type arg2)",
     43                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     44                "return_type":"SIMD_type",
     45                "fws":[8, 16, 32, 64],
    4046        },
    4147        "simd_umult":\
    4248        {
    43                 "Pattern":"_mm_mul_epu$fw$(arg1, arg2)",
    44                 "Fws":[32],
    45                 "ReturnType":"SIMD_type",
     49                "signature":"SIMD_type _mm_mul_epu$fw$(SIMD_type arg1, SIMD_type arg2)",
     50                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     51                "return_type":"SIMD_type",
     52                "fws":[32],
    4653        },
    4754        "simd_mult":\
    4855        {
    49                 "Pattern":"_mm_mullo_epi$fw$(arg1, arg2)",
    50                 "Fws":[16],
    51                 "ReturnType":"SIMD_type",
     56                "signature":"SIMD_type _mm_mullo_epi$fw$(SIMD_type arg1, SIMD_type arg2)",
     57                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     58                "return_type":"SIMD_type",
     59                "fws":[16],
    5260        },
    5361        "simd_eq":\
    5462        {
    55                 "Pattern":"_mm_cmpeq_epi$fw$(arg1, arg2)",
    56                 "Fws":[8, 16, 32],
    57                 "ReturnType":"SIMD_type",
     63                "signature":"SIMD_type _mm_cmpeq_epi$fw$(SIMD_type arg1, SIMD_type arg2)",
     64                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     65                "return_type":"SIMD_type",
     66                "fws":[8, 16, 32],
    5867        },
    5968        "simd_gt":\
    6069        {
    61                 "Pattern":"_mm_cmpgt_epi$fw$(arg1, arg2)",
    62                 "Fws":[8, 16, 32],
    63                 "ReturnType":"SIMD_type",
     70                "signature":"SIMD_type _mm_cmpgt_epi$fw$(SIMD_type arg1, SIMD_type arg2)",
     71                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     72                "return_type":"SIMD_type",
     73                "fws":[8, 16, 32],
    6474        },
    6575        "simd_max":\
    6676        {
    67                 "Pattern":"_mm_max_epi$fw$(arg1, arg2)",
    68                 "Fws":[16],
    69                 "ReturnType":"SIMD_type",
     77                "signature":"SIMD_type _mm_max_epi$fw$(SIMD_type arg1, SIMD_type arg2)",
     78                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     79                "return_type":"SIMD_type",
     80                "fws":[16],
    7081        },
    7182        "simd_umax":\
    7283        {
    73                 "Pattern":"_mm_max_epu$fw$(arg1, arg2)",
    74                 "Fws":[8],
    75                 "ReturnType":"SIMD_type",
     84                "signature":"SIMD_type _mm_max_epu$fw$(SIMD_type arg1, SIMD_type arg2)",
     85                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     86                "return_type":"SIMD_type",
     87                "fws":[8],
    7688        },
    7789        "simd_min":\
    7890        {
    79                 "Pattern":"_mm_min_epi$fw$(arg1, arg2)",
    80                 "Fws":[16],
    81                 "ReturnType":"SIMD_type",
     91                "signature":"SIMD_type _mm_min_epi$fw$(SIMD_type arg1, SIMD_type arg2)",
     92                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     93                "return_type":"SIMD_type",
     94                "fws":[16],
    8295        },
    8396        "simd_umin":\
    8497        {
    85                 "Pattern":"_mm_min_epu$fw$(arg1, arg2)",
    86                 "Fws":[8],
    87                 "ReturnType":"SIMD_type",
     98                "signature":"SIMD_type _mm_min_epu$fw$(SIMD_type arg1, SIMD_type arg2)",
     99                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     100                "return_type":"SIMD_type",
     101                "fws":[8],
    88102        },
    89103        "simd_srli":\
    90104        {
    91                 "Pattern":"_mm_srli_epi$fw$(arg1, sh)",
    92                 "Fws":[16, 32, 64],
    93                 "ReturnType":"SIMD_type",
     105                "signature":"SIMD_type _mm_srli_epi$fw$(SIMD_type arg1, int sh)",
     106                "args_type":{"arg1":"SIMD_type", "sh":"signed_int(32)"},
     107                "return_type":"SIMD_type",
     108                "fws":[16, 32, 64],
    94109        },
    95110        "simd_slli":\
    96111        {
    97                 "Pattern":"_mm_slli_epi$fw$(arg1, sh)",
    98                 "Fws":[16, 32, 64],
    99                 "ReturnType":"SIMD_type",
     112                "signature":"SIMD_type _mm_slli_epi$fw$(SIMD_type arg1, int sh)",
     113                "args_type":{"arg1":"SIMD_type", "sh":"signed_int(32)"},
     114                "return_type":"SIMD_type",
     115                "fws":[16, 32, 64],
    100116        },
    101117        "simd_srai":\
    102118        {
    103                 "Pattern":"_mm_srai_epi$fw$(arg1, sh)",
    104                 "Fws":[16, 32],
    105                 "ReturnType":"SIMD_type",
     119                "signature":"SIMD_type _mm_srai_epi$fw$(SIMD_type arg1, int sh)",
     120                "args_type":{"arg1":"SIMD_type", "sh":"signed_int(32)"},
     121                "return_type":"SIMD_type",
     122                "fws":[16, 32],
    106123        },
    107124        "simd_constant":\
    108125        {
    109                 "Pattern":"_mm_set1_epi$fw$(val)",
    110                 "Fws":[8, 16, 32],
    111                 "ReturnType":"SIMD_type",
     126                "signature":"SIMD_type _mm_set1_epi$fw$(int val)",
     127                "args_type":{"val":"signed_int(32)"},
     128                "return_type":"SIMD_type",
     129                "fws":[8, 16, 32],
    112130        },
    113131        "simd_abs":\
    114132        {
    115                 "Pattern":"_mm_abs_epi$fw$(arg1)",
    116                 "Fws":[8, 16, 32],
    117                 "ReturnType":"SIMD_type",
     133                "signature":"SIMD_type _mm_abs_epi$fw$(SIMD_type arg1)",
     134                "args_type":{"arg1":"SIMD_type"},
     135                "return_type":"SIMD_type",
     136                "fws":[8, 16, 32],
    118137        },
    119138        "hsimd_add_hl":\
    120139        {
    121                 "Pattern":"_mm_hadd_epi$fw/2$(arg2, arg1)",
    122                 "Fws":[32, 64],
    123                 "ReturnType":"SIMD_type",       
     140                "signature":"SIMD_type _mm_hadd_epi$fw/2$(SIMD_type arg2, SIMD_type arg1)",
     141                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     142                "return_type":"SIMD_type",
     143                "fws":[32, 64],
    124144        },
    125145        "hsimd_packus":\
    126146        {
    127                 "Pattern":"_mm_packus_epi$fw$(arg2, arg1)",
    128                 "Fws":[16],
    129                 "ReturnType":"SIMD_type",
     147                "signature":"SIMD_type _mm_packus_epi$fw$(SIMD_type arg2, SIMD_type arg1)",
     148                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     149                "return_type":"SIMD_type",
     150                "fws":[16],
    130151        },
    131152        "hsimd_packss":\
    132153        {
    133                 "Pattern":"_mm_packs_epi$fw$(arg2, arg1)",
    134                 "Fws":[16, 32],
    135                 "ReturnType":"SIMD_type",
     154                "signature":"SIMD_type _mm_packs_epi$fw$(SIMD_type arg2, SIMD_type arg1)",
     155                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     156                "return_type":"SIMD_type",
     157                "fws":[16, 32],
    136158        },
    137159        "hsimd_signmask":\
    138160        {
    139                 "Pattern":"_mm_movemask_epi$fw$(arg1)",
    140                 "Fws":[8],
    141                 "ReturnType":IntType,
     161                "signature":"int _mm_movemask_epi$fw$(SIMD_type arg1)",
     162                "args_type":{"arg1":"SIMD_type"},
     163                "return_type":"signed_int(32)",
     164                "fws":[8],
    142165        },
    143166        "esimd_mergeh":\
    144167        {
    145                 "Pattern":"_mm_unpackhi_epi$fw$(arg2, arg1)",
    146                 "Fws":[8, 16, 32, 64],
    147                 "ReturnType":"SIMD_type",
     168                "signature":"SIMD_type _mm_unpackhi_epi$fw$(SIMD_type arg2, SIMD_type arg1)",
     169                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     170                "return_type":"SIMD_type",
     171                "fws":[8, 16, 32, 64],
    148172        },
    149173        "esimd_mergel":\
    150174        {
    151                 "Pattern":"_mm_unpacklo_epi$fw$(arg2, arg1)",
    152                 "Fws":[8, 16, 32, 64],
    153                 "ReturnType":"SIMD_type",
     175                "signature":"SIMD_type _mm_unpacklo_epi$fw$(SIMD_type arg2, SIMD_type arg1)",
     176                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     177                "return_type":"SIMD_type",
     178                "fws":[8, 16, 32, 64],
    154179        },
    155180        "mvmd_fill":\
    156181        {
    157                 "Pattern":"_mm_set1_epi$fw$(val1)",
    158                 "Fws":[8, 16, 32],
    159                 "ReturnType":"SIMD_type",
     182                "signature":"SIMD_type _mm_set1_epi$fw$(int val1)",
     183                "args_type":{"val1":"signed_int(32)"},
     184                "return_type":"SIMD_type",
     185                "fws":[8, 16, 32],
    160186        },
    161187        "mvmd_fill4":\
    162188        {
    163                 "Pattern":"_mm_set_epi$fw$(val1, val2, val3, val4)",
    164                 "Fws":[32],
    165                 "ReturnType":"SIMD_type",
     189                "signature":"SIMD_type _mm_set_epi$fw$(int val1, int val2, int val3, int val4)",
     190                "args_type":{"val1":"signed_int(32)", "val2":"signed_int(32)", "val3":"signed_int(32)", "val4":"signed_int(32)"},
     191                "return_type":"SIMD_type",
     192                "fws":[32],
    166193        },
    167194        "mvmd_fill8":\
    168195        {
    169                 "Pattern":"_mm_set_epi$fw$(val1, val2, val3, val4, val5, val6, val7, val8)",
    170                 "Fws":[16],
    171                 "ReturnType":"SIMD_type",
     196                "signature":"SIMD_type _mm_set_epi$fw$(int val1, int val2, int val3, int val4, int val5, int val6, int val7, int val8)",
     197                "args_type":{"val1":"signed_int(32)", "val2":"signed_int(32)", "val3":"signed_int(32)", "val4":"signed_int(32)", \
     198                                        "val5":"signed_int(32)", "val6":"signed_int(32)", "val7":"signed_int(32)", "val8":"signed_int(32)"},
     199                "return_type":"SIMD_type",
     200                "fws":[16],
    172201        },
    173202        "mvmd_fill16":\
    174203        {
    175                 "Pattern":"_mm_set_epi$fw$(val1, val2, val3, val4, val5, val6, val7, val8, val9, val10, val11, val12, val13, val14, val15, val16)",
    176                 "Fws":[8],
    177                 "ReturnType":"SIMD_type",
     204                "signature":"SIMD_type _mm_set_epi$fw$(int val1, int val2, int val3, int val4, int val5, int val6, int val7, int val8, \
     205                                        int val9, int val10, int val11, int val12, int val13, int val14, int val15, int val16)",
     206                "args_type":{"val1":"signed_int(32)", "val2":"signed_int(32)", "val3":"signed_int(32)", "val4":"signed_int(32)", \
     207                                        "val5":"signed_int(32)", "val6":"signed_int(32)", "val7":"signed_int(32)", "val8":"signed_int(32)", \
     208                                        "val9":"signed_int(32)", "val10":"signed_int(32)", "val11":"signed_int(32)", "val12":"signed_int(32)", \
     209                                        "val13":"signed_int(32)", "val14":"signed_int(32)", "val15":"signed_int(32)", "val16":"signed_int(32)"},
     210                "return_type":"SIMD_type",
     211                "fws":[8],
    178212        },
    179213        "mvmd_shufflei":\
    180214        {
    181                 "Pattern":"_mm_shuffle_epi$fw$(arg1, msk)",
    182                 "Fws":[32],
    183                 "ReturnType":"SIMD_type",
     215                "signature":"SIMD_type _mm_shuffle_epi$fw$(SIMD_type arg1, int msk)",
     216                "args_type":{"arg1":"SIMD_type", "msk":"signed_int(32)"},
     217                "return_type":"SIMD_type",
     218                "fws":[32],
    184219        },
    185220        "mvmd_shuffle":\
    186221        {
    187                 "Pattern":"_mm_shuffle_epi$fw$(arg1, arg2)",
    188                 "Fws":[8],
    189                 "ReturnType":"SIMD_type",
    190         },
    191         "bitblock_load_aligned":\
    192         {
    193                 "Pattern":"_mm_load_si$fw$(arg1)",
    194                 "Fws":[128],
    195                 "ReturnType":"SIMD_type",
    196         },
    197         "bitblock_load_unaligned":\
    198         {
    199                 "Pattern":"_mm_lddqu_si$fw$ (arg1)",
    200                 "Fws":[128],
    201                 "ReturnType":"SIMD_type",
    202         },
    203         "bitblock_store_aligned":\
    204         {
    205                 "Pattern":"_mm_store_si$fw$(arg1, arg2)",
    206                 "Fws":[128],
    207                 "ReturnType":"void",
    208         },
    209         "bitblock_store_unaligned":\
    210         {
    211                 "Pattern":"_mm_storeu_si$fw$(arg1, arg2)",
    212                 "Fws":[128],
    213                 "ReturnType":"void",
     222                "signature":"SIMD_type _mm_shuffle_epi$fw$(SIMD_type arg1, SIMD_type arg2)",
     223                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     224                "return_type":"SIMD_type",
     225                "fws":[8],
    214226        },
    215227        "_mm_sll_epi64":\
    216228        {
    217                 "Pattern":"_mm_sll_epi64(arg1, sh)",
    218                 "Fws":[64],
    219                 "ReturnType":"SIMD_type",
     229                "signature":"SIMD_type _mm_sll_epi64(SIMD_type arg1, SIMD_type sh)",
     230                "args_type":{"arg1":"SIMD_type", "sh":"SIMD_type"},
     231                "return_type":"SIMD_type",
     232                "fws":[64],
    220233        },
    221234        "_mm_slli_si128":\
    222235        {
    223                 "Pattern":"_mm_slli_si128(arg1, arg2)",
    224                 "Fws":[128],
    225                 "ReturnType":"SIMD_type",
     236                "signature":"SIMD_type _mm_slli_si128(SIMD_type arg1, int sh)",
     237                "args_type":{"arg1":"SIMD_type", "sh":"signed_int(32)"},
     238                "return_type":"SIMD_type",
     239                "fws":[128],
    226240        },
    227241        "_mm_srl_epi64":\
    228242        {
    229                 "Pattern":"_mm_srl_epi64(arg1, sh)",
    230                 "Fws":[64],
    231                 "ReturnType":"SIMD_type",
     243                "signature":"SIMD_type _mm_srl_epi64(SIMD_type arg1, SIMD_type sh)",
     244                "args_type":{"arg1":"SIMD_type", "sh":"SIMD_type"},
     245                "return_type":"SIMD_type",
     246                "fws":[64],
    232247        },
    233248        "_mm_srli_si128":\
    234249        {
    235                 "Pattern":"_mm_srli_si128(arg1, arg2)",
    236                 "Fws":[128],
    237                 "ReturnType":"SIMD_type",
     250                "signature":"SIMD_type _mm_srli_si128(SIMD_type arg1, int sh)",
     251                "args_type":{"arg1":"SIMD_type", "sh":"signed_int(32)"},
     252                "return_type":"SIMD_type",
     253                "fws":[128],
    238254        },
    239255        "_mm_set_epi32":\
    240256        {
    241                 "Pattern":"_mm_set_epi32(val)",
    242                 "Fws":[32],
    243                 "ReturnType":"SIMD_type",
     257                "signature":"SIMD_type _mm_set_epi32(int val1, int val2, int val3, int val4)",
     258                "args_type":{"val1":"signed_int(32)", "val2":"signed_int(32)", "val3":"signed_int(32)", "val4":"signed_int(32)"},
     259                "return_type":"SIMD_type",
     260                "fws":[32],
    244261        },
    245262        "_mm_set1_epi32":\
    246263        {
    247                 "Pattern":"_mm_set1_epi32(val)",
    248                 "Fws":[32],
    249                 "ReturnType":"SIMD_type",
     264                "signature":"SIMD_type _mm_set1_epi32(int val1)",
     265                "args_type":{"val1":"signed_int(32)"},
     266                "return_type":"SIMD_type",
     267                "fws":[32],
    250268        },
    251269        "_mm_cvtsi32_si128":\
    252270        {
    253                 "Pattern":"_mm_cvtsi32_si128(val)",
    254                 "Fws":[128],
    255                 "ReturnType":"SIMD_type",
     271                "signature":"SIMD_type _mm_cvtsi32_si128(int val1)",
     272                "args_type":{"val1":"signed_int(32)"},
     273                "return_type":"SIMD_type",
     274                "fws":[128],
    256275        },
    257276        "_mm_shufflehi_epi16":\
    258277        {
    259                 "Pattern":"_mm_shufflehi_epi16(arg1, msk)",
    260                 "Fws":[16],
    261                 "ReturnType":"SIMD_type",
     278                "signature":"SIMD_type _mm_shufflehi_epi16(SIMD_type arg1, int msk)",
     279                "args_type":{"arg1":"SIMD_type", "msk":"signed_int(32)"},
     280                "return_type":"SIMD_type",
     281                "fws":[16],
    262282        },
    263283        "_mm_shufflelo_epi16":\
    264284        {
    265                 "Pattern":"_mm_shufflelo_epi16(arg1, msk)",
    266                 "Fws":[16],
    267                 "ReturnType":"SIMD_type",
     285                "signature":"SIMD_type _mm_shufflelo_epi16(SIMD_type arg1, int msk)",
     286                "args_type":{"arg1":"SIMD_type", "msk":"signed_int(32)"},
     287                "return_type":"SIMD_type",
     288                "fws":[16],
    268289        },
    269290        "_mm_sad_epu8":\
    270291        {
    271                 "Pattern":"_mm_sad_epu8(arg1, arg2)",
    272                 "Fws":[8],
    273                 "ReturnType":"SIMD_type",
     292                "signature":"SIMD_type _mm_sad_epu8(SIMD_type arg1, SIMD_type arg2)",
     293                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     294                "return_type":"SIMD_type",
     295                "fws":[8],
    274296        },
    275297        "_mm_hsub_epi16":\
    276298        {
    277                 "Pattern":"_mm_hsub_epi16(arg1, arg2)",
    278                 "Fws":[16],
    279                 "ReturnType":"SIMD_type",
     299                "signature":"SIMD_type _mm_hsub_epi16(SIMD_type arg1, SIMD_type arg2)",
     300                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     301                "return_type":"SIMD_type",
     302                "fws":[16],
    280303        },
    281304        "_mm_hsub_epi32":\
    282305        {
    283                 "Pattern":"_mm_hsub_epi32(arg1, arg2)",
    284                 "Fws":[32],
    285                 "ReturnType":"SIMD_type",
     306                "signature":"SIMD_type _mm_hsub_epi32(SIMD_type arg1, SIMD_type arg2)",
     307                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     308                "return_type":"SIMD_type",
     309                "fws":[32],
    286310        },
    287311        "_mm_sign_epi8":\
    288312        {
    289                 "Pattern":"_mm_sign_epi8(arg1, arg2)",
    290                 "Fws":[8],
    291                 "ReturnType":"SIMD_type",
     313                "signature":"SIMD_type _mm_sign_epi8(SIMD_type arg1, SIMD_type arg2)",
     314                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     315                "return_type":"SIMD_type",
     316                "fws":[8],
    292317        },
    293318        "_mm_sign_epi16":\
    294319        {
    295                 "Pattern":"_mm_sign_epi16(arg1, arg2)",
    296                 "Fws":[16],
    297                 "ReturnType":"SIMD_type",
     320                "signature":"SIMD_type _mm_sign_epi16(SIMD_type arg1, SIMD_type arg2)",
     321                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     322                "return_type":"SIMD_type",
     323                "fws":[16],
    298324        },
    299325        "_mm_sign_epi32":\
    300326        {
    301                 "Pattern":"_mm_sign_epi32(arg1, arg2)",
    302                 "Fws":[32],
    303                 "ReturnType":"SIMD_type",
     327                "signature":"SIMD_type _mm_sign_epi32(SIMD_type arg1, SIMD_type arg2)",
     328                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     329                "return_type":"SIMD_type",
     330                "fws":[32],
    304331        },
    305332        "_mm_extract_epi16":\
    306333        {
    307                 "Pattern":"_mm_extract_epi16(arg1, pos)",
    308                 "Fws":[16],
    309                 "ReturnType":"SIMD_type",
     334                "signature":"int _mm_extract_epi16(SIMD_type arg1, int pos)",
     335                "args_type":{"arg1":"SIMD_type", "pos":"signed_int(32)"},
     336                "return_type":"signed_int(32)",
     337                "fws":[16],
    310338        },
    311339}
  • trunk/libgen/Library_Generator/StrategyPool.py

    r1494 r1521  
    740740                "constant_1_blend":\
    741741                {
    742                 #simd<1>::constant only accepts 0 or -1
    743                 "body":r'''
    744 return simd_constant(32, val)
     742                #simd<1>::constant only accepts 0 or 1
     743                "body":r'''
     744return simd_constant(32, -1*val)
    745745''',
    746746                "Ops":["simd_constant"],
     
    752752                {
    753753                "body":r'''
    754 return _mm_set_epi32(0, val, 0, val) if val>=0 else _mm_set_epi32(-1, val, -1, val)
     754return _mm_set_epi32(val>>32, val, val>>32, val)
    755755''',
    756756                "Ops":["simd_constant"],
     
    762762                {
    763763                "body":r'''
    764 return IDISA_CASTING("SIMD_type", _mm256_set_epi32(0, val, 0, val, 0, val, 0, val)) if val>=0 else IDISA_CASTING("SIMD_type", _mm256_set_epi32(-1, val, -1, val, -1, val, -1, val))''',
     764return IDISA_CASTING("SIMD_type", _mm256_set_epi32(val>>32, val, val>>32, val, val>>32, val, val>>32, val))''',
    765765                "Ops":["simd_constant"],
    766766                "Fws":[64],
     
    771771                {
    772772                "body":r'''
    773 return _mm_set_epi32(0, 0, 0, val) if val>=0 else _mm_set_epi32(-1, -1, -1, val)
     773return _mm_set_epi32(0, 0, val>>32, val)
    774774''',
    775775                "Ops":["simd_constant"],
     
    781781                {
    782782                "body":r'''
    783 return IDISA_CASTING("SIMD_type", _mm256_set_epi32(0, 0, 0, val, 0, 0, 0, val)) if val>=0 else IDISA_CASTING("SIMD_type", _mm256_set_epi32(-1, -1, -1, val, -1, -1, -1, val))''',
     783return IDISA_CASTING("SIMD_type", _mm256_set_epi32(0, 0, val>>32, val, 0, 0, val>>32, val))''',
    784784                "Ops":["simd_constant"],
    785785                "Fws":[128],
     
    790790                {
    791791                "body":r'''
    792 return IDISA_CASTING("SIMD_type", _mm256_set_epi32(0, 0, 0, 0, 0, 0, 0, val)) if val>=0 else IDISA_CASTING("SIMD_type", _mm256_set_epi32(-1, -1, -1, -1, -1, -1, -1, val))''',
     792return IDISA_CASTING("SIMD_type", _mm256_set_epi32(0, 0, 0, 0, 0, 0, val>>32, val))''',
    793793                "Ops":["simd_constant"],
    794794                "Fws":[256],
     
    10851085                "Platforms":[configure.ALL],
    10861086                },
     1087       
     1088                "signmask_avx":\
     1089                {
     1090                "body":r'''
     1091return (IDISA_CASTING("uint64_t", _mm_movemask_epi8(IDISA_CASTING("__m128i", avx_select_hi128(arg1))))<<16) | IDISA_CASTING("uint64_t", _mm_movemask_epi8(IDISA_CASTING("__m128i", avx_select_lo128(arg1))))''',
     1092                "Ops":["hsimd_signmask"],
     1093                "Fws":[8],
     1094                "Platforms":[configure.AVX],
     1095                },
    10871096                       
    10881097                "merge_doubling":\
     
    11021111''',
    11031112                "Ops":["esimd_mergel", "esimd_mergeh"],
    1104                 "Fws":range(1, curRegSize/2),
    1105                 "Platforms":[configure.ALL],
     1113                "Fws":range(1, curRegSize/2+1),
     1114                "Platforms":[configure.ALL],
     1115                },
     1116               
     1117                "mergeh_avx_using_SSE_BuiltIns":\
     1118                {
     1119                "body":r'''
     1120hiPart2 = avx_select_hi128(arg2)
     1121hiPart1 = avx_select_hi128(arg1)
     1122return avx_general_combine256(IDISA_PACK("_mm_unpackhi_epi$fw$", hiPart2, hiPart1), IDISA_PACK("_mm_unpacklo_epi$fw$", hiPart2, hiPart1))''',
     1123                "Ops":["esimd_mergeh"],
     1124                "Fws":[8, 16, 32, 64],
     1125                "Platforms":[configure.AVX],
     1126                },
     1127
     1128                "mergel_avx_using_SSE_BuiltIns":\
     1129                {
     1130                "body":r'''
     1131loPart2 = avx_select_lo128(arg2)
     1132loPart1 = avx_select_lo128(arg1)
     1133return avx_general_combine256(IDISA_PACK("_mm_unpackhi_epi$fw$", loPart2, loPart1), IDISA_PACK("_mm_unpacklo_epi$fw$", loPart2, loPart1))''',
     1134                "Ops":["esimd_mergel"],
     1135                "Fws":[8, 16, 32, 64],
     1136                "Platforms":[configure.AVX],
    11061137                },
    11071138               
     
    12531284                {
    12541285                "body":r'''
    1255 return mvmd_fill(2*fw, (val1<<fw)|(val1^(-1<<fw))) if val1<0 else mvmd_fill(2*fw, (val1<<fw)|val1)
     1286return mvmd_fill(2*fw, (val1<<fw)|val1)
    12561287''',
    12571288                "Ops":["mvmd_fill"],
     
    12641295                #mvmd<1>::fill only accepts 0 or -1
    12651296                "body":r'''
    1266 return mvmd_fill(32, val1)
     1297return mvmd_fill(32, -1*val1)
    12671298''',
    12681299                "Ops":["mvmd_fill"],
     
    12741305                {
    12751306                "body":r'''
    1276 return _mm_set_epi32(0, val1, 0, val1) if val1>=0 else _mm_set_epi32(-1, val1, -1, val1)
     1307return _mm_set_epi32(val1>>32, val1, val1>>32, val1)
    12771308''',
    12781309                "Ops":["mvmd_fill"],
     
    12841315                {
    12851316                "body":r'''
    1286 return _mm_set_epi32(0, 0, 0, val1) if val1>=0 else _mm_set_epi32(-1, -1, -1, val1)
     1317return _mm_set_epi32(0, 0, val1>>32, val1)
    12871318''',
    12881319                "Ops":["mvmd_fill"],
     
    15341565                },
    15351566               
     1567                "mvmd_extract_havling":\
     1568                {
     1569                "body":r'''
     1570return ((IDISA_CASTING("uint64_t", mvmd_extract(fw/2, 2*pos+1, arg1))<<(fw/2)) | mvmd_extract(fw/2, 2*pos, arg1))''',
     1571                "Ops":["mvmd_extract"],
     1572                "Fws":range(2, 64+1),
     1573                "Platforms":[configure.ALL],
     1574                },#IDISA_CASTING("uint64_t", ((1<<fw)-1)) &
     1575               
     1576                "mvmd_extract_8_SSE":\
     1577                {
     1578                "body":r'''
     1579return 255 & _mm_extract_epi8(arg1, pos)''',
     1580                "Ops":["mvmd_extract"],
     1581                "Fws":[8],
     1582                "Platforms":[arch for arch in configure.SSE_SERIES],
     1583                },
     1584               
     1585                "mvmd_extract_8_AVX":\
     1586                {
     1587                "body":r'''
     1588return (255 & _mm_extract_epi8(avx_select_lo128(arg1), pos)) if (pos<16) else (255 & _mm_extract_epi8(avx_select_hi128(arg1), pos-16))
     1589''',
     1590                "Ops":["mvmd_extract"],
     1591                "Fws":[8],
     1592                "Platforms":[configure.AVX],
     1593                },
     1594       
     1595                "mvmd_extract_16_SSE":\
     1596                {
     1597                "body":r'''
     1598return 65535 & _mm_extract_epi16(arg1, pos)''',
     1599                "Ops":["mvmd_extract"],
     1600                "Fws":[16],
     1601                "Platforms":[arch for arch in configure.SSE_SERIES],
     1602                },
     1603
     1604                "mvmd_extract_16_AVX":\
     1605                {
     1606                "body":r'''
     1607return (65535 & _mm_extract_epi16(avx_select_lo128(arg1), pos)) if (pos<8) else (65535 & _mm_extract_epi16(avx_select_hi128(arg1), pos-8))
     1608''',
     1609                "Ops":["mvmd_extract"],
     1610                "Fws":[16],
     1611                "Platforms":[configure.AVX],
     1612                },
     1613
     1614                "mvmd_extract_32_SSE":\
     1615                {
     1616                "body":r'''
     1617return IDISA_CASTING("uint64_t", (1<<32)-1) & _mm_extract_epi32(arg1, pos)''',
     1618                "Ops":["mvmd_extract"],
     1619                "Fws":[32],
     1620                "Platforms":[arch for arch in configure.SSE_SERIES],
     1621                },
     1622
     1623                "mvmd_extract_32_AVX":\
     1624                {
     1625                "body":r'''
     1626return (IDISA_CASTING("uint64_t", (1<<32)-1) & _mm_extract_epi32(avx_select_lo128(arg1), pos)) if (pos<4) else (IDISA_CASTING("uint64_t", (1<<32)-1) & _mm_extract_epi32(avx_select_hi128(arg1), pos-4))
     1627''',
     1628                "Ops":["mvmd_extract"],
     1629                "Fws":[32],
     1630                "Platforms":[configure.AVX],
     1631                },
     1632
     1633                "mvmd_extract_doubling":\
     1634                {
     1635                "body":r'''
     1636return (mvmd_extract(2*fw, pos/2, arg1) & ((1<<fw)-1)) if pos%2==0 else (mvmd_extract(2*fw, pos/2, arg1)>>fw)''',
     1637                "Ops":["mvmd_extract"],
     1638                "Fws":range(1, 32+1),
     1639                "Platforms":[configure.ALL],
     1640                },
     1641               
    15361642                "simd_add_2_logic":\
    15371643                {
     
    17171823                },
    17181824               
     1825                "bitblock_any_avx":\
     1826                {
     1827                "body":r'''
     1828return _mm256_testz_si256(IDISA_CASTING("__m256i", arg1), IDISA_CASTING("__m256i", arg1)) == 0''',
     1829                "Ops":["bitblock_any"],
     1830                "Fws":[curRegSize],
     1831                "Platforms":[configure.AVX],
     1832                },
     1833
    17191834#               "bitblock_any_using_PTEST":\
    17201835#               {
     
    17331848                "Platforms":[arch for arch in configure.SSE_SERIES],
    17341849                },
     1850       
     1851                "bitblock_all_avx_using_VPTEST":\
     1852                {
     1853                "body":r'''
     1854return _mm256_testz_si256(IDISA_CASTING("__m256i", simd_not(arg1)), IDISA_CASTING("__m256i", simd_constant(8, -1))) == 1''',
     1855                "Ops":["bitblock_all"],
     1856                "Fws":[curRegSize],
     1857                "Platforms":[configure.AVX],
     1858                },
    17351859               
    17361860#               "bitblock_all_using_PTEST":\
  • trunk/libgen/Library_Generator/UI.py

    r1458 r1521  
    1212        return (uiInput.arch, uiInput.lang)
    1313
    14 def WriteCodes(operationSetResult, arch, lang):
    15         UiOutput(operationSetResult, arch, lang)
     14def WriteCodes(operationSetResult, arch, lang, outfile, whichContent):
     15        UiOutput(operationSetResult, arch, lang, outfile, whichContent)
    1616
    1717class UiInput:
     
    7575
    7676class UiOutput:
    77         def __init__(self, operationSetResult, arch, lang):
     77        def __init__(self, operationSetResult, arch, lang, outfile, whichContent):
    7878               
    7979                if lang == configure.Language_C:
    80                         self.WriteCCodes(operationSetResult, arch, lang)
     80                        self.WriteCCodes(operationSetResult, arch, lang, whichContent)
    8181                elif lang == configure.Language_CPP:
    82                         self.WriteCodes(operationSetResult, arch, lang)
    83                         self.WriteValidOperations(operationSetResult, arch)
    84                
    85         def PreliminaryCodes(self, arch, lang):
     82                        self.WriteCodes(operationSetResult, arch, lang, outfile, whichContent)
     83                        self.WriteValidOperations(operationSetResult, arch, outfile)
     84               
     85        def PreliminaryCodes(self, arch, lang, outfile, whichContent):
    8686                codes = ""
    87 #               if arch in configure.InstructionSetLibrary:
    88 #                       codes = configure.InstructionSetLibrary[arch] + "\n\n"
    89 #               else:
    90 #                       print "arch is not supported currently!"
    91                
    9287                if lang == configure.Language_C:
    9388                        codes += "#ifndef " + "_IDISA_" + arch.upper() + "_" + "C" + "_" + "H" + "\n"
     
    9691                        codes += "typedef " + configure.SIMD_type[arch] + " SIMD_type;\n"
    9792                elif lang == configure.Language_CPP:
    98                         codes += "#ifndef " + "_IDISA_" + arch.upper() + "_" + "H" + "\n"
    99                         codes += "#define " + "_IDISA_" + arch.upper() + "_" + "H" + "\n"
    100                         codes += '''#include "''' + configure.InstructionSetLibrary[arch] + '''"\n\n'''
    101                         codes += "typedef " + configure.SIMD_type[arch] + " SIMD_type;\n"
     93                        #codes += "#ifndef " + "_IDISA_" + arch.upper() + "_" + "H" + "\n"
     94                        codes += "#ifndef " + outfile.replace(".", "_").upper() + "\n"
     95                        #codes += "#define " + "_IDISA_" + arch.upper() + "_" + "H" + "\n"
     96                        codes += "#define " + outfile.replace(".", "_").upper() + "\n"
     97                       
     98                        if whichContent == configure.Body_Declaration:
     99                                codes += configure.Macro_Idisa128_Hpp if "idisa128" in outfile.lower() else configure.Macro_Idisa256_Hpp
     100                        elif whichContent == configure.Body_Implementation:
     101                                codes += '''#include "''' + configure.InstructionSetLibrary[arch] + '''"\n\n'''
     102                                codes += "typedef " + configure.SIMD_type[arch] + " " + configure.Bitblock_type[arch] + ";\n"
     103                        else:
     104                                codes += '''#include "''' + configure.InstructionSetLibrary[arch] + '''"\n'''
     105                                codes += '''#include <stdint.h>\n\n'''
     106                                codes += "typedef " + configure.SIMD_type[arch] + " " + configure.Bitblock_type[arch] + ";\n"
    102107                else:
    103108                        pass
     
    115120                return functionDef
    116121
    117         def WriteCodes(self, operationSetResult, arch, lang):
     122        def WriteCodes(self, operationSetResult, arch, lang, outfile, whichContent):
    118123                allClasses = ["simd", "hsimd", "esimd", "mvmd", "bitblock"]
    119124                operationImp = {}
     
    121126               
    122127                #Output the header file
    123                 fileOut = open("idisa"+'_'+arch.lower()+'.h', 'w')
     128                #fileOut = open("idisa"+'_'+arch.lower()+'.h', 'w')
     129                fileOut = open(outfile, 'w')
     130               
    124131                (optOpCount, optOpCodes, opMaxCount) = (operationSetResult.optOpCount, operationSetResult.optOpCodes, operationSetResult.opMaxCount)
    125                 fileOut.write(self.PreliminaryCodes(arch, lang))
     132               
     133                fileOut.write(self.PreliminaryCodes(arch, lang, outfile, whichContent))
    126134               
    127135                for classType in allClasses:
     
    136144                               
    137145                                if operationTmp.classType == classType:
    138                                         curClass.Append( Utility.LibFunction(operationTmp) )
     146                                        #curClass.Append( Utility.LibFunction(operationTmp) )
     147                                        opSignatures = {}
    139148                                        for fw in Utility.GetValidFieldWidth(configure.RegisterSize[arch]):
    140149                                                operation = Utility.definedOperations[opName][fw]
    141150                                                if optOpCount[operation.fullName + "_" + str(fw)] < opMaxCount:
    142151                                                                curOperation = Utility.LibFunction(operation, optOpCount[operation.fullName + "_" + str(fw)], optOpCodes[operation.fullName + "_" + str(fw)])
     152                                                                curSignature = curOperation.ClassDeclarationToCppText()
     153                                                                if curSignature not in opSignatures:
     154                                                                        opSignatures[curSignature] = True
     155                                                                        curClass.Append(curOperation)
    143156                                                                #curOperation.SetBodyContent(optOpCodes[operation.fullName + "_" + str(fw)])
    144157                                                                operationImp[classType][operation.fullName].append(curOperation.ToCppText())
    145158                                                                operationDecla[classType][operation.fullName].append(curOperation.FunctionDeclarationToCppText())
    146                                                
    147                         fileOut.write(curClass.ToCppText())
    148                
    149                 fileOut.write("//Declaration Part" + "\n")
    150                 for opName in Utility.definedOperations:
    151                         operationTmp = Utility.definedOperations[opName][1]
    152                         if operationTmp.classType == "":
    153                         #logic operations
    154                                 curOperation = Utility.LibFunction(operationTmp)
    155                                 if optOpCount[operationTmp.fullName + "_" + str(1)] < opMaxCount:
    156                                         fileOut.write(curOperation.FunctionDeclarationToCppText() + ";\n")
    157                                
    158                 for classType in allClasses:
    159                         if classType == "bitblock":
    160                                 continue
    161                         for op in operationDecla[classType]:
    162                                 for decla in operationDecla[classType][op]:
    163                                         fileOut.write(decla + ";\n")
    164                 fileOut.write("\n")
    165                
    166                 fileOut.write("//Implementation Part" + "\n")
    167                 #write pre-defined functions first
    168                 for func in Utility.usedFunctionSupport:
    169                         fileOut.write(Utility.functionSupport[func]["body"] + "\n")
    170                
    171                 for opName in Utility.definedOperations:
    172                         operationTmp = Utility.definedOperations[opName][1]
    173                         if operationTmp.classType == "" and optOpCount[operationTmp.fullName + "_" + str(1)] < opMaxCount:
    174                         #logic operations
    175                                 curOperation = Utility.LibFunction(operationTmp, optOpCount[operationTmp.fullName + "_" + str(1)], optOpCodes[operationTmp.fullName + "_" + str(1)])
    176                                 fileOut.write(curOperation.ToCppText() + "\n")
    177                                
    178                 for classType in allClasses:
    179                         for op in operationImp[classType]:
    180                                 for imp in operationImp[classType][op]:
    181                                         fileOut.write(imp + "\n")
     159                       
     160                        if whichContent != configure.Body_Declaration:                 
     161                                fileOut.write(curClass.ToCppText())
     162               
     163                if whichContent != configure.Body_Declaration:
     164                        fileOut.write("//Declaration Part" + "\n")
     165               
     166                        for opName in Utility.definedOperations:
     167                                operationTmp = Utility.definedOperations[opName][1]
     168                                if operationTmp.classType == "":
     169                                        #logic operations
     170                                        curOperation = Utility.LibFunction(operationTmp)
     171                                        if optOpCount[operationTmp.fullName + "_" + str(1)] < opMaxCount:
     172                                                fileOut.write(curOperation.FunctionDeclarationToCppText() + ";\n")
     173                               
     174                        for classType in allClasses:
     175                                if classType == "bitblock":
     176                                        continue
     177                                for op in operationDecla[classType]:
     178                                        for decla in operationDecla[classType][op]:
     179                                                fileOut.write(decla + ";\n")
     180                        fileOut.write("\n")
     181               
     182                if whichContent != configure.Body_Declaration:
     183                        fileOut.write("//Implementation Part" + "\n")
     184                        #write pre-defined functions first
     185                        for func in Utility.usedFunctionSupport:
     186                                fileOut.write(Utility.functionSupport[func]["body"] + "\n")
     187               
     188                        for opName in Utility.definedOperations:
     189                                operationTmp = Utility.definedOperations[opName][1]
     190                                if operationTmp.classType == "" and optOpCount[operationTmp.fullName + "_" + str(1)] < opMaxCount:
     191                                        #logic operations
     192                                        curOperation = Utility.LibFunction(operationTmp, optOpCount[operationTmp.fullName + "_" + str(1)], optOpCodes[operationTmp.fullName + "_" + str(1)])
     193                                        fileOut.write(curOperation.ToCppText() + "\n")
     194                               
     195                        for classType in allClasses:
     196                                for op in operationImp[classType]:
     197                                        for imp in operationImp[classType][op]:
     198                                                fileOut.write(imp + "\n")
    182199               
    183200                fileOut.write("#endif")                 
     
    193210                #fileOut.close()
    194211       
    195         def WriteValidOperations(self, operationSetResult, arch):
    196                 fileOut = open("idisa"+"_"+arch.lower()+".db", 'w')
     212        def WriteValidOperations(self, operationSetResult, arch, outfile):
     213                #fileOut = open("idisa"+"_"+arch.lower()+".db", 'w')
     214                if ".hpp" in outfile:
     215                        fileOut = open(outfile.replace(".hpp", ".db"), 'w')
     216                elif ".cpp" in outfile:
     217                        fileOut = open(outfile.replace(".cpp", ".db"), 'w')
     218                else:
     219                        fileOut = open(outfile.replace(".h", ".db"), 'w')
    197220                (optOpCount, opMaxCount) = (operationSetResult.optOpCount, operationSetResult.opMaxCount)
    198221                opNameFilter = ["bitblock_load_aligned", "bitblock_load_unaligned", "bitblock_store_aligned", "bitblock_store_unaligned"]
     
    224247                fileOut.close()
    225248       
    226         def WriteCCodes(self, operationSetResult, arch, lang):
     249        def WriteCCodes(self, operationSetResult, arch, lang, whichContent):
    227250                fileOut = open("idisa"+'_'+arch.lower()+"_"+"c.h", "w")
    228251                (optOpCount, optOpCodes, opMaxCount) = (operationSetResult.optOpCount, operationSetResult.optOpCodes, operationSetResult.opMaxCount)
     
    266289                fileOut.write("#endif")
    267290                fileOut.close()
    268 '''
    269 if __name__ == "__main__":
    270         simdClass = UIClass("simd")
    271         hsimdClass = UIClass("hsimd")
    272         esimdClass = UIClass("esimd")
    273         msimdClass = UIClass("mvmd")
    274         for op in configure.AllOperations:
    275                 singleOp = Operation.Operation(configure.AllOperations[op], "SSE2")
    276                 if singleOp.classType == "simd":
    277                         simdClass.Append( UIFunction(singleOp) )
    278                 elif singleOp.classType == "hsimd":
    279                         hsimdClass.Append( UIFunction(singleOp) )
    280                 elif singleOp.classType == "esimd":
    281                         esimdClass.Append( UIFunction(singleOp) )
    282                 elif singleOp.classType == "mvmd":
    283                         msimdClass.Append( UIFunction(singleOp) )
    284        
    285         print simdClass.ToCppText()
    286         for func in simdClass.body:
    287                 print func.ToCppText()
    288                
    289         print hsimdClass.ToCppText()
    290         for func in hsimdClass.body:
    291                 print func.ToCppText()
    292        
    293         print esimdClass.ToCppText()
    294         for func in esimdClass.body:
    295                 print func.ToCppText()
    296        
    297         print msimdClass.ToCppText()
    298         for func in msimdClass.body:
    299                 print func.ToCppText()
    300 '''
  • trunk/libgen/Library_Generator/Utility.py

    r1369 r1521  
    11import sys
    22import os
     3import math
    34
    45os.chdir(sys.path[0])
     
    89import configure
    910import OptParser
     11import BuiltIns
    1012
    1113#This dictionary stores all the simd operations with class_func as the format for keys
     
    3234#This is an interface for returning the calling statements of a function given its all arguments
    3335#e.g. given function name = "foo" and arguments = [arg1, arg2], then it returns "foo(arg1, arg2)"
    34 def CallingStatement(func, args):
     36def CallingStatement(func, arch, args):
     37        if builtIns.IsOperationBuiltIn(func):
     38                builtInOp = BuiltIns.BuiltInOperation(arch, builtIns.builtInsTable[func]["signature"], builtIns.builtInsTable[func]["args_type"])
     39                builtInOp.arguments = args
     40                return builtInOp.GetCallingConvention()
     41       
    3542        text = func
    3643        text += "("
     
    6673                if "all" in allFuncs[func]["platform"] or arch in allFuncs[func]["platform"]:
    6774                        retFuncs[func] = allFuncs[func]
     75                        retFuncs[func]["body"] = retFuncs[func]["body"].replace("(SIMD_type)", "("+configure.Bitblock_type[arch]+")")
    6876
    6977        return retFuncs
     
    7785                rPos -= 1
    7886        return CleanBrackets(expr[lPos+1:rPos])
    79        
     87
     88def EvalStr(expr, regSize, fw):
     89        expr = expr[expr.find("(")+1:-1]
     90        expr = expr.replace("fw", str(fw)).replace("curRegSize", str(regSize))
     91        return [eval(val) for val in expr.split(",", 1)]
     92
     93def GetMinMax(expr):
     94        if isinstance(expr, str):
     95                fw = eval(''.join(ch for ch in expr if ch.isdigit()))
     96                fw = 64 if fw >= 64 else fw
     97                return (0, (2**fw)-1)
     98        elif isinstance(expr, list):
     99                return (expr[0], expr[-1])
     100        print expr
     101        assert True==False, "Unknown expr for GetMinMax!"
     102
    80103# This part is about definition of LibClass, LibFunction and LibVariable, in which,
    81104# LibClass is the class to describe general interfaces of classes(such as simd, hsimd, esimd, mvmd);
     
    93116               
    94117        def ToCppText(self):
    95                 cppText = "template <int fw>\n" if self.templatedClass==True else ""
     118                cppText = "template <uint32_t fw>\n" if self.templatedClass==True else ""
    96119                cppText += self.type + " " + self.name + "\n"
    97120                cppText += "{\n"
     
    108131class LibFunction:
    109132        def __init__(self, operation, cost=0, body=""):
     133                self.arch = operation.arch
    110134                self.name = operation.name
    111135                self.type = "function"
  • trunk/libgen/Library_Tester/CalculatingModules/hsimd_signmask.py

    r1237 r1521  
    88                ans += arg1[i]
    99                i += fw
    10         ans = ("" if len(ans) >= 32 else "0"*(32-len(ans))) + ans
    11         #the result should be a 32-bits integer
    12         return utility.TwosComplement(32, ans)
     10        ans = ("" if len(ans) >= 64 else "0"*(64-len(ans))) + ans
     11        #the result should be a 64-bits unsigned integer
     12        return int(ans, 2)
    1313
    1414'''
  • trunk/libgen/Library_Tester/GenData.py

    r1494 r1521  
    11import random
     2
     3from TesterUtility import configure
    24
    35def Flip(bits, fw, num):
     
    7274                j = 0
    7375                for arg in operation.arguments:
    74                         if arg.type == "SIMD_type":
     76                        if arg.type == configure.Bitblock_type[operation.arch]:
    7577                                data.append(simdData[i][j])
    7678                                j += 1
    77                         elif arg.type == "int":
     79                        elif arg.type == "uint64_t":
    7880                                lowBound = operation.valueRange[arg.name]["min"]
    7981                                upBound = operation.valueRange[arg.name]["max"]
  • trunk/libgen/Library_Tester/GenerateCppTests.py

    r1494 r1521  
    5959        text = templatedFunc
    6060        oprdNum = len(operation.arguments)
     61        SIMD_type = configure.Bitblock_type[arch]
    6162
    6263        arguments_init = ""
    6364        for i in range(oprdNum):
    64                 arguments_init += "\t" + "SIMD_type arg" + str(i) + ";\n"
     65                arguments_init += "\t" + SIMD_type + " arg" + str(i) + ";\n"
    6566       
    6667        test_body = ""
     
    7172                        args = []
    7273                        for j in range(oprdNum):
    73                                 if operation.arguments[j].type == "SIMD_type":
     74                                if operation.arguments[j].type == SIMD_type:
    7475                                        test_body += "\t\t\t" + "arg$j$ = LoadfromString(data[$i$][$j$], $optId$);\n".replace("$j$", str(j)).replace("$i$", str(i)).replace("$optId$", str(TesterUtility.GetOptId(arch)))
    75                                 elif operation.arguments[j].type == "int":
    76                                         test_body += "\t\t\t" + "arg$j$ = atoi(data[$i$][$j$]);\n".replace("$j$", str(j)).replace("$i$", str(i))
     76                                elif operation.arguments[j].type == "uint64_t":
     77                                        test_body += "\t\t\t" + "arg$j$ = DigitString2Int(data[$i$][$j$]);\n".replace("$j$", str(j)).replace("$i$", str(i))
    7778                                else:
    7879                                        print "can't process this data type", operation.arguments[j].type
    7980                                args.append("arg"+str(j))
    8081                               
    81                         if operation.returnType == "SIMD_type":
    82                                 test_body += "\t\t\t" + "ans.push_back(Store2String($call_op$, $optId$));\n".replace("$call_op$", operation.CallingStatementToCppText(vop.fw, args, testingData[op_fw][i][-1])).replace("$optId$", str(TesterUtility.GetOptId(arch)))
    83                         elif operation.returnType == "int":
    84                                 test_body += "\t\t\t" + "ans.push_back(Int2String($call_op$));\n".replace("$call_op$", operation.CallingStatementToCppText(vop.fw, args, testingData[op_fw][i][-1])).replace("$optId$", str(TesterUtility.GetOptId(arch)))
     82                        if operation.returnType == SIMD_type:
     83                                test_body += "\t\t\t" + "ans.push_back(Store2String($call_op$, $optId$));\n".replace("$call_op$", operation.CallingStatementToCppText(vop.fw, args, testingData[op_fw][i][-1], True)).replace("$optId$", str(TesterUtility.GetOptId(arch)))
     84                        elif operation.returnType == "uint64_t":
     85                                test_body += "\t\t\t" + "ans.push_back(Int2String($call_op$));\n".replace("$call_op$", operation.CallingStatementToCppText(vop.fw, args, testingData[op_fw][i][-1], True)).replace("$optId$", str(TesterUtility.GetOptId(arch)))
    8586                        else:
    8687                                print "can't process this data type", operation.returnType
     
    9798        text = normalFunc
    9899        oprdNum = len(operation.arguments)
    99        
     100        SIMD_type = configure.Bitblock_type[arch]
    100101        args = []
    101102        arguments_init = ""
    102103        for i in range(oprdNum):
    103                 if operation.arguments[i].type == "SIMD_type":
    104                         arguments_init += "\t" + "SIMD_type arg" + str(i) + " = " + "LoadfromString(tuple[$i$], $optId$);\n".replace("$i$", str(i)).replace("$optId$", str(TesterUtility.GetOptId(arch)))
    105                 elif operation.arguments[i].type == "int":
    106                         arguments_init += "\t" + "int arg" + str(i) + " = " + "atoi(tuple[$i$].c_str());\n".replace("$i$", str(i))
     104                if operation.arguments[i].type == SIMD_type:
     105                        arguments_init += "\t" + SIMD_type + " arg" + str(i) + " = " + "LoadfromString(tuple[$i$], $optId$);\n".replace("$i$", str(i)).replace("$optId$", str(TesterUtility.GetOptId(arch)))
     106                elif operation.arguments[i].type == "uint64_t":
     107                        arguments_init += "\t" + "uint64_t arg" + str(i) + " = " + "DigitString2Int(tuple[$i$]);\n".replace("$i$", str(i))
    107108                else:
    108109                        print "can't process this data type", operation.arguments[i].type
     
    121122        text = text.replace("$test_body$", test_body)
    122123        text = text.replace("$tmpAns_type$", operation.returnType)
    123         if operation.returnType == "SIMD_type":
     124        if operation.returnType == SIMD_type:
    124125                text = text.replace("$store_tmpAns$", "Store2String(tmpAns, $optId$)".replace("$optId$", str(TesterUtility.GetOptId(arch))))
    125         elif operation.returnType == "int" or operation.returnType == "bool":
     126        elif operation.returnType == "uint64_t" or operation.returnType == "bool":
    126127                text = text.replace("$store_tmpAns$", "Int2String(tmpAns)")
    127128        else:
     
    202203        utilityCodes[0] = '''#include "''' + "idisa_" + arch.lower() + '''.h"\n'''
    203204        utilityCodes[1] = '''#define USE_SSE\n''' if arch in configure.SSE_SERIES else ('''#define USE_AVX\n''' if arch == configure.AVX else '''''')
     205        utilityCodes[2] = '''typedef ''' + configure.SIMD_type[arch] + " SIMD_type;\n"
    204206        fileIn.close()
    205207        fileIn = open("utility.h", "w")
  • trunk/libgen/Library_Tester/utility.h

    r1494 r1521  
    1 #include "idisa_ssse3.h"
     1#include "idisa_sse2.h"
    22#define USE_SSE
     3typedef __m128i SIMD_type;
    34#include <iostream>
    45#include <sstream>
     
    89#include <cstdio>
    910#include <cstdlib>
     11#include <stdint.h>
    1012
    1113#define BUFFER_PROFILING 1
     
    8284}
    8385
     86uint64_t DigitString2Int(string s)
     87{
     88    int i, sz = s.length();
     89    uint64_t x = 0;
     90    for(i=0; i<sz; i++)
     91    {
     92        x = x * (uint64_t)10 + (uint64_t)(s[i] - '0');
     93    }
     94    return x;
     95}
     96
    8497string Int2BitString(int x)
    8598{
    8699        string ans = "";
    87         for(int i=31; i>=0; i--)
     100        int sz = 32;
     101        for(int i=sz-1; i>=0; i--)
    88102        {
    89103                if((1<<i)&x) ans = ans + "1";
     
    93107}
    94108
    95 string Int2String(int x)
     109string Int2String(uint64_t x)
    96110{
    97111        stringstream stm;
     
    256270}
    257271
    258 void GetRandomNums(int low, int up, int *arr, int ct)
    259 {
    260         int hiCt = ct/2;
    261         int loCt = ct - hiCt;
     272void GetRandomNums(uint64_t low, uint64_t up, uint64_t *arr, int ct)
     273{
    262274        int i, ptr = 0;
    263        
    264         for(i=0; i<loCt; i++)
    265         {
    266                 if(up-i<low)
    267                         arr[ptr++] = up;
    268                 else
    269                         arr[ptr++] = low+i;
    270         }
    271        
    272         for(i=0; i<hiCt; i++)
    273         {
    274                 if(up-i<low)
    275                         arr[ptr++] = low;
    276                 else
    277                         arr[ptr++] = up-i;
     275        arr[ptr++] = low;
     276        arr[ptr++] = up;
     277        uint64_t diff = up - low;
     278        for(i=0; i<ct-2; i++)
     279        {
     280            uint64_t tmp = rand();
     281            tmp = ((uint64_t)(tmp * (uint64_t)rand())) % diff;
     282            arr[ptr++] = low + tmp;
    278283        }
    279284}
  • trunk/libgen/Makefile

    r1501 r1521  
    11
    2 LIB_GEN_DIR = Library_Generator
    3 LIB_TEST_DIR = Library_Tester
    4 LIB_DIR = ../../lib
     2GENERATOR_DIR = Library_Generator
     3TESTER_DIR = Library_Tester
     4CONFIGURE_DIR = Configure
     5IDISA_LIB_DIR = idisa_lib
     6IDISA_LIB_CPP_DIR = $(IDISA_LIB_DIR)/cpp
    57
    6 IDISA_GENERATOR = $(LIB_GEN_DIR)/LibraryGenerator.py
    7 IDISA_TESTER = $(LIB_TEST_DIR)/LibraryTester.py
    8 IDISA_SSE2_C_LIB = idisa_sse2_c.h
     8IDISA_GENERATOR = $(GENERATOR_DIR)/LibraryGenerator.py
     9IDISA_TESTER = $(TESTER_DIR)/LibraryTester.py
     10
     11IDISA_SSE2_C_LIB = idisa_sse2_c
    912IDISA_SSE2_CPP_LIB = idisa_sse2
    1013
     
    1922IDISA_AVX_CPP_LIB = idisa_avx
    2023
    21 IDISA_128_LIB = idisa128
     24IDISA128 = idisa128
    2225
    23 IDISA_256_LIB = idisa256
     26IDISA256 = idisa256
    2427
     28BODY_DECLARATION = declaration
    2529
     30BODY_IMPLEMENTATION = implementation
    2631
    2732sse2:
    2833        python $(IDISA_GENERATOR) -a sse2 -l cpp -f $(IDISA_SSE2_CPP_LIB).h -g
    29         cp $(LIB_GEN_DIR)/$(IDISA_SSE2_CPP_LIB).h $(LIB_GEN_DIR)/$(IDISA_128_LIB).hpp
    3034
    3135sse2_c:
    3236        python $(IDISA_GENERATOR) -a sse2 -l c -f $(IDISA_SSE2_C_LIB).h -g
    33         cp $(LIB_GEN_DIR)/$(IDISA_SSE2_C_LIB).h $(LIB_GEN_DIR)/$(IDISA_128_LIB).hpp
    3437
    3538sse2_test:
     
    3841sse3:
    3942        python $(IDISA_GENERATOR) -a sse3 -l cpp -f $(IDISA_SSE3_CPP_LIB).h -g
    40         cp $(LIB_GEN_DIR)/$(IDISA_SSE3_CPP_LIB).h $(LIB_GEN_DIR)/$(IDISA_128_LIB).hpp   
    41 
    4243sse3_test:
    4344        python $(IDISA_TESTER) -a sse3 -l cpp -f $(IDISA_SSE3_CPP_LIB) -t
     
    4546ssse3:
    4647        python $(IDISA_GENERATOR) -a ssse3 -l cpp -f $(IDISA_SSSE3_CPP_LIB).h -g
    47         cp $(LIB_GEN_DIR)/$(IDISA_SSSE3_CPP_LIB).h $(LIB_GEN_DIR)/$(IDISA_128_LIB).hpp
    48 
    4948ssse3_test:
    5049        python $(IDISA_TESTER) -a ssse3 -l cpp -f $(IDISA_SSSE3_CPP_LIB) -t
     
    5251sse4_1:
    5352        python $(IDISA_GENERATOR) -a sse4_1 -l cpp -f $(IDISA_SSE4_1_CPP_LIB).h -g
    54         cp $(LIB_GEN_DIR)/$(IDISA_SSE4_1_CPP_LIB).h $(LIB_GEN_DIR)/$(IDISA_128_LIB).hpp
    55 
    5653sse4_1_test:
    5754        python $(IDISA_TESTER) -a sse4_1 -l cpp -f $(IDISA_SSE4_1_CPP_LIB) -t
    58         cp $(LIB_GEN_DIR)/$(IDISA_SSE4_1_CPP_LIB).h $(LIB_GEN_DIR)/$(IDISA_128_LIB).hpp
    5955
    6056sse4_2:
    6157        python $(IDISA_GENERATOR) -a sse4_2 -l cpp -f $(IDISA_SSE4_2_CPP_LIB).h -g
    62         cp $(LIB_GEN_DIR)/$(IDISA_SSE4_2_CPP_LIB).h $(LIB_GEN_DIR)/$(IDISA_128_LIB).hpp
    63 
    6458sse4_2_test:
    6559        python $(IDISA_TESTER) -a sse4_2 -l cpp -f $(IDISA_SSE4_2_CPP_LIB) -t
     
    6761avx:
    6862        python $(IDISA_GENERATOR) -a avx -l cpp -f $(IDISA_AVX_CPP_LIB).h -g
    69         cp $(LIB_GEN_DIR)/$(IDISA_AVX_CPP_LIB).h $(LIB_GEN_DIR)/$(IDISA_256_LIB).hpp
    70 
    7163avx_test:
    7264        python $(IDISA_TESTER) -a avx -l cpp -f $(IDISA_AVX_CPP_LIB) -t
     65
     66idisa128:
     67        # produces the idisa128.hpp with only declaration of idisa operations
     68        # copys the idisa128.hpp from generator's directory to idisa_lib/
     69        python $(IDISA_GENERATOR) -a sse2 -l cpp -f $(IDISA128).hpp -g --body=$(BODY_DECLARATION)
     70        cp $(GENERATOR_DIR)/$(IDISA128).hpp $(IDISA_LIB_DIR)/
     71       
     72        # produces the idisa_sse2/sse3/ssse3/sse4_1/sse4_2.cpp containing the implementation of idisa operations
     73        # copys the idisa_sse2/sse3/ssse3/sse4_1/sse4_2.cpp from generator's directory to idisa_lib/cpp/
     74        python $(IDISA_GENERATOR) -a sse2 -l cpp -f $(IDISA_SSE2_CPP_LIB).cpp -g --body=$(BODY_IMPLEMENTATION)
     75        cp $(GENERATOR_DIR)/$(IDISA_SSE2_CPP_LIB).cpp $(IDISA_LIB_CPP_DIR)/
     76       
     77        python $(IDISA_GENERATOR) -a sse3 -l cpp -f $(IDISA_SSE3_CPP_LIB).cpp -g --body=$(BODY_IMPLEMENTATION)
     78        cp $(GENERATOR_DIR)/$(IDISA_SSE3_CPP_LIB).cpp $(IDISA_LIB_CPP_DIR)/
     79       
     80        python $(IDISA_GENERATOR) -a ssse3 -l cpp -f $(IDISA_SSSE3_CPP_LIB).cpp -g --body=$(BODY_IMPLEMENTATION)
     81        cp $(GENERATOR_DIR)/$(IDISA_SSSE3_CPP_LIB).cpp $(IDISA_LIB_CPP_DIR)/
     82       
     83        python $(IDISA_GENERATOR) -a sse4_1 -l cpp -f $(IDISA_SSE4_1_CPP_LIB).cpp -g --body=$(BODY_IMPLEMENTATION)
     84        cp $(GENERATOR_DIR)/$(IDISA_SSE4_1_CPP_LIB).cpp $(IDISA_LIB_CPP_DIR)/
     85       
     86        python $(IDISA_GENERATOR) -a sse4_2 -l cpp -f $(IDISA_SSE4_2_CPP_LIB).cpp -g --body=$(BODY_IMPLEMENTATION)
     87        cp $(GENERATOR_DIR)/$(IDISA_SSE4_2_CPP_LIB).cpp $(IDISA_LIB_CPP_DIR)/
     88
     89idisa256:
     90        # produces the idisa256.cpp with only declaration of idisa operations
     91        # copys the idisa256.cpp from generator's directory to idisa_lib/
     92        python $(IDISA_GENERATOR) -a avx -l cpp -f $(IDISA256).hpp -g --body=$(BODY_DECLARATION)
     93        cp $(GENERATOR_DIR)/$(IDISA256).hpp $(IDISA_LIB_DIR)/
     94       
     95        # produces the idisa_avx.hpp containing the implementation of idisa operations
     96        # copys the idisa_avx.hpp from generator's directory to idisa_lib/cpp/
     97        python $(IDISA_GENERATOR) -a avx -l cpp -f $(IDISA_AVX_CPP_LIB).cpp -g --body=$(BODY_IMPLEMENTATION)
     98        cp $(GENERATOR_DIR)/$(IDISA_AVX_CPP_LIB).cpp $(IDISA_LIB_CPP_DIR)/
     99
     100clean:
     101        rm -f $(GENERATOR_DIR)/*.pyc
     102        rm -f $(TESTER_DIR)/*.pyc
     103        rm -f $(CONFIGURE_DIR)/*.pyc
Note: See TracChangeset for help on using the changeset viewer.