Data.LLVM.IR.Ops

Definitions

record CaseBranch : Type

  Case branch for switch instructions.
  Models individual cases in LLVM IR switch statements like:
  ```llvm
  switch i32 %val, label %default [
  |   i32 1, label %case1
  |   i32 2, label %case2
  ]
  ```

Totality: total
Visibility: public export
Constructor: 

MkCaseBranch : LType -> LExpr -> Label -> CaseBranch

Projections:

.label : CaseBranch -> Label

  Target label for this case

.tpe : CaseBranch -> LType

  Type of the case value

.value : CaseBranch -> LExpr

  Case value to match

Hints:

Encode FCM CaseBranch CPtr

Encode ATM CaseBranch VString

.tpe : CaseBranch -> LType

  Type of the case value

Visibility: public export

tpe : CaseBranch -> LType

  Type of the case value

Visibility: public export

.value : CaseBranch -> LExpr

  Case value to match

Visibility: public export

value : CaseBranch -> LExpr

  Case value to match

Visibility: public export

.label : CaseBranch -> Label

  Target label for this case

Visibility: public export

label : CaseBranch -> Label

  Target label for this case

Visibility: public export

record InvokeCall : Type

  Invoke instruction call specification.
  Models LLVM IR invoke instructions like:
  ```llvm
  %result = invoke fastcc i32 @function(i32 %arg) 
  |           to label %normal unwind label %exception
  ```

Totality: total
Visibility: public export
Constructor: 

MkInvokeCall : Maybe CallingConvention -> List Attribute -> Maybe AddressSpace -> LType -> LExpr -> List LExpr -> Label -> Label -> InvokeCall

Projections:

.addressSpace : InvokeCall -> Maybe AddressSpace

  Address space for the function pointer

.args : InvokeCall -> List LExpr

  Function arguments

.cc : InvokeCall -> Maybe CallingConvention

  Calling convention (fastcc, coldcc, etc.)

.fnval : InvokeCall -> LExpr

  Function value or pointer

.normal : InvokeCall -> Label

  Normal execution continuation label

.returnAttrs : InvokeCall -> List Attribute

  Return value attributes

.tpe : InvokeCall -> LType

  Function type

.unwind : InvokeCall -> Label

  Exception unwind label

Hints:

Encode FCM InvokeCall CPtr

Encode ATM InvokeCall VString

.cc : InvokeCall -> Maybe CallingConvention

  Calling convention (fastcc, coldcc, etc.)

Visibility: public export

cc : InvokeCall -> Maybe CallingConvention

  Calling convention (fastcc, coldcc, etc.)

Visibility: public export

.returnAttrs : InvokeCall -> List Attribute

  Return value attributes

Visibility: public export

returnAttrs : InvokeCall -> List Attribute

  Return value attributes

Visibility: public export

.addressSpace : InvokeCall -> Maybe AddressSpace

  Address space for the function pointer

Visibility: public export

addressSpace : InvokeCall -> Maybe AddressSpace

  Address space for the function pointer

Visibility: public export

.tpe : InvokeCall -> LType

  Function type

Visibility: public export

tpe : InvokeCall -> LType

  Function type

Visibility: public export

.fnval : InvokeCall -> LExpr

  Function value or pointer

Visibility: public export

fnval : InvokeCall -> LExpr

  Function value or pointer

Visibility: public export

.args : InvokeCall -> List LExpr

  Function arguments

Visibility: public export

args : InvokeCall -> List LExpr

  Function arguments

Visibility: public export

.normal : InvokeCall -> Label

  Normal execution continuation label

Visibility: public export

normal : InvokeCall -> Label

  Normal execution continuation label

Visibility: public export

.unwind : InvokeCall -> Label

  Exception unwind label

Visibility: public export

unwind : InvokeCall -> Label

  Exception unwind label

Visibility: public export

record BrCall : Type

  Call branch instruction specification.
  Models LLVM IR callbr instructions like:
  ```llvm
  callbr void asm "", "r,!i"(i32 %x) 
  |        to label %fallthrough [label %indirect1, label %indirect2]
  ```

Totality: total
Visibility: public export
Constructor: 

