3.2. Values — Anaconda Enterprise 4.4 documentation

Anaconda Enterprise: Documentation

# 3.2. Values

Values are what a module mostly consists of.

`llvmlite.ir.` `Undefined`

  An undefined value (mapping to LLVM’s “undef”).

class `llvmlite.ir.` `Value`

  The base class for all IR values.

class `llvmlite.ir.` `Constant`(typ, constant)

  A literal value. typ is the type of the represented value (a `Type` instance). constant is the Python value to be represented. Which Python types are allowed for constant depends on typ:

  - All types accept `Undefined`, and turn it into LLVM’s “undef”.
  - All types accept None, and turn it into LLVM’s “zeroinitializer”.
  - `IntType` accepts any Python integer or boolean.
  - `FloatType` and `DoubleType` accept any Python real number.
  - Aggregate types (i.e. array and structure types) accept a sequence of Python values corresponding to the type’s element types.
  - In addition, `ArrayType` also accepts a single `bytearray` instance to initialize the array from a string of bytes. This is useful for character constants.
  classmethod `literal_array`(elements)

    An alternate constructor for constant arrays. elements is a sequence of values (`Constant` or otherwise). All elements must have the same type. A constant array containing the elements in order is returned

  classmethod `literal_struct`(elements)

    An alternate constructor for constant structs. elements is a sequence of values (`Constant` or otherwise). A constant struct containing the elements in order is returned

  `bitcast`(typ)

    Convert this pointer constant to a constant of the given pointer type.

  `gep`(indices)

    Compute the address of the inner element given by the sequence of indices. The constant must have a pointer type.

  `inttoptr`(typ)

    Convert this integer constant to a constant of the given pointer type.

  Note

  You cannot define constant functions. Use a function declaration instead.

class `llvmlite.ir.` `Argument`

  One of a function’s arguments. Arguments have the following method:

  `add_attribute`(attr)

    Add an argument attribute to this argument. attr is a Python string.

class `llvmlite.ir.` `Block`

  A basic block. You shouldn’t instantiate or mutate this type directly; instead, call the helper methods on `Function` and `IRBuilder`.

  Basic blocks have the following methods and attributes:

  `replace`(old, new)

    Replace the instruction old with the other instruction new in this block’s list of instructions. All uses of old in the whole function are also patched. old and new are `Instruction` objects.

  `function`

    The function this block is defined in.

  `is_terminated`

    Whether this block ends with a terminator instruction.

  `terminator`

    The block’s terminator instruction, if any. Otherwise None.

class `llvmlite.ir.` `BlockAddress`

  A constant representing an address of a basic block.

  Block address constants have the following attributes:

  `function`

    The function the basic block is defined in.

  `basic_block`

    The basic block. Must be a part of `function`.

## 3.2.1. Metadata

There are several kinds of metadata values.

class `llvmlite.ir.` `MetaDataString`(module, value)

  A string literal for use in metadata. module is the module the metadata belongs to. value is a Python string.

class `llvmlite.ir.` `MDValue`

  A metadata node. To create an instance, call `Module.add_metadata()`.

class `llvmlite.ir.` `DIValue`

  A debug information descriptor, containing key-value pairs. To create an instance, call `Module.add_debug_info()`.

class `llvmlite.ir.` `DIToken`(value)

  A debug information “token”, representing a well-known enumeration value. value should be the enumeration name, e.g. `'DW_LANG_Python'`.

class `llvmlite.ir.` `NamedMetaData`

  A named metadata node. To create an instance, call `Module.add_named_metadata()`. Named metadata has the following method:

  `add`(md)

    Append the given piece of metadata to the collection of operands referred to by the NamedMetaData. md can be either a `MetaDataString` or a `MDValue`.

## 3.2.2. Global values

Global values are values accessible using a module-wide name.

class `llvmlite.ir.` `GlobalValue`

  The base class for global values. Global values have the following writable attribute:

  `linkage`

    A Python string describing the linkage behaviour of the global value (e.g. whether it is visible from other modules). Default is the empty string, meaning “external”.

  `storage_class`

    A Python string describing the storage class of the global value. Default is the empty string, meaning “default”. Other possible values include “dllimport” and “dllexport”.

