cpython/Tools/cases_generator/generate_cases.py

"""Generate the main interpreter switch.
Reads the instruction definitions from bytecodes.c.
Writes the cases to generated_cases.c.h, which is #included in ceval.c.
"""

import argparse
import contextlib
import itertools
import os
import posixpath
import sys
import textwrap
import typing
from collections.abc import Iterator

import stacking  # Early import to avoid circular import
from _typing_backports import assert_never
from analysis import Analyzer
from formatting import Formatter, list_effect_size
from flags import InstructionFlags, variable_used
from instructions import (
    AnyInstruction,
    AbstractInstruction,
    Component,
    Instruction,
    MacroInstruction,
    MacroParts,
    PseudoInstruction,
    TIER_ONE,
    TIER_TWO,
)
import parsing
from parsing import StackEffect


HERE = os.path.dirname(__file__)
ROOT = os.path.join(HERE, "../..")
THIS = os.path.relpath(__file__, ROOT).replace(os.path.sep, posixpath.sep)

DEFAULT_INPUT = os.path.relpath(os.path.join(ROOT, "Python/bytecodes.c"))
DEFAULT_OUTPUT = os.path.relpath(os.path.join(ROOT, "Python/generated_cases.c.h"))
DEFAULT_OPCODE_IDS_H_OUTPUT = os.path.relpath(
    os.path.join(ROOT, "Include/opcode_ids.h")
)
DEFAULT_OPCODE_TARGETS_H_OUTPUT = os.path.relpath(
    os.path.join(ROOT, "Python/opcode_targets.h")
)
DEFAULT_METADATA_OUTPUT = os.path.relpath(
    os.path.join(ROOT, "Include/internal/pycore_opcode_metadata.h")
)
DEFAULT_PYMETADATA_OUTPUT = os.path.relpath(
    os.path.join(ROOT, "Lib/_opcode_metadata.py")
)
DEFAULT_EXECUTOR_OUTPUT = os.path.relpath(
    os.path.join(ROOT, "Python/executor_cases.c.h")
)
DEFAULT_ABSTRACT_INTERPRETER_OUTPUT = os.path.relpath(
    os.path.join(ROOT, "Python/abstract_interp_cases.c.h")
)

# Constants used instead of size for macro expansions.
# Note: 1, 2, 4 must match actual cache entry sizes.
OPARG_SIZES = {
    "OPARG_FULL": 0,
    "OPARG_CACHE_1": 1,
    "OPARG_CACHE_2": 2,
    "OPARG_CACHE_4": 4,
    "OPARG_TOP": 5,
    "OPARG_BOTTOM": 6,
    "OPARG_SET_IP": 7,
}

INSTR_FMT_PREFIX = "INSTR_FMT_"

# TODO: generate all these after updating the DSL
SPECIALLY_HANDLED_ABSTRACT_INSTR = {
    "LOAD_FAST",
    "LOAD_FAST_CHECK",
    "LOAD_FAST_AND_CLEAR",
    "LOAD_CONST",
    "STORE_FAST",
    "STORE_FAST_MAYBE_NULL",
    "COPY",
    # Arithmetic
    "_BINARY_OP_MULTIPLY_INT",
    "_BINARY_OP_ADD_INT",
    "_BINARY_OP_SUBTRACT_INT",
}

arg_parser = argparse.ArgumentParser(
    description="Generate the code for the interpreter switch.",
    formatter_class=argparse.ArgumentDefaultsHelpFormatter,
)

