ir

type AssignFragment struct {
	Dst Fragment
	Src Fragment
}

type Backend interface {
	BuildStandaloneProgram(p *Program) (asm.Program, error)
}

type Block []Fragment

type CacheFlushFragment struct {
	// Base is the starting address of the region to flush
	Base Fragment
	// Size is the size of the region in bytes
	Size Fragment
}

type CallFragment struct {
	Target Fragment
	Args   []Fragment // Arguments to pass to the function
	Result Var
}

type CompareCondition struct {
	Kind  CompareKind
	Left  Fragment
	Right Fragment
}

type CompareKind int

type Condition interface {
	Fragment
}

type ConstantBytesConfig struct {
	// Target selects the asm variable that will reference the constant. Required.
	Target asm.Variable
	// Data provides the literal contents to bind.
	Data []byte
	// ZeroTerminate appends a trailing zero byte when true (unless already
	// present) so the constant can be treated as a C string.
	ZeroTerminate bool
	// Length receives the length of Data before any zero terminator is appended
	// when set. Useful for methods that need the literal size separately.
	Length Var
	// TotalLength receives the full length after optional zero termination when
	// set. Callers can differentiate between the raw length and the encoded size.
	TotalLength Var
	// Pointer optionally receives the address of the constant block. This allows
	// callers to reuse the data without re-encoding string literals.
	Pointer Var
}

type ConstantBytesFragment struct {
	Target asm.Variable
	Data   []byte
}

type ConstantPointerFragment struct {
	Target asm.Variable
}

type DeclareParam string

type Fragment interface{}

type GlobalConfig struct {
	// Size controls how many bytes are reserved for the variable. Defaults to 8.
	Size int
	// Align controls the byte alignment for the variable. Defaults to 8 and must
	// be a power of two.
	Align int
}

type GlobalMem struct {
	Name  string
	Disp  Fragment
	Width ValueWidth
}

type GlobalPointerFragment struct {
	Name string
}

type GlobalVar string

type GotoFragment struct {
	Label Fragment
}

type I8Var struct {
	Name Var
}

type I32Var struct {
	Name Var
}

type ISBFragment struct{}

type IfFragment struct {
	Cond      Condition
	Then      Fragment
	Otherwise Fragment
}

type Int8 int8

type Int16 int16

type Int32 int32

type Int64 int64

type IsNegativeCondition struct {
	Value Fragment
}

type IsZeroCondition struct {
	Value Fragment
}

type Label string

type LabelFragment struct {
	Label Label
	Block Block
}

type MemVar struct {
	Base  Var
	Disp  Fragment
	Width ValueWidth
}

type MemoryFragment interface {
	Fragment
	WithDisp(disp any) Fragment
}

type Method []Fragment

type MethodPointerFragment struct {
	Name string
}

type NativeBackend interface {
	Backend
	// PrepareNativeExecution prepares a compiled program for native execution.
	// Returns a callable function, a cleanup function, and an error.
	// The cleanup function must be called when the function is no longer needed.
	PrepareNativeExecution(prog asm.Program) (asm.NativeFunc, func(), error)
}

type OpFragment struct {
	Kind  OpKind
	Left  Fragment
	Right Fragment
}

type OpKind int

type PrintfFragment struct {
	Format string
	Args   []Fragment
}

type Program struct {
	Entrypoint string
	Methods    map[string]Method
	Globals    map[string]GlobalConfig
}

type ReturnFragment struct {
	Value Fragment
}

type StackSlot struct {
	// contains filtered or unexported fields
}

type StackSlotConfig struct {
	// Size is the number of bytes required by the caller. Must be > 0.
	Size int64
	// Body builds the fragment that will run while the stack slot is active.
	Body func(StackSlot) Fragment
}

type StackSlotContext struct {
	Id   uint64
	Base int32
	Size int64
}

type StackSlotFragment struct {
	Id     uint64
	Size   int64
	Body   Fragment
	Chunks []string
}

type StackSlotMemFragment struct {
	SlotID uint64
	Disp   Fragment
	Width  ValueWidth // Width of memory access (0 means 64-bit/default)
}

type StackSlotPtrFragment struct {
	SlotID uint64
	Disp   Fragment
}

type StageResultStoreConfig struct {
	// Base points at the destination region (for example Var("page").AsMem()).
	Base MemoryFragment
	// Offset is the byte displacement for the detail (low 32-bit) field.
	Offset int64
	// Value is the encoded result (detail | stage<<shift) to store.
	Value Var
	// Scratch optionally provides a variable to receive the shifted stage. When
	// omitted the helper allocates an internal temporary.
	Scratch Var
	// Shift controls how many bits to shift Value right to obtain the stage. If
	// zero the helper uses defaultStageResultShift.
	Shift int64
}

type SyscallCheckedConfig struct {
	// Result stores the syscall return value for later use. It must be a Var so
	// the helper can emit the common negative-result check.
	Result Var
	// Number is the syscall number (for example linux.SYS_OPENAT).
	Number defs.Syscall
	// Args provides the syscall arguments. Each element must be compatible with
	// Syscall (Var, string, or int-convertible value).
	Args []any
	// OnError runs when the syscall result is negative. Use a Block to sequence
	// multiple fragments or Goto to jump to an error label.
	OnError Fragment
}

type SyscallFragment struct {
	Num  defs.Syscall
	Args []Fragment
}

type ValueWidth uint8

type Var string