MkBrCall : Maybe CallingConvention -> List Attribute -> Maybe AddressSpace -> LType -> LExpr -> List LExpr -> Label -> List Label -> BrCall

Projections:

.addressSpace : BrCall -> Maybe AddressSpace

  Address space for the function pointer

.args : BrCall -> List LExpr

  Function arguments

.cc : BrCall -> Maybe CallingConvention

  Calling convention

.fallthrough : BrCall -> Label

  Fallthrough label for normal execution

.fnval : BrCall -> LExpr

  Function value or pointer

.indirect : BrCall -> List Label

  Possible indirect branch targets

.returnAttrs : BrCall -> List Attribute

  Return value attributes

.tpe : BrCall -> LType

  Function type

Hints:

Encode FCM BrCall CPtr

Encode ATM BrCall VString

.cc : BrCall -> Maybe CallingConvention

  Calling convention

Visibility: public export

cc : BrCall -> Maybe CallingConvention

  Calling convention

Visibility: public export

.returnAttrs : BrCall -> List Attribute

  Return value attributes

Visibility: public export

returnAttrs : BrCall -> List Attribute

  Return value attributes

Visibility: public export

.addressSpace : BrCall -> Maybe AddressSpace

  Address space for the function pointer

Visibility: public export

addressSpace : BrCall -> Maybe AddressSpace

  Address space for the function pointer

Visibility: public export

.tpe : BrCall -> LType

  Function type

Visibility: public export

tpe : BrCall -> LType

  Function type

Visibility: public export

.fnval : BrCall -> LExpr

  Function value or pointer

Visibility: public export

fnval : BrCall -> LExpr

  Function value or pointer

Visibility: public export

.args : BrCall -> List LExpr

  Function arguments

Visibility: public export

args : BrCall -> List LExpr

  Function arguments

Visibility: public export

.fallthrough : BrCall -> Label

  Fallthrough label for normal execution

Visibility: public export

fallthrough : BrCall -> Label

  Fallthrough label for normal execution

Visibility: public export

.indirect : BrCall -> List Label

  Possible indirect branch targets

Visibility: public export

indirect : BrCall -> List Label

  Possible indirect branch targets

Visibility: public export

record CatchSwitch : Type

  Catch switch instruction specification.
  Models LLVM IR catchswitch instructions like:
  ```llvm
  %cs = catchswitch within none [label %handler1, label %handler2] 
  |       unwind to caller
  ```

Totality: total
Visibility: public export
Constructor: 

MkCatchSwitch : Name -> Maybe Label -> List Label -> Maybe Label -> CatchSwitch

Projections:

.handlers : CatchSwitch -> List Label

  List of exception handler labels

.name : CatchSwitch -> Name

  Name of the catchswitch result

.parent : CatchSwitch -> Maybe Label

  Parent scope (within clause)

.unwind : CatchSwitch -> Maybe Label

  Unwind destination (to caller or label)

Hints:

Encode FCM CatchSwitch CPtr

Encode ATM CatchSwitch VString

.name : CatchSwitch -> Name

  Name of the catchswitch result

Visibility: public export

name : CatchSwitch -> Name

  Name of the catchswitch result

Visibility: public export

.parent : CatchSwitch -> Maybe Label

  Parent scope (within clause)

Visibility: public export

parent : CatchSwitch -> Maybe Label

  Parent scope (within clause)

Visibility: public export

.handlers : CatchSwitch -> List Label

  List of exception handler labels

Visibility: public export

handlers : CatchSwitch -> List Label

  List of exception handler labels

Visibility: public export

.unwind : CatchSwitch -> Maybe Label

  Unwind destination (to caller or label)

Visibility: public export

unwind : CatchSwitch -> Maybe Label

  Unwind destination (to caller or label)

Visibility: public export

data TailCall : Type

  Tail call modifiers for function calls.
  Models LLVM IR tail call prefixes like:
  ```llvm
  %result = tail call i32 @func(i32 %arg)
  %result = musttail call i32 @func(i32 %arg)
  %result = notail call i32 @func(i32 %arg)
  ```