arg_parser.add_argument(
    "-v",
    "--verbose",
    help="Print list of non-viable uops and exit",
    action="store_true",
)
arg_parser.add_argument(
    "-o", "--output", type=str, help="Generated code", default=DEFAULT_OUTPUT
)
arg_parser.add_argument(
    "-n",
    "--opcode_ids_h",
    type=str,
    help="Header file with opcode number definitions",
    default=DEFAULT_OPCODE_IDS_H_OUTPUT,
)
arg_parser.add_argument(
    "-t",
    "--opcode_targets_h",
    type=str,
    help="File with opcode targets for computed gotos",
    default=DEFAULT_OPCODE_TARGETS_H_OUTPUT,
)
arg_parser.add_argument(
    "-m",
    "--metadata",
    type=str,
    help="Generated C metadata",
    default=DEFAULT_METADATA_OUTPUT,
)
arg_parser.add_argument(
    "-p",
    "--pymetadata",
    type=str,
    help="Generated Python metadata",
    default=DEFAULT_PYMETADATA_OUTPUT,
)
arg_parser.add_argument(
    "-l", "--emit-line-directives", help="Emit #line directives", action="store_true"
)
arg_parser.add_argument(
    "input", nargs=argparse.REMAINDER, help="Instruction definition file(s)"
)
arg_parser.add_argument(
    "-e",
    "--executor-cases",
    type=str,
    help="Write executor cases to this file",
    default=DEFAULT_EXECUTOR_OUTPUT,
)
arg_parser.add_argument(
    "-a",
    "--abstract-interpreter-cases",
    type=str,
    help="Write abstract interpreter cases to this file",
    default=DEFAULT_ABSTRACT_INTERPRETER_OUTPUT,
)


