Structs

The following structs are available globally.

  • An Alias represents a global alias in an LLVM module - a new symbol and corresponding metadata for an existing position

    See more

    Declaration

    Swift

    public struct Alias: IRGlobal
  • ArrayType is a very simple derived type that arranges elements sequentially in memory. ArrayType requires a size (number of elements) and an underlying data type.

    See more

    Declaration

    Swift

    public struct ArrayType: IRType
  • A BasicBlock represents 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-in loop.

    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 more

    Declaration

    Swift

    public struct BasicBlock: IRValue
  • A Constant represents 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.

    Constants keep track of the values they represent at the type level to disallow mixed-type arithmetic. Use the cast family of operations to safely convert constants to other representations.

    See more

    Declaration

    Swift

    public struct Constant<Repr: ConstantRepresentation>: IRValue
  • FunctionType represents 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 a void type or first class type — except for LabelType and MetadataType.

    See more

    Declaration

    Swift

    public struct FunctionType: IRType
  • A Global represents a region of memory allocated at compile time instead of at runtime. A global variable must either have an initializer, or make reference to an external definition that has an initializer.

    See more

    Declaration

    Swift

    public struct Global: IRGlobal
  • An Instruction represents an instruction residing in a basic block.

    See more

    Declaration

    Swift

    public struct Instruction: IRValue
  • The IntType represents an integral value of a specified bit width.

    The IntType is 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.

    See more

    Declaration

    Swift

    public struct IntType: IRType
  • The MetadataType type represents embedded metadata. No derived types may be created from metadata except for function arguments.

    See more

    Declaration

    Swift

    public struct MetadataType: IRType
  • A PhiNode object 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 = a
    

    The value of b in this program depends on the value of the condition involving the variable c. Because b must 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 aCondTrue, the value of b is 2, else it is 1 and SSA semantics are preserved.

    See more

    Declaration

    Swift

    public struct PhiNode: IRValue
  • PointerType is used to specify memory locations. Pointers are commonly used to reference objects in memory.

    PointerType may 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 (void*) nor does it permit pointers to labels (label*). Use i8* instead.

    See more

    Declaration

    Swift

    public struct PointerType: IRType
  • StructType is 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 load and store by getting a pointer to a field with the ‘getelementptr‘ instruction. Structures in registers are accessed using the extractvalue and insertvalue instructions.

    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 the DataLayout of the module, which is required to match what the underlying code generator expects.

    Structures can either be literal or identified. 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.

    See more

    Declaration

    Swift

    public struct StructType: IRType
  • A Switch represents a switch instruction. A switch instruction 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.

    See more

    Declaration

    Swift

    public struct Switch: IRValue
  • TokenType is used when a value is associated with an instruction but all uses of the value must not attempt to introspect or obscure it. As such, it is not appropriate to have a PHI or select of type TokenType.

    See more

    Declaration

    Swift

    public struct TokenType: IRType
  • Use

    Use represents an iterator over the uses and users of a particular value in an LLVM program.

    See more

    Declaration

    Swift

    public struct Use
  • A VectorType is 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.

    See more

    Declaration

    Swift

    public struct VectorType: IRType
  • The Void type represents any value and has no size.

    See more

    Declaration

    Swift

    public struct VoidType: IRType
  • X86MMXType represents 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 more

    Declaration

    Swift

    public struct X86MMXType: IRType