Skip to content
Standard libraryZig 0.17.0Official documentation
Sourcestd/zig/Zir.zig

Source line 1

Zig Intermediate Representation.

Astgen.zig converts AST nodes to these untyped IR instructions. Next, Sema.zig processes these into AIR. The minimum amount of information needed to represent a list of ZIR instructions. Once this structure is completed, it can be used to generate AIR, followed by machine code, without any memory access into the AST tree token list, node list, or source bytes. Exceptions include:

  • Compile errors, which may need to reach into these data structures to create a useful report.
  • In the future, possibly inline assembly, which needs to get parsed and handled by the codegen backend, and errors reported there. However for now, inline assembly is not an exception.

Fields

instructions: std.MultiArrayList(Inst).Slice
string_bytes: []u8

In order to store references to strings in fewer bytes, we copy all string bytes into here. String bytes can be null. It is up to whomever is referencing the data here whether they want to store both index and length, thus allowing null bytes, or store only index, and use null-termination. The string_bytes array is agnostic to either usage. Index 0 is reserved for special cases.

extra: []u32

The meaning of this data is determined by Inst.Tag value. The first few indexes are reserved. See ExtraIndex for the values.

std.zig.Zir.Allocator

alias

Source line 20

Alias of std.mem.Allocator

std.zig.Zir.assert

alias

Source line 21

Alias of std.debug.assert

std.zig.Zir.assertTrackable

function

Source line 5223

Asserts that a ZIR instruction is tracked across incremental updates, and thus may be given an InternPool.TrackedInst.

pub fn assertTrackable(zir: Zir, inst_idx: Zir.Inst.Index) void

Parameters

zir: Zir
inst_idx: Zir.Inst.Index

std.zig.Zir.Ast

alias

Source line 24

Alias of std.zig.Ast

std.zig.Zir.BigIntConst

alias

Source line 22

Alias of std.math.big.int.Const

std.zig.Zir.BigIntMutable

alias

Source line 23

Alias of std.math.big.int.Mutable

std.zig.Zir.bodySlice

function

Source line 129

pub fn bodySlice(zir: Zir, start: usize, len: usize) []Inst.Index

Parameters

zir: Zir
start: usize
len: usize

std.zig.Zir.builtin

constant

Source line 15

std.zig.Zir.DeclContents

container

Source line 4037

DeclContents contains all "interesting" instructions found within a declaration by findTrackable. These instructions are partitioned into a few different sets, since this makes ZIR instruction mapping more effective.

Fields

func_decl: ?Inst.Index

This is a simple optional because ZIR guarantees that a func/func_inferred/func_fancy instruction can only occur once per declaration.

type_decls: std.ArrayList(Inst.Index)
other: std.ArrayList(Inst.Index)

std.zig.Zir.DeclContents.clear

function

Source line 4050

pub fn clear(contents: *DeclContents) void

Parameters

contents: *DeclContents

std.zig.Zir.DeclContents.deinit

function

Source line 4056

pub fn deinit(contents: *DeclContents, gpa: Allocator) void

Parameters

contents: *DeclContents
gpa: Allocator

std.zig.Zir.DeclContents.init

constant

Source line 4044

DeclContents

std.zig.Zir.deinit

function

Source line 151

pub fn deinit(code: *Zir, gpa: Allocator) void

Parameters

code: *Zir
gpa: Allocator

std.zig.Zir.extraData

function

Source line 70

Returns the requested data, as well as the new index which is at the start of the trailers for the object.

pub fn extraData(code: Zir, comptime T: type, index: usize) ExtraData(T)

Parameters

code: Zir
T: type
index: usize

std.zig.Zir.ExtraData

type-function

Source line 64

fn ExtraData(comptime T: type) type

Parameters

T: type

Fields

data: T
end: usize

std.zig.Zir.ExtraIndex

container

Source line 53

Fields

compile_errors

If this is 0, no compile errors. Otherwise there is a CompileErrors payload at this index.

imports

If this is 0, this file contains no imports. Otherwise there is a Imports payload at this index.

_

std.zig.Zir.findTrackable

function

Source line 4067

Find all tracked ZIR instructions, recursively, within a declaration instruction. Does not recurse through nested declarations; to find all declarations, call this function recursively on the type declarations discovered in contents.type_decls.

This populates an ArrayList because an iterator would need to allocate memory anyway.

pub fn findTrackable(zir: Zir, gpa: Allocator, contents: *DeclContents, decl_inst: Zir.Inst.Index) !void

Parameters

zir: Zir
gpa: Allocator
contents: *DeclContents
decl_inst: Zir.Inst.Index

std.zig.Zir.findTrackableBody

function

Source line 4648

fn findTrackableBody( zir: Zir, gpa: Allocator, contents: *DeclContents, defers: *std.AutoHashMapUnmanaged(u32, void), body: []const Inst.Index, ) Allocator.Error!void

Parameters

zir: Zir
gpa: Allocator
contents: *DeclContents
defers: *std.AutoHashMapUnmanaged(u32, void)
body: []const Inst.Index

Errors

OutOfMemory

std.zig.Zir.findTrackableFields

function

Source line 4086

findTrackable does not recurse into field expressions in a type. Instead, this function will scan specifically field expressions in a given type declaration for trackable ZIR instructions.

pub fn findTrackableFields( zir: *const Zir, gpa: Allocator, contents: *DeclContents, type_decl_inst: Zir.Inst.Index, ) Allocator.Error!void

Parameters

zir: *const Zir
gpa: Allocator
contents: *DeclContents
type_decl_inst: Zir.Inst.Index

Errors

OutOfMemory

std.zig.Zir.findTrackableInner

function

Source line 4129

fn findTrackableInner( zir: Zir, gpa: Allocator, contents: *DeclContents, defers: *std.AutoHashMapUnmanaged(u32, void), inst: Inst.Index, ) Allocator.Error!void

Parameters

zir: Zir
gpa: Allocator
contents: *DeclContents
defers: *std.AutoHashMapUnmanaged(u32, void)
inst: Inst.Index

Errors

OutOfMemory

std.zig.Zir.FnInfo

container

Source line 4660

Fields

param_body: []const Inst.Index
param_body_inst: Inst.Index
ret_ty_body: []const Inst.Index
body: []const Inst.Index
ret_ty_ref: Zir.Inst.Ref
ret_ty_is_generic: bool
total_params_len: u32
inferred_error_set: bool

std.zig.Zir.getAssociatedSrcHash

function

Source line 4887

pub fn getAssociatedSrcHash(zir: Zir, inst: Zir.Inst.Index) ?std.zig.SrcHash

Parameters

zir: Zir
inst: Zir.Inst.Index

std.zig.Zir.getDeclaration

function

Source line 4816

pub fn getDeclaration(zir: Zir, inst: Zir.Inst.Index) Inst.Declaration.Unwrapped

Parameters

zir: Zir
inst: Zir.Inst.Index

std.zig.Zir.getEnumDecl

function

Source line 5585

pub fn getEnumDecl(zir: *const Zir, enum_decl: Inst.Index) UnwrappedEnumDecl

Parameters

zir: *const Zir
enum_decl: Inst.Index

std.zig.Zir.getFnInfo

function

Source line 4709

pub fn getFnInfo(zir: Zir, fn_inst: Inst.Index) FnInfo

Parameters

zir: Zir
fn_inst: Inst.Index

std.zig.Zir.getOpaqueDecl

function

Source line 5715

pub fn getOpaqueDecl(zir: *const Zir, opaque_decl: Inst.Index) UnwrappedOpaqueDecl

Parameters

zir: *const Zir
opaque_decl: Inst.Index

std.zig.Zir.getParamBody

function

Source line 4671

pub fn getParamBody(zir: Zir, fn_inst: Inst.Index) []const Zir.Inst.Index

Parameters

zir: Zir
fn_inst: Inst.Index

std.zig.Zir.getParamName

function

Source line 4700

pub fn getParamName(zir: Zir, param_inst: Inst.Index) ?NullTerminatedString

Parameters

zir: Zir
param_inst: Inst.Index

std.zig.Zir.getStructDecl

function

Source line 5270

pub fn getStructDecl(zir: *const Zir, struct_decl: Inst.Index) UnwrappedStructDecl

Parameters

zir: *const Zir
struct_decl: Inst.Index

std.zig.Zir.getSwitchBlock

function

Source line 4982

pub fn getSwitchBlock(zir: *const Zir, switch_inst: Inst.Index) UnwrappedSwitchBlock

Parameters

zir: *const Zir
switch_inst: Inst.Index

std.zig.Zir.getUnionDecl

function

Source line 5436

pub fn getUnionDecl(zir: *const Zir, union_decl: Inst.Index) UnwrappedUnionDecl

Parameters

zir: *const Zir
union_decl: Inst.Index

std.zig.Zir.hasCompileErrors

function

Source line 133

pub fn hasCompileErrors(code: Zir) bool

Parameters

code: Zir

std.zig.Zir.Header

container

Source line 39

The data stored at byte offset 0 when ZIR is stored in a file.

Fields

instructions_len: u32
string_bytes_len: u32
extra_len: u32
unused: u32 = 0

We could leave this as padding, however it triggers a Valgrind warning because we read and write undefined bytes to the file system. This is harmless, but it's essentially free to have a zero field here and makes the warning go away, making it more likely that following Valgrind warnings will be taken seriously.

stat_inode: Io.File.INode
stat_size: u64
stat_mtime: i128

std.zig.Zir.Inst

container

Source line 161

These are untyped instructions generated from an Abstract Syntax Tree. The data here is immutable because it is possible to have multiple analyses on the same ZIR happening at the same time.

Fields

tag: Tag
data: Data

std.zig.Zir.inst_tracking_version

constant

Source line 5219

When the ZIR update tracking logic must be modified to consider new instructions, change this constant to trigger compile errors at all relevant locations.

std.zig.Zir.Inst.AllocExtended

container

Source line 3938

Trailing:

  1. type_inst: Ref, // if small 0b000X is set
  2. align_inst: Ref, // if small 0b00X0 is set

Fields

src_node: Ast.Node.Offset

std.zig.Zir.Inst.AllocExtended.Small

container

Source line 3941

Fields

has_type: bool
has_align: bool
is_const: bool
is_comptime: bool
_: u12 = 0

std.zig.Zir.Inst.ArrayInit

container

Source line 3998

Fields

ty: Ref
init_count: u32

std.zig.Zir.Inst.ArrayInitRefTy

container

Source line 3471

Fields

ptr_ty: Ref
elem_count: u32

std.zig.Zir.Inst.ArrayTypeSentinel

container

Source line 3184

Fields

len: Ref
sentinel: Ref
elem_type: Ref

std.zig.Zir.Inst.As

container

Source line 3487

Fields

dest_type: Ref
operand: Ref

std.zig.Zir.Inst.Asm

container

Source line 2569

Trailing:

  1. Output for every outputs_len
  2. Input for every inputs_len

Fields

src_node: Ast.Node.Offset
asm_source: NullTerminatedString
output_type_bits: u32

1 bit for each outputs_len: whether it uses -> T or not. 0b0 - operand is a pointer to where to store the output. 0b1 - operand is a type; asm expression has the output as the result. 0b0X is the first output, 0bX0 is the second, etc.

clobbers: Ref

std.zig.Zir.Inst.Asm.Input

container

Source line 2595

Fields

name: NullTerminatedString

index into string_bytes (null terminated)

constraint: NullTerminatedString

index into string_bytes (null terminated)

operand: Ref

std.zig.Zir.Inst.Asm.Output

container

Source line 2586

Fields

name: NullTerminatedString

index into string_bytes (null terminated)

constraint: NullTerminatedString

index into string_bytes (null terminated)

operand: Ref

How to interpret this is determined by output_type_bits.

std.zig.Zir.Inst.Asm.Small

container

Source line 2580

Fields

is_volatile: bool
outputs_len: u7
inputs_len: u8

std.zig.Zir.Inst.AtomicLoad

container

Source line 3887

Fields

elem_type: Ref
ptr: Ref
ordering: Ref

std.zig.Zir.Inst.AtomicRmw

container

Source line 3868

Fields

ptr: Ref
operation: Ref
operand: Ref
ordering: Ref

std.zig.Zir.Inst.AtomicStore

container

Source line 3881

Fields

ptr: Ref
operand: Ref
ordering: Ref

std.zig.Zir.Inst.Bin

container

Source line 3217

The meaning of these operands depends on the corresponding Tag.

Fields

lhs: Ref
rhs: Ref

std.zig.Zir.Inst.BinNode

container

Source line 3222

Fields

node: Ast.Node.Offset
lhs: Ref
rhs: Ref

std.zig.Zir.Inst.Block

container

Source line 2697

This data is stored inside extra, with trailing operands according to body_len. Each operand is an Index.

Fields

body_len: u32

std.zig.Zir.Inst.BlockComptime

container

Source line 2703

Trailing:

  • inst: Index // for each body_len

Fields

reason: std.zig.SimpleComptimeReason
body_len: u32

std.zig.Zir.Inst.BoolBr

container

Source line 2710

Trailing:

  • inst: Index // for each body_len

Fields

lhs: Ref
body_len: u32

std.zig.Zir.Inst.Break

container

Source line 2561

Fields

operand_src_node: Ast.Node.OptionalOffset
block_inst: Index

std.zig.Zir.Inst.BuiltinCall

container

Source line 3135

Fields

flags: Flags
modifier: Ref
callee: Ref
args: Ref

std.zig.Zir.Inst.BuiltinCall.Flags

container

Source line 3143

Fields

is_nosuspend: bool
ensure_result_used: bool
_: u30 = 0

std.zig.Zir.Inst.Call

container

Source line 3088

Stored inside extra, with trailing arguments according to args_len. Implicit 0. arg_0_start: u32, // always same as args_len

  1. arg_end: u32, // for each args_len arg_N_start is the same as arg_N-1_end

Fields

flags: Flags
callee: Ref

std.zig.Zir.Inst.Call.Flags

container

Source line 3094

Fields

packed_modifier: PackedModifier
ensure_result_used: bool = false
pop_error_return_trace: bool
args_len: PackedArgsLen

std.zig.Zir.Inst.Call.Flags.PackedArgsLen

type

Source line 3097

std.zig.Zir.Inst.Call.Flags.PackedModifier

type

Source line 3096

std.lang.CallModifier in packed form

std.zig.Zir.Inst.Capture

container

Source line 3538

Represents a single value being captured in a type declaration's closure.

Fields

tag: enum(u3) {
    /// `data` is a `u16` index into the parent closure.
    nested,
    /// `data` is a `Zir.Inst.Index` to an instruction whose value is being captured.
    instruction,
    /// `data` is a `Zir.Inst.Index` to an instruction representing an alloc whose contents is being captured.
    instruction_load,
    /// `data` is a `NullTerminatedString` to a decl name.
    decl_val,
    /// `data` is a `NullTerminatedString` to a decl name.
    decl_ref,
}
data: u29

std.zig.Zir.Inst.Capture.unwrap

function

Source line 3583

pub fn unwrap(cap: Capture) Unwrapped

Parameters

cap: Capture

std.zig.Zir.Inst.Capture.Unwrapped

container

Source line 3552

Fields

nested: u16
instruction: Zir.Inst.Index
instruction_load: Zir.Inst.Index
decl_val: NullTerminatedString
decl_ref: NullTerminatedString

std.zig.Zir.Inst.Capture.wrap

function

Source line 3559

pub fn wrap(cap: Unwrapped) Capture

Parameters

cap: Unwrapped

std.zig.Zir.Inst.Cmpxchg

container

Source line 3859

Fields

node: Ast.Node.Offset
ptr: Ref
expected_value: Ref
new_value: Ref
success_order: Ref
failure_order: Ref

std.zig.Zir.Inst.CompileErrors

container

Source line 3956

Trailing: CompileErrors.Item for each items_len.

Fields

items_len: u32

std.zig.Zir.Inst.CompileErrors.Item

container

Source line 3961

Trailing: note_payload_index: u32 for each notes_len. It's a payload index of another Item.

Fields

msg: NullTerminatedString

null terminated string index

node: Ast.Node.OptionalIndex
token: Ast.OptionalTokenIndex

If node is .none then this will be populated.

byte_offset: u32

Can be used in combination with token.

notes: u32

0 or a payload index of a Block, each is a payload index of another Item.

std.zig.Zir.Inst.CompileErrors.Item.notesLen

function

Source line 3973

pub fn notesLen(item: Item, zir: Zir) u32

Parameters

item: Item
zir: Zir

std.zig.Zir.Inst.CondBr

container

Source line 3158

This data is stored inside extra, with two sets of trailing Ref:

    1. the then body, according to then_body_len.
    1. the else body, according to else_body_len.

Fields

condition: Ref
then_body_len: u32
else_body_len: u32

std.zig.Zir.Inst.Data

container

Source line 2390

All instructions have an 8-byte payload, which is contained within this union. Tag determines which union field is active, as well as how to interpret the data within.

Fields

extended: Extended.InstData

Used for Tag.extended. The extended opcode determines the meaning of the small and operand fields.

un_node: struct {
    /// Offset from Decl AST node index.
    src_node: Ast.Node.Offset,
    /// The meaning of this operand depends on the corresponding `Tag`.
    operand: Ref,
}

Used for unary operators, with an AST node source location.

un_tok: struct {
    /// Offset from Decl AST token index.
    src_tok: Ast.TokenOffset,
    /// The meaning of this operand depends on the corresponding `Tag`.
    operand: Ref,
}

Used for unary operators, with a token source location.

pl_node: struct {
    /// Offset from Decl AST node index.
    /// `Tag` determines which kind of AST node this points to.
    src_node: Ast.Node.Offset,
    /// index into extra.
    /// `Tag` determines what lives there.
    payload_index: u32,
}
pl_tok: struct {
    /// Offset from Decl AST token index.
    src_tok: Ast.TokenOffset,
    /// index into extra.
    /// `Tag` determines what lives there.
    payload_index: u32,
}
bin: Bin
str: struct {
    /// Offset into `string_bytes`.
    start: NullTerminatedString,
    /// Number of bytes in the string.
    len: u32,

    pub fn get(self: @This(), code: Zir) []const u8 {
        return code.string_bytes[@backingInt(self.start)..][0..self.len];
    }
}

For strings which may contain null bytes.

str_tok: struct {
    /// Offset into `string_bytes`. Null-terminated.
    start: NullTerminatedString,
    /// Offset from Decl AST token index.
    src_tok: Ast.TokenOffset,

    pub fn get(self: @This(), code: Zir) [:0]const u8 {
        return code.nullTerminatedString(self.start);
    }
}
tok: Ast.TokenOffset

Offset from Decl AST token index.

node: Ast.Node.Offset

Offset from Decl AST node index.

int: u64
float: f64
ptr_type: struct {
    flags: packed struct {
        is_allowzero: bool,
        is_mutable: bool,
        is_volatile: bool,
        has_sentinel: bool,
        has_align: bool,
        has_addrspace: bool,
        has_bit_range: bool,
        _: u1 = 0,
    },
    size: std.lang.Type.Pointer.Size,
    /// Index into extra. See `PtrType`.
    payload_index: u32,
}
int_type: struct {
    /// Offset from Decl AST node index.
    /// `Tag` determines which kind of AST node this points to.
    src_node: Ast.Node.Offset,
    signedness: std.lang.Signedness,
    bit_count: u16,
}
@"unreachable": struct {
    /// Offset from Decl AST node index.
    /// `Tag` determines which kind of AST node this points to.
    src_node: Ast.Node.Offset,
}
@"break": struct {
    operand: Ref,
    /// Index of a `Break` payload.
    payload_index: u32,
}
dbg_stmt: LineColumn
inst_node: struct {
    /// Offset from Decl AST node index.
    src_node: Ast.Node.Offset,
    /// The meaning of this operand depends on the corresponding `Tag`.
    inst: Index,
}

Used for unary operators which reference an inst, with an AST node source location.

str_op: struct {
    /// Offset into `string_bytes`. Null-terminated.
    str: NullTerminatedString,
    operand: Ref,

    pub fn getStr(self: @This(), zir: Zir) [:0]const u8 {
        return zir.nullTerminatedString(self.str);
    }
}
@"defer": struct {
    index: u32,
    len: u32,
}
save_err_ret_index: struct {
    operand: Ref, // If error type (or .none), save new trace index
}
elem_val_imm: struct {
    /// The indexable value being accessed.
    operand: Ref,
    /// The index being accessed.
    idx: u32,
}
declaration: struct {
    /// This node provides a new absolute baseline node for all instructions within this struct.
    src_node: Ast.Node.Index,
    /// index into extra to a `Declaration` payload.
    payload_index: u32,
}

std.zig.Zir.Inst.Data.FieldEnum

container

Source line 2534

TODO this has to be kept in sync with Data which we want to be an untagged union. There is some kind of language awkwardness here and it has to do with deserializing an untagged union (in this case Data) from a file, and trying to preserve the hidden safety field.

Fields

extended
un_node
un_tok
pl_node
pl_tok
bin
str
str_tok
tok
node
int
float
ptr_type
int_type
@"unreachable"
@"break"
dbg_stmt
inst_node
str_op
@"defer"
save_err_ret_index
elem_val_imm
declaration

std.zig.Zir.Inst.Data.get

function

Source line 2431

pub fn get(self: @This(), code: Zir) []const u8

Parameters

self: @This()
code: Zir

std.zig.Zir.Inst.Data.get

function

Source line 2441

pub fn get(self: @This(), code: Zir) [:0]const u8

Parameters

self: @This()
code: Zir

std.zig.Zir.Inst.Data.getStr

function

Source line 2497

pub fn getStr(self: @This(), zir: Zir) [:0]const u8

Parameters

self: @This()
zir: Zir

std.zig.Zir.Inst.Declaration

container

Source line 2739

Trailing:

  1. name: NullTerminatedString // if flags.id.hasName()
  2. lib_name: NullTerminatedString // if flags.id.hasLibName()
  3. type_body_len: u32 // if flags.id.hasTypeBody()
  4. align_body_len: u32 // if flags.id.hasSpecialBodies()
  5. linksection_body_len: u32 // if flags.id.hasSpecialBodies()
  6. addrspace_body_len: u32 // if flags.id.hasSpecialBodies()
  7. value_body_len: u32 // if flags.id.hasValueBody()
  8. type_body_inst: Zir.Inst.Index
    • for each type_body_len
    • body to be exited via break_inline to this declaration instruction
  9. align_body_inst: Zir.Inst.Index
    • for each align_body_len
    • body to be exited via break_inline to this declaration instruction
  10. linksection_body_inst: Zir.Inst.Index
    • for each linksection_body_len
    • body to be exited via break_inline to this declaration instruction
  11. addrspace_body_inst: Zir.Inst.Index
  • for each addrspace_body_len
  • body to be exited via break_inline to this declaration instruction
  1. value_body_inst: Zir.Inst.Index
  • for each value_body_len
  • body to be exited via break_inline to this declaration instruction
  • within this body, the declaration instruction refers to the resolved type from the type body

Fields

src_hash_0: u32
src_hash_1: u32
src_hash_2: u32
src_hash_3: u32
flags_0: u32
flags_1: u32

std.zig.Zir.Inst.Declaration.Bodies

container

Source line 3029

Fields

type_body: ?[]const Index
align_body: ?[]const Index
linksection_body: ?[]const Index
addrspace_body: ?[]const Index
value_body: ?[]const Index

std.zig.Zir.Inst.Declaration.Flags

container

Source line 2791

Fields

src_line: u30
src_column: u29
id: Id

std.zig.Zir.Inst.Declaration.Flags.Id

container

Source line 2796

Fields

unnamed_test
@"test"
decltest
@"comptime"
const_simple
const_typed
@"const"
pub_const_simple
pub_const_typed
pub_const
extern_const_simple
extern_const
pub_extern_const_simple
pub_extern_const
export_const
pub_export_const
var_simple
@"var"
var_threadlocal
pub_var_simple
pub_var
pub_var_threadlocal
extern_var
extern_var_threadlocal
pub_extern_var
pub_extern_var_threadlocal
export_var
export_var_threadlocal
pub_export_var
pub_export_var_threadlocal

std.zig.Zir.Inst.Declaration.Flags.Id.hasLibName

function

Source line 2843

pub fn hasLibName(id: Id) bool

Parameters

id: Id

std.zig.Zir.Inst.Declaration.Flags.Id.hasName

function

Source line 2834

pub fn hasName(id: Id) bool

Parameters

id: Id

std.zig.Zir.Inst.Declaration.Flags.Id.hasSpecialBodies

function

Source line 2887

pub fn hasSpecialBodies(id: Id) bool

Parameters

id: Id

std.zig.Zir.Inst.Declaration.Flags.Id.hasTypeBody

function

Source line 2856

pub fn hasTypeBody(id: Id) bool

Parameters

id: Id

std.zig.Zir.Inst.Declaration.Flags.Id.hasValueBody

function

Source line 2872

pub fn hasValueBody(id: Id) bool

Parameters

id: Id

std.zig.Zir.Inst.Declaration.Flags.Id.isPub

function

Source line 2966

pub fn isPub(id: Id) bool

Parameters

id: Id

std.zig.Zir.Inst.Declaration.Flags.Id.isThreadlocal

function

Source line 2986

pub fn isThreadlocal(id: Id) bool

Parameters

id: Id

std.zig.Zir.Inst.Declaration.Flags.Id.kind

function

Source line 2929

pub fn kind(id: Id) Declaration.Unwrapped.Kind

Parameters

id: Id

std.zig.Zir.Inst.Declaration.Flags.Id.linkage

function

Source line 2907

pub fn linkage(id: Id) Declaration.Unwrapped.Linkage

Parameters

id: Id

std.zig.Zir.Inst.Declaration.getBodies

function

Source line 3037

pub fn getBodies(declaration: Declaration, extra_end: u32, zir: Zir) Bodies

Parameters

declaration: Declaration
extra_end: u32
zir: Zir

std.zig.Zir.Inst.Declaration.Name

container

Source line 3001

Fields

@"comptime" = std.math.maxInt(u32)
unnamed_test = std.math.maxInt(u32) - 1
_

Other values are NullTerminatedString values, i.e. index into string_bytes. If the byte referenced is 0, the decl is a named test, and the actual name begins at the following byte.

std.zig.Zir.Inst.Declaration.Name.isNamedTest

function

Source line 3009

pub fn isNamedTest(name: Name, zir: Zir) bool

Parameters

name: Name
zir: Zir

std.zig.Zir.Inst.Declaration.Name.toString

function

Source line 3015

pub fn toString(name: Name, zir: Zir) ?NullTerminatedString

Parameters

name: Name
zir: Zir

std.zig.Zir.Inst.Declaration.Unwrapped

container

Source line 2749

Fields

src_node: Ast.Node.Index
src_line: u32
src_column: u32
kind: Kind
name: NullTerminatedString

Always .empty for kind of unnamed_test, .@"comptime"

is_pub: bool

Always false for kind of unnamed_test, .@"test", .decltest, .@"comptime".

is_threadlocal: bool

Always false for kind != .@"var".

linkage: Linkage

Always .normal for kind != .@"const" and kind != .@"var".

lib_name: NullTerminatedString

Always .empty for linkage != .@"extern".

type_body: ?[]const Inst.Index

Always populated for linkage == .@"extern".

align_body: ?[]const Inst.Index
linksection_body: ?[]const Inst.Index
addrspace_body: ?[]const Inst.Index
value_body: ?[]const Inst.Index

Always populated for linkage != .@"extern".

std.zig.Zir.Inst.Declaration.Unwrapped.Kind

container

Source line 2750

Fields

unnamed_test
@"test"
decltest
@"comptime"
@"const"
@"var"

std.zig.Zir.Inst.Declaration.Unwrapped.Linkage

container

Source line 2759

Fields

normal
@"extern"
@"export"

std.zig.Zir.Inst.ElemPtrImm

container

Source line 3257

Fields

ptr: Ref
index: u32

std.zig.Zir.Inst.EnumDecl

container

Source line 3666

Trailing:

  1. captures_len: u32, // if has_captures_len
  2. decls_len: u32, // if has_decls_len
  3. fields_len: u32, // if has_fields_len
  4. tag_type_body_len: u32, // if has_tag_type
  5. capture: Capture // for every captures_len
  6. capture_name: NullTerminatedString // for every captures_len
  7. decl: Index, // for every decls_len; points to a declaration instruction
  8. field_name: NullTerminatedString // for every fields_len
  9. field_value_body_len: u32 // for every fields_len if any_field_values
  10. tag_type_body_inst: Inst.Index // for each tag_type_body_len
  11. body_inst: Inst.Index // value body for each field

Fields

fields_hash_0: u32
fields_hash_1: u32
fields_hash_2: u32
fields_hash_3: u32
src_line: u32
src_column: u32
src_node: Ast.Node.Index

This node provides a new absolute baseline node for all instructions within this struct.

std.zig.Zir.Inst.EnumDecl.Small

container

Source line 3678

Fields

has_captures_len: bool
has_decls_len: bool
has_fields_len: bool
name_strategy: NameStrategy
has_tag_type: bool
nonexhaustive: bool
any_field_values: bool
_: u8 = 0

std.zig.Zir.Inst.ErrorSetDecl

container

Source line 3791

Trailing:

  1. field_name: NullTerminatedString // for every fields_len

Fields

fields_len: u32

std.zig.Zir.Inst.Export

container

Source line 3950

Fields

exported: Ref
options: Ref

std.zig.Zir.Inst.Extended

container

Source line 1924

Rarer instructions are here; ones that do not fit in the 8-bit Tag enum. noreturn instructions may not go here; they must be part of the main Tag enum.

Fields

struct_decl

A struct type definition. Contains references to ZIR instructions for the field types, defaults, and alignments. operand is payload index to StructDecl. small is StructDecl.Small.

enum_decl

An enum type definition. Contains references to ZIR instructions for the field value expressions and optional type tag expression. operand is payload index to EnumDecl. small is EnumDecl.Small.

union_decl

A union type definition. Contains references to ZIR instructions for the field types and optional type tag expression. operand is payload index to UnionDecl. small is UnionDecl.Small.

opaque_decl

An opaque type definition. Contains references to decls and captures. operand is payload index to OpaqueDecl. small is OpaqueDecl.Small.

tuple_decl

A tuple type. Note that tuples are not namespace/container types. operand is payload index to TupleDecl. small is fields_len: u16.

this

Implements the @This builtin. operand is src_node: Ast.Node.Offset.

ret_addr

Implements the @returnAddress builtin. operand is src_node: Ast.Node.Offset.

builtin_src

Implements the @src builtin. operand is payload index to LineColumn.

error_return_trace

Implements the @errorReturnTrace builtin. operand is src_node: Ast.Node.Offset.

frame

Implements the @frame builtin. operand is src_node: Ast.Node.Offset.

frame_address

Implements the @frameAddress builtin. operand is src_node: Ast.Node.Offset.

alloc

Same as alloc from Tag but may contain an alignment instruction. operand is payload index to AllocExtended. small:

  • 0b000X - has type
  • 0b00X0 - has alignment
  • 0b0X00 - 1=const, 0=var
  • 0bX000 - is comptime
builtin_extern

The @extern builtin. operand is payload index to BinNode.

@"asm"

Inline assembly. operand is payload index to Asm.

asm_expr

Same as asm except the assembly template is not a string literal but a comptime expression. The asm_source field of the Asm is not a null-terminated string but instead a Ref.

compile_log

Log compile time variables and emit an error message. operand is payload index to NodeMultiOp. small is operands_len. The AST node is the compile log builtin call.

typeof_peer

The builtin @TypeOf which returns the type after Peer Type Resolution of one or more params. operand is payload index to TypeOfPeer. small is operands_len. The AST node is the builtin call.

min_multi

Implements the @min builtin for more than 2 args. operand is payload index to NodeMultiOp. small is operands_len. The AST node is the builtin call.

max_multi

Implements the @max builtin for more than 2 args. operand is payload index to NodeMultiOp. small is operands_len. The AST node is the builtin call.

add_with_overflow

Implements the @addWithOverflow builtin. operand is payload index to BinNode. small is unused.

sub_with_overflow

Implements the @subWithOverflow builtin. operand is payload index to BinNode. small is unused.

mul_with_overflow

Implements the @mulWithOverflow builtin. operand is payload index to BinNode. small is unused.

shl_with_overflow

Implements the @shlWithOverflow builtin. operand is payload index to BinNode. small is unused.

round_op

@round, @floor, @ceil, or @trunc, with a result type. operand is payload index to BinNode. small is a RoundOp representing the specific operation being performed.

round_op_ty

Returns the type for the operand of a rounding op. operand is UnNode. small is unused.

wasm_memory_size

operand is payload index to UnNode.

wasm_memory_grow

operand is payload index to BinNode.

prefetch

The @prefetch builtin. operand is payload index to BinNode.

set_float_mode

Implement builtin @setFloatMode. operand is payload index to UnNode.

error_cast

Implements the @errorCast builtin. operand is payload index to BinNode. lhs is dest type, rhs is operand.

breakpoint

Implements @breakpoint. operand is src_node: Ast.Node.Offset.

disable_instrumentation

Implement builtin @disableInstrumentation. operand is src_node: Ast.Node.Offset.

disable_intrinsics

Implement builtin @disableIntrinsics. operand is src_node: i32.

select

Implements the @select builtin. operand is payload index to Select.

int_from_error

Implement builtin @errToInt. operand is payload index to UnNode.

error_from_int

Implement builtin @errorFromInt. operand is payload index to UnNode.

reify_slice_arg_ty

Given a comptime-known operand of type []const A, returns the type *const [operand.len]B. The types A and B are determined from ReifySliceArgInfo. This instruction is used to provide result types to arguments of @Fn, @Struct, etc. operand is payload index to UnNode. small is a bitcast ReifySliceArgInfo.

reify_enum_value_slice_ty

Like reify_slice_arg_ty for the specific case of []const []const u8 to []const TagInt, as needed for @Enum. operand is payload index to BinNode. lhs is the type TagInt. rhs is the []const []const u8 value. small is unused.

reify_pointer_sentinel_ty

Given a comptime-known operand of type type, returns the type ?operand if possible, otherwise ?noreturn. Used for the final arg of @Pointer to allow reifying pointers to opaque types. operand is payload index to UnNode. small is unused.

reify_tuple

Implements builtin @Tuple. operand is payload index to UnNode.

reify_pointer

Implements builtin @Pointer. operand is payload index to ReifyPointer.

reify_fn

Implements builtin @Fn. operand is payload index to ReifyFn.

reify_struct

Implements builtin @Struct. operand is payload index to ReifyStruct. small contains NameStrategy.

reify_union

Implements builtin @Union. operand is payload index to ReifyUnion. small contains NameStrategy.

reify_enum

Implements builtin @Enum. operand is payload index to ReifyEnum. small contains NameStrategy.

reify_spirv_type

Implements builtin @SpirvType. operand is payload index to ReifyFn.

cmpxchg

Implements the @cmpxchgStrong and @cmpxchgWeak builtins. small 0=>weak 1=>strong operand is payload index to Cmpxchg.

c_va_arg

Implement builtin @cVaArg. operand is payload index to BinNode.

c_va_copy

Implement builtin @cVaCopy. operand is payload index to UnNode.

c_va_end

Implement builtin @cVaEnd. operand is payload index to UnNode.

c_va_start

Implement builtin @cVaStart. operand is src_node: Ast.Node.Offset.

ptr_cast_full

Implements the following builtins: @ptrCast, @alignCast, @addrSpaceCast, @constCast, @volatileCast. Represents an arbitrary nesting of the above builtins. Such a nesting is treated as a single operation which can modify multiple components of a pointer type. operand is payload index to BinNode. small contains FullPtrCastFlags. AST node is the root of the nested casts. lhs is dest type, rhs is operand.

ptr_cast_no_dest

operand is payload index to UnNode. small contains FullPtrCastFlags. Guaranteed to only have flags where no explicit destination type is required (const_cast and volatile_cast). AST node is the root of the nested casts.

work_item_id

Implements the @workItemId builtin. operand is payload index to UnNode.

work_group_size

Implements the @workGroupSize builtin. operand is payload index to UnNode.

work_group_id

Implements the @workGroupId builtin. operand is payload index to UnNode.

in_comptime

Implements the @inComptime builtin. operand is src_node: Ast.Node.Offset.

restore_err_ret_index

Restores the error return index to its last saved state in a given block. If the block is .none, restores to the state from the point of function entry. If the operand is not .none, the restore is conditional on the operand value not being an error. operand is payload index to RestoreErrRetIndex. small is undefined.

closure_get

Retrieves a value from the current type declaration scope's closure. operand is src_node: Ast.Node.Offset. small is closure index.

value_placeholder

Used as a placeholder instruction which is just a dummy index for Sema to replace with a specific value. For instance, this is used for the capture of an errdefer. This should never appear in a body.

field_parent_ptr

Implements the @fieldParentPtr builtin. operand is payload index to FieldParentPtr. small contains FullPtrCastFlags. Guaranteed to not have the ptr_cast flag. Uses the pl_node union field with payload FieldParentPtr.

std_lang_value

Get a type or value from std.lang. operand is src_node: Ast.Node.Offset. small is an Inst.StdLangValue.

branch_hint

Provide a @branchHint for the current block. operand is payload index to UnNode. small is unused.

inplace_arith_result_ty

Compute the result type for in-place arithmetic, e.g. +=. operand is Zir.Inst.Ref of the loaded LHS (not its type). small is an Inst.InplaceOp.

dbg_empty_stmt

Marks a statement that can be stepped to but produces no code. operand and small are ignored.

astgen_error

At this point, AstGen encountered a fatal error which terminated ZIR lowering for this body. A file-level error has been reported. Sema should terminate semantic analysis. operand and small are ignored. This instruction is always noreturn, however, it is not considered as such by ZIR-level queries. This allows AstGen to assume that any code may have gone here, avoiding false-positive "unreachable code" errors.

float_op_result_ty

Given a type, strips away any error unions or optionals stacked on top and returns the base type. That base type must be a float. For example: Provided with error{Foo}!?f64, returns f64. operand is payload index to UnNode.

std.zig.Zir.Inst.Extended.InstData

container

Source line 2190

Fields

opcode: Extended
small: u16
operand: u32

std.zig.Zir.Inst.Field

container

Source line 3476

Fields

lhs: Ref
field_name_start: NullTerminatedString

Offset into string_bytes.

std.zig.Zir.Inst.FieldCall

container

Source line 3117

Stored inside extra, with trailing arguments according to args_len. Implicit 0. arg_0_start: u32, // always same as args_len

  1. arg_end: u32, // for each args_len arg_N_start is the same as arg_N-1_end

Fields

flags: Call.Flags
obj_ptr: Ref
field_name_start: NullTerminatedString

Offset into string_bytes.

std.zig.Zir.Inst.FieldNamed

container

Source line 3482

Fields

lhs: Ref
field_name: Ref

std.zig.Zir.Inst.FieldParentPtr

container

Source line 3899

Fields

