[#llvm-sandboxir]
= xref:llvm.adoc[llvm]::sandboxir
:relfileprefix: ../
:mrdocs:

Transactional IR layer over LLVM IR with save/restore and an LLVM‐like API.

== Types

[cols="1,4"]
|===
| Name| Description
| xref:llvm/sandboxir/Action.adoc[`Action`] 
| Describes how to vectorize a bundle of values.
| xref:llvm/sandboxir/AddrSpaceCastInst.adoc[`AddrSpaceCastInst`] 
| SandboxIR wrapper for an LLVM addrspacecast instruction.
| xref:llvm/sandboxir/AllocaInst.adoc[`AllocaInst`] 
| SandboxIR wrapper for an LLVM alloca instruction.
| xref:llvm/sandboxir/Analyses.adoc[`Analyses`] 
| Analysis results available to Sandbox IR passes.
| xref:llvm/sandboxir/Argument.adoc[`Argument`] 
| Argument of a sandboxir::Function.
| xref:llvm/sandboxir/ArrayType.adoc[`ArrayType`] 
| Class to represent array types.
| xref:llvm/sandboxir/AtomicCmpXchgInst.adoc[`AtomicCmpXchgInst`] 
| SandboxIR wrapper for an LLVM cmpxchg instruction.
| xref:llvm/sandboxir/AtomicRMWInst.adoc[`AtomicRMWInst`] 
| SandboxIR wrapper for an LLVM atomicrmw instruction.
| xref:llvm/sandboxir/BBIterator.adoc[`BBIterator`] 
| Iterator for `Instruction`s in a `BasicBlock.
| xref:llvm/sandboxir/BasicBlock.adoc[`BasicBlock`] 
| Contains a list of sandboxir::Instruction's.
| xref:llvm/sandboxir/BinaryOperator.adoc[`BinaryOperator`] 
| SandboxIR wrapper for an LLVM binary operator.
| xref:llvm/sandboxir/BitCastInst.adoc[`BitCastInst`] 
| SandboxIR wrapper for an LLVM bitcast instruction.
| xref:llvm/sandboxir/BlockAddress.adoc[`BlockAddress`] 
| A constant that refers to the address of a basic block.
| xref:llvm/sandboxir/BrInstCommon.adoc[`BrInstCommon`] 
| Shared base for UncondBrInst and CondBrInst successor accessors.
| xref:llvm/sandboxir/BundleVec.adoc[`BundleVec`] 
| A simple bottom‐up or top‐down vectorizer Region pass.
| xref:llvm/sandboxir/ByteType.adoc[`ByteType`] 
| Class to represent byte types.
| xref:llvm/sandboxir/CallBase.adoc[`CallBase`] 
| Base class for SandboxIR call‐like instructions.
| xref:llvm/sandboxir/CallBrInst.adoc[`CallBrInst`] 
| SandboxIR wrapper for an LLVM callbr instruction.
| xref:llvm/sandboxir/CallInst.adoc[`CallInst`] 
| SandboxIR wrapper for an LLVM call instruction.
| xref:llvm/sandboxir/CastInst.adoc[`CastInst`] 
| Base class for SandboxIR cast instructions.
| xref:llvm/sandboxir/CastInstImpl-063.adoc[`CastInstImpl`] 
| CRTP helper implementing concrete SandboxIR cast instructions.
| xref:llvm/sandboxir/CatchPadInst.adoc[`CatchPadInst`] 
| SandboxIR wrapper for an LLVM catchpad instruction.
| xref:llvm/sandboxir/CatchReturnInst.adoc[`CatchReturnInst`] 
| SandboxIR wrapper for an LLVM catchret instruction.
| xref:llvm/sandboxir/CatchSwitchAddHandler.adoc[`CatchSwitchAddHandler`] 
| Tracks adding a handler to a catchswitch instruction.
| xref:llvm/sandboxir/CatchSwitchInst.adoc[`CatchSwitchInst`] 
| SandboxIR wrapper for an LLVM catchswitch instruction.
| xref:llvm/sandboxir/CleanupPadInst.adoc[`CleanupPadInst`] 
| SandboxIR wrapper for an LLVM cleanuppad instruction.
| xref:llvm/sandboxir/CleanupReturnInst.adoc[`CleanupReturnInst`] 
| SandboxIR wrapper for an LLVM cleanupret instruction.
| xref:llvm/sandboxir/CmpInst.adoc[`CmpInst`] 
| Base class for SandboxIR integer and floating‐point compares.
| xref:llvm/sandboxir/CmpSwapOperands.adoc[`CmpSwapOperands`] 
| Tracks swapping the operands of a compare instruction.
| xref:llvm/sandboxir/CollectDescr.adoc[`CollectDescr`] 
| Describes how to collect the values needed by each lane.
| xref:llvm/sandboxir/CondBrInst.adoc[`CondBrInst`] 
| SandboxIR wrapper for a conditional branch instruction.
| xref:llvm/sandboxir/Constant.adoc[`Constant`] 
| A SandboxIR wrapper for an LLVM constant value.
| xref:llvm/sandboxir/ConstantAggregate.adoc[`ConstantAggregate`] 
| Base class for aggregate constants (with operands).
| xref:llvm/sandboxir/ConstantAggregateZero.adoc[`ConstantAggregateZero`] 
| A SandboxIR wrapper for an all‐zero aggregate constant.
| xref:llvm/sandboxir/ConstantArray.adoc[`ConstantArray`] 
| A SandboxIR wrapper for a constant array.
| xref:llvm/sandboxir/ConstantDataArray.adoc[`ConstantDataArray`] 
| A densely packed array constant of simple integer or floating‐point elements.
| xref:llvm/sandboxir/ConstantDataSequential.adoc[`ConstantDataSequential`] 
| Base class for densely packed array/vector constants of simple data elements.
| xref:llvm/sandboxir/ConstantDataVector.adoc[`ConstantDataVector`] 
| A densely packed vector constant of simple integer or floating‐point elements.
| xref:llvm/sandboxir/ConstantExpr.adoc[`ConstantExpr`] 
| A constant expression computed from other constants.
| xref:llvm/sandboxir/ConstantFP.adoc[`ConstantFP`] 
| A SandboxIR wrapper for a floating‐point constant.
| xref:llvm/sandboxir/ConstantInt.adoc[`ConstantInt`] 
| A SandboxIR wrapper for an integer constant.
| xref:llvm/sandboxir/ConstantPointerNull.adoc[`ConstantPointerNull`] 
| A SandboxIR wrapper for a null pointer constant.
| xref:llvm/sandboxir/ConstantPtrAuth.adoc[`ConstantPtrAuth`] 
| A constant that represents a pointer authenticated (signed) pointer value.
| xref:llvm/sandboxir/ConstantStruct.adoc[`ConstantStruct`] 
| A SandboxIR wrapper for a constant struct.
| xref:llvm/sandboxir/ConstantTokenNone.adoc[`ConstantTokenNone`] 
| A constant token with no value, used for untyped token operands.
| xref:llvm/sandboxir/ConstantVector.adoc[`ConstantVector`] 
| A SandboxIR wrapper for a constant vector with operand elements.
| xref:llvm/sandboxir/Context.adoc[`Context`] 
| Owns SandboxIR objects, maps them to LLVM IR, and tracks IR changes.
| xref:llvm/sandboxir/CreateAndInsertInst.adoc[`CreateAndInsertInst`] 
| Tracks creating and inserting a new instruction.
| xref:llvm/sandboxir/DGNode.adoc[`DGNode`] 
| A DependencyGraph Node that points to an Instruction and contains memory dependency edges.
| xref:llvm/sandboxir/DSOLocalEquivalent.adoc[`DSOLocalEquivalent`] 
| A wrapper representing a dso_local_equivalent constant for a global value.
| xref:llvm/sandboxir/DependencyGraph.adoc[`DependencyGraph`] 
| Dependency graph of Sandbox IR instructions used by the vectorizer scheduler.
| xref:llvm/sandboxir/DiamondReuse.adoc[`DiamondReuse`] 
| Legality result that reuses an existing vector without new code.
| xref:llvm/sandboxir/DiamondReuseMultiInput.adoc[`DiamondReuseMultiInput`] 
| Legality result that reuses multiple vectors and/or scalars.
| xref:llvm/sandboxir/DiamondReuseWithShuffle.adoc[`DiamondReuseWithShuffle`] 
| Legality result that reuses an existing vector with a shuffle.
| xref:llvm/sandboxir/EraseFromParent.adoc[`EraseFromParent`] 
| Tracks erasing an instruction (and optionally related instructions) from its parent, retaining enough state to restore them.
| xref:llvm/sandboxir/ExtractElementInst.adoc[`ExtractElementInst`] 
| SandboxIR wrapper for an LLVM extractelement instruction.
| xref:llvm/sandboxir/ExtractValueInst.adoc[`ExtractValueInst`] 
| SandboxIR wrapper for an LLVM extractvalue instruction.
| xref:llvm/sandboxir/FCmpInst.adoc[`FCmpInst`] 
| SandboxIR wrapper for an LLVM fcmp instruction.
| xref:llvm/sandboxir/FPExtInst.adoc[`FPExtInst`] 
| SandboxIR wrapper for an LLVM fpext instruction.
| xref:llvm/sandboxir/FPMathOperator.adoc[`FPMathOperator`] 
| Utility class for floating‐point operations with relaxed accuracy info.
| xref:llvm/sandboxir/FPToSIInst.adoc[`FPToSIInst`] 
| SandboxIR wrapper for an LLVM fptosi instruction.
| xref:llvm/sandboxir/FPToUIInst.adoc[`FPToUIInst`] 
| SandboxIR wrapper for an LLVM fptoui instruction.
| xref:llvm/sandboxir/FPTruncInst.adoc[`FPTruncInst`] 
| SandboxIR wrapper for an LLVM fptrunc instruction.
| xref:llvm/sandboxir/FenceInst.adoc[`FenceInst`] 
| SandboxIR wrapper for an LLVM fence instruction.
| xref:llvm/sandboxir/FixedVectorType.adoc[`FixedVectorType`] 
| Class to represent fixed width SIMD vectors.
| xref:llvm/sandboxir/FreezeInst.adoc[`FreezeInst`] 
| SandboxIR wrapper for an LLVM freeze instruction.
| xref:llvm/sandboxir/FuncletPadInst.adoc[`FuncletPadInst`] 
| Base class for SandboxIR catchpad and cleanuppad instructions.
| xref:llvm/sandboxir/Function.adoc[`Function`] 
| SandboxIR wrapper around an LLVM Function.
| xref:llvm/sandboxir/FunctionPass.adoc[`FunctionPass`] 
| A pass that runs on a sandbox::Function.
| xref:llvm/sandboxir/FunctionPassManager.adoc[`FunctionPassManager`] 
| A pass manager that runs function passes on a sandbox::Function.
| xref:llvm/sandboxir/FunctionType.adoc[`FunctionType`] 
| Class to represent function types.
| xref:llvm/sandboxir/GenericSetter.adoc[`GenericSetter`] 
| Tracks most instruction setter changes via getter/setter member pointers.
| xref:llvm/sandboxir/GenericSetterWithIdx.adoc[`GenericSetterWithIdx`] 
| Similar to GenericSetter but the setters/getters have an index as their first argument. This is commont in cases like: getOperand(unsigned Idx)
| xref:llvm/sandboxir/GetElementPtrInst.adoc[`GetElementPtrInst`] 
| SandboxIR wrapper for an LLVM getelementptr instruction.
| xref:llvm/sandboxir/GlobalAlias.adoc[`GlobalAlias`] 
| A SandboxIR wrapper for an LLVM global alias.
| xref:llvm/sandboxir/GlobalIFunc.adoc[`GlobalIFunc`] 
| A SandboxIR wrapper for an LLVM indirect function (ifunc).
| xref:llvm/sandboxir/GlobalObject.adoc[`GlobalObject`] 
| A SandboxIR wrapper for an LLVM GlobalObject (function, variable, or ifunc).
| xref:llvm/sandboxir/GlobalValue.adoc[`GlobalValue`] 
| A SandboxIR wrapper for an LLVM GlobalValue.
| xref:llvm/sandboxir/GlobalVariable.adoc[`GlobalVariable`] 
| A SandboxIR wrapper for an LLVM global variable.
| xref:llvm/sandboxir/GlobalWithNodeAPI-00.adoc[`GlobalWithNodeAPI`] 
| Mixin that adds module list iterators to SandboxIR globals.
| xref:llvm/sandboxir/ICmpInst.adoc[`ICmpInst`] 
| SandboxIR wrapper for an LLVM icmp instruction.
| xref:llvm/sandboxir/IRChangeBase.adoc[`IRChangeBase`] 
| The base class for IR Change classes.
| xref:llvm/sandboxir/IRSnapshotChecker.adoc[`IRSnapshotChecker`] 
| Debug checker that snapshots SandboxIR functions and compares them after revert.
| xref:llvm/sandboxir/InsertElementInst.adoc[`InsertElementInst`] 
| SandboxIR wrapper for an LLVM insertelement instruction.
| xref:llvm/sandboxir/InsertIntoBB.adoc[`InsertIntoBB`] 
| Tracks inserting an instruction into a basic block.
| xref:llvm/sandboxir/InsertPosition.adoc[`InsertPosition`] 
| Insertion point for creating SandboxIR instructions.
| xref:llvm/sandboxir/InsertValueInst.adoc[`InsertValueInst`] 
| SandboxIR wrapper for an LLVM insertvalue instruction.
| xref:llvm/sandboxir/InstrMaps.adoc[`InstrMaps`] 
| Maps the original instructions to the vectorized instrs and the reverse. For now an original instr can only map to a single vector.
| xref:llvm/sandboxir/Instruction.adoc[`Instruction`] 
| A sandboxir::User with operands, opcode and linked with previous/next instructions in an instruction list.
| xref:llvm/sandboxir/IntToPtrInst.adoc[`IntToPtrInst`] 
| SandboxIR wrapper for an LLVM inttoptr instruction.
| xref:llvm/sandboxir/IntegerType.adoc[`IntegerType`] 
| Class to represent integer types.
| xref:llvm/sandboxir/Interval.adoc[`Interval`] 
| A contiguous inclusive range of ordered nodes from top through bottom.
| xref:llvm/sandboxir/IntervalIterator.adoc[`IntervalIterator`] 
| A simple iterator for iterating the interval.
| xref:llvm/sandboxir/IntrinsicInst.adoc[`IntrinsicInst`] 
| SandboxIR class IntrinsicInst.
| xref:llvm/sandboxir/InvokeInst.adoc[`InvokeInst`] 
| SandboxIR wrapper for an LLVM invoke instruction.
| xref:llvm/sandboxir/LLVMOpUserItToSBTy.adoc[`LLVMOpUserItToSBTy`] 
| Helper that maps LLVM operand‐user iterators to SandboxIR types.
| xref:llvm/sandboxir/LandingPadInst.adoc[`LandingPadInst`] 
| SandboxIR wrapper for an LLVM landingpad instruction.
| xref:llvm/sandboxir/LegalityAnalysis.adoc[`LegalityAnalysis`] 
| Performs the legality analysis and returns a LegalityResult object.
| xref:llvm/sandboxir/LegalityResult.adoc[`LegalityResult`] 
| Result of a legality check for vectorizing a bundle.
| xref:llvm/sandboxir/LegalityResultWithReason.adoc[`LegalityResultWithReason`] 
| Base class for results with reason.
| xref:llvm/sandboxir/LoadInst.adoc[`LoadInst`] 
| SandboxIR wrapper for an LLVM load instruction.
| xref:llvm/sandboxir/LoadStoreVec.adoc[`LoadStoreVec`] 
| A Region pass that vectorizes short store‐load chains.
| xref:llvm/sandboxir/MemDGNode.adoc[`MemDGNode`] 
| A DependencyGraph Node for instructions that may read/write memory, or have some ordering constraints, like with stacksave/stackrestore and alloca/inalloca.
| xref:llvm/sandboxir/MemDGNodeIntervalBuilder.adoc[`MemDGNodeIntervalBuilder`] 
| Convenience builders for a MemDGNode interval.
| xref:llvm/sandboxir/MemSeedBundle.adoc[`MemSeedBundle`] 
| Specialization of SeedBundle for memory‐access instructions.
| xref:llvm/sandboxir/Module.adoc[`Module`] 
| In SandboxIR the Module is mainly used to access the list of global objects.
| xref:llvm/sandboxir/MoveInstr.adoc[`MoveInstr`] 
| Tracks moving an instruction to a new position in the IR.
| xref:llvm/sandboxir/NoCFIValue.adoc[`NoCFIValue`] 
| A constant that wraps a global value without CFI instrumentation.
| xref:llvm/sandboxir/NullPass.adoc[`NullPass`] 
| A Region pass that does nothing, for use as a placeholder in tests.
| xref:llvm/sandboxir/OpaqueInst.adoc[`OpaqueInst`] 
| SandboxIR instruction with no specialized API surface.
| xref:llvm/sandboxir/OpaqueValue.adoc[`OpaqueValue`] 
| Opaque SandboxIR wrapper for LLVM values without a dedicated subclass.
| xref:llvm/sandboxir/OperandUseIterator.adoc[`OperandUseIterator`] 
| Iterator for the `Use` edges of a User's operands.
| xref:llvm/sandboxir/Operator.adoc[`Operator`] 
| Utility class that abstracts common functionality of Instructions and ConstantExprs.
| xref:llvm/sandboxir/OverflowingBinaryOperator.adoc[`OverflowingBinaryOperator`] 
| Utility class for integer operators that may exhibit overflow.
| xref:llvm/sandboxir/PHIAddIncoming.adoc[`PHIAddIncoming`] 
| Tracks addition of an incoming value to a PHI node.
| xref:llvm/sandboxir/PHINode.adoc[`PHINode`] 
| SandboxIR wrapper for an LLVM PHI node.
| xref:llvm/sandboxir/PHIRemoveIncoming.adoc[`PHIRemoveIncoming`] 
| Tracks removal of an incoming value from a PHI node.
| xref:llvm/sandboxir/Pack.adoc[`Pack`] 
| Legality result that packs scalars instead of vectorizing.
| xref:llvm/sandboxir/PackInst.adoc[`PackInst`] 
| A SandboxIR instruction that packs scalar values into a vector.
| xref:llvm/sandboxir/PackReuse.adoc[`PackReuse`] 
| A Region pass that de‐duplicates packs by reusing existing pack patterns.
| xref:llvm/sandboxir/Pass.adoc[`Pass`] 
| The base class of a Sandbox IR Pass.
| xref:llvm/sandboxir/PassManager-0e.adoc[`PassManager`] 
| Base class.
| xref:llvm/sandboxir/PointerType.adoc[`PointerType`] 
| Class to represent pointers.
| xref:llvm/sandboxir/PoisonValue.adoc[`PoisonValue`] 
| A SandboxIR wrapper for an LLVM poison value.
| xref:llvm/sandboxir/PossiblyDisjointInst.adoc[`PossiblyDisjointInst`] 
| An or instruction that can be marked "disjoint".
| xref:llvm/sandboxir/PossiblyNonNegInst.adoc[`PossiblyNonNegInst`] 
| Instruction that can have a nneg flag (zext/uitofp).
| xref:llvm/sandboxir/PredIterator.adoc[`PredIterator`] 
| Iterate over both def‐use and mem dependencies.
| xref:llvm/sandboxir/PrintInstructionCount.adoc[`PrintInstructionCount`] 
| A Region pass that prints the instruction count for the region to stdout. Used to test ‐sbvec‐passes while we don't have any actual optimization passes.
| xref:llvm/sandboxir/PrintRegion.adoc[`PrintRegion`] 
| A Region pass that does nothing, for use as a placeholder in tests.
| xref:llvm/sandboxir/PriorityCmp.adoc[`PriorityCmp`] 
| Comparator that orders ready‐list nodes by scheduling priority.
| xref:llvm/sandboxir/PtrToAddrInst.adoc[`PtrToAddrInst`] 
| SandboxIR wrapper for an LLVM ptrtoaddr instruction.
| xref:llvm/sandboxir/PtrToIntInst.adoc[`PtrToIntInst`] 
| SandboxIR wrapper for an LLVM ptrtoint instruction.
| xref:llvm/sandboxir/ReadyListContainer.adoc[`ReadyListContainer`] 
| The list holding nodes that are ready to schedule. Used by the scheduler.
| xref:llvm/sandboxir/Region.adoc[`Region`] 
| The unit that RegionPasses operate on: new instructions from vectorization.
| xref:llvm/sandboxir/RegionInternalsAttorney.adoc[`RegionInternalsAttorney`] 
| A helper client‐attorney class for unit tests.
| xref:llvm/sandboxir/RegionPass.adoc[`RegionPass`] 
| A pass that runs on a sandbox::Region.
| xref:llvm/sandboxir/RegionPassManager.adoc[`RegionPassManager`] 
| A pass manager that runs region passes on a sandbox::Region.
| xref:llvm/sandboxir/RegionWithScore.adoc[`RegionWithScore`] 
| A Region class that tracks its instructions score.
| xref:llvm/sandboxir/RegionsFromBBs.adoc[`RegionsFromBBs`] 
| A SandboxIR function pass that builds one region per BB and runs a region pass pipeline on them.
| xref:llvm/sandboxir/RegionsFromMetadata.adoc[`RegionsFromMetadata`] 
| A SandboxIR function pass that builds regions from IR metadata and then runs a pipeline of region passes on them.
| xref:llvm/sandboxir/RemoveFromParent.adoc[`RemoveFromParent`] 
| Tracks removing an instruction from its parent without deleting it.
| xref:llvm/sandboxir/ResumeInst.adoc[`ResumeInst`] 
| SandboxIR wrapper for an LLVM resume instruction.
| xref:llvm/sandboxir/ReturnInst.adoc[`ReturnInst`] 
| SandboxIR wrapper for an LLVM return instruction.
| xref:llvm/sandboxir/SBVecContext.adoc[`SBVecContext`] 
| SandboxIR context specialized for the SandboxVectorizer.
| xref:llvm/sandboxir/SExtInst.adoc[`SExtInst`] 
| SandboxIR wrapper for an LLVM sext instruction.
| xref:llvm/sandboxir/SIToFPInst.adoc[`SIToFPInst`] 
| SandboxIR wrapper for an LLVM sitofp instruction.
| xref:llvm/sandboxir/SandboxVectorizerPassBuilder.adoc[`SandboxVectorizerPassBuilder`] 
| Factory for creating SandboxVectorizer function and region passes by name.
| xref:llvm/sandboxir/ScalableVectorType.adoc[`ScalableVectorType`] 
| Class to represent scalable SIMD vectors.
| xref:llvm/sandboxir/SchedBundle.adoc[`SchedBundle`] 
| The nodes that need to be scheduled back‐to‐back in a single scheduling cycle form a SchedBundle.
| xref:llvm/sandboxir/Scheduler.adoc[`Scheduler`] 
| The list scheduler.
| xref:llvm/sandboxir/SchedulerInternalsAttorney.adoc[`SchedulerInternalsAttorney`] 
| A client‐attorney class for accessing the Scheduler's internals (used for unit tests).
| xref:llvm/sandboxir/SchedulingPoint.adoc[`SchedulingPoint`] 
| Scheduling cursor used by the Scheduler during top‐down or bottom‐up scheduling.
| xref:llvm/sandboxir/ScoreBoard.adoc[`ScoreBoard`] 
| Vectorization Score (cost) tracking class.
| xref:llvm/sandboxir/SeedBundle.adoc[`SeedBundle`] 
| A set of candidate Instructions for vectorizing together.
| xref:llvm/sandboxir/SeedCollection.adoc[`SeedCollection`] 
| Collects vectorization seed instructions and runs a region‐pass pipeline.
| xref:llvm/sandboxir/SeedCollector.adoc[`SeedCollector`] 
| Collects load and store seed instructions from a basic block.
| xref:llvm/sandboxir/SeedContainer.adoc[`SeedContainer`] 
| Tracks seeds within SeedBundles keyed by pointer, type, and opcode.
| xref:llvm/sandboxir/SelectInst.adoc[`SelectInst`] 
| SandboxIR wrapper for an LLVM select instruction.
| xref:llvm/sandboxir/ShuffleMask.adoc[`ShuffleMask`] 
| A shuffle mask describing how to rearrange vector lanes.
| xref:llvm/sandboxir/ShuffleVectorInst.adoc[`ShuffleVectorInst`] 
| SandboxIR wrapper for an LLVM shufflevector instruction.
| xref:llvm/sandboxir/ShuffleVectorSetMask.adoc[`ShuffleVectorSetMask`] 
| Tracks changing the shuffle mask of a shufflevector instruction.
| xref:llvm/sandboxir/SingleLLVMInstructionImpl-02.adoc[`SingleLLVMInstructionImpl`] 
| Instructions that contain a single LLVM Instruction can inherit from this.
| xref:llvm/sandboxir/StoreInst.adoc[`StoreInst`] 
| SandboxIR wrapper for an LLVM store instruction.
| xref:llvm/sandboxir/StructType.adoc[`StructType`] 
| Class to represent struct types.
| xref:llvm/sandboxir/SuccIterator.adoc[`SuccIterator`] 
| Iterate over both def‐use and mem dependencies.
| xref:llvm/sandboxir/SwitchAddCase.adoc[`SwitchAddCase`] 
| Tracks adding a case to a switch instruction.
| xref:llvm/sandboxir/SwitchInst.adoc[`SwitchInst`] 
| SandboxIR wrapper for an LLVM switch instruction.
| xref:llvm/sandboxir/SwitchRemoveCase.adoc[`SwitchRemoveCase`] 
| Tracks removing case(s) from a switch instruction.
| xref:llvm/sandboxir/TargetExtType.adoc[`TargetExtType`] 
| Target extension type wrapper (defined elsewhere).
| xref:llvm/sandboxir/ToStr.adoc[`ToStr`] 
| Helpers that map legality enums to debug string names.
| xref:llvm/sandboxir/Tracker.adoc[`Tracker`] 
| The tracker collects all the change objects and implements the main API for saving / reverting / accepting.
| xref:llvm/sandboxir/TransactionAcceptOrRevert.adoc[`TransactionAcceptOrRevert`] 
| A Region pass that accepts or reverts Sandbox IR based on vectorization cost.
| xref:llvm/sandboxir/TransactionAlwaysAccept.adoc[`TransactionAlwaysAccept`] 
| A Region pass that always accepts the transaction without checking its cost.
| xref:llvm/sandboxir/TransactionAlwaysRevert.adoc[`TransactionAlwaysRevert`] 
| A Region pass that always reverts the transaction without checking its cost.
| xref:llvm/sandboxir/TransactionSave.adoc[`TransactionSave`] 
| A Region pass that saves the Sandbox IR state via Context::save().
| xref:llvm/sandboxir/TruncInst.adoc[`TruncInst`] 
| SandboxIR wrapper for an LLVM trunc instruction.
| xref:llvm/sandboxir/Type.adoc[`Type`] 
| Just like llvm::Type these are immutable, unique, never get freed and can only be created via static factory methods.
| xref:llvm/sandboxir/UIToFPInst.adoc[`UIToFPInst`] 
| SandboxIR wrapper for an LLVM uitofp instruction.
| xref:llvm/sandboxir/UnaryInstruction.adoc[`UnaryInstruction`] 
| An abstract class, parent of unary instructions.
| xref:llvm/sandboxir/UnaryOperator.adoc[`UnaryOperator`] 
| SandboxIR wrapper for an LLVM unary operator.
| xref:llvm/sandboxir/UncondBrInst.adoc[`UncondBrInst`] 
| SandboxIR wrapper for an unconditional branch instruction.
| xref:llvm/sandboxir/UndefValue.adoc[`UndefValue`] 
| A SandboxIR wrapper for an LLVM undef value.
| xref:llvm/sandboxir/UnreachableInst.adoc[`UnreachableInst`] 
| SandboxIR wrapper for an LLVM unreachable instruction.
| xref:llvm/sandboxir/Use.adoc[`Use`] 
| Represents a Def‐use/Use‐def edge in SandboxIR.
| xref:llvm/sandboxir/UseSet.adoc[`UseSet`] 
| Tracks the change of the source Value of a sandboxir::Use.
| xref:llvm/sandboxir/UseSwap.adoc[`UseSwap`] 
| Tracks swapping a Use with another Use.
| xref:llvm/sandboxir/User.adoc[`User`] 
| A sandboxir::User has operands.
| xref:llvm/sandboxir/UserUseIterator.adoc[`UserUseIterator`] 
| Iterator for the `Use` edges of a Value's users.
| xref:llvm/sandboxir/Utils.adoc[`Utils`] 
| Collector for SandboxIR‐related convenience functions that don't belong in other classes.
| xref:llvm/sandboxir/VAArgInst.adoc[`VAArgInst`] 
| SandboxIR wrapper for an LLVM va_arg instruction.
| xref:llvm/sandboxir/Value.adoc[`Value`] 
| A SandboxIR Value has users. This is the base class.
| xref:llvm/sandboxir/VecUtils.adoc[`VecUtils`] 
| Convenience helpers for the SandboxVectorizer that do not belong elsewhere.
| xref:llvm/sandboxir/VectorType.adoc[`VectorType`] 
| Base class of all SIMD vector types.
| xref:llvm/sandboxir/Widen.adoc[`Widen`] 
| Legality result indicating the bundle should be widened into a vector.
| xref:llvm/sandboxir/ZExtInst.adoc[`ZExtInst`] 
| SandboxIR wrapper for an LLVM zext instruction.
|===


== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:llvm/sandboxir/BundleTy.adoc[`BundleTy`] 
| Small vector of values representing a vectorization bundle.
| xref:llvm/sandboxir/LoadSeedBundle.adoc[`LoadSeedBundle`] 
| Seed bundle specialized for load instructions.
| xref:llvm/sandboxir/StoreSeedBundle.adoc[`StoreSeedBundle`] 
| Seed bundle specialized for store instructions.
|===


== Enums

[cols="1,4"]
|===
| Name| Description
| xref:llvm/sandboxir/DGNodeID.adoc[`DGNodeID`] 
| SubclassIDs for isa/dyn_cast etc.
| xref:llvm/sandboxir/LegalityResultID.adoc[`LegalityResultID`] 
| Identifiers for concrete LegalityResult subclasses.
| xref:llvm/sandboxir/RegionClassID.adoc[`RegionClassID`] 
| Identifiers for Region subclasses used by classof‐style checks.
| xref:llvm/sandboxir/ResultReason.adoc[`ResultReason`] 
| The reason for vectorizing or not vectorizing.
| xref:llvm/sandboxir/SchedDirection.adoc[`SchedDirection`] 
| Direction in which the scheduler walks the dependency graph.
|===


== Functions

[cols="1,4"]
|===
| Name| Description
| xref:llvm/sandboxir/getLoadStoreAddressSpace.adoc[`getLoadStoreAddressSpace`] 
| Return the address space of a load or store pointer.
| xref:llvm/sandboxir/schedDirectionToStr.adoc[`schedDirectionToStr`] 
| Return a string name for scheduling direction `Dir.`
| xref:llvm/sandboxir/operator_lshift-0c6b5.adoc[`operator<<`] 
| Stream insertion operators
|===



[.small]#Created with https://www.mrdocs.com[MrDocs]#