module

type BasicBlock struct {
	// Name is an optional label for the basic block.
	Name string

	// Instructions contains the block's instruction sequence.
	Instructions []*Instruction
}

type Constant struct {
	// ConstType is the type of this constant.
	ConstType *Type

	// IntValue is used for integer constants.
	IntValue int64

	// FloatValue is used for floating-point constants.
	FloatValue float64

	// IsUndef is true for undef values.
	IsUndef bool

	// IsAggregate is true for aggregate constants (arrays, structs).
	// Elements contains the sub-constant value IDs.
	IsAggregate bool
	Elements    []*Constant

	// IsDataArray is true for ConstantDataArray constants — serialized as
	// CST_CODE_DATA (code 22) instead of CST_CODE_AGGREGATE (code 7).
	//
	// Required for metadata payloads whose consumer-side loader does a
	// hard `dyn_cast<ConstantDataArray>`. Example: dx.viewIdState —
	// `DxilMDHelper::LoadDxilViewIdState` (DxilMetadataHelper.cpp:2211)
	// runs at D3D12 runtime format validation during
	// CreateGraphicsPipelineState and rejects the `ConstantArray` form
	// that CST_CODE_AGGREGATE produces.
	//
	// Element values are stored inline as raw uint64; decoding rules
	// depend on the array element type (i32 → unsigned integer value,
	// f32 → Float32bits, etc.). The element type is carried by
	// ConstType.ArrayElem.
	IsDataArray bool
	DataValues  []uint64

	// ValueID is assigned during serialization.
	ValueID int
}

type Function struct {
	// Name is the function name (e.g., "main", "dx.op.loadInput.f32").
	Name string

	// FuncType is the function's type (TypeFunction).
	FuncType *Type

	// IsDeclaration is true for external declarations (no body).
	IsDeclaration bool

	// BasicBlocks contains the function body (nil for declarations).
	BasicBlocks []*BasicBlock

	// ValueID is assigned during serialization.
	ValueID int

	// AttrSetID is the 1-based index into the PARAMATTR_BLOCK (0 = none).
	// DXC marks every intrinsic declaration with at least "nounwind", which
	// the D3D12 runtime validator checks. Declarations default to
	// AttrSetNounwind; bodies default to 0.
	AttrSetID uint32
}

type GlobalVar struct {
	Name        string
	VarType     *Type
	AddrSpace   uint8
	IsConstant  bool
	Initializer *Constant
	ValueID     int
	// Alignment is the byte alignment for the global variable.
	// 0 means use the default (4). Set to 8 for i64/f64 types.
	Alignment uint32
	// Linkage overrides the auto-derived linkage for this global.
	// -1 (default) = auto: external (0) when no initializer, internal (3)
	// when initializer is present. Set to 0 to force external linkage
	// with an initializer (DXC uses this for decomposed groupshared
	// struct members: `global T undef` with external linkage).
	Linkage int8
}

type InstrKind int

type Instruction struct {
	Kind InstrKind

	// HasValue is true if this instruction produces a value.
	HasValue bool

	// ResultType is the type of the produced value (nil if HasValue is false).
	ResultType *Type

	// Operands are the instruction's input values (interpretation
	// depends on Kind).
	Operands []int // indices into value numbering

	// For InstrRet: ReturnValue is the value to return (-1 for void).
	ReturnValue int

	// For InstrCall: the called function.
	CalledFunc *Function

	// For InstrPhi: incoming (value, predecessor-bb) pairs.
	PhiIncomings []PhiIncoming

	// Flags holds optional instruction-level flags. For InstrBinOp with
	// floating-point operands, this carries fast-math flags (FMF) matching
	// the LLVM 3.7 bitcode encoding: bit 0 = UnsafeAlgebra ("fast"),
	// bit 1 = NoNaNs, bit 2 = NoInfs, bit 3 = NoSignedZeros,
	// bit 4 = AllowReciprocal. DXC always sets UnsafeAlgebra (bit 0) for
	// non-precise float ops, producing the "fast" keyword in IR text.
	Flags uint32

	// ValueID is assigned during serialization.
	ValueID int
}

type MetadataNode struct {
	Kind MetadataNodeKind

	// ID is assigned during serialization.
	ID int

	// For MDString: the string value.
	StringValue string

	// For MDValue: the type and constant value.
	ValueType  *Type
	ValueConst *Constant

	// For MDValue referencing a function: the referenced function.
	// When set, ValueConst is ignored and the metadata value record
	// emits [pointer-to-function-type-id, function.ValueID]. This is
	// how DXIL encodes !dx.entryPoints[0][0] = void()* @main.
	ValueFunc *Function

	// For MDTuple: sub-nodes. A nil entry represents a null operand.
	SubNodes []*MetadataNode
}

type MetadataNodeKind int

type Module struct {
	// ShaderKind is the type of shader (vertex, pixel, compute, etc.).
	ShaderKind ShaderKind

	// MajorVersion and MinorVersion are the DXIL version numbers.
	MajorVersion uint32
	MinorVersion uint32

	// TargetTriple is always "dxil-ms-dx" for DXIL.
	TargetTriple string

	// DataLayout is the LLVM data layout string.
	DataLayout string

	// Types contains all types used in the module.
	Types []*Type

	// Functions contains all function declarations and definitions.
	Functions []*Function

	// Constants contains all constant values.
	Constants []*Constant

	// GlobalVars contains global variable declarations.
	GlobalVars []*GlobalVar

	// NamedMetadata maps metadata names (e.g. "dx.version") to
	// metadata node lists.
	NamedMetadata []*NamedMetadataNode

	// Metadata contains all metadata nodes referenced by the module.
	Metadata []*MetadataNode
	// contains filtered or unexported fields
}

type NamedMetadataNode struct {
	// Name is the metadata name (e.g., "dx.version", "dx.shaderModel").
	Name string

	// Operands are the metadata nodes referenced by this named entry.
	Operands []*MetadataNode
}

type PhiIncoming struct {
	ValueID int
	BBIndex int
}

type ShaderKind uint32

type Type struct {
	Kind TypeKind

	// ID is the index of this type in the module's type table.
	// Assigned during serialization.
	ID int

	// For TypeInteger: bit width (1, 8, 16, 32, 64).
	IntBits uint

	// For TypeFloat: bit width (16, 32, 64).
	FloatBits uint

	// For TypePointer: the element type pointed to.
	PointerElem *Type
	// For TypePointer: address space (0 = default, 3 = thread group shared).
	// Workgroup global variables in DXIL live in addrspace 3 and any pointer
	// derived from them carries the same addrspace, which the validator
	// memcmp's against atomicrmw operand types.
	PointerAddrSpace uint8

	// For TypeStruct: name (empty for anonymous) and element types.
	StructName  string
	StructElems []*Type

	// For TypeArray and TypeVector: element type and count.
	ElemType  *Type
	ElemCount uint

	// For TypeFunction: return type and parameter types.
	RetType    *Type
	ParamTypes []*Type
}

type TypeKind int