mirror of
https://github.com/KhronosGroup/SPIRV-Tools
synced 2025-01-09 00:00:15 +00:00
9382035a22
Requires use of SPIRV-Headers that has support for SPV_KHR_shader_ballot. Adds assembler, disassembler, binary parser support. Adds general support for allowing an operand to be only enabled by a set of extensions. TODO: Validator support for extension checking.
428 lines
16 KiB
Python
Executable File
428 lines
16 KiB
Python
Executable File
#!/usr/bin/env python
|
|
# Copyright (c) 2016 Google Inc.
|
|
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
"""Generates various info tables from SPIR-V JSON grammar."""
|
|
|
|
from __future__ import print_function
|
|
|
|
import errno
|
|
import functools
|
|
import json
|
|
import os.path
|
|
import re
|
|
|
|
# Prefix for all C variables generated by this script.
|
|
PYGEN_VARIABLE_PREFIX = 'pygen_variable'
|
|
|
|
def make_path_to_file(f):
|
|
"""Makes all ancestor directories to the given file, if they
|
|
don't yet exist.
|
|
|
|
Arguments:
|
|
f: The file whose ancestor directories are to be created.
|
|
"""
|
|
dir = os.path.dirname(os.path.abspath(f))
|
|
try:
|
|
os.makedirs(dir)
|
|
except OSError as e:
|
|
if e.errno == errno.EEXIST and os.path.isdir(dir):
|
|
pass
|
|
else:
|
|
raise
|
|
|
|
def compose_capability_list(caps):
|
|
"""Returns a string containing a braced list of capabilities as enums.
|
|
|
|
Arguments:
|
|
- caps: a sequence of capability names
|
|
|
|
Returns:
|
|
a string containing the braced list of SpvCapability* enums named by caps.
|
|
"""
|
|
return "{" + ", ".join(['SpvCapability{}'.format(c) for c in caps]) + "}"
|
|
|
|
|
|
def compose_extension_list(exts):
|
|
"""Returns a string containing a braced list of extensions as enums.
|
|
|
|
Arguments:
|
|
- exts: a sequence of extension names
|
|
|
|
Returns:
|
|
a string containing the braced list of SpvCapability* enums named by caps.
|
|
"""
|
|
return "{" + ", ".join(['libspirv::Extension::k{}'.format(e) for e in exts]) + "}"
|
|
|
|
|
|
def convert_operand_kind(operand_tuple):
|
|
"""Returns the corresponding operand type used in spirv-tools for
|
|
the given operand kind and quantifier used in the JSON grammar.
|
|
|
|
Arguments:
|
|
- operand_tuple: a tuple of two elements:
|
|
- operand kind: used in the JSON grammar
|
|
- quantifier: '', '?', or '*'
|
|
|
|
Returns:
|
|
a string of the enumerant name in spv_operand_type_t
|
|
"""
|
|
kind, quantifier = operand_tuple
|
|
# The following cases are where we differ between the JSON grammar and
|
|
# spirv-tools.
|
|
if kind == 'IdResultType':
|
|
kind = 'TypeId'
|
|
elif kind == 'IdResult':
|
|
kind = 'ResultId'
|
|
elif kind == 'IdMemorySemantics' or kind == 'MemorySemantics':
|
|
kind = 'MemorySemanticsId'
|
|
elif kind == 'IdScope' or kind == 'Scope':
|
|
kind = 'ScopeId'
|
|
elif kind == 'IdRef':
|
|
kind = 'Id'
|
|
|
|
elif kind == 'ImageOperands':
|
|
kind = 'Image'
|
|
elif kind == 'Dim':
|
|
kind = 'Dimensionality'
|
|
elif kind == 'ImageFormat':
|
|
kind = 'SamplerImageFormat'
|
|
elif kind == 'KernelEnqueueFlags':
|
|
kind = 'KernelEnqFlags'
|
|
|
|
elif kind == 'LiteralExtInstInteger':
|
|
kind = 'ExtensionInstructionNumber'
|
|
elif kind == 'LiteralSpecConstantOpInteger':
|
|
kind = 'SpecConstantOpNumber'
|
|
elif kind == 'LiteralContextDependentNumber':
|
|
kind = 'TypedLiteralNumber'
|
|
|
|
elif kind == 'PairLiteralIntegerIdRef':
|
|
kind = 'LiteralIntegerId'
|
|
elif kind == 'PairIdRefLiteralInteger':
|
|
kind = 'IdLiteralInteger'
|
|
elif kind == 'PairIdRefIdRef': # Used by OpPhi in the grammar
|
|
kind = 'Id'
|
|
|
|
if kind == 'FPRoundingMode':
|
|
kind = 'FpRoundingMode'
|
|
elif kind == 'FPFastMathMode':
|
|
kind = 'FpFastMathMode'
|
|
|
|
if quantifier == '?':
|
|
kind = 'Optional{}'.format(kind)
|
|
elif quantifier == '*':
|
|
kind = 'Variable{}'.format(kind)
|
|
|
|
return 'SPV_OPERAND_TYPE_{}'.format(
|
|
re.sub(r'([a-z])([A-Z])', r'\1_\2', kind).upper())
|
|
|
|
|
|
class InstInitializer(object):
|
|
"""Instances holds a SPIR-V instruction suitable for printing as
|
|
the initializer for spv_opcode_desc_t."""
|
|
|
|
def __init__(self, opname, caps, operands):
|
|
"""Initialization.
|
|
|
|
Arguments:
|
|
- opname: opcode name (with the 'Op' prefix)
|
|
- caps: a sequence of capability names required by this opcode
|
|
- operands: a sequence of (operand-kind, operand-quantifier) tuples
|
|
"""
|
|
assert opname.startswith('Op')
|
|
self.opname = opname[2:] # Remove the "Op" prefix.
|
|
self.caps_mask = compose_capability_list(caps)
|
|
self.operands = [convert_operand_kind(o) for o in operands]
|
|
|
|
self.fix_syntax()
|
|
|
|
operands = [o[0] for o in operands]
|
|
self.ref_type_id = 'IdResultType' in operands
|
|
self.def_result_id = 'IdResult' in operands
|
|
|
|
|
|
def fix_syntax(self):
|
|
"""Fix an instruction's syntax, adjusting for differences between
|
|
the officially released grammar and how SPIRV-Tools uses the grammar.
|
|
|
|
Fixes:
|
|
- ExtInst should not end with SPV_OPERAND_VARIABLE_ID.
|
|
https://github.com/KhronosGroup/SPIRV-Tools/issues/233
|
|
"""
|
|
if (self.opname == 'ExtInst'
|
|
and self.operands[-1] == 'SPV_OPERAND_TYPE_VARIABLE_ID'):
|
|
self.operands.pop()
|
|
|
|
|
|
def __str__(self):
|
|
template = ['{{"{opname}"', 'SpvOp{opname}', '{caps_mask}',
|
|
'{num_operands}', '{{{operands}}}',
|
|
'{def_result_id}', '{ref_type_id}}}']
|
|
return ', '.join(template).format(
|
|
opname=self.opname,
|
|
caps_mask=self.caps_mask,
|
|
num_operands=len(self.operands),
|
|
operands=', '.join(self.operands),
|
|
def_result_id=(1 if self.def_result_id else 0),
|
|
ref_type_id=(1 if self.ref_type_id else 0))
|
|
|
|
|
|
class ExtInstInitializer(object):
|
|
"""Instances holds a SPIR-V extended instruction suitable for printing as
|
|
the initializer for spv_ext_inst_desc_t."""
|
|
|
|
def __init__(self, opname, opcode, caps, operands):
|
|
"""Initialization.
|
|
|
|
Arguments:
|
|
- opname: opcode name
|
|
- opcode: enumerant value for this opcode
|
|
- caps: a sequence of capability names required by this opcode
|
|
- operands: a sequence of (operand-kind, operand-quantifier) tuples
|
|
"""
|
|
self.opname = opname
|
|
self.opcode = opcode
|
|
self.caps_mask = compose_capability_list(caps)
|
|
self.operands = [convert_operand_kind(o) for o in operands]
|
|
self.operands.append('SPV_OPERAND_TYPE_NONE')
|
|
|
|
def __str__(self):
|
|
template = ['{{"{opname}"', '{opcode}', '{caps_mask}',
|
|
'{{{operands}}}}}']
|
|
return ', '.join(template).format(
|
|
opname=self.opname,
|
|
opcode=self.opcode,
|
|
caps_mask=self.caps_mask,
|
|
operands=', '.join(self.operands))
|
|
|
|
|
|
def generate_instruction(inst, is_ext_inst):
|
|
"""Returns the C initializer for the given SPIR-V instruction.
|
|
|
|
Arguments:
|
|
- inst: a dict containing information about a SPIR-V instruction
|
|
- is_ext_inst: a bool indicating whether |inst| is an extended
|
|
instruction.
|
|
|
|
Returns:
|
|
a string containing the C initializer for spv_opcode_desc_t or
|
|
spv_ext_inst_desc_t
|
|
"""
|
|
opname = inst.get('opname')
|
|
opcode = inst.get('opcode')
|
|
caps = inst.get('capabilities', [])
|
|
operands = inst.get('operands', {})
|
|
operands = [(o['kind'], o.get('quantifier', '')) for o in operands]
|
|
|
|
assert opname is not None
|
|
|
|
if is_ext_inst:
|
|
return str(ExtInstInitializer(opname, opcode, caps, operands))
|
|
else:
|
|
return str(InstInitializer(opname, caps, operands))
|
|
|
|
|
|
def generate_instruction_table(inst_table, is_ext_inst):
|
|
"""Returns the info table containing all SPIR-V instructions.
|
|
|
|
Arguments:
|
|
- inst_table: a dict containing all SPIR-V instructions.
|
|
- is_ext_inst: a bool indicating whether |inst_table| is for
|
|
an extended instruction set.
|
|
"""
|
|
return ',\n'.join([generate_instruction(inst, is_ext_inst)
|
|
for inst in inst_table])
|
|
|
|
|
|
class EnumerantInitializer(object):
|
|
"""Prints an enumerant as the initializer for spv_operand_desc_t."""
|
|
|
|
def __init__(self, enumerant, value, caps, exts, parameters):
|
|
"""Initialization.
|
|
|
|
Arguments:
|
|
- enumerant: enumerant name
|
|
- value: enumerant value
|
|
- caps: a sequence of capability names required by this enumerant
|
|
- exts: a sequence of names of extensions enabling this enumerant
|
|
- parameters: a sequence of (operand-kind, operand-quantifier) tuples
|
|
"""
|
|
self.enumerant = enumerant
|
|
self.value = value
|
|
self.caps = compose_capability_list(caps)
|
|
self.exts = compose_extension_list(exts)
|
|
self.parameters = [convert_operand_kind(p) for p in parameters]
|
|
|
|
def __str__(self):
|
|
template = ['{{"{enumerant}"', '{value}',
|
|
'{caps}', '{exts}', '{{{parameters}}}}}']
|
|
return ', '.join(template).format(
|
|
enumerant=self.enumerant,
|
|
value=self.value,
|
|
caps=self.caps,
|
|
exts=self.exts,
|
|
parameters=', '.join(self.parameters))
|
|
|
|
|
|
def generate_enum_operand_kind_entry(entry):
|
|
"""Returns the C initializer for the given operand enum entry.
|
|
|
|
Arguments:
|
|
- entry: a dict containing information about an enum entry
|
|
|
|
Returns:
|
|
a string containing the C initializer for spv_operand_desc_t
|
|
"""
|
|
enumerant = entry.get('enumerant')
|
|
value = entry.get('value')
|
|
caps = entry.get('capabilities', [])
|
|
exts = entry.get('exts', [])
|
|
params = entry.get('parameters', [])
|
|
params = [p.get('kind') for p in params]
|
|
params = zip(params, [''] * len(params))
|
|
|
|
assert enumerant is not None
|
|
assert value is not None
|
|
|
|
return str(EnumerantInitializer(enumerant, value, caps, exts, params))
|
|
|
|
|
|
def generate_enum_operand_kind(enum):
|
|
"""Returns the C definition for the given operand kind."""
|
|
kind = enum.get('kind')
|
|
assert kind is not None
|
|
|
|
name = '{}_{}Entries'.format(PYGEN_VARIABLE_PREFIX, kind)
|
|
entries = [' {}'.format(generate_enum_operand_kind_entry(e))
|
|
for e in enum.get('enumerants', [])]
|
|
|
|
template = ['static const spv_operand_desc_t {name}[] = {{',
|
|
'{entries}', '}};']
|
|
entries = '\n'.join(template).format(
|
|
name=name,
|
|
entries=',\n'.join(entries))
|
|
|
|
return kind, name, entries
|
|
|
|
|
|
def generate_operand_kind_table(enums):
|
|
"""Returns the info table containing all SPIR-V operand kinds."""
|
|
# We only need to output info tables for those operand kinds that are enums.
|
|
enums = [generate_enum_operand_kind(e)
|
|
for e in enums
|
|
if e.get('category') in ['ValueEnum', 'BitEnum']]
|
|
# We have three operand kinds that requires their optional counterpart to
|
|
# exist in the operand info table.
|
|
three_optional_enums = ['ImageOperands', 'AccessQualifier', 'MemoryAccess']
|
|
three_optional_enums = [e for e in enums if e[0] in three_optional_enums]
|
|
enums.extend(three_optional_enums)
|
|
|
|
enum_kinds, enum_names, enum_entries = zip(*enums)
|
|
# Mark the last three as optional ones.
|
|
enum_quantifiers = [''] * (len(enums) - 3) + ['?'] * 3
|
|
# And we don't want redefinition of them.
|
|
enum_entries = enum_entries[:-3]
|
|
enum_kinds = [convert_operand_kind(e)
|
|
for e in zip(enum_kinds, enum_quantifiers)]
|
|
table_entries = zip(enum_kinds, enum_names, enum_names)
|
|
table_entries = [' {{{}, ARRAY_SIZE({}), {}}}'.format(*e)
|
|
for e in table_entries]
|
|
|
|
template = [
|
|
'static const spv_operand_desc_group_t {p}_OperandInfoTable[] = {{',
|
|
'{enums}', '}};']
|
|
table = '\n'.join(template).format(
|
|
p=PYGEN_VARIABLE_PREFIX, enums=',\n'.join(table_entries))
|
|
|
|
return '\n\n'.join(enum_entries + (table,))
|
|
|
|
|
|
def main():
|
|
import argparse
|
|
parser = argparse.ArgumentParser(description='Generate SPIR-V info tables')
|
|
parser.add_argument('--spirv-core-grammar', metavar='<path>',
|
|
type=str, required=True,
|
|
help='input JSON grammar file for core SPIR-V '
|
|
'instructions')
|
|
parser.add_argument('--extinst-glsl-grammar', metavar='<path>',
|
|
type=str, required=False, default=None,
|
|
help='input JSON grammar file for GLSL extended '
|
|
'instruction set')
|
|
parser.add_argument('--extinst-opencl-grammar', metavar='<path>',
|
|
type=str, required=False, default=None,
|
|
help='input JSON grammar file for OpenGL extended '
|
|
'instruction set')
|
|
parser.add_argument('--core-insts-output', metavar='<path>',
|
|
type=str, required=False, default=None,
|
|
help='output file for core SPIR-V instructions')
|
|
parser.add_argument('--glsl-insts-output', metavar='<path>',
|
|
type=str, required=False, default=None,
|
|
help='output file for GLSL extended instruction set')
|
|
parser.add_argument('--opencl-insts-output', metavar='<path>',
|
|
type=str, required=False, default=None,
|
|
help='output file for OpenCL extended instruction set')
|
|
parser.add_argument('--operand-kinds-output', metavar='<path>',
|
|
type=str, required=False, default=None,
|
|
help='output file for operand kinds')
|
|
args = parser.parse_args()
|
|
|
|
if (args.core_insts_output is None) != \
|
|
(args.operand_kinds_output is None):
|
|
print('error: --core-insts-output and --operand_kinds_output '
|
|
'should be specified together.')
|
|
exit(1)
|
|
if (args.glsl_insts_output is None) != \
|
|
(args.extinst_glsl_grammar is None):
|
|
print('error: --glsl-insts-output and --extinst-glsl-grammar '
|
|
'should be specified together.')
|
|
exit(1)
|
|
if (args.opencl_insts_output is None) != \
|
|
(args.extinst_opencl_grammar is None):
|
|
print('error: --opencl-insts-output and --extinst-opencl-grammar '
|
|
'should be specified together.')
|
|
exit(1)
|
|
if all([args.core_insts_output is None,
|
|
args.glsl_insts_output is None,
|
|
args.opencl_insts_output is None]):
|
|
print('error: at least one output should be specified.')
|
|
exit(1)
|
|
|
|
with open(args.spirv_core_grammar) as json_file:
|
|
grammar = json.loads(json_file.read())
|
|
if args.core_insts_output is not None:
|
|
make_path_to_file(args.core_insts_output)
|
|
make_path_to_file(args.operand_kinds_output)
|
|
print(generate_instruction_table(grammar['instructions'], False),
|
|
file=open(args.core_insts_output, 'w'))
|
|
print(generate_operand_kind_table(grammar['operand_kinds']),
|
|
file=open(args.operand_kinds_output, 'w'))
|
|
|
|
if args.extinst_glsl_grammar is not None:
|
|
with open(args.extinst_glsl_grammar) as json_file:
|
|
grammar = json.loads(json_file.read())
|
|
make_path_to_file(args.glsl_insts_output)
|
|
print(generate_instruction_table(grammar['instructions'], True),
|
|
file=open(args.glsl_insts_output, 'w'))
|
|
|
|
if args.extinst_opencl_grammar is not None:
|
|
with open(args.extinst_opencl_grammar) as json_file:
|
|
grammar = json.loads(json_file.read())
|
|
make_path_to_file(args.opencl_insts_output)
|
|
print(generate_instruction_table(grammar['instructions'], True),
|
|
file=open(args.opencl_insts_output, 'w'))
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|