Delete utils/generate_grammar_tables.py (#6138)
Bug: crbug.com/266223071
diff --git a/BUILD.bazel b/BUILD.bazel
index 1986176..5724279 100644
--- a/BUILD.bazel
+++ b/BUILD.bazel
@@ -26,17 +26,8 @@
])
py_binary(
- # Generates tables for extensions and extended instruction sets.
- # TODO(crbug.com/266223071) Replace this with ggt.py
- name = "generate_grammar_tables",
- srcs = ["utils/generate_grammar_tables.py"],
-)
-
-py_binary(
# The script that generates compressed grammar tables for
# instructions and operands.
- # TODO(crbug.com/266223071) Eventually this will fully replace
- # utils/generate_grammar_tables.py.
name = "ggt",
main = "utils/ggt.py", # The file found by $(location :ggt)
srcs = [
diff --git a/source/CMakeLists.txt b/source/CMakeLists.txt
index 2cacf4e..1b37ab2 100644
--- a/source/CMakeLists.txt
+++ b/source/CMakeLists.txt
@@ -12,7 +12,6 @@
# See the License for the specific language governing permissions and
# limitations under the License.
-set(GRAMMAR_PROCESSING_SCRIPT "${spirv-tools_SOURCE_DIR}/utils/generate_grammar_tables.py")
set(VIMSYNTAX_PROCESSING_SCRIPT "${spirv-tools_SOURCE_DIR}/utils/vim/generate_syntax.py")
set(XML_REGISTRY_PROCESSING_SCRIPT "${spirv-tools_SOURCE_DIR}/utils/generate_registry_tables.py")
set(LANG_HEADER_PROCESSING_SCRIPT "${spirv-tools_SOURCE_DIR}/utils/generate_language_headers.py")
diff --git a/utils/generate_grammar_tables.py b/utils/generate_grammar_tables.py
deleted file mode 100755
index 48bdeee..0000000
--- a/utils/generate_grammar_tables.py
+++ /dev/null
@@ -1,873 +0,0 @@
-#!/usr/bin/env python3
-# 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."""
-
-# NOTE: This is being replaced by ggt.py
-
-import errno
-import json
-import os.path
-import re
-
-# Prefix for all C variables generated by this script.
-PYGEN_VARIABLE_PREFIX = 'pygen_variable'
-
-# Extensions to recognize, but which don't necessarily come from the SPIR-V
-# core or KHR grammar files. Get this list from the SPIR-V registry web page.
-# NOTE: Only put things on this list if it is not in those grammar files.
-EXTENSIONS_FROM_SPIRV_REGISTRY_AND_NOT_FROM_GRAMMARS = """
-SPV_AMD_gcn_shader
-SPV_AMD_gpu_shader_half_float
-SPV_AMD_gpu_shader_int16
-SPV_AMD_shader_trinary_minmax
-SPV_KHR_non_semantic_info
-SPV_EXT_relaxed_printf_string_address_space
-"""
-
-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 convert_min_required_version(version):
- """Converts the minimal required SPIR-V version encoded in the grammar to
- the symbol in SPIRV-Tools."""
- if version is None:
- return 'SPV_SPIRV_VERSION_WORD(1, 0)'
- if version == 'None':
- return '0xffffffffu'
- return 'SPV_SPIRV_VERSION_WORD({})'.format(version.replace('.', ','))
-
-
-def convert_max_required_version(version):
- """Converts the maximum required SPIR-V version encoded in the grammar to
- the symbol in SPIRV-Tools."""
- if version is None:
- return '0xffffffffu'
- return 'SPV_SPIRV_VERSION_WORD({})'.format(version.replace('.', ','))
-
-def get_alias_array_name(aliases):
- """Returns the name of the array containing all the given aliases.
-
- Arguments:
- - aliases: a sequence of alias names
- """
- if not aliases:
- return 'nullptr';
- return '{}_aliases_{}'.format(PYGEN_VARIABLE_PREFIX, ''.join(aliases))
-
-def compose_alias_list(aliases):
- """Returns a string containing a braced list of aliases.
-
- Arguments:
- - aliases: a sequence of alias names
-
- Returns:
- a string containing the braced list of char* named by aliases.
- """
- return '{' + ', '.join([('"{}"').format(a) for a in aliases]) + '}'
-
-def generate_aliases_arrays(aliases):
- """Returns the arrays of aliases
-
- Arguments:
- - aliases: a sequence of sequence of alias names
- """
- aliases = sorted(set([tuple(a) for a in aliases if a]))
- arrays = [
- 'static const char* {}[] = {};'.format(
- get_alias_array_name(a), compose_alias_list(a))
- for a in aliases]
- return '\n'.join(arrays)
-
-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* or spv::Capability:: enums named by caps.
- """
- base_string = 'spv::Capability::'
-
- return '{' + ', '.join([(base_string + '{}').format(c) for c in caps]) + '}'
-
-
-def get_capability_array_name(caps):
- """Returns the name of the array containing all the given capabilities.
-
- Args:
- - caps: a sequence of capability names
- """
- if not caps:
- return 'nullptr'
- return '{}_caps_{}'.format(PYGEN_VARIABLE_PREFIX, ''.join(caps))
-
-
-def generate_capability_arrays(caps):
- """Returns the arrays of capabilities.
-
- Arguments:
- - caps: a sequence of sequence of capability names
- """
- caps = sorted(set([tuple(c) for c in caps if c]))
- cap_str = 'spv::Capability'
- arrays = [
- 'static const ' + cap_str + ' {}[] = {};'.format(
- get_capability_array_name(c), compose_capability_list(c))
- for c in caps]
- return '\n'.join(arrays)
-
-
-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 extensions named by exts.
- """
- return '{' + ', '.join(
- ['spvtools::Extension::k{}'.format(e) for e in exts]) + '}'
-
-
-def get_extension_array_name(extensions):
- """Returns the name of the array containing all the given extensions.
-
- Args:
- - extensions: a sequence of extension names
- """
- if not extensions:
- return 'nullptr'
- else:
- return '{}_exts_{}'.format(
- PYGEN_VARIABLE_PREFIX, ''.join(extensions))
-
-
-def generate_extension_arrays(extensions):
- """Returns the arrays of extensions.
-
- Arguments:
- - caps: a sequence of sequence of extension names
- """
- extensions = sorted(set([tuple(e) for e in extensions if e]))
- arrays = [
- 'static const spvtools::Extension {}[] = {};'.format(
- get_extension_array_name(e), compose_extension_list(e))
- for e in extensions]
- return '\n'.join(arrays)
-
-
-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, aliases, caps, exts, operands, version, lastVersion):
- """Initialization.
-
- Arguments:
- - opname: opcode name (with the 'Op' prefix)
- - aliases: a sequence of aliases for the name of this opcode
- - caps: a sequence of capability names required by this opcode
- - exts: a sequence of names of extensions enabling this enumerant
- - operands: a sequence of (operand-kind, operand-quantifier) tuples
- - version: minimal SPIR-V version required for this opcode
- - lastVersion: last version of SPIR-V that includes this opcode
- """
-
- assert opname.startswith('Op')
- self.opname = opname[2:] # Remove the "Op" prefix.
- self.num_aliases = len(aliases);
- self.aliases_mask = get_alias_array_name(aliases)
- self.num_caps = len(caps)
- self.caps_mask = get_capability_array_name(caps)
- self.num_exts = len(exts)
- self.exts = get_extension_array_name(exts)
- 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
-
- self.version = convert_min_required_version(version)
- self.lastVersion = convert_max_required_version(lastVersion)
-
- 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):
- base_str = 'spv::Op::Op'
- template = ['{{"{opname}"', base_str + '{opname}',
- '{num_aliases}', '{aliases_mask}',
- '{num_caps}', '{caps_mask}',
- '{num_operands}', '{{{operands}}}',
- '{def_result_id}', '{ref_type_id}',
- '{num_exts}', '{exts}',
- '{min_version}', '{max_version}}}']
- return ', '.join(template).format(
- opname=self.opname,
- num_aliases=self.num_aliases,
- aliases_mask=self.aliases_mask,
- num_caps=self.num_caps,
- 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),
- num_exts=self.num_exts,
- exts=self.exts,
- min_version=self.version,
- max_version=self.lastVersion)
-
-
-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.num_caps = len(caps)
- self.caps_mask = get_capability_array_name(caps)
- self.operands = [convert_operand_kind(o) for o in operands]
- self.operands.append('SPV_OPERAND_TYPE_NONE')
-
- def __str__(self):
- template = ['{{"{opname}"', '{opcode}', '{num_caps}', '{caps_mask}',
- '{{{operands}}}}}']
- return ', '.join(template).format(
- opname=self.opname,
- opcode=self.opcode,
- num_caps=self.num_caps,
- 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')
- aliases = inst.get('aliases', [])
- caps = inst.get('capabilities', [])
- exts = inst.get('extensions', [])
- operands = inst.get('operands', {})
- operands = [(o['kind'], o.get('quantifier', '')) for o in operands]
- min_version = inst.get('version', None)
- max_version = inst.get('lastVersion', None)
-
- assert opname is not None
-
- if is_ext_inst:
- return str(ExtInstInitializer(opname, opcode, caps, operands))
- else:
- return str(InstInitializer(opname, aliases, caps, exts, operands, min_version, max_version))
-
-
-def generate_instruction_table(inst_table):
- """Returns the info table containing all SPIR-V instructions, sorted by
- opcode, and prefixed by capability arrays.
-
- Note:
- - the built-in sorted() function is guaranteed to be stable.
- https://docs.python.org/3/library/functions.html#sorted
-
- Arguments:
- - inst_table: a list containing all SPIR-V instructions.
- """
- inst_table = sorted(inst_table, key=lambda k: (k['opcode'], k['opname']))
-
- aliases_arrays = generate_aliases_arrays(
- [inst.get('aliases', []) for inst in inst_table])
- caps_arrays = generate_capability_arrays(
- [inst.get('capabilities', []) for inst in inst_table])
- exts_arrays = generate_extension_arrays(
- [inst.get('extensions', []) for inst in inst_table])
-
- insts = [generate_instruction(inst, False) for inst in inst_table]
- insts = ['static const spv_opcode_desc_t kOpcodeTableEntries[] = {{\n'
- ' {}\n}};'.format(',\n '.join(insts))]
-
- return '{}\n\n{}\n\n{}\n\n{}'.format(aliases_arrays, caps_arrays, exts_arrays, '\n'.join(insts))
-
-
-def generate_extended_instruction_table(json_grammar, set_name, operand_kind_prefix=""):
- """Returns the info table containing all SPIR-V extended instructions,
- sorted by opcode, and prefixed by capability arrays.
-
- Arguments:
- - inst_table: a list containing all SPIR-V instructions.
- - set_name: the name of the extended instruction set.
- - operand_kind_prefix: the prefix, if any, to add to the front
- of operand kind names.
- """
- if operand_kind_prefix:
- prefix_operand_kind_names(operand_kind_prefix, json_grammar)
-
- inst_table = json_grammar["instructions"]
- set_name = set_name.replace(".", "_")
-
- inst_table = sorted(inst_table, key=lambda k: k['opcode'])
- caps = [inst.get('capabilities', []) for inst in inst_table]
- caps_arrays = generate_capability_arrays(caps)
- insts = [generate_instruction(inst, True) for inst in inst_table]
- insts = ['static const spv_ext_inst_desc_t {}_entries[] = {{\n'
- ' {}\n}};'.format(set_name, ',\n '.join(insts))]
-
- return '{}\n\n{}'.format(caps_arrays, '\n'.join(insts))
-
-
-class EnumerantInitializer(object):
- """Prints an enumerant as the initializer for spv_operand_desc_t."""
-
- def __init__(self, enumerant, value, aliases, caps, exts, parameters, version, lastVersion):
- """Initialization.
-
- Arguments:
- - enumerant: enumerant name
- - value: enumerant value
- - aliases: a sequence of aliased capability names
- - 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
- - version: minimal SPIR-V version required for this opcode
- - lastVersion: last SPIR-V version this opode appears
- """
- self.enumerant = enumerant
- self.value = value
- self.num_aliases = len(aliases)
- self.aliases = get_alias_array_name(aliases)
- self.num_caps = len(caps)
- self.caps = get_capability_array_name(caps)
- self.num_exts = len(exts)
- self.exts = get_extension_array_name(exts)
- self.parameters = [convert_operand_kind(p) for p in parameters]
- self.version = convert_min_required_version(version)
- self.lastVersion = convert_max_required_version(lastVersion)
-
- def __str__(self):
- template = ['{{"{enumerant}"', '{value}',
- '{num_aliases}', '{aliases}',
- '{num_caps}', '{caps}',
- '{num_exts}', '{exts}',
- '{{{parameters}}}', '{min_version}',
- '{max_version}}}']
- return ', '.join(template).format(
- enumerant=self.enumerant,
- value=self.value,
- num_aliases=self.num_aliases,
- aliases=self.aliases,
- num_caps=self.num_caps,
- caps=self.caps,
- num_exts=self.num_exts,
- exts=self.exts,
- parameters=', '.join(self.parameters),
- min_version=self.version,
- max_version=self.lastVersion)
-
-
-def generate_enum_operand_kind_entry(entry, extension_map):
- """Returns the C initializer for the given operand enum entry.
-
- Arguments:
- - entry: a dict containing information about an enum entry
- - extension_map: a dict mapping enum value to list of extensions
-
- Returns:
- a string containing the C initializer for spv_operand_desc_t
- """
- enumerant = entry.get('enumerant')
- value = entry.get('value')
- aliases = entry.get('aliases', [])
- caps = entry.get('capabilities', [])
- if value in extension_map:
- exts = extension_map[value]
- else:
- exts = []
- params = entry.get('parameters', [])
- params = [p.get('kind') for p in params]
- params = zip(params, [''] * len(params))
- version = entry.get('version', None)
- max_version = entry.get('lastVersion', None)
-
- assert enumerant is not None
- assert value is not None
-
- return str(EnumerantInitializer(
- enumerant, value, aliases, caps, exts, params, version, max_version))
-
-
-def generate_enum_operand_kind(enum, synthetic_exts_list):
- """Returns the C definition for the given operand kind.
- It's a static const named array of spv_operand_desc_t.
-
- Also appends to |synthetic_exts_list| a list of extension lists
- used.
- """
- kind = enum.get('kind')
- assert kind is not None
-
- # Sort all enumerants according to their values, but otherwise
- # preserve their order so the first name listed in the grammar
- # as the preferred name for disassembly.
- if enum.get('category') == 'ValueEnum':
- def functor(k): return (k['value'])
- else:
- def functor(k): return (int(k['value'], 16))
- entries = sorted(enum.get('enumerants', []), key=functor)
-
- # SubgroupEqMask and SubgroupEqMaskKHR are the same number with
- # same semantics, but one has no extension list while the other
- # does. Both should have the extension list.
- # So create a mapping from enum value to the union of the extensions
- # across all those grammar entries. Preserve order.
- extension_map = {}
- for e in entries:
- value = e.get('value')
- extension_map[value] = []
- for e in entries:
- value = e.get('value')
- exts = e.get('extensions', [])
- for ext in exts:
- if ext not in extension_map[value]:
- extension_map[value].append(ext)
- synthetic_exts_list.extend(extension_map.values())
-
- name = '{}_{}Entries'.format(PYGEN_VARIABLE_PREFIX, kind)
- entries = [' {}'.format(generate_enum_operand_kind_entry(e, extension_map))
- for e in entries]
- if len(entries) == 0:
- # Insert a dummy entry. Otherwise the array is empty and compilation
- # will fail in MSVC.
- entries = [' {"place holder", 0, 0, nullptr, 0, nullptr, 0, nullptr, {}, SPV_SPIRV_VERSION_WORD(999,0), 0}']
-
- 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 = [e for e in enums if e.get('category') in ['ValueEnum', 'BitEnum']]
-
- aliases = [entry.get('aliases', [])
- for enum in enums
- for entry in enum.get('enumerants', [])]
- aliases_arrays = generate_aliases_arrays(aliases)
-
- caps = [entry.get('capabilities', [])
- for enum in enums
- for entry in enum.get('enumerants', [])]
- caps_arrays = generate_capability_arrays(caps)
-
- exts = [entry.get('extensions', [])
- for enum in enums
- for entry in enum.get('enumerants', [])]
- enums = [generate_enum_operand_kind(e, exts) for e in enums]
- exts_arrays = generate_extension_arrays(exts)
-
- # We have a few operand kinds that require their optional counterpart to
- # exist in the operand info table.
- optional_enums = ['ImageOperands', 'AccessQualifier', 'MemoryAccess', 'PackedVectorFormat', 'CooperativeMatrixOperands', 'MatrixMultiplyAccumulateOperands', 'RawAccessChainOperands', 'FPEncoding']
- optional_enums = [e for e in enums if e[0] in optional_enums]
- enums.extend(optional_enums)
-
- enum_kinds, enum_names, enum_entries = zip(*enums)
- # Mark the last few as optional ones.
- enum_quantifiers = [''] * (len(enums) - len(optional_enums)) + ['?'] * len(optional_enums)
- # And we don't want redefinition of them.
- enum_entries = enum_entries[:-len(optional_enums)]
- 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((aliases_arrays,) + (caps_arrays,) + (exts_arrays,) + enum_entries + (table,))
-
-
-def get_extension_list(instructions, operand_kinds):
- """Returns extensions as an alphabetically sorted list of strings."""
-
- things_with_an_extensions_field = [item for item in instructions]
-
- enumerants = sum([item.get('enumerants', [])
- for item in operand_kinds], [])
-
- things_with_an_extensions_field.extend(enumerants)
-
- extensions = sum([item.get('extensions', [])
- for item in things_with_an_extensions_field
- if item.get('extensions')], [])
-
- for item in EXTENSIONS_FROM_SPIRV_REGISTRY_AND_NOT_FROM_GRAMMARS.split():
- # If it's already listed in a grammar, then don't put it in the
- # special exceptions list.
- assert item not in extensions, 'Extension %s is already in a grammar file' % item
-
- extensions.extend(
- EXTENSIONS_FROM_SPIRV_REGISTRY_AND_NOT_FROM_GRAMMARS.split())
-
- # Validator would ignore type declaration unique check. Should only be used
- # for legacy autogenerated test files containing multiple instances of the
- # same type declaration, if fixing the test by other methods is too
- # difficult. Shouldn't be used for any other reasons.
- extensions.append('SPV_VALIDATOR_ignore_type_decl_unique')
-
- return sorted(set(extensions))
-
-
-def get_capabilities(operand_kinds):
- """Returns capabilities as a list of JSON objects, in order of
- appearance."""
- enumerants = sum([item.get('enumerants', []) for item in operand_kinds
- if item.get('kind') in ['Capability']], [])
- return enumerants
-
-
-def generate_extension_enum(extensions):
- """Returns enumeration containing extensions declared in the grammar."""
- return ',\n'.join(['k' + extension for extension in extensions])
-
-
-def generate_extension_to_string_mapping(extensions):
- """Returns mapping function from extensions to corresponding strings."""
- function = 'const char* ExtensionToString(Extension extension) {\n'
- function += ' switch (extension) {\n'
- template = ' case Extension::k{extension}:\n' \
- ' return "{extension}";\n'
- function += ''.join([template.format(extension=extension)
- for extension in extensions])
- function += ' }\n\n return "";\n}'
- return function
-
-
-def generate_string_to_extension_mapping(extensions):
- """Returns mapping function from strings to corresponding extensions."""
-
- function = '''
- bool GetExtensionFromString(const char* str, Extension* extension) {{
- static const char* known_ext_strs[] = {{ {strs} }};
- static const Extension known_ext_ids[] = {{ {ids} }};
- const auto b = std::begin(known_ext_strs);
- const auto e = std::end(known_ext_strs);
- const auto found = std::equal_range(
- b, e, str, [](const char* str1, const char* str2) {{
- return std::strcmp(str1, str2) < 0;
- }});
- if (found.first == e || found.first == found.second) return false;
-
- *extension = known_ext_ids[found.first - b];
- return true;
- }}
- '''.format(strs=', '.join(['"{}"'.format(e) for e in extensions]),
- ids=', '.join(['Extension::k{}'.format(e) for e in extensions]))
-
- return function
-
-
-def generate_capability_to_string_mapping(operand_kinds):
- """Returns mapping function from capabilities to corresponding strings.
-
- We take care to avoid emitting duplicate values.
- """
- cap_str = 'spv::Capability'
- cap_join = '::'
-
- function = 'const char* CapabilityToString(' + cap_str + ' capability) {\n'
- function += ' switch (capability) {\n'
- template = ' case ' + cap_str + cap_join + '{capability}:\n' \
- ' return "{capability}";\n'
- emitted = set() # The values of capabilities we already have emitted
- for capability in get_capabilities(operand_kinds):
- value = capability.get('value')
- if value not in emitted:
- emitted.add(value)
- function += template.format(capability=capability.get('enumerant'))
- function += ' case ' + cap_str + cap_join + 'Max:\n' \
- ' assert(0 && "Attempting to convert ' + cap_str + cap_join + 'Max to string");\n' \
- ' return "";\n'
- function += ' }\n\n return "";\n}'
- return function
-
-
-def generate_all_string_enum_mappings(extensions, operand_kinds):
- """Returns all string-to-enum / enum-to-string mapping tables."""
- tables = []
- tables.append(generate_extension_to_string_mapping(extensions))
- tables.append(generate_string_to_extension_mapping(extensions))
- tables.append(generate_capability_to_string_mapping(operand_kinds))
- return '\n\n'.join(tables)
-
-
-def precondition_operand_kinds(operand_kinds):
- """For operand kinds that have the same number, make sure they all have the
- same extension list."""
-
- # Map operand kind and value to list of the union of extensions
- # for same-valued enumerants.
- exts = {}
- for kind_entry in operand_kinds:
- kind = kind_entry.get('kind')
- for enum_entry in kind_entry.get('enumerants', []):
- value = enum_entry.get('value')
- key = kind + '.' + str(value)
- if key in exts:
- exts[key].extend(enum_entry.get('extensions', []))
- else:
- exts[key] = enum_entry.get('extensions', [])
- exts[key] = sorted(set(exts[key]))
-
- # Now make each entry the same list.
- for kind_entry in operand_kinds:
- kind = kind_entry.get('kind')
- for enum_entry in kind_entry.get('enumerants', []):
- value = enum_entry.get('value')
- key = kind + '.' + str(value)
- if len(exts[key]) > 0:
- enum_entry['extensions'] = exts[key]
-
- return operand_kinds
-
-
-def prefix_operand_kind_names(prefix, json_dict):
- """Modifies json_dict, by prefixing all the operand kind names
- with the given prefix. Also modifies their uses in the instructions
- to match.
- """
-
- old_to_new = {}
- for operand_kind in json_dict.get("operand_kinds", []):
- old_name = operand_kind["kind"]
- new_name = prefix + old_name
- operand_kind["kind"] = new_name
- old_to_new[old_name] = new_name
-
- for instruction in json_dict["instructions"]:
- for operand in instruction.get("operands", []):
- replacement = old_to_new.get(operand["kind"])
- if replacement is not None:
- operand["kind"] = replacement
-
-
-def main():
- import argparse
- parser = argparse.ArgumentParser(description='Generate SPIR-V info tables')
-
- parser.add_argument('--spirv-core-grammar', metavar='<path>',
- type=str, required=False,
- help='input JSON grammar file for core SPIR-V '
- 'instructions')
- parser.add_argument('--extinst-debuginfo-grammar', metavar='<path>',
- type=str, required=False, default=None,
- help='input JSON grammar file for DebugInfo extended '
- 'instruction set')
- parser.add_argument('--extinst-cldebuginfo100-grammar', metavar='<path>',
- type=str, required=False, default=None,
- help='input JSON grammar file for OpenCL.DebugInfo.100 '
- 'extended instruction set')
-
- parser.add_argument('--extension-enum-output', metavar='<path>',
- type=str, required=False, default=None,
- help='output file for extension enumeration')
- parser.add_argument('--enum-string-mapping-output', metavar='<path>',
- type=str, required=False, default=None,
- help='output file for enum-string mappings')
- parser.add_argument('--extinst-vendor-grammar', metavar='<path>',
- type=str, required=False, default=None,
- help='input JSON grammar file for vendor extended '
- 'instruction set'),
- parser.add_argument('--vendor-insts-output', metavar='<path>',
- type=str, required=False, default=None,
- help='output file for vendor extended instruction set')
- parser.add_argument('--vendor-operand-kind-prefix', metavar='<string>',
- type=str, required=False, default=None,
- help='prefix for operand kinds (to disambiguate operand type enums)')
- args = parser.parse_args()
-
- # The GN build system needs this because it doesn't handle quoting
- # empty string arguments well.
- if args.vendor_operand_kind_prefix == "...nil...":
- args.vendor_operand_kind_prefix = ""
-
- if (args.vendor_insts_output is None) != \
- (args.extinst_vendor_grammar is None):
- print('error: --vendor-insts-output and '
- '--extinst-vendor-grammar should be specified together.')
- exit(1)
- if all([args.vendor_insts_output is None,
- args.extension_enum_output is None,
- args.enum_string_mapping_output is None]):
- print('error: at least one output should be specified.')
- exit(1)
-
- if args.spirv_core_grammar is not None:
- with open(args.spirv_core_grammar) as json_file:
- core_grammar = json.loads(json_file.read())
- with open(args.extinst_debuginfo_grammar) as debuginfo_json_file:
- debuginfo_grammar = json.loads(debuginfo_json_file.read())
- with open(args.extinst_cldebuginfo100_grammar) as cldebuginfo100_json_file:
- cldebuginfo100_grammar = json.loads(cldebuginfo100_json_file.read())
- prefix_operand_kind_names("CLDEBUG100_", cldebuginfo100_grammar)
- instructions = []
- instructions.extend(core_grammar['instructions'])
- instructions.extend(debuginfo_grammar['instructions'])
- instructions.extend(cldebuginfo100_grammar['instructions'])
- operand_kinds = []
- operand_kinds.extend(core_grammar['operand_kinds'])
- operand_kinds.extend(debuginfo_grammar['operand_kinds'])
- operand_kinds.extend(cldebuginfo100_grammar['operand_kinds'])
- extensions = get_extension_list(instructions, operand_kinds)
- operand_kinds = precondition_operand_kinds(operand_kinds)
- if args.extension_enum_output is not None:
- make_path_to_file(args.extension_enum_output)
- with open(args.extension_enum_output, 'w') as f:
- f.write(generate_extension_enum(extensions))
- if args.enum_string_mapping_output is not None:
- make_path_to_file(args.enum_string_mapping_output)
- with open(args.enum_string_mapping_output, 'w') as f:
- f.write(generate_all_string_enum_mappings(
- extensions, operand_kinds))
-
- if args.extinst_vendor_grammar is not None:
- with open(args.extinst_vendor_grammar) as json_file:
- grammar = json.loads(json_file.read())
- make_path_to_file(args.vendor_insts_output)
- name = args.extinst_vendor_grammar
- start = name.find('extinst.') + len('extinst.')
- name = name[start:-len('.grammar.json')].replace('-', '_')
- with open(args.vendor_insts_output, 'w') as f:
- f.write(generate_extended_instruction_table(
- grammar, name, args.vendor_operand_kind_prefix))
-
-
-if __name__ == '__main__':
- main()
diff --git a/utils/ggt.py b/utils/ggt.py
index c2efc8c..8f2f238 100755
--- a/utils/ggt.py
+++ b/utils/ggt.py
@@ -14,8 +14,6 @@
# limitations under the License.
"""Generates compressed grammar tables from SPIR-V JSON grammar."""
-# Note: This will eventually replace generate_grammar_tables.py
-
import errno
import json
import os.path
