Changeset 3584 for trunk


Ignore:
Timestamp:
Dec 17, 2013, 1:05:26 PM (5 years ago)
Author:
linmengl
Message:

merge from github:llvm branch

Location:
trunk/libgen
Files:
18 added
26 edited

Legend:

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

    r3436 r3584  
    102102    },
    103103   
     104    "simd_vsrl":\
     105    {
     106     "signature":"SIMD_type simd<fw>::vsrl(SIMD_type arg1, SIMD_type shift_mask)",
     107     "args_type":{"arg1":"SIMD_type", "shift_mask":"SIMD_type"},
     108     "return_type":"SIMD_type",
     109    },
     110
    104111    "simd_srl":\
    105112    {
     
    117124    },
    118125   
     126    "simd_vsll":\
     127    {
     128     "signature":"SIMD_type simd<fw>::vsll(SIMD_type arg1, SIMD_type shift_mask)",
     129     "args_type":{"arg1":"SIMD_type", "shift_mask":"SIMD_type"},
     130     "return_type":"SIMD_type",
     131    },
     132
    119133    "simd_sll":\
    120134    {
     
    132146    },
    133147   
     148    "simd_vsra":\
     149    {
     150     "signature":"SIMD_type simd<fw>::vsra(SIMD_type arg1, SIMD_type shift_mask)",
     151     "args_type":{"arg1":"SIMD_type", "shift_mask":"SIMD_type"},
     152     "return_type":"SIMD_type",
     153    },
     154
    134155    "simd_sra":\
    135156    {
     
    521542     "args_type":{"arg1":"SIMD_type", "pos":"range(0, curRegSize/fw-1)"},
    522543     "return_type":"unsigned_int(64)",
    523      "cpp_class_signature":"template <uint8_t pos> static inline typename FieldType<fw>::T extract(SIMD_type arg1)",
    524     },
     544     "cpp_class_signature":"template <uint16_t pos> static inline typename FieldType<fw>::T extract(SIMD_type arg1)",
     545    },
     546
     547    "mvmd_insert":\
     548    {
     549     "signature":"SIMD_type mvmd<fw>::insert<pos>(SIMD_type arg1, int arg2)",
     550     "args_type":{"arg1":"SIMD_type", "pos":"range(0, curRegSize/fw-1)", "arg2":"range(0, 2**fw-1)"},
     551     "return_type":"SIMD_type",
     552     "cpp_class_signature":"template <uint16_t pos> static inline SIMD_type insert(SIMD_type arg1, typename FieldType<fw>::T arg2)",
     553    },   
    525554
    526555    #bitblock operations
  • trunk/libgen/Configure/configure.py

    r3436 r3584  
    2121AVX2 = "AVX2"
    2222ALL = "ALL"
     23LLVM128 = "LLVM128"
     24LLVM256 = "LLVM256"
    2325SSE_SERIES = [SSE, SSE2, SSE3, SSSE3, SSE4_1, SSE4_2]
    2426AVX_SERIES = [AVX, AVX2]
     27LLVM_SERIES = [LLVM128, LLVM256]
    2528
    2629#Languages and architectures
     
    5457
    5558Macro_Idisa256_Hpp = r'''
     59#if defined USE_AVX
    5660#include "idisa_cpp/idisa_avx.cpp"
     61#else
     62#include "idisa_cpp/idisa_avx2.cpp"
     63#endif
    5764'''
    5865
     
    112119
    113120#Register sizes for different instruction sets
    114 RegisterSize = {MMX:64, SSE:128, SSE2:128, SSE3:128, SSSE3:128, SSE4:128, SSE4_a:128, SSE4_1:128, SSE4_2:128, NEON:128, AVX:256, AVX2:256}
     121RegisterSize = {MMX:64, SSE:128, SSE2:128, SSE3:128, SSSE3:128, SSE4:128, \
     122                        SSE4_a:128, SSE4_1:128, SSE4_2:128, NEON:128, AVX:256, AVX2:256, \
     123                        LLVM128: 128, LLVM256: 256}
    115124
    116125#Instruction set library
    117126InstructionSetLibrary = {MMX:"mmintrin.h", SSE:"xmmintrin.h", SSE2:"emmintrin.h", SSE3:"pmmintrin.h",\
    118127        SSSE3:"tmmintrin.h", SSE4_a:"ammintrin.h", SSE4_1:"smmintrin.h", SSE4_2:"smmintrin.h", NEON:"arm_neon.h", \
    119         AVX:"immintrin.h", AVX2:"immintrin.h"}
     128        AVX:"immintrin.h", AVX2:"immintrin.h", LLVM128: "../llvm_header/header.h"}
     129
    120130#Imports
    121 ExtraImports = {AVX:["idisa_sse2.cpp"], AVX2:["idisa_sse2.cpp"]}
     131ExtraImports = {AVX:["idisa_sse2.cpp"], AVX2:["emmintrin.h"]}
    122132
    123133#SIMD types in C/C++ for different instruction sets
    124134SIMD_type = {MMX:"__m64", SSE:"__m128i", SSE2:"__m128i", SSE3:"__m128i", SSSE3:"__m128i", SSE4_a:"__m128i", SSE4_1:"__m128i", SSE4_2:"__m128i", NEON:"uint64x2_t", \
    125         AVX:"__m256", AVX2:"__m256i"}
     135        AVX:"__m256", AVX2:"__m256i", LLVM128: "SIMD_type"}
    126136
    127137Bitblock_type = {MMX:"bitblock64_t", SSE:"bitblock128_t", SSE2:"bitblock128_t", SSE3:"bitblock128_t", SSSE3:"bitblock128_t", SSE4_1:"bitblock128_t", SSE4_2:"bitblock128_t",
    128                                 NEON:"bitblock128_t", AVX:"bitblock256_t", AVX2:"bitblock256_t"}
     138                                NEON:"bitblock128_t", AVX:"bitblock256_t", AVX2:"bitblock256_t", LLVM128: "bitblock128_t"}
    129139
    130140Load_type = {MMX:"bitblock64_t*", SSE:"bitblock128_t*", SSE2:"bitblock128_t*", SSE3:"bitblock128_t*", SSSE3:"bitblock128_t*", SSE4_1:"bitblock128_t*", SSE4_2:"bitblock128_t*",
    131                         NEON:"uint64_t const*", AVX:"bitblock256_t*", AVX2:"bitblock256_t*"}
     141                        NEON:"uint64_t const*", AVX:"bitblock256_t*", AVX2:"bitblock256_t*", LLVM128: "bitblock128_t*"}
    132142
    133143Store_type = {MMX:"bitblock64_t*", SSE:"bitblock128_t*", SSE2:"bitblock128_t*", SSE3:"bitblock128_t*", SSSE3:"bitblock128_t*", SSE4_1:"bitblock128_t*", SSE4_2:"bitblock128_t*",
    134                         NEON:"uint64_t*", AVX:"bitblock256_t*", AVX2:"bitblock256_t*"}
     144                        NEON:"uint64_t*", AVX:"bitblock256_t*", AVX2:"bitblock256_t*", LLVM128: "bitblock128_t*"}
    135145
    136146AVXBuiltInVecWrapper = "AVXBuiltInVecWrapper"
     
    141151
    142152cppCopyrightNotice = r'''
    143 /* Copyright (c) 2011, Hua Huang and Robert D. Cameron.
     153/* Copyright (c) 2011, Hua Huang, Meng Lin and Robert D. Cameron.
    144154   Licensed under the Academic Free License 3.0.
    145155   This file is generated by the IDISA+ generator;
  • trunk/libgen/Library_Generator/AVX2Instructions.py

    r3436 r3584  
    3636                "return_type":"SIMD_type",
    3737                "fws":[[1]],
    38         },
    39 
    40         # TEST NEED. Not quite sure about this
     38        },     
    4139        "simd_ifh":\
    4240        {
     
    128126                "fws":[[16, 32, 64]],
    129127        },
     128
     129        "simd_srl":\
     130        {
     131                "signature":["t _mm256_srl_epi$fw$(t arg1, __m128i shift_mask)"],
     132                "args_type":{"arg1":"SIMD_type", "shift_mask":"__m128i"},
     133                "return_type":"SIMD_type",
     134                "fws":[[16, 32, 64]],
     135        },
     136
    130137        "simd_slli":\
    131138        {
     
    135142                "fws":[[16, 32, 64]],
    136143        },
     144
     145        "simd_sll":\
     146        {
     147                "signature":["t _mm256_sll_epi$fw$(t arg1, t shift_mask)"],
     148                "args_type":{"arg1":"SIMD_type", "shift_mask":"__m128i"},
     149                "return_type":"SIMD_type",
     150                "fws":[[16, 32, 64]],
     151        },
     152
    137153        "simd_srai":\
    138154        {
     
    142158                "fws":[[16, 32]],
    143159        },
     160
     161        "simd_sra":\
     162        {
     163                "signature":["t _mm256_sra_epi$fw$(t arg1, t shift_mask)"],
     164                "args_type":{"arg1":"SIMD_type", "shift_mask":"__m128i"},
     165                "return_type":"SIMD_type",
     166                "fws":[[16, 32]],
     167        },
     168
    144169        "simd_constant":\
    145170        {
     
    155180                "return_type":"SIMD_type",
    156181                "fws":[[8, 16, 32]],
    157         },
    158         "hsimd_add_hl":\
    159         {
    160                 "signature":["t _mm256_hadd_epi$fw/2$(t arg1, t arg2)"],
    161                 "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
    162                 "return_type":"SIMD_type",
    163                 "fws":[[32, 64]],
    164         },
    165         "hsimd_packus":\
    166         {
    167                 "signature":["t _mm256_packus_epi$fw$(t arg1, t arg2)"],
    168                 "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
    169                 "return_type":"SIMD_type",
    170                 "fws":[[16, 32]],
    171         },
    172         "hsimd_packss":\
    173         {
    174                 "signature":["t _mm256_packs_epi$fw$(t arg1, t arg2)"],
    175                 "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
    176                 "return_type":"SIMD_type",
    177                 "fws":[[16, 32]],
    178         },
     182        },     
     183
    179184        "mvmd_fill":\
    180185        {
     
    237242                "fws":[[256]],
    238243        },
     244
     245        "hsimd_signmask":\
     246        {
     247                "signature":["int _mm256_movemask_epi8(SIMD_type arg1)"],
     248                "args_type":{"arg1":"SIMD_type"},
     249                "return_type":"int",
     250                "fws":[[8]],   
     251        },
     252
     253        "_mm256_movemask_pd":\
     254        {
     255                "signature":["t _mm256_movemask_pd(t arg1)"],
     256                "args_type":{"arg1":"__m256d"},
     257                "return_type":"int",
     258                "fws":[[64]],
     259        },
     260
     261        "_mm256_movemask_ps":\
     262        {
     263                "signature":["t _mm256_movemask_ps(t arg1)"],
     264                "args_type":{"arg1":"__m256"},
     265                "return_type":"int",
     266                "fws":[[32]],
     267        },
     268
     269        "_mm256_castsi256_pd":\
     270        {
     271                "signature":["t _mm256_castsi256_pd(t arg1)"],
     272                "args_type":{"arg1":"SIMD_type"},
     273                "return_type":"__m256d",
     274                "fws":[[256]],
     275        },
     276
     277        "_mm256_castsi256_ps":\
     278        {
     279                "signature":["t _mm256_castsi256_ps(t arg1)"],
     280                "args_type":{"arg1":"SIMD_type"},
     281                "return_type":"__m256",
     282                "fws":[[256]],
     283        },
     284
     285        "_mm256_srl_epi64":\
     286        {
     287                "signature":["t _mm256_srl_epi64(t arg1, t arg2)"],
     288                "args_type":{"arg1":"SIMD_type", "arg2":"__m128i"},
     289                "return_type":"SIMD_type",
     290                "fws":[[64]],
     291        },
     292
     293        "_mm256_sll_epi64":\
     294        {
     295                "signature":["t _mm256_sll_epi64(t arg1, t arg2)"],
     296                "args_type":{"arg1":"SIMD_type", "arg2":"__m128i"},
     297                "return_type":"SIMD_type",
     298                "fws":[[64]],
     299        },
     300
     301        "_mm256_packs_epi16":\
     302        {
     303                "signature":["t _mm256_packs_epi16(t arg1, t arg2)"],
     304                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     305                "return_type":"SIMD_type",
     306                "fws":[[16]],
     307        },
     308
     309        "_mm256_packs_epi32":\
     310        {
     311                "signature":["t _mm256_packs_epi32(t arg1, t arg2)"],
     312                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     313                "return_type":"SIMD_type",
     314                "fws":[[32]],
     315        },
     316
     317        "_mm256_packus_epi16":\
     318        {
     319                "signature":["t _mm256_packus_epi16(t arg1, t arg2)"],
     320                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     321                "return_type":"SIMD_type",
     322                "fws":[[16]],
     323        },
     324
     325        "_mm256_packus_epi32":\
     326        {
     327                "signature":["t _mm256_packus_epi32(t arg1, t arg2)"],
     328                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     329                "return_type":"SIMD_type",
     330                "fws":[[32]],
     331        },
     332
     333        "_mm256_hadd_epi16":\
     334        {
     335                "signature":["t _mm256_hadd_epi16(t arg1, t arg2)"],
     336                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     337                "return_type":"SIMD_type",
     338                "fws":[[16]],
     339        },
     340
     341        "_mm256_hadd_epi32":\
     342        {
     343                "signature":["t _mm256_hadd_epi32(t arg1, t arg2)"],
     344                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type"},
     345                "return_type":"SIMD_type",
     346                "fws":[[32]],
     347        },
     348
     349        "_mm256_permute2x128_si256":\
     350        {
     351                "signature":["t _mm256_permute2x128_si256(t arg1, t arg2, t imm)"],
     352                "args_type":{"arg1":"SIMD_type", "arg2":"SIMD_type", "imm":"signed_int(32)"},
     353                "return_type":"SIMD_type",
     354                "fws":[[256]],
     355        },
     356
    239357        "_mm256_set_epi32":\
    240358        {
     
    252370                "fws":[[256]],
    253371        },
     372        "_mm_cvtsi64_si128":\
     373        {
     374                "signature":["__m128i _mm_cvtsi64_si128(t arg1)"],
     375                "args_type":{"arg1":"signed_int(64)"},
     376                "return_type":"__m128i",
     377                "fws":[[128]],
     378        },
    254379        "_mm_sad_epu8":\
    255380        {
     
    357482                "fws":[[64]],
    358483        },
    359        
     484
     485        "_mm_cvtsi32_si128":\
     486        {
     487                "signature":["__m128i _mm_cvtsi32_si128(int arg1)"],
     488                "args_type":{"arg1":"signed_int(32)"},
     489                "return_type":"__m128i",
     490                "fws":[[128]],
     491        },     
     492
     493        "_mm_cvtsi128_si32":\
     494        {
     495                "signature":["int _mm_cvtsi128_si32(__m128i arg1)"],
     496                "args_type":{"arg1":"__m128i"},
     497                "return_type":"uint32_t",
     498                "fws":[[128]],
     499        },     
     500
     501        "_mm256_srl_epi64":\
     502        {
     503                "signature":["SIMD_type _mm256_srl_epi64(SIMD_type arg1, __m128i sh)"],
     504                "args_type":{"arg1":"SIMD_type", "sh":"__m128i"},
     505                "return_type":"SIMD_type",
     506                "fws":[[256]],
     507        },     
     508
     509        "_mm256_permute4x64_epi64":\
     510        {
     511                "signature":["SIMD_type _mm256_permute4x64_epi64(SIMD_type arg1, int sh)"],
     512                "args_type":{"arg1":"SIMD_type", "sh":"signed_int(32)"},
     513                "return_type":"SIMD_type",
     514                "fws":[[256]],
     515        },     
     516
     517        "_mm256_set_epi64x":\
     518        {
     519                "signature":["SIMD_type _mm256_set_epi64x(t arg1, t arg2, t arg3, t arg4)"],
     520                "args_type":{"arg1":"signed_int(64)", "arg2":"signed_int(64)", "arg3":"signed_int(64)", "arg4":"signed_int(64)"},
     521                "return_type":"SIMD_type",
     522                "fws":[[256]],
     523        },             
     524
     525        "__builtin_popcountll":\
     526        {
     527                "signature":["int __builtin_popcountll(t arg1)"],
     528                "args_type":{"arg1":"unsigned_int(64)"},
     529                "return_type":"int",
     530                "fws":[[256]],
     531        },
     532
     533        "_mm_insert_epi16":\
     534        {
     535                "signature":["__m128i _mm_insert_epi16(t arg1, t i, t imm)"],
     536                "args_type":{"arg1":"__m128i", "i":"signed_int(32)", "imm":"signed_int(32)"},
     537                "return_type":"__m128i",
     538                "fws":[[16]],
     539        },             
    360540}
     541
  • trunk/libgen/Library_Generator/BuiltIns.py

    r2825 r3584  
    2020        while opSignature.find("(", spacePos) != -1:
    2121            leftBrac = opSignature.find("(", spacePos)
    22             spacePos = leftBrac + 1
     22            spacePos = leftBrac + 1           
     23
    2324        rightBrac = opSignature.find(")", leftBrac)
    24         #print opSignature,
     25        # print opSignature, "==>",
    2526        self.arch = arch
    2627        self.returnType = opSignature[:firstSpace]
     
    3940        self.arguments = self.args
    4041
    41         #print self.funcName, self.arguments
     42        # print self.funcName,"::", self.arguments, "::", self.argsType
    4243
    4344    def GetCallingConvention(self):
     
    4546        txt = self.funcName
    4647        txt += "("
    47         for i in range(len(self.args)):
     48        for i in range(len(self.args)):           
    4849            if StandardTypes.IsExtactWidthIntType(self.argsType[self.args[i]]):
    4950                txt += "(" + self.argsType[self.args[i]] + ")" + "(" + self.arguments[i] + ")" + ", "
     
    5354                txt += "(" + StandardTypes.GetUnsignedIntType(self.argsType[self.args[i]], configure.RegisterSize[self.arch]) + ")" + "(" + self.arguments[i] + ")" + ", "
    5455            elif StandardTypes.IsSIMDType(self.argsType[self.args[i]]):
    55                 txt += self.arguments[i] + ", "
     56                txt += StandardTypes.GetSIMDTypeConvert(self.argsType[self.args[i]], self.arch, self.arguments[i]) + ", "
    5657            elif StandardTypes.IsSIMDPointer(self.argsType[self.args[i]]):
    5758                txt += "(" + StandardTypes.GetSIMDPointer(self.arch) + ")" + "(" + self.arguments[i] + ")" + ", "
     
    9798        builtInOperations = {}
    9899        for opName in self.builtInsTable:
     100            # if opName == 'simd_srl':
     101            #     ipdb.set_trace()
     102
    99103            args_type = self.builtInsTable[opName]["args_type"]
    100104            for i in range(len(self.builtInsTable[opName]["signature"])):
  • trunk/libgen/Library_Generator/CppFunctionSupport.py

    r3436 r3584  
    99Functions = \
    1010{
     11        # Keys are mainly used as function names within all the strategies.
     12        # But if the name after "#define" is different from the key,
     13        # That name will be the function name.
     14
    1115        "shufflemask2":\
    1216        {
     
    9296        },
    9397
     98        # it's function name is still avx_select_hi128
    9499        "avx2_select_hi128":\
    95100        {
     
    180185        "returnType":configure.SIMD_type[configure.AVX2],
    181186        "cost":4,
    182         },
    183        
    184         # WTF is this?
     187        },     
     188       
    185189        "avx_move_lo128_to_hi128":\
    186190        {
     
    197201        "body":r'''
    198202#define avx_move_lo128_to_hi128(x) \
    199         _mm256_permute2f128_si128(x, x, 0 + 8)''',
     203        _mm256_permute2f128_si256(x, x, 0 + 8)''',
    200204        "platform":[configure.AVX2],
    201205        "returnType":configure.SIMD_type[configure.AVX2],
  • trunk/libgen/Library_Generator/IDISAFunctionSupport.py

    r1952 r3584  
    99   
    1010    def __init__(self, arch):
    11         self.arch = arch
    12         pass
     11        self.arch = arch
     12        pass
    1313
    1414    @staticmethod
    1515    def IsIDISAFunction(funcName):
    16         callMethod = None
    17         try:
    18             callMethod = getattr(IDISAFunction, "Is" + funcName.upper())
    19         except:
    20             pass
    21         return True if callMethod else False
     16        callMethod = None
     17        try:
     18            callMethod = getattr(IDISAFunction, "Is" + funcName.upper())
     19        except:
     20            pass
     21        return True if callMethod else False
    2222   
    2323    @staticmethod
    2424    def Parse(self, funcName, argsList, fw=0):
    25         callMethod = getattr(self, "Is" + funcName.upper())
    26         argsList.append(fw)   
    27         if callMethod:
    28             return callMethod(argsList)
    29         else:
    30             print "No such IDISA function", funcName
     25        callMethod = getattr(self, "Is" + funcName.upper())
     26        argsList.append(fw)   
     27        if callMethod:
     28            return callMethod(argsList)
     29        else:
     30            print "No such IDISA function", funcName
    3131
    3232    def IsIDISA_CASTING(self, argsList):
    33         assert len(argsList)-1 == 2, "IDISA_CASTING can't accept these many arguments!"
    34         castExpr = str(argsList[0])
     33        assert len(argsList)-1 == 2, "IDISA_CASTING can't accept these many arguments!"
     34        castExpr = str(argsList[0])
    3535        if castExpr == "_mm_castsi128_ps": 
    3636                return (castExpr + "(" + str(argsList[1]) + ")", "__m128")
    37         if castExpr == "_mm_castsi128_pd": 
     37        if castExpr == "_mm256_castsi256_ps":
     38                return (castExpr + "(" + str(argsList[1]) + ")", "__m256")
     39        if castExpr == "_mm_castsi128_pd":                 
    3840                return (castExpr + "(" + str(argsList[1]) + ")", "__m128d")
    39         returnType = configure.Bitblock_type[self.arch] if castExpr == "SIMD_type" else castExpr
    40         #codes = "reinterpret_cast" + "<" + returnType + ">(" + str(argsList[1]) + ")"
    41         codes = "((" + returnType + ")(" + str(argsList[1]) + "))"
    42         return (codes, returnType)
     41        if castExpr == "_mm256_castsi256_pd":
     42                return (castExpr + "(" + str(argsList[1]) + ")", "__m256d")
     43        if castExpr == "_mm256_castsi128_si256":
     44                return (castExpr + "(" + str(argsList[1]) + ")", "__m256i")
     45
     46        returnType = configure.Bitblock_type[self.arch] if castExpr == "SIMD_type" else castExpr
     47        #codes = "reinterpret_cast" + "<" + returnType + ">(" + str(argsList[1]) + ")"
     48        codes = "((" + returnType + ")(" + str(argsList[1]) + "))"
     49        return (codes, returnType)
    4350   
    4451    def IsIDISA_PACK(self, argsList):
    45         func = argsList[0]
    46         fw = argsList[-1]
    47         assert "$fw$" in func, "No $fw$ in function name!"
    48         func = func.replace("$fw$", str(fw))
    49         assert Utility.builtIns.IsOperationBuiltIn(func) == True, "This " + func + " is not a built-in!"
    50        
    51         returnType = Utility.builtIns.GetOperationReturnType(func)
    52         codes = func + "("
    53         for arg in argsList[1:-2]:
    54             codes += arg + "," + " "
    55         codes += argsList[-2] + ")"
    56         return (codes, returnType)
     52        func = argsList[0]
     53        fw = argsList[-1]
     54        assert "$fw$" in func, "No $fw$ in function name!"
     55        func = func.replace("$fw$", str(fw))
     56        assert Utility.builtIns.IsOperationBuiltIn(func) == True, "This " + func + " is not a built-in!"
     57       
     58        returnType = Utility.builtIns.GetOperationReturnType(func)
     59        codes = func + "("
     60        for arg in argsList[1:-2]:
     61                codes += arg + "," + " "
     62        codes += argsList[-2] + ")"
     63        return (codes, returnType)
  • trunk/libgen/Library_Generator/InstructionSet.py

    r3436 r3584  
    1313import AVXInstructions
    1414import AVX2Instructions
     15import LLVMInstructions
    1516
    1617from Utility import configure
     
    3334        elif arch == configure.NEON:
    3435                return NEONInstructions.NEONBuiltIns
     36        elif arch == configure.LLVM128:
     37                return LLVMInstructions.LLVMBuiltIns
    3538        else:
    3639                print "The generator doesn't support this arch =", arch
  • trunk/libgen/Library_Generator/LibraryGenerator.py

    r3436 r3584  
    44
    55import sys
    6 
    76import UI
    87import Utility
     
    1413import OperationSetAnalyzer
    1514
    16 import ipdb
    1715
    1816def operationInfo(definedOperations):
    1917        # All options have full powers of 2 as field width
    20         ref_keys = [1, 2, 4, 8, 16, 32, 64, 128]
     18        ref_keys = [1, 2, 4, 8, 16, 32, 64, 128, 256]
    2119        generators = ["SIMDBuiltinGenerator", "SIMDConstantBuiltinGenerator", "SIMDLogicBuiltinGenerator", "SIMDBitblockBuiltinGenerator", "SIMDBitblockImmediateBuiltinGenerator"]     
    2220        return_type = {"bool": "BOOL", "uint64_t": "BITFIELD", "bitblock128_t": "BITBLOCK", "void": "VOID"}
     
    3129                        print op_key.upper(), "(makeAllSimpleSignatures(" + op_upperBound + ", new " + op_generator + "(), ",                                           
    3230                        print len(op_detail.arguments) * "BITBLOCK, ",                 
    33                         print return_type[op_detail.returnType] + ")),"
     31                        # print return_type[op_detail.returnType] + ")),"
    3432                        # print "args:"
    3533                        # for arg in op_detail.arguments:
  • trunk/libgen/Library_Generator/NEONInstructions.py

    r1958 r3584  
    119119#        "fws":[[8, 16, 32, 64]],
    120120#    },
    121 #    "simd_sll":\
     121#    "simd_vsll":\
    122122#    {
    123123#        "signature":["SIMD_type (SIMD_type)vshlq_u$fw$(SIMD_type arg1, SIMD_type shift_mask)"],
  • trunk/libgen/Library_Generator/SSE2Instructions.py

    r1958 r3584  
    214214                "fws":[[8]],
    215215        },
     216
    216217        "mvmd_shufflei":\
    217218        {
     
    221222                "fws":[[32]],
    222223        },
     224
     225        "mvmd_insert":\
     226        {
     227                "signature":["SIMD_type _mm_insert_epi16(SIMD_type arg1, int arg2, int pos)"],
     228                "args_type":{"arg1":"SIMD_type", "arg2":"signed_int(32)", "pos":"signed_int(32)"},
     229                "return_type":"SIMD_type",
     230                "fws":[[16]],
     231        },
     232
    223233        "bitblock_load_aligned":\
    224234        {
  • trunk/libgen/Library_Generator/StandardTypes.py

    r1870 r3584  
    8282    return "uint64_t*"
    8383
     84def GetSIMDTypeConvert(argType, arch, argument):
     85    if argType == "SIMD_type":
     86        return argument
     87
     88    if configure.SIMD_type[arch] != argType:       
     89        if arch == "AVX2" and argType == "__m128i" and not "(" in argument:           
     90            return "avx_select_lo128(%s)" % argument
     91   
     92    return argument
     93
    8494def GetNEONSignedType(fw=0, fwStr="fw"):
    8595    if fw <= 0:
     
    113123
    114124def IsSIMDType(typeStr):
    115     return "SIMD_type" == typeStr or "bitblock" in typeStr or "__m128i"  in typeStr or "__m128" in typeStr
     125    return "SIMD_type" == typeStr or "bitblock" in typeStr or "__m128i"  in typeStr or "__m128" in typeStr or "__m256" in typeStr
    116126
    117127def IsUnsignedIntType(typeStr):
  • trunk/libgen/Library_Generator/StrategyPool.py

    r3436 r3584  
    398398                {
    399399                "body":r'''
    400 return simd_or(simd_and(simd_himask(fw), simd_srai(fw/2, sh if sh<fw/2 else fw/2, arg1)), simd_srli(fw, sh, arg1) if sh<=fw/2 else simd_srai(fw/2, sh-(fw/2), simd_srli(fw, fw/2, arg1)))''',
     400return simd_or(simd_and(simd_himask(fw), simd_srai(fw/2, sh if sh<fw/2 else fw/2, arg1)), simd_srli(fw, sh, arg1) if sh<=fw/2 else simd_srai(fw/2, max(0, sh-(fw/2)), simd_srli(fw, fw/2, arg1)))''',
    401401                "Ops":["simd_srai"],
    402402                "Fws":[-1],
     
    463463                {
    464464                "body":r'''
    465 return _mm_sign_epi8(arg1, simd_constant(fw, -1))''',
     465return _mm_sign_epi8(arg1, simd_constant(fw, (1<<fw)-1))''',
    466466                "Ops":["simd_neg"],
    467467                "Fws":[8],
     
    472472                {
    473473                "body":r'''
    474 return _mm_sign_epi16(arg1, simd_constant(fw, -1))''',
     474return _mm_sign_epi16(arg1, simd_constant(fw, (1<<fw)-1))''',
    475475                "Ops":["simd_neg"],
    476476                "Fws":[16],
     
    481481                {
    482482                "body":r'''
    483 return _mm_sign_epi32(arg1, simd_constant(fw, -1))''',
     483return _mm_sign_epi32(arg1, simd_constant(fw, (1<<fw)-1))''',
    484484                "Ops":["simd_neg"],
    485485                "Fws":[32],
     
    570570                },
    571571       
    572                 "sll_64_blend":\
     572                "vsll_64_blend":\
    573573                {
    574574                "body":r'''
    575575return simd_ifh(1, simd_himask(128), _mm_sll_epi64(arg1, simd_and(_mm_srli_si128(shift_mask, 8), _mm_cvtsi32_si128(63))), _mm_sll_epi64(arg1, simd_and(shift_mask, _mm_cvtsi32_si128(63))))''',
    576                 "Ops":["simd_sll"],
    577                 "Fws":[64],
    578                 "Platforms":[arch for arch in configure.SSE_SERIES],
    579                 },
    580                
     576                "Ops":["simd_vsll"],
     577                "Fws":[64],
     578                "Platforms":[arch for arch in configure.SSE_SERIES],
     579                },
     580               
     581                "vsll_128_blend":\
     582                {
     583                "body":r'''
     584shift = simd_and(shift_mask, _mm_cvtsi32_si128(127))
     585return simd_or(_mm_sll_epi64(arg1, shift), simd_or(_mm_slli_si128(_mm_sll_epi64(arg1, simd_sub(32, shift, _mm_cvtsi32_si128(64))), 8),  _mm_slli_si128(_mm_srl_epi64(arg1, simd_sub(32, _mm_cvtsi32_si128(64), shift)), 8)))''',
     586                "Ops":["simd_vsll"],
     587                "Fws":[128],
     588                "Platforms":[arch for arch in configure.SSE_SERIES],
     589                },
     590
    581591                "sll_128_blend":\
    582592                {
    583593                "body":r'''
    584 shift = simd_and(shift_mask, _mm_cvtsi32_si128(127))
     594shift = simd_and(shift_mask, _mm_cvtsi32_si128((1<<32)-1))
    585595return simd_or(_mm_sll_epi64(arg1, shift), simd_or(_mm_slli_si128(_mm_sll_epi64(arg1, simd_sub(32, shift, _mm_cvtsi32_si128(64))), 8),  _mm_slli_si128(_mm_srl_epi64(arg1, simd_sub(32, _mm_cvtsi32_si128(64), shift)), 8)))''',
    586596                "Ops":["simd_sll"],
     
    622632                {
    623633                "body":r'''
    624 return simd_or(simd_slli(128, sh, arg1), avx_move_lo128_to_hi128(simd_srli(128, (256-sh)&0x7F, arg1))) if (sh<128) else simd_slli(128, sh-128, avx_move_lo128_to_hi128(arg1))''',
     634return simd_or(simd_slli(128, sh, arg1), avx_move_lo128_to_hi128(simd_srli(128, (128-sh), arg1))) if (sh<128) else simd_slli(128, sh-128, avx_move_lo128_to_hi128(arg1))''',
    625635                "Ops":["simd_slli"],
    626636                "Fws":[256],
     
    673683                },
    674684               
    675                 "srl_64_blend":\
     685                "vsrl_64_blend":\
    676686                {
    677687                "body":r'''
    678688return simd_ifh(1, simd_himask(128), _mm_srl_epi64(arg1, simd_and(_mm_srli_si128(shift_mask, 8), _mm_cvtsi32_si128(63))), _mm_srl_epi64(arg1, simd_and(shift_mask, _mm_cvtsi32_si128(63))))''',
    679                 "Ops":["simd_srl"],
    680                 "Fws":[64],
    681                 "Platforms":[arch for arch in configure.SSE_SERIES],
    682                 },
    683                
     689                "Ops":["simd_vsrl"],
     690                "Fws":[64],
     691                "Platforms":[arch for arch in configure.SSE_SERIES],
     692                },
     693               
     694                "vsrl_128_blend":\
     695                {
     696                "body":r'''
     697shift = simd_and(shift_mask, _mm_cvtsi32_si128(127))
     698return simd_or(_mm_srl_epi64(arg1, shift), simd_or(_mm_srli_si128(_mm_srl_epi64(arg1, simd_sub(32, shift, _mm_cvtsi32_si128(64))), 8),  _mm_srli_si128(_mm_sll_epi64(arg1, simd_sub(32, _mm_cvtsi32_si128(64), shift)), 8)))''',
     699                "Ops":["simd_vsrl"],
     700                "Fws":[128],
     701                "Platforms":[arch for arch in configure.SSE_SERIES],
     702                },             
     703
    684704                "srl_128_blend":\
    685705                {
    686706                "body":r'''
    687 shift = simd_and(shift_mask, _mm_cvtsi32_si128(127))
     707shift = simd_and(shift_mask, _mm_cvtsi32_si128((1<<32)-1))
    688708return simd_or(_mm_srl_epi64(arg1, shift), simd_or(_mm_srli_si128(_mm_srl_epi64(arg1, simd_sub(32, shift, _mm_cvtsi32_si128(64))), 8),  _mm_srli_si128(_mm_sll_epi64(arg1, simd_sub(32, _mm_cvtsi32_si128(64), shift)), 8)))''',
    689709                "Ops":["simd_srl"],
    690710                "Fws":[128],
    691711                "Platforms":[arch for arch in configure.SSE_SERIES],
     712                },
     713               
     714                "srl_256_blend":\
     715                {
     716                "body":r'''
     717shift = _mm_cvtsi128_si32(avx_select_lo128(shift_mask))
     718n = shift / 64
     719arg2 = mvmd_srli(64, 1, arg1) if n==1 else (mvmd_srli(64, 2, arg1) if n==2 else (mvmd_srli(64, 3, arg1) if n==3 else arg1))
     720return simd_constant(32, 0) if n>=4 else (simd_or(_mm256_srl_epi64(arg2, _mm_cvtsi32_si128(shift & 63)), mvmd_srli(64, 1, _mm256_sll_epi64(arg2, _mm_cvtsi32_si128(64 - (shift & 63))))) if (shift & 63) > 0 else arg2)         
     721                ''',
     722                "Ops":["simd_srl"],
     723                "Fws":[256],
     724                "Platforms":[configure.AVX2],
     725                },
     726               
     727                "sll_256_blend":\
     728                {
     729                "body":r'''
     730shift = _mm_cvtsi128_si32(avx_select_lo128(shift_mask))
     731n = shift / 64
     732arg2 = mvmd_slli(64, 1, arg1) if n==1 else (mvmd_slli(64, 2, arg1) if n==2 else (mvmd_slli(64, 3, arg1) if n==3 else arg1))
     733return simd_constant(32, 0) if n>=4 else (simd_or(_mm256_sll_epi64(arg2, _mm_cvtsi32_si128(shift & 63)), mvmd_slli(64, 1, _mm256_srl_epi64(arg2, _mm_cvtsi32_si128(64 - (shift & 63))))) if (shift & 63) > 0 else arg2)         
     734                ''',
     735                "Ops":["simd_sll"],
     736                "Fws":[256],
     737                "Platforms":[configure.AVX2],
    692738                },
    693739       
     
    722768                {
    723769                "body":r'''
    724 return simd_or(simd_srli(128, sh, arg1), simd_slli(128, (256-sh)&0x7F, IDISA_CASTING("SIMD_type", _mm256_castsi128_si256(avx_select_hi128(arg1))))) if (sh<128) else simd_srli(128, (sh - 128)&0x7F, avx_move_hi128_to_lo128(arg1))''',
     770return simd_or(simd_srli(128, sh, arg1), simd_slli(128, (128-sh), IDISA_CASTING("_mm256_castsi128_si256", avx_select_hi128(arg1)))) if (sh<128) else simd_srli(128, (sh - 128), avx_move_hi128_to_lo128(arg1))''',
    725771                "Ops":["simd_srli"],
    726772                "Fws":[256],
     
    776822                {
    777823                "body":r'''
    778 return simd_xor(arg1, simd_constant(32, -1))''',
     824return simd_xor(arg1, simd_constant(32, 4294967295))''',
    779825                "Ops":["simd_not"],
    780826                "Fws":[1],
     
    836882                "Fws":[64],
    837883                "Platforms":configure.AVX_SERIES,
     884                },
     885
     886                "bitblock_popcount_256_avx2":\
     887                {
     888                "body":r'''
     889return __builtin_popcountll(mvmd_extract(64, 0, arg1)) + __builtin_popcountll(mvmd_extract(64, 1, arg1)) + __builtin_popcountll(mvmd_extract(64, 2, arg1)) + __builtin_popcountll(mvmd_extract(64, 3, arg1))''',
     890                "Ops":["bitblock_popcount"],
     891                "Fws":[256],
     892                "Platforms":[configure.AVX2],
     893                },             
     894
     895                "simd_popcount_256_avx2":\
     896                {
     897                "body":r'''
     898return _mm256_castsi128_si256(_mm_cvtsi64_si128(bitblock_popcount(arg1)))''',
     899                "Ops":["simd_popcount"],
     900                "Fws":[256],
     901                "Platforms":[configure.AVX2],
    838902                },
    839903               
     
    914978                {
    915979                "body":r'''
    916 return _mm_set_epi32(0,-1, 0, -1)''',
     980return _mm_set_epi32(0,(1<<32)-1, 0, (1<<32)-1)''',
    917981                "Ops":["simd_lomask"],
    918982                "Fws":[64],
     
    923987                {
    924988                "body":r'''
    925 return IDISA_CASTING("SIMD_type", _mm256_set_epi32(0, -1, 0, -1, 0, -1, 0, -1))''',
     989return IDISA_CASTING("SIMD_type", _mm256_set_epi32(0, (1<<32)-1, 0, (1<<32)-1, 0, (1<<32)-1, 0, (1<<32)-1))''',
    926990                "Ops":["simd_lomask"],
    927991                "Fws":[64],
     
    9411005                {
    9421006                "body":r'''
    943 return _mm_set_epi32(0, 0, -1, -1)''',
     1007return _mm_set_epi32(0, 0, (1<<32)-1, (1<<32)-1)''',
    9441008                "Ops":["simd_lomask"],
    9451009                "Fws":[128],
     
    9501014                {
    9511015                "body":r'''
    952 return IDISA_CASTING("SIMD_type", _mm256_set_epi32(0, 0, -1, -1, 0, 0,-1, -1))''',
     1016return IDISA_CASTING("SIMD_type", _mm256_set_epi32(0, 0, (1<<32)-1, (1<<32)-1, 0, 0,(1<<32)-1, (1<<32)-1))''',
    9531017                "Ops":["simd_lomask"],
    9541018                "Fws":[128],
     
    9591023                {
    9601024                "body":r'''
    961 return IDISA_CASTING("SIMD_type", _mm256_set_epi32(0, 0, 0, 0,-1,-1,-1,-1))''',
     1025return IDISA_CASTING("SIMD_type", _mm256_set_epi32(0, 0, 0, 0,(1<<32)-1,(1<<32)-1,(1<<32)-1,(1<<32)-1))''',
    9621026                "Ops":["simd_lomask"],
    9631027                "Fws":[256],
     
    9861050                {
    9871051                "body":r'''
    988 return simd_constant(fw, -65536)''',
     1052return simd_constant(fw, 4294901760)''',
    9891053                "Ops":["simd_himask"],
    9901054                "Fws":[32],
     
    9951059                {
    9961060                "body":r'''
    997 return _mm_set_epi32(-1, 0, -1, 0)''',
     1061return _mm_set_epi32((1<<32)-1, 0, (1<<32)-1, 0)''',
    9981062                "Ops":["simd_himask"],
    9991063                "Fws":[64],
     
    10041068                {
    10051069                "body":r'''
    1006 return IDISA_CASTING("SIMD_type", _mm256_set_epi32(-1, 0, -1, 0, -1, 0, -1, 0))''',
     1070return IDISA_CASTING("SIMD_type", _mm256_set_epi32((1<<32)-1, 0, (1<<32)-1, 0, (1<<32)-1, 0, (1<<32)-1, 0))''',
    10071071                "Ops":["simd_himask"],
    10081072                "Fws":[64],
     
    10221086                {
    10231087                "body":r'''
    1024 return _mm_set_epi32(-1, -1, 0, 0)''',
     1088return _mm_set_epi32((1<<32)-1, (1<<32)-1, 0, 0)''',
    10251089                "Ops":["simd_himask"],
    10261090                "Fws":[128],
     
    10311095                {
    10321096                "body":r'''
    1033 return IDISA_CASTING("SIMD_type", _mm256_set_epi32(-1,-1, 0, 0,-1,-1, 0, 0))''',
     1097return IDISA_CASTING("SIMD_type", _mm256_set_epi32((1<<32)-1,(1<<32)-1, 0, 0,(1<<32)-1,(1<<32)-1, 0, 0))''',
    10341098                "Ops":["simd_himask"],
    10351099                "Fws":[128],
     
    10401104                {
    10411105                "body":r'''
    1042 return IDISA_CASTING("SIMD_type", _mm256_set_epi32(-1,-1,-1,-1, 0, 0, 0, 0))''',
     1106return IDISA_CASTING("SIMD_type", _mm256_set_epi32((1<<32)-1,(1<<32)-1,(1<<32)-1,(1<<32)-1, 0, 0, 0, 0))''',
    10431107                "Ops":["simd_himask"],
    10441108                "Fws":[256],
     
    10651129                },
    10661130
     1131                "constant_doubling_1":\
     1132                {
     1133                "body":r'''
     1134return simd_constant(2*fw, (val<<fw) | (val & ((1<<fw)-1)))
     1135''',
     1136                "Ops":["simd_constant"],
     1137                "Fws":range(2, 5),
     1138                "Platforms":[configure.ALL],
     1139                },
     1140
    10671141                "constant_1_blend":\
    10681142                {
    10691143                #simd<1>::constant only accepts 0 or 1
    10701144                "body":r'''
    1071 return simd_constant(32, -1*val)
     1145return simd_constant(2, val + val + val)
    10721146''',
    10731147                "Ops":["simd_constant"],
     
    14871561                "Ops":["hsimd_signmask"],
    14881562                "Fws":[8],
    1489                 "Platforms":configure.AVX_SERIES,
     1563                "Platforms":[configure.AVX],
     1564                },
     1565               
     1566                "signmask_avx2_32":\
     1567                {
     1568                "body":r'''
     1569return _mm256_movemask_ps(IDISA_CASTING("_mm256_castsi256_ps", arg1))''',
     1570                "Ops":["hsimd_signmask"],
     1571                "Fws":[32],
     1572                "Platforms":[configure.AVX2],
     1573                },
     1574               
     1575                "signmask_avx2_64":\
     1576                {
     1577                "body":r'''
     1578return _mm256_movemask_pd(IDISA_CASTING("_mm256_castsi256_pd", arg1))''',
     1579                "Ops":["hsimd_signmask"],
     1580                "Fws":[64],
     1581                "Platforms":[configure.AVX2],
    14901582                },
    14911583               
     
    19912083                "Fws":range(2, curRegSize+1),
    19922084                "Platforms":[configure.ALL],
     2085                },
     2086
     2087                "mvmd_slli_64_avx2_permute":\
     2088                {
     2089                "body":r'''
     2090return simd_and(_mm256_set_epi64x(18446744073709551615, 18446744073709551615, 18446744073709551615, 0), _mm256_permute4x64_epi64(arg1, 128+16)) if sh == 1 else (simd_and(_mm256_set_epi64x(18446744073709551615, 18446744073709551615, 0, 0), _mm256_permute4x64_epi64(arg1, 64)) if sh == 2 else (simd_and(_mm256_set_epi64x(18446744073709551615, 0, 0, 0), _mm256_permute4x64_epi64(arg1, 0)) if sh == 3 else (arg1 if sh == 0 else simd_constant(32, 0))))''',
     2091                "Ops":["mvmd_slli"],
     2092                "Fws": [64],
     2093                "Platforms":[configure.AVX2],
     2094                },
     2095
     2096                "mvmd_srli_64_avx2_permute":\
     2097                {
     2098                "body":r'''
     2099return simd_and(_mm256_set_epi64x(0, 0, 0, 18446744073709551615), _mm256_permute4x64_epi64(arg1, 3)) if sh == 3 else (simd_and(_mm256_set_epi64x(0, 0, 18446744073709551615, 18446744073709551615), _mm256_permute4x64_epi64(arg1, 14)) if sh == 2 else (simd_and(_mm256_set_epi64x(0, 18446744073709551615, 18446744073709551615, 18446744073709551615), _mm256_permute4x64_epi64(arg1, 57)) if sh == 1 else (arg1 if sh == 0 else simd_constant(32, 0))))''',
     2100                "Ops":["mvmd_srli"],
     2101                "Fws":[64],
     2102                "Platforms":[configure.AVX2],
    19932103                },
    19942104               
     
    23602470                {
    23612471                "body":r'''
    2362 return hsimd_signmask(8, simd_eq(8, arg1, simd_constant(8, -1))) == 0xFFFF''',
     2472return hsimd_signmask(8, simd_eq(8, arg1, simd_constant(8, 255))) == 0xFFFF''',
    23632473                "Ops":["bitblock_all"],
    23642474                "Fws":[curRegSize],
     
    23692479                {
    23702480                "body":r'''
    2371 return _mm256_testz_si256(IDISA_CASTING("__m256i", simd_not(arg1)), IDISA_CASTING("__m256i", simd_constant(8, -1))) == 1''',
     2481return _mm256_testz_si256(IDISA_CASTING("__m256i", simd_not(arg1)), IDISA_CASTING("__m256i", simd_constant(8, 255))) == 1''',
    23722482                "Ops":["bitblock_all"],
    23732483                "Fws":[curRegSize],
     
    23782488                {
    23792489                "body":r'''
    2380 return hsimd_signmask(32, simd_eq(32, arg1, simd_constant(32, -1))) == 15''',
     2490return hsimd_signmask(32, simd_eq(32, arg1, simd_constant(32, 4294967295))) == 15''',
    23812491                "Ops":["bitblock_all"],
    23822492                "Fws":[curRegSize],
     
    24912601                "Platforms":[configure.ALL],
    24922602                },
     2603
     2604                "hsimd_add_hl_avx2_32":\
     2605                {
     2606                "body":r'''
     2607alpha = _mm256_permute2x128_si256(arg2, arg1, 32)
     2608beta  = _mm256_permute2x128_si256(arg2, arg1, 49)
     2609return _mm256_hadd_epi16(alpha, beta)
     2610''',
     2611                "Ops":["hsimd_add_hl"],
     2612                "Fws":[32],
     2613                "Platforms":[configure.AVX2],
     2614                },
     2615
     2616                "hsimd_add_hl_avx2_64":\
     2617                {
     2618                "body":r'''
     2619alpha = _mm256_permute2x128_si256(arg2, arg1, 32)
     2620beta  = _mm256_permute2x128_si256(arg2, arg1, 49)
     2621return _mm256_hadd_epi32(alpha, beta)
     2622''',
     2623                "Ops":["hsimd_add_hl"],
     2624                "Fws":[64],
     2625                "Platforms":[configure.AVX2],
     2626                },
     2627
     2628                "hsimd_packus_avx2_16": \
     2629                {
     2630                "body":r'''
     2631alpha = _mm256_permute2x128_si256(arg2, arg1, 32)
     2632beta  = _mm256_permute2x128_si256(arg2, arg1, 49)
     2633return _mm256_packus_epi16(alpha, beta)         
     2634''',
     2635                "Ops":["hsimd_packus"],
     2636                "Fws":[16],
     2637                "Platforms":[configure.AVX2],
     2638                },
     2639
     2640                "hsimd_packus_avx2_32": \
     2641                {
     2642                "body":r'''
     2643alpha = _mm256_permute2x128_si256(arg2, arg1, 32)
     2644beta  = _mm256_permute2x128_si256(arg2, arg1, 49)
     2645return _mm256_packus_epi32(alpha, beta)         
     2646''',
     2647                "Ops":["hsimd_packus"],
     2648                "Fws":[32],
     2649                "Platforms":[configure.AVX2],
     2650                },
     2651
     2652                "hsimd_packss_avx2_16": \
     2653                {
     2654                "body":r'''
     2655alpha = _mm256_permute2x128_si256(arg2, arg1, 32)
     2656beta  = _mm256_permute2x128_si256(arg2, arg1, 49)
     2657return _mm256_packs_epi16(alpha, beta)         
     2658''',
     2659                "Ops":["hsimd_packss"],
     2660                "Fws":[16],
     2661                "Platforms":[configure.AVX2],
     2662                },
     2663
     2664                "hsimd_packss_avx2_32": \
     2665                {
     2666                "body":r'''
     2667alpha = _mm256_permute2x128_si256(arg2, arg1, 32)
     2668beta  = _mm256_permute2x128_si256(arg2, arg1, 49)
     2669return _mm256_packs_epi32(alpha, beta)         
     2670''',
     2671                "Ops":["hsimd_packss"],
     2672                "Fws":[32],
     2673                "Platforms":[configure.AVX2],
     2674                },
     2675
     2676                "mvmd_insert_halfing": \
     2677                {
     2678                "body":r'''
     2679return mvmd_insert(fw/2, 2*pos, mvmd_insert(fw/2, 2*pos+1, arg1, (arg2 >> (fw/2))), (arg2 & ((1<<(fw/2)) - 1)))
     2680''',
     2681                "Ops":["mvmd_insert"],
     2682                "Fws":range(2, 65),
     2683                "Platforms":[configure.ALL],
     2684                },
     2685
     2686                "mvmd_insert_doubling": \
     2687                {
     2688                "body":r'''
     2689v = arg2 & ((1 << fw) - 1)
     2690doublev = mvmd_extract(fw*2, pos/2, arg1)
     2691return mvmd_insert(fw*2, pos/2, arg1, (((doublev >> fw) << fw) | v) if (pos & 1) == 0 else (doublev & ((1<<fw)-1) | (v << fw)))
     2692''',
     2693                "Ops":["mvmd_insert"],
     2694                "Fws":range(2, 33),
     2695                "Platforms":[configure.ALL],
     2696                },
     2697
     2698                "mvmd_insert_16_avx2": \
     2699                {
     2700                "body":r'''
     2701return avx_general_combine256(avx_select_hi128(arg1), _mm_insert_epi16(avx_select_lo128(arg1), arg2, pos)) if pos < 8 else avx_general_combine256(_mm_insert_epi16(avx_select_hi128(arg1), arg2, pos-8), avx_select_lo128(arg1))
     2702''',
     2703                "Ops":["mvmd_insert"],
     2704                "Fws":[16],
     2705                "Platforms":[configure.AVX2],
     2706                },
    24932707        }       
    24942708       
  • trunk/libgen/Library_Generator/UI.py

    r3436 r3584  
    127127
    128128                        codes += \
    129 """                     
     129"""             
     130#ifndef FIELD_TYPE
     131#define FIELD_TYPE     
    130132template <uint32_t fw> struct FieldType {
    131133   typedef int T;  //default for FieldType::T is int
     
    141143template <> struct FieldType<128> {typedef uint64_t T;};
    142144template <> struct FieldType<256> {typedef uint64_t T;};
     145#endif
    143146
    144147"""
     
    197200                                                        operationImp[classType][operation.fullName].append(curOperation.ToCppText())
    198201                                                        operationDecla[classType][operation.fullName].append(curOperation.FunctionDeclarationToCppText())
     202                                                else:
     203                                                        pass                                                   
     204                                                        # print "WTF, too many op count for: %s fw = %d, count = %d" % (opName, fw, optOpCount[operation.fullName + "_" + str(fw)])
    199205                       
    200206                        if whichContent != configure.Body_Declaration:         
  • trunk/libgen/Library_Generator/Utility.py

    r3436 r3584  
    6464        return ret
    6565
     66# e.g. body = '#define abc(x)', will extract 'abc'
     67def ExtractNameFromFunctionSupport(body, origin_key):   
     68        m = re.search(r'\#define\s+(\w+)\s*\(', body)
     69        if m:           
     70                return m.group(1)
     71        else:
     72                return origin_key
     73
    6674#Load some pre-defined functions
    6775def LoadFunctionSupport(arch, lang):
     
    7886        for func in allFuncs:
    7987                if "all" in allFuncs[func]["platform"] or arch in allFuncs[func]["platform"]:
    80                         retFuncs[func] = allFuncs[func]
    81                         retFuncs[func]["body"] = retFuncs[func]["body"].replace("(SIMD_type)", "("+configure.Bitblock_type[arch]+")")
    82 
     88                        fname = ExtractNameFromFunctionSupport(allFuncs[func]["body"], func)
     89                        retFuncs[fname] = allFuncs[func]
     90                        retFuncs[fname]["body"] = retFuncs[fname]["body"].replace("(SIMD_type)", "("+configure.Bitblock_type[arch]+")")
     91                       
    8392        return retFuncs
    8493
     
    179188                #if we have provided a signature
    180189                if self.cpp_class_signature != "":
    181                         declare = ("template <> " if self.classType != "bitblock" else "") + self.ClassDeclarationToCppText()
     190                        declare = ("template <> " if self.classType.find("bitblock") == -1 else "") + self.ClassDeclarationToCppText()
    182191                        declare = declare.replace("static ", "")                       
    183192                        declare = declare.replace("typename ", "")
    184193                        declare = re.sub(r'\bfw\b', str(self.fieldWidth), declare)
    185                         if self.classType != "bitblock":                       
     194                        if self.classType.find("bitblock") == -1:                       
    186195                                declare = re.sub(r'\b' + self.name + r'\b', "%s<%d>::%s" % (self.classType, self.fieldWidth, self.name), declare)                       
    187196                        else:
  • trunk/libgen/Library_Tester/CalculatingModules/bitblock_sll.py

    r1924 r3584  
    33# Licensed under the Academic Free License 3.0.
    44
    5 import simd_slli
     5import simd_sll
    66
    77def GetResult(data):
    88    (arg1, count) = (data[0], data[1])
    99    (i, regSize, ans) = (0, len(arg1), "")
    10    
    11     while i<regSize:
    12         sh = int(count[i:i+regSize], 2) if regSize<=32 else int(count[i+regSize-32:i+regSize], 2)
    13         sh &= regSize -1
    14         ans += simd_slli.GetResult(regSize, sh, [arg1[i:i+regSize]])
    15         i += regSize
    16    
    17     return ans
     10
     11    return simd_sll.GetResult(regSize, data)
  • trunk/libgen/Library_Tester/CalculatingModules/bitblock_srl.py

    r1924 r3584  
    33# Licensed under the Academic Free License 3.0.
    44
    5 import simd_srli
     5import simd_srl
    66
    77def GetResult(data):
     
    99    (i, regSize, ans) = (0, len(arg1), "")
    1010   
    11     while i<regSize:
    12         sh = int(count[i:i+regSize], 2) if regSize<=32 else int(count[i+regSize-32:i+regSize], 2)
    13         sh &= regSize -1
    14         ans += simd_srli.GetResult(regSize, sh, [arg1[i:i+regSize]])
    15         i += regSize
    16    
    17     return ans
     11    return simd_srl.GetResult(regSize, data)
  • trunk/libgen/Library_Tester/CalculatingModules/simd_sll.py

    r1923 r3584  
    77def GetResult(fw, data):
    88        (arg1, count) = (data[0], data[1])
    9         (i, sz, ans) = (0, len(arg1), "")
    10        
    11         while i<sz:
    12                 sh = int(count[i:i+fw], 2) if fw<=32 else int(count[i+fw-32:i+fw], 2)
    13                 sh &= (fw - 1)
    14                 ans += simd_slli.GetResult(fw, sh, [arg1[i:i+fw]])
    15                 i += fw
    16        
    17         return ans
     9        return simd_slli.GetResult(fw, int(count[-32:], 2), [arg1])
  • trunk/libgen/Library_Tester/CalculatingModules/simd_sra.py

    r1767 r3584  
    77def GetResult(fw, data):
    88        (arg1, count) = (data[0], data[1])
    9         (i, sz, ans) = (0, len(arg1), "")
    10         count = int(count[-32:], 2)
    11         ans = simd_srai.GetResult(fw, count, [arg1])
    12         return ans
     9        return simd_srai.GetResult(fw, int(count[-32:], 2), [arg1])
  • trunk/libgen/Library_Tester/CalculatingModules/simd_srl.py

    r1923 r3584  
    77def GetResult(fw, data):
    88        (arg1, count) = (data[0], data[1])
    9         (i, sz, ans) = (0, len(arg1), "")
    10        
    11         while i<sz:
    12                 sh = int(count[i:i+fw], 2) if fw<=32 else int(count[i+fw-32:i+fw], 2)
    13                 sh &= (fw - 1)
    14                 ans += simd_srli.GetResult(fw, sh, [arg1[i:i+fw]])
    15                 i += fw
    16        
    17         return ans
     9        return simd_srli.GetResult(fw, int(count[-32:], 2), [arg1])
  • trunk/libgen/Library_Tester/GenerateTests.py

    r3436 r3584  
    44
    55import os
    6 
    76import GenData
    87import TesterUtility
     
    109
    1110# Number of test cases. For development, use small number to test faster.
    12 maxTestCase = 20
     11maxTestCase = 10
    1312
    1413def MakeTestdata(arch, definedOperations, validOperations):
     
    3837                        for i in range(len(templatedData)):
    3938                                testingData[opFullName + "_" + str(regSize)][i].append(templatedData[i])
    40                 else:
     39                else:                   
    4140                        #operations with other types
    4241                        for validOp in validOperations[opFullName]:
    43                                 operation = definedOperations[opFullName][validOp.fw]
     42                                operation = definedOperations[opFullName][validOp.fw]                           
     43
    4444                                if operation.opPattern == 0:
    4545                                        #normal operations
     
    5151                                        templatedData = []
    5252                                        for key in operation.valueRange:
     53                                                if "arg" in key:
     54                                                        # we want templated values only. Args can also appear in the valueRange
     55                                                        continue
    5356                                                lowBound = operation.valueRange[key]["min"]
    5457                                                upBound = operation.valueRange[key]["max"]
    55                                                 templatedData = TesterUtility.GetRandomNums(lowBound, upBound, maxTestCase)
    56                                                 break
     58                                                templatedData = TesterUtility.GetRandomNums(lowBound, upBound, maxTestCase)                                             
    5759                                       
    5860                                        for i in range(len(templatedData)):
  • trunk/libgen/Library_Tester/LibraryTester.py

    r3436 r3584  
    1818from TestDriverGenerater import CppDriverGenerater, CDriverGenerater
    1919
    20 import ipdb
    2120
    2221def WriteTestingData(fileName, data):
     
    5251        elif arch == configure.AVX2:
    5352                return "g++ -mavx2 -o"
     53        elif arch in configure.LLVM_SERIES:
     54                return "./llvm_build.sh "
     55
     56def GetRunCommand(arch):
     57        if arch in configure.LLVM_SERIES:
     58                return "lli optimized.bc"
     59        else:
     60                return "./" + arch + "_test"
    5461
    5562def ReadContentAsOneLine(fileName):
     
    160167       
    161168        if options.test_option != "neon_gen_data":
    162                 #execute external shell commands to get output generated by library routines
     169                #execute external shell commands to get output generated by library routines           
    163170                os.system(GetGCCCommand(arch) + arch + "_test" + " " + arch + "_test.cpp")
    164                 exeReturn = os.system("./" + arch + "_test")
     171                exeReturn = os.system(GetRunCommand(arch))
    165172                if exeReturn != 0:
    166173                        print "Something wrong with the xxx_test.cpp! Can not execute the xxx_test correctly!"
  • trunk/libgen/Library_Tester/TestDriverGenerater.py

    r3436 r3584  
    6969                arguments_init = ""
    7070                for i in range(oprdNum):
    71                         arguments_init += "\t" + SIMD_type + " arg" + str(i) + ";\n"
     71                        if operation.arguments[i].type == SIMD_type:
     72                                arguments_init += "\t" + SIMD_type + " arg" + str(i) + ";\n"
     73                        elif operation.arguments[i].type == "uint64_t":
     74                                arguments_init += "\t" + "uint64_t arg" + str(i) + ";\n"
     75                        else:
     76                                print "can't process this data type", operation.arguments[i].type                       
    7277               
    7378                test_body = ""
     
    224229                elif arch == configure.NEON:
    225230                        return "USE_NEON"
     231                elif arch == configure.LLVM128:
     232                        return "USE_LLVM128"
     233                       
     234                print "WARNING: GetArchSymbol: arch not recognized"
    226235                return "missing arch define"
    227236
  • trunk/libgen/Library_Tester/TesterUtility.py

    r1767 r3584  
    3939        elif "neon" in arch:
    4040                return 3
     41        elif "llvm128" in arch:
     42                return 1
     43
     44        print "WARNING: GetOptId, arch not recognized"
    4145        return -1
    4246
  • trunk/libgen/Library_Tester/utility.h

    r3436 r3584  
    1 #include "idisa_avx2.h"
    2 #define USE_AVX2
    3 typedef __m256i SIMD_type;
     1#include "idisa_sse2.h"
     2#define USE_SSE
     3typedef __m128i SIMD_type;
    44#include <vector>
    55#include <iostream>
     
    130130                case 1:
    131131{
    132 #ifdef USE_SSE
    133132                        int buf[4];
    134133                        regSize = 128;
     
    149148                        }
    150149                        //cout << endl;
     150#ifdef USE_SSE
    151151                        ans = _mm_loadu_si128((SIMD_type *)buf);
     152#else
     153                        ans = bitblock::load_unaligned((SIMD_type *)buf);
    152154#endif
    153155}
     
    201203                        break;
    202204                default:
     205                        cerr << "LoadfromString Invalid opt code! Get opt code = " << opt << endl;
    203206                        break;
    204207        }
     
    222225                case 1:
    223226{
    224 #ifdef USE_SSE
    225227                        int buf[4];
    226228                       
    227229                        buf[0] = buf[1] = buf[2] = buf[3] = x;
    228230                       
     231#ifdef USE_SSE
    229232                        ans = _mm_loadu_si128((SIMD_type *)buf);
     233#else
     234                        ans = bitblock::load_unaligned((SIMD_type *)buf);
    230235#endif
    231236}
     
    262267                        break;
    263268                default:
     269                        cerr << "LoadfromInt Invalid opt code! Get opt code = " << opt << endl;
    264270                        break;
    265271        }
     
    281287                case 1:
    282288{
     289                        int buf[4];
    283290#ifdef USE_SSE
    284                         int buf[4];
    285291                        _mm_storeu_si128((SIMD_type *)buf, v);
     292#else
     293                        bitblock::store_unaligned(v, (SIMD_type *)buf);                 
     294#endif
    286295                        /*
    287296                        //big endian
     
    296305                                ans = ans + Int2BitString(buf[i]);     
    297306                        }
    298 #endif
    299307}
    300308                        break;
     
    354362                        break;
    355363                default:
     364                        cerr << "Store2String opt code wrong! Get opt code = " << opt << endl;
    356365                        break;
    357366        }
  • trunk/libgen/Makefile

    r3436 r3584  
    2727IDISA_AVX_CPP_LIB = idisa_avx
    2828IDISA_AVX2_CPP_LIB = idisa_avx2
     29IDISA_LLVM128_CPP_LIB = idisa_llvm128
    2930
    3031IDISA128 = idisa128
     
    3738
    3839BODY_IMPLEMENTATION = implementation
     40
     41playground: Library_Tester/playground.cpp
     42        # g++ -o playground -mavx2 -march=core-avx2 Library_Tester/playground.cpp       
     43        g++ -o playground -msse2 Library_Tester/playground.cpp         
    3944
    4045sse2:
     
    112117avx2_test:
    113118        python $(IDISA_TESTER) -a avx2 -l cpp -f $(IDISA_AVX2_CPP_LIB) -t
     119
     120llvm:
     121        python $(IDISA_GENERATOR) -a llvm128 -l cpp -f $(IDISA_LLVM128_CPP_LIB).h -g
     122llvm_test:
     123        python $(IDISA_TESTER) -a llvm128 -l cpp -f $(IDISA_LLVM128_CPP_LIB) -t
    114124#avx_strategy_count:
    115125#       python $(IDISA_GENERATOR) -a avx -l cpp -f $(IDISA_AVX_CPP_LIB).h -g --strategy_count = True
     
    155165        python $(IDISA_GENERATOR) -a avx -l cpp -f $(IDISA_AVX_CPP_LIB).cpp -g --body=$(BODY_IMPLEMENTATION)
    156166        mv $(GENERATOR_DIR)/$(IDISA_AVX_CPP_LIB).cpp $(LIB_CPP_DIR)/
     167
     168        python $(IDISA_GENERATOR) -a avx2 -l cpp -f $(IDISA_AVX2_CPP_LIB).cpp -g --body=$(BODY_IMPLEMENTATION)
     169        mv $(GENERATOR_DIR)/$(IDISA_AVX2_CPP_LIB).cpp $(LIB_CPP_DIR)/
    157170
    158171idisa:
  • trunk/libgen/README.md

    r3436 r3584  
    1 Copyright (c) 2011, Hua Huang and Robert D. Cameron.
     1Copyright (c) 2011, Hua Huang, Robert D. Cameron and Meng Lin.
    22
    33Licensed under the Academic Free License 3.0.
     
    55# Overview:
    66This is a toolkit called IDISA+ which could automatically generate SIMD libraries
    7 for SSE2/SSE3/SSSE3/SSE4.1/SSE4.2/AVX/NEON platforms. The supported operations can be found in the IDISA+.pdf.
     7for SSE2/SSE3/SSSE3/SSE4.1/SSE4.2/AVX/NEON platforms. The supported operations can be found in the [IDISA+.pdf](https://github.com/Logicalmars/SIMD-libgen/blob/master/doc/).
    88This toolkit has two components, the library generator and the library tester.
    99
Note: See TracChangeset for help on using the changeset viewer.