class `llvmlite.ir.` `GlobalVariable`(module, typ, name, addrspace=0)

  A global variable. module is where the variable will be defined. typ is the variable’s type. name is the variable’s name (a Python string). addrspace is an optional address space to store the variable in.

  typ cannot be a function type. To declare a global function, use `Function`.

  The returned Value’s actual type is a pointer to typ. To read (respectively write) the variable’s contents, you need to `load()` from (respectively `store()` to) the returned Value.

  Global variables have the following writable attributes:

  `global_constant`

    If true, the variable is declared a constant, i.e. its contents cannot be ever modified. Default is False.

  `unnamed_addr`

    If true, the address of the variable is deemed insignificant, i.e. it will be merged with other variables which have the same initializer. Default is False.

  `initializer`

    The variable’s initialization value (probably a `Constant` of type typ). Default is None, meaning the variable is uninitialized.

  `align`

    An explicit alignment in bytes. Default is None, meaning the default alignment for the variable’s type is used.

class `llvmlite.ir.` `Function`(module, typ, name)

  A global function. module is where the function will be defined. typ is the function’s type (a `FunctionType` instance). name is the function’s name (a Python string).

  If a global function has any basic blocks, it is a function definition. Otherwise, it is a function declaration.

  Functions have the following methods and attributes:

  `append_basic_block`(name='')

    Append a basic block to this function’s body. If name is non empty, it names the block’s entry label.

    A new `Block` is returned.

  `insert_basic_block`(before, name='')

    Similar to `append_basic_block()`, but inserts it before the basic block before in the function’s list of basic blocks.

  `set_metadata`(name, node)

    Add a function-specific metadata named name pointing to the given metadata node (a `MDValue`).

  `args`

    The function’s arguments as a tuple of `Argument` instances.

  `attributes`

    A set of function attributes. Each optional attribute is a Python string. By default this is empty. Use the `add()` method to add an attribute:

        fnty = ir.FunctionType(ir.DoubleType(), (ir.DoubleType(),))
        fn = Function(module, fnty, "sqrt")
        fn.attributes.add("alwaysinline")

  `calling_convention`

    The function’s calling convention (a Python string). Default is the empty string.

  `is_declaration`

    Whether the global function is a declaration (True) or a definition (False).

## 3.2.3. Instructions

Every instruction is also a value: it has a name (the recipient’s name), a well-defined type, and can be used as an operand in other instructions or in literals.

Instruction types should usually not be instantiated directly. Instead, use the helper methods on the `IRBuilder` class.

class `llvmlite.ir.` `Instruction`

  The base class for all instructions. Instructions have the following method and attributes:

  `set_metadata`(name, node)

    Add an instruction-specific metadata named name pointing to the given metadata node (a `MDValue`).

  `function`

    The function this instruction is part of.

  `module`

    The module this instruction’s function is defined in.

class `llvmlite.ir.` `PredictableInstr`

  The class of instructions for which we can specificy the probabilities of different outcomes (e.g. a switch or a conditional branch). Predictable instructions have the following method:

  `set_weights`(weights)

    Set the weights of the instruction’s possible outcomes. weights is a sequence of positive integers, each corresponding to a different outcome and specifying its relative probability compared to other outcomes (the greater, the likelier).

class `llvmlite.ir.` `SwitchInstr`

  A switch instruction. Switch instructions have the following method:

  `add_case`(val, block)

    Add a case to the switch instruction. val should be a `Constant` or a Python value compatible with the switch instruction’s operand type. block is a `Block` to jump to if, and only if, val and the switch operand compare equal.

class `llvmlite.ir.` `IndirectBranch`

  An indirect branch instruction. Indirect branch instructions have the following method:

  `add_destination`(value, block)

    Add an outgoing edge. The indirect branch instruction must refer to every basic block it can transfer control to.

class `llvmlite.ir.` `PhiInstr`

  A phi instruction. Phi instructions have the following method:

  `add_incoming`(value, block)

    Add an incoming edge. Whenever transfer is controlled from block (a `Block`), the phi instruction takes the given value.

class `llvmlite.ir.` `LandingPad`

  A landing pad. Landing pads have the following method:

  `add_clause`(value, block)

    Add a catch or filter clause. Create catch clauses using `CatchClause`, and filter clauses using `FilterClause`.

## 3.2.4. Landing pad clauses

Landing pads have the following classes associated with them:

class `llvmlite.ir.` `CatchClause`(value)

  A catch clause. Instructs the personality function to compare the in-flight exception typeinfo with value, which should have type IntType(8).as_pointer().as_pointer().

class `llvmlite.ir.` `FilterClause`(value)

  A filter clause. Instructs the personality function to check inclusion of the the in-flight exception typeinfo in value, which should have type ArrayType(IntType(8).as_pointer().as_pointer(), ...).