Continuum Analytics: Documentation

# 3.1. Types

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

class `llvmlite.ir.``Type`

  The base class for all types. You should 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 (a `llvmlite.binding.TargetData` instance).

  `get_abi_alignment`(target_data)

    Get the ABI alignment of this type, in bytes, according to the target_data (a `llvmlite.binding.TargetData` instance).

    Note

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

  `__call__`(value)

    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

## 3.1.1. Atomic types

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

  The type of pointers to another type. pointee is the type pointed to. The optional addrspace integer allows you to choose a non-default address space (the meaning is platform-dependent).

  Pointer types exposes the following attributes:

  `addrspace`

    The pointer’s address space number.

  `pointee`

    The type pointed to.

class `llvmlite.ir.``IntType`(bits)

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

  `width`

    The width in bits.

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; only used as the return type of a function without a return value.

## 3.1.2. Aggregate types

class `llvmlite.ir.``Aggregate`

  The base class for aggregate types. You should never instantiate it directly. Aggregate types have the following 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 the number of elements (a Python integer).

class `llvmlite.ir.``LiteralStructType`(elements)

  The class for literal struct types. elements is a sequence of element types for each member of the structure.

## 3.1.3. 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 don’t need to instantiate this type.

class `llvmlite.ir.``MetaDataType`

  The type for metadata. You don’t need to instantiate this type.

  Note

  This used to be called `MetaData` but was renamed for clarity.