class Generator(Analyzer):
    def get_stack_effect_info(
        self, thing: parsing.InstDef | parsing.Macro | parsing.Pseudo
    ) -> tuple[AnyInstruction | None, str, str]:
        def effect_str(effects: list[StackEffect]) -> str:
            n_effect, sym_effect = list_effect_size(effects)
            if sym_effect:
                return f"{sym_effect} + {n_effect}" if n_effect else sym_effect
            return str(n_effect)

        instr: AnyInstruction | None
        popped: str | None = None
        pushed: str | None = None
        match thing:
            case parsing.InstDef():
                instr = self.instrs[thing.name]
                popped = effect_str(instr.input_effects)
                pushed = effect_str(instr.output_effects)
            case parsing.Macro():
                instr = self.macro_instrs[thing.name]
                popped, pushed = stacking.get_stack_effect_info_for_macro(instr)
            case parsing.Pseudo():
                instr = self.pseudo_instrs[thing.name]
                # Calculate stack effect, and check that it's the same
                # for all targets.
                for target in self.pseudos[thing.name].targets:
                    target_instr = self.instrs.get(target)
                    # Currently target is always an instr. This could change
                    # in the future, e.g., if we have a pseudo targetting a
                    # macro instruction.
                    assert target_instr
                    target_popped = effect_str(target_instr.input_effects)
                    target_pushed = effect_str(target_instr.output_effects)
                    if popped is None:
                        popped, pushed = target_popped, target_pushed
                    else:
                        assert popped == target_popped
                        assert pushed == target_pushed
            case _:
                assert_never(thing)
        assert popped is not None and pushed is not None
        return instr, popped, pushed

    @contextlib.contextmanager
    def metadata_item(self, signature: str, open: str, close: str) -> Iterator[None]:
        self.out.emit("")
        self.out.emit(f"extern {signature};")
        self.out.emit("#ifdef NEED_OPCODE_METADATA")
        with self.out.block(f"{signature} {open}", close):
            yield
        self.out.emit("#endif // NEED_OPCODE_METADATA")

    def write_stack_effect_functions(self) -> None:
        popped_data: list[tuple[AnyInstruction, str]] = []
        pushed_data: list[tuple[AnyInstruction, str]] = []
        for thing in self.everything:
            if isinstance(thing, parsing.Macro) and thing.name in self.instrs:
                continue
            instr, popped, pushed = self.get_stack_effect_info(thing)
            if instr is not None:
                popped_data.append((instr, popped))
                pushed_data.append((instr, pushed))

        def write_function(
            direction: str, data: list[tuple[AnyInstruction, str]]
        ) -> None:
            with self.metadata_item(
                f"int _PyOpcode_num_{direction}(int opcode, int oparg, bool jump)",
                "",
                "",
            ):
                with self.out.block("switch(opcode)"):
                    for instr, effect in data:
                        self.out.emit(f"case {instr.name}:")
                        self.out.emit(f"    return {effect};")
                    self.out.emit("default:")
                    self.out.emit("    return -1;")

        write_function("popped", popped_data)
        write_function("pushed", pushed_data)
        self.out.emit("")

    def from_source_files(self) -> str:
        filenames = []
        for filename in self.input_filenames:
            try:
                filename = os.path.relpath(filename, ROOT)
            except ValueError:
                # May happen on Windows if root and temp on different volumes
                pass
            filenames.append(filename.replace(os.path.sep, posixpath.sep))
        paths = f"\n{self.out.comment}   ".join(filenames)
        return f"{self.out.comment} from:\n{self.out.comment}   {paths}\n"

    def write_provenance_header(self) -> None:
        self.out.write_raw(f"{self.out.comment} This file is generated by {THIS}\n")
        self.out.write_raw(self.from_source_files())
        self.out.write_raw(f"{self.out.comment} Do not edit!\n")

    def assign_opcode_ids(self) -> None:
        """Assign IDs to opcodes"""

        ops: list[tuple[bool, str]] = []  # (has_arg, name) for each opcode
        instrumented_ops: list[str] = []

        specialized_ops: set[str] = set()
        for name, family in self.families.items():
            specialized_ops.update(family.members)

        for instr in self.macro_instrs.values():
            name = instr.name
            if name in specialized_ops:
                continue
            if name.startswith("INSTRUMENTED_"):
                instrumented_ops.append(name)
            else:
                ops.append((instr.instr_flags.HAS_ARG_FLAG, name))

        # Special case: this instruction is implemented in ceval.c
        # rather than bytecodes.c, so we need to add it explicitly
        # here (at least until we add something to bytecodes.c to
        # declare external instructions).
        instrumented_ops.append("INSTRUMENTED_LINE")

        # assert lists are unique
        assert len(set(ops)) == len(ops)
        assert len(set(instrumented_ops)) == len(instrumented_ops)

        opname: list[str | None] = [None] * 512
        opmap: dict[str, int] = {}
        markers: dict[str, int] = {}

        def map_op(op: int, name: str) -> None:
            assert op < len(opname)
            assert opname[op] is None, (op, name)
            assert name not in opmap
            opname[op] = name
            opmap[name] = op

        # 0 is reserved for cache entries. This helps debugging.
        map_op(0, "CACHE")

        # 17 is reserved as it is the initial value for the specializing counter.
        # This helps catch cases where we attempt to execute a cache.
        map_op(17, "RESERVED")

        # 149 is RESUME - it is hard coded as such in Tools/build/deepfreeze.py
        map_op(149, "RESUME")

        # Specialized ops appear in their own section
        # Instrumented opcodes are at the end of the valid range
        min_internal = 150
        min_instrumented = 254 - (len(instrumented_ops) - 1)
        assert min_internal + len(specialized_ops) < min_instrumented

        next_opcode = 1
        for has_arg, name in sorted(ops):
            if name in opmap:
                continue  # an anchored name, like CACHE
            map_op(next_opcode, name)
            if has_arg and "HAVE_ARGUMENT" not in markers:
                markers["HAVE_ARGUMENT"] = next_opcode

            while opname[next_opcode] is not None:
                next_opcode += 1

        assert next_opcode < min_internal, next_opcode

        for i, op in enumerate(sorted(specialized_ops)):
            map_op(min_internal + i, op)

        markers["MIN_INSTRUMENTED_OPCODE"] = min_instrumented
        for i, op in enumerate(instrumented_ops):
            map_op(min_instrumented + i, op)

        # Pseudo opcodes are after the valid range
        for i, op in enumerate(sorted(self.pseudos)):
            map_op(256 + i, op)

        assert 255 not in opmap.values()  # 255 is reserved
        self.opmap = opmap
        self.markers = markers

    def write_opcode_ids(
        self, opcode_ids_h_filename: str, opcode_targets_filename: str
    ) -> None:
        """Write header file that defined the opcode IDs"""

        with open(opcode_ids_h_filename, "w") as f:
            # Create formatter
            self.out = Formatter(f, 0)

            self.write_provenance_header()

            self.out.emit("")
            self.out.emit("#ifndef Py_OPCODE_IDS_H")
            self.out.emit("#define Py_OPCODE_IDS_H")
            self.out.emit("#ifdef __cplusplus")
            self.out.emit('extern "C" {')
            self.out.emit("#endif")
            self.out.emit("")
            self.out.emit("/* Instruction opcodes for compiled code */")

            def define(name: str, opcode: int) -> None:
                self.out.emit(f"#define {name:<38} {opcode:>3}")

            all_pairs: list[tuple[int, int, str]] = []
            # the second item in the tuple sorts the markers before the ops
            all_pairs.extend((i, 1, name) for (name, i) in self.markers.items())
            all_pairs.extend((i, 2, name) for (name, i) in self.opmap.items())
            for i, _, name in sorted(all_pairs):
                assert name is not None
                define(name, i)

            self.out.emit("")
            self.out.emit("#ifdef __cplusplus")
            self.out.emit("}")
            self.out.emit("#endif")
            self.out.emit("#endif /* !Py_OPCODE_IDS_H */")

        with open(opcode_targets_filename, "w") as f:
            # Create formatter
            self.out = Formatter(f, 0)

            with self.out.block("static void *opcode_targets[256] =", ";"):
                targets = ["_unknown_opcode"] * 256
                for name, op in self.opmap.items():
                    if op < 256:
                        targets[op] = f"TARGET_{name}"
                f.write(",\n".join([f"    &&{s}" for s in targets]))

    def write_metadata(self, metadata_filename: str, pymetadata_filename: str) -> None:
        """Write instruction metadata to output file."""

        # Compute the set of all instruction formats.
        all_formats: set[str] = set()
        for thing in self.everything:
            format: str | None = None
            match thing:
                case parsing.InstDef():
                    format = self.instrs[thing.name].instr_fmt
                case parsing.Macro():
                    format = self.macro_instrs[thing.name].instr_fmt
                case parsing.Pseudo():
                    for target in self.pseudos[thing.name].targets:
                        target_instr = self.instrs.get(target)
                        assert target_instr
                        if format is None:
                            format = target_instr.instr_fmt
                        else:
                            assert format == target_instr.instr_fmt
                case _:
                    assert_never(thing)
            assert format is not None
            all_formats.add(format)

        # Turn it into a sorted list of enum values.
        format_enums = [INSTR_FMT_PREFIX + format for format in sorted(all_formats)]

        with open(metadata_filename, "w") as f:
            # Create formatter
            self.out = Formatter(f, 0)

            self.write_provenance_header()

            self.out.emit("")
            self.out.emit("#ifndef Py_BUILD_CORE")
            self.out.emit('#  error "this header requires Py_BUILD_CORE define"')
            self.out.emit("#endif")
            self.out.emit("")
            self.out.emit("#include <stdbool.h>              // bool")

            self.write_pseudo_instrs()

            self.out.emit("")
            self.write_uop_items(lambda name, counter: f"#define {name} {counter}")

            self.write_stack_effect_functions()

            # Write the enum definition for instruction formats.
            with self.out.block("enum InstructionFormat", ";"):
                for enum in format_enums:
                    self.out.emit(enum + ",")

            self.out.emit("")
            self.out.emit(
                "#define IS_VALID_OPCODE(OP) \\\n"
                "    (((OP) >= 0) && ((OP) < OPCODE_METADATA_SIZE) && \\\n"
                "     (_PyOpcode_opcode_metadata[(OP)].valid_entry))"
            )

            self.out.emit("")
            InstructionFlags.emit_macros(self.out)

            self.out.emit("")
            with self.out.block("struct opcode_metadata", ";"):
                self.out.emit("bool valid_entry;")
                self.out.emit("enum InstructionFormat instr_format;")
                self.out.emit("int flags;")
            self.out.emit("")

            with self.out.block("struct opcode_macro_expansion", ";"):
                self.out.emit("int nuops;")
                self.out.emit(
                    "struct { int16_t uop; int8_t size; int8_t offset; } uops[12];"
                )
            self.out.emit("")

            for key, value in OPARG_SIZES.items():
                self.out.emit(f"#define {key} {value}")
            self.out.emit("")

            self.out.emit(
                "#define OPCODE_METADATA_FMT(OP) "
                "(_PyOpcode_opcode_metadata[(OP)].instr_format)"
            )
            self.out.emit("#define SAME_OPCODE_METADATA(OP1, OP2) \\")
            self.out.emit(
                "        (OPCODE_METADATA_FMT(OP1) == OPCODE_METADATA_FMT(OP2))"
            )
            self.out.emit("")

            # Write metadata array declaration
            self.out.emit("#define OPCODE_METADATA_SIZE 512")
            self.out.emit("#define OPCODE_UOP_NAME_SIZE 512")
            self.out.emit("#define OPCODE_MACRO_EXPANSION_SIZE 256")

            with self.metadata_item(
                "const struct opcode_metadata "
                "_PyOpcode_opcode_metadata[OPCODE_METADATA_SIZE]",
                "=",
                ";",
            ):
                # Write metadata for each instruction
                for thing in self.everything:
                    match thing:
                        case parsing.InstDef():
                            self.write_metadata_for_inst(self.instrs[thing.name])
                        case parsing.Macro():
                            if thing.name not in self.instrs:
                                self.write_metadata_for_macro(
                                    self.macro_instrs[thing.name]
                                )
                        case parsing.Pseudo():
                            self.write_metadata_for_pseudo(
                                self.pseudo_instrs[thing.name]
                            )
                        case _:
                            assert_never(thing)

            with self.metadata_item(
                "const struct opcode_macro_expansion "
                "_PyOpcode_macro_expansion[OPCODE_MACRO_EXPANSION_SIZE]",
                "=",
                ";",
            ):
                # Write macro expansion for each non-pseudo instruction
                for mac in self.macro_instrs.values():
                    if is_super_instruction(mac):
                        # Special-case the heck out of super-instructions
                        self.write_super_expansions(mac.name)
                    else:
                        self.write_macro_expansions(
                            mac.name, mac.parts, mac.cache_offset
                        )

            with self.metadata_item(
                "const char * const _PyOpcode_uop_name[OPCODE_UOP_NAME_SIZE]", "=", ";"
            ):
                self.write_uop_items(lambda name, counter: f'[{name}] = "{name}",')

            with self.metadata_item(
                f"const char *const _PyOpcode_OpName[{1 + max(self.opmap.values())}]",
                "=",
                ";",
            ):
                for name in self.opmap:
                    self.out.emit(f'[{name}] = "{name}",')

            with self.metadata_item(
                f"const uint8_t _PyOpcode_Caches[256]",
                "=",
                ";",
            ):
                family_member_names: set[str] = set()
                for family in self.families.values():
                    family_member_names.update(family.members)
                for mac in self.macro_instrs.values():
                    if (
                        mac.cache_offset > 0
                        and mac.name not in family_member_names
                        and not mac.name.startswith("INSTRUMENTED_")
                    ):
                        self.out.emit(f"[{mac.name}] = {mac.cache_offset},")
                # Irregular case:
                self.out.emit("[JUMP_BACKWARD] = 1,")

            deoptcodes = {}
            for name, op in self.opmap.items():
                if op < 256:
                    deoptcodes[name] = name
            for name, family in self.families.items():
                for m in family.members:
                    deoptcodes[m] = name
            # special case:
            deoptcodes["BINARY_OP_INPLACE_ADD_UNICODE"] = "BINARY_OP"

            with self.metadata_item(f"const uint8_t _PyOpcode_Deopt[256]", "=", ";"):
                for opt, deopt in sorted(deoptcodes.items()):
                    self.out.emit(f"[{opt}] = {deopt},")

            self.out.emit("")
            self.out.emit("#define EXTRA_CASES \\")
            valid_opcodes = set(self.opmap.values())
            with self.out.indent():
                for op in range(256):
                    if op not in valid_opcodes:
                        self.out.emit(f"case {op}: \\")
                self.out.emit("    ;\n")

        with open(pymetadata_filename, "w") as f:
            # Create formatter
            self.out = Formatter(f, 0, comment="#")

            self.write_provenance_header()

            # emit specializations
            specialized_ops = set()

            self.out.emit("")
            self.out.emit("_specializations = {")
            for name, family in self.families.items():
                with self.out.indent():
                    self.out.emit(f'"{family.name}": [')
                    with self.out.indent():
                        for m in family.members:
                            self.out.emit(f'"{m}",')
                        specialized_ops.update(family.members)
                    self.out.emit(f"],")
            self.out.emit("}")

            # Handle special case
            self.out.emit("")
            self.out.emit("# An irregular case:")
            self.out.emit(
                '_specializations["BINARY_OP"].append('
                '"BINARY_OP_INPLACE_ADD_UNICODE")'
            )
            specialized_ops.add("BINARY_OP_INPLACE_ADD_UNICODE")

            ops = sorted((id, name) for (name, id) in self.opmap.items())
            # emit specialized opmap
            self.out.emit("")
            with self.out.block("_specialized_opmap ="):
                for op, name in ops:
                    if name in specialized_ops:
                        self.out.emit(f"'{name}': {op},")

            # emit opmap
            self.out.emit("")
            with self.out.block("opmap ="):
                for op, name in ops:
                    if name not in specialized_ops:
                        self.out.emit(f"'{name}': {op},")

            for name in ["MIN_INSTRUMENTED_OPCODE", "HAVE_ARGUMENT"]:
                self.out.emit(f"{name} = {self.markers[name]}")

    def write_pseudo_instrs(self) -> None:
        """Write the IS_PSEUDO_INSTR macro"""
        self.out.emit("\n\n#define IS_PSEUDO_INSTR(OP)  ( \\")
        for op in self.pseudos:
            self.out.emit(f"    ((OP) == {op}) || \\")
        self.out.emit(f"    0)")

    def write_uop_items(self, make_text: typing.Callable[[str, int], str]) -> None:
        """Write '#define XXX NNN' for each uop"""
        counter = 300  # TODO: Avoid collision with pseudo instructions
        seen = set()

        def add(name: str) -> None:
            if name in seen:
                return
            nonlocal counter
            self.out.emit(make_text(name, counter))
            counter += 1
            seen.add(name)

        # These two are first by convention
        add("_EXIT_TRACE")
        add("_SET_IP")

        for instr in self.instrs.values():
            # Skip ops that are also macros -- those are desugared inst()s
            if instr.name not in self.macros:
                add(instr.name)

    def write_macro_expansions(
        self, name: str, parts: MacroParts, cache_offset: int
    ) -> None:
        """Write the macro expansions for a macro-instruction."""
        # TODO: Refactor to share code with write_cody(), is_viaible_uop(), etc.
        offset = 0  # Cache effect offset
        expansions: list[tuple[str, int, int]] = []  # [(name, size, offset), ...]
        for part in parts:
            if isinstance(part, Component):
                # All component instructions must be viable uops
                if not part.instr.is_viable_uop():
                    # This note just reminds us about macros that cannot
                    # be expanded to Tier 2 uops. It is not an error.
                    # It is sometimes emitted for macros that have a
                    # manual translation in translate_bytecode_to_trace()
                    # in Python/optimizer.c.
                    if len(parts) > 1 or part.instr.name != name:
                        self.note(
                            f"Part {part.instr.name} of {name} is not a viable uop",
                            part.instr.inst,
                        )
                    return
                if not part.active_caches:
                    if part.instr.name == "_SET_IP":
                        size, offset = OPARG_SIZES["OPARG_SET_IP"], cache_offset
                    else:
                        size, offset = OPARG_SIZES["OPARG_FULL"], 0
                else:
                    # If this assert triggers, is_viable_uops() lied
                    assert len(part.active_caches) == 1, (name, part.instr.name)
                    cache = part.active_caches[0]
                    size, offset = cache.effect.size, cache.offset
                expansions.append((part.instr.name, size, offset))
        assert len(expansions) > 0, f"Macro {name} has empty expansion?!"
        self.write_expansions(name, expansions)

    def write_super_expansions(self, name: str) -> None:
        """Write special macro expansions for super-instructions.

        If you get an assertion failure here, you probably have accidentally
        violated one of the assumptions here.

        - A super-instruction's name is of the form FIRST_SECOND where
          FIRST and SECOND are regular instructions whose name has the
          form FOO_BAR. Thus, there must be exactly 3 underscores.
          Example: LOAD_CONST_STORE_FAST.

        - A super-instruction's body uses `oparg1 and `oparg2`, and no
          other instruction's body uses those variable names.

        - A super-instruction has no active (used) cache entries.

        In the expansion, the first instruction's operand is all but the
        bottom 4 bits of the super-instruction's oparg, and the second
        instruction's operand is the bottom 4 bits. We use the special
        size codes OPARG_TOP and OPARG_BOTTOM for these.
        """
        pieces = name.split("_")
        assert len(pieces) == 4, f"{name} doesn't look like a super-instr"
        name1 = "_".join(pieces[:2])
        name2 = "_".join(pieces[2:])
        assert name1 in self.instrs, f"{name1} doesn't match any instr"
        assert name2 in self.instrs, f"{name2} doesn't match any instr"
        instr1 = self.instrs[name1]
        instr2 = self.instrs[name2]
        assert not instr1.active_caches, f"{name1} has active caches"
        assert not instr2.active_caches, f"{name2} has active caches"
        expansions: list[tuple[str, int, int]] = [
            (name1, OPARG_SIZES["OPARG_TOP"], 0),
            (name2, OPARG_SIZES["OPARG_BOTTOM"], 0),
        ]
        self.write_expansions(name, expansions)

    def write_expansions(
        self, name: str, expansions: list[tuple[str, int, int]]
    ) -> None:
        pieces = [
            f"{{ {name}, {size}, {offset} }}" for name, size, offset in expansions
        ]
        self.out.emit(
            f"[{name}] = "
            f"{{ .nuops = {len(pieces)}, .uops = {{ {', '.join(pieces)} }} }},"
        )

    def emit_metadata_entry(self, name: str, fmt: str, flags: InstructionFlags) -> None:
        flag_names = flags.names(value=True)
        if not flag_names:
            flag_names.append("0")
        self.out.emit(
            f"[{name}] = {{ true, {INSTR_FMT_PREFIX}{fmt},"
            f" {' | '.join(flag_names)} }},"
        )

    def write_metadata_for_inst(self, instr: Instruction) -> None:
        """Write metadata for a single instruction."""
        self.emit_metadata_entry(instr.name, instr.instr_fmt, instr.instr_flags)

    def write_metadata_for_macro(self, mac: MacroInstruction) -> None:
        """Write metadata for a macro-instruction."""
        self.emit_metadata_entry(mac.name, mac.instr_fmt, mac.instr_flags)

    def write_metadata_for_pseudo(self, ps: PseudoInstruction) -> None:
        """Write metadata for a macro-instruction."""
        self.emit_metadata_entry(ps.name, ps.instr_fmt, ps.instr_flags)

    def write_instructions(
        self, output_filename: str, emit_line_directives: bool
    ) -> None:
        """Write instructions to output file."""
        with open(output_filename, "w") as f:
            # Create formatter
            self.out = Formatter(f, 8, emit_line_directives)

            self.write_provenance_header()

            # Write and count instructions of all kinds
            n_macros = 0
            for thing in self.everything:
                match thing:
                    case parsing.InstDef():
                        pass
                    case parsing.Macro():
                        n_macros += 1
                        mac = self.macro_instrs[thing.name]
                        stacking.write_macro_instr(mac, self.out)
                    case parsing.Pseudo():
                        pass
                    case _:
                        assert_never(thing)

        print(
            f"Wrote {n_macros} cases to {output_filename}",
            file=sys.stderr,
        )

    def write_executor_instructions(
        self, executor_filename: str, emit_line_directives: bool
    ) -> None:
        """Generate cases for the Tier 2 interpreter."""
        n_uops = 0
        with open(executor_filename, "w") as f:
            self.out = Formatter(f, 8, emit_line_directives)
            self.write_provenance_header()
            for instr in self.instrs.values():
                if instr.is_viable_uop():
                    n_uops += 1
                    self.out.emit("")
                    with self.out.block(f"case {instr.name}:"):
                        stacking.write_single_instr(instr, self.out, tier=TIER_TWO)
                        if instr.check_eval_breaker:
                            self.out.emit("CHECK_EVAL_BREAKER();")
                        self.out.emit("break;")
        print(
            f"Wrote {n_uops} cases to {executor_filename}",
            file=sys.stderr,
        )

    def write_abstract_interpreter_instructions(
        self, abstract_interpreter_filename: str, emit_line_directives: bool
    ) -> None:
        """Generate cases for the Tier 2 abstract interpreter/analzyer."""
        with open(abstract_interpreter_filename, "w") as f:
            self.out = Formatter(f, 8, emit_line_directives)
            self.write_provenance_header()
            for instr in self.instrs.values():
                instr = AbstractInstruction(instr.inst)
                if (
                    instr.is_viable_uop()
                    and instr.name not in SPECIALLY_HANDLED_ABSTRACT_INSTR
                ):
                    self.out.emit("")
                    with self.out.block(f"case {instr.name}:"):
                        instr.write(self.out, tier=TIER_TWO)
                        self.out.emit("break;")
        print(
            f"Wrote some stuff to {abstract_interpreter_filename}",
            file=sys.stderr,
        )


