Structures

The following structures are available globally.

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

    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
  • Represents a simple function call.

    See more

    Declaration

    Swift

    public struct Call : IRValue
  • Represents a function call that may transfer control to an exception handler.

    See more

    Declaration

    Swift

    public struct Invoke : 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> : IRConstant where Repr : ConstantRepresentation
  • FloatType enumerates representations of a floating value of a particular bit width and semantics.

    See more

    Declaration

    Swift

    public struct FloatType : IRType
  • 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
  • An Instruction represents an instruction residing in a basic block.

    See more

    Declaration

    Swift

    public struct Instruction : IRValue
  • A TerminatorInstruction represents an instruction that terminates a basic block.

    See more

    Declaration

    Swift

    public struct TerminatorInstruction
  • 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
  • A DebugLocation represents a location in source.

    See more

    Declaration

    Swift

    public struct DebugLocation : Metadata
  • CompileUnitMetadata nodes represent a compile unit, the root of a metadata hierarchy for a translation unit.

    Compile unit descriptors provide the root scope for objects declared in a specific compilation unit. FileMetadata descriptors are defined using this scope.

    These descriptors are collected by a named metadata node !llvm.dbg.cu. They keep track of global variables, type information, and imported entities (declarations and namespaces).

    See more

    Declaration

    Swift

    public struct CompileUnitMetadata : DIScope
  • FileMetadata nodes represent files.

    The file name does not necessarily have to be a proper file path. For example, it can include additional slash-separated path components.

    See more

    Declaration

    Swift

    public struct FileMetadata : DIScope
  • DIBasicType nodes represent primitive types, such as int, bool and float.

    Basic types carry an encoding describing the details of the type to influence how it is presented in debuggers. LLVM currently supports specific DWARF Attribute Type Encodings that are enumerated in DIAttributeTypeEncoding.

    See more

    Declaration

    Swift

    public struct DIBasicType : DIType
  • DISubroutineType nodes represent subroutine types.

    Subroutine types are meant to mirror their formal declarations in source: arguments are represented in order. The return type is optional and meant to represent the concept of void in C-like languages.

    See more

    Declaration

    Swift

    public struct DISubroutineType : DIType
  • LexicalBlockMetadata nodes describe nested blocks within a subprogram. The line number and column numbers are used to distinguish two lexical blocks at same depth.

    Usually lexical blocks are distinct to prevent node merging based on operands.

    See more

    Declaration

    Swift

    public struct LexicalBlockMetadata : DIScope
  • LexicalBlockFile nodes are used to discriminate between sections of a lexical block. The file field can be changed to indicate textual inclusion, or the discriminator field can be used to discriminate between control flow within a single block in the source language.

    See more

    Declaration

    Swift

    public struct LexicalBlockFileMetadata : DIScope
  • LocalVariableMetadata nodes represent local variables and function parameters in the source language.

    See more

    Declaration

    Swift

    public struct LocalVariableMetadata : Metadata
  • ObjectiveCPropertyMetadata nodes represent Objective-C property nodes.

    See more

    Declaration

    Swift

    public struct ObjectiveCPropertyMetadata : Metadata
  • ImportedEntityMetadata nodes represent entities (such as modules) imported into a compile unit.

    See more

    Declaration

    Swift

    public struct ImportedEntityMetadata : DIType
  • NameSpaceMetadata nodes represent subroutines in the source program. They are attached to corresponding LLVM IR functions.

    See more

    Declaration

    Swift

    public struct FunctionMetadata : DIScope
  • NameSpaceMetadata nodes represent entities like C++ modules.

    See more

    Declaration

    Swift

    public struct ModuleMetadata : DIScope
  • NameSpaceMetadata nodes represent entities like C++ namespaces.

    See more

    Declaration

    Swift

    public struct NameSpaceMetadata : DIScope
  • ExpressionMetadata nodes represent expressions that are inspired by the DWARF expression language. They are used in debug intrinsics (such as llvm.dbg.declare and llvm.dbg.value) to describe how the referenced LLVM variable relates to the source language variable.

    Debug intrinsics are interpreted left-to-right: start by pushing the value/address operand of the intrinsic onto a stack, then repeatedly push and evaluate opcodes from the ExpressionMetadata until the final variable description is produced.

    Though DWARF supports hundreds of expressions, LLVM currently implements a very limited subset.

    See more

    Declaration

    Swift

    public struct ExpressionMetadata : Metadata
  • Enumerates the known attributes that can appear on an Objective-C property.

    See more

    Declaration

    Swift

    public struct ObjectiveCPropertyAttribute : OptionSet
  • Enumerates a set of flags that can be applied to metadata nodes to change their interpretation at compile time or attach additional semantic significance at runtime.

    See more

    Declaration

    Swift

    public struct DIFlags : OptionSet
  • 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 Section represents one of the binary sections in an object file.

    See more

    Declaration

    Swift

    public struct Section
  • A symbol is a top-level addressable entity in an object file.

    See more

    Declaration

    Swift

    public struct Symbol
  • A Relocation represents the contents of a relocated symbol in the dynamic linker.

    See more

    Declaration

    Swift

    public struct Relocation
  • 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
  • An alignment value, expressed in bytes.

    See more

    Declaration

    Swift

    public struct Alignment : Comparable, Hashable
  • This is an opaque type for sizes expressed in aggregate bit units, usually 8 bits per unit.

    Instances of this type represent a quantity as a multiple of a radix size

    • e.g. the size of a char in bits on the target architecture. As an opaque type, Size protects you from accidentally combining operations on quantities in bit units and size units.

    For portability, never assume that a target radix is 8 bits wide. Use Size values wherever you calculate sizes and offsets.

    See more

    Declaration

    Swift

    public struct Size
  • 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