Totality: total
Visibility: public export
Constructors:

Tail : TailCall

  Regular tail call optimization hint

MustTail : TailCall

  Mandatory tail call (must be optimized)

NoTail : TailCall

  Disable tail call optimization

Hints:

Encode FCM TailCall CEnum

Encode ATM TailCall VString

record FnCall : Type

  Function call instruction specification.
  Models LLVM IR call instructions like:
  ```llvm
  %result = call i32 @function(i32 %arg1, i8* %arg2)
  %result = tail call fastcc float @fastfunc(float %x)
  call void @procedure()
  ```

Totality: total
Visibility: public export
Constructor: 

MkFnCall : TailCall -> FastMath -> Maybe CallingConvention -> List Attribute -> Maybe AddressSpace -> LType -> LExpr -> List (WithType LExpr) -> List Attribute -> FnCall

Projections:

.addressSpace : FnCall -> Maybe AddressSpace

  Address space for the function pointer

.args : FnCall -> List (WithType LExpr)

  Function arguments with their types

.cc : FnCall -> Maybe CallingConvention

  Calling convention

.fastMath : FnCall -> FastMath

  Fast math flags for floating point operations

.fnAttrs : FnCall -> List Attribute

  Function attributes

.fnval : FnCall -> LExpr

  Function value or pointer

.returnAttrs : FnCall -> List Attribute

  Return value attributes

.tail : FnCall -> TailCall

  Tail call modifier

.tpe : FnCall -> LType

  Function type

Hints:

Encode FCM FnCall CPtr

Encode ATM FnCall VString

.tail : FnCall -> TailCall

  Tail call modifier

Visibility: public export

tail : FnCall -> TailCall

  Tail call modifier

Visibility: public export

.fastMath : FnCall -> FastMath

  Fast math flags for floating point operations

Visibility: public export

fastMath : FnCall -> FastMath

  Fast math flags for floating point operations

Visibility: public export

.cc : FnCall -> Maybe CallingConvention

  Calling convention

Visibility: public export

cc : FnCall -> Maybe CallingConvention

  Calling convention

Visibility: public export

.returnAttrs : FnCall -> List Attribute

  Return value attributes

Visibility: public export

returnAttrs : FnCall -> List Attribute

  Return value attributes

Visibility: public export

.addressSpace : FnCall -> Maybe AddressSpace

  Address space for the function pointer

Visibility: public export

addressSpace : FnCall -> Maybe AddressSpace

  Address space for the function pointer

Visibility: public export

.tpe : FnCall -> LType

  Function type

Visibility: public export

tpe : FnCall -> LType

  Function type

Visibility: public export

.fnval : FnCall -> LExpr

  Function value or pointer

Visibility: public export

fnval : FnCall -> LExpr

  Function value or pointer

Visibility: public export

.args : FnCall -> List (WithType LExpr)

  Function arguments with their types

Visibility: public export

args : FnCall -> List (WithType LExpr)

  Function arguments with their types

Visibility: public export

.fnAttrs : FnCall -> List Attribute

  Function attributes

Visibility: public export

fnAttrs : FnCall -> List Attribute

  Function attributes

Visibility: public export

data Terminator : Type

  Terminator instructions that end basic blocks.
  Models LLVM IR terminator instructions like:
  ```llvm
  ret void
  ret i32 %value
  br label %target
  br i1 %cond, label %true, label %false
  switch i32 %val, label %default [ i32 0, label %case0 ]
  ```

Totality: total
Visibility: public export
Constructors:

RetVoid : Terminator

  Return void from function

Ret : LType -> LExpr -> Terminator

  Return value from function

CondBr : LExpr -> LExpr -> LExpr -> Terminator

  Conditional branch (br i1 %cond, label %true, label %false)

JumpBr : LExpr -> Terminator

  Unconditional branch (br label %target)

Switch : LType -> LExpr -> Name -> List CaseBranch -> Terminator

  Switch statement with multiple cases

IndirectBr : LExpr -> List LExpr -> Terminator

  Indirect branch through computed address

Invoke : InvokeCall -> Terminator

  Invoke instruction (function call with exception handling)

