Structs
The following structs are available globally.
-
A
BasicBlockrepresents a basic block in an LLVM IR program. A basic block contains a sequence of instructions, a pointer to its parent block and its follower block, and an optional label that gives the basic block an entry in the symbol table.A basic block can be thought of as a sequence of instructions, and indeed its member instructions may be iterated over with a
for-inloop.The first basic block in a function is special in two ways: it is immediately executed on entrance to the function, and it is not allowed to have predecessor basic blocks (i.e. there can not be any branches to the entry block of a function). Because the block can have no predecessors, it also cannot have any PHI nodes.
See moreDeclaration
Swift
public struct BasicBlock: IRValue
-
A
Constantrepresents a value initialized to a constant. Constant values may be manipulated with standard Swift arithmetic operations and used with standard IR Builder instructions like any other operand. The difference being any instructions acting solely on constants and any arithmetic performed on constants is evaluated at compile-time only.
See moreConstants keep track of the values they represent at the type level to disallow mixed-type arithmetic. Use thecastfamily of operations to safely convert constants to other representations.Declaration
Swift
public struct Constant<Repr: ConstantRepresentation>: IRValue
-
See moreFunctionTyperepresents a function’s type signature. It consists of a return type and a list of formal parameter types. The return type of a function type is avoidtype or first class type — except forLabelTypeandMetadataType.Declaration
Swift
public struct FunctionType: IRType
-
The
IntTyperepresents an integral value of a specified bit width.The
See moreIntTypeis a very simple type that simply specifies an arbitrary bit width for the integer type desired. Any bit width from 1 bit to (2^23)-1 (about 8 million) can be specified.Declaration
Swift
public struct IntType: IRType
-
A
PhiNodeobject represents a PHI node.Because all instructions in LLVM IR are in SSA (Single Static Assignment) form, a PHI node is necessary when the value of a variable assignment depends on the path the flow of control takes through the program. For example:
var a = 1 if c == 42 { a = 2 } let b = aThe value of
bin this program depends on the value of the condition involving the variablec. Becausebmust be assigned to once, a PHI node is created and the program effectively is transformed into the following:let aNoCond = 1 if c == 42 { let aCondTrue = 2 } let b = PHI(aNoCond, aCondTrue)If the flow of control reaches
See moreaCondTrue, the value ofbis2, else it is1and SSA semantics are preserved.Declaration
Swift
public struct PhiNode: IRValue
-
PointerTypeis used to specify memory locations. Pointers are commonly used to reference objects in memory.PointerTypemay have an optional address space attribute defining the numbered address space where the pointed-to object resides. The default address space is number zero. The semantics of non-zero address spaces are target-specific.Note that LLVM does not permit pointers to void
See more(void*)nor does it permit pointers to labels(label*). Usei8*instead.Declaration
Swift
public struct PointerType: IRType
-
StructTypeis used to represent a collection of data members together in memory. The elements of a structure may be any type that has a size.Structures in memory are accessed using
loadandstoreby getting a pointer to a field with the ‘getelementptr‘ instruction. Structures in registers are accessed using theextractvalueandinsertvalueinstructions.Structures may optionally be
packed
structures, which indicate that the alignment of the struct is one byte, and that there is no padding between the elements. In non-packed structs, padding between field types is inserted as defined by theDataLayoutof the module, which is required to match what the underlying code generator expects.Structures can either be
See moreliteral
oridentified
. A literal structure is defined inline with other types (e.g. {i32, i32}*) whereas identified types are always defined at the top level with a name. Literal types are uniqued by their contents and can never be recursive or opaque since there is no way to write one. Identified types can be recursive, can be opaqued, and are never uniqued.Declaration
Swift
public struct StructType: IRType
-
A
See moreSwitchrepresents aswitchinstruction. Aswitchinstruction defines a jump table of values and destination basic blocks to pass the flow of control to if a condition value matches. If no match is made, control flow passes to the default basic block.Declaration
Swift
public struct Switch: IRValue
-
See moreUserepresents an iterator over the uses and users of a particular value in an LLVM program.Declaration
Swift
public struct Use
-
A
See moreVectorTypeis a simple derived type that represents a vector of elements.VectorTypes are used when multiple primitive data are operated in parallel using a single instruction (SIMD). A vector type requires a size (number of elements) and an underlying primitive data type.Declaration
Swift
public struct VectorType: IRType
-
X86MMXTyperepresents a value held in an MMX register on an x86 machine.The operations allowed on it are quite limited: parameters and return values, load and store, and bitcast. User-specified MMX instructions are represented as intrinsic or asm calls with arguments and/or results of this type. There are no arrays, vectors or constants of this type.
See moreDeclaration
Swift
public struct X86MMXType: IRType
Structs Reference