def is_super_instruction(mac: MacroInstruction) -> bool:
    if (
        len(mac.parts) == 1
        and isinstance(mac.parts[0], Component)
        and variable_used(mac.parts[0].instr.inst, "oparg1")
    ):
        assert variable_used(mac.parts[0].instr.inst, "oparg2")
        return True
    else:
        return False


def main() -> None:
    """Parse command line, parse input, analyze, write output."""
    args = arg_parser.parse_args()  # Prints message and sys.exit(2) on error
    if len(args.input) == 0:
        args.input.append(DEFAULT_INPUT)

    # Raises OSError if input unreadable
    a = Generator(args.input)

    a.parse()  # Raises SyntaxError on failure
    a.analyze()  # Prints messages and sets a.errors on failure
    if a.errors:
        sys.exit(f"Found {a.errors} errors")
    if args.verbose:
        # Load execution counts from bmraw.json, if it exists
        a.report_non_viable_uops("bmraw.json")
        return

    # These raise OSError if output can't be written
    a.write_instructions(args.output, args.emit_line_directives)

    a.assign_opcode_ids()
    a.write_opcode_ids(args.opcode_ids_h, args.opcode_targets_h)
    a.write_metadata(args.metadata, args.pymetadata)
    a.write_executor_instructions(args.executor_cases, args.emit_line_directives)
    a.write_abstract_interpreter_instructions(
        args.abstract_interpreter_cases, args.emit_line_directives
    )


if __name__ == "__main__":
    main()