src/gallium/drivers/swr/rasterizer/jitter/scripts/gen_llvm_ir_macros.py

   1 # Copyright (C) 2014-2015 Intel Corporation.   All Rights Reserved.
   2 #
   3 # Permission is hereby granted, free of charge, to any person obtaining a
   4 # copy of this software and associated documentation files (the "Software"),
   5 # to deal in the Software without restriction, including without limitation
   6 # the rights to use, copy, modify, merge, publish, distribute, sublicense,
   7 # and/or sell copies of the Software, and to permit persons to whom the
   8 # Software is furnished to do so, subject to the following conditions:
   9 #
  10 # The above copyright notice and this permission notice (including the next
  11 # paragraph) shall be included in all copies or substantial portions of the
  12 # Software.
  13 #
  14 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15 # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  17 # THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  18 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  19 # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  20 # IN THE SOFTWARE.
  21
  22 #!deps/python32/python.exe
  23
  24 import os, sys, re
  25 import argparse
  26 import json as JSON
  27 import operator
  28
  29 header = r"""/****************************************************************************
  30 * Copyright (C) 2014-2016 Intel Corporation.   All Rights Reserved.
  31 *
  32 * Permission is hereby granted, free of charge, to any person obtaining a
  33 * copy of this software and associated documentation files (the "Software"),
  34 * to deal in the Software without restriction, including without limitation
  35 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  36 * and/or sell copies of the Software, and to permit persons to whom the
  37 * Software is furnished to do so, subject to the following conditions:
  38 *
  39 * The above copyright notice and this permission notice (including the next
  40 * paragraph) shall be included in all copies or substantial portions of the
  41 * Software.
  42 *
  43 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  44 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  45 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  46 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  47 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  48 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  49 * IN THE SOFTWARE.
  50 *
  51 * @file %s
  52 *
  53 * @brief auto-generated file
  54 *
  55 * DO NOT EDIT
  56 *
  57 ******************************************************************************/
  58
  59 """
  60
  61 """
  62 """
  63 def gen_file_header(filename):
  64     global header
  65     headerStr = header % filename
  66     return headerStr.splitlines()
  67
  68
  69 inst_aliases = {
  70     'SHUFFLE_VECTOR': 'VSHUFFLE',
  71     'INSERT_ELEMENT': 'VINSERT',
  72     'EXTRACT_ELEMENT': 'VEXTRACT',
  73     'MEM_SET': 'MEMSET',
  74     'MEM_CPY': 'MEMCPY',
  75     'MEM_MOVE': 'MEMMOVE',
  76     'L_SHR': 'LSHR',
  77     'A_SHR': 'ASHR',
  78     'BIT_CAST': 'BITCAST',
  79     'U_DIV': 'UDIV',
  80     'S_DIV': 'SDIV',
  81     'U_REM': 'UREM',
  82     'S_REM': 'SREM',
  83     'BIN_OP': 'BINOP',
  84 }
  85
  86 intrinsics = [
  87         ["VGATHERPS", "x86_avx2_gather_d_ps_256", ["src", "pBase", "indices", "mask", "scale"]],
  88         ["VGATHERDD", "x86_avx2_gather_d_d_256", ["src", "pBase", "indices", "mask", "scale"]],
  89         ["VSQRTPS", "x86_avx_sqrt_ps_256", ["a"]],
  90         ["VRSQRTPS", "x86_avx_rsqrt_ps_256", ["a"]],
  91         ["VRCPPS", "x86_avx_rcp_ps_256", ["a"]],
  92         ["VMINPS", "x86_avx_min_ps_256", ["a", "b"]],
  93         ["VMAXPS", "x86_avx_max_ps_256", ["a", "b"]],
  94         ["VPMINSD", "x86_avx2_pmins_d", ["a", "b"]],
  95         ["VPMAXSD", "x86_avx2_pmaxs_d", ["a", "b"]],
  96         ["VROUND", "x86_avx_round_ps_256", ["a", "rounding"]],
  97         ["VCMPPS", "x86_avx_cmp_ps_256", ["a", "b", "cmpop"]],
  98         ["VBLENDVPS", "x86_avx_blendv_ps_256", ["a", "b", "mask"]],
  99         ["BEXTR_32", "x86_bmi_bextr_32", ["src", "control"]],
 100         ["VMASKLOADD", "x86_avx2_maskload_d_256", ["src", "mask"]],
 101         ["VMASKMOVPS", "x86_avx_maskload_ps_256", ["src", "mask"]],
 102         ["VPSHUFB", "x86_avx2_pshuf_b", ["a", "b"]],
 103         ["VPMOVSXBD", "x86_avx2_pmovsxbd", ["a"]],  # sign extend packed 8bit components
 104         ["VPMOVSXWD", "x86_avx2_pmovsxwd", ["a"]],  # sign extend packed 16bit components
 105         ["VPERMD", "x86_avx2_permd", ["idx", "a"]],
 106         ["VPERMPS", "x86_avx2_permps", ["idx", "a"]],
 107         ["VCVTPH2PS", "x86_vcvtph2ps_256", ["a"]],
 108         ["VCVTPS2PH", "x86_vcvtps2ph_256", ["a", "round"]],
 109         ["VHSUBPS", "x86_avx_hsub_ps_256", ["a", "b"]],
 110         ["VPTESTC", "x86_avx_ptestc_256", ["a", "b"]],
 111         ["VPTESTZ", "x86_avx_ptestz_256", ["a", "b"]],
 112         ["VFMADDPS", "x86_fma_vfmadd_ps_256", ["a", "b", "c"]],
 113         ["VCVTTPS2DQ", "x86_avx_cvtt_ps2dq_256", ["a"]],
 114         ["VMOVMSKPS", "x86_avx_movmsk_ps_256", ["a"]],
 115         ["INTERRUPT", "x86_int", ["a"]],
 116     ]
 117
 118 def convert_uppercamel(name):
 119     s1 = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', name)
 120     return re.sub('([a-z0-9])([A-Z])', r'\1_\2', s1).upper()
 121
 122 """
 123     Given an input file (e.g. IRBuilder.h) generates function dictionary.
 124 """
 125 def parse_ir_builder(input_file):
 126
 127     functions = []
 128
 129     lines = input_file.readlines()
 130
 131     idx = 0
 132     while idx < len(lines) - 1:
 133         line = lines[idx].rstrip()
 134         idx += 1
 135
 136         #match = re.search(r"\*Create", line)
 137         match = re.search(r"[\*\s]Create(\w*)\(", line)
 138         if match is not None:
 139             #print("Line: %s" % match.group(1))
 140
 141             if re.search(r"^\s*Create", line) is not None:
 142                 func_sig = lines[idx-2].rstrip() + line
 143             else:
 144                 func_sig = line
 145
 146             end_of_args = False
 147             while not end_of_args:
 148                 end_paren = re.search(r"\)", line)
 149                 if end_paren is not None:
 150                     end_of_args = True
 151                 else:
 152                     line = lines[idx].rstrip()
 153                     func_sig += line
 154                     idx += 1
 155
 156             delfunc = re.search(r"LLVM_DELETED_FUNCTION|= delete;", func_sig)
 157
 158             if not delfunc:
 159                 func = re.search(r"(.*?)\*[\n\s]*(Create\w*)\((.*?)\)", func_sig)
 160                 if func is not None:
 161
 162                     return_type = func.group(1).lstrip() + '*'
 163                     func_name = func.group(2)
 164                     arguments = func.group(3)
 165
 166                     func_args = ''
 167                     func_args_nodefs = ''
 168
 169                     num_args = arguments.count(',')
 170
 171                     arg_names = []
 172                     num_args = 0
 173                     args = arguments.split(',')
 174                     for arg in args:
 175                         arg = arg.lstrip()
 176                         if arg:
 177                             if num_args > 0:
 178                                 func_args += ', '
 179                                 func_args_nodefs += ', '
 180                             func_args += arg
 181                             func_args_nodefs += arg.split(' =')[0]
 182
 183                             split_args = arg.split('=')
 184                             arg_name = split_args[0].rsplit(None, 1)[-1]
 185
 186                             #print("Before ArgName = %s" % arg_name)
 187
 188                             reg_arg = re.search(r"[\&\*]*(\w*)", arg_name)
 189                             if reg_arg:
 190                                 #print("Arg Name = %s" % reg_arg.group(1))
 191                                 arg_names += [reg_arg.group(1)]
 192
 193                             num_args += 1
 194
 195                     ignore = False
 196
 197                     # The following functions need to be ignored.
 198                     if func_name == 'CreateInsertNUWNSWBinOp':
 199                         ignore = True
 200
 201                     if func_name == 'CreateMaskedIntrinsic':
 202                         ignore = True
 203
 204                     # Convert CamelCase to CAMEL_CASE
 205                     func_mod = re.search(r"Create(\w*)", func_name)
 206                     if func_mod:
 207                         func_mod = func_mod.group(1)
 208                         func_mod = convert_uppercamel(func_mod)
 209                         if func_mod[0:2] == 'F_' or func_mod[0:2] == 'I_':
 210                             func_mod = func_mod[0] + func_mod[2:]
 211
 212                     # Substitute alias based on CAMEL_CASE name.
 213                     func_alias = inst_aliases.get(func_mod)
 214                     if not func_alias:
 215                         func_alias = func_mod
 216
 217                         if func_name == 'CreateCall' or func_name == 'CreateGEP':
 218                             arglist = re.search(r'ArrayRef', func_args)
 219                             if arglist:
 220                                 func_alias = func_alias + 'A'
 221
 222                     if not ignore:
 223                         functions.append({
 224                                 "name": func_name,
 225                                 "alias": func_alias,
 226                                 "return": return_type,
 227                                 "args": func_args,
 228                                 "args_nodefs": func_args_nodefs,
 229                                 "arg_names": arg_names
 230                             })
 231
 232     return functions
 233
 234 """
 235     Auto-generates macros for LLVM IR
 236 """
 237 def generate_gen_h(functions, output_file):
 238     output_lines = gen_file_header(os.path.basename(output_file.name))
 239
 240     output_lines += [
 241         '#pragma once',
 242         '',
 243         '//////////////////////////////////////////////////////////////////////////',
 244         '/// Auto-generated Builder IR declarations',
 245         '//////////////////////////////////////////////////////////////////////////',
 246     ]
 247
 248     for func in functions:
 249         name = func['name']
 250         if func['alias']:
 251             name = func['alias']
 252         output_lines += [
 253             '%s%s(%s);' % (func['return'], name, func['args'])
 254         ]
 255
 256     output_file.write('\n'.join(output_lines) + '\n')
 257
 258 """
 259     Auto-generates macros for LLVM IR
 260 """
 261 def generate_gen_cpp(functions, output_file):
 262     output_lines = gen_file_header(os.path.basename(output_file.name))
 263
 264     output_lines += [
 265         '#include \"builder.h\"',
 266         ''
 267     ]
 268
 269     for func in functions:
 270         name = func['name']
 271         if func['alias']:
 272             name = func['alias']
 273
 274         args = func['arg_names']
 275         func_args = ''
 276         first_arg = True
 277         for arg in args:
 278             if not first_arg:
 279                 func_args += ', '
 280             func_args += arg
 281             first_arg = False
 282
 283         output_lines += [
 284             '//////////////////////////////////////////////////////////////////////////',
 285             '%sBuilder::%s(%s)' % (func['return'], name, func['args_nodefs']),
 286             '{',
 287             '   return IRB()->%s(%s);' % (func['name'], func_args),
 288             '}',
 289             '',
 290         ]
 291
 292     output_file.write('\n'.join(output_lines) + '\n')
 293
 294 """
 295     Auto-generates macros for LLVM IR
 296 """
 297 def generate_x86_h(output_file):
 298     output_lines = gen_file_header(os.path.basename(output_file.name))
 299
 300     output_lines += [
 301         '#pragma once',
 302         '',
 303         '//////////////////////////////////////////////////////////////////////////',
 304         '/// Auto-generated x86 intrinsics',
 305         '//////////////////////////////////////////////////////////////////////////',
 306     ]
 307
 308     for inst in intrinsics:
 309         #print("Inst: %s, x86: %s numArgs: %d" % (inst[0], inst[1], len(inst[2])))
 310
 311         args = ''
 312         first = True
 313         for arg in inst[2]:
 314             if not first:
 315                 args += ', '
 316             args += ("Value* %s" % arg)
 317             first = False
 318
 319         output_lines += [
 320             'Value *%s(%s);' % (inst[0], args)
 321         ]
 322
 323     output_file.write('\n'.join(output_lines) + '\n')
 324
 325 """
 326     Auto-generates macros for LLVM IR
 327 """
 328 def generate_x86_cpp(output_file):
 329     output_lines = gen_file_header(os.path.basename(output_file.name))
 330
 331     output_lines += [
 332         '#include \"builder.h\"',
 333         ''
 334     ]
 335
 336     for inst in intrinsics:
 337         #print("Inst: %s, x86: %s numArgs: %d" % (inst[0], inst[1], len(inst[2])))
 338
 339         args = ''
 340         pass_args = ''
 341         first = True
 342         for arg in inst[2]:
 343             if not first:
 344                 args += ', '
 345                 pass_args += ', '
 346             args += ("Value* %s" % arg)
 347             pass_args += arg
 348             first = False
 349
 350         output_lines += [
 351             '//////////////////////////////////////////////////////////////////////////',
 352             'Value *Builder::%s(%s)' % (inst[0], args),
 353             '{',
 354             '    Function *func = Intrinsic::getDeclaration(JM()->mpCurrentModule, Intrinsic::%s);' % inst[1],
 355             '    return CALL(func, std::initializer_list<Value*>{%s});' % pass_args,
 356             '}',
 357             '',
 358         ]
 359
 360     output_file.write('\n'.join(output_lines) + '\n')
 361
 362 """
 363     Function which is invoked when this script is started from a command line.
 364     Will present and consume a set of arguments which will tell this script how
 365     to behave
 366 """
 367 def main():
 368
 369     # Parse args...
 370     parser = argparse.ArgumentParser()
 371     parser.add_argument("--input", "-i", type=argparse.FileType('r'), help="Path to IRBuilder.h", required=False)
 372     parser.add_argument("--output", "-o", type=argparse.FileType('w'), help="Path to output file", required=True)
 373     parser.add_argument("--gen_h", "-gen_h", help="Generate builder_gen.h", action="store_true", default=False)
 374     parser.add_argument("--gen_cpp", "-gen_cpp", help="Generate builder_gen.cpp", action="store_true", default=False)
 375     parser.add_argument("--gen_x86_h", "-gen_x86_h", help="Generate x86 intrinsics. No input is needed.", action="store_true", default=False)
 376     parser.add_argument("--gen_x86_cpp", "-gen_x86_cpp", help="Generate x86 intrinsics. No input is needed.", action="store_true", default=False)
 377     args = parser.parse_args()
 378
 379     if args.input:
 380         functions = parse_ir_builder(args.input)
 381
 382         if args.gen_h:
 383             generate_gen_h(functions, args.output)
 384
 385         if args.gen_cpp:
 386             generate_gen_cpp(functions, args.output)
 387     else:
 388         if args.gen_x86_h:
 389             generate_x86_h(args.output)
 390
 391         if args.gen_x86_cpp:
 392             generate_x86_cpp(args.output)
 393
 394         if args.gen_h:
 395             print("Need to specify --input for --gen_h!")
 396
 397         if args.gen_cpp:
 398             print("Need to specify --input for --gen_cpp!")
 399
 400 if __name__ == '__main__':
 401     main()
 402 # END OF FILE