src_node: Ast.Node.Offset
parent_ptr_type: Ref
field_name: Ref
field_ptr: Ref

std.zig.Zir.Inst.FieldType

container

Source line 3848

Fields

container_type: Ref
name_start: NullTerminatedString

Offset into string_bytes, null terminated.

std.zig.Zir.Inst.FieldTypeRef

container

Source line 3854

Fields

container_type: Ref
field_name: Ref

std.zig.Zir.Inst.Float128

container

Source line 3796

A f128 value, broken up into 4 u32 parts.

Fields

piece0: u32
piece1: u32
piece2: u32
piece3: u32

std.zig.Zir.Inst.Float128.get

function

Source line 3802

pub fn get(self: Float128) f128

Parameters

self: Float128

std.zig.Zir.Inst.FullPtrCastFlags

container

Source line 3608

Fields

ptr_cast: bool = false
align_cast: bool = false
addrspace_cast: bool = false
const_cast: bool = false
volatile_cast: bool = false

std.zig.Zir.Inst.FullPtrCastFlags.needResultTypeBuiltinName

function

Source line 3615

pub inline fn needResultTypeBuiltinName(flags: FullPtrCastFlags) []const u8

Parameters

std.zig.Zir.Inst.Func

container

Source line 2614

Trailing: if (ret_ty.body_len == 1) {

  1. return_type: Ref } if (ret_ty.body_len > 1) {
  2. return_type: Index // for each ret_ty.body_len }
  3. body: Index // for each body_len
  4. src_locs: SrcLocs // if body_len != 0
  5. proto_hash: std.zig.SrcHash // if body_len != 0; hash of function prototype

Fields

ret_ty: RetTy
param_block: Index

Points to the block that contains the param instructions for this function. If this is a declaration, it refers to the declaration's value body.

body_len: u32

std.zig.Zir.Inst.Func.RetTy

container

Source line 2621

Fields

body_len: u31

0 means void. 1 means the type is a simple Ref. Otherwise, the length of a trailing body.

is_generic: bool

Whether the return type is generic, i.e. refers to one or more previous parameters.

std.zig.Zir.Inst.Func.SrcLocs

container

Source line 2630

Fields

lbrace_line: u32

Line index in the source file relative to the parent decl.

rbrace_line: u32

Line index in the source file relative to the parent decl.

columns: u32

lbrace_column is least significant bits u16 rbrace_column is most significant bits u16

std.zig.Zir.Inst.FuncFancy

container

Source line 2661

Trailing: if (has_cc_ref and !has_cc_body) {

  1. cc: Ref, } if (has_cc_body) {
  2. cc_body_len: u32
  3. cc_body: u32 // for each cc_body_len } if (has_ret_ty_ref and !has_ret_ty_body) {
  4. ret_ty: Ref, } if (has_ret_ty_body) {
  5. ret_ty_body_len: u32
  6. ret_ty_body: u32 // for each ret_ty_body_len }
  7. noalias_bits: u32 // if has_any_noalias
    • each bit starting with LSB corresponds to parameter indexes
  8. body: Index // for each body_len
  9. src_locs: Func.SrcLocs // if body_len != 0
  10. proto_hash: std.zig.SrcHash // if body_len != 0; hash of function prototype

Fields

param_block: Index

Points to the block that contains the param instructions for this function. If this is a declaration, it refers to the declaration's value body.

body_len: u32
bits: Bits

std.zig.Zir.Inst.FuncFancy.Bits

container

Source line 2670

If both has_cc_ref and has_cc_body are false, it means auto calling convention. If both has_ret_ty_ref and has_ret_ty_body are false, it means void return type.

Fields

is_var_args: bool
is_inferred_error: bool
is_noinline: bool
has_cc_ref: bool
has_cc_body: bool
has_ret_ty_ref: bool
has_ret_ty_body: bool
has_any_noalias: bool
ret_ty_is_generic: bool
_: u23 = 0

std.zig.Zir.Inst.Import

container

Source line 4026

Fields

res_ty: Ref

The result type of the import, or .none if none was available.

path: NullTerminatedString

The import path.

std.zig.Zir.Inst.Imports

container

Source line 3982

Trailing: for each imports_len there is an Item

Fields

imports_len: u32

std.zig.Zir.Inst.Imports.Item

container

Source line 3985

Fields

name: NullTerminatedString

null terminated string index

token: Ast.TokenIndex

points to the import name

std.zig.Zir.Inst.Index

container

Source line 2198

The position of a ZIR instruction within the Zir instructions array.

Fields

main_struct_inst = 0

ZIR is structured so that the outermost "main" struct of any file is always at index 0.

_

std.zig.Zir.Inst.Index.toOptional

function

Source line 2208

pub fn toOptional(i: Index) OptionalIndex

Parameters

i: Index

std.zig.Zir.Inst.Index.toRef

function

Source line 2204

pub fn toRef(i: Index) Inst.Ref

Parameters

i: Index

std.zig.Zir.Inst.InplaceOp

container

Source line 3649

Fields

add_eq
sub_eq

std.zig.Zir.Inst.LineColumn

container

Source line 3993

Fields

line: u32
column: u32

std.zig.Zir.Inst.MulAdd

container

Source line 3893

Fields

mulend1: Ref
mulend2: Ref
addend: Ref

std.zig.Zir.Inst.MultiOp

container

Source line 2686

This data is stored inside extra, with trailing operands according to operands_len. Each operand is a Ref.

Fields

operands_len: u32

std.zig.Zir.Inst.NameStrategy

container

Source line 3594

Fields

parent

Use the same name as the parent declaration name. e.g. const Foo = struct {...};.

func

Use the name of the currently executing comptime function call, with the current parameters. e.g. ArrayList(i32).

anon

Create an anonymous name for this declaration. Like this: "ParentDeclName_struct_69"

dbg_var

Use the name specified in the next dbg_var_{val,ptr} instruction.

std.zig.Zir.Inst.NodeMultiOp

container

Source line 2691

Trailing: operand: Ref, // for each operands_len (stored in small).

Fields

src_node: Ast.Node.Offset

std.zig.Zir.Inst.OpaqueDecl

container

Source line 3766

Trailing:

  1. captures_len: u32, // if has_captures_len
  2. decls_len: u32, // if has_decls_len
  3. capture: Capture, // for every captures_len
  4. capture_name: NullTerminatedString // for every captures_len
  5. decl: Index, // for every decls_len; points to a declaration instruction

Fields

src_line: u32
src_column: u32
src_node: Ast.Node.Index

This node provides a new absolute baseline node for all instructions within this struct.

std.zig.Zir.Inst.OpaqueDecl.Small

container

Source line 3772

Fields

has_captures_len: bool
has_decls_len: bool
name_strategy: NameStrategy
_: u12 = 0

std.zig.Zir.Inst.OptionalIndex

container

Source line 2213

Fields

main_struct_inst = 0

ZIR is structured so that the outermost "main" struct of any file is always at index 0.

none = std.math.maxInt(u32)
_

std.zig.Zir.Inst.OptionalIndex.unwrap

function

Source line 2220

pub fn unwrap(oi: OptionalIndex) ?Index

Parameters

std.zig.Zir.Inst.Param

container

Source line 3922

Trailing: inst: Index // for every body_len

Fields

name: NullTerminatedString

Null-terminated string index.

type: Type

std.zig.Zir.Inst.Param.Type

container

Source line 3927

Fields

body_len: u31

The body contains the type of the parameter.

is_generic: bool

Whether the type is generic, i.e. refers to one or more previous parameters.

std.zig.Zir.Inst.PtrType

container

Source line 3179

Stored in extra. Depending on the flags in Data, there will be up to 5 trailing Ref fields:

  1. sentinel: Ref // if has_sentinel flag is set
  2. align: Ref // if has_align flag is set
  3. address_space: Ref // if has_addrspace flag is set
  4. bit_start: Ref // if has_bit_range flag is set
  5. host_size: Ref // if has_bit_range flag is set

Fields

elem_type: Ref
src_node: Ast.Node.Offset

std.zig.Zir.Inst.Ref

container

Source line 2233

A reference to ZIR instruction, or to an InternPool index, or neither.

If the integer tag value is < InternPool.static_len, then it corresponds to an InternPool index. Otherwise, this refers to a ZIR instruction.

The tag type is specified so that it is safe to bitcast between []u32 and []Ref.

Fields

u0_type
u1_type
u8_type
i8_type
u16_type
i16_type
u29_type
u32_type
i32_type
u64_type
i64_type
u80_type
u128_type
i128_type
u256_type
usize_type
isize_type
c_char_type
c_short_type
c_ushort_type
c_int_type
c_uint_type
c_long_type
c_ulong_type
c_longlong_type
c_ulonglong_type
c_longdouble_type
f16_type
f32_type
f64_type
f80_type
f128_type
anyopaque_type
bool_type
void_type
type_type
anyerror_type
comptime_int_type
comptime_float_type
noreturn_type
anyframe_type
null_type
undefined_type
enum_literal_type
ptr_usize_type
ptr_const_comptime_int_type
manyptr_u8_type
manyptr_const_u8_type
manyptr_const_u8_sentinel_0_type
slice_const_u8_type
slice_const_u8_sentinel_0_type
manyptr_const_slice_const_u8_type
slice_const_slice_const_u8_type
optional_type_type
manyptr_const_type_type
slice_const_type_type
vector_8_i8_type
vector_16_i8_type
vector_32_i8_type
vector_64_i8_type
vector_1_u8_type
vector_2_u8_type
vector_4_u8_type
vector_8_u8_type
vector_16_u8_type
vector_32_u8_type
vector_64_u8_type
vector_2_i16_type
vector_4_i16_type
vector_8_i16_type
vector_16_i16_type
vector_32_i16_type
vector_4_u16_type
vector_8_u16_type
vector_16_u16_type
vector_32_u16_type
vector_2_i32_type
vector_4_i32_type
vector_8_i32_type
vector_16_i32_type
vector_4_u32_type
vector_8_u32_type
vector_16_u32_type
vector_2_i64_type
vector_4_i64_type
vector_8_i64_type
vector_2_u64_type
vector_4_u64_type
vector_8_u64_type
vector_1_u128_type
vector_2_u128_type
vector_1_u256_type
vector_4_f16_type
vector_8_f16_type
vector_16_f16_type
vector_32_f16_type
vector_2_f32_type
vector_4_f32_type
vector_8_f32_type
vector_16_f32_type
vector_2_f64_type
vector_4_f64_type
vector_8_f64_type
optional_noreturn_type
anyerror_void_error_union_type
adhoc_inferred_error_set_type
generic_poison_type
empty_tuple_type
undef
undef_bool
undef_usize
undef_u1
zero
zero_usize
zero_u1
zero_u8
one
one_usize
one_u1
one_u8
four_u8
negative_one
void_value
unreachable_value
null_value
bool_true
bool_false
empty_tuple
none = std.math.maxInt(u32)

This Ref does not correspond to any ZIR instruction or constant value and may instead be used as a sentinel to indicate null.

_

std.zig.Zir.Inst.Ref.static_len

constant

Source line 2369

std.zig.Zir.Inst.Ref.toIndex

function

Source line 2371

pub fn toIndex(inst: Ref) ?Index

Parameters

inst: Ref

std.zig.Zir.Inst.Ref.toIndexAllowNone

function

Source line 2381

pub fn toIndexAllowNone(inst: Ref) ?Index

Parameters

inst: Ref

std.zig.Zir.Inst.ReifyEnum

container

Source line 3304

Fields

src_line: u32
src_column: u32
node: Ast.Node.Index

This node is absolute, because reify instructions are tracked across updates, and this simplifies the logic for getting source locations for types.

tag_ty: Ref
mode: Ref
field_names: Ref
field_values: Ref

std.zig.Zir.Inst.ReifyFn

container

Source line 3270

Fields

node: Ast.Node.Offset
param_types: Ref
param_attrs: Ref
ret_ty: Ref
fn_attrs: Ref

std.zig.Zir.Inst.ReifyPointer

container

Source line 3262

Fields

node: Ast.Node.Offset
size: Ref
attrs: Ref
elem_ty: Ref
sentinel: Ref

std.zig.Zir.Inst.ReifySliceArgInfo

container

Source line 3228

Fields

type_to_fn_param_attrs

Input element type is type. Output element type is std.lang.Type.Fn.ParamAttributes.

string_to_struct_field_type

Input element type is []const u8. Output element type is type.

string_to_union_field_type

Identical to string_to_struct_field_type aside from emitting slightly different error messages.

string_to_struct_field_attrs

Input element type is []const u8. Output element type is std.lang.Type.Struct.FieldAttributes.

string_to_union_field_attrs

Input element type is []const u8. Output element type is std.lang.Type.Union.FieldAttributes.

std.zig.Zir.Inst.ReifySpirvType

container

Source line 3316

Fields

src_line: u32
src_column: u32
node: Ast.Node.Index

This node is absolute, because reify instructions are tracked across updates, and this simplifies the logic for getting source locations for types.

operand: Ref

std.zig.Zir.Inst.ReifyStruct

container

Source line 3278

Fields

src_line: u32
src_column: u32
node: Ast.Node.Index

This node is absolute, because reify instructions are tracked across updates, and this simplifies the logic for getting source locations for types.

layout: Ref
backing_ty: Ref
field_names: Ref
field_types: Ref
field_attrs: Ref

std.zig.Zir.Inst.ReifyUnion

container

Source line 3291

Fields

src_line: u32
src_column: u32
node: Ast.Node.Index

This node is absolute, because reify instructions are tracked across updates, and this simplifies the logic for getting source locations for types.

layout: Ref
arg_ty: Ref
field_names: Ref
field_types: Ref
field_attrs: Ref

std.zig.Zir.Inst.RestoreErrRetIndex

container

Source line 4018

Fields

src_node: Ast.Node.Offset
block: Ref

If .none, restore the trace to its state upon function entry.

operand: Ref

If .none, restore unconditionally.

std.zig.Zir.Inst.RoundOp

container

Source line 3245

Fields

round
floor
ceil
trunc

std.zig.Zir.Inst.Select

container

Source line 3913

Fields

node: Ast.Node.Offset
elem_type: Ref
pred: Ref
a: Ref
b: Ref

std.zig.Zir.Inst.Shuffle

container

Source line 3906

Fields

elem_type: Ref
a: Ref
b: Ref
mask: Ref

std.zig.Zir.Inst.SliceEnd

container

Source line 3195

Fields

lhs: Ref
start: Ref
end: Ref

std.zig.Zir.Inst.SliceLength

container

Source line 3208

Fields

lhs: Ref
start: Ref
len: Ref
sentinel: Ref
start_src_node_offset: Ast.Node.Offset

std.zig.Zir.Inst.SliceSentinel

container

Source line 3201

Fields

lhs: Ref
start: Ref
end: Ref
sentinel: Ref

std.zig.Zir.Inst.SliceStart

container

Source line 3190

Fields

lhs: Ref
start: Ref

std.zig.Zir.Inst.Src

container

Source line 4003

Fields

node: Ast.Node.Offset
line: u32
column: u32

std.zig.Zir.Inst.StdLangValue

container

Source line 3623

Fields

atomic_order
atomic_rmw_op
calling_convention
address_space
float_mode
signedness
reduce_op
call_modifier
prefetch_options
export_options
extern_options
branch_hint
clobbers
pointer_size
pointer_attributes
fn_attributes
container_layout
enum_mode
spirv_type_options
calling_convention_c
calling_convention_inline

std.zig.Zir.Inst.StructDecl

container

Source line 3510

Trailing:

  1. captures_len: u32 // if has_captures_len
  2. decls_len: u32, // if has_decls_len
  3. fields_len: u32, // if has_fields_len
  4. arg_baseline_src_node: Ast.Node.Index // if has_backing_int
  5. fields_baseline_src_node: Ast.Node.Index // if has_fields_len
  6. backing_int_body_len: u32 // if has_backing_int
  7. capture: Capture // for every captures_len
  8. capture_name: NullTerminatedString // for every captures_len
  9. decl: Index, // for every decls_len; points to a declaration instruction
  10. field_name: NullTerminatedString // for every fields_len
  11. field_type_body_len: u32 // for every fields_len
  12. field_align_body_len: u32 // for every fields_len if any_field_aligns
  13. field_default_body_len: u32 // for every fields_len if any_field_defaults
  14. field_comptime_bits: u32 // one bit per fields_len if any_comptime_fields // LSB is first field, minimum number of u32 needed
  15. backing_int_body_inst: Inst.Index // for each backing_int_body_len
  16. body_inst: Inst.Index // type body, then align body, then default body, for each field

Fields

fields_hash_0: u32
fields_hash_1: u32
fields_hash_2: u32
fields_hash_3: u32
src_line: u32
src_column: u32
src_node: Ast.Node.Index

This node provides a new absolute baseline node for all instructions within this struct.

std.zig.Zir.Inst.StructDecl.Small

container

Source line 3522

Fields

has_captures_len: bool
has_decls_len: bool
has_fields_len: bool
name_strategy: NameStrategy
layout: std.lang.Type.ContainerLayout
has_backing_int_type: bool

Always false if layout != .@"packed".

any_field_aligns: bool
any_field_defaults: bool
any_comptime_fields: bool
_: u5 = 0

std.zig.Zir.Inst.StructInit

container

Source line 3812

Trailing is an item per field.

Fields

abs_node: Ast.Node.Index

If this is an anonymous initialization (the operand is poison), this instruction becomes the owner of a type. To resolve source locations, we need an absolute source node.

src_line: u32
src_column: u32
fields_len: u32

std.zig.Zir.Inst.StructInit.Item

container

Source line 3820

Fields

field_type: Index

The struct_init_field_type ZIR instruction for this field init.

init: Ref

The field init expression to be used as the field value. This value will be coerced to the field type if not already.

std.zig.Zir.Inst.StructInitAnon

container

Source line 3832

Trailing is an Item per field. TODO make this instead array of inits followed by array of names because it will be simpler Sema code and better for CPU cache.

Fields

abs_node: Ast.Node.Index

This is an anonymous initialization, meaning this instruction becomes the owner of a type. To resolve source locations, we need an absolute source node.

src_line: u32
src_column: u32
fields_len: u32

std.zig.Zir.Inst.StructInitAnon.Item

container

Source line 3840

Fields

field_name: NullTerminatedString

Null-terminated string table index.

init: Ref

The field init expression to be used as the field value.

std.zig.Zir.Inst.SwitchBlock

container

Source line 3372

Trailing:

  1. multi_cases_len: u32, // If has_multi_cases is set.
  2. payload_capture_placeholder: Inst.Index, // If payload_capture_inst_is_placeholder is set. // Index of instruction prongs use to refer to their payload capture.
  3. tag_capture_placeholder: Inst.Index, // If tag_capture_inst_is_placeholder is set. // Index of instruction prongs use to refer to their tag capture.
  4. catch_or_if_src_node_offset: Ast.Node.Offset, // If inst is switch_block_err_union.
  5. non_err_info: ProngInfo.NonErr, // If inst is switch_block_err_union.
  6. else_info: ProngInfo.Else, // If has_else is set.
  7. scalar_prong_info: ProngInfo, // for every scalar_cases_len
  8. multi_prong_info: ProngInfo, // for every multi_cases_len
  9. multi_case_items_len: u32, // for every multi_cases_len
  10. multi_case_ranges_len: u32, // If has_ranges is set: for every multi_cases_len
  11. scalar_item_info: ItemInfo, // for every scalar_cases_len
  12. multi_items_info: { // for every multi_cases_len item_info: ItemInfo, // for each multi_case_items_len range_items_info: { // for each multi_case_ranges_len first_info: ItemInfo, last_info: ItemInfo, } }
  13. non_err_body { body_inst: Index // for every non_err_info.body_len }
  14. else_body: { // If has_else is set. body_inst: Inst.Index, // for every else_info.body_len }
  15. scalar_bodies: { // for every scalar_cases_len prong_body: { // for each body_len in scalar_prong_info body_inst: Inst.Index, // for every body_len } item_body: { // for each body_len in scalar_item_info body_inst: Inst.Index, // for every body_len } }
  16. multi_bodies: { // for each multi_items_info prong_body: { body_inst: Inst.Index, // for each multi_prong_info.body_len } item_body: { // for each item_info body_inst: Inst.Index, // for every item_info.body_len } range_bodies: { // for each .{first_info, last_info} in range_items_info first_body_inst: Inst.Index, // for every first_info.body_len last_body_inst: Inst.Index, // for every last_info.body_len } }

Fields

raw_operand: Ref

Either catch/if or switch operand.

bits: Bits

std.zig.Zir.Inst.SwitchBlock.Bits

container

Source line 3377

Fields

has_multi_cases: bool

If true, one or more prongs have multiple items.

any_ranges: bool

If true, one or more prongs have ranges. Only valid if has_multi_cases is also set.

has_else: bool
has_under: bool
has_continue: bool

If true, at least one prong contains a continue. Only valid if has_label is set.

any_maybe_runtime_capture: bool
payload_capture_inst_is_placeholder: bool
tag_capture_inst_is_placeholder: bool
scalar_cases_len: ScalarCasesLen

std.zig.Zir.Inst.SwitchBlock.Bits.ScalarCasesLen

type

Source line 3397

std.zig.Zir.Inst.SwitchBlock.ItemInfo

container

Source line 3428

Fields

kind: ItemInfo.Kind
data: u30

std.zig.Zir.Inst.SwitchBlock.ItemInfo.bodyLen

function

Source line 3465

pub fn bodyLen(item_info: ItemInfo) ?u32

Parameters

item_info: ItemInfo

std.zig.Zir.Inst.SwitchBlock.ItemInfo.Kind

container

Source line 3432

Fields

enum_literal
error_value
body_len
under

std.zig.Zir.Inst.SwitchBlock.ItemInfo.unwrap

function

Source line 3456

pub fn unwrap(item_info: ItemInfo) ItemInfo.Unwrapped

Parameters

item_info: ItemInfo

std.zig.Zir.Inst.SwitchBlock.ItemInfo.Unwrapped

container

Source line 3439

Fields

enum_literal: Zir.NullTerminatedString
error_value: Zir.NullTerminatedString
body_len: u32
under

std.zig.Zir.Inst.SwitchBlock.ItemInfo.wrap

function

Source line 3446

pub fn wrap(unwrapped: ItemInfo.Unwrapped) ItemInfo

Parameters

unwrapped: ItemInfo.Unwrapped

std.zig.Zir.Inst.SwitchBlock.ProngInfo

container

Source line 3400

Fields

body_len: u27
capture: ProngInfo.Capture
is_inline: bool
has_tag_capture: bool
is_comptime_unreach: bool

std.zig.Zir.Inst.SwitchBlock.ProngInfo.Capture

container

Source line 3407

Fields

none
by_val
by_ref

std.zig.Zir.Inst.SwitchBlock.ProngInfo.Else

container

Source line 3419

Fields

body_len: u27
capture: ProngInfo.Capture
is_inline: bool
has_tag_capture: bool
is_simple_noreturn: bool

std.zig.Zir.Inst.SwitchBlock.ProngInfo.NonErr

container

Source line 3413

Fields

body_len: u29
capture: ProngInfo.Capture
operand_is_ref: bool

std.zig.Zir.Inst.Tag

container

Source line 167

These names are used directly as the instruction names in the text format. See data_field_map for a list of which Data fields are used by each Tag.

Fields

add

Arithmetic addition, asserts no integer overflow. Uses the pl_node union field. Payload is Bin.

addwrap

Twos complement wrapping integer addition. Uses the pl_node union field. Payload is Bin.

add_sat

Saturating addition. Uses the pl_node union field. Payload is Bin.

add_unsafe

The same as add except no safety check.

sub

Arithmetic subtraction. Asserts no integer overflow. Uses the pl_node union field. Payload is Bin.

subwrap

Twos complement wrapping integer subtraction. Uses the pl_node union field. Payload is Bin.

sub_sat

Saturating subtraction. Uses the pl_node union field. Payload is Bin.

mul

Arithmetic multiplication. Asserts no integer overflow. Uses the pl_node union field. Payload is Bin.

mulwrap

Twos complement wrapping integer multiplication. Uses the pl_node union field. Payload is Bin.

mul_sat

Saturating multiplication. Uses the pl_node union field. Payload is Bin.

div_exact

Implements the @divExact builtin. Uses the pl_node union field with payload Bin.

div_floor

Implements the @divFloor builtin. Uses the pl_node union field with payload Bin.

div_ceil

Implements the @divCeil builtin. Uses the pl_node union field with payload Bin.

div_trunc

Implements the @divTrunc builtin. Uses the pl_node union field with payload Bin.

mod

Implements the @mod builtin. Uses the pl_node union field with payload Bin.

rem

Implements the @rem builtin. Uses the pl_node union field with payload Bin.

mod_rem

Ambiguously remainder division or modulus. If the computation would possibly have a different value depending on whether the operation is remainder division or modulus, a compile error is emitted. Otherwise the computation is performed. Uses the pl_node union field. Payload is Bin.

shl

Integer shift-left. Zeroes are shifted in from the right hand side. Uses the pl_node union field. Payload is Bin.

shl_exact

Implements the @shlExact builtin. Uses the pl_node union field with payload Bin.

shl_sat

Saturating shift-left. Uses the pl_node union field. Payload is Bin.

shr

Integer shift-right. Arithmetic or logical depending on the signedness of the integer type. Uses the pl_node union field. Payload is Bin.

shr_exact

Implements the @shrExact builtin. Uses the pl_node union field with payload Bin.

param

Declares a parameter of the current function. Used for:

  • debug info
  • checking shadowing against declarations in the current namespace
  • parameter type expressions referencing other parameters These occur in the block outside a function body (the same block as contains the func instruction). Uses the pl_tok field. Token is the parameter name, payload is a Param.
param_comptime

Same as param except the parameter is marked comptime.

param_anytype

Same as param except the parameter is marked anytype. Uses the str_tok field. Token is the parameter name. String is the parameter name.

param_anytype_comptime

Same as param except the parameter is marked both comptime and anytype. Uses the str_tok field. Token is the parameter name. String is the parameter name.

array_cat

Array concatenation. a ++ b Uses the pl_node union field. Payload is Bin.

array_type

[N]T syntax. No source location provided. Uses the pl_node union field. Payload is Bin. lhs is length, rhs is element type.

array_type_sentinel

[N:S]T syntax. Source location is the array type expression node. Uses the pl_node union field. Payload is ArrayTypeSentinel.

reify_int

@Int builtin. Uses the pl_node union field with Bin payload. lhs is signedness, rhs is bit count.

vector_type

@Vector builtin. Uses the pl_node union field with Bin payload. lhs is length, rhs is element type.

elem_type

Given a pointer type, returns its element type. Reaches through any optional or error union types wrapping the pointer. Asserts that the underlying type is a pointer type. Returns generic poison if the element type is anyopaque. Uses the un_node field.

indexable_ptr_elem_type

Given an indexable pointer (slice, many-ptr, single-ptr-to-array), returns its element type. Emits a compile error if the type is not an indexable pointer. Uses the un_node field.

splat_op_result_ty

Given a vector or array type, strips off any error unions or optionals layered on top and returns its element type.

!?[N]T -> T

Uses the un_node field.

from_backing_int_arg_ty

Given a type, strips away any error unions or optionals stacked on top, validates it for usage with @fromBackingInt and returns its backing integer type.

E!?enum(T) { _ } -> T

Uses the un_node field.

indexable_ptr_len

Given a pointer to an indexable object, returns the len property. This is used by for loops. This instruction also emits a for-loop specific compile error if the indexable object is not indexable. Uses the un_node field. The AST node is the for loop node.

anyframe_type

Create a anyframe->T type. Uses the un_node field.

as_node

Type coercion to the function's return type. Uses the pl_node field. Payload is As. AST node could be many things.

as_shift_operand

Same as as_node but ignores runtime to comptime int error.

bit_and

Bitwise AND. &

bitcast

Reinterpret the memory representation of a value as a different type. Uses the pl_node field with payload Bin.

bit_not

Bitwise NOT. ~ Uses un_node.

bit_or

Bitwise OR. |

block

A labeled block of code, which can return a value. Uses the pl_node union field. Payload is Block.

block_comptime

Like block, but forces full evaluation of its contents at compile-time. Exited with break_inline. Uses the pl_node union field. Payload is BlockComptime.

block_inline

A list of instructions which are analyzed in the parent context, without generating a runtime block. Must terminate with an "inline" variant of a noreturn instruction. Uses the pl_node union field. Payload is Block.

declaration

This instruction may only ever appear in the list of declarations for a namespace type, e.g. within a struct_decl instruction. It represents a single source declaration (const/var/fn), containing the name, attributes, type, and value of the declaration. Uses the declaration union field. Payload is Declaration.

suspend_block

Implements suspend {...}. Uses the pl_node union field. Payload is Block.

bool_not

Boolean NOT. See also bit_not. Uses the un_node field.

bool_br_and

Short-circuiting boolean and. lhs is a boolean Ref and the other operand is a block, which is evaluated if lhs is true. Uses the pl_node union field. Payload is BoolBr.

bool_br_or

Short-circuiting boolean or. lhs is a boolean Ref and the other operand is a block, which is evaluated if lhs is false. Uses the pl_node union field. Payload is BoolBr.

@"break"

Return a value from a block. Uses the break union field. Uses the source information from previous instruction.

break_inline

Return a value from a block. This instruction is used as the terminator of a block_inline. It allows using the return value from Sema.analyzeBody. This instruction may also be used when it is known that there is only one break instruction in a block, and the target block is the parent. Uses the break union field.

switch_continue

Branch from within a switch case to the case specified by the operand. Uses the break union field. block_inst refers to a switch_block/ switch_block_ref/switch_block_err_union.

check_comptime_control_flow

Checks that comptime control flow does not happen inside a runtime block. Uses the un_node union field.

call

Function call. Uses the pl_node union field with payload Call. AST node is the function call.

field_call

Function call using a.b() syntax. Uses the named field as the callee. If there is no such field, searches in the type for a decl matching the field name. The decl is resolved and we ensure that it's a function which can accept the object as the first parameter, with one pointer fixup. This function is then used as the callee, with the object as an implicit first parameter. Uses the pl_node union field with payload FieldCall. AST node is the function call.

builtin_call

Implements the @call builtin. Uses the pl_node union field with payload BuiltinCall. AST node is the builtin call.

cmp_lt

< Uses the pl_node union field. Payload is Bin.

cmp_lte

<= Uses the pl_node union field. Payload is Bin.

cmp_eq

== Uses the pl_node union field. Payload is Bin.

cmp_gte

>= Uses the pl_node union field. Payload is Bin.

cmp_gt

> Uses the pl_node union field. Payload is Bin.

cmp_neq

!= Uses the pl_node union field. Payload is Bin.

condbr

Conditional branch. Splits control flow based on a boolean condition value. Uses the pl_node union field. AST node is an if, while, for, etc. Payload is CondBr.

condbr_inline

Same as condbr, except the condition is coerced to a comptime value, and only the taken branch is analyzed. The then block and else block must terminate with an "inline" variant of a noreturn instruction.

@"try"

Given an operand which is an error union, splits control flow. In case of error, control flow goes into the block that is part of this instruction, which is guaranteed to end with a return instruction and never breaks out of the block. In the case of non-error, control flow proceeds to the next instruction after the try, with the result of this instruction being the unwrapped payload value, as if err_union_payload_unsafe was executed on the operand. Uses the pl_node union field. Payload is Try.

try_ptr

Same as try except the operand is a pointer and the result is a pointer.

error_set_decl

An error set type definition. Contains a list of field names. Uses the pl_node union field. Payload is ErrorSetDecl.

dbg_stmt

Declares the beginning of a statement. Used for debug info. Uses the dbg_stmt union field. The line and column are offset from the parent declaration.

dbg_var_ptr

Marks a variable declaration. Used for debug info. Uses the str_op union field. The string is the local variable name, and the operand is the pointer to the variable's location. The local may be a const or a var.

dbg_var_val

Same as dbg_var_ptr but the local is always a const and the operand is the local's value.

decl_ref

Uses a name to identify a Decl and takes a pointer to it.

Uses the str_tok union field.

decl_val

Uses a name to identify a Decl and uses it as a value. Uses the str_tok union field.

load

Load the value from a pointer. Assumes x.* syntax. Uses un_node field. AST node is the x.* syntax.

div

Arithmetic division. Asserts no integer overflow. Uses the pl_node union field. Payload is Bin.

elem_ptr_node

Given a pointer to an array, slice, or pointer, returns a pointer to the element at the provided index. Uses the pl_node union field. AST node is a[b] syntax. Payload is Bin.

elem_ptr

Same as elem_ptr_node but used only for for loop. Uses the pl_node union field. AST node is the condition of a for loop. Payload is Bin. No OOB safety check is emitted.

elem_ptr_load

Given a pointer to an array, slice, or pointer, loads the element at the provided index.

Uses the pl_node union field. AST node is a[b] syntax. Payload is Bin.

elem_val

Given an array, slice, or pointer, returns the element at the provided index.

Uses the pl_node union field. AST node is the condition of a for loop. Payload is Bin.

No OOB safety check is emitted.

elem_val_imm

Same as elem_val but takes the index as an immediate value. No OOB safety check is emitted. A prior instruction must validate this operation. Uses the elem_val_imm union field.

ensure_result_used

Emits a compile error if the operand is not void. Uses the un_node field.

ensure_result_non_error

Emits a compile error if an error is ignored. Uses the un_node field.

ensure_err_union_payload_void

Emits a compile error error union payload is not void.

error_union_type

Create a E!T type. Uses the pl_node field with Bin payload.

error_value

error.Foo syntax. Uses the str_tok field of the Data union.

@"export"

Implements the @export builtin function. Uses the pl_node union field. Payload is Export.

field_ptr

Given a pointer to a struct or object that contains virtual fields, returns a pointer to the named field. The field name is stored in string_bytes. Used by a.b syntax. Uses pl_node field. The AST node is the a.b syntax. Payload is Field.

field_ptr_load

Given a pointer to a struct or object that contains virtual fields, loads from the named field.

The field name is stored in string_bytes. Used by a.b syntax.

This instruction also accepts a pointer.

Uses pl_node field. The AST node is the a.b syntax. Payload is Field.

field_ptr_named

Given a pointer to a struct or object that contains virtual fields, returns a pointer to the named field. The field name is a comptime instruction. Used by @field. Uses pl_node field. The AST node is the builtin call. Payload is FieldNamed.

field_ptr_named_load

Given a pointer to a struct or object that contains virtual fields, loads from the named field.

The field name is a comptime instruction. Used by @field.

Uses pl_node field. The AST node is the builtin call. Payload is FieldNamed.

func

Returns a function type, or a function instance, depending on whether the body_len is 0. Calling convention is auto. Uses the pl_node union field. payload_index points to a Func.

func_inferred

Same as func but has an inferred error set.

func_fancy

Represents a function declaration or function prototype, depending on whether body_len is 0. Uses the pl_node union field. payload_index points to a FuncFancy.

import

Implements the @import builtin. Uses the pl_tok field.

int

Integer literal that fits in a u64. Uses the int union field.

int_big

Arbitrary sized integer literal. Uses the str union field.

float

A float literal that fits in a f64. Uses the float union value.

float128

A float literal that fits in a f128. Uses the pl_node union value. Payload is Float128.

int_type

Make an integer type out of signedness and bit count. Payload is int_type

is_non_null

Return a boolean false if an optional is null. x != null Uses the un_node field.

is_non_null_ptr

Return a boolean false if an optional is null. x.* != null Uses the un_node field.

is_non_err

Return a boolean false if value is an error Uses the un_node field.

is_non_err_ptr

Return a boolean false if dereferenced pointer is an error Uses the un_node field.

ret_is_non_err

Same as is_non_er but doesn't validate that the type can be an error. Uses the un_node field.

loop

A labeled block of code that loops forever. At the end of the body will have either a repeat instruction or a repeat_inline instruction. Uses the pl_node field. The AST node is either a for loop or while loop. This ZIR instruction is needed because AIR does not (yet?) match ZIR, and Sema needs to emit more than 1 AIR block for this instruction. The payload is Block.

repeat

Sends runtime control flow back to the beginning of the current block. Uses the node field.

repeat_inline

Sends comptime control flow back to the beginning of the current block. Uses the node field.

for_len

Asserts that all the lengths provided match. Used to build a for loop. Return value is the length as a usize. Uses the pl_node field with payload MultiOp. There are two items for each AST node inside the for loop condition. If both items in a pair are .none, then this node is an unbounded range. If only the second item in a pair is .none, then the first is an indexable. Otherwise, the node is a bounded range a..b, with the items being a and b. Illegal behaviors:

  • If all lengths are unbounded ranges (always a compile error).
  • If any two lengths do not match each other.
merge_error_sets

Merge two error sets into one, E1 || E2. Uses the pl_node field with payload Bin.

ref

Turns an R-Value into a const L-Value. In other words, it takes a value, stores it in a memory location, and returns a const single-item pointer to it. If the value is comptime, the memory location is global static constant data. Otherwise, the memory location is in the stack frame, local to the scope containing the instruction. Uses the un_tok union field.

deref

Implements the dereference operator (.*). Checks that operand is a pointer that supports being directly dereferenced. Uses the un_node union field.

ref_deref

Emitted when a dereference (.*) with a reference result location occurs. Checks that operand is a pointer that supports being directly dereferenced and returns a single-item pointer to the dereferenced memory location. Uses the un_node union field.

ret_node

Sends control flow back to the function's callee. Includes an operand as the return value. Includes an AST node source location. Uses the un_node union field.

ret_load

Sends control flow back to the function's callee. The operand is a ret_ptr instruction, where the return value can be found. Includes an AST node source location. Uses the un_node union field.

ret_implicit

Sends control flow back to the function's callee. Includes an operand as the return value. Includes a token source location. Uses the un_tok union field.

ret_err_value

Sends control flow back to the function's callee. The return operand is error.foo where foo is given by the string. If the current function has an inferred error set, the error given by the name is added to it. Uses the str_tok union field.

ret_ptr

Obtains a pointer to the return value. Uses the node union field.

ret_type

Obtains the return type of the in-scope function. Uses the node union field.

ptr_type

Create a pointer type which can have a sentinel, alignment, address space, and/or bit range. Uses the ptr_type union field.

slice_start

Slice operation lhs[rhs..]. No sentinel and no end offset. Returns a pointer to the subslice. Uses the pl_node field. AST node is the slice syntax. Payload is SliceStart.

slice_end

Slice operation array_ptr[start..end]. No sentinel. Returns a pointer to the subslice. Uses the pl_node field. AST node is the slice syntax. Payload is SliceEnd.

slice_sentinel

Slice operation array_ptr[start..end:sentinel]. Returns a pointer to the subslice. Uses the pl_node field. AST node is the slice syntax. Payload is SliceSentinel.

slice_length

Slice operation array_ptr[start..][0..len]. Optional sentinel. Returns a pointer to the subslice. Uses the pl_node field. AST node is the slice syntax. Payload is SliceLength.

slice_sentinel_ty

Given a value which is a pointer to the LHS of a slice operation, return the sentinel type, used as the result type of the slice sentinel (i.e. s in lhs[a..b :s]). Uses the un_node field. AST node is the slice syntax. Operand is lhs.

store_node

Same as store except provides a source location. Uses the pl_node union field. Payload is Bin.

store_to_inferred_ptr

Same as store_node but the type of the value being stored will be used to infer the pointer type of an alloc_inferred. Uses the pl_node union field. Payload is Bin.

str

String Literal. Makes an anonymous Decl and then takes a pointer to it. Uses the str union field.

negate

Arithmetic negation. Asserts no integer overflow. Same as sub with a lhs of 0, split into a separate instruction to save memory. Uses un_node.

negate_wrap

Twos complement wrapping integer negation. Same as subwrap with a lhs of 0, split into a separate instruction to save memory. Uses un_node.

typeof

Returns the type of a value. Uses the un_node field.

typeof_builtin

Implements @TypeOf for one operand. Uses the pl_node field. Payload is Block.

typeof_log2_int_type

Given a value, look at the type of it, which must be an integer type. Returns the integer type for the RHS of a shift operation. Uses the un_node field.

@"unreachable"

Asserts control-flow will not reach this instruction (unreachable). Uses the @"unreachable" union field.

xor

Bitwise XOR. ^ Uses the pl_node union field. Payload is Bin.

optional_type

Create an optional type '?T' Uses the un_node field.

optional_payload_safe

?T => T with safety. Given an optional value, returns the payload value, with a safety check that the value is non-null. Used for orelse, if and while. Uses the un_node field.

optional_payload_unsafe

?T => T without safety. Given an optional value, returns the payload value. No safety checks. Uses the un_node field.

optional_payload_safe_ptr

*?T => *T with safety. Given a pointer to an optional value, returns a pointer to the payload value, with a safety check that the value is non-null. Used for orelse, if and while. Uses the un_node field.

optional_payload_unsafe_ptr

*?T => *T without safety. Given a pointer to an optional value, returns a pointer to the payload value. No safety checks. Uses the un_node field.

err_union_payload_unsafe

E!T => T without safety. Given an error union value, returns the payload value. No safety checks. Uses the un_node field.

err_union_payload_unsafe_ptr

*E!T => *T without safety. Given a pointer to a error union value, returns a pointer to the payload value. No safety checks. Uses the un_node field.

err_union_code

E!T => E without safety. Given an error union value, returns the error code. No safety checks. Uses the un_node field.

err_union_code_ptr

*E!T => E without safety. Given a pointer to an error union value, returns the error code. No safety checks. Uses the un_node field.

enum_literal

An enum literal. Uses the str_tok union field.

decl_literal

A decl literal. This is similar to field, but unwraps error unions and optionals, and coerces the result to the given type. Uses the pl_node union field. Payload is Field.

decl_literal_no_coerce

The same as decl_literal, but the coercion is omitted. This is used for decl literal function call syntax, i.e. .foo(). Uses the pl_node union field. Payload is Field.

switch_block

A switch expression. Uses the pl_node union field. AST node is the switch, payload is SwitchBlock.

switch_block_ref

A switch expression. Uses the pl_node union field. AST node is the switch, payload is SwitchBlock. Operand is a pointer.

switch_block_err_union

A switch on an error union:

  • eu catch |err| switch (err) {...}, AST node is the catch.
  • if (eu) |payload| {...} else |err| {...}, AST node is the if. Uses the pl_node union field. Payload is SwitchBlock.
validate_destructure

Check that the operand's type is an array or tuple with the given number of elements. Uses the pl_node field. Payload is ValidateDestructure.

field_type_ref

Given a struct or union, and a field name as a Ref, returns the field type. Uses the pl_node field. Payload is FieldTypeRef.

opt_eu_base_ptr_init

Given a pointer, initializes all error unions and optionals in the pointee to payloads, returning the base payload pointer. For instance, converts *E!?T into a valid *T (clobbering any existing error or null value). Uses the un_node field.

coerce_ptr_elem_ty

Coerce a given value such that when a reference is taken, the resulting pointer will be coercible to the given type. For instance, given a value of type 'u32' and the pointer type '*u64', coerces the value to a 'u64'. Asserts that the type is a pointer type. Uses the pl_node field. Payload is Bin. LHS is the pointer type, RHS is the value.

validate_ref_ty

Given a type, validate that it is a pointer type suitable for return from the address-of operator. Emit a compile error if not. Uses the un_tok union field. Token is the & operator. Operand is the type.

validate_const

Given a value, check whether it is a valid local constant in this scope. In a runtime scope, this is always a nop. In a comptime scope, raises a compile error if the value is runtime-known. Result is always void. Uses the un_node union field. Node is the initializer. Operand is the initializer value.

struct_init_empty

A struct literal with a specified explicit type, with no fields. Uses the un_node field.

struct_init_empty_result

An anonymous struct literal with a known result type, with no fields. Uses the un_node field.

struct_init_empty_ref_result

An anonymous struct literal with no fields, returned by reference, with a known result type for the pointer. Asserts that the type is a pointer. Uses the un_node field.

struct_init_anon

Struct initialization without a type. Creates a value of an anonymous struct type. Uses the pl_node field. Payload is StructInitAnon.

struct_init

Finalizes a typed struct or union initialization, performs validation, and returns the struct or union value. The given type must be validated prior to this instruction, using validate_struct_init_ty or validate_struct_init_result_ty. If the given type is generic poison, this is downgraded to an anonymous initialization. Uses the pl_node field. Payload is StructInit.

struct_init_ref

Struct initialization syntax, make the result a pointer. Equivalent to struct_init followed by ref - this ZIR tag exists as an optimization for a common pattern. Uses the pl_node field. Payload is StructInit.

validate_struct_init_ty

Checks that the type supports struct init syntax. Always returns void. Uses the un_node field.

validate_struct_init_result_ty

Like validate_struct_init_ty, but additionally accepts types which structs coerce to. Used on the known result type of a struct init expression. Always returns void. Uses the un_node field.

validate_ptr_struct_init

Given a set of struct_init_field_ptr instructions, assumes they are all part of a struct initialization expression, and emits compile errors for duplicate fields as well as missing fields, if applicable. This instruction asserts that there is at least one struct_init_field_ptr instruction, because it must use one of them to find out the struct type. Uses the pl_node field. Payload is Block.

struct_init_field_type

Given a type being used for a struct initialization expression, returns the type of the field with the given name. Uses the pl_node field. Payload is FieldType.

struct_init_field_ptr

Given a pointer being used as the result pointer of a struct initialization expression, return a pointer to the field of the given name. Uses the pl_node field. The AST node is the field initializer. Payload is Field.

array_init_anon

Array initialization without a type. Creates a value of a tuple type. Uses the pl_node field. Payload is MultiOp.

array_init

Array initialization syntax with a known type. The given type must be validated prior to this instruction, using some validate_array_init_*_ty instruction. Uses the pl_node field. Payload is MultiOp, where the first operand is the type.

array_init_ref

Array initialization syntax, make the result a pointer. Equivalent to array_init followed by ref- this ZIR tag exists as an optimization for a common pattern. Uses the pl_node field. Payload is MultiOp, where the first operand is the type.

validate_array_init_ty

Checks that the type supports array init syntax. Always returns void. Uses the pl_node field. Payload is ArrayInit.

validate_array_init_result_ty

Like validate_array_init_ty, but additionally accepts types which arrays coerce to. Used on the known result type of an array init expression. Always returns void. Uses the pl_node field. Payload is ArrayInit.

validate_array_init_ref_ty

Given a pointer or slice type and an element count, return the expected type of an array initializer such that a pointer to the initializer has the given pointer type, checking that this type supports array init syntax and emitting a compile error if not. Preserves error union and optional wrappers on the array type, if any. Asserts that the given type is a pointer or slice type. Uses the pl_node field. Payload is ArrayInitRefTy.

validate_ptr_array_init

Given a set of array_init_elem_ptr instructions, assumes they are all part of an array initialization expression, and emits a compile error if the number of elements does not match the array type. This instruction asserts that there is at least one array_init_elem_ptr instruction, because it must use one of them to find out the array type. Uses the pl_node field. Payload is Block.

array_init_elem_type

Given a type being used for an array initialization expression, returns the type of the element at the given index. Uses the bin union field. lhs is the indexable type, rhs is the index.

array_init_elem_ptr

Given a pointer being used as the result pointer of an array initialization expression, return a pointer to the element at the given index. Uses the pl_node union field. AST node is an element inside array initialization syntax. Payload is ElemPtrImm.

union_init

Implements the @unionInit builtin. Uses the pl_node field. Payload is UnionInit.

type_info

Implements the @typeInfo builtin. Uses un_node.

size_of

Implements the @sizeOf builtin. Uses un_node.

bit_size_of

Implements the @bitSizeOf builtin. Uses un_node.

int_from_ptr

Implement builtin @intFromPtr. Uses un_node. Convert a pointer to a usize integer.

compile_error

Emit an error message and fail compilation. Uses the un_node field.

set_eval_branch_quota

Changes the maximum number of backwards branches that compile-time code execution can use before giving up and making a compile error. Uses the un_node union field.

int_from_enum

Converts an enum value into an integer. Resulting type will be the tag type of the enum. Uses un_node.

backing_int

Implements the @backingInt builtin. Uses un_node.

align_of

Implement builtin @alignOf. Uses un_node.

int_from_bool

Implement builtin @intFromBool. Uses un_node.

embed_file

Implement builtin @embedFile. Uses un_node.

error_name

Implement builtin @errorName. Uses un_node.

panic

Implement builtin @panic. Uses un_node.

trap

Implements @trap. Uses the node field.

set_runtime_safety

Implement builtin @setRuntimeSafety. Uses un_node.

sqrt

Implement builtin @sqrt. Uses un_node.

sin

Implement builtin @sin. Uses un_node.

cos

Implement builtin @cos. Uses un_node.

tan

Implement builtin @tan. Uses un_node.

exp

Implement builtin @exp. Uses un_node.

exp2

Implement builtin @exp2. Uses un_node.

log

Implement builtin @log. Uses un_node.

log2

Implement builtin @log2. Uses un_node.

log10

Implement builtin @log10. Uses un_node.

abs

Implement builtin @abs. Uses un_node.

floor

Implement builtin @floor. Uses un_node.

ceil

Implement builtin @ceil. Uses un_node.

trunc

Implement builtin @trunc. Uses un_node.

round

Implement builtin @round. Uses un_node.

tag_name

Implement builtin @tagName. Uses un_node.

type_name

Implement builtin @typeName. Uses un_node.

frame_type

Implement builtin @Frame. Uses un_node.

int_from_float

Implements the @intFromFloat builtin. Uses pl_node with payload Bin. lhs is dest type, rhs is operand.

float_from_int

Implements the @floatFromInt builtin. Uses pl_node with payload Bin. lhs is dest type, rhs is operand.

ptr_from_int

Implements the @ptrFromInt builtin. Uses pl_node with payload Bin. lhs is dest type, rhs is operand.

enum_from_int

Converts an integer into an enum value. Uses pl_node with payload Bin. lhs is dest type, rhs is operand.

from_backing_int

Implements the @fromBackingInt builtin. Uses pl_node with payload Bin. lhs is dest type, rhs is operand.

float_cast

Convert a larger float type to any other float type, possibly causing a loss of precision. Uses the pl_node field. AST is the @floatCast syntax. Payload is Bin with lhs as the dest type, rhs the operand.

int_cast

Implements the @intCast builtin. Uses pl_node with payload Bin. lhs is dest type, rhs is operand. Convert an integer value to another integer type, asserting that the destination type can hold the same mathematical value.

ptr_cast

Implements the @ptrCast builtin. Uses pl_node with payload Bin. lhs is dest type, rhs is operand. Not every @ptrCast will correspond to this instruction - see also ptr_cast_full in Extended.

truncate

Implements the @truncate builtin. Uses pl_node with payload Bin. lhs is dest type, rhs is operand.

has_decl

Implements the @hasDecl builtin. Uses the pl_node union field. Payload is Bin.

has_field

Implements the @hasField builtin. Uses the pl_node union field. Payload is Bin.

clz

Implements the @clz builtin. Uses the un_node union field.

ctz

Implements the @ctz builtin. Uses the un_node union field.

pop_count

Implements the @popCount builtin. Uses the un_node union field.

byte_swap

Implements the @byteSwap builtin. Uses the un_node union field.

bit_reverse

Implements the @bitReverse builtin. Uses the un_node union field.

bit_offset_of

Implements the @bitOffsetOf builtin. Uses the pl_node union field with payload Bin.

offset_of

Implements the @offsetOf builtin. Uses the pl_node union field with payload Bin.

splat

Implements the @splat builtin. Uses the pl_node union field with payload Bin.

reduce

Implements the @reduce builtin. Uses the pl_node union field with payload Bin.

shuffle

Implements the @shuffle builtin. Uses the pl_node union field with payload Shuffle.

atomic_load

Implements the @atomicLoad builtin. Uses the pl_node union field with payload AtomicLoad.

atomic_rmw

Implements the @atomicRmw builtin. Uses the pl_node union field with payload AtomicRmw.

atomic_store

Implements the @atomicStore builtin. Uses the pl_node union field with payload AtomicStore.

mul_add

Implements the @mulAdd builtin. Uses the pl_node union field with payload MulAdd. The addend communicates the type of the builtin. The mulends need to be coerced to the same type.

memcpy

Implements the @memcpy builtin. Uses the pl_node union field with payload Bin.

memmove

Implements the @memmove builtin. Uses the pl_node union field with payload Bin.

memset

Implements the @memset builtin. Uses the pl_node union field with payload Bin.

min

Implements the @min builtin for 2 args. Uses the pl_node union field with payload Bin

max

Implements the @max builtin for 2 args. Uses the pl_node union field with payload Bin

alloc

Allocates stack local memory. Uses the un_node union field. The operand is the type of the allocated object. The node source location points to a var decl node. A make_ptr_const instruction should be used once the value has been stored to the allocation. To ensure comptime value detection functions, there are some restrictions on how this pointer should be used prior to the make_ptr_const instruction: no pointer derived from this alloc may be returned from a block or stored to another address. In other words, it must be trivial to determine whether any given pointer derives from this one.

alloc_mut

Same as alloc except mutable. As such, make_ptr_const need not be used, and there are no restrictions on the usage of the pointer.

alloc_comptime_mut

Allocates comptime-mutable memory. Uses the un_node union field. The operand is the type of the allocated object. The node source location points to a var decl node.

alloc_inferred

Same as alloc except the type is inferred. Uses the node union field.

alloc_inferred_mut

Same as alloc_inferred except mutable.

alloc_inferred_comptime

Allocates comptime const memory. Uses the node union field. The type of the allocated object is inferred. The node source location points to a var decl node.

alloc_inferred_comptime_mut

Same as alloc_comptime_mut except the type is inferred.

resolve_inferred_alloc

Each store_to_inferred_ptr puts the type of the stored value into a set, and then resolve_inferred_alloc triggers peer type resolution on the set. The operand is a alloc_inferred or alloc_inferred_mut instruction, which is the allocation that needs to have its type inferred. Results in the final resolved pointer. The alloc_inferred[_comptime][_mut] instruction should never be referred to after this instruction. Uses the un_node field. The AST node is the var decl.

make_ptr_const

Turns a pointer coming from an alloc or Extended.alloc into a constant version of the same pointer. For inferred allocations this is instead implicitly handled by the resolve_inferred_alloc instruction. Uses the un_node union field.

@"resume"

Implements resume syntax. Uses un_node field.

@"defer"

A defer statement. Uses the defer union field.

save_err_ret_index

Requests that Sema update the saved error return trace index for the enclosing block, if the operand is .none or of an error/error-union type. Uses the save_err_ret_index field.

restore_err_ret_index_unconditional

Specialized form of Extended.restore_err_ret_index. Unconditionally restores the error return index to its last saved state in the block referred to by operand. If operand is none, restores to the point of function entry. Uses the un_node field.

restore_err_ret_index_fn_entry

Specialized form of Extended.restore_err_ret_index. Restores the error return index to its state at the entry of the current function conditional on operand being a non-error. If operand is none, restores unconditionally. Uses the un_node field.

extended

The ZIR instruction tag is one of the Extended ones. Uses the extended union field.

std.zig.Zir.Inst.Tag.data_tags

constant

Source line 1642

Used by debug safety-checking code.

std.zig.Zir.Inst.Tag.isAlwaysVoid

function

Source line 1371

AstGen uses this to find out if Ref.void_value should be used in place of the result of a given instruction. This allows Sema to forego adding the instruction to the map after analysis.

pub fn isAlwaysVoid(tag: Tag, data: Data) bool

Parameters

tag: Tag
data: Data

std.zig.Zir.Inst.Tag.isNoReturn

function

Source line 1106

Returns whether the instruction is one of the control flow "noreturn" types. Function calls do not count.

pub fn isNoReturn(tag: Tag) bool

Parameters

tag: Tag

std.zig.Zir.Inst.Try

container

Source line 3166

This data is stored inside extra, trailed by:

    1. body: Index // for each body_len.

Fields

operand: Ref

The error union to unwrap.

body_len: u32

std.zig.Zir.Inst.TupleDecl

container

Source line 3785

Trailing:

  1. fields: { // for every fields_len (stored in extended.small) type: Inst.Ref, init: Inst.Ref, // .none for non-comptime fields }

Fields

src_node: Ast.Node.Offset

std.zig.Zir.Inst.TypeOfPeer

container

Source line 3129

There is a body of instructions at extra[body_index..][0..body_len]. Trailing:

  1. operand: Ref // for each operands_len

Fields

src_node: Ast.Node.Offset
body_len: u32
body_index: u32

std.zig.Zir.Inst.UnionDecl

container

Source line 3704

Trailing:

  1. captures_len: u32 // if has_captures_len
  2. decls_len: u32, // if has_decls_len
  3. fields_len: u32, // if has_fields_len
  4. arg_type_body_len: u32, // if kind.hasArgType()
  5. capture: Capture // for every captures_len
  6. capture_name: NullTerminatedString // for every captures_len
  7. decl: Index, // for every decls_len; points to a declaration instruction
  8. field_name: NullTerminatedString // for every fields_len
  9. field_type_body_len: u32 // for every fields_len 9 . field_align_body_len: u32 // for every fields_len if any_field_aligns
  10. field_value_body_len: u32 // for every fields_len if any_field_values
  11. arg_type_body_inst: Inst.Index // for each arg_type_body_len
  12. body_inst: Inst.Index // type body, then align body, then value body, for each field

Fields

fields_hash_0: u32
fields_hash_1: u32
fields_hash_2: u32
fields_hash_3: u32
src_line: u32
src_column: u32
src_node: Ast.Node.Index

This node provides a new absolute baseline node for all instructions within this struct.

std.zig.Zir.Inst.UnionDecl.Kind

container

Source line 3727

Fields

auto

union

tagged_explicit

union(T)

tagged_enum

union(enum)

tagged_enum_explicit

union(enum(T))

@"extern"

extern union

@"packed"

packed union

packed_explicit

packed union(T)

std.zig.Zir.Inst.UnionDecl.Kind.hasArgType

function

Source line 3743

pub fn hasArgType(k: Kind) bool

Parameters

k: Kind

std.zig.Zir.Inst.UnionDecl.Kind.layout

function

Source line 3750

pub fn layout(k: Kind) std.lang.Type.ContainerLayout

Parameters

k: Kind

std.zig.Zir.Inst.UnionDecl.Small

container

Source line 3716

Fields

has_captures_len: bool
has_decls_len: bool
has_fields_len: bool
name_strategy: NameStrategy
kind: Kind
any_field_aligns: bool
any_field_values: bool
_: u6 = 0

std.zig.Zir.Inst.UnionInit

container

Source line 3875

Fields

union_type: Ref
field_name: Ref
init: Ref

std.zig.Zir.Inst.UnNode

container

Source line 3252

Fields

node: Ast.Node.Offset
operand: Ref

std.zig.Zir.Inst.ValidateDestructure

container

Source line 4009

Fields

operand: Ref

The value being destructured.

destructure_node: Ast.Node.Offset

The destructure_assign node.

expect_len: u32

The expected field count.

std.zig.Zir.Io

alias

Source line 18

Alias of std.Io

std.zig.Zir.loweringFailed

function

Source line 142

pub fn loweringFailed(code: Zir) bool

Parameters

code: Zir

std.zig.Zir.mem

alias

Source line 19

Alias of std.mem

std.zig.Zir.nullTerminatedString

function

Source line 120

Given an index into string_bytes returns the null-terminated string found there.

pub fn nullTerminatedString(code: Zir, index: NullTerminatedString) [:0]const u8

Parameters

code: Zir
index: NullTerminatedString

std.zig.Zir.NullTerminatedString

container

Source line 114

Fields

empty = 0
_

std.zig.Zir.refSlice

function

Source line 125

pub fn refSlice(code: Zir, start: usize, len: usize) []Inst.Ref

Parameters

code: Zir
start: usize
len: usize

std.zig.Zir.std

alias

Source line 17

Alias of std

std.zig.Zir.typeDecls

function

Source line 5258

pub fn typeDecls(zir: Zir, type_decl: Inst.Index) []const Zir.Inst.Index

Parameters

zir: Zir
type_decl: Inst.Index

std.zig.Zir.UnwrappedEnumDecl

container

Source line 5656

Fields

src_line: u32
src_column: u32
src_node: Ast.Node.Index
name_strategy: Inst.NameStrategy
arg_baseline_src_node: Ast.Node.Index
fields_baseline_src_node: Ast.Node.Index
captures: []const Inst.Capture
capture_names: []const NullTerminatedString
decls: []const Inst.Index
tag_type_body: ?[]const Inst.Index
nonexhaustive: bool
field_names: []const NullTerminatedString
field_value_body_lens: ?[]const u32
field_bodies_overlong: []const Inst.Index

std.zig.Zir.UnwrappedEnumDecl.FieldIterator

container

Source line 5686

Fields

next_idx: u32
names: []const NullTerminatedString
value_body_lens: ?[]const u32
bodies_overlong: []const Inst.Index

std.zig.Zir.UnwrappedEnumDecl.FieldIterator.body

function

Source line 5706

fn body(it: *FieldIterator, len: u32) ?[]const Inst.Index

Parameters

it: *FieldIterator
len: u32

std.zig.Zir.UnwrappedEnumDecl.FieldIterator.Field

container

Source line 5691

Fields

idx: u32
name: NullTerminatedString
value_body: ?[]const Inst.Index

std.zig.Zir.UnwrappedEnumDecl.FieldIterator.next

function

Source line 5696

pub fn next(it: *FieldIterator) ?Field

Parameters

std.zig.Zir.UnwrappedEnumDecl.iterateFields

function

Source line 5677

pub fn iterateFields(enum_decl: UnwrappedEnumDecl) FieldIterator

Parameters

enum_decl: UnwrappedEnumDecl

std.zig.Zir.UnwrappedOpaqueDecl

container

Source line 5748

Fields

src_line: u32
src_column: u32
src_node: Ast.Node.Index
name_strategy: Inst.NameStrategy
captures: []const Inst.Capture
capture_names: []const NullTerminatedString
decls: []const Inst.Index

std.zig.Zir.UnwrappedStructDecl

container

Source line 5357

Fields

src_line: u32
src_column: u32
src_node: Ast.Node.Index
name_strategy: Inst.NameStrategy
arg_baseline_src_node: Ast.Node.Index
fields_baseline_src_node: Ast.Node.Index
captures: []const Inst.Capture
capture_names: []const NullTerminatedString
decls: []const Inst.Index
layout: std.lang.Type.ContainerLayout
backing_int_type_body: ?[]const Inst.Index
field_names: []const NullTerminatedString
field_type_body_lens: []const u32
field_align_body_lens: ?[]const u32
field_default_body_lens: ?[]const u32
field_comptime_bits: ?[]const u32
field_bodies_overlong: []const Inst.Index

std.zig.Zir.UnwrappedStructDecl.FieldIterator

container

Source line 5393

Fields

next_idx: u32
names: []const NullTerminatedString
type_body_lens: []const u32
align_body_lens: ?[]const u32
default_body_lens: ?[]const u32
comptime_bits: ?[]const u32
bodies_overlong: []const Inst.Index

std.zig.Zir.UnwrappedStructDecl.FieldIterator.body

function

Source line 5427

fn body(it: *FieldIterator, len: u32) ?[]const Inst.Index

Parameters

it: *FieldIterator
len: u32

std.zig.Zir.UnwrappedStructDecl.FieldIterator.Field

container

Source line 5401

Fields

idx: u32
name: NullTerminatedString
type_body: []const Inst.Index
align_body: ?[]const Inst.Index
default_body: ?[]const Inst.Index
is_comptime: bool

std.zig.Zir.UnwrappedStructDecl.FieldIterator.next

function

Source line 5409

pub fn next(it: *FieldIterator) ?Field

Parameters

std.zig.Zir.UnwrappedStructDecl.iterateFields

function

Source line 5381

pub fn iterateFields(struct_decl: UnwrappedStructDecl) FieldIterator

Parameters

struct_decl: UnwrappedStructDecl

std.zig.Zir.UnwrappedSwitchBlock

container

Source line 5096

Trailing (starting at end):

  1. case_bodies: { // for each case in Case.Iterator.next() prong_body: { body_inst: Inst.Index, // for every case.prong_info.body_len, } item_body: { // for each body_len in case.item_infos body_inst: Inst.Index, // for every body_len } range_bodies: { // for each .{first_info, last_info} in case.range_infos first_body_inst: Inst.Index, // for every first_info.body_len last_body_inst: Inst.Index, // for every last_info.body_len } }

Fields

main_operand: Inst.Ref

Either catch/if or switch operand.

switch_src_node_offset: Ast.Node.Offset
catch_or_if_src_node_offset: Ast.Node.OptionalOffset
payload_capture_placeholder: Inst.OptionalIndex
tag_capture_placeholder: Inst.OptionalIndex
has_continue: bool
any_maybe_runtime_capture: bool
non_err_case: ?Case.NonErr
else_case: ?Case.Else
has_under: bool
prong_infos: []const Inst.SwitchBlock.ProngInfo
multi_case_items_lens: []const u32
multi_case_ranges_lens: ?[]const u32
item_infos: []const Inst.SwitchBlock.ItemInfo
end: usize

std.zig.Zir.UnwrappedSwitchBlock.anyRanges

function

Source line 5115

pub fn anyRanges(unwrapped: *const UnwrappedSwitchBlock) bool

Parameters

unwrapped: *const UnwrappedSwitchBlock

std.zig.Zir.UnwrappedSwitchBlock.Case

container

Source line 5135

Fields

index: Case.Index
prong_info: Inst.SwitchBlock.ProngInfo
item_infos: []const Inst.SwitchBlock.ItemInfo
range_infos: []const [2]Inst.SwitchBlock.ItemInfo

std.zig.Zir.UnwrappedSwitchBlock.Case.Else

container

Source line 5157

Fields

index: Case.Index
body: []const Inst.Index
capture: Inst.SwitchBlock.ProngInfo.Capture
is_inline: bool
has_tag_capture: bool
is_simple_noreturn: bool

std.zig.Zir.UnwrappedSwitchBlock.Case.Index

container

Source line 5141

Fields

kind: enum(u1) { scalar, multi }
value: u31

std.zig.Zir.UnwrappedSwitchBlock.Case.Index.@"else"

constant

Source line 5145

Case.Index

std.zig.Zir.UnwrappedSwitchBlock.Case.Iterator

container

Source line 5166

Fields

next_idx: u32
prong_infos: []const Inst.SwitchBlock.ProngInfo
multi_case_items_lens: []const u32
multi_case_ranges_lens: ?[]const u32
item_infos: []const Inst.SwitchBlock.ItemInfo

std.zig.Zir.UnwrappedSwitchBlock.Case.Iterator.itemInfos

function

Source line 5198

fn itemInfos(it: *Iterator, count: u32) []const Inst.SwitchBlock.ItemInfo

Parameters

it: *Iterator
count: u32

std.zig.Zir.UnwrappedSwitchBlock.Case.Iterator.next

function

Source line 5173

pub fn next(it: *Iterator) ?Case

Parameters

it: *Iterator

std.zig.Zir.UnwrappedSwitchBlock.Case.NonErr

container

Source line 5151

Fields

body: []const Inst.Index
capture: Inst.SwitchBlock.ProngInfo.Capture
operand_is_ref: bool

std.zig.Zir.UnwrappedSwitchBlock.iterateCases

function

Source line 5206

pub fn iterateCases(unwrapped: UnwrappedSwitchBlock) Case.Iterator

Parameters

std.zig.Zir.UnwrappedSwitchBlock.multiCasesLen

function

Source line 5123

pub fn multiCasesLen(unwrapped: *const UnwrappedSwitchBlock) u32

Parameters

unwrapped: *const UnwrappedSwitchBlock

std.zig.Zir.UnwrappedSwitchBlock.scalarCasesLen

function

Source line 5119

pub fn scalarCasesLen(unwrapped: *const UnwrappedSwitchBlock) u32

Parameters

unwrapped: *const UnwrappedSwitchBlock

std.zig.Zir.UnwrappedSwitchBlock.totalItemsLen

function

Source line 5127

pub fn totalItemsLen(unwrapped: *const UnwrappedSwitchBlock) u32

Parameters

unwrapped: *const UnwrappedSwitchBlock

std.zig.Zir.UnwrappedUnionDecl

container

Source line 5516

Fields

src_line: u32
src_column: u32
src_node: Ast.Node.Index
name_strategy: Inst.NameStrategy
arg_baseline_src_node: Ast.Node.Index
fields_baseline_src_node: Ast.Node.Index
captures: []const Inst.Capture
capture_names: []const NullTerminatedString
decls: []const Inst.Index
kind: Inst.UnionDecl.Kind
arg_type_body: ?[]const Inst.Index
field_names: []const NullTerminatedString
field_type_body_lens: []const u32
field_align_body_lens: ?[]const u32
field_value_body_lens: ?[]const u32
field_bodies_overlong: []const Inst.Index

std.zig.Zir.UnwrappedUnionDecl.FieldIterator

container

Source line 5550

Fields

next_idx: u32
names: []const NullTerminatedString
type_body_lens: []const u32
align_body_lens: ?[]const u32
value_body_lens: ?[]const u32
bodies_overlong: []const Inst.Index

std.zig.Zir.UnwrappedUnionDecl.FieldIterator.body

function

Source line 5576

fn body(it: *FieldIterator, len: u32) ?[]const Inst.Index

Parameters

it: *FieldIterator
len: u32

std.zig.Zir.UnwrappedUnionDecl.FieldIterator.Field

container

Source line 5557

Fields

idx: u32
name: NullTerminatedString
type_body: ?[]const Inst.Index
align_body: ?[]const Inst.Index
value_body: ?[]const Inst.Index

std.zig.Zir.UnwrappedUnionDecl.FieldIterator.next

function

Source line 5564

pub fn next(it: *FieldIterator) ?Field

Parameters

std.zig.Zir.UnwrappedUnionDecl.iterateFields

function

Source line 5539

pub fn iterateFields(union_decl: UnwrappedUnionDecl) FieldIterator

Parameters

union_decl: UnwrappedUnionDecl

std.zig.Zir.Zir

alias

Source line 14

Alias of std.zig.Zir

Source code

std/zig/Zir.zig

//! Zig Intermediate Representation.
//!
//! Astgen.zig converts AST nodes to these untyped IR instructions. Next,
//! Sema.zig processes these into AIR.
//! The minimum amount of information needed to represent a list of ZIR instructions.
//! Once this structure is completed, it can be used to generate AIR, followed by
//! machine code, without any memory access into the AST tree token list, node list,
//! or source bytes. Exceptions include:
//!  * Compile errors, which may need to reach into these data structures to
//!    create a useful report.
//!  * In the future, possibly inline assembly, which needs to get parsed and
//!    handled by the codegen backend, and errors reported there. However for now,
//!    inline assembly is not an exception.
const Zir = @This();
const builtin = @import("builtin");

const std = @import("std");
const Io = std.Io;
const mem = std.mem;
const Allocator = std.mem.Allocator;
const assert = std.debug.assert;
const BigIntConst = std.math.big.int.Const;
const BigIntMutable = std.math.big.int.Mutable;
const Ast = std.zig.Ast;

instructions: std.MultiArrayList(Inst).Slice,
/// In order to store references to strings in fewer bytes, we copy all
/// string bytes into here. String bytes can be null. It is up to whomever
/// is referencing the data here whether they want to store both index and length,
/// thus allowing null bytes, or store only index, and use null-termination. The
/// `string_bytes` array is agnostic to either usage.
/// Index 0 is reserved for special cases.
string_bytes: []u8,
/// The meaning of this data is determined by `Inst.Tag` value.
/// The first few indexes are reserved. See `ExtraIndex` for the values.
extra: []u32,

/// The data stored at byte offset 0 when ZIR is stored in a file.
pub const Header = extern struct {
    instructions_len: u32,
    string_bytes_len: u32,
    extra_len: u32,
    /// We could leave this as padding, however it triggers a Valgrind warning because
    /// we read and write undefined bytes to the file system. This is harmless, but
    /// it's essentially free to have a zero field here and makes the warning go away,
    /// making it more likely that following Valgrind warnings will be taken seriously.
    unused: u32 = 0,
    stat_inode: Io.File.INode,
    stat_size: u64,
    stat_mtime: i128,
};

pub const ExtraIndex = enum(u32) {
    /// If this is 0, no compile errors. Otherwise there is a `CompileErrors`
    /// payload at this index.
    compile_errors,
    /// If this is 0, this file contains no imports. Otherwise there is a `Imports`
    /// payload at this index.
    imports,

    _,
};

fn ExtraData(comptime T: type) type {
    return struct { data: T, end: usize };
}

/// Returns the requested data, as well as the new index which is at the start of the
/// trailers for the object.
pub fn extraData(code: Zir, comptime T: type, index: usize) ExtraData(T) {
    const info = @typeInfo(T).@"struct";
    var i: usize = index;
    var result: T = undefined;
    inline for (info.field_names, info.field_types) |field_name, field_type| {
        @field(result, field_name) = switch (field_type) {
            u32 => code.extra[i],

            Inst.Ref,
            Inst.Index,
            Inst.Declaration.Name,
            std.zig.SimpleComptimeReason,
            NullTerminatedString,
            // Ast.TokenIndex is missing because it is a u32.
            Ast.OptionalTokenIndex,
            Ast.Node.Index,
            Ast.Node.OptionalIndex,
            => @fromBackingInt(@intCast(code.extra[i])),

            Ast.TokenOffset,
            Ast.OptionalTokenOffset,
            Ast.Node.Offset,
            Ast.Node.OptionalOffset,
            => @fromBackingInt(@intCast(@as(i32, @bitCast(code.extra[i])))),

            Inst.Call.Flags,
            Inst.BuiltinCall.Flags,
            Inst.SwitchBlock.Bits,
            Inst.FuncFancy.Bits,
            Inst.Declaration.Flags,
            Inst.Param.Type,
            Inst.Func.RetTy,
            => @bitCast(code.extra[i]),

            else => @compileError("bad field type"),
        };
        i += 1;
    }
    return .{
        .data = result,
        .end = i,
    };
}

pub const NullTerminatedString = enum(u32) {
    empty = 0,
    _,
};

/// Given an index into `string_bytes` returns the null-terminated string found there.
pub fn nullTerminatedString(code: Zir, index: NullTerminatedString) [:0]const u8 {
    const slice = code.string_bytes[@backingInt(index)..];
    return slice[0..std.mem.findScalar(u8, slice, 0).? :0];
}

pub fn refSlice(code: Zir, start: usize, len: usize) []Inst.Ref {
    return @ptrCast(code.extra[start..][0..len]);
}

pub fn bodySlice(zir: Zir, start: usize, len: usize) []Inst.Index {
    return @ptrCast(zir.extra[start..][0..len]);
}

pub fn hasCompileErrors(code: Zir) bool {
    if (code.extra[@backingInt(ExtraIndex.compile_errors)] != 0) {
        return true;
    } else {
        assert(code.instructions.len != 0); // i.e. lowering did not fail
        return false;
    }
}

pub fn loweringFailed(code: Zir) bool {
    if (code.instructions.len == 0) {
        assert(code.hasCompileErrors());
        return true;
    } else {
        return false;
    }
}

pub fn deinit(code: *Zir, gpa: Allocator) void {
    code.instructions.deinit(gpa);
    gpa.free(code.string_bytes);
    gpa.free(code.extra);
    code.* = undefined;
}

/// These are untyped instructions generated from an Abstract Syntax Tree.
/// The data here is immutable because it is possible to have multiple
/// analyses on the same ZIR happening at the same time.
pub const Inst = struct {
    tag: Tag,
    data: Data,

    /// These names are used directly as the instruction names in the text format.
    /// See `data_field_map` for a list of which `Data` fields are used by each `Tag`.
    pub const Tag = enum(u8) {
        /// Arithmetic addition, asserts no integer overflow.
        /// Uses the `pl_node` union field. Payload is `Bin`.
        add,
        /// Twos complement wrapping integer addition.
        /// Uses the `pl_node` union field. Payload is `Bin`.
        addwrap,
        /// Saturating addition.
        /// Uses the `pl_node` union field. Payload is `Bin`.
        add_sat,
        /// The same as `add` except no safety check.
        add_unsafe,
        /// Arithmetic subtraction. Asserts no integer overflow.
        /// Uses the `pl_node` union field. Payload is `Bin`.
        sub,
        /// Twos complement wrapping integer subtraction.
        /// Uses the `pl_node` union field. Payload is `Bin`.
        subwrap,
        /// Saturating subtraction.
        /// Uses the `pl_node` union field. Payload is `Bin`.
        sub_sat,
        /// Arithmetic multiplication. Asserts no integer overflow.
        /// Uses the `pl_node` union field. Payload is `Bin`.
        mul,
        /// Twos complement wrapping integer multiplication.
        /// Uses the `pl_node` union field. Payload is `Bin`.
        mulwrap,
        /// Saturating multiplication.
        /// Uses the `pl_node` union field. Payload is `Bin`.
        mul_sat,
        /// Implements the `@divExact` builtin.
        /// Uses the `pl_node` union field with payload `Bin`.
        div_exact,
        /// Implements the `@divFloor` builtin.
        /// Uses the `pl_node` union field with payload `Bin`.
        div_floor,
        /// Implements the `@divCeil` builtin.
        /// Uses the `pl_node` union field with payload `Bin`.
        div_ceil,
        /// Implements the `@divTrunc` builtin.
        /// Uses the `pl_node` union field with payload `Bin`.
        div_trunc,
        /// Implements the `@mod` builtin.
        /// Uses the `pl_node` union field with payload `Bin`.
        mod,
        /// Implements the `@rem` builtin.
        /// Uses the `pl_node` union field with payload `Bin`.
        rem,
        /// Ambiguously remainder division or modulus. If the computation would possibly have
        /// a different value depending on whether the operation is remainder division or modulus,
        /// a compile error is emitted. Otherwise the computation is performed.
        /// Uses the `pl_node` union field. Payload is `Bin`.
        mod_rem,
        /// Integer shift-left. Zeroes are shifted in from the right hand side.
        /// Uses the `pl_node` union field. Payload is `Bin`.
        shl,
        /// Implements the `@shlExact` builtin.
        /// Uses the `pl_node` union field with payload `Bin`.
        shl_exact,
        /// Saturating shift-left.
        /// Uses the `pl_node` union field. Payload is `Bin`.
        shl_sat,
        /// Integer shift-right. Arithmetic or logical depending on the signedness of
        /// the integer type.
        /// Uses the `pl_node` union field. Payload is `Bin`.
        shr,
        /// Implements the `@shrExact` builtin.
        /// Uses the `pl_node` union field with payload `Bin`.
        shr_exact,

        /// Declares a parameter of the current function. Used for:
        /// * debug info
        /// * checking shadowing against declarations in the current namespace
        /// * parameter type expressions referencing other parameters
        /// These occur in the block outside a function body (the same block as
        /// contains the func instruction).
        /// Uses the `pl_tok` field. Token is the parameter name, payload is a `Param`.
        param,
        /// Same as `param` except the parameter is marked comptime.
        param_comptime,
        /// Same as `param` except the parameter is marked anytype.
        /// Uses the `str_tok` field. Token is the parameter name. String is the parameter name.
        param_anytype,
        /// Same as `param` except the parameter is marked both comptime and anytype.
        /// Uses the `str_tok` field. Token is the parameter name. String is the parameter name.
        param_anytype_comptime,
        /// Array concatenation. `a ++ b`
        /// Uses the `pl_node` union field. Payload is `Bin`.
        array_cat,
        /// `[N]T` syntax. No source location provided.
        /// Uses the `pl_node` union field. Payload is `Bin`. lhs is length, rhs is element type.
        array_type,
        /// `[N:S]T` syntax. Source location is the array type expression node.
        /// Uses the `pl_node` union field. Payload is `ArrayTypeSentinel`.
        array_type_sentinel,
        /// `@Int` builtin.
        /// Uses the `pl_node` union field with `Bin` payload.
        /// lhs is signedness, rhs is bit count.
        reify_int,
        /// `@Vector` builtin.
        /// Uses the `pl_node` union field with `Bin` payload.
        /// lhs is length, rhs is element type.
        vector_type,
        /// Given a pointer type, returns its element type. Reaches through any optional or error
        /// union types wrapping the pointer. Asserts that the underlying type is a pointer type.
        /// Returns generic poison if the element type is `anyopaque`.
        /// Uses the `un_node` field.
        elem_type,
        /// Given an indexable pointer (slice, many-ptr, single-ptr-to-array), returns its
        /// element type. Emits a compile error if the type is not an indexable pointer.
        /// Uses the `un_node` field.
        indexable_ptr_elem_type,
        /// Given a vector or array type, strips off any error unions or
        /// optionals layered on top and returns its element type.
        ///
        /// `!?[N]T` -> `T`
        ///
        /// Uses the `un_node` field.
        splat_op_result_ty,
        /// Given a type, strips away any error unions or optionals stacked
        /// on top, validates it for usage with `@fromBackingInt` and returns
        /// its backing integer type.
        ///
        /// `E!?enum(T) { _ }` -> `T`
        ///
        /// Uses the `un_node` field.
        from_backing_int_arg_ty,
        /// Given a pointer to an indexable object, returns the len property. This is
        /// used by for loops. This instruction also emits a for-loop specific compile
        /// error if the indexable object is not indexable.
        /// Uses the `un_node` field. The AST node is the for loop node.
        indexable_ptr_len,
        /// Create a `anyframe->T` type.
        /// Uses the `un_node` field.
        anyframe_type,
        /// Type coercion to the function's return type.
        /// Uses the `pl_node` field. Payload is `As`. AST node could be many things.
        as_node,
        /// Same as `as_node` but ignores runtime to comptime int error.
        as_shift_operand,
        /// Bitwise AND. `&`
        bit_and,
        /// Reinterpret the memory representation of a value as a different type.
        /// Uses the pl_node field with payload `Bin`.
        bitcast,
        /// Bitwise NOT. `~`
        /// Uses `un_node`.
        bit_not,
        /// Bitwise OR. `|`
        bit_or,
        /// A labeled block of code, which can return a value.
        /// Uses the `pl_node` union field. Payload is `Block`.
        block,
        /// Like `block`, but forces full evaluation of its contents at compile-time.
        /// Exited with `break_inline`.
        /// Uses the `pl_node` union field. Payload is `BlockComptime`.
        block_comptime,
        /// A list of instructions which are analyzed in the parent context, without
        /// generating a runtime block. Must terminate with an "inline" variant of
        /// a noreturn instruction.
        /// Uses the `pl_node` union field. Payload is `Block`.
        block_inline,
        /// This instruction may only ever appear in the list of declarations for a
        /// namespace type, e.g. within a `struct_decl` instruction. It represents a
        /// single source declaration (`const`/`var`/`fn`), containing the name,
        /// attributes, type, and value of the declaration.
        /// Uses the `declaration` union field. Payload is `Declaration`.
        declaration,
        /// Implements `suspend {...}`.
        /// Uses the `pl_node` union field. Payload is `Block`.
        suspend_block,
        /// Boolean NOT. See also `bit_not`.
        /// Uses the `un_node` field.
        bool_not,
        /// Short-circuiting boolean `and`. `lhs` is a boolean `Ref` and the other operand
        /// is a block, which is evaluated if `lhs` is `true`.
        /// Uses the `pl_node` union field. Payload is `BoolBr`.
        bool_br_and,
        /// Short-circuiting boolean `or`. `lhs` is a boolean `Ref` and the other operand
        /// is a block, which is evaluated if `lhs` is `false`.
        /// Uses the `pl_node` union field. Payload is `BoolBr`.
        bool_br_or,
        /// Return a value from a block.
        /// Uses the `break` union field.
        /// Uses the source information from previous instruction.
        @"break",
        /// Return a value from a block. This instruction is used as the terminator
        /// of a `block_inline`. It allows using the return value from `Sema.analyzeBody`.
        /// This instruction may also be used when it is known that there is only one
        /// break instruction in a block, and the target block is the parent.
        /// Uses the `break` union field.
        break_inline,
        /// Branch from within a switch case to the case specified by the operand.
        /// Uses the `break` union field. `block_inst` refers to a `switch_block`/
        /// `switch_block_ref`/`switch_block_err_union`.
        switch_continue,
        /// Checks that comptime control flow does not happen inside a runtime block.
        /// Uses the `un_node` union field.
        check_comptime_control_flow,
        /// Function call.
        /// Uses the `pl_node` union field with payload `Call`.
        /// AST node is the function call.
        call,
        /// Function call using `a.b()` syntax.
        /// Uses the named field as the callee. If there is no such field, searches in the type for
        /// a decl matching the field name. The decl is resolved and we ensure that it's a function
        /// which can accept the object as the first parameter, with one pointer fixup. This
        /// function is then used as the callee, with the object as an implicit first parameter.
        /// Uses the `pl_node` union field with payload `FieldCall`.
        /// AST node is the function call.
        field_call,
        /// Implements the `@call` builtin.
        /// Uses the `pl_node` union field with payload `BuiltinCall`.
        /// AST node is the builtin call.
        builtin_call,
        /// `<`
        /// Uses the `pl_node` union field. Payload is `Bin`.
        cmp_lt,
        /// `<=`
        /// Uses the `pl_node` union field. Payload is `Bin`.
        cmp_lte,
        /// `==`
        /// Uses the `pl_node` union field. Payload is `Bin`.
        cmp_eq,
        /// `>=`
        /// Uses the `pl_node` union field. Payload is `Bin`.
        cmp_gte,
        /// `>`
        /// Uses the `pl_node` union field. Payload is `Bin`.
        cmp_gt,
        /// `!=`
        /// Uses the `pl_node` union field. Payload is `Bin`.
        cmp_neq,
        /// Conditional branch. Splits control flow based on a boolean condition value.
        /// Uses the `pl_node` union field. AST node is an if, while, for, etc.
        /// Payload is `CondBr`.
        condbr,
        /// Same as `condbr`, except the condition is coerced to a comptime value, and
        /// only the taken branch is analyzed. The then block and else block must
        /// terminate with an "inline" variant of a noreturn instruction.
        condbr_inline,
        /// Given an operand which is an error union, splits control flow. In
        /// case of error, control flow goes into the block that is part of this
        /// instruction, which is guaranteed to end with a return instruction
        /// and never breaks out of the block.
        /// In the case of non-error, control flow proceeds to the next instruction
        /// after the `try`, with the result of this instruction being the unwrapped
        /// payload value, as if `err_union_payload_unsafe` was executed on the operand.
        /// Uses the `pl_node` union field. Payload is `Try`.
        @"try",
        /// Same as `try` except the operand is a pointer and the result is a pointer.
        try_ptr,
        /// An error set type definition. Contains a list of field names.
        /// Uses the `pl_node` union field. Payload is `ErrorSetDecl`.
        error_set_decl,
        /// Declares the beginning of a statement. Used for debug info.
        /// Uses the `dbg_stmt` union field. The line and column are offset
        /// from the parent declaration.
        dbg_stmt,
        /// Marks a variable declaration. Used for debug info.
        /// Uses the `str_op` union field. The string is the local variable name,
        /// and the operand is the pointer to the variable's location. The local
        /// may be a const or a var.
        dbg_var_ptr,
        /// Same as `dbg_var_ptr` but the local is always a const and the operand
        /// is the local's value.
        dbg_var_val,
        /// Uses a name to identify a Decl and takes a pointer to it.
        ///
        /// Uses the `str_tok` union field.
        decl_ref,
        /// Uses a name to identify a Decl and uses it as a value.
        /// Uses the `str_tok` union field.
        decl_val,
        /// Load the value from a pointer. Assumes `x.*` syntax.
        /// Uses `un_node` field. AST node is the `x.*` syntax.
        load,
        /// Arithmetic division. Asserts no integer overflow.
        /// Uses the `pl_node` union field. Payload is `Bin`.
        div,
        /// Given a pointer to an array, slice, or pointer, returns a pointer to the element at
        /// the provided index.
        /// Uses the `pl_node` union field. AST node is a[b] syntax. Payload is `Bin`.
        elem_ptr_node,
        /// Same as `elem_ptr_node` but used only for for loop.
        /// Uses the `pl_node` union field. AST node is the condition of a for loop.
        /// Payload is `Bin`.
        /// No OOB safety check is emitted.
        elem_ptr,
        /// Given a pointer to an array, slice, or pointer, loads the element
        /// at the provided index.
        ///
        /// Uses the `pl_node` union field. AST node is a[b] syntax. Payload is `Bin`.
        elem_ptr_load,
        /// Given an array, slice, or pointer, returns the element at the
        /// provided index.
        ///
        /// Uses the `pl_node` union field. AST node is the condition of a for
        /// loop. Payload is `Bin`.
        ///
        /// No OOB safety check is emitted.
        elem_val,
        /// Same as `elem_val` but takes the index as an immediate value.
        /// No OOB safety check is emitted. A prior instruction must validate this operation.
        /// Uses the `elem_val_imm` union field.
        elem_val_imm,
        /// Emits a compile error if the operand is not `void`.
        /// Uses the `un_node` field.
        ensure_result_used,
        /// Emits a compile error if an error is ignored.
        /// Uses the `un_node` field.
        ensure_result_non_error,
        /// Emits a compile error error union payload is not void.
        ensure_err_union_payload_void,
        /// Create a `E!T` type.
        /// Uses the `pl_node` field with `Bin` payload.
        error_union_type,
        /// `error.Foo` syntax. Uses the `str_tok` field of the Data union.
        error_value,
        /// Implements the `@export` builtin function.
        /// Uses the `pl_node` union field. Payload is `Export`.
        @"export",
        /// Given a pointer to a struct or object that contains virtual fields, returns a pointer
        /// to the named field. The field name is stored in string_bytes. Used by a.b syntax.
        /// Uses `pl_node` field. The AST node is the a.b syntax. Payload is Field.
        field_ptr,
        /// Given a pointer to a struct or object that contains virtual fields, loads from the
        /// named field.
        ///
        /// The field name is stored in string_bytes. Used by a.b syntax.
        ///
        /// This instruction also accepts a pointer.
        ///
        /// Uses `pl_node` field. The AST node is the a.b syntax. Payload is Field.
        field_ptr_load,
        /// Given a pointer to a struct or object that contains virtual fields, returns a pointer
        /// to the named field. The field name is a comptime instruction. Used by @field.
        /// Uses `pl_node` field. The AST node is the builtin call. Payload is FieldNamed.
        field_ptr_named,
        /// Given a pointer to a struct or object that contains virtual fields,
        /// loads from the named field.
        ///
        /// The field name is a comptime instruction. Used by @field.
        ///
        /// Uses `pl_node` field. The AST node is the builtin call. Payload is FieldNamed.
        field_ptr_named_load,
        /// Returns a function type, or a function instance, depending on whether
        /// the body_len is 0. Calling convention is auto.
        /// Uses the `pl_node` union field. `payload_index` points to a `Func`.
        func,
        /// Same as `func` but has an inferred error set.
        func_inferred,
        /// Represents a function declaration or function prototype, depending on
        /// whether body_len is 0.
        /// Uses the `pl_node` union field. `payload_index` points to a `FuncFancy`.
        func_fancy,
        /// Implements the `@import` builtin.
        /// Uses the `pl_tok` field.
        import,
        /// Integer literal that fits in a u64. Uses the `int` union field.
        int,
        /// Arbitrary sized integer literal. Uses the `str` union field.
        int_big,
        /// A float literal that fits in a f64. Uses the float union value.
        float,
        /// A float literal that fits in a f128. Uses the `pl_node` union value.
        /// Payload is `Float128`.
        float128,
        /// Make an integer type out of signedness and bit count.
        /// Payload is `int_type`
        int_type,
        /// Return a boolean false if an optional is null. `x != null`
        /// Uses the `un_node` field.
        is_non_null,
        /// Return a boolean false if an optional is null. `x.* != null`
        /// Uses the `un_node` field.
        is_non_null_ptr,
        /// Return a boolean false if value is an error
        /// Uses the `un_node` field.
        is_non_err,
        /// Return a boolean false if dereferenced pointer is an error
        /// Uses the `un_node` field.
        is_non_err_ptr,
        /// Same as `is_non_er` but doesn't validate that the type can be an error.
        /// Uses the `un_node` field.
        ret_is_non_err,
        /// A labeled block of code that loops forever. At the end of the body will have either
        /// a `repeat` instruction or a `repeat_inline` instruction.
        /// Uses the `pl_node` field. The AST node is either a for loop or while loop.
        /// This ZIR instruction is needed because AIR does not (yet?) match ZIR, and Sema
        /// needs to emit more than 1 AIR block for this instruction.
        /// The payload is `Block`.
        loop,
        /// Sends runtime control flow back to the beginning of the current block.
        /// Uses the `node` field.
        repeat,
        /// Sends comptime control flow back to the beginning of the current block.
        /// Uses the `node` field.
        repeat_inline,
        /// Asserts that all the lengths provided match. Used to build a for loop.
        /// Return value is the length as a usize.
        /// Uses the `pl_node` field with payload `MultiOp`.
        /// There are two items for each AST node inside the for loop condition.
        /// If both items in a pair are `.none`, then this node is an unbounded range.
        /// If only the second item in a pair is `.none`, then the first is an indexable.
        /// Otherwise, the node is a bounded range `a..b`, with the items being `a` and `b`.
        /// Illegal behaviors:
        ///  * If all lengths are unbounded ranges (always a compile error).
        ///  * If any two lengths do not match each other.
        for_len,
        /// Merge two error sets into one, `E1 || E2`.
        /// Uses the `pl_node` field with payload `Bin`.
        merge_error_sets,
        /// Turns an R-Value into a const L-Value. In other words, it takes a value,
        /// stores it in a memory location, and returns a const single-item pointer to it.
        /// If the value is `comptime`, the memory location is global static constant data.
        /// Otherwise, the memory location is in the stack frame, local to the scope
        /// containing the instruction.
        /// Uses the `un_tok` union field.
        ref,
        /// Implements the dereference operator (`.*`). Checks that operand is a pointer
        /// that supports being directly dereferenced.
        /// Uses the `un_node` union field.
        deref,
        /// Emitted when a dereference (`.*`) with a reference result location occurs.
        /// Checks that operand is a pointer that supports being directly dereferenced
        /// and returns a single-item pointer to the dereferenced memory location.
        /// Uses the `un_node` union field.
        ref_deref,
        /// Sends control flow back to the function's callee.
        /// Includes an operand as the return value.
        /// Includes an AST node source location.
        /// Uses the `un_node` union field.
        ret_node,
        /// Sends control flow back to the function's callee.
        /// The operand is a `ret_ptr` instruction, where the return value can be found.
        /// Includes an AST node source location.
        /// Uses the `un_node` union field.
        ret_load,
        /// Sends control flow back to the function's callee.
        /// Includes an operand as the return value.
        /// Includes a token source location.
        /// Uses the `un_tok` union field.
        ret_implicit,
        /// Sends control flow back to the function's callee.
        /// The return operand is `error.foo` where `foo` is given by the string.
        /// If the current function has an inferred error set, the error given by the
        /// name is added to it.
        /// Uses the `str_tok` union field.
        ret_err_value,
        /// Obtains a pointer to the return value.
        /// Uses the `node` union field.
        ret_ptr,
        /// Obtains the return type of the in-scope function.
        /// Uses the `node` union field.
        ret_type,
        /// Create a pointer type which can have a sentinel, alignment, address space, and/or bit range.
        /// Uses the `ptr_type` union field.
        ptr_type,
        /// Slice operation `lhs[rhs..]`. No sentinel and no end offset.
        /// Returns a pointer to the subslice.
        /// Uses the `pl_node` field. AST node is the slice syntax. Payload is `SliceStart`.
        slice_start,
        /// Slice operation `array_ptr[start..end]`. No sentinel.
        /// Returns a pointer to the subslice.
        /// Uses the `pl_node` field. AST node is the slice syntax. Payload is `SliceEnd`.
        slice_end,
        /// Slice operation `array_ptr[start..end:sentinel]`.
        /// Returns a pointer to the subslice.
        /// Uses the `pl_node` field. AST node is the slice syntax. Payload is `SliceSentinel`.
        slice_sentinel,
        /// Slice operation `array_ptr[start..][0..len]`. Optional sentinel.
        /// Returns a pointer to the subslice.
        /// Uses the `pl_node` field. AST node is the slice syntax. Payload is `SliceLength`.
        slice_length,
        /// Given a value which is a pointer to the LHS of a slice operation, return the sentinel
        /// type, used as the result type of the slice sentinel (i.e. `s` in `lhs[a..b :s]`).
        /// Uses the `un_node` field. AST node is the slice syntax. Operand is `lhs`.
        slice_sentinel_ty,
        /// Same as `store` except provides a source location.
        /// Uses the `pl_node` union field. Payload is `Bin`.
        store_node,
        /// Same as `store_node` but the type of the value being stored will be
        /// used to infer the pointer type of an `alloc_inferred`.
        /// Uses the `pl_node` union field. Payload is `Bin`.
        store_to_inferred_ptr,
        /// String Literal. Makes an anonymous Decl and then takes a pointer to it.
        /// Uses the `str` union field.
        str,
        /// Arithmetic negation. Asserts no integer overflow.
        /// Same as sub with a lhs of 0, split into a separate instruction to save memory.
        /// Uses `un_node`.
        negate,
        /// Twos complement wrapping integer negation.
        /// Same as subwrap with a lhs of 0, split into a separate instruction to save memory.
        /// Uses `un_node`.
        negate_wrap,
        /// Returns the type of a value.
        /// Uses the `un_node` field.
        typeof,
        /// Implements `@TypeOf` for one operand.
        /// Uses the `pl_node` field. Payload is `Block`.
        typeof_builtin,
        /// Given a value, look at the type of it, which must be an integer type.
        /// Returns the integer type for the RHS of a shift operation.
        /// Uses the `un_node` field.
        typeof_log2_int_type,
        /// Asserts control-flow will not reach this instruction (`unreachable`).
        /// Uses the `@"unreachable"` union field.
        @"unreachable",
        /// Bitwise XOR. `^`
        /// Uses the `pl_node` union field. Payload is `Bin`.
        xor,
        /// Create an optional type '?T'
        /// Uses the `un_node` field.
        optional_type,
        /// ?T => T with safety.
        /// Given an optional value, returns the payload value, with a safety check that
        /// the value is non-null. Used for `orelse`, `if` and `while`.
        /// Uses the `un_node` field.
        optional_payload_safe,
        /// ?T => T without safety.
        /// Given an optional value, returns the payload value. No safety checks.
        /// Uses the `un_node` field.
        optional_payload_unsafe,
        /// *?T => *T with safety.
        /// Given a pointer to an optional value, returns a pointer to the payload value,
        /// with a safety check that the value is non-null. Used for `orelse`, `if` and `while`.
        /// Uses the `un_node` field.
        optional_payload_safe_ptr,
        /// *?T => *T without safety.
        /// Given a pointer to an optional value, returns a pointer to the payload value.
        /// No safety checks.
        /// Uses the `un_node` field.
        optional_payload_unsafe_ptr,
        /// E!T => T without safety.
        /// Given an error union value, returns the payload value. No safety checks.
        /// Uses the `un_node` field.
        err_union_payload_unsafe,
        /// *E!T => *T without safety.
        /// Given a pointer to a error union value, returns a pointer to the payload value.
        /// No safety checks.
        /// Uses the `un_node` field.
        err_union_payload_unsafe_ptr,
        /// E!T => E without safety.
        /// Given an error union value, returns the error code. No safety checks.
        /// Uses the `un_node` field.
        err_union_code,
        /// *E!T => E without safety.
        /// Given a pointer to an error union value, returns the error code. No safety checks.
        /// Uses the `un_node` field.
        err_union_code_ptr,
        /// An enum literal. Uses the `str_tok` union field.
        enum_literal,
        /// A decl literal. This is similar to `field`, but unwraps error unions and optionals,
        /// and coerces the result to the given type.
        /// Uses the `pl_node` union field. Payload is `Field`.
        decl_literal,
        /// The same as `decl_literal`, but the coercion is omitted. This is used for decl literal
        /// function call syntax, i.e. `.foo()`.
        /// Uses the `pl_node` union field. Payload is `Field`.
        decl_literal_no_coerce,
        /// A switch expression. Uses the `pl_node` union field.
        /// AST node is the switch, payload is `SwitchBlock`.
        switch_block,
        /// A switch expression. Uses the `pl_node` union field.
        /// AST node is the switch, payload is `SwitchBlock`. Operand is a pointer.
        switch_block_ref,
        /// A switch on an error union:
        /// - `eu catch |err| switch (err) {...}`, AST node is the `catch`.
        /// - `if (eu) |payload| {...} else |err| {...}`, AST node is the `if`.
        /// Uses the `pl_node` union field. Payload is `SwitchBlock`.
        switch_block_err_union,
        /// Check that the operand's type is an array or tuple with the given number of elements.
        /// Uses the `pl_node` field. Payload is `ValidateDestructure`.
        validate_destructure,
        /// Given a struct or union, and a field name as a Ref,
        /// returns the field type. Uses the `pl_node` field. Payload is `FieldTypeRef`.
        field_type_ref,
        /// Given a pointer, initializes all error unions and optionals in the pointee to payloads,
        /// returning the base payload pointer. For instance, converts *E!?T into a valid *T
        /// (clobbering any existing error or null value).
        /// Uses the `un_node` field.
        opt_eu_base_ptr_init,
        /// Coerce a given value such that when a reference is taken, the resulting pointer will be
        /// coercible to the given type. For instance, given a value of type 'u32' and the pointer
        /// type '*u64', coerces the value to a 'u64'. Asserts that the type is a pointer type.
        /// Uses the `pl_node` field. Payload is `Bin`.
        /// LHS is the pointer type, RHS is the value.
        coerce_ptr_elem_ty,
        /// Given a type, validate that it is a pointer type suitable for return from the address-of
        /// operator. Emit a compile error if not.
        /// Uses the `un_tok` union field. Token is the `&` operator. Operand is the type.
        validate_ref_ty,
        /// Given a value, check whether it is a valid local constant in this scope.
        /// In a runtime scope, this is always a nop.
        /// In a comptime scope, raises a compile error if the value is runtime-known.
        /// Result is always void.
        /// Uses the `un_node` union field. Node is the initializer. Operand is the initializer value.
        validate_const,

        // The following tags all relate to struct initialization expressions.

        /// A struct literal with a specified explicit type, with no fields.
        /// Uses the `un_node` field.
        struct_init_empty,
        /// An anonymous struct literal with a known result type, with no fields.
        /// Uses the `un_node` field.
        struct_init_empty_result,
        /// An anonymous struct literal with no fields, returned by reference, with a known result
        /// type for the pointer. Asserts that the type is a pointer.
        /// Uses the `un_node` field.
        struct_init_empty_ref_result,
        /// Struct initialization without a type. Creates a value of an anonymous struct type.
        /// Uses the `pl_node` field. Payload is `StructInitAnon`.
        struct_init_anon,
        /// Finalizes a typed struct or union initialization, performs validation, and returns the
        /// struct or union value. The given type must be validated prior to this instruction, using
        /// `validate_struct_init_ty` or `validate_struct_init_result_ty`. If the given type is
        /// generic poison, this is downgraded to an anonymous initialization.
        /// Uses the `pl_node` field. Payload is `StructInit`.
        struct_init,
        /// Struct initialization syntax, make the result a pointer. Equivalent to `struct_init`
        /// followed by `ref` - this ZIR tag exists as an optimization for a common pattern.
        /// Uses the `pl_node` field. Payload is `StructInit`.
        struct_init_ref,
        /// Checks that the type supports struct init syntax. Always returns void.
        /// Uses the `un_node` field.
        validate_struct_init_ty,
        /// Like `validate_struct_init_ty`, but additionally accepts types which structs coerce to.
        /// Used on the known result type of a struct init expression. Always returns void.
        /// Uses the `un_node` field.
        validate_struct_init_result_ty,
        /// Given a set of `struct_init_field_ptr` instructions, assumes they are all part of a
        /// struct initialization expression, and emits compile errors for duplicate fields as well
        /// as missing fields, if applicable.
        /// This instruction asserts that there is at least one struct_init_field_ptr instruction,
        /// because it must use one of them to find out the struct type.
        /// Uses the `pl_node` field. Payload is `Block`.
        validate_ptr_struct_init,
        /// Given a type being used for a struct initialization expression, returns the type of the
        /// field with the given name.
        /// Uses the `pl_node` field. Payload is `FieldType`.
        struct_init_field_type,
        /// Given a pointer being used as the result pointer of a struct initialization expression,
        /// return a pointer to the field of the given name.
        /// Uses the `pl_node` field. The AST node is the field initializer. Payload is Field.
        struct_init_field_ptr,

        // The following tags all relate to array initialization expressions.

        /// Array initialization without a type. Creates a value of a tuple type.
        /// Uses the `pl_node` field. Payload is `MultiOp`.
        array_init_anon,
        /// Array initialization syntax with a known type. The given type must be validated prior to
        /// this instruction, using some `validate_array_init_*_ty` instruction.
        /// Uses the `pl_node` field. Payload is `MultiOp`, where the first operand is the type.
        array_init,
        /// Array initialization syntax, make the result a pointer. Equivalent to `array_init`
        /// followed by `ref`- this ZIR tag exists as an optimization for a common pattern.
        /// Uses the `pl_node` field. Payload is `MultiOp`, where the first operand is the type.
        array_init_ref,
        /// Checks that the type supports array init syntax. Always returns void.
        /// Uses the `pl_node` field. Payload is `ArrayInit`.
        validate_array_init_ty,
        /// Like `validate_array_init_ty`, but additionally accepts types which arrays coerce to.
        /// Used on the known result type of an array init expression. Always returns void.
        /// Uses the `pl_node` field. Payload is `ArrayInit`.
        validate_array_init_result_ty,
        /// Given a pointer or slice type and an element count, return the expected type of an array
        /// initializer such that a pointer to the initializer has the given pointer type, checking
        /// that this type supports array init syntax and emitting a compile error if not. Preserves
        /// error union and optional wrappers on the array type, if any.
        /// Asserts that the given type is a pointer or slice type.
        /// Uses the `pl_node` field. Payload is `ArrayInitRefTy`.
        validate_array_init_ref_ty,
        /// Given a set of `array_init_elem_ptr` instructions, assumes they are all part of an array
        /// initialization expression, and emits a compile error if the number of elements does not
        /// match the array type.
        /// This instruction asserts that there is at least one `array_init_elem_ptr` instruction,
        /// because it must use one of them to find out the array type.
        /// Uses the `pl_node` field. Payload is `Block`.
        validate_ptr_array_init,
        /// Given a type being used for an array initialization expression, returns the type of the
        /// element at the given index.
        /// Uses the `bin` union field. lhs is the indexable type, rhs is the index.
        array_init_elem_type,
        /// Given a pointer being used as the result pointer of an array initialization expression,
        /// return a pointer to the element at the given index.
        /// Uses the `pl_node` union field. AST node is an element inside array initialization
        /// syntax. Payload is `ElemPtrImm`.
        array_init_elem_ptr,

        /// Implements the `@unionInit` builtin.
        /// Uses the `pl_node` field. Payload is `UnionInit`.
        union_init,
        /// Implements the `@typeInfo` builtin. Uses `un_node`.
        type_info,
        /// Implements the `@sizeOf` builtin. Uses `un_node`.
        size_of,
        /// Implements the `@bitSizeOf` builtin. Uses `un_node`.
        bit_size_of,

        /// Implement builtin `@intFromPtr`. Uses `un_node`.
        /// Convert a pointer to a `usize` integer.
        int_from_ptr,
        /// Emit an error message and fail compilation.
        /// Uses the `un_node` field.
        compile_error,
        /// Changes the maximum number of backwards branches that compile-time
        /// code execution can use before giving up and making a compile error.
        /// Uses the `un_node` union field.
        set_eval_branch_quota,
        /// Converts an enum value into an integer. Resulting type will be the tag type
        /// of the enum. Uses `un_node`.
        int_from_enum,
        /// Implements the `@backingInt` builtin.
        /// Uses `un_node`.
        backing_int,
        /// Implement builtin `@alignOf`. Uses `un_node`.
        align_of,
        /// Implement builtin `@intFromBool`. Uses `un_node`.
        int_from_bool,
        /// Implement builtin `@embedFile`. Uses `un_node`.
        embed_file,
        /// Implement builtin `@errorName`. Uses `un_node`.
        error_name,
        /// Implement builtin `@panic`. Uses `un_node`.
        panic,
        /// Implements `@trap`.
        /// Uses the `node` field.
        trap,
        /// Implement builtin `@setRuntimeSafety`. Uses `un_node`.
        set_runtime_safety,
        /// Implement builtin `@sqrt`. Uses `un_node`.
        sqrt,
        /// Implement builtin `@sin`. Uses `un_node`.
        sin,
        /// Implement builtin `@cos`. Uses `un_node`.
        cos,
        /// Implement builtin `@tan`. Uses `un_node`.
        tan,
        /// Implement builtin `@exp`. Uses `un_node`.
        exp,
        /// Implement builtin `@exp2`. Uses `un_node`.
        exp2,
        /// Implement builtin `@log`. Uses `un_node`.
        log,
        /// Implement builtin `@log2`. Uses `un_node`.
        log2,
        /// Implement builtin `@log10`. Uses `un_node`.
        log10,
        /// Implement builtin `@abs`. Uses `un_node`.
        abs,
        /// Implement builtin `@floor`. Uses `un_node`.
        floor,
        /// Implement builtin `@ceil`. Uses `un_node`.
        ceil,
        /// Implement builtin `@trunc`. Uses `un_node`.
        trunc,
        /// Implement builtin `@round`. Uses `un_node`.
        round,
        /// Implement builtin `@tagName`. Uses `un_node`.
        tag_name,
        /// Implement builtin `@typeName`. Uses `un_node`.
        type_name,
        /// Implement builtin `@Frame`. Uses `un_node`.
        frame_type,

        /// Implements the `@intFromFloat` builtin.
        /// Uses `pl_node` with payload `Bin`. `lhs` is dest type, `rhs` is operand.
        int_from_float,
        /// Implements the `@floatFromInt` builtin.
        /// Uses `pl_node` with payload `Bin`. `lhs` is dest type, `rhs` is operand.
        float_from_int,
        /// Implements the `@ptrFromInt` builtin.
        /// Uses `pl_node` with payload `Bin`. `lhs` is dest type, `rhs` is operand.
        ptr_from_int,
        /// Converts an integer into an enum value.
        /// Uses `pl_node` with payload `Bin`. `lhs` is dest type, `rhs` is operand.
        enum_from_int,
        /// Implements the `@fromBackingInt` builtin.
        /// Uses `pl_node` with payload `Bin`. `lhs` is dest type, `rhs` is operand.
        from_backing_int,
        /// Convert a larger float type to any other float type, possibly causing
        /// a loss of precision.
        /// Uses the `pl_node` field. AST is the `@floatCast` syntax.
        /// Payload is `Bin` with lhs as the dest type, rhs the operand.
        float_cast,
        /// Implements the `@intCast` builtin.
        /// Uses `pl_node` with payload `Bin`. `lhs` is dest type, `rhs` is operand.
        /// Convert an integer value to another integer type, asserting that the destination type
        /// can hold the same mathematical value.
        int_cast,
        /// Implements the `@ptrCast` builtin.
        /// Uses `pl_node` with payload `Bin`. `lhs` is dest type, `rhs` is operand.
        /// Not every `@ptrCast` will correspond to this instruction - see also
        /// `ptr_cast_full` in `Extended`.
        ptr_cast,
        /// Implements the `@truncate` builtin.
        /// Uses `pl_node` with payload `Bin`. `lhs` is dest type, `rhs` is operand.
        truncate,

        /// Implements the `@hasDecl` builtin.
        /// Uses the `pl_node` union field. Payload is `Bin`.
        has_decl,
        /// Implements the `@hasField` builtin.
        /// Uses the `pl_node` union field. Payload is `Bin`.
        has_field,

        /// Implements the `@clz` builtin. Uses the `un_node` union field.
        clz,
        /// Implements the `@ctz` builtin. Uses the `un_node` union field.
        ctz,
        /// Implements the `@popCount` builtin. Uses the `un_node` union field.
        pop_count,
        /// Implements the `@byteSwap` builtin. Uses the `un_node` union field.
        byte_swap,
        /// Implements the `@bitReverse` builtin. Uses the `un_node` union field.
        bit_reverse,

        /// Implements the `@bitOffsetOf` builtin.
        /// Uses the `pl_node` union field with payload `Bin`.
        bit_offset_of,
        /// Implements the `@offsetOf` builtin.
        /// Uses the `pl_node` union field with payload `Bin`.
        offset_of,
        /// Implements the `@splat` builtin.
        /// Uses the `pl_node` union field with payload `Bin`.
        splat,
        /// Implements the `@reduce` builtin.
        /// Uses the `pl_node` union field with payload `Bin`.
        reduce,
        /// Implements the `@shuffle` builtin.
        /// Uses the `pl_node` union field with payload `Shuffle`.
        shuffle,
        /// Implements the `@atomicLoad` builtin.
        /// Uses the `pl_node` union field with payload `AtomicLoad`.
        atomic_load,
        /// Implements the `@atomicRmw` builtin.
        /// Uses the `pl_node` union field with payload `AtomicRmw`.
        atomic_rmw,
        /// Implements the `@atomicStore` builtin.
        /// Uses the `pl_node` union field with payload `AtomicStore`.
        atomic_store,
        /// Implements the `@mulAdd` builtin.
        /// Uses the `pl_node` union field with payload `MulAdd`.
        /// The addend communicates the type of the builtin.
        /// The mulends need to be coerced to the same type.
        mul_add,
        /// Implements the `@memcpy` builtin.
        /// Uses the `pl_node` union field with payload `Bin`.
        memcpy,
        /// Implements the `@memmove` builtin.
        /// Uses the `pl_node` union field with payload `Bin`.
        memmove,
        /// Implements the `@memset` builtin.
        /// Uses the `pl_node` union field with payload `Bin`.
        memset,
        /// Implements the `@min` builtin for 2 args.
        /// Uses the `pl_node` union field with payload `Bin`
        min,
        /// Implements the `@max` builtin for 2 args.
        /// Uses the `pl_node` union field with payload `Bin`
        max,

        /// Allocates stack local memory.
        /// Uses the `un_node` union field. The operand is the type of the allocated object.
        /// The node source location points to a var decl node.
        /// A `make_ptr_const` instruction should be used once the value has
        /// been stored to the allocation. To ensure comptime value detection
        /// functions, there are some restrictions on how this pointer should be
        /// used prior to the `make_ptr_const` instruction: no pointer derived
        /// from this `alloc` may be returned from a block or stored to another
        /// address. In other words, it must be trivial to determine whether any
        /// given pointer derives from this one.
        alloc,
        /// Same as `alloc` except mutable. As such, `make_ptr_const` need not be used,
        /// and there are no restrictions on the usage of the pointer.
        alloc_mut,
        /// Allocates comptime-mutable memory.
        /// Uses the `un_node` union field. The operand is the type of the allocated object.
        /// The node source location points to a var decl node.
        alloc_comptime_mut,
        /// Same as `alloc` except the type is inferred.
        /// Uses the `node` union field.
        alloc_inferred,
        /// Same as `alloc_inferred` except mutable.
        alloc_inferred_mut,
        /// Allocates comptime const memory.
        /// Uses the `node` union field. The type of the allocated object is inferred.
        /// The node source location points to a var decl node.
        alloc_inferred_comptime,
        /// Same as `alloc_comptime_mut` except the type is inferred.
        alloc_inferred_comptime_mut,
        /// Each `store_to_inferred_ptr` puts the type of the stored value into a set,
        /// and then `resolve_inferred_alloc` triggers peer type resolution on the set.
        /// The operand is a `alloc_inferred` or `alloc_inferred_mut` instruction, which
        /// is the allocation that needs to have its type inferred.
        /// Results in the final resolved pointer. The `alloc_inferred[_comptime][_mut]`
        /// instruction should never be referred to after this instruction.
        /// Uses the `un_node` field. The AST node is the var decl.
        resolve_inferred_alloc,
        /// Turns a pointer coming from an `alloc` or `Extended.alloc` into a constant
        /// version of the same pointer. For inferred allocations this is instead implicitly
        /// handled by the `resolve_inferred_alloc` instruction.
        /// Uses the `un_node` union field.
        make_ptr_const,

        /// Implements `resume` syntax. Uses `un_node` field.
        @"resume",

        /// A defer statement.
        /// Uses the `defer` union field.
        @"defer",

        /// Requests that Sema update the saved error return trace index for the enclosing
        /// block, if the operand is .none or of an error/error-union type.
        /// Uses the `save_err_ret_index` field.
        save_err_ret_index,
        /// Specialized form of `Extended.restore_err_ret_index`.
        /// Unconditionally restores the error return index to its last saved state
        /// in the block referred to by `operand`. If `operand` is `none`, restores
        /// to the point of function entry.
        /// Uses the `un_node` field.
        restore_err_ret_index_unconditional,
        /// Specialized form of `Extended.restore_err_ret_index`.
        /// Restores the error return index to its state at the entry of
        /// the current function conditional on `operand` being a non-error.
        /// If `operand` is `none`, restores unconditionally.
        /// Uses the `un_node` field.
        restore_err_ret_index_fn_entry,

        /// The ZIR instruction tag is one of the `Extended` ones.
        /// Uses the `extended` union field.
        extended,

        /// Returns whether the instruction is one of the control flow "noreturn" types.
        /// Function calls do not count.
        pub fn isNoReturn(tag: Tag) bool {
            return switch (tag) {
                .param,
                .param_comptime,
                .param_anytype,
                .param_anytype_comptime,
                .add,
                .addwrap,
                .add_sat,
                .add_unsafe,
                .alloc,
                .alloc_mut,
                .alloc_comptime_mut,
                .alloc_inferred,
                .alloc_inferred_mut,
                .alloc_inferred_comptime,
                .alloc_inferred_comptime_mut,
                .make_ptr_const,
                .array_cat,
                .array_type,
                .array_type_sentinel,
                .reify_int,
                .vector_type,
                .elem_type,
                .indexable_ptr_elem_type,
                .splat_op_result_ty,
                .from_backing_int_arg_ty,
                .indexable_ptr_len,
                .anyframe_type,
                .as_node,
                .as_shift_operand,
                .bit_and,
                .bitcast,
                .bit_or,
                .block,
                .block_comptime,
                .block_inline,
                .declaration,
                .suspend_block,
                .loop,
                .bool_br_and,
                .bool_br_or,
                .bool_not,
                .call,
                .field_call,
                .cmp_lt,
                .cmp_lte,
                .cmp_eq,
                .cmp_gte,
                .cmp_gt,
                .cmp_neq,
                .error_set_decl,
                .dbg_stmt,
                .dbg_var_ptr,
                .dbg_var_val,
                .decl_ref,
                .decl_val,
                .load,
                .div,
                .elem_ptr,
                .elem_val,
                .elem_ptr_node,
                .elem_ptr_load,
                .elem_val_imm,
                .ensure_result_used,
                .ensure_result_non_error,
                .ensure_err_union_payload_void,
                .@"export",
                .field_ptr,
                .field_ptr_load,
                .field_ptr_named,
                .field_ptr_named_load,
                .func,
                .func_inferred,
                .func_fancy,
                .has_decl,
                .int,
                .int_big,
                .float,
                .float128,
                .int_type,
                .is_non_null,
                .is_non_null_ptr,
                .is_non_err,
                .is_non_err_ptr,
                .ret_is_non_err,
                .mod_rem,
                .mul,
                .mulwrap,
                .mul_sat,
                .ref,
                .deref,
                .ref_deref,
                .shl,
                .shl_sat,
                .shr,
                .store_node,
                .store_to_inferred_ptr,
                .str,
                .sub,
                .subwrap,
                .sub_sat,
                .negate,
                .negate_wrap,
                .typeof,
                .typeof_builtin,
                .xor,
                .optional_type,
                .optional_payload_safe,
                .optional_payload_unsafe,
                .optional_payload_safe_ptr,
                .optional_payload_unsafe_ptr,
                .err_union_payload_unsafe,
                .err_union_payload_unsafe_ptr,
                .err_union_code,
                .err_union_code_ptr,
                .ptr_type,
                .enum_literal,
                .decl_literal,
                .decl_literal_no_coerce,
                .merge_error_sets,
                .error_union_type,
                .bit_not,
                .error_value,
                .slice_start,
                .slice_end,
                .slice_sentinel,
                .slice_length,
                .slice_sentinel_ty,
                .import,
                .typeof_log2_int_type,
                .resolve_inferred_alloc,
                .set_eval_branch_quota,
                .switch_block,
                .switch_block_ref,
                .switch_block_err_union,
                .validate_destructure,
                .union_init,
                .field_type_ref,
                .enum_from_int,
                .int_from_enum,
                .backing_int,
                .from_backing_int,
                .type_info,
                .size_of,
                .bit_size_of,
                .int_from_ptr,
                .align_of,
                .int_from_bool,
                .embed_file,
                .error_name,
                .set_runtime_safety,
                .sqrt,
                .sin,
                .cos,
                .tan,
                .exp,
                .exp2,
                .log,
                .log2,
                .log10,
                .abs,
                .floor,
                .ceil,
                .trunc,
                .round,
                .tag_name,
                .type_name,
                .frame_type,
                .int_from_float,
                .float_from_int,
                .ptr_from_int,
                .float_cast,
                .int_cast,
                .ptr_cast,
                .truncate,
                .has_field,
                .clz,
                .ctz,
                .pop_count,
                .byte_swap,
                .bit_reverse,
                .div_exact,
                .div_floor,
                .div_ceil,
                .div_trunc,
                .mod,
                .rem,
                .shl_exact,
                .shr_exact,
                .bit_offset_of,
                .offset_of,
                .splat,
                .reduce,
                .shuffle,
                .atomic_load,
                .atomic_rmw,
                .atomic_store,
                .mul_add,
                .builtin_call,
                .max,
                .memcpy,
                .memset,
                .memmove,
                .min,
                .@"resume",
                .extended,
                .ret_ptr,
                .ret_type,
                .@"try",
                .try_ptr,
                .@"defer",
                .save_err_ret_index,
                .for_len,
                .opt_eu_base_ptr_init,
                .coerce_ptr_elem_ty,
                .struct_init_empty,
                .struct_init_empty_result,
                .struct_init_empty_ref_result,
                .struct_init_anon,
                .struct_init,
                .struct_init_ref,
                .validate_struct_init_ty,
                .validate_struct_init_result_ty,
                .validate_ptr_struct_init,
                .struct_init_field_type,
                .struct_init_field_ptr,
                .array_init_anon,
                .array_init,
                .array_init_ref,
                .validate_array_init_ty,
                .validate_array_init_result_ty,
                .validate_array_init_ref_ty,
                .validate_ptr_array_init,
                .array_init_elem_type,
                .array_init_elem_ptr,
                .validate_ref_ty,
                .validate_const,
                .restore_err_ret_index_unconditional,
                .restore_err_ret_index_fn_entry,
                => false,

                .@"break",
                .break_inline,
                .condbr,
                .condbr_inline,
                .compile_error,
                .ret_node,
                .ret_load,
                .ret_implicit,
                .ret_err_value,
                .@"unreachable",
                .repeat,
                .repeat_inline,
                .panic,
                .trap,
                .check_comptime_control_flow,
                .switch_continue,
                => true,
            };
        }

        /// AstGen uses this to find out if `Ref.void_value` should be used in place
        /// of the result of a given instruction. This allows Sema to forego adding
        /// the instruction to the map after analysis.
        pub fn isAlwaysVoid(tag: Tag, data: Data) bool {
            return switch (tag) {
                .dbg_stmt,
                .dbg_var_ptr,
                .dbg_var_val,
                .ensure_result_used,
                .ensure_result_non_error,
                .ensure_err_union_payload_void,
                .set_eval_branch_quota,
                .atomic_store,
                .store_node,
                .store_to_inferred_ptr,
                .validate_destructure,
                .@"export",
                .set_runtime_safety,
                .memcpy,
                .memset,
                .memmove,
                .check_comptime_control_flow,
                .@"defer",
                .save_err_ret_index,
                .restore_err_ret_index_unconditional,
                .restore_err_ret_index_fn_entry,
                .validate_struct_init_ty,
                .validate_struct_init_result_ty,
                .validate_ptr_struct_init,
                .validate_array_init_ty,
                .validate_array_init_result_ty,
                .validate_ptr_array_init,
                .validate_ref_ty,
                .validate_const,
                => true,

                .param,
                .param_comptime,
                .param_anytype,
                .param_anytype_comptime,
                .add,
                .addwrap,
                .add_sat,
                .add_unsafe,
                .alloc,
                .alloc_mut,
                .alloc_comptime_mut,
                .alloc_inferred,
                .alloc_inferred_mut,
                .alloc_inferred_comptime,
                .alloc_inferred_comptime_mut,
                .resolve_inferred_alloc,
                .make_ptr_const,
                .array_cat,
                .array_type,
                .array_type_sentinel,
                .reify_int,
                .vector_type,
                .elem_type,
                .indexable_ptr_elem_type,
                .splat_op_result_ty,
                .from_backing_int_arg_ty,
                .indexable_ptr_len,
                .anyframe_type,
                .as_node,
                .as_shift_operand,
                .bit_and,
                .bitcast,
                .bit_or,
                .block,
                .block_comptime,
                .block_inline,
                .declaration,
                .suspend_block,
                .loop,
                .bool_br_and,
                .bool_br_or,
                .bool_not,
                .call,
                .field_call,
                .cmp_lt,
                .cmp_lte,
                .cmp_eq,
                .cmp_gte,
                .cmp_gt,
                .cmp_neq,
                .error_set_decl,
                .decl_ref,
                .decl_val,
                .load,
                .div,
                .elem_ptr,
                .elem_val,
                .elem_ptr_node,
                .elem_ptr_load,
                .elem_val_imm,
                .field_ptr,
                .field_ptr_load,
                .field_ptr_named,
                .field_ptr_named_load,
                .func,
                .func_inferred,
                .func_fancy,
                .has_decl,
                .int,
                .int_big,
                .float,
                .float128,
                .int_type,
                .is_non_null,
                .is_non_null_ptr,
                .is_non_err,
                .is_non_err_ptr,
                .ret_is_non_err,
                .mod_rem,
                .mul,
                .mulwrap,
                .mul_sat,
                .ref,
                .deref,
                .ref_deref,
                .shl,
                .shl_sat,
                .shr,
                .str,
                .sub,
                .subwrap,
                .sub_sat,
                .negate,
                .negate_wrap,
                .typeof,
                .typeof_builtin,
                .xor,
                .optional_type,
                .optional_payload_safe,
                .optional_payload_unsafe,
                .optional_payload_safe_ptr,
                .optional_payload_unsafe_ptr,
                .err_union_payload_unsafe,
                .err_union_payload_unsafe_ptr,
                .err_union_code,
                .err_union_code_ptr,
                .ptr_type,
                .enum_literal,
                .decl_literal,
                .decl_literal_no_coerce,
                .merge_error_sets,
                .error_union_type,
                .bit_not,
                .error_value,
                .slice_start,
                .slice_end,
                .slice_sentinel,
                .slice_length,
                .slice_sentinel_ty,
                .import,
                .typeof_log2_int_type,
                .switch_block,
                .switch_block_ref,
                .switch_block_err_union,
                .union_init,
                .field_type_ref,
                .enum_from_int,
                .int_from_enum,
                .backing_int,
                .from_backing_int,
                .type_info,
                .size_of,
                .bit_size_of,
                .int_from_ptr,
                .align_of,
                .int_from_bool,
                .embed_file,
                .error_name,
                .sqrt,
                .sin,
                .cos,
                .tan,
                .exp,
                .exp2,
                .log,
                .log2,
                .log10,
                .abs,
                .floor,
                .ceil,
                .trunc,
                .round,
                .tag_name,
                .type_name,
                .frame_type,
                .int_from_float,
                .float_from_int,
                .ptr_from_int,
                .float_cast,
                .int_cast,
                .ptr_cast,
                .truncate,
                .has_field,
                .clz,
                .ctz,
                .pop_count,
                .byte_swap,
                .bit_reverse,
                .div_exact,
                .div_floor,
                .div_ceil,
                .div_trunc,
                .mod,
                .rem,
                .shl_exact,
                .shr_exact,
                .bit_offset_of,
                .offset_of,
                .splat,
                .reduce,
                .shuffle,
                .atomic_load,
                .atomic_rmw,
                .mul_add,
                .builtin_call,
                .max,
                .min,
                .@"resume",
                .@"break",
                .break_inline,
                .condbr,
                .condbr_inline,
                .switch_continue,
                .compile_error,
                .ret_node,
                .ret_load,
                .ret_implicit,
                .ret_err_value,
                .ret_ptr,
                .ret_type,
                .@"unreachable",
                .repeat,
                .repeat_inline,
                .panic,
                .trap,
                .for_len,
                .@"try",
                .try_ptr,
                .opt_eu_base_ptr_init,
                .coerce_ptr_elem_ty,
                .struct_init_empty,
                .struct_init_empty_result,
                .struct_init_empty_ref_result,
                .struct_init_anon,
                .struct_init,
                .struct_init_ref,
                .struct_init_field_type,
                .struct_init_field_ptr,
                .array_init_anon,
                .array_init,
                .array_init_ref,
                .validate_array_init_ref_ty,
                .array_init_elem_type,
                .array_init_elem_ptr,
                => false,

                .extended => switch (data.extended.opcode) {
                    .branch_hint,
                    .breakpoint,
                    .disable_instrumentation,
                    .disable_intrinsics,
                    => true,
                    else => false,
                },
            };
        }

        /// Used by debug safety-checking code.
        pub const data_tags = list: {
            @setEvalBranchQuota(2000);
            break :list std.enums.directEnumArray(Tag, Data.FieldEnum, 0, .{
                .add = .pl_node,
                .addwrap = .pl_node,
                .add_sat = .pl_node,
                .add_unsafe = .pl_node,
                .sub = .pl_node,
                .subwrap = .pl_node,
                .sub_sat = .pl_node,
                .mul = .pl_node,
                .mulwrap = .pl_node,
                .mul_sat = .pl_node,

                .param = .pl_tok,
                .param_comptime = .pl_tok,
                .param_anytype = .str_tok,
                .param_anytype_comptime = .str_tok,
                .array_cat = .pl_node,
                .array_type = .pl_node,
                .array_type_sentinel = .pl_node,
                .reify_int = .pl_node,
                .vector_type = .pl_node,
                .elem_type = .un_node,
                .indexable_ptr_elem_type = .un_node,
                .splat_op_result_ty = .un_node,
                .from_backing_int_arg_ty = .un_node,
                .indexable_ptr_len = .un_node,
                .anyframe_type = .un_node,
                .as_node = .pl_node,
                .as_shift_operand = .pl_node,
                .bit_and = .pl_node,
                .bitcast = .pl_node,
                .bit_not = .un_node,
                .bit_or = .pl_node,
                .block = .pl_node,
                .block_comptime = .pl_node,
                .block_inline = .pl_node,
                .declaration = .declaration,
                .suspend_block = .pl_node,
                .bool_not = .un_node,
                .bool_br_and = .pl_node,
                .bool_br_or = .pl_node,
                .@"break" = .@"break",
                .break_inline = .@"break",
                .switch_continue = .@"break",
                .check_comptime_control_flow = .un_node,
                .for_len = .pl_node,
                .call = .pl_node,
                .field_call = .pl_node,
                .cmp_lt = .pl_node,
                .cmp_lte = .pl_node,
                .cmp_eq = .pl_node,
                .cmp_gte = .pl_node,
                .cmp_gt = .pl_node,
                .cmp_neq = .pl_node,
                .condbr = .pl_node,
                .condbr_inline = .pl_node,
                .@"try" = .pl_node,
                .try_ptr = .pl_node,
                .error_set_decl = .pl_node,
                .dbg_stmt = .dbg_stmt,
                .dbg_var_ptr = .str_op,
                .dbg_var_val = .str_op,
                .decl_ref = .str_tok,
                .decl_val = .str_tok,
                .load = .un_node,
                .div = .pl_node,
                .elem_ptr = .pl_node,
                .elem_ptr_node = .pl_node,
                .elem_val = .pl_node,
                .elem_ptr_load = .pl_node,
                .elem_val_imm = .elem_val_imm,
                .ensure_result_used = .un_node,
                .ensure_result_non_error = .un_node,
                .ensure_err_union_payload_void = .un_node,
                .error_union_type = .pl_node,
                .error_value = .str_tok,
                .@"export" = .pl_node,
                .field_ptr = .pl_node,
                .field_ptr_load = .pl_node,
                .field_ptr_named = .pl_node,
                .field_ptr_named_load = .pl_node,
                .func = .pl_node,
                .func_inferred = .pl_node,
                .func_fancy = .pl_node,
                .import = .pl_tok,
                .int = .int,
                .int_big = .str,
                .float = .float,
                .float128 = .pl_node,
                .int_type = .int_type,
                .is_non_null = .un_node,
                .is_non_null_ptr = .un_node,
                .is_non_err = .un_node,
                .is_non_err_ptr = .un_node,
                .ret_is_non_err = .un_node,
                .loop = .pl_node,
                .repeat = .node,
                .repeat_inline = .node,
                .merge_error_sets = .pl_node,
                .mod_rem = .pl_node,
                .ref = .un_tok,
                .deref = .un_node,
                .ref_deref = .un_node,
                .ret_node = .un_node,
                .ret_load = .un_node,
                .ret_implicit = .un_tok,
                .ret_err_value = .str_tok,
                .ret_ptr = .node,
                .ret_type = .node,
                .ptr_type = .ptr_type,
                .slice_start = .pl_node,
                .slice_end = .pl_node,
                .slice_sentinel = .pl_node,
                .slice_length = .pl_node,
                .slice_sentinel_ty = .un_node,
                .store_node = .pl_node,
                .store_to_inferred_ptr = .pl_node,
                .str = .str,
                .negate = .un_node,
                .negate_wrap = .un_node,
                .typeof = .un_node,
                .typeof_log2_int_type = .un_node,
                .@"unreachable" = .@"unreachable",
                .xor = .pl_node,
                .optional_type = .un_node,
                .optional_payload_safe = .un_node,
                .optional_payload_unsafe = .un_node,
                .optional_payload_safe_ptr = .un_node,
                .optional_payload_unsafe_ptr = .un_node,
                .err_union_payload_unsafe = .un_node,
                .err_union_payload_unsafe_ptr = .un_node,
                .err_union_code = .un_node,
                .err_union_code_ptr = .un_node,
                .enum_literal = .str_tok,
                .decl_literal = .pl_node,
                .decl_literal_no_coerce = .pl_node,
                .switch_block = .pl_node,
                .switch_block_ref = .pl_node,
                .switch_block_err_union = .pl_node,
                .validate_destructure = .pl_node,
                .field_type_ref = .pl_node,
                .union_init = .pl_node,
                .type_info = .un_node,
                .size_of = .un_node,
                .bit_size_of = .un_node,
                .opt_eu_base_ptr_init = .un_node,
                .coerce_ptr_elem_ty = .pl_node,
                .validate_ref_ty = .un_tok,
                .validate_const = .un_node,

                .int_from_ptr = .un_node,
                .compile_error = .un_node,
                .set_eval_branch_quota = .un_node,
                .int_from_enum = .un_node,
                .backing_int = .un_node,
                .align_of = .un_node,
                .int_from_bool = .un_node,
                .embed_file = .un_node,
                .error_name = .un_node,
                .panic = .un_node,
                .trap = .node,
                .set_runtime_safety = .un_node,
                .sqrt = .un_node,
                .sin = .un_node,
                .cos = .un_node,
                .tan = .un_node,
                .exp = .un_node,
                .exp2 = .un_node,
                .log = .un_node,
                .log2 = .un_node,
                .log10 = .un_node,
                .abs = .un_node,
                .floor = .un_node,
                .ceil = .un_node,
                .trunc = .un_node,
                .round = .un_node,
                .tag_name = .un_node,
                .type_name = .un_node,
                .frame_type = .un_node,

                .int_from_float = .pl_node,
                .float_from_int = .pl_node,
                .ptr_from_int = .pl_node,
                .enum_from_int = .pl_node,
                .from_backing_int = .pl_node,
                .float_cast = .pl_node,
                .int_cast = .pl_node,
                .ptr_cast = .pl_node,
                .truncate = .pl_node,
                .typeof_builtin = .pl_node,

                .has_decl = .pl_node,
                .has_field = .pl_node,

                .clz = .un_node,
                .ctz = .un_node,
                .pop_count = .un_node,
                .byte_swap = .un_node,
                .bit_reverse = .un_node,

                .div_exact = .pl_node,
                .div_floor = .pl_node,
                .div_ceil = .pl_node,
                .div_trunc = .pl_node,
                .mod = .pl_node,
                .rem = .pl_node,

                .shl = .pl_node,
                .shl_exact = .pl_node,
                .shl_sat = .pl_node,
                .shr = .pl_node,
                .shr_exact = .pl_node,

                .bit_offset_of = .pl_node,
                .offset_of = .pl_node,
                .splat = .pl_node,
                .reduce = .pl_node,
                .shuffle = .pl_node,
                .atomic_load = .pl_node,
                .atomic_rmw = .pl_node,
                .atomic_store = .pl_node,
                .mul_add = .pl_node,
                .builtin_call = .pl_node,
                .max = .pl_node,
                .memcpy = .pl_node,
                .memset = .pl_node,
                .memmove = .pl_node,
                .min = .pl_node,

                .alloc = .un_node,
                .alloc_mut = .un_node,
                .alloc_comptime_mut = .un_node,
                .alloc_inferred = .node,
                .alloc_inferred_mut = .node,
                .alloc_inferred_comptime = .node,
                .alloc_inferred_comptime_mut = .node,
                .resolve_inferred_alloc = .un_node,
                .make_ptr_const = .un_node,

                .@"resume" = .un_node,

                .@"defer" = .@"defer",

                .save_err_ret_index = .save_err_ret_index,
                .restore_err_ret_index_unconditional = .un_node,
                .restore_err_ret_index_fn_entry = .un_node,

                .struct_init_empty = .un_node,
                .struct_init_empty_result = .un_node,
                .struct_init_empty_ref_result = .un_node,
                .struct_init_anon = .pl_node,
                .struct_init = .pl_node,
                .struct_init_ref = .pl_node,
                .validate_struct_init_ty = .un_node,
                .validate_struct_init_result_ty = .un_node,
                .validate_ptr_struct_init = .pl_node,
                .struct_init_field_type = .pl_node,
                .struct_init_field_ptr = .pl_node,
                .array_init_anon = .pl_node,
                .array_init = .pl_node,
                .array_init_ref = .pl_node,
                .validate_array_init_ty = .pl_node,
                .validate_array_init_result_ty = .pl_node,
                .validate_array_init_ref_ty = .pl_node,
                .validate_ptr_array_init = .pl_node,
                .array_init_elem_type = .bin,
                .array_init_elem_ptr = .pl_node,

                .extended = .extended,
            });
        };

        // Uncomment to view how many tag slots are available.
        //comptime {
        //    @compileLog("ZIR tags left: ", 256 - @typeInfo(Tag).@"enum".field_names.len);
        //}
    };

    /// Rarer instructions are here; ones that do not fit in the 8-bit `Tag` enum.
    /// `noreturn` instructions may not go here; they must be part of the main `Tag` enum.
    pub const Extended = enum(u16) {
        /// A struct type definition. Contains references to ZIR instructions for
        /// the field types, defaults, and alignments.
        /// `operand` is payload index to `StructDecl`.
        /// `small` is `StructDecl.Small`.
        struct_decl,
        /// An enum type definition. Contains references to ZIR instructions for
        /// the field value expressions and optional type tag expression.
        /// `operand` is payload index to `EnumDecl`.
        /// `small` is `EnumDecl.Small`.
        enum_decl,
        /// A union type definition. Contains references to ZIR instructions for
        /// the field types and optional type tag expression.
        /// `operand` is payload index to `UnionDecl`.
        /// `small` is `UnionDecl.Small`.
        union_decl,
        /// An opaque type definition. Contains references to decls and captures.
        /// `operand` is payload index to `OpaqueDecl`.
        /// `small` is `OpaqueDecl.Small`.
        opaque_decl,
        /// A tuple type. Note that tuples are not namespace/container types.
        /// `operand` is payload index to `TupleDecl`.
        /// `small` is `fields_len: u16`.
        tuple_decl,
        /// Implements the `@This` builtin.
        /// `operand` is `src_node: Ast.Node.Offset`.
        this,
        /// Implements the `@returnAddress` builtin.
        /// `operand` is `src_node: Ast.Node.Offset`.
        ret_addr,
        /// Implements the `@src` builtin.
        /// `operand` is payload index to `LineColumn`.
        builtin_src,
        /// Implements the `@errorReturnTrace` builtin.
        /// `operand` is `src_node: Ast.Node.Offset`.
        error_return_trace,
        /// Implements the `@frame` builtin.
        /// `operand` is `src_node: Ast.Node.Offset`.
        frame,
        /// Implements the `@frameAddress` builtin.
        /// `operand` is `src_node: Ast.Node.Offset`.
        frame_address,
        /// Same as `alloc` from `Tag` but may contain an alignment instruction.
        /// `operand` is payload index to `AllocExtended`.
        /// `small`:
        ///  * 0b000X - has type
        ///  * 0b00X0 - has alignment
        ///  * 0b0X00 - 1=const, 0=var
        ///  * 0bX000 - is comptime
        alloc,
        /// The `@extern` builtin.
        /// `operand` is payload index to `BinNode`.
        builtin_extern,
        /// Inline assembly.
        /// `operand` is payload index to `Asm`.
        @"asm",
        /// Same as `asm` except the assembly template is not a string literal but a comptime
        /// expression.
        /// The `asm_source` field of the Asm is not a null-terminated string
        /// but instead a Ref.
        asm_expr,
        /// Log compile time variables and emit an error message.
        /// `operand` is payload index to `NodeMultiOp`.
        /// `small` is `operands_len`.
        /// The AST node is the compile log builtin call.
        compile_log,
        /// The builtin `@TypeOf` which returns the type after Peer Type Resolution
        /// of one or more params.
        /// `operand` is payload index to `TypeOfPeer`.
        /// `small` is `operands_len`.
        /// The AST node is the builtin call.
        typeof_peer,
        /// Implements the `@min` builtin for more than 2 args.
        /// `operand` is payload index to `NodeMultiOp`.
        /// `small` is `operands_len`.
        /// The AST node is the builtin call.
        min_multi,
        /// Implements the `@max` builtin for more than 2 args.
        /// `operand` is payload index to `NodeMultiOp`.
        /// `small` is `operands_len`.
        /// The AST node is the builtin call.
        max_multi,
        /// Implements the `@addWithOverflow` builtin.
        /// `operand` is payload index to `BinNode`.
        /// `small` is unused.
        add_with_overflow,
        /// Implements the `@subWithOverflow` builtin.
        /// `operand` is payload index to `BinNode`.
        /// `small` is unused.
        sub_with_overflow,
        /// Implements the `@mulWithOverflow` builtin.
        /// `operand` is payload index to `BinNode`.
        /// `small` is unused.
        mul_with_overflow,
        /// Implements the `@shlWithOverflow` builtin.
        /// `operand` is payload index to `BinNode`.
        /// `small` is unused.
        shl_with_overflow,
        /// `@round`, `@floor`, `@ceil`, or `@trunc`, with a result type.
        /// `operand` is payload index to `BinNode`.
        /// `small` is a `RoundOp` representing the specific operation being performed.
        round_op,
        /// Returns the type for the operand of a rounding op.
        /// `operand` is `UnNode`.
        /// `small` is unused.
        round_op_ty,
        /// `operand` is payload index to `UnNode`.
        wasm_memory_size,
        /// `operand` is payload index to `BinNode`.
        wasm_memory_grow,
        /// The `@prefetch` builtin.
        /// `operand` is payload index to `BinNode`.
        prefetch,
        /// Implement builtin `@setFloatMode`.
        /// `operand` is payload index to `UnNode`.
        set_float_mode,
        /// Implements the `@errorCast` builtin.
        /// `operand` is payload index to `BinNode`. `lhs` is dest type, `rhs` is operand.
        error_cast,
        /// Implements `@breakpoint`.
        /// `operand` is `src_node: Ast.Node.Offset`.
        breakpoint,
        /// Implement builtin `@disableInstrumentation`. `operand` is `src_node: Ast.Node.Offset`.
        disable_instrumentation,
        /// Implement builtin `@disableIntrinsics`. `operand` is `src_node: i32`.
        disable_intrinsics,
        /// Implements the `@select` builtin.
        /// `operand` is payload index to `Select`.
        select,
        /// Implement builtin `@errToInt`.
        /// `operand` is payload index to `UnNode`.
        int_from_error,
        /// Implement builtin `@errorFromInt`.
        /// `operand` is payload index to `UnNode`.
        error_from_int,
        /// Given a comptime-known operand of type `[]const A`, returns the type `*const [operand.len]B`.
        /// The types `A` and `B` are determined from `ReifySliceArgInfo`.
        /// This instruction is used to provide result types to arguments of `@Fn`, `@Struct`, etc.
        /// `operand` is payload index to `UnNode`.
        /// `small` is a bitcast `ReifySliceArgInfo`.
        reify_slice_arg_ty,
        /// Like `reify_slice_arg_ty` for the specific case of `[]const []const u8` to `[]const TagInt`,
        /// as needed for `@Enum`.
        /// `operand` is payload index to `BinNode`. lhs is the type `TagInt`. rhs is the `[]const []const u8` value.
        /// `small` is unused.
        reify_enum_value_slice_ty,
        /// Given a comptime-known operand of type `type`, returns the type `?operand` if possible, otherwise `?noreturn`.
        /// Used for the final arg of `@Pointer` to allow reifying pointers to opaque types.
        /// `operand` is payload index to `UnNode`.
        /// `small` is unused.
        reify_pointer_sentinel_ty,
        /// Implements builtin `@Tuple`.
        /// `operand` is payload index to `UnNode`.
        reify_tuple,
        /// Implements builtin `@Pointer`.
        /// `operand` is payload index to `ReifyPointer`.
        reify_pointer,
        /// Implements builtin `@Fn`.
        /// `operand` is payload index to `ReifyFn`.
        reify_fn,
        /// Implements builtin `@Struct`.
        /// `operand` is payload index to `ReifyStruct`.
        /// `small` contains `NameStrategy`.
        reify_struct,
        /// Implements builtin `@Union`.
        /// `operand` is payload index to `ReifyUnion`.
        /// `small` contains `NameStrategy`.
        reify_union,
        /// Implements builtin `@Enum`.
        /// `operand` is payload index to `ReifyEnum`.
        /// `small` contains `NameStrategy`.
        reify_enum,
        /// Implements builtin `@SpirvType`.
        /// `operand` is payload index to `ReifyFn`.
        reify_spirv_type,
        /// Implements the `@cmpxchgStrong` and `@cmpxchgWeak` builtins.
        /// `small` 0=>weak 1=>strong
        /// `operand` is payload index to `Cmpxchg`.
        cmpxchg,
        /// Implement builtin `@cVaArg`.
        /// `operand` is payload index to `BinNode`.
        c_va_arg,
        /// Implement builtin `@cVaCopy`.
        /// `operand` is payload index to `UnNode`.
        c_va_copy,
        /// Implement builtin `@cVaEnd`.
        /// `operand` is payload index to `UnNode`.
        c_va_end,
        /// Implement builtin `@cVaStart`.
        /// `operand` is `src_node: Ast.Node.Offset`.
        c_va_start,
        /// Implements the following builtins:
        /// `@ptrCast`, `@alignCast`, `@addrSpaceCast`, `@constCast`, `@volatileCast`.
        /// Represents an arbitrary nesting of the above builtins. Such a nesting is treated as a
        /// single operation which can modify multiple components of a pointer type.
        /// `operand` is payload index to `BinNode`.
        /// `small` contains `FullPtrCastFlags`.
        /// AST node is the root of the nested casts.
        /// `lhs` is dest type, `rhs` is operand.
        ptr_cast_full,
        /// `operand` is payload index to `UnNode`.
        /// `small` contains `FullPtrCastFlags`.
        /// Guaranteed to only have flags where no explicit destination type is
        /// required (const_cast and volatile_cast).
        /// AST node is the root of the nested casts.
        ptr_cast_no_dest,
        /// Implements the `@workItemId` builtin.
        /// `operand` is payload index to `UnNode`.
        work_item_id,
        /// Implements the `@workGroupSize` builtin.
        /// `operand` is payload index to `UnNode`.
        work_group_size,
        /// Implements the `@workGroupId` builtin.
        /// `operand` is payload index to `UnNode`.
        work_group_id,
        /// Implements the `@inComptime` builtin.
        /// `operand` is `src_node: Ast.Node.Offset`.
        in_comptime,
        /// Restores the error return index to its last saved state in a given
        /// block. If the block is `.none`, restores to the state from the point
        /// of function entry. If the operand is not `.none`, the restore is
        /// conditional on the operand value not being an error.
        /// `operand` is payload index to `RestoreErrRetIndex`.
        /// `small` is undefined.
        restore_err_ret_index,
        /// Retrieves a value from the current type declaration scope's closure.
        /// `operand` is `src_node: Ast.Node.Offset`.
        /// `small` is closure index.
        closure_get,
        /// Used as a placeholder instruction which is just a dummy index for Sema to replace
        /// with a specific value. For instance, this is used for the capture of an `errdefer`.
        /// This should never appear in a body.
        value_placeholder,
        /// Implements the `@fieldParentPtr` builtin.
        /// `operand` is payload index to `FieldParentPtr`.
        /// `small` contains `FullPtrCastFlags`.
        /// Guaranteed to not have the `ptr_cast` flag.
        /// Uses the `pl_node` union field with payload `FieldParentPtr`.
        field_parent_ptr,
        /// Get a type or value from `std.lang`.
        /// `operand` is `src_node: Ast.Node.Offset`.
        /// `small` is an `Inst.StdLangValue`.
        std_lang_value,
        /// Provide a `@branchHint` for the current block.
        /// `operand` is payload index to `UnNode`.
        /// `small` is unused.
        branch_hint,
        /// Compute the result type for in-place arithmetic, e.g. `+=`.
        /// `operand` is `Zir.Inst.Ref` of the loaded LHS (*not* its type).
        /// `small` is an `Inst.InplaceOp`.
        inplace_arith_result_ty,
        /// Marks a statement that can be stepped to but produces no code.
        /// `operand` and `small` are ignored.
        dbg_empty_stmt,
        /// At this point, AstGen encountered a fatal error which terminated ZIR lowering for this body.
        /// A file-level error has been reported. Sema should terminate semantic analysis.
        /// `operand` and `small` are ignored.
        /// This instruction is always `noreturn`, however, it is not considered as such by ZIR-level queries. This allows AstGen to assume that
        /// any code may have gone here, avoiding false-positive "unreachable code" errors.
        astgen_error,
        /// Given a type, strips away any error unions or optionals stacked
        /// on top and returns the base type. That base type must be a float.
        /// For example: Provided with `error{Foo}!?f64`, returns `f64`.
        /// `operand` is payload index to `UnNode`.
        float_op_result_ty,

        pub const InstData = struct {
            opcode: Extended,
            small: u16,
            operand: u32,
        };
    };

    /// The position of a ZIR instruction within the `Zir` instructions array.
    pub const Index = enum(u32) {
        /// ZIR is structured so that the outermost "main" struct of any file
        /// is always at index 0.
        main_struct_inst = 0,
        _,

        pub fn toRef(i: Index) Inst.Ref {
            return @fromBackingInt(@intCast(Ref.static_len + @backingInt(i)));
        }

        pub fn toOptional(i: Index) OptionalIndex {
            return @fromBackingInt(@intCast(@backingInt(i)));
        }
    };

    pub const OptionalIndex = enum(u32) {
        /// ZIR is structured so that the outermost "main" struct of any file
        /// is always at index 0.
        main_struct_inst = 0,
        none = std.math.maxInt(u32),
        _,

        pub fn unwrap(oi: OptionalIndex) ?Index {
            return if (oi == .none) null else @fromBackingInt(@intCast(@backingInt(oi)));
        }
    };

    /// A reference to ZIR instruction, or to an InternPool index, or neither.
    ///
    /// If the integer tag value is < InternPool.static_len, then it
    /// corresponds to an InternPool index. Otherwise, this refers to a ZIR
    /// instruction.
    ///
    /// The tag type is specified so that it is safe to bitcast between `[]u32`
    /// and `[]Ref`.
    pub const Ref = enum(u32) {
        u0_type,
        u1_type,
        u8_type,
        i8_type,
        u16_type,
        i16_type,
        u29_type,
        u32_type,
        i32_type,
        u64_type,
        i64_type,
        u80_type,
        u128_type,
        i128_type,
        u256_type,
        usize_type,
        isize_type,
        c_char_type,
        c_short_type,
        c_ushort_type,
        c_int_type,
        c_uint_type,
        c_long_type,
        c_ulong_type,
        c_longlong_type,
        c_ulonglong_type,
        c_longdouble_type,
        f16_type,
        f32_type,
        f64_type,
        f80_type,
        f128_type,
        anyopaque_type,
        bool_type,
        void_type,
        type_type,
        anyerror_type,
        comptime_int_type,
        comptime_float_type,
        noreturn_type,
        anyframe_type,
        null_type,
        undefined_type,
        enum_literal_type,
        ptr_usize_type,
        ptr_const_comptime_int_type,
        manyptr_u8_type,
        manyptr_const_u8_type,
        manyptr_const_u8_sentinel_0_type,
        slice_const_u8_type,
        slice_const_u8_sentinel_0_type,
        manyptr_const_slice_const_u8_type,
        slice_const_slice_const_u8_type,
        optional_type_type,
        manyptr_const_type_type,
        slice_const_type_type,
        vector_8_i8_type,
        vector_16_i8_type,
        vector_32_i8_type,
        vector_64_i8_type,
        vector_1_u8_type,
        vector_2_u8_type,
        vector_4_u8_type,
        vector_8_u8_type,
        vector_16_u8_type,
        vector_32_u8_type,
        vector_64_u8_type,
        vector_2_i16_type,
        vector_4_i16_type,
        vector_8_i16_type,
        vector_16_i16_type,
        vector_32_i16_type,
        vector_4_u16_type,
        vector_8_u16_type,
        vector_16_u16_type,
        vector_32_u16_type,
        vector_2_i32_type,
        vector_4_i32_type,
        vector_8_i32_type,
        vector_16_i32_type,
        vector_4_u32_type,
        vector_8_u32_type,
        vector_16_u32_type,
        vector_2_i64_type,
        vector_4_i64_type,
        vector_8_i64_type,
        vector_2_u64_type,
        vector_4_u64_type,
        vector_8_u64_type,
        vector_1_u128_type,
        vector_2_u128_type,
        vector_1_u256_type,
        vector_4_f16_type,
        vector_8_f16_type,
        vector_16_f16_type,
        vector_32_f16_type,
        vector_2_f32_type,
        vector_4_f32_type,
        vector_8_f32_type,
        vector_16_f32_type,
        vector_2_f64_type,
        vector_4_f64_type,
        vector_8_f64_type,
        optional_noreturn_type,
        anyerror_void_error_union_type,
        adhoc_inferred_error_set_type,
        generic_poison_type,
        empty_tuple_type,
        undef,
        undef_bool,
        undef_usize,
        undef_u1,
        zero,
        zero_usize,
        zero_u1,
        zero_u8,
        one,
        one_usize,
        one_u1,
        one_u8,
        four_u8,
        negative_one,
        void_value,
        unreachable_value,
        null_value,
        bool_true,
        bool_false,
        empty_tuple,

        /// This Ref does not correspond to any ZIR instruction or constant
        /// value and may instead be used as a sentinel to indicate null.
        none = std.math.maxInt(u32),

        _,

        pub const static_len = @typeInfo(@This()).@"enum".field_names.len - 1;

        pub fn toIndex(inst: Ref) ?Index {
            assert(inst != .none);
            const ref_int = @backingInt(inst);
            if (ref_int >= static_len) {
                return @fromBackingInt(@intCast(ref_int - static_len));
            } else {
                return null;
            }
        }

        pub fn toIndexAllowNone(inst: Ref) ?Index {
            if (inst == .none) return null;
            return toIndex(inst);
        }
    };

    /// All instructions have an 8-byte payload, which is contained within
    /// this union. `Tag` determines which union field is active, as well as
    /// how to interpret the data within.
    pub const Data = union {
        /// Used for `Tag.extended`. The extended opcode determines the meaning
        /// of the `small` and `operand` fields.
        extended: Extended.InstData,
        /// Used for unary operators, with an AST node source location.
        un_node: struct {
            /// Offset from Decl AST node index.
            src_node: Ast.Node.Offset,
            /// The meaning of this operand depends on the corresponding `Tag`.
            operand: Ref,
        },
        /// Used for unary operators, with a token source location.
        un_tok: struct {
            /// Offset from Decl AST token index.
            src_tok: Ast.TokenOffset,
            /// The meaning of this operand depends on the corresponding `Tag`.
            operand: Ref,
        },
        pl_node: struct {
            /// Offset from Decl AST node index.
            /// `Tag` determines which kind of AST node this points to.
            src_node: Ast.Node.Offset,
            /// index into extra.
            /// `Tag` determines what lives there.
            payload_index: u32,
        },
        pl_tok: struct {
            /// Offset from Decl AST token index.
            src_tok: Ast.TokenOffset,
            /// index into extra.
            /// `Tag` determines what lives there.
            payload_index: u32,
        },
        bin: Bin,
        /// For strings which may contain null bytes.
        str: struct {
            /// Offset into `string_bytes`.
            start: NullTerminatedString,
            /// Number of bytes in the string.
            len: u32,

            pub fn get(self: @This(), code: Zir) []const u8 {
                return code.string_bytes[@backingInt(self.start)..][0..self.len];
            }
        },
        str_tok: struct {
            /// Offset into `string_bytes`. Null-terminated.
            start: NullTerminatedString,
            /// Offset from Decl AST token index.
            src_tok: Ast.TokenOffset,

            pub fn get(self: @This(), code: Zir) [:0]const u8 {
                return code.nullTerminatedString(self.start);
            }
        },
        /// Offset from Decl AST token index.
        tok: Ast.TokenOffset,
        /// Offset from Decl AST node index.
        node: Ast.Node.Offset,
        int: u64,
        float: f64,
        ptr_type: struct {
            flags: packed struct {
                is_allowzero: bool,
                is_mutable: bool,
                is_volatile: bool,
                has_sentinel: bool,
                has_align: bool,
                has_addrspace: bool,
                has_bit_range: bool,
                _: u1 = 0,
            },
            size: std.lang.Type.Pointer.Size,
            /// Index into extra. See `PtrType`.
            payload_index: u32,
        },
        int_type: struct {
            /// Offset from Decl AST node index.
            /// `Tag` determines which kind of AST node this points to.
            src_node: Ast.Node.Offset,
            signedness: std.lang.Signedness,
            bit_count: u16,
        },
        @"unreachable": struct {
            /// Offset from Decl AST node index.
            /// `Tag` determines which kind of AST node this points to.
            src_node: Ast.Node.Offset,
        },
        @"break": struct {
            operand: Ref,
            /// Index of a `Break` payload.
            payload_index: u32,
        },
        dbg_stmt: LineColumn,
        /// Used for unary operators which reference an inst,
        /// with an AST node source location.
        inst_node: struct {
            /// Offset from Decl AST node index.
            src_node: Ast.Node.Offset,
            /// The meaning of this operand depends on the corresponding `Tag`.
            inst: Index,
        },
        str_op: struct {
            /// Offset into `string_bytes`. Null-terminated.
            str: NullTerminatedString,
            operand: Ref,

            pub fn getStr(self: @This(), zir: Zir) [:0]const u8 {
                return zir.nullTerminatedString(self.str);
            }
        },
        @"defer": struct {
            index: u32,
            len: u32,
        },
        save_err_ret_index: struct {
            operand: Ref, // If error type (or .none), save new trace index
        },
        elem_val_imm: struct {
            /// The indexable value being accessed.
            operand: Ref,
            /// The index being accessed.
            idx: u32,
        },
        declaration: struct {
            /// This node provides a new absolute baseline node for all instructions within this struct.
            src_node: Ast.Node.Index,
            /// index into extra to a `Declaration` payload.
            payload_index: u32,
        },

        // Make sure we don't accidentally add a field to make this union
        // bigger than expected. Note that in Debug builds, Zig is allowed
        // to insert a secret field for safety checks.
        comptime {
            if (builtin.mode != .debug and builtin.mode != .safe) {
                assert(@sizeOf(Data) == 8);
            }
        }

        /// TODO this has to be kept in sync with `Data` which we want to be an untagged
        /// union. There is some kind of language awkwardness here and it has to do with
        /// deserializing an untagged union (in this case `Data`) from a file, and trying
        /// to preserve the hidden safety field.
        pub const FieldEnum = enum {
            extended,
            un_node,
            un_tok,
            pl_node,
            pl_tok,
            bin,
            str,
            str_tok,
            tok,
            node,
            int,
            float,
            ptr_type,
            int_type,
            @"unreachable",
            @"break",
            dbg_stmt,
            inst_node,
            str_op,
            @"defer",
            save_err_ret_index,
            elem_val_imm,
            declaration,
        };
    };

    pub const Break = struct {
        operand_src_node: Ast.Node.OptionalOffset,
        block_inst: Index,
    };

    /// Trailing:
    /// 0. Output for every outputs_len
    /// 1. Input for every inputs_len
    pub const Asm = struct {
        src_node: Ast.Node.Offset,
        // null-terminated string index
        asm_source: NullTerminatedString,
        /// 1 bit for each outputs_len: whether it uses `-> T` or not.
        ///   0b0 - operand is a pointer to where to store the output.
        ///   0b1 - operand is a type; asm expression has the output as the result.
        /// 0b0X is the first output, 0bX0 is the second, etc.
        output_type_bits: u32,
        clobbers: Ref,

        pub const Small = packed struct(u16) {
            is_volatile: bool,
            outputs_len: u7,
            inputs_len: u8,
        };

        pub const Output = struct {
            /// index into string_bytes (null terminated)
            name: NullTerminatedString,
            /// index into string_bytes (null terminated)
            constraint: NullTerminatedString,
            /// How to interpret this is determined by `output_type_bits`.
            operand: Ref,
        };

        pub const Input = struct {
            /// index into string_bytes (null terminated)
            name: NullTerminatedString,
            /// index into string_bytes (null terminated)
            constraint: NullTerminatedString,
            operand: Ref,
        };
    };

    /// Trailing:
    /// if (ret_ty.body_len == 1) {
    ///   0. return_type: Ref
    /// }
    /// if (ret_ty.body_len > 1) {
    ///   1. return_type: Index // for each ret_ty.body_len
    /// }
    /// 2. body: Index // for each body_len
    /// 3. src_locs: SrcLocs // if body_len != 0
    /// 4. proto_hash: std.zig.SrcHash // if body_len != 0; hash of function prototype
    pub const Func = struct {
        ret_ty: RetTy,
        /// Points to the block that contains the param instructions for this function.
        /// If this is a `declaration`, it refers to the declaration's value body.
        param_block: Index,
        body_len: u32,

        pub const RetTy = packed struct(u32) {
            /// 0 means `void`.
            /// 1 means the type is a simple `Ref`.
            /// Otherwise, the length of a trailing body.
            body_len: u31,
            /// Whether the return type is generic, i.e. refers to one or more previous parameters.
            is_generic: bool,
        };

        pub const SrcLocs = struct {
            /// Line index in the source file relative to the parent decl.
            lbrace_line: u32,
            /// Line index in the source file relative to the parent decl.
            rbrace_line: u32,
            /// lbrace_column is least significant bits u16
            /// rbrace_column is most significant bits u16
            columns: u32,
        };
    };

    /// Trailing:
    /// if (has_cc_ref and !has_cc_body) {
    ///   0. cc: Ref,
    /// }
    /// if (has_cc_body) {
    ///   1. cc_body_len: u32
    ///   2. cc_body: u32 // for each cc_body_len
    /// }
    /// if (has_ret_ty_ref and !has_ret_ty_body) {
    ///   3. ret_ty: Ref,
    /// }
    /// if (has_ret_ty_body) {
    ///   4. ret_ty_body_len: u32
    ///   5. ret_ty_body: u32 // for each ret_ty_body_len
    /// }
    /// 6. noalias_bits: u32 // if has_any_noalias
    ///    - each bit starting with LSB corresponds to parameter indexes
    /// 7. body: Index // for each body_len
    /// 8. src_locs: Func.SrcLocs // if body_len != 0
    /// 9. proto_hash: std.zig.SrcHash // if body_len != 0; hash of function prototype
    pub const FuncFancy = struct {
        /// Points to the block that contains the param instructions for this function.
        /// If this is a `declaration`, it refers to the declaration's value body.
        param_block: Index,
        body_len: u32,
        bits: Bits,

        /// If both has_cc_ref and has_cc_body are false, it means auto calling convention.
        /// If both has_ret_ty_ref and has_ret_ty_body are false, it means void return type.
        pub const Bits = packed struct(u32) {
            is_var_args: bool,
            is_inferred_error: bool,
            is_noinline: bool,
            has_cc_ref: bool,
            has_cc_body: bool,
            has_ret_ty_ref: bool,
            has_ret_ty_body: bool,
            has_any_noalias: bool,
            ret_ty_is_generic: bool,
            _: u23 = 0,
        };
    };

    /// This data is stored inside extra, with trailing operands according to `operands_len`.
    /// Each operand is a `Ref`.
    pub const MultiOp = struct {
        operands_len: u32,
    };

    /// Trailing: operand: Ref, // for each `operands_len` (stored in `small`).
    pub const NodeMultiOp = struct {
        src_node: Ast.Node.Offset,
    };

    /// This data is stored inside extra, with trailing operands according to `body_len`.
    /// Each operand is an `Index`.
    pub const Block = struct {
        body_len: u32,
    };

    /// Trailing:
    /// * inst: Index // for each `body_len`
    pub const BlockComptime = struct {
        reason: std.zig.SimpleComptimeReason,
        body_len: u32,
    };

    /// Trailing:
    /// * inst: Index // for each `body_len`
    pub const BoolBr = struct {
        lhs: Ref,
        body_len: u32,
    };

    /// Trailing:
    /// 0. name: NullTerminatedString      // if `flags.id.hasName()`
    /// 1. lib_name: NullTerminatedString  // if `flags.id.hasLibName()`
    /// 2. type_body_len: u32              // if `flags.id.hasTypeBody()`
    /// 3. align_body_len: u32             // if `flags.id.hasSpecialBodies()`
    /// 4. linksection_body_len: u32       // if `flags.id.hasSpecialBodies()`
    /// 5. addrspace_body_len: u32         // if `flags.id.hasSpecialBodies()`
    /// 6. value_body_len: u32             // if `flags.id.hasValueBody()`
    /// 7. type_body_inst: Zir.Inst.Index
    ///    - for each `type_body_len`
    ///    - body to be exited via `break_inline` to this `declaration` instruction
    /// 8. align_body_inst: Zir.Inst.Index
    ///    - for each `align_body_len`
    ///    - body to be exited via `break_inline` to this `declaration` instruction
    /// 9. linksection_body_inst: Zir.Inst.Index
    ///    - for each `linksection_body_len`
    ///    - body to be exited via `break_inline` to this `declaration` instruction
    /// 10. addrspace_body_inst: Zir.Inst.Index
    ///    - for each `addrspace_body_len`
    ///    - body to be exited via `break_inline` to this `declaration` instruction
    /// 11. value_body_inst: Zir.Inst.Index
    ///    - for each `value_body_len`
    ///    - body to be exited via `break_inline` to this `declaration` instruction
    ///    - within this body, the `declaration` instruction refers to the resolved type from the type body
    pub const Declaration = struct {
        // These fields should be concatenated and reinterpreted as a `std.zig.SrcHash`.
        src_hash_0: u32,
        src_hash_1: u32,
        src_hash_2: u32,
        src_hash_3: u32,
        // These fields should be concatenated and reinterpreted as a `Flags`.
        flags_0: u32,
        flags_1: u32,

        pub const Unwrapped = struct {
            pub const Kind = enum {
                unnamed_test,
                @"test",
                decltest,
                @"comptime",
                @"const",
                @"var",
            };

            pub const Linkage = enum {
                normal,
                @"extern",
                @"export",
            };

            src_node: Ast.Node.Index,

            src_line: u32,
            src_column: u32,

            kind: Kind,
            /// Always `.empty` for `kind` of `unnamed_test`, `.@"comptime"`
            name: NullTerminatedString,
            /// Always `false` for `kind` of `unnamed_test`, `.@"test"`, `.decltest`, `.@"comptime"`.
            is_pub: bool,
            /// Always `false` for `kind != .@"var"`.
            is_threadlocal: bool,
            /// Always `.normal` for `kind != .@"const" and kind != .@"var"`.
            linkage: Linkage,
            /// Always `.empty` for `linkage != .@"extern"`.
            lib_name: NullTerminatedString,

            /// Always populated for `linkage == .@"extern".
            type_body: ?[]const Inst.Index,
            align_body: ?[]const Inst.Index,
            linksection_body: ?[]const Inst.Index,
            addrspace_body: ?[]const Inst.Index,
            /// Always populated for `linkage != .@"extern".
            value_body: ?[]const Inst.Index,
        };

        pub const Flags = packed struct(u64) {
            src_line: u30,
            src_column: u29,
            id: Id,

            pub const Id = enum(u5) {
                unnamed_test,
                @"test",
                decltest,
                @"comptime",

                const_simple,
                const_typed,
                @"const",
                pub_const_simple,
                pub_const_typed,
                pub_const,

                extern_const_simple,
                extern_const,
                pub_extern_const_simple,
                pub_extern_const,

                export_const,
                pub_export_const,

                var_simple,
                @"var",
                var_threadlocal,
                pub_var_simple,
                pub_var,
                pub_var_threadlocal,

                extern_var,
                extern_var_threadlocal,
                pub_extern_var,
                pub_extern_var_threadlocal,

                export_var,
                export_var_threadlocal,
                pub_export_var,
                pub_export_var_threadlocal,

                pub fn hasName(id: Id) bool {
                    return switch (id) {
                        .unnamed_test,
                        .@"comptime",
                        => false,
                        else => true,
                    };
                }

                pub fn hasLibName(id: Id) bool {
                    return switch (id) {
                        .extern_const,
                        .pub_extern_const,
                        .extern_var,
                        .extern_var_threadlocal,
                        .pub_extern_var,
                        .pub_extern_var_threadlocal,
                        => true,
                        else => false,
                    };
                }

                pub fn hasTypeBody(id: Id) bool {
                    return switch (id) {
                        .unnamed_test,
                        .@"test",
                        .decltest,
                        .@"comptime",
                        => false, // these constructs are untyped
                        .const_simple,
                        .pub_const_simple,
                        .var_simple,
                        .pub_var_simple,
                        => false, // these reprs omit type bodies
                        else => true,
                    };
                }

                pub fn hasValueBody(id: Id) bool {
                    return switch (id) {
                        .extern_const_simple,
                        .extern_const,
                        .pub_extern_const_simple,
                        .pub_extern_const,
                        .extern_var,
                        .extern_var_threadlocal,
                        .pub_extern_var,
                        .pub_extern_var_threadlocal,
                        => false, // externs do not have values
                        else => true,
                    };
                }

                pub fn hasSpecialBodies(id: Id) bool {
                    return switch (id) {
                        .unnamed_test,
                        .@"test",
                        .decltest,
                        .@"comptime",
                        => false, // these constructs are untyped
                        .const_simple,
                        .const_typed,
                        .pub_const_simple,
                        .pub_const_typed,
                        .extern_const_simple,
                        .pub_extern_const_simple,
                        .var_simple,
                        .pub_var_simple,
                        => false, // these reprs omit special bodies
                        else => true,
                    };
                }

                pub fn linkage(id: Id) Declaration.Unwrapped.Linkage {
                    return switch (id) {
                        .extern_const_simple,
                        .extern_const,
                        .pub_extern_const_simple,
                        .pub_extern_const,
                        .extern_var,
                        .extern_var_threadlocal,
                        .pub_extern_var,
                        .pub_extern_var_threadlocal,
                        => .@"extern",
                        .export_const,
                        .pub_export_const,
                        .export_var,
                        .export_var_threadlocal,
                        .pub_export_var,
                        .pub_export_var_threadlocal,
                        => .@"export",
                        else => .normal,
                    };
                }

                pub fn kind(id: Id) Declaration.Unwrapped.Kind {
                    return switch (id) {
                        .unnamed_test => .unnamed_test,
                        .@"test" => .@"test",
                        .decltest => .decltest,
                        .@"comptime" => .@"comptime",
                        .const_simple,
                        .const_typed,
                        .@"const",
                        .pub_const_simple,
                        .pub_const_typed,
                        .pub_const,
                        .extern_const_simple,
                        .extern_const,
                        .pub_extern_const_simple,
                        .pub_extern_const,
                        .export_const,
                        .pub_export_const,
                        => .@"const",
                        .var_simple,
                        .@"var",
                        .var_threadlocal,
                        .pub_var_simple,
                        .pub_var,
                        .pub_var_threadlocal,
                        .extern_var,
                        .extern_var_threadlocal,
                        .pub_extern_var,
                        .pub_extern_var_threadlocal,
                        .export_var,
                        .export_var_threadlocal,
                        .pub_export_var,
                        .pub_export_var_threadlocal,
                        => .@"var",
                    };
                }

                pub fn isPub(id: Id) bool {
                    return switch (id) {
                        .pub_const_simple,
                        .pub_const_typed,
                        .pub_const,
                        .pub_extern_const_simple,
                        .pub_extern_const,
                        .pub_export_const,
                        .pub_var_simple,
                        .pub_var,
                        .pub_var_threadlocal,
                        .pub_extern_var,
                        .pub_extern_var_threadlocal,
                        .pub_export_var,
                        .pub_export_var_threadlocal,
                        => true,
                        else => false,
                    };
                }

                pub fn isThreadlocal(id: Id) bool {
                    return switch (id) {
                        .var_threadlocal,
                        .pub_var_threadlocal,
                        .extern_var_threadlocal,
                        .pub_extern_var_threadlocal,
                        .export_var_threadlocal,
                        .pub_export_var_threadlocal,
                        => true,
                        else => false,
                    };
                }
            };
        };

        pub const Name = enum(u32) {
            @"comptime" = std.math.maxInt(u32),
            unnamed_test = std.math.maxInt(u32) - 1,
            /// Other values are `NullTerminatedString` values, i.e. index into
            /// `string_bytes`. If the byte referenced is 0, the decl is a named
            /// test, and the actual name begins at the following byte.
            _,

            pub fn isNamedTest(name: Name, zir: Zir) bool {
                return switch (name) {
                    .@"comptime", .unnamed_test => false,
                    _ => zir.string_bytes[@backingInt(name)] == 0,
                };
            }
            pub fn toString(name: Name, zir: Zir) ?NullTerminatedString {
                switch (name) {
                    .@"comptime", .unnamed_test => return null,
                    _ => {},
                }
                const idx: u32 = @backingInt(name);
                if (zir.string_bytes[idx] == 0) {
                    // Named test
                    return @fromBackingInt(@intCast(idx + 1));
                }
                return @fromBackingInt(@intCast(idx));
            }
        };

        pub const Bodies = struct {
            type_body: ?[]const Index,
            align_body: ?[]const Index,
            linksection_body: ?[]const Index,
            addrspace_body: ?[]const Index,
            value_body: ?[]const Index,
        };

        pub fn getBodies(declaration: Declaration, extra_end: u32, zir: Zir) Bodies {
            var extra_index: u32 = extra_end;
            const value_body_len = declaration.value_body_len;
            const type_body_len: u32 = len: {
                if (!declaration.flags().kind.hasTypeBody()) break :len 0;
                const len = zir.extra[extra_index];
                extra_index += 1;
                break :len len;
            };
            const align_body_len, const linksection_body_len, const addrspace_body_len = lens: {
                if (!declaration.flags.kind.hasSpecialBodies()) {
                    break :lens .{ 0, 0, 0 };
                }
                const lens = zir.extra[extra_index..][0..3].*;
                extra_index += 3;
                break :lens lens;
            };
            return .{
                .type_body = if (type_body_len == 0) null else b: {
                    const b = zir.bodySlice(extra_index, type_body_len);
                    extra_index += type_body_len;
                    break :b b;
                },
                .align_body = if (align_body_len == 0) null else b: {
                    const b = zir.bodySlice(extra_index, align_body_len);
                    extra_index += align_body_len;
                    break :b b;
                },
                .linksection_body = if (linksection_body_len == 0) null else b: {
                    const b = zir.bodySlice(extra_index, linksection_body_len);
                    extra_index += linksection_body_len;
                    break :b b;
                },
                .addrspace_body = if (addrspace_body_len == 0) null else b: {
                    const b = zir.bodySlice(extra_index, addrspace_body_len);
                    extra_index += addrspace_body_len;
                    break :b b;
                },
                .value_body = if (value_body_len == 0) null else b: {
                    const b = zir.bodySlice(extra_index, value_body_len);
                    extra_index += value_body_len;
                    break :b b;
                },
            };
        }
    };

    /// Stored inside extra, with trailing arguments according to `args_len`.
    /// Implicit 0. arg_0_start: u32, // always same as `args_len`
    /// 1. arg_end: u32, // for each `args_len`
    /// arg_N_start is the same as arg_N-1_end
    pub const Call = struct {
        // Note: Flags *must* come first so that unusedResultExpr
        // can find it when it goes to modify them.
        flags: Flags,
        callee: Ref,

        pub const Flags = packed struct {
            /// std.lang.CallModifier in packed form
            pub const PackedModifier = u3;
            pub const PackedArgsLen = u27;

            packed_modifier: PackedModifier,
            ensure_result_used: bool = false,
            pop_error_return_trace: bool,
            args_len: PackedArgsLen,

            comptime {
                if (@sizeOf(Flags) != 4 or @bitSizeOf(Flags) != 32)
                    @compileError("Layout of Call.Flags needs to be updated!");
                if (@bitSizeOf(std.lang.CallModifier) != @bitSizeOf(PackedModifier))
                    @compileError("Call.Flags.PackedModifier needs to be updated!");
            }
        };
    };

    /// Stored inside extra, with trailing arguments according to `args_len`.
    /// Implicit 0. arg_0_start: u32, // always same as `args_len`
    /// 1. arg_end: u32, // for each `args_len`
    /// arg_N_start is the same as arg_N-1_end
    pub const FieldCall = struct {
        // Note: Flags *must* come first so that unusedResultExpr
        // can find it when it goes to modify them.
        flags: Call.Flags,
        obj_ptr: Ref,
        /// Offset into `string_bytes`.
        field_name_start: NullTerminatedString,
    };

    /// There is a body of instructions at `extra[body_index..][0..body_len]`.
    /// Trailing:
    /// 0. operand: Ref // for each `operands_len`
    pub const TypeOfPeer = struct {
        src_node: Ast.Node.Offset,
        body_len: u32,
        body_index: u32,
    };

    pub const BuiltinCall = struct {
        // Note: Flags *must* come first so that unusedResultExpr
        // can find it when it goes to modify them.
        flags: Flags,
        modifier: Ref,
        callee: Ref,
        args: Ref,

        pub const Flags = packed struct {
            is_nosuspend: bool,
            ensure_result_used: bool,
            _: u30 = 0,

            comptime {
                if (@sizeOf(Flags) != 4 or @bitSizeOf(Flags) != 32)
                    @compileError("Layout of BuiltinCall.Flags needs to be updated!");
            }
        };
    };

    /// This data is stored inside extra, with two sets of trailing `Ref`:
    /// * 0. the then body, according to `then_body_len`.
    /// * 1. the else body, according to `else_body_len`.
    pub const CondBr = struct {
        condition: Ref,
        then_body_len: u32,
        else_body_len: u32,
    };

    /// This data is stored inside extra, trailed by:
    /// * 0. body: Index //  for each `body_len`.
    pub const Try = struct {
        /// The error union to unwrap.
        operand: Ref,
        body_len: u32,
    };

    /// Stored in extra. Depending on the flags in Data, there will be up to 5
    /// trailing Ref fields:
    /// 0. sentinel: Ref // if `has_sentinel` flag is set
    /// 1. align: Ref // if `has_align` flag is set
    /// 2. address_space: Ref // if `has_addrspace` flag is set
    /// 3. bit_start: Ref // if `has_bit_range` flag is set
    /// 4. host_size: Ref // if `has_bit_range` flag is set
    pub const PtrType = struct {
        elem_type: Ref,
        src_node: Ast.Node.Offset,
    };

    pub const ArrayTypeSentinel = struct {
        len: Ref,
        sentinel: Ref,
        elem_type: Ref,
    };

    pub const SliceStart = struct {
        lhs: Ref,
        start: Ref,
    };

    pub const SliceEnd = struct {
        lhs: Ref,
        start: Ref,
        end: Ref,
    };

    pub const SliceSentinel = struct {
        lhs: Ref,
        start: Ref,
        end: Ref,
        sentinel: Ref,
    };

    pub const SliceLength = struct {
        lhs: Ref,
        start: Ref,
        len: Ref,
        sentinel: Ref,
        start_src_node_offset: Ast.Node.Offset,
    };

    /// The meaning of these operands depends on the corresponding `Tag`.
    pub const Bin = struct {
        lhs: Ref,
        rhs: Ref,
    };

    pub const BinNode = struct {
        node: Ast.Node.Offset,
        lhs: Ref,
        rhs: Ref,
    };

    pub const ReifySliceArgInfo = enum(u16) {
        /// Input element type is `type`.
        /// Output element type is `std.lang.Type.Fn.ParamAttributes`.
        type_to_fn_param_attrs,
        /// Input element type is `[]const u8`.
        /// Output element type is `type`.
        string_to_struct_field_type,
        /// Identical to `string_to_struct_field_type` aside from emitting slightly different error messages.
        string_to_union_field_type,
        /// Input element type is `[]const u8`.
        /// Output element type is `std.lang.Type.Struct.FieldAttributes`.
        string_to_struct_field_attrs,
        /// Input element type is `[]const u8`.
        /// Output element type is `std.lang.Type.Union.FieldAttributes`.
        string_to_union_field_attrs,
    };

    pub const RoundOp = enum(u16) {
        round,
        floor,
        ceil,
        trunc,
    };

    pub const UnNode = struct {
        node: Ast.Node.Offset,
        operand: Ref,
    };

    pub const ElemPtrImm = struct {
        ptr: Ref,
        index: u32,
    };

    pub const ReifyPointer = struct {
        node: Ast.Node.Offset,
        size: Ref,
        attrs: Ref,
        elem_ty: Ref,
        sentinel: Ref,
    };

    pub const ReifyFn = struct {
        node: Ast.Node.Offset,
        param_types: Ref,
        param_attrs: Ref,
        ret_ty: Ref,
        fn_attrs: Ref,
    };

    pub const ReifyStruct = struct {
        src_line: u32,
        src_column: u32,
        /// This node is absolute, because `reify` instructions are tracked across updates, and
        /// this simplifies the logic for getting source locations for types.
        node: Ast.Node.Index,
        layout: Ref,
        backing_ty: Ref,
        field_names: Ref,
        field_types: Ref,
        field_attrs: Ref,
    };

    pub const ReifyUnion = struct {
        src_line: u32,
        src_column: u32,
        /// This node is absolute, because `reify` instructions are tracked across updates, and
        /// this simplifies the logic for getting source locations for types.
        node: Ast.Node.Index,
        layout: Ref,
        arg_ty: Ref,
        field_names: Ref,
        field_types: Ref,
        field_attrs: Ref,
    };

    pub const ReifyEnum = struct {
        src_line: u32,
        src_column: u32,
        /// This node is absolute, because `reify` instructions are tracked across updates, and
        /// this simplifies the logic for getting source locations for types.
        node: Ast.Node.Index,
        tag_ty: Ref,
        mode: Ref,
        field_names: Ref,
        field_values: Ref,
    };

    pub const ReifySpirvType = struct {
        src_line: u32,
        src_column: u32,
        /// This node is absolute, because `reify` instructions are tracked across updates, and
        /// this simplifies the logic for getting source locations for types.
        node: Ast.Node.Index,
        operand: Ref,
    };

    /// Trailing:
    /// 0. multi_cases_len: u32, // If has_multi_cases is set.
    /// 1. payload_capture_placeholder: Inst.Index, // If payload_capture_inst_is_placeholder is set.
    ///                                             // Index of instruction prongs use to refer to their payload capture.
    /// 2. tag_capture_placeholder: Inst.Index, // If tag_capture_inst_is_placeholder is set.
    ///                                         // Index of instruction prongs use to refer to their tag capture.
    /// 3. catch_or_if_src_node_offset: Ast.Node.Offset, // If inst is switch_block_err_union.
    /// 4. non_err_info: ProngInfo.NonErr, // If inst is switch_block_err_union.
    /// 5. else_info: ProngInfo.Else, // If has_else is set.
    /// 6. scalar_prong_info: ProngInfo, // for every scalar_cases_len
    /// 7. multi_prong_info: ProngInfo, // for every multi_cases_len
    /// 8. multi_case_items_len: u32, // for every multi_cases_len
    /// 9. multi_case_ranges_len: u32, // If has_ranges is set: for every multi_cases_len
    /// 10. scalar_item_info: ItemInfo, // for every scalar_cases_len
    /// 11. multi_items_info: { // for every multi_cases_len
    ///        item_info: ItemInfo, // for each multi_case_items_len
    ///        range_items_info: { // for each multi_case_ranges_len
    ///            first_info: ItemInfo,
    ///            last_info: ItemInfo,
    ///        }
    ///    }
    /// 12. non_err_body {
    ///        body_inst: Index // for every non_err_info.body_len
    ///     }
    /// 13. else_body: { // If has_else is set.
    ///        body_inst: Inst.Index, // for every else_info.body_len
    ///    }
    /// 14. scalar_bodies: { // for every scalar_cases_len
    ///        prong_body: { // for each body_len in scalar_prong_info
    ///            body_inst: Inst.Index, // for every body_len
    ///        }
    ///        item_body: { // for each body_len in scalar_item_info
    ///            body_inst: Inst.Index, // for every body_len
    ///        }
    ///    }
    /// 15. multi_bodies: { // for each multi_items_info
    ///        prong_body: {
    ///            body_inst: Inst.Index, // for each multi_prong_info.body_len
    ///        }
    ///        item_body: { // for each item_info
    ///            body_inst: Inst.Index, // for every item_info.body_len
    ///        }
    ///        range_bodies: { // for each .{first_info, last_info} in range_items_info
    ///            first_body_inst: Inst.Index, // for every first_info.body_len
    ///            last_body_inst: Inst.Index, // for every last_info.body_len
    ///        }
    ///    }
    pub const SwitchBlock = struct {
        /// Either `catch`/`if` or `switch` operand.
        raw_operand: Ref,
        bits: Bits,

        pub const Bits = packed struct(u32) {
            /// If true, one or more prongs have multiple items.
            has_multi_cases: bool,
            /// If true, one or more prongs have ranges.
            /// Only valid if `has_multi_cases` is also set.
            any_ranges: bool,
            has_else: bool,
            has_under: bool,
            /// If true, at least one prong contains a `continue`.
            /// Only valid if `has_label` is set.
            has_continue: bool,
            // If true, at least one prong has a non-inline payload/tag capture.
            any_maybe_runtime_capture: bool,
            payload_capture_inst_is_placeholder: bool,
            tag_capture_inst_is_placeholder: bool,
            scalar_cases_len: ScalarCasesLen,

            // NOTE maybe don't steal any more bits from poor `scalar_cases_len`
            // and split `Bits` into two parts instead, `raw_operand` surely
            // wouldn't mind donating a couple of bits for that purpose...
            pub const ScalarCasesLen = u24;
        };

        pub const ProngInfo = packed struct(u32) {
            body_len: u27,
            capture: ProngInfo.Capture,
            is_inline: bool,
            has_tag_capture: bool,
            is_comptime_unreach: bool,

            pub const Capture = enum(u2) {
                none,
                by_val,
                by_ref,
            };

            pub const NonErr = packed struct(u32) {
                body_len: u29,
                capture: ProngInfo.Capture,
                operand_is_ref: bool,
            };

            pub const Else = packed struct(u32) {
                body_len: u27,
                capture: ProngInfo.Capture,
                is_inline: bool,
                has_tag_capture: bool,
                is_simple_noreturn: bool,
            };
        };

        pub const ItemInfo = packed struct(u32) {
            kind: ItemInfo.Kind,
            data: u30,

            pub const Kind = enum(u2) {
                enum_literal,
                error_value,
                body_len,
                under,
            };

            pub const Unwrapped = union(ItemInfo.Kind) {
                enum_literal: Zir.NullTerminatedString,
                error_value: Zir.NullTerminatedString,
                body_len: u32,
                under,
            };

            pub fn wrap(unwrapped: ItemInfo.Unwrapped) ItemInfo {
                const data_uncasted: u32 = switch (unwrapped) {
                    .enum_literal => |str_index| @backingInt(str_index),
                    .error_value => |str_index| @backingInt(str_index),
                    .body_len => |body_len| body_len,
                    .under => 0,
                };
                return .{ .kind = unwrapped, .data = @intCast(data_uncasted) };
            }

            pub fn unwrap(item_info: ItemInfo) ItemInfo.Unwrapped {
                return switch (item_info.kind) {
                    .enum_literal => .{ .enum_literal = @fromBackingInt(@intCast(item_info.data)) },
                    .error_value => .{ .error_value = @fromBackingInt(@intCast(item_info.data)) },
                    .body_len => .{ .body_len = item_info.data },
                    .under => .under,
                };
            }

            pub fn bodyLen(item_info: ItemInfo) ?u32 {
                return if (item_info.kind == .body_len) item_info.data else null;
            }
        };
    };

    pub const ArrayInitRefTy = struct {
        ptr_ty: Ref,
        elem_count: u32,
    };

    pub const Field = struct {
        lhs: Ref,
        /// Offset into `string_bytes`.
        field_name_start: NullTerminatedString,
    };

    pub const FieldNamed = struct {
        lhs: Ref,
        field_name: Ref,
    };

    pub const As = struct {
        dest_type: Ref,
        operand: Ref,
    };

    /// Trailing:
    /// 0.  captures_len: u32 // if `has_captures_len`
    /// 1.  decls_len: u32, // if `has_decls_len`
    /// 2.  fields_len: u32, // if `has_fields_len`
    /// 3.  arg_baseline_src_node: Ast.Node.Index // if `has_backing_int`
    /// 4.  fields_baseline_src_node: Ast.Node.Index // if `has_fields_len`
    /// 5.  backing_int_body_len: u32 // if `has_backing_int`
    /// 6.  capture: Capture // for every `captures_len`
    /// 7.  capture_name: NullTerminatedString // for every `captures_len`
    /// 8.  decl: Index, // for every `decls_len`; points to a `declaration` instruction
    /// 9.  field_name: NullTerminatedString // for every `fields_len`
    /// 10. field_type_body_len: u32 // for every `fields_len`
    /// 11. field_align_body_len: u32 // for every `fields_len` if `any_field_aligns`
    /// 12. field_default_body_len: u32 // for every `fields_len` if `any_field_defaults`
    /// 13. field_comptime_bits: u32 // one bit per `fields_len` if `any_comptime_fields`
    ///                              // LSB is first field, minimum number of `u32` needed
    /// 14. backing_int_body_inst: Inst.Index // for each `backing_int_body_len`
    /// 15. body_inst: Inst.Index // type body, then align body, then default body, for each field
    pub const StructDecl = struct {
        // These fields should be concatenated and reinterpreted as a `std.zig.SrcHash`.
        // This hash contains the source of all fields, and any specified attributes (`extern`, backing type, etc).
        fields_hash_0: u32,
        fields_hash_1: u32,
        fields_hash_2: u32,
        fields_hash_3: u32,
        src_line: u32,
        src_column: u32,
        /// This node provides a new absolute baseline node for all instructions within this struct.
        src_node: Ast.Node.Index,

        pub const Small = packed struct(u16) {
            has_captures_len: bool,
            has_decls_len: bool,
            has_fields_len: bool,
            name_strategy: NameStrategy,
            layout: std.lang.Type.ContainerLayout,
            /// Always `false` if `layout != .@"packed"`.
            has_backing_int_type: bool,
            any_field_aligns: bool,
            any_field_defaults: bool,
            any_comptime_fields: bool,
            _: u5 = 0,
        };
    };

    /// Represents a single value being captured in a type declaration's closure.
    pub const Capture = packed struct(u32) {
        tag: enum(u3) {
            /// `data` is a `u16` index into the parent closure.
            nested,
            /// `data` is a `Zir.Inst.Index` to an instruction whose value is being captured.
            instruction,
            /// `data` is a `Zir.Inst.Index` to an instruction representing an alloc whose contents is being captured.
            instruction_load,
            /// `data` is a `NullTerminatedString` to a decl name.
            decl_val,
            /// `data` is a `NullTerminatedString` to a decl name.
            decl_ref,
        },
        data: u29,
        pub const Unwrapped = union(enum) {
            nested: u16,
            instruction: Zir.Inst.Index,
            instruction_load: Zir.Inst.Index,
            decl_val: NullTerminatedString,
            decl_ref: NullTerminatedString,
        };
        pub fn wrap(cap: Unwrapped) Capture {
            return switch (cap) {
                .nested => |idx| .{
                    .tag = .nested,
                    .data = idx,
                },
                .instruction => |inst| .{
                    .tag = .instruction,
                    .data = @intCast(@backingInt(inst)),
                },
                .instruction_load => |inst| .{
                    .tag = .instruction_load,
                    .data = @intCast(@backingInt(inst)),
                },
                .decl_val => |str| .{
                    .tag = .decl_val,
                    .data = @intCast(@backingInt(str)),
                },
                .decl_ref => |str| .{
                    .tag = .decl_ref,
                    .data = @intCast(@backingInt(str)),
                },
            };
        }
        pub fn unwrap(cap: Capture) Unwrapped {
            return switch (cap.tag) {
                .nested => .{ .nested = @intCast(cap.data) },
                .instruction => .{ .instruction = @fromBackingInt(@intCast(cap.data)) },
                .instruction_load => .{ .instruction_load = @fromBackingInt(@intCast(cap.data)) },
                .decl_val => .{ .decl_val = @fromBackingInt(@intCast(cap.data)) },
                .decl_ref => .{ .decl_ref = @fromBackingInt(@intCast(cap.data)) },
            };
        }
    };

    pub const NameStrategy = enum(u2) {
        /// Use the same name as the parent declaration name.
        /// e.g. `const Foo = struct {...};`.
        parent,
        /// Use the name of the currently executing comptime function call,
        /// with the current parameters. e.g. `ArrayList(i32)`.
        func,
        /// Create an anonymous name for this declaration.
        /// Like this: "ParentDeclName_struct_69"
        anon,
        /// Use the name specified in the next `dbg_var_{val,ptr}` instruction.
        dbg_var,
    };

    pub const FullPtrCastFlags = packed struct(u5) {
        ptr_cast: bool = false,
        align_cast: bool = false,
        addrspace_cast: bool = false,
        const_cast: bool = false,
        volatile_cast: bool = false,

        pub inline fn needResultTypeBuiltinName(flags: FullPtrCastFlags) []const u8 {
            if (flags.ptr_cast) return "@ptrCast";
            if (flags.align_cast) return "@alignCast";
            if (flags.addrspace_cast) return "@addrSpaceCast";
            unreachable;
        }
    };

    pub const StdLangValue = enum(u16) {
        // Types
        atomic_order,
        atomic_rmw_op,
        calling_convention,
        address_space,
        float_mode,
        signedness,
        reduce_op,
        call_modifier,
        prefetch_options,
        export_options,
        extern_options,
        branch_hint,
        clobbers,
        pointer_size,
        pointer_attributes,
        fn_attributes,
        container_layout,
        enum_mode,
        spirv_type_options,
        // Values
        calling_convention_c,
        calling_convention_inline,
    };

    pub const InplaceOp = enum(u16) {
        add_eq,
        sub_eq,
    };

    /// Trailing:
    /// 0. captures_len: u32, // if has_captures_len
    /// 1. decls_len: u32, // if has_decls_len
    /// 2. fields_len: u32, // if has_fields_len
    /// 3. tag_type_body_len: u32, // if has_tag_type
    /// 4. capture: Capture // for every `captures_len`
    /// 5. capture_name: NullTerminatedString // for every `captures_len`
    /// 6. decl: Index, // for every `decls_len`; points to a `declaration` instruction
    /// 7. field_name: NullTerminatedString // for every `fields_len`
    /// 8. field_value_body_len: u32 // for every `fields_len` if `any_field_values`
    /// 9. tag_type_body_inst: Inst.Index // for each `tag_type_body_len`
    /// 10. body_inst: Inst.Index // value body for each field
    pub const EnumDecl = struct {
        // These fields should be concatenated and reinterpreted as a `std.zig.SrcHash`.
        // This hash contains the source of all fields, and the backing type if specified.
        fields_hash_0: u32,
        fields_hash_1: u32,
        fields_hash_2: u32,
        fields_hash_3: u32,
        src_line: u32,
        src_column: u32,
        /// This node provides a new absolute baseline node for all instructions within this struct.
        src_node: Ast.Node.Index,

        pub const Small = packed struct(u16) {
            has_captures_len: bool,
            has_decls_len: bool,
            has_fields_len: bool,
            name_strategy: NameStrategy,
            has_tag_type: bool,
            nonexhaustive: bool,
            any_field_values: bool,
            _: u8 = 0,
        };
    };

    /// Trailing:
    /// 0.  captures_len: u32 // if `has_captures_len`
    /// 1.  decls_len: u32, // if `has_decls_len`
    /// 2.  fields_len: u32, // if `has_fields_len`
    /// 3.  arg_type_body_len: u32, // if `kind.hasArgType()`
    /// 4.  capture: Capture // for every `captures_len`
    /// 5.  capture_name: NullTerminatedString // for every `captures_len`
    /// 6.  decl: Index, // for every `decls_len`; points to a `declaration` instruction
    /// 7.  field_name: NullTerminatedString // for every `fields_len`
    /// 8.  field_type_body_len: u32 // for every `fields_len`
    /// 9 . field_align_body_len: u32 // for every `fields_len` if `any_field_aligns`
    /// 10. field_value_body_len: u32 // for every `fields_len` if `any_field_values`
    /// 11. arg_type_body_inst: Inst.Index // for each `arg_type_body_len`
    /// 12. body_inst: Inst.Index // type body, then align body, then value body, for each field
    pub const UnionDecl = struct {
        // These fields should be concatenated and reinterpreted as a `std.zig.SrcHash`.
        // This hash contains the source of all fields, and any specified attributes (`extern` etc).
        fields_hash_0: u32,
        fields_hash_1: u32,
        fields_hash_2: u32,
        fields_hash_3: u32,
        src_line: u32,
        src_column: u32,
        /// This node provides a new absolute baseline node for all instructions within this struct.
        src_node: Ast.Node.Index,

        pub const Small = packed struct(u16) {
            has_captures_len: bool,
            has_decls_len: bool,
            has_fields_len: bool,
            name_strategy: NameStrategy,
            kind: Kind,
            any_field_aligns: bool,
            any_field_values: bool,
            _: u6 = 0,
        };

        pub const Kind = enum(u3) {
            /// `union`
            auto,
            /// `union(T)`
            tagged_explicit,
            /// `union(enum)`
            tagged_enum,
            /// `union(enum(T))`
            tagged_enum_explicit,
            /// `extern union`
            @"extern",
            /// `packed union`
            @"packed",
            /// `packed union(T)`
            packed_explicit,

            pub fn hasArgType(k: Kind) bool {
                return switch (k) {
                    .auto, .tagged_enum, .@"extern", .@"packed" => false,
                    .tagged_explicit, .tagged_enum_explicit, .packed_explicit => true,
                };
            }

            pub fn layout(k: Kind) std.lang.Type.ContainerLayout {
                return switch (k) {
                    .auto, .tagged_explicit, .tagged_enum, .tagged_enum_explicit => .auto,
                    .@"extern" => .@"extern",
                    .@"packed", .packed_explicit => .@"packed",
                };
            }
        };
    };

    /// Trailing:
    /// 0. captures_len: u32, // if has_captures_len
    /// 1. decls_len: u32, // if has_decls_len
    /// 2. capture: Capture, // for every captures_len
    /// 3. capture_name: NullTerminatedString // for every captures_len
    /// 4. decl: Index, // for every decls_len; points to a `declaration` instruction
    pub const OpaqueDecl = struct {
        src_line: u32,
        src_column: u32,
        /// This node provides a new absolute baseline node for all instructions within this struct.
        src_node: Ast.Node.Index,

        pub const Small = packed struct(u16) {
            has_captures_len: bool,
            has_decls_len: bool,
            name_strategy: NameStrategy,
            _: u12 = 0,
        };
    };

    /// Trailing:
    /// 1. fields: { // for every `fields_len` (stored in `extended.small`)
    ///        type: Inst.Ref,
    ///        init: Inst.Ref, // `.none` for non-`comptime` fields
    ///    }
    pub const TupleDecl = struct {
        src_node: Ast.Node.Offset,
    };

    /// Trailing:
    /// 0. field_name: NullTerminatedString // for every fields_len
    pub const ErrorSetDecl = struct {
        fields_len: u32,
    };

    /// A f128 value, broken up into 4 u32 parts.
    pub const Float128 = struct {
        piece0: u32,
        piece1: u32,
        piece2: u32,
        piece3: u32,

        pub fn get(self: Float128) f128 {
            const int_bits = @as(u128, self.piece0) |
                (@as(u128, self.piece1) << 32) |
                (@as(u128, self.piece2) << 64) |
                (@as(u128, self.piece3) << 96);
            return @as(f128, @bitCast(int_bits));
        }
    };

    /// Trailing is an item per field.
    pub const StructInit = struct {
        /// If this is an anonymous initialization (the operand is poison), this instruction becomes the owner of a type.
        /// To resolve source locations, we need an absolute source node.
        abs_node: Ast.Node.Index,
        src_line: u32,
        src_column: u32,
        fields_len: u32,

        pub const Item = struct {
            /// The `struct_init_field_type` ZIR instruction for this field init.
            field_type: Index,
            /// The field init expression to be used as the field value. This value will be coerced
            /// to the field type if not already.
            init: Ref,
        };
    };

    /// Trailing is an Item per field.
    /// TODO make this instead array of inits followed by array of names because
    /// it will be simpler Sema code and better for CPU cache.
    pub const StructInitAnon = struct {
        /// This is an anonymous initialization, meaning this instruction becomes the owner of a type.
        /// To resolve source locations, we need an absolute source node.
        abs_node: Ast.Node.Index,
        src_line: u32,
        src_column: u32,
        fields_len: u32,

        pub const Item = struct {
            /// Null-terminated string table index.
            field_name: NullTerminatedString,
            /// The field init expression to be used as the field value.
            init: Ref,
        };
    };

    pub const FieldType = struct {
        container_type: Ref,
        /// Offset into `string_bytes`, null terminated.
        name_start: NullTerminatedString,
    };

    pub const FieldTypeRef = struct {
        container_type: Ref,
        field_name: Ref,
    };

    pub const Cmpxchg = struct {
        node: Ast.Node.Offset,
        ptr: Ref,
        expected_value: Ref,
        new_value: Ref,
        success_order: Ref,
        failure_order: Ref,
    };

    pub const AtomicRmw = struct {
        ptr: Ref,
        operation: Ref,
        operand: Ref,
        ordering: Ref,
    };

    pub const UnionInit = struct {
        union_type: Ref,
        field_name: Ref,
        init: Ref,
    };

    pub const AtomicStore = struct {
        ptr: Ref,
        operand: Ref,
        ordering: Ref,
    };

    pub const AtomicLoad = struct {
        elem_type: Ref,
        ptr: Ref,
        ordering: Ref,
    };

    pub const MulAdd = struct {
        mulend1: Ref,
        mulend2: Ref,
        addend: Ref,
    };

    pub const FieldParentPtr = struct {
        src_node: Ast.Node.Offset,
        parent_ptr_type: Ref,
        field_name: Ref,
        field_ptr: Ref,
    };

    pub const Shuffle = struct {
        elem_type: Ref,
        a: Ref,
        b: Ref,
        mask: Ref,
    };

    pub const Select = struct {
        node: Ast.Node.Offset,
        elem_type: Ref,
        pred: Ref,
        a: Ref,
        b: Ref,
    };

    /// Trailing: inst: Index // for every body_len
    pub const Param = struct {
        /// Null-terminated string index.
        name: NullTerminatedString,
        type: Type,

        pub const Type = packed struct(u32) {
            /// The body contains the type of the parameter.
            body_len: u31,
            /// Whether the type is generic, i.e. refers to one or more previous parameters.
            is_generic: bool,
        };
    };

    /// Trailing:
    /// 0. type_inst: Ref,  // if small 0b000X is set
    /// 1. align_inst: Ref, // if small 0b00X0 is set
    pub const AllocExtended = struct {
        src_node: Ast.Node.Offset,

        pub const Small = packed struct(u16) {
            has_type: bool,
            has_align: bool,
            is_const: bool,
            is_comptime: bool,
            _: u12 = 0,
        };
    };

    pub const Export = struct {
        exported: Ref,
        options: Ref,
    };

    /// Trailing: `CompileErrors.Item` for each `items_len`.
    pub const CompileErrors = struct {
        items_len: u32,

        /// Trailing: `note_payload_index: u32` for each `notes_len`.
        /// It's a payload index of another `Item`.
        pub const Item = struct {
            /// null terminated string index
            msg: NullTerminatedString,
            node: Ast.Node.OptionalIndex,
            /// If node is .none then this will be populated.
            token: Ast.OptionalTokenIndex,
            /// Can be used in combination with `token`.
            byte_offset: u32,
            /// 0 or a payload index of a `Block`, each is a payload
            /// index of another `Item`.
            notes: u32,

            pub fn notesLen(item: Item, zir: Zir) u32 {
                if (item.notes == 0) return 0;
                const block = zir.extraData(Block, item.notes);
                return block.data.body_len;
            }
        };
    };

    /// Trailing: for each `imports_len` there is an Item
    pub const Imports = struct {
        imports_len: u32,

        pub const Item = struct {
            /// null terminated string index
            name: NullTerminatedString,
            /// points to the import name
            token: Ast.TokenIndex,
        };
    };

    pub const LineColumn = struct {
        line: u32,
        column: u32,
    };

    pub const ArrayInit = struct {
        ty: Ref,
        init_count: u32,
    };

    pub const Src = struct {
        node: Ast.Node.Offset,
        line: u32,
        column: u32,
    };

    pub const ValidateDestructure = struct {
        /// The value being destructured.
        operand: Ref,
        /// The `destructure_assign` node.
        destructure_node: Ast.Node.Offset,
        /// The expected field count.
        expect_len: u32,
    };

    pub const RestoreErrRetIndex = struct {
        src_node: Ast.Node.Offset,
        /// If `.none`, restore the trace to its state upon function entry.
        block: Ref,
        /// If `.none`, restore unconditionally.
        operand: Ref,
    };

    pub const Import = struct {
        /// The result type of the import, or `.none` if none was available.
        res_ty: Ref,
        /// The import path.
        path: NullTerminatedString,
    };
};

/// `DeclContents` contains all "interesting" instructions found within a declaration by `findTrackable`.
/// These instructions are partitioned into a few different sets, since this makes ZIR instruction mapping
/// more effective.
pub const DeclContents = struct {
    /// This is a simple optional because ZIR guarantees that a `func`/`func_inferred`/`func_fancy` instruction
    /// can only occur once per `declaration`.
    func_decl: ?Inst.Index,
    type_decls: std.ArrayList(Inst.Index),
    other: std.ArrayList(Inst.Index),

    pub const init: DeclContents = .{
        .func_decl = null,
        .type_decls = .empty,
        .other = .empty,
    };

    pub fn clear(contents: *DeclContents) void {
        contents.func_decl = null;
        contents.type_decls.clearRetainingCapacity();
        contents.other.clearRetainingCapacity();
    }

    pub fn deinit(contents: *DeclContents, gpa: Allocator) void {
        contents.type_decls.deinit(gpa);
        contents.other.deinit(gpa);
    }
};

/// Find all tracked ZIR instructions, recursively, within a `declaration` instruction. Does not recurse through
/// nested declarations; to find all declarations, call this function recursively on the type declarations discovered
/// in `contents.type_decls`.
///
/// This populates an `ArrayList` because an iterator would need to allocate memory anyway.
pub fn findTrackable(zir: Zir, gpa: Allocator, contents: *DeclContents, decl_inst: Zir.Inst.Index) !void {
    contents.clear();

    const decl = zir.getDeclaration(decl_inst);

    // `defer` instructions duplicate the same body arbitrarily many times, but we only want to traverse
    // their contents once per defer. So, we store the extra index of the body here to deduplicate.
    var found_defers: std.AutoHashMapUnmanaged(u32, void) = .empty;
    defer found_defers.deinit(gpa);

    if (decl.type_body) |b| try zir.findTrackableBody(gpa, contents, &found_defers, b);
    if (decl.align_body) |b| try zir.findTrackableBody(gpa, contents, &found_defers, b);
    if (decl.linksection_body) |b| try zir.findTrackableBody(gpa, contents, &found_defers, b);
    if (decl.addrspace_body) |b| try zir.findTrackableBody(gpa, contents, &found_defers, b);
    if (decl.value_body) |b| try zir.findTrackableBody(gpa, contents, &found_defers, b);
}

/// `findTrackable` does not recurse into field expressions in a type. Instead, this function will
/// scan specifically field expressions in a given type declaration for trackable ZIR instructions.
pub fn findTrackableFields(
    zir: *const Zir,
    gpa: Allocator,
    contents: *DeclContents,
    type_decl_inst: Zir.Inst.Index,
) Allocator.Error!void {
    contents.clear();

    var found_defers: std.AutoHashMapUnmanaged(u32, void) = .empty;
    defer found_defers.deinit(gpa);

    assert(zir.instructions.items(.tag)[@backingInt(type_decl_inst)] == .extended);
    switch (zir.instructions.items(.data)[@backingInt(type_decl_inst)].extended.opcode) {
        .struct_decl => {
            const struct_decl = zir.getStructDecl(type_decl_inst);
            var it = struct_decl.iterateFields();
            while (it.next()) |field| {
                try zir.findTrackableBody(gpa, contents, &found_defers, field.type_body);
                if (field.align_body) |b| try zir.findTrackableBody(gpa, contents, &found_defers, b);
                if (field.default_body) |b| try zir.findTrackableBody(gpa, contents, &found_defers, b);
            }
        },
        .union_decl => {
            const union_decl = zir.getUnionDecl(type_decl_inst);
            var it = union_decl.iterateFields();
            while (it.next()) |field| {
                if (field.type_body) |b| try zir.findTrackableBody(gpa, contents, &found_defers, b);
                if (field.align_body) |b| try zir.findTrackableBody(gpa, contents, &found_defers, b);
                if (field.value_body) |b| try zir.findTrackableBody(gpa, contents, &found_defers, b);
            }
        },
        .enum_decl => {
            const enum_decl = zir.getEnumDecl(type_decl_inst);
            var it = enum_decl.iterateFields();
            while (it.next()) |field| {
                if (field.value_body) |b| try zir.findTrackableBody(gpa, contents, &found_defers, b);
            }
        },
        .opaque_decl => {},
        else => unreachable,
    }
}

fn findTrackableInner(
    zir: Zir,
    gpa: Allocator,
    contents: *DeclContents,
    defers: *std.AutoHashMapUnmanaged(u32, void),
    inst: Inst.Index,
) Allocator.Error!void {
    comptime assert(Zir.inst_tracking_version == 0);

    const tags = zir.instructions.items(.tag);
    const datas = zir.instructions.items(.data);

    switch (tags[@backingInt(inst)]) {
        .declaration => unreachable,

        // Boring instruction tags first. These have no body and are not declarations or type declarations.
        .add,
        .addwrap,
        .add_sat,
        .add_unsafe,
        .sub,
        .subwrap,
        .sub_sat,
        .mul,
        .mulwrap,
        .mul_sat,
        .div_exact,
        .div_floor,
        .div_ceil,
        .div_trunc,
        .mod,
        .rem,
        .mod_rem,
        .shl,
        .shl_exact,
        .shl_sat,
        .shr,
        .shr_exact,
        .param_anytype,
        .param_anytype_comptime,
        .array_cat,
        .array_type,
        .array_type_sentinel,
        .reify_int,
        .vector_type,
        .elem_type,
        .indexable_ptr_elem_type,
        .splat_op_result_ty,
        .from_backing_int_arg_ty,
        .indexable_ptr_len,
        .anyframe_type,
        .as_node,
        .as_shift_operand,
        .bit_and,
        .bitcast,
        .bit_not,
        .bit_or,
        .bool_not,
        .bool_br_and,
        .bool_br_or,
        .@"break",
        .break_inline,
        .switch_continue,
        .check_comptime_control_flow,
        .builtin_call,
        .cmp_lt,
        .cmp_lte,
        .cmp_eq,
        .cmp_gte,
        .cmp_gt,
        .cmp_neq,
        .error_set_decl,
        .dbg_stmt,
        .dbg_var_ptr,
        .dbg_var_val,
        .decl_ref,
        .decl_val,
        .load,
        .div,
        .elem_ptr_node,
        .elem_ptr,
        .elem_ptr_load,
        .elem_val,
        .elem_val_imm,
        .ensure_result_used,
        .ensure_result_non_error,
        .ensure_err_union_payload_void,
        .error_union_type,
        .error_value,
        .@"export",
        .field_ptr,
        .field_ptr_load,
        .field_ptr_named,
        .field_ptr_named_load,
        .import,
        .int,
        .int_big,
        .float,
        .float128,
        .int_type,
        .is_non_null,
        .is_non_null_ptr,
        .is_non_err,
        .is_non_err_ptr,
        .ret_is_non_err,
        .repeat,
        .repeat_inline,
        .for_len,
        .merge_error_sets,
        .ref,
        .deref,
        .ref_deref,
        .ret_node,
        .ret_load,
        .ret_implicit,
        .ret_err_value,
        .ret_ptr,
        .ret_type,
        .ptr_type,
        .slice_start,
        .slice_end,
        .slice_sentinel,
        .slice_length,
        .slice_sentinel_ty,
        .store_node,
        .store_to_inferred_ptr,
        .str,
        .negate,
        .negate_wrap,
        .typeof,
        .typeof_log2_int_type,
        .@"unreachable",
        .xor,
        .optional_type,
        .optional_payload_safe,
        .optional_payload_unsafe,
        .optional_payload_safe_ptr,
        .optional_payload_unsafe_ptr,
        .err_union_payload_unsafe,
        .err_union_payload_unsafe_ptr,
        .err_union_code,
        .err_union_code_ptr,
        .enum_literal,
        .decl_literal,
        .decl_literal_no_coerce,
        .validate_destructure,
        .field_type_ref,
        .opt_eu_base_ptr_init,
        .coerce_ptr_elem_ty,
        .validate_ref_ty,
        .validate_const,
        .struct_init_empty,
        .struct_init_empty_result,
        .struct_init_empty_ref_result,
        .validate_struct_init_ty,
        .validate_struct_init_result_ty,
        .validate_ptr_struct_init,
        .struct_init_field_type,
        .struct_init_field_ptr,
        .array_init_anon,
        .array_init,
        .array_init_ref,
        .validate_array_init_ty,
        .validate_array_init_result_ty,
        .validate_array_init_ref_ty,
        .validate_ptr_array_init,
        .array_init_elem_type,
        .array_init_elem_ptr,
        .union_init,
        .type_info,
        .size_of,
        .bit_size_of,
        .int_from_ptr,
        .compile_error,
        .set_eval_branch_quota,
        .int_from_enum,
        .align_of,
        .int_from_bool,
        .embed_file,
        .error_name,
        .panic,
        .trap,
        .set_runtime_safety,
        .sqrt,
        .sin,
        .cos,
        .tan,
        .exp,
        .exp2,
        .log,
        .log2,
        .log10,
        .abs,
        .floor,
        .ceil,
        .trunc,
        .round,
        .tag_name,
        .type_name,
        .frame_type,
        .int_from_float,
        .float_from_int,
        .ptr_from_int,
        .enum_from_int,
        .backing_int,
        .from_backing_int,
        .float_cast,
        .int_cast,
        .ptr_cast,
        .truncate,
        .has_decl,
        .has_field,
        .clz,
        .ctz,
        .pop_count,
        .byte_swap,
        .bit_reverse,
        .bit_offset_of,
        .offset_of,
        .splat,
        .reduce,
        .shuffle,
        .atomic_load,
        .atomic_rmw,
        .atomic_store,
        .mul_add,
        .memcpy,
        .memset,
        .memmove,
        .min,
        .max,
        .alloc,
        .alloc_mut,
        .alloc_comptime_mut,
        .alloc_inferred,
        .alloc_inferred_mut,
        .alloc_inferred_comptime,
        .alloc_inferred_comptime_mut,
        .resolve_inferred_alloc,
        .make_ptr_const,
        .@"resume",
        .save_err_ret_index,
        .restore_err_ret_index_unconditional,
        .restore_err_ret_index_fn_entry,
        => return,

        // Struct initializations need tracking, as they may create anonymous struct types.
        .struct_init,
        .struct_init_ref,
        .struct_init_anon,
        => return contents.other.append(gpa, inst),

        .extended => {
            const extended = datas[@backingInt(inst)].extended;
            switch (extended.opcode) {
                .value_placeholder => unreachable,

                // Once again, we start with the boring tags.
                .this,
                .ret_addr,
                .builtin_src,
                .error_return_trace,
                .frame,
                .frame_address,
                .alloc,
                .builtin_extern,
                .@"asm",
                .asm_expr,
                .compile_log,
                .min_multi,
                .max_multi,
                .add_with_overflow,
                .sub_with_overflow,
                .mul_with_overflow,
                .shl_with_overflow,
                .round_op,
                .wasm_memory_size,
                .wasm_memory_grow,
                .prefetch,
                .set_float_mode,
                .error_cast,
                .breakpoint,
                .disable_instrumentation,
                .disable_intrinsics,
                .select,
                .int_from_error,
                .error_from_int,
                .reify_slice_arg_ty,
                .reify_enum_value_slice_ty,
                .reify_pointer_sentinel_ty,
                .reify_tuple,
                .reify_pointer,
                .reify_fn,
                .cmpxchg,
                .c_va_arg,
                .c_va_copy,
                .c_va_end,
                .c_va_start,
                .ptr_cast_full,
                .ptr_cast_no_dest,
                .work_item_id,
                .work_group_size,
                .work_group_id,
                .in_comptime,
                .restore_err_ret_index,
                .closure_get,
                .field_parent_ptr,
                .std_lang_value,
                .branch_hint,
                .inplace_arith_result_ty,
                .tuple_decl,
                .dbg_empty_stmt,
                .astgen_error,
                .float_op_result_ty,
                .round_op_ty,
                => return,

                // `@TypeOf` has a body.
                .typeof_peer => {
                    const extra = zir.extraData(Zir.Inst.TypeOfPeer, extended.operand);
                    const body = zir.bodySlice(extra.data.body_index, extra.data.body_len);
                    try zir.findTrackableBody(gpa, contents, defers, body);
                },

                // Reifications need tracking.
                .reify_enum,
                .reify_struct,
                .reify_union,
                .reify_spirv_type,
                => return contents.other.append(gpa, inst),

                // Type declarations need tracking.
                .struct_decl,
                .union_decl,
                .enum_decl,
                .opaque_decl,
                => return contents.type_decls.append(gpa, inst),
            }
        },

        // Functions instructions are interesting and have a body.
        .func,
        .func_inferred,
        => {
            const inst_data = datas[@backingInt(inst)].pl_node;
            const extra = zir.extraData(Inst.Func, inst_data.payload_index);

            if (extra.data.body_len == 0) {
                // This is just a prototype. No need to track.
                assert(extra.data.ret_ty.body_len < 2);
                return;
            }

            assert(contents.func_decl == null);
            contents.func_decl = inst;

            var extra_index: usize = extra.end;
            switch (extra.data.ret_ty.body_len) {
                0 => {},
                1 => extra_index += 1,
                else => {
                    const body = zir.bodySlice(extra_index, extra.data.ret_ty.body_len);
                    extra_index += body.len;
                    try zir.findTrackableBody(gpa, contents, defers, body);
                },
            }
            const body = zir.bodySlice(extra_index, extra.data.body_len);
            return zir.findTrackableBody(gpa, contents, defers, body);
        },
        .func_fancy => {
            const inst_data = datas[@backingInt(inst)].pl_node;
            const extra = zir.extraData(Inst.FuncFancy, inst_data.payload_index);

            if (extra.data.body_len == 0) {
                // This is just a prototype. No need to track.
                assert(!extra.data.bits.has_cc_body);
                assert(!extra.data.bits.has_ret_ty_body);
                return;
            }

            assert(contents.func_decl == null);
            contents.func_decl = inst;

            var extra_index: usize = extra.end;

            if (extra.data.bits.has_cc_body) {
                const body_len = zir.extra[extra_index];
                extra_index += 1;
                const body = zir.bodySlice(extra_index, body_len);
                try zir.findTrackableBody(gpa, contents, defers, body);
                extra_index += body.len;
            } else if (extra.data.bits.has_cc_ref) {
                extra_index += 1;
            }

            if (extra.data.bits.has_ret_ty_body) {
                const body_len = zir.extra[extra_index];
                extra_index += 1;
                const body = zir.bodySlice(extra_index, body_len);
                try zir.findTrackableBody(gpa, contents, defers, body);
                extra_index += body.len;
            } else if (extra.data.bits.has_ret_ty_ref) {
                extra_index += 1;
            }

            extra_index += @intFromBool(extra.data.bits.has_any_noalias);

            const body = zir.bodySlice(extra_index, extra.data.body_len);
            return zir.findTrackableBody(gpa, contents, defers, body);
        },

        // Block instructions, recurse over the bodies.

        .block,
        .block_inline,
        .typeof_builtin,
        .loop,
        => {
            const inst_data = datas[@backingInt(inst)].pl_node;
            const extra = zir.extraData(Inst.Block, inst_data.payload_index);
            const body = zir.bodySlice(extra.end, extra.data.body_len);
            return zir.findTrackableBody(gpa, contents, defers, body);
        },
        .block_comptime => {
            const inst_data = datas[@backingInt(inst)].pl_node;
            const extra = zir.extraData(Inst.BlockComptime, inst_data.payload_index);
            const body = zir.bodySlice(extra.end, extra.data.body_len);
            return zir.findTrackableBody(gpa, contents, defers, body);
        },
        .condbr, .condbr_inline => {
            const inst_data = datas[@backingInt(inst)].pl_node;
            const extra = zir.extraData(Inst.CondBr, inst_data.payload_index);
            const then_body = zir.bodySlice(extra.end, extra.data.then_body_len);
            const else_body = zir.bodySlice(extra.end + then_body.len, extra.data.else_body_len);
            try zir.findTrackableBody(gpa, contents, defers, then_body);
            try zir.findTrackableBody(gpa, contents, defers, else_body);
        },
        .@"try", .try_ptr => {
            const inst_data = datas[@backingInt(inst)].pl_node;
            const extra = zir.extraData(Inst.Try, inst_data.payload_index);
            const body = zir.bodySlice(extra.end, extra.data.body_len);
            try zir.findTrackableBody(gpa, contents, defers, body);
        },

        .switch_block,
        .switch_block_ref,
        .switch_block_err_union,
        => {
            const zir_switch = zir.getSwitchBlock(inst);
            if (zir_switch.non_err_case) |non_err_case| {
                try zir.findTrackableBody(gpa, contents, defers, non_err_case.body);
            }
            if (zir_switch.else_case) |else_case| {
                try zir.findTrackableBody(gpa, contents, defers, else_case.body);
            }
            var extra_index = zir_switch.end;
            var case_it = zir_switch.iterateCases();
            while (case_it.next()) |case| {
                const prong_body = zir.bodySlice(extra_index, case.prong_info.body_len);
                extra_index += prong_body.len;
                try zir.findTrackableBody(gpa, contents, defers, prong_body);
                for (case.item_infos) |item_info| {
                    if (item_info.bodyLen()) |body_len| {
                        const item_body = zir.bodySlice(extra_index, body_len);
                        extra_index += item_body.len;
                        try zir.findTrackableBody(gpa, contents, defers, item_body);
                    }
                }
                for (case.range_infos) |range_info| {
                    if (range_info[0].bodyLen()) |body_len| {
                        const first_body = zir.bodySlice(extra_index, body_len);
                        extra_index += first_body.len;
                        try zir.findTrackableBody(gpa, contents, defers, first_body);
                    }
                    if (range_info[1].bodyLen()) |body_len| {
                        const last_body = zir.bodySlice(extra_index, body_len);
                        extra_index += last_body.len;
                        try zir.findTrackableBody(gpa, contents, defers, last_body);
                    }
                }
            }
        },

        .suspend_block => @panic("TODO iterate suspend block"),

        .param, .param_comptime => {
            const inst_data = datas[@backingInt(inst)].pl_tok;
            const extra = zir.extraData(Inst.Param, inst_data.payload_index);
            const body = zir.bodySlice(extra.end, extra.data.type.body_len);
            try zir.findTrackableBody(gpa, contents, defers, body);
        },

        inline .call, .field_call => |tag| {
            const inst_data = datas[@backingInt(inst)].pl_node;
            const extra = zir.extraData(switch (tag) {
                .call => Inst.Call,
                .field_call => Inst.FieldCall,
                else => unreachable,
            }, inst_data.payload_index);
            // It's easiest to just combine all the arg bodies into one body, like we do above for `struct_decl`.
            const args_len = extra.data.flags.args_len;
            if (args_len > 0) {
                const first_arg_start_off = args_len;
                const final_arg_end_off = zir.extra[extra.end + args_len - 1];
                const args_body = zir.bodySlice(extra.end + first_arg_start_off, final_arg_end_off - first_arg_start_off);
                try zir.findTrackableBody(gpa, contents, defers, args_body);
            }
        },
        .@"defer" => {
            const inst_data = datas[@backingInt(inst)].@"defer";
            const gop = try defers.getOrPut(gpa, inst_data.index);
            if (!gop.found_existing) {
                const body = zir.bodySlice(inst_data.index, inst_data.len);
                try zir.findTrackableBody(gpa, contents, defers, body);
            }
        },
    }
}

fn findTrackableBody(
    zir: Zir,
    gpa: Allocator,
    contents: *DeclContents,
    defers: *std.AutoHashMapUnmanaged(u32, void),
    body: []const Inst.Index,
) Allocator.Error!void {
    for (body) |member| {
        try zir.findTrackableInner(gpa, contents, defers, member);
    }
}

pub const FnInfo = struct {
    param_body: []const Inst.Index,
    param_body_inst: Inst.Index,
    ret_ty_body: []const Inst.Index,
    body: []const Inst.Index,
    ret_ty_ref: Zir.Inst.Ref,
    ret_ty_is_generic: bool,
    total_params_len: u32,
    inferred_error_set: bool,
};

pub fn getParamBody(zir: Zir, fn_inst: Inst.Index) []const Zir.Inst.Index {
    const tags = zir.instructions.items(.tag);
    const datas = zir.instructions.items(.data);
    const inst_data = datas[@backingInt(fn_inst)].pl_node;

    const param_block_index = switch (tags[@backingInt(fn_inst)]) {
        .func, .func_inferred => blk: {
            const extra = zir.extraData(Inst.Func, inst_data.payload_index);
            break :blk extra.data.param_block;
        },
        .func_fancy => blk: {
            const extra = zir.extraData(Inst.FuncFancy, inst_data.payload_index);
            break :blk extra.data.param_block;
        },
        else => unreachable,
    };

    switch (tags[@backingInt(param_block_index)]) {
        .block, .block_comptime, .block_inline => {
            const param_block = zir.extraData(Inst.Block, datas[@backingInt(param_block_index)].pl_node.payload_index);
            return zir.bodySlice(param_block.end, param_block.data.body_len);
        },
        .declaration => {
            return zir.getDeclaration(param_block_index).value_body.?;
        },
        else => unreachable,
    }
}

pub fn getParamName(zir: Zir, param_inst: Inst.Index) ?NullTerminatedString {
    const inst = zir.instructions.get(@backingInt(param_inst));
    return switch (inst.tag) {
        .param, .param_comptime => zir.extraData(Inst.Param, inst.data.pl_tok.payload_index).data.name,
        .param_anytype, .param_anytype_comptime => inst.data.str_tok.start,
        else => null,
    };
}

pub fn getFnInfo(zir: Zir, fn_inst: Inst.Index) FnInfo {
    const tags = zir.instructions.items(.tag);
    const datas = zir.instructions.items(.data);
    const info: struct {
        param_block: Inst.Index,
        body: []const Inst.Index,
        ret_ty_ref: Inst.Ref,
        ret_ty_body: []const Inst.Index,
        ret_ty_is_generic: bool,
        ies: bool,
    } = switch (tags[@backingInt(fn_inst)]) {
        .func, .func_inferred => |tag| blk: {
            const inst_data = datas[@backingInt(fn_inst)].pl_node;
            const extra = zir.extraData(Inst.Func, inst_data.payload_index);

            var extra_index: usize = extra.end;
            var ret_ty_ref: Inst.Ref = .none;
            var ret_ty_body: []const Inst.Index = &.{};

            switch (extra.data.ret_ty.body_len) {
                0 => {
                    ret_ty_ref = .void_type;
                },
                1 => {
                    ret_ty_ref = @fromBackingInt(@intCast(zir.extra[extra_index]));
                    extra_index += 1;
                },
                else => {
                    ret_ty_body = zir.bodySlice(extra_index, extra.data.ret_ty.body_len);
                    extra_index += ret_ty_body.len;
                },
            }

            const body = zir.bodySlice(extra_index, extra.data.body_len);
            extra_index += body.len;

            break :blk .{
                .param_block = extra.data.param_block,
                .ret_ty_ref = ret_ty_ref,
                .ret_ty_body = ret_ty_body,
                .body = body,
                .ret_ty_is_generic = extra.data.ret_ty.is_generic,
                .ies = tag == .func_inferred,
            };
        },
        .func_fancy => blk: {
            const inst_data = datas[@backingInt(fn_inst)].pl_node;
            const extra = zir.extraData(Inst.FuncFancy, inst_data.payload_index);

            var extra_index: usize = extra.end;
            var ret_ty_ref: Inst.Ref = .none;
            var ret_ty_body: []const Inst.Index = &.{};

            if (extra.data.bits.has_cc_body) {
                extra_index += zir.extra[extra_index] + 1;
            } else if (extra.data.bits.has_cc_ref) {
                extra_index += 1;
            }
            if (extra.data.bits.has_ret_ty_body) {
                const body_len = zir.extra[extra_index];
                extra_index += 1;
                ret_ty_body = zir.bodySlice(extra_index, body_len);
                extra_index += ret_ty_body.len;
            } else if (extra.data.bits.has_ret_ty_ref) {
                ret_ty_ref = @fromBackingInt(@intCast(zir.extra[extra_index]));
                extra_index += 1;
            } else {
                ret_ty_ref = .void_type;
            }

            extra_index += @intFromBool(extra.data.bits.has_any_noalias);

            const body = zir.bodySlice(extra_index, extra.data.body_len);
            extra_index += body.len;
            break :blk .{
                .param_block = extra.data.param_block,
                .ret_ty_ref = ret_ty_ref,
                .ret_ty_body = ret_ty_body,
                .body = body,
                .ret_ty_is_generic = extra.data.bits.ret_ty_is_generic,
                .ies = extra.data.bits.is_inferred_error,
            };
        },
        else => unreachable,
    };
    const param_body = zir.getParamBody(fn_inst);
    var total_params_len: u32 = 0;
    for (param_body) |inst| {
        switch (tags[@backingInt(inst)]) {
            .param, .param_comptime, .param_anytype, .param_anytype_comptime => {
                total_params_len += 1;
            },
            else => continue,
        }
    }
    return .{
        .param_body = param_body,
        .param_body_inst = info.param_block,
        .ret_ty_body = info.ret_ty_body,
        .ret_ty_ref = info.ret_ty_ref,
        .body = info.body,
        .total_params_len = total_params_len,
        .ret_ty_is_generic = info.ret_ty_is_generic,
        .inferred_error_set = info.ies,
    };
}

pub fn getDeclaration(zir: Zir, inst: Zir.Inst.Index) Inst.Declaration.Unwrapped {
    assert(zir.instructions.items(.tag)[@backingInt(inst)] == .declaration);
    const pl_node = zir.instructions.items(.data)[@backingInt(inst)].declaration;
    const extra = zir.extraData(Inst.Declaration, pl_node.payload_index);

    const flags_vals: [2]u32 = .{ extra.data.flags_0, extra.data.flags_1 };
    const flags: Inst.Declaration.Flags = @bitCast(flags_vals);

    var extra_index = extra.end;

    const name: NullTerminatedString = if (flags.id.hasName()) name: {
        const name = zir.extra[extra_index];
        extra_index += 1;
        break :name @fromBackingInt(@intCast(name));
    } else .empty;

    const lib_name: NullTerminatedString = if (flags.id.hasLibName()) lib_name: {
        const lib_name = zir.extra[extra_index];
        extra_index += 1;
        break :lib_name @fromBackingInt(@intCast(lib_name));
    } else .empty;

    const type_body_len: u32 = if (flags.id.hasTypeBody()) len: {
        const len = zir.extra[extra_index];
        extra_index += 1;
        break :len len;
    } else 0;
    const align_body_len: u32, const linksection_body_len: u32, const addrspace_body_len: u32 = lens: {
        if (!flags.id.hasSpecialBodies()) break :lens .{ 0, 0, 0 };
        const lens = zir.extra[extra_index..][0..3].*;
        extra_index += 3;
        break :lens lens;
    };
    const value_body_len: u32 = if (flags.id.hasValueBody()) len: {
        const len = zir.extra[extra_index];
        extra_index += 1;
        break :len len;
    } else 0;

    const type_body = zir.bodySlice(extra_index, type_body_len);
    extra_index += type_body_len;
    const align_body = zir.bodySlice(extra_index, align_body_len);
    extra_index += align_body_len;
    const linksection_body = zir.bodySlice(extra_index, linksection_body_len);
    extra_index += linksection_body_len;
    const addrspace_body = zir.bodySlice(extra_index, addrspace_body_len);
    extra_index += addrspace_body_len;
    const value_body = zir.bodySlice(extra_index, value_body_len);
    extra_index += value_body_len;

    return .{
        .src_node = pl_node.src_node,

        .src_line = flags.src_line,
        .src_column = flags.src_column,

        .kind = flags.id.kind(),
        .name = name,
        .is_pub = flags.id.isPub(),
        .is_threadlocal = flags.id.isThreadlocal(),
        .linkage = flags.id.linkage(),
        .lib_name = lib_name,

        .type_body = if (type_body_len == 0) null else type_body,
        .align_body = if (align_body_len == 0) null else align_body,
        .linksection_body = if (linksection_body_len == 0) null else linksection_body,
        .addrspace_body = if (addrspace_body_len == 0) null else addrspace_body,
        .value_body = if (value_body_len == 0) null else value_body,
    };
}

pub fn getAssociatedSrcHash(zir: Zir, inst: Zir.Inst.Index) ?std.zig.SrcHash {
    const tag = zir.instructions.items(.tag);
    const data = zir.instructions.items(.data);
    switch (tag[@backingInt(inst)]) {
        .declaration => {
            const declaration = data[@backingInt(inst)].declaration;
            const extra = zir.extraData(Inst.Declaration, declaration.payload_index);
            return @bitCast([4]u32{
                extra.data.src_hash_0,
                extra.data.src_hash_1,
                extra.data.src_hash_2,
                extra.data.src_hash_3,
            });
        },
        .func, .func_inferred => {
            const pl_node = data[@backingInt(inst)].pl_node;
            const extra = zir.extraData(Inst.Func, pl_node.payload_index);
            if (extra.data.body_len == 0) {
                // Function type or extern fn - no associated hash
                return null;
            }
            const extra_index = extra.end +
                extra.data.ret_ty.body_len +
                extra.data.body_len +
                @typeInfo(Inst.Func.SrcLocs).@"struct".field_names.len;
            return @bitCast([4]u32{
                zir.extra[extra_index + 0],
                zir.extra[extra_index + 1],
                zir.extra[extra_index + 2],
                zir.extra[extra_index + 3],
            });
        },
        .func_fancy => {
            const pl_node = data[@backingInt(inst)].pl_node;
            const extra = zir.extraData(Inst.FuncFancy, pl_node.payload_index);
            if (extra.data.body_len == 0) {
                // Function type or extern fn - no associated hash
                return null;
            }
            const bits = extra.data.bits;
            var extra_index = extra.end;
            if (bits.has_cc_body) {
                const body_len = zir.extra[extra_index];
                extra_index += 1 + body_len;
            } else extra_index += @intFromBool(bits.has_cc_ref);
            if (bits.has_ret_ty_body) {
                const body_len = zir.extra[extra_index];
                extra_index += 1 + body_len;
            } else extra_index += @intFromBool(bits.has_ret_ty_ref);
            extra_index += @intFromBool(bits.has_any_noalias);
            extra_index += extra.data.body_len;
            extra_index += @typeInfo(Zir.Inst.Func.SrcLocs).@"struct".field_names.len;
            return @bitCast([4]u32{
                zir.extra[extra_index + 0],
                zir.extra[extra_index + 1],
                zir.extra[extra_index + 2],
                zir.extra[extra_index + 3],
            });
        },
        .extended => {},
        else => return null,
    }
    const extended = data[@backingInt(inst)].extended;
    switch (extended.opcode) {
        .struct_decl => {
            const extra = zir.extraData(Inst.StructDecl, extended.operand).data;
            return @bitCast([4]u32{
                extra.fields_hash_0,
                extra.fields_hash_1,
                extra.fields_hash_2,
                extra.fields_hash_3,
            });
        },
        .union_decl => {
            const extra = zir.extraData(Inst.UnionDecl, extended.operand).data;
            return @bitCast([4]u32{
                extra.fields_hash_0,
                extra.fields_hash_1,
                extra.fields_hash_2,
                extra.fields_hash_3,
            });
        },
        .enum_decl => {
            const extra = zir.extraData(Inst.EnumDecl, extended.operand).data;
            return @bitCast([4]u32{
                extra.fields_hash_0,
                extra.fields_hash_1,
                extra.fields_hash_2,
                extra.fields_hash_3,
            });
        },
        else => return null,
    }
}

pub fn getSwitchBlock(zir: *const Zir, switch_inst: Inst.Index) UnwrappedSwitchBlock {
    const has_non_err = switch (zir.instructions.items(.tag)[@backingInt(switch_inst)]) {
        .switch_block, .switch_block_ref => false,
        .switch_block_err_union => true,
        else => unreachable,
    };
    const inst_data = zir.instructions.items(.data)[@backingInt(switch_inst)].pl_node;
    const extra = zir.extraData(Inst.SwitchBlock, inst_data.payload_index);
    const bits = extra.data.bits;
    var extra_index = extra.end;
    const multi_cases_len = if (bits.has_multi_cases) len: {
        const multi_cases_len = zir.extra[extra_index];
        extra_index += 1;
        break :len multi_cases_len;
    } else 0;
    const payload_capture_placeholder: Inst.OptionalIndex = if (bits.payload_capture_inst_is_placeholder) inst: {
        const inst: Inst.Index = @fromBackingInt(@intCast(zir.extra[extra_index]));
        extra_index += 1;
        break :inst inst.toOptional();
    } else .none;
    const tag_capture_placeholder: Inst.OptionalIndex = if (bits.tag_capture_inst_is_placeholder) inst: {
        const inst: Inst.Index = @fromBackingInt(@intCast(zir.extra[extra_index]));
        extra_index += 1;
        break :inst inst.toOptional();
    } else .none;
    const catch_or_if_src_node_offset: Ast.Node.OptionalOffset = if (has_non_err) node_offset: {
        const node_offset: Ast.Node.Offset = @fromBackingInt(@intCast(@as(i32, @bitCast(zir.extra[extra_index]))));
        extra_index += 1;
        break :node_offset node_offset.toOptional();
    } else .none;
    const non_err_info: Inst.SwitchBlock.ProngInfo.NonErr = if (has_non_err) non_err_info: {
        const non_err_info: Inst.SwitchBlock.ProngInfo.NonErr = @bitCast(zir.extra[extra_index]);
        extra_index += 1;
        break :non_err_info non_err_info;
    } else undefined;
    const else_info: Inst.SwitchBlock.ProngInfo.Else = if (bits.has_else) else_info: {
        const else_info: Inst.SwitchBlock.ProngInfo.Else = @bitCast(zir.extra[extra_index]);
        extra_index += 1;
        break :else_info else_info;
    } else undefined;
    const scalar_cases_len: u32 = bits.scalar_cases_len;
    const prong_infos: []const Inst.SwitchBlock.ProngInfo =
        @ptrCast(zir.extra[extra_index..][0 .. scalar_cases_len + multi_cases_len]);
    extra_index += prong_infos.len;
    const multi_case_items_lens = zir.extra[extra_index..][0..multi_cases_len];
    extra_index += multi_case_items_lens.len;
    const multi_case_ranges_lens: ?[]const u32 = if (bits.any_ranges) lens: {
        const multi_case_ranges_lens = zir.extra[extra_index..][0..multi_cases_len];
        extra_index += multi_case_ranges_lens.len;
        break :lens multi_case_ranges_lens;
    } else null;
    var total_items_len: usize = scalar_cases_len;
    for (multi_case_items_lens) |items_len| {
        total_items_len += items_len;
    }
    if (multi_case_ranges_lens) |ranges_lens| for (ranges_lens) |ranges_len| {
        total_items_len += 2 * ranges_len;
    };
    const item_infos: []const Inst.SwitchBlock.ItemInfo =
        @ptrCast(zir.extra[extra_index..][0..total_items_len]);
    extra_index += item_infos.len;
    const non_err_case: ?UnwrappedSwitchBlock.Case.NonErr = if (has_non_err) non_err_case: {
        const body = zir.bodySlice(extra_index, non_err_info.body_len);
        extra_index += body.len;
        break :non_err_case .{
            .body = body,
            .capture = non_err_info.capture,
            .operand_is_ref = non_err_info.operand_is_ref,
        };
    } else null;
    const else_case: ?UnwrappedSwitchBlock.Case.Else = if (bits.has_else) else_case: {
        const body = zir.bodySlice(extra_index, else_info.body_len);
        extra_index += body.len;
        break :else_case .{
            .index = .@"else",
            .body = body,
            .capture = else_info.capture,
            .is_inline = else_info.is_inline,
            .has_tag_capture = else_info.has_tag_capture,
            .is_simple_noreturn = else_info.is_simple_noreturn,
        };
    } else null;
    return .{
        .main_operand = extra.data.raw_operand,
        .switch_src_node_offset = inst_data.src_node,
        .catch_or_if_src_node_offset = catch_or_if_src_node_offset,
        .payload_capture_placeholder = payload_capture_placeholder,
        .tag_capture_placeholder = tag_capture_placeholder,
        .has_continue = bits.has_continue,
        .any_maybe_runtime_capture = bits.any_maybe_runtime_capture,
        .non_err_case = non_err_case,
        .else_case = else_case,
        .has_under = bits.has_under,
        .prong_infos = prong_infos,
        .multi_case_items_lens = multi_case_items_lens,
        .multi_case_ranges_lens = multi_case_ranges_lens,
        .item_infos = item_infos,
        .end = extra_index,
    };
}

/// Trailing (starting at `end`):
/// 0. case_bodies: { // for each case in Case.Iterator.next()
///        prong_body: {
///            body_inst: Inst.Index, // for every case.prong_info.body_len,
///        }
///        item_body: { // for each body_len in case.item_infos
///            body_inst: Inst.Index, // for every body_len
///        }
///        range_bodies: { // for each .{first_info, last_info} in case.range_infos
///            first_body_inst: Inst.Index, // for every first_info.body_len
///            last_body_inst: Inst.Index, // for every last_info.body_len
///        }
///    }
pub const UnwrappedSwitchBlock = struct {
    /// Either `catch`/`if` or `switch` operand.
    main_operand: Inst.Ref,
    switch_src_node_offset: Ast.Node.Offset,
    catch_or_if_src_node_offset: Ast.Node.OptionalOffset,
    payload_capture_placeholder: Inst.OptionalIndex,
    tag_capture_placeholder: Inst.OptionalIndex,
    has_continue: bool,
    any_maybe_runtime_capture: bool,
    non_err_case: ?Case.NonErr,
    else_case: ?Case.Else,
    has_under: bool,
    // Refer to doc comment and `iterateCases` to access everything below correctly.
    prong_infos: []const Inst.SwitchBlock.ProngInfo,
    multi_case_items_lens: []const u32,
    multi_case_ranges_lens: ?[]const u32,
    item_infos: []const Inst.SwitchBlock.ItemInfo,
    end: usize,

    pub fn anyRanges(unwrapped: *const UnwrappedSwitchBlock) bool {
        return unwrapped.multi_case_ranges_lens != null;
    }

    pub fn scalarCasesLen(unwrapped: *const UnwrappedSwitchBlock) u32 {
        return @intCast(unwrapped.prong_infos.len - unwrapped.multi_case_items_lens.len);
    }

    pub fn multiCasesLen(unwrapped: *const UnwrappedSwitchBlock) u32 {
        return @intCast(unwrapped.multi_case_items_lens.len);
    }

    pub fn totalItemsLen(unwrapped: *const UnwrappedSwitchBlock) u32 {
        var total_items_len: u32 = @intCast(unwrapped.item_infos.len);
        if (unwrapped.multi_case_ranges_lens) |ranges_lens| {
            for (ranges_lens) |len| total_items_len -= len;
        }
        return total_items_len;
    }

    pub const Case = struct {
        index: Case.Index,
        prong_info: Inst.SwitchBlock.ProngInfo,
        item_infos: []const Inst.SwitchBlock.ItemInfo,
        range_infos: []const [2]Inst.SwitchBlock.ItemInfo,

        pub const Index = packed struct(u32) {
            kind: enum(u1) { scalar, multi },
            value: u31,

            pub const @"else": Case.Index = .{
                .kind = .scalar,
                .value = std.math.maxInt(u31),
            };
        };

        pub const NonErr = struct {
            body: []const Inst.Index,
            capture: Inst.SwitchBlock.ProngInfo.Capture,
            operand_is_ref: bool,
        };

        pub const Else = struct {
            index: Case.Index,
            body: []const Inst.Index,
            capture: Inst.SwitchBlock.ProngInfo.Capture,
            is_inline: bool,
            has_tag_capture: bool,
            is_simple_noreturn: bool,
        };

        pub const Iterator = struct {
            next_idx: u32,
            prong_infos: []const Inst.SwitchBlock.ProngInfo,
            multi_case_items_lens: []const u32,
            multi_case_ranges_lens: ?[]const u32,
            item_infos: []const Inst.SwitchBlock.ItemInfo,

            pub fn next(it: *Iterator) ?Case {
                const idx = it.next_idx;
                if (idx == it.prong_infos.len) return null;
                it.next_idx += 1;
                const scalar_cases_len = it.prong_infos.len - it.multi_case_items_lens.len;
                return if (idx < scalar_cases_len) .{
                    .index = .{
                        .kind = .scalar,
                        .value = @intCast(idx),
                    },
                    .prong_info = it.prong_infos[idx],
                    .item_infos = it.itemInfos(1),
                    .range_infos = &.{},
                } else .{
                    .index = .{
                        .kind = .multi,
                        .value = @intCast(idx - scalar_cases_len),
                    },
                    .prong_info = it.prong_infos[idx],
                    .item_infos = it.itemInfos(it.multi_case_items_lens[idx - scalar_cases_len]),
                    .range_infos = if (it.multi_case_ranges_lens) |ranges_lens| b: {
                        break :b @ptrCast(it.itemInfos(2 * ranges_lens[idx - scalar_cases_len]));
                    } else &.{},
                };
            }
            fn itemInfos(it: *Iterator, count: u32) []const Inst.SwitchBlock.ItemInfo {
                const lens = it.item_infos[0..count];
                it.item_infos = it.item_infos[count..];
                return lens;
            }
        };
    };

    pub fn iterateCases(unwrapped: UnwrappedSwitchBlock) Case.Iterator {
        return .{
            .next_idx = 0,
            .prong_infos = unwrapped.prong_infos,
            .multi_case_items_lens = unwrapped.multi_case_items_lens,
            .multi_case_ranges_lens = unwrapped.multi_case_ranges_lens,
            .item_infos = unwrapped.item_infos,
        };
    }
};

/// When the ZIR update tracking logic must be modified to consider new instructions,
/// change this constant to trigger compile errors at all relevant locations.
pub const inst_tracking_version = 0;

/// Asserts that a ZIR instruction is tracked across incremental updates, and
/// thus may be given an `InternPool.TrackedInst`.
pub fn assertTrackable(zir: Zir, inst_idx: Zir.Inst.Index) void {
    comptime assert(Zir.inst_tracking_version == 0);
    const inst = zir.instructions.get(@backingInt(inst_idx));
    switch (inst.tag) {
        .struct_init,
        .struct_init_ref,
        .struct_init_anon,
        => {}, // tracked in order, as the owner instructions of anonymous struct types
        .func, .func_inferred => {
            // These are tracked if they are actual function declarations rather than prototypes.
            const extra = zir.extraData(Inst.Func, inst.data.pl_node.payload_index);
            assert(extra.data.body_len != 0);
        },
        .func_fancy => {
            // These are tracked if they are actual function declarations rather than prototypes.
            const extra = zir.extraData(Inst.FuncFancy, inst.data.pl_node.payload_index);
            assert(extra.data.body_len != 0);
        },
        .declaration => {}, // tracked by correlating names in the namespace of the parent container
        .extended => switch (inst.data.extended.opcode) {
            .struct_decl,
            .union_decl,
            .enum_decl,
            .opaque_decl,
            .reify_enum,
            .reify_struct,
            .reify_union,
            .reify_spirv_type,
            => {}, // tracked in order, as the owner instructions of explicit container types
            else => unreachable, // assertion failure; not trackable
        },
        else => unreachable, // assertion failure; not trackable
    }
}

pub fn typeDecls(zir: Zir, type_decl: Inst.Index) []const Zir.Inst.Index {
    const inst = zir.instructions.get(@backingInt(type_decl));
    assert(inst.tag == .extended);
    return switch (inst.data.extended.opcode) {
        .struct_decl => zir.getStructDecl(type_decl).decls,
        .union_decl => zir.getUnionDecl(type_decl).decls,
        .enum_decl => zir.getEnumDecl(type_decl).decls,
        .opaque_decl => zir.getOpaqueDecl(type_decl).decls,
        else => unreachable,
    };
}

pub fn getStructDecl(zir: *const Zir, struct_decl: Inst.Index) UnwrappedStructDecl {
    const inst_data = zir.instructions.get(@backingInt(struct_decl));
    assert(inst_data.tag == .extended);
    assert(inst_data.data.extended.opcode == .struct_decl);
    const small: Inst.StructDecl.Small = @bitCast(inst_data.data.extended.small);
    const extra = zir.extraData(Inst.StructDecl, inst_data.data.extended.operand);
    var extra_index = extra.end;
    const captures_len: u32 = if (small.has_captures_len) blk: {
        const captures_len = zir.extra[extra_index];
        extra_index += 1;
        break :blk captures_len;
    } else 0;
    const decls_len: u32 = if (small.has_decls_len) blk: {
        const decls_len = zir.extra[extra_index];
        extra_index += 1;
        break :blk decls_len;
    } else 0;
    const fields_len: u32 = if (small.has_fields_len) blk: {
        const fields_len = zir.extra[extra_index];
        extra_index += 1;
        break :blk fields_len;
    } else 0;
    const arg_baseline_src_node: Ast.Node.Index = if (small.has_backing_int_type) node: {
        defer extra_index += 1;
        break :node @fromBackingInt(zir.extra[extra_index]);
    } else extra.data.src_node;
    const fields_baseline_src_node: Ast.Node.Index = if (small.has_fields_len) node: {
        defer extra_index += 1;
        break :node @fromBackingInt(zir.extra[extra_index]);
    } else extra.data.src_node;
    const backing_int_type_body_len: u32 = if (small.has_backing_int_type) len: {
        const body_len = zir.extra[extra_index];
        extra_index += 1;
        break :len body_len;
    } else 0;
    const captures: []const Inst.Capture = @ptrCast(zir.extra[extra_index..][0..captures_len]);
    extra_index += captures_len;
    const capture_names: []const NullTerminatedString = @ptrCast(zir.extra[extra_index..][0..captures_len]);
    extra_index += captures_len;
    const decls: []const Inst.Index = @ptrCast(zir.extra[extra_index..][0..decls_len]);
    extra_index += decls_len;
    const field_names: []const NullTerminatedString = @ptrCast(zir.extra[extra_index..][0..fields_len]);
    extra_index += fields_len;
    const field_type_body_lens: []const u32 = @ptrCast(zir.extra[extra_index..][0..fields_len]);
    extra_index += fields_len;
    const field_align_body_lens: ?[]const u32 = if (small.any_field_aligns) lens: {
        const lens = zir.extra[extra_index..][0..fields_len];
        extra_index += fields_len;
        break :lens @ptrCast(lens);
    } else null;
    const field_default_body_lens: ?[]const u32 = if (small.any_field_defaults) lens: {
        const lens = zir.extra[extra_index..][0..fields_len];
        extra_index += fields_len;
        break :lens @ptrCast(lens);
    } else null;
    const field_comptime_bits: ?[]const u32 = if (small.any_comptime_fields) bits: {
        const bits_len = @divCeil(fields_len, 32);
        const bits = zir.extra[extra_index..][0..bits_len];
        extra_index += bits_len;
        break :bits bits;
    } else null;
    const backing_int_type_body: ?[]const Zir.Inst.Index = switch (backing_int_type_body_len) {
        0 => null,
        else => |n| zir.bodySlice(extra_index, n),
    };
    extra_index += backing_int_type_body_len;
    const field_bodies_overlong: []const Inst.Index = @ptrCast(zir.extra[extra_index..]);
    return .{
        .src_line = extra.data.src_line,
        .src_column = extra.data.src_column,
        .src_node = extra.data.src_node,
        .name_strategy = small.name_strategy,
        .arg_baseline_src_node = arg_baseline_src_node,
        .fields_baseline_src_node = fields_baseline_src_node,
        .captures = captures,
        .capture_names = capture_names,
        .decls = decls,
        .layout = small.layout,
        .backing_int_type_body = backing_int_type_body,
        .field_names = field_names,
        .field_type_body_lens = field_type_body_lens,
        .field_align_body_lens = field_align_body_lens,
        .field_default_body_lens = field_default_body_lens,
        .field_comptime_bits = field_comptime_bits,
        .field_bodies_overlong = field_bodies_overlong,
    };
}
pub const UnwrappedStructDecl = struct {
    src_line: u32,
    src_column: u32,
    src_node: Ast.Node.Index,
    name_strategy: Inst.NameStrategy,

    arg_baseline_src_node: Ast.Node.Index,
    fields_baseline_src_node: Ast.Node.Index,

    captures: []const Inst.Capture,
    capture_names: []const NullTerminatedString,

    decls: []const Inst.Index,

    layout: std.lang.Type.ContainerLayout,
    backing_int_type_body: ?[]const Inst.Index,

    field_names: []const NullTerminatedString,
    field_type_body_lens: []const u32,
    field_align_body_lens: ?[]const u32,
    field_default_body_lens: ?[]const u32,
    field_comptime_bits: ?[]const u32,
    field_bodies_overlong: []const Inst.Index,

    pub fn iterateFields(struct_decl: UnwrappedStructDecl) FieldIterator {
        return .{
            .next_idx = 0,
            .names = struct_decl.field_names,
            .type_body_lens = struct_decl.field_type_body_lens,
            .align_body_lens = struct_decl.field_align_body_lens,
            .default_body_lens = struct_decl.field_default_body_lens,
            .comptime_bits = struct_decl.field_comptime_bits,
            .bodies_overlong = struct_decl.field_bodies_overlong,
        };
    }

    pub const FieldIterator = struct {
        next_idx: u32,
        names: []const NullTerminatedString,
        type_body_lens: []const u32,
        align_body_lens: ?[]const u32,
        default_body_lens: ?[]const u32,
        comptime_bits: ?[]const u32,
        bodies_overlong: []const Inst.Index,
        pub const Field = struct {
            idx: u32,
            name: NullTerminatedString,
            type_body: []const Inst.Index,
            align_body: ?[]const Inst.Index,
            default_body: ?[]const Inst.Index,
            is_comptime: bool,
        };
        pub fn next(it: *FieldIterator) ?Field {
            const idx = it.next_idx;
            if (idx == it.names.len) return null;
            it.next_idx += 1;
            return .{
                .idx = idx,
                .name = it.names[idx],
                .type_body = it.body(it.type_body_lens[idx]).?,
                .align_body = it.body(if (it.align_body_lens) |l| l[idx] else 0),
                .default_body = it.body(if (it.default_body_lens) |l| l[idx] else 0),
                .is_comptime = ct: {
                    const bits = it.comptime_bits orelse break :ct false;
                    const big = bits[idx / 32];
                    const shifted = big >> @intCast(idx % 32);
                    break :ct @as(u1, @truncate(shifted)) == 1;
                },
            };
        }
        fn body(it: *FieldIterator, len: u32) ?[]const Inst.Index {
            if (len == 0) return null;
            const b = it.bodies_overlong[0..len];
            it.bodies_overlong = it.bodies_overlong[len..];
            return b;
        }
    };
};

pub fn getUnionDecl(zir: *const Zir, union_decl: Inst.Index) UnwrappedUnionDecl {
    const inst_data = zir.instructions.get(@backingInt(union_decl));
    assert(inst_data.tag == .extended);
    assert(inst_data.data.extended.opcode == .union_decl);
    const small: Inst.UnionDecl.Small = @bitCast(inst_data.data.extended.small);
    const extra = zir.extraData(Inst.UnionDecl, inst_data.data.extended.operand);
    var extra_index = extra.end;
    const captures_len: u32 = if (small.has_captures_len) blk: {
        const captures_len = zir.extra[extra_index];
        extra_index += 1;
        break :blk captures_len;
    } else 0;
    const decls_len: u32 = if (small.has_decls_len) blk: {
        const decls_len = zir.extra[extra_index];
        extra_index += 1;
        break :blk decls_len;
    } else 0;
    const fields_len: u32 = if (small.has_fields_len) blk: {
        const fields_len = zir.extra[extra_index];
        extra_index += 1;
        break :blk fields_len;
    } else 0;
    const arg_baseline_src_node: Ast.Node.Index = if (small.kind.hasArgType()) node: {
        defer extra_index += 1;
        break :node @fromBackingInt(zir.extra[extra_index]);
    } else extra.data.src_node;
    const fields_baseline_src_node: Ast.Node.Index = if (small.has_fields_len) node: {
        defer extra_index += 1;
        break :node @fromBackingInt(zir.extra[extra_index]);
    } else extra.data.src_node;
    const arg_type_body_len: u32 = if (small.kind.hasArgType()) len: {
        const body_len = zir.extra[extra_index];
        extra_index += 1;
        break :len body_len;
    } else 0;
    const captures: []const Inst.Capture = @ptrCast(zir.extra[extra_index..][0..captures_len]);
    extra_index += captures_len;
    const capture_names: []const NullTerminatedString = @ptrCast(zir.extra[extra_index..][0..captures_len]);
    extra_index += captures_len;
    const decls: []const Inst.Index = @ptrCast(zir.extra[extra_index..][0..decls_len]);
    extra_index += decls_len;
    const field_names: []const NullTerminatedString = @ptrCast(zir.extra[extra_index..][0..fields_len]);
    extra_index += fields_len;
    const field_type_body_lens: []const u32 = @ptrCast(zir.extra[extra_index..][0..fields_len]);
    extra_index += fields_len;
    const field_align_body_lens: ?[]const u32 = if (small.any_field_aligns) lens: {
        const lens = zir.extra[extra_index..][0..fields_len];
        extra_index += fields_len;
        break :lens @ptrCast(lens);
    } else null;
    const field_value_body_lens: ?[]const u32 = if (small.any_field_values) lens: {
        const lens = zir.extra[extra_index..][0..fields_len];
        extra_index += fields_len;
        break :lens @ptrCast(lens);
    } else null;
    const arg_type_body: ?[]const Zir.Inst.Index = switch (arg_type_body_len) {
        0 => null,
        else => |n| zir.bodySlice(extra_index, n),
    };
    extra_index += arg_type_body_len;
    const field_bodies_overlong: []const Inst.Index = @ptrCast(zir.extra[extra_index..]);
    return .{
        .src_line = extra.data.src_line,
        .src_column = extra.data.src_column,
        .src_node = extra.data.src_node,
        .name_strategy = small.name_strategy,
        .arg_baseline_src_node = arg_baseline_src_node,
        .fields_baseline_src_node = fields_baseline_src_node,
        .captures = captures,
        .capture_names = capture_names,
        .decls = decls,
        .kind = small.kind,
        .arg_type_body = arg_type_body,
        .field_names = field_names,
        .field_type_body_lens = field_type_body_lens,
        .field_align_body_lens = field_align_body_lens,
        .field_value_body_lens = field_value_body_lens,
        .field_bodies_overlong = field_bodies_overlong,
    };
}
pub const UnwrappedUnionDecl = struct {
    src_line: u32,
    src_column: u32,
    src_node: Ast.Node.Index,
    name_strategy: Inst.NameStrategy,

    arg_baseline_src_node: Ast.Node.Index,
    fields_baseline_src_node: Ast.Node.Index,

    captures: []const Inst.Capture,
    capture_names: []const NullTerminatedString,

    decls: []const Inst.Index,

    kind: Inst.UnionDecl.Kind,
    arg_type_body: ?[]const Inst.Index,

    field_names: []const NullTerminatedString,
    field_type_body_lens: []const u32,
    field_align_body_lens: ?[]const u32,
    field_value_body_lens: ?[]const u32,
    field_bodies_overlong: []const Inst.Index,

    pub fn iterateFields(union_decl: UnwrappedUnionDecl) FieldIterator {
        return .{
            .next_idx = 0,
            .names = union_decl.field_names,
            .type_body_lens = union_decl.field_type_body_lens,
            .align_body_lens = union_decl.field_align_body_lens,
            .value_body_lens = union_decl.field_value_body_lens,
            .bodies_overlong = union_decl.field_bodies_overlong,
        };
    }

    pub const FieldIterator = struct {
        next_idx: u32,
        names: []const NullTerminatedString,
        type_body_lens: []const u32,
        align_body_lens: ?[]const u32,
        value_body_lens: ?[]const u32,
        bodies_overlong: []const Inst.Index,
        pub const Field = struct {
            idx: u32,
            name: NullTerminatedString,
            type_body: ?[]const Inst.Index,
            align_body: ?[]const Inst.Index,
            value_body: ?[]const Inst.Index,
        };
        pub fn next(it: *FieldIterator) ?Field {
            const idx = it.next_idx;
            if (idx == it.names.len) return null;
            it.next_idx += 1;
            return .{
                .idx = idx,
                .name = it.names[idx],
                .type_body = it.body(it.type_body_lens[idx]),
                .align_body = it.body(if (it.align_body_lens) |l| l[idx] else 0),
                .value_body = it.body(if (it.value_body_lens) |l| l[idx] else 0),
            };
        }
        fn body(it: *FieldIterator, len: u32) ?[]const Inst.Index {
            if (len == 0) return null;
            const b = it.bodies_overlong[0..len];
            it.bodies_overlong = it.bodies_overlong[len..];
            return b;
        }
    };
};

pub fn getEnumDecl(zir: *const Zir, enum_decl: Inst.Index) UnwrappedEnumDecl {
    const inst_data = zir.instructions.get(@backingInt(enum_decl));
    assert(inst_data.tag == .extended);
    assert(inst_data.data.extended.opcode == .enum_decl);
    const small: Inst.EnumDecl.Small = @bitCast(inst_data.data.extended.small);
    const extra = zir.extraData(Inst.EnumDecl, inst_data.data.extended.operand);
    var extra_index = extra.end;
    const captures_len: u32 = if (small.has_captures_len) blk: {
        const captures_len = zir.extra[extra_index];
        extra_index += 1;
        break :blk captures_len;
    } else 0;
    const decls_len: u32 = if (small.has_decls_len) blk: {
        const decls_len = zir.extra[extra_index];
        extra_index += 1;
        break :blk decls_len;
    } else 0;
    const fields_len: u32 = if (small.has_fields_len) blk: {
        const fields_len = zir.extra[extra_index];
        extra_index += 1;
        break :blk fields_len;
    } else 0;
    const arg_baseline_src_node: Ast.Node.Index = if (small.has_tag_type) node: {
        defer extra_index += 1;
        break :node @fromBackingInt(zir.extra[extra_index]);
    } else extra.data.src_node;
    const fields_baseline_src_node: Ast.Node.Index = if (small.has_fields_len) node: {
        defer extra_index += 1;
        break :node @fromBackingInt(zir.extra[extra_index]);
    } else extra.data.src_node;
    const tag_type_body_len: u32 = if (small.has_tag_type) len: {
        const body_len = zir.extra[extra_index];
        extra_index += 1;
        break :len body_len;
    } else 0;
    const captures: []const Inst.Capture = @ptrCast(zir.extra[extra_index..][0..captures_len]);
    extra_index += captures_len;
    const capture_names: []const NullTerminatedString = @ptrCast(zir.extra[extra_index..][0..captures_len]);
    extra_index += captures_len;
    const decls: []const Inst.Index = @ptrCast(zir.extra[extra_index..][0..decls_len]);
    extra_index += decls_len;
    const field_names: []const NullTerminatedString = @ptrCast(zir.extra[extra_index..][0..fields_len]);
    extra_index += fields_len;
    const field_value_body_lens: ?[]const u32 = if (small.any_field_values) lens: {
        const lens = zir.extra[extra_index..][0..fields_len];
        extra_index += fields_len;
        break :lens @ptrCast(lens);
    } else null;
    const tag_type_body: ?[]const Zir.Inst.Index = switch (tag_type_body_len) {
        0 => null,
        else => |n| zir.bodySlice(extra_index, n),
    };
    extra_index += tag_type_body_len;
    const field_bodies_overlong: []const Inst.Index = @ptrCast(zir.extra[extra_index..]);
    return .{
        .src_line = extra.data.src_line,
        .src_column = extra.data.src_column,
        .src_node = extra.data.src_node,
        .name_strategy = small.name_strategy,
        .arg_baseline_src_node = arg_baseline_src_node,
        .fields_baseline_src_node = fields_baseline_src_node,
        .captures = captures,
        .capture_names = capture_names,
        .decls = decls,
        .tag_type_body = tag_type_body,
        .nonexhaustive = small.nonexhaustive,
        .field_names = field_names,
        .field_value_body_lens = field_value_body_lens,
        .field_bodies_overlong = field_bodies_overlong,
    };
}
pub const UnwrappedEnumDecl = struct {
    src_line: u32,
    src_column: u32,
    src_node: Ast.Node.Index,
    name_strategy: Inst.NameStrategy,

    arg_baseline_src_node: Ast.Node.Index,
    fields_baseline_src_node: Ast.Node.Index,

    captures: []const Inst.Capture,
    capture_names: []const NullTerminatedString,

    decls: []const Inst.Index,

    tag_type_body: ?[]const Inst.Index,
    nonexhaustive: bool,

    field_names: []const NullTerminatedString,
    field_value_body_lens: ?[]const u32,
    field_bodies_overlong: []const Inst.Index,

    pub fn iterateFields(enum_decl: UnwrappedEnumDecl) FieldIterator {
        return .{
            .next_idx = 0,
            .names = enum_decl.field_names,
            .value_body_lens = enum_decl.field_value_body_lens,
            .bodies_overlong = enum_decl.field_bodies_overlong,
        };
    }

    pub const FieldIterator = struct {
        next_idx: u32,
        names: []const NullTerminatedString,
        value_body_lens: ?[]const u32,
        bodies_overlong: []const Inst.Index,
        pub const Field = struct {
            idx: u32,
            name: NullTerminatedString,
            value_body: ?[]const Inst.Index,
        };
        pub fn next(it: *FieldIterator) ?Field {
            const idx = it.next_idx;
            if (idx == it.names.len) return null;
            it.next_idx += 1;
            return .{
                .idx = idx,
                .name = it.names[idx],
                .value_body = it.body(if (it.value_body_lens) |l| l[idx] else 0),
            };
        }
        fn body(it: *FieldIterator, len: u32) ?[]const Inst.Index {
            if (len == 0) return null;
            const b = it.bodies_overlong[0..len];
            it.bodies_overlong = it.bodies_overlong[len..];
            return b;
        }
    };
};

pub fn getOpaqueDecl(zir: *const Zir, opaque_decl: Inst.Index) UnwrappedOpaqueDecl {
    const inst_data = zir.instructions.get(@backingInt(opaque_decl));
    assert(inst_data.tag == .extended);
    assert(inst_data.data.extended.opcode == .opaque_decl);
    const small: Inst.OpaqueDecl.Small = @bitCast(inst_data.data.extended.small);
    const extra = zir.extraData(Inst.OpaqueDecl, inst_data.data.extended.operand);
    var extra_index = extra.end;
    const captures_len: u32 = if (small.has_captures_len) blk: {
        const captures_len = zir.extra[extra_index];
        extra_index += 1;
        break :blk captures_len;
    } else 0;
    const decls_len: u32 = if (small.has_decls_len) blk: {
        const decls_len = zir.extra[extra_index];
        extra_index += 1;
        break :blk decls_len;
    } else 0;
    const captures: []const Inst.Capture = @ptrCast(zir.extra[extra_index..][0..captures_len]);
    extra_index += captures_len;
    const capture_names: []const NullTerminatedString = @ptrCast(zir.extra[extra_index..][0..captures_len]);
    extra_index += captures_len;
    const decls: []const Inst.Index = @ptrCast(zir.extra[extra_index..][0..decls_len]);
    extra_index += decls_len;
    return .{
        .src_line = extra.data.src_line,
        .src_column = extra.data.src_column,
        .src_node = extra.data.src_node,
        .name_strategy = small.name_strategy,
        .captures = captures,
        .capture_names = capture_names,
        .decls = decls,
    };
}
pub const UnwrappedOpaqueDecl = struct {
    src_line: u32,
    src_column: u32,
    src_node: Ast.Node.Index,
    name_strategy: Inst.NameStrategy,
    captures: []const Inst.Capture,
    capture_names: []const NullTerminatedString,
    decls: []const Inst.Index,
};