CallBR : BrCall -> Terminator

  Call branch instruction (inline assembly with possible branches)

Resume : LType -> LExpr -> Terminator

  Resume exception propagation

Unreachable : Terminator

  Unreachable code marker

CatchSwitchOp : CatchSwitch -> Terminator

  Catch switch for exception handling

CatchRet : LExpr -> Label -> Terminator

  Return from catch handler

CleanupRetCaller : LExpr -> Terminator

  Return from cleanup to caller

CleanupRet : LExpr -> Label -> Terminator

  Return from cleanup to specific label

Hints:

Encode FCM Terminator CPtr

Encode ATM Terminator VString

Walk Terminator LOperation

data Comparison : Type

  Integer comparison predicates for icmp instruction.
  Models LLVM IR icmp comparisons like:
  ```llvm
  %result = icmp eq i32 %a, %b
  %result = icmp slt i32 %x, %y
  ```

Totality: total
Visibility: public export
Constructors:

CEq : Comparison

  Equal (==)

CNe : Comparison

  Not equal (!=)

CUGt : Comparison

  Unsigned greater than (>)

CUGe : Comparison

  Unsigned greater than or equal (>=)

CULt : Comparison

  Unsigned less than (<)

CULe : Comparison

  Unsigned less than or equal (<=)

CSGt : Comparison

  Signed greater than (>)

CSGe : Comparison

  Signed greater than or equal (>=)

CSLt : Comparison

  Signed less than (<)

CSLe : Comparison

  Signed less than or equal (<=)

data Wrapping : Type

  Integer overflow wrapping behavior.
  Models LLVM IR overflow flags like:
  ```llvm
  %result = add nuw i32 %a, %b     ; no unsigned wrap
  %result = add nsw i32 %a, %b     ; no signed wrap  
  %result = add nuw nsw i32 %a, %b ; no wrap at all
  ```

Totality: total
Visibility: public export
Constructors:

NoSigned : Wrapping

  No signed wrap (nsw)

NoUnsigned : Wrapping

  No unsigned wrap (nuw)

NoSignedUnsigned : Wrapping

  No signed or unsigned wrap (nuw nsw)

Hints:

Encode FCM Wrapping CEnum

Encode ATM Wrapping VString

data UnaryOpcode : Type

  Unary operation opcodes.
  Models LLVM IR unary instructions like:
  ```llvm
  %result = fneg float %x
  ```

Totality: total
Visibility: public export
Constructor: 

FNeg : UnaryOpcode

  Floating point negation

Hints:

Encode FCM UnaryOpcode CEnum

Encode ATM UnaryOpcode VString

Walk (UnaryOpcode, (LType, LExpr)) LOperation

data BinaryOpcode : Type

  Binary operation opcodes for arithmetic and logical operations.
  Models LLVM IR binary instructions like:
  ```llvm
  %result = add i32 %a, %b
  %result = fadd float %x, %y
  %result = and i1 %p, %q
  %result = shl i32 %val, 2
  ```
  All the simple binary opcodes

Totality: total
Visibility: public export
Constructors:

Add : BinaryOpcode

  Integer addition

AddWrap : Wrapping -> BinaryOpcode

  Integer addition with wrap flags

FAdd : FastMath -> BinaryOpcode

  Floating point addition with fast math

Sub : BinaryOpcode

  Integer subtraction

SubWrap : Wrapping -> BinaryOpcode

  Integer subtraction with wrap flags

FSub : FastMath -> BinaryOpcode

  Floating point subtraction with fast math

Mul : BinaryOpcode

  Integer multiplication

MulWrap : Wrapping -> BinaryOpcode

  Integer multiplication with wrap flags

FMul : FastMath -> BinaryOpcode

  Floating point multiplication with fast math

UDiv : BinaryOpcode

  Unsigned integer division

UDivExact : BinaryOpcode

  Exact unsigned integer division

SDiv : BinaryOpcode

  Signed integer division

SDivExact : BinaryOpcode

  Exact signed integer division

FDiv : FastMath -> BinaryOpcode

  Floating point division with fast math

URem : BinaryOpcode

  Unsigned integer remainder

