# Types

All values used in an LLVM module are explicitly typed. All types derive from a common base class `Type`. You can instantiate most of them directly. Once instantiated, a type should be considered immutable.

class llvmlite.ir.Type

  The base class for all types. Never instantiate it directly. Types have the following methods in common:

  - as_pointer(addrspace=0)

      Return a `PointerType` pointing to this type. The optional addrspace integer allows you to choose a non-default address space—the meaning is platform dependent.

  - get_abi_size(target_data)

      Get the ABI size of this type, in bytes, according to the target_data—an `llvmlite.binding.TargetData` instance.

  - get_abi_alignment(target_data)

      Get the ABI alignment of this type, in bytes, according to the target_data—an `llvmlite.binding.TargetData` instance.

  - get_element_offset(target_data, position)

      Get the byte offset for the struct element at position, according to the target_data—an `llvmlite.binding.TargetData` instance.

      NOTE: `get_abi_size()`, `get_abi_alignment()`, and `get_element_offset()` call into the LLVM C++ API to get the requested information.

  - __call__(value)

      A convenience method to create a `Constant` of this type with the given value:

          >>> int32 = ir.IntType(32)
          >>> c = int32(42)
          >>> c
          <ir.Constant type='i32' value=42>
          >>> print(c)
          i32 42

## Atomic types

class llvmlite.ir.IntType(bits)

  The type of integers. The Python integer bits specifies the bitwidth of the integers having this type.

  width

    The width in bits.

class llvmlite.ir.HalfType

  The type of half-precision, floating-point, real numbers.

class llvmlite.ir.FloatType

  The type of single-precision, floating-point, real numbers.

class llvmlite.ir.DoubleType

  The type of double-precision, floating-point, real numbers.

class llvmlite.ir.VoidType

  The class for void types. Used only as the return type of a function without a return value.

## Pointer Types

The IR layer presently supports both Typed Pointers and Opaque Pointers. Support for Typed Pointers will eventually be removed.

Note

Further details of the migration to Opaque Pointers are outlined in the section on Deprecation of Typed Pointers.

Typed Pointers are created using:

class llvmlite.ir.PointerType(pointee, addrspace=0)

  The type of pointers to another type.

  Pointer types expose the following attributes:

  - addrspace

      The pointer’s address space number. This optional integer allows you to choose a non-default address space—the meaning is platform dependent.

  - pointee

      The type pointed to.

Printing of Typed Pointers as Opaque Pointers can be enabled by setting the environment variable:

    LLVMLITE_ENABLE_IR_LAYER_TYPED_POINTERS=0

or by setting the `ir_layer_typed_pointers_enabled` attribute after importing llvmlite, but prior to using any of its functionality. For example:

    import llvmlite
    llvmlite.ir_layer_typed_pointers_enabled = False

    # ... continue using llvmlite ...

Opaque Pointers can be created by using:

class llvmlite.ir.PointerType(addrspace=0)

  The type of pointers.

  Pointer types expose the following attribute:

  - addrspace

      The pointer’s address space number. This optional integer allows you to choose a non-default address space—the meaning is platform dependent.

## Aggregate types

class llvmlite.ir.Aggregate

  The base class for aggregate types. Never instantiate it directly. Aggregate types have the elements attribute in common.

  elements

    A tuple-like immutable sequence of element types for this aggregate type.

class llvmlite.ir.ArrayType(element, count)

  The class for array types.

  - element is the type of every element.

  - count is a Python integer representing the number of elements.

class llvmlite.ir.VectorType(element, count)

  The class for vector types.

  - element is the type of every element.

  - count is a Python integer representing the number of elements.

class llvmlite.ir.LiteralStructType(elements[, packed=False])

  The class for literal struct types.

  - elements is a sequence of element types for each member of the structure.

  - packed controls whether to use packed layout.

class llvmlite.ir.IdentifiedStructType

  The class for identified struct types. Identified structs are compared by name. It can be used to make opaque types.

  Users should not create new instance directly. Use the `Context.get_identified_type` method instead.

  An identified struct is created without a body (thus opaque). To define the struct body, use the `.set_body` method.

  set_body(*elems)

    Define the structure body with a sequence of element types.

## Other types

class llvmlite.ir.FunctionType(return_type, args, var_arg=False)

  The type of a function.

  - return_type is the return type of the function.

  - args is a sequence describing the types of argument to the function.

  - If var_arg is `True`, the function takes a variable number of additional arguments of unknown types after the explicit args.

    EXAMPLE:

        int32 = ir.IntType(32)
        fnty = ir.FunctionType(int32, (ir.DoubleType(), ir.PointerType(int32)))

    An equivalent C declaration would be:

        typedef int32_t (*fnty)(double, int32_t *);

class llvmlite.ir.LabelType

  The type for labels. You do not need to instantiate this type.

class llvmlite.ir.MetaDataType

  The type for Metadata. You do not need to instantiate this type.

  NOTE: This class was previously called “MetaData,” but it was renamed for clarity.