SRem : BinaryOpcode

  Signed integer remainder

FRem : FastMath -> BinaryOpcode

  Floating point remainder with fast math

Shl : BinaryOpcode

  Shift left

ShlWrap : Wrapping -> BinaryOpcode

  Shift left with wrap flags

LShr : BinaryOpcode

  Logical shift right

LShrExact : BinaryOpcode

  Exact logical shift right

AShr : BinaryOpcode

  Arithmetic shift right

AShrExact : BinaryOpcode

  Exact arithmetic shift right

And : BinaryOpcode

  Bitwise AND

Or : BinaryOpcode

  Bitwise OR

DisjointOr : BinaryOpcode

  Disjoint bitwise OR (operands have no common set bits)

Xor : BinaryOpcode

  Bitwise XOR

Hints:

Encode FCM BinaryOpcode CPtr

Encode ATM BinaryOpcode VString

Walk (BinaryOpcode, (LType, (LExpr, LExpr))) LOperation

data VectorOpcode : Type

  Vector operation opcodes.
  Models LLVM IR vector manipulation instructions like:
  ```llvm
  %result = insertelement <4 x i32> %vec, i32 %val, i32 0
  %result = extractelement <4 x i32> %vec, i32 2
  %result = shufflevector <4 x i32> %v1, <4 x i32> %v2, <4 x i32> <i32 0, i32 5, i32 2, i32 7>
  ```

Totality: total
Visibility: public export
Constructors:

InsertElement : WithType LExpr -> WithType LExpr -> WithType LExpr -> VectorOpcode

  Insert element into vector at specified index

ShuffleVector : WithType LExpr -> WithType LExpr -> WithType LExpr -> VectorOpcode

  Shuffle two vectors according to mask

ExtractElement : WithType LExpr -> WithType LExpr -> VectorOpcode

  Extract element from vector at specified index

Hints:

Encode FCM VectorOpcode CPtr

Encode ATM VectorOpcode VString

Walk VectorOpcode LOperation

data AggregateOpcode : Type

  Aggregate operation opcodes for structs and arrays.
  Models LLVM IR aggregate manipulation instructions like:
  ```llvm
  %result = extractvalue {i32, float} %agg, 0
  %result = insertvalue {i32, float} %agg, i32 42, 0
  ```

Totality: total
Visibility: public export
Constructors:

ExtractValue : WithType LExpr -> Nat -> AggregateOpcode

  Extract value from aggregate at specified index

InsertValue : WithType LExpr -> WithType LExpr -> Nat -> AggregateOpcode

  Insert value into aggregate at specified index

Hints:

Encode FCM AggregateOpcode CPtr

Encode ATM AggregateOpcode VString

Walk AggregateOpcode LOperation

data ConversionOpCode : Type

  Type conversion operation opcodes.
  Models LLVM IR conversion instructions like:
  ```llvm
  %result = trunc i32 %val to i16
  %result = zext i16 %val to i32
  %result = bitcast i8* %ptr to i32*
  %result = addrspacecast i8* %ptr to i8 addrspace(1)*
  ```

Totality: total
Visibility: public export
Constructors:

Trunc : Wrapping -> ConversionOpCode

  Truncate integer to smaller type

ZExt : ConversionOpCode

  Zero extend integer to larger type

SExt : ConversionOpCode

  Sign extend integer to larger type

FPTrunc : FastMath -> ConversionOpCode

  Truncate floating point to smaller precision

FPExt : FastMath -> ConversionOpCode

  Extend floating point to larger precision

FPToUi : ConversionOpCode

  Convert floating point to unsigned integer

FPToSi : ConversionOpCode

  Convert floating point to signed integer

UiToFP : ConversionOpCode

  Convert unsigned integer to floating point

SiToFP : ConversionOpCode

  Convert signed integer to floating point

PtrToInt : ConversionOpCode

  Convert pointer to integer

BitCast : ConversionOpCode

  Bitwise go between types of same size

AddrSpaceCast : AddressSpace -> ConversionOpCode

  Convert pointer between address spaces

Hints:

Encode FCM ConversionOpCode CPtr

Encode ATM ConversionOpCode VString

Walk (ConversionOpCode, (LType, (LExpr, LType))) LOperation

data CompareOpcode : Type

  Comparison operation opcodes.
  Models LLVM IR comparison instructions like:
  ```llvm
  %result = icmp eq i32 %a, %b
  %result = fcmp olt float %x, %y
  %result = fcmp true float %a, %b    ; always true
  ```

Totality: total
Visibility: public export
Constructors:

ICmp : Comparison -> CompareOpcode

  Integer comparison

ICmpSign : Comparison -> CompareOpcode

  Integer comparison with sign information

FCmpOrd : FastMath -> Comparison -> CompareOpcode

  Ordered floating point comparison

FCmpUnOrd : FastMath -> Comparison -> CompareOpcode

  Unordered floating point comparison

FCmpFalse : CompareOpcode

  Always false comparison

FCmpTrue : CompareOpcode

  Always true comparison

data MiscOpcode : Type

  Miscellaneous operation opcodes.
  Models LLVM IR miscellaneous instructions like:
  ```llvm
  %result = phi i32 [ %val1, %bb1 ], [ %val2, %bb2 ]
  %result = select i1 %cond, i32 %true_val, i32 %false_val
  %result = freeze i32 %val
  ```

Totality: total
Visibility: public export
Constructors:

Phi : LType -> List (LExpr, Label) -> MiscOpcode

  PHI node for SSA form

Select : FastMath -> WithType LExpr -> WithType LExpr -> WithType LExpr -> MiscOpcode

  Conditional select instruction

Freeze : WithType LExpr -> MiscOpcode

  Freeze instruction (converts poison to undef)

FnCallOp : FnCall -> MiscOpcode

  Function call operation

Hints:

Encode FCM MiscOpcode CPtr

Encode ATM MiscOpcode VString

Walk MiscOpcode LOperation

data AtomicOrder : Type

Totality: total
Visibility: public export
Constructors:

Unordered : AtomicOrder

  No atomic ordering

Monotonic : AtomicOrder

  Monotonic atomic ordering

Acquire : AtomicOrder

  Acquire atomic ordering

Release : AtomicOrder

  Release atomic ordering

AcquireRelease : AtomicOrder

  Acquire-release atomic ordering

SequentiallyConsistent : AtomicOrder

  Sequentially consistent atomic ordering

Hints:

Encode FCM AtomicOrder CEnum

Encode ATM AtomicOrder VString

data MemoryOpcode : Type

  Memory operation opcodes for memory allocation and access.
  Models LLVM IR memory instructions like:
  ```llvm
  %ptr = alloca i32, align 4
  %ptr = alloca i32, i32 %count, align 8
  %ptr = alloca i32, align 4, addrspace(1)
  ```

Totality: total
Visibility: public export
Constructors:

Alloc : LType -> Maybe (WithType Nat) -> Maybe Nat -> Maybe AddressSpace -> MemoryOpcode

  <result> = alloca [inalloca] <type> [, <ty> <NumElements>] [, align <alignment>] [, addrspace(<num>)]     ; yields type addrspace(num)*:result
  Stack allocation instruction

LoadRegular : Bool -> LType -> LExpr -> Maybe Nat -> Bool -> Bool -> Bool -> Bool -> Maybe Metadata -> Maybe Metadata -> Maybe Nat -> Bool -> MemoryOpcode

  Many of the args are written as Bools, as the spec has them as useless metadata

LoadAtomic : Bool -> LType -> LExpr -> Maybe String -> Maybe AtomicOrder -> Maybe Nat -> Bool -> Bool -> MemoryOpcode

StoreRegular : Bool -> WithType LExpr -> LExpr -> Maybe Nat -> Bool -> Bool -> MemoryOpcode

StoreAtomic : Bool -> WithType LExpr -> LExpr -> Maybe String -> Maybe AtomicOrder -> Maybe Nat -> Bool -> MemoryOpcode

Fence : Maybe String -> Maybe AtomicOrder -> MemoryOpcode

Hints:

Encode FCM MemoryOpcode CPtr

Encode ATM MemoryOpcode VString

Walk MemoryOpcode LOperation

data CatchClause : Type

Totality: total
Visibility: public export
Constructors:

Catching : LType -> LExpr -> CatchClause

  Catch clause for landing pad instructions

Filtering : LType -> LExpr -> CatchClause

  Filter clause for landing pad instructions

Hints:

Encode FCM CatchClause CPtr

Encode ATM CatchClause VString

data ExceptOpcode : Type

Totality: total
Visibility: public export
Constructors:

LandingPad : LType -> List CatchClause -> ExceptOpcode

LandingPadCleanup : LType -> List CatchClause -> ExceptOpcode

CatchPad : Name -> LExpr -> ExceptOpcode

CleanupPad : Name -> LExpr -> ExceptOpcode

Hints:

Encode FCM ExceptOpcode CPtr

Encode ATM ExceptOpcode VString

Walk ExceptOpcode LOperation

data LOperation : Type

  LLVM operations categorized by type.
  Represents all possible LLVM IR operations.

Totality: total
Visibility: public export
Constructors:

TerminatorOp : Terminator -> LOperation

  Terminator instruction (ends basic blocks)

UnaryOp : UnaryOpcode -> LType -> LExpr -> LOperation

  Unary operation

BinaryOp : BinaryOpcode -> LType -> LExpr -> LExpr -> LOperation

  Binary operation

VectorOp : VectorOpcode -> LOperation

  Vector operation

AggregateOp : AggregateOpcode -> LOperation

  Aggregate operation

ConversionOp : ConversionOpCode -> WithType LExpr -> LType -> LOperation

  Type conversion operation

MiscOp : MiscOpcode -> LOperation

  Miscellaneous operation

MemoryOp : MemoryOpcode -> LOperation

  Memory operation

ExceptOp : ExceptOpcode -> LOperation

  Exception handling operation 

Hints:

Encode FCM LOperation CPtr

Encode ATM LOperation VString

Endable Block LOperation

LBlock (List LStatement, LOperation)

Walk LOperation LStatement

Walk Terminator LOperation

Walk (UnaryOpcode, (LType, LExpr)) LOperation

Walk (BinaryOpcode, (LType, (LExpr, LExpr))) LOperation

Walk VectorOpcode LOperation

Walk AggregateOpcode LOperation

Walk (ConversionOpCode, (LType, (LExpr, LType))) LOperation

Walk MiscOpcode LOperation

Walk MemoryOpcode LOperation

Walk ExceptOpcode LOperation

data LStatement : Type

  LLVM statements that can appear in basic blocks.
  Models different forms of LLVM IR statements like:
  ```llvm
  %result = add i32 %a, %b        ; targeted assignment
  call void @function()           ; discarded result
  entry:                          ; basic block label
  ```

Totality: total
Visibility: public export
Constructor: 

Operation : Name -> LOperation -> LStatement

  Operation with named result (%name = operation)

Hints:

Encode FCM LStatement CPtr

Encode ATM LStatement VString

Endable Block LStatement

LBlock (Maybe Name -> List LStatement)

LBlock (List LStatement, LOperation)

Startable Block LStatement

Walk LOperation LStatement

record Block : Type

  Basic block 

Totality: total
Visibility: public export
Constructor: 

MkBlock : String -> List LStatement -> Terminator -> Block

Projections:

.name : Block -> String

  Block name (without label prefix)

.statements : Block -> List LStatement

  List of statements in the block

.terminator : Block -> Terminator

  Terminator instruction that ends the block

Hints:

Encode FCM Block CPtr

Encode ATM Block VString

Endable Block LStatement

Endable Block LOperation

Startable Block LStatement

.name : Block -> String

  Block name (without label prefix)

Visibility: public export

name : Block -> String

  Block name (without label prefix)

Visibility: public export

.statements : Block -> List LStatement

  List of statements in the block

Visibility: public export

statements : Block -> List LStatement

  List of statements in the block

Visibility: public export

.terminator : Block -> Terminator

  Terminator instruction that ends the block

Visibility: public export

terminator : Block -> Terminator

  Terminator instruction that ends the block

Visibility: public export