The context used to intialize this metadata builder.

Creates a metadata builder with the given context.

Builds metadata describing the accuracy of a floating-point computation using the given accuracy value.

Builds branch weight metadata for a set of branch targets of a branch, select, switch, or call instruction.

Builds branch metadata that expresses that the flow of control is unpredictable in a given branch or switch instruction.

Builds section prefix metadata.

LLVM allows an explicit section to be specified for functions. If the target supports it, it will emit functions to the section specified. Additionally, the function can be placed in a COMDAT.

Builds range metadata.

Range metadata may be attached only to load, call and invoke of integer types. It expresses the possible ranges the loaded value or the value returned by the called function at this call site is in. If the loaded or returned value is not in the specified range, the behavior is undefined.

Build callees metadata.

Callees metadata may be attached to indirect call sites. If callees metadata is attached to a call site, and any callee is not among the set of functions provided by the metadata, the behavior is undefined.

Build Callback metadata.

Callback metadata may be attached to a function declaration, or definition. The metadata describes how the arguments of a call to a function are in turn passed to the callback function specified by the metadata. Thus, the callback metadata provides a partial description of a call site inside the function with regards to the arguments of a call to the function. The only semantic restriction on the function itself is that it is not allowed to inspect or modify arguments referenced in the callback metadata as pass-through to the callback function.

Build function entry count metadata.

Function entry count metadata can be attached to function definitions to record the number of times the function is called. Used with block frequency information, it is also used to derive the basic block profile count.

Build a metadata node for the root of a TBAA hierarchy with the given name.

The root node of a TBAA hierarchy describes a boundary for a source language’s type system. For the purposes of optimization, a TBAA analysis pass must consider ancestors of two different root systems mayalias.

Build a metadata node suitable for an alias.scope metadata attachment.

When evaluating an aliasing query, if for some domain, the set of scopes with that domain in one instruction’s alias.scope list is a subset of (or equal to) the set of scopes for that domain in another instruction’s noalias list, then the two memory accesses are assumed not to alias.

Because scopes in one domain don’t affect scopes in other domains, separate domains can be used to compose multiple independent noalias sets. This is used for example during inlining. As the noalias function parameters are turned into noalias scope metadata, a new domain is used every time the function is inlined.

Builds a metadata node suitable for a tbaa.struct metadata attachment.

tbaa.struct metadata can describe which memory subregions in a memcpy are padding and what the TBAA tags of the struct are.

Note that the fields need not be contiguous. In the following example, there is a 4 byte gap between the two fields. This gap represents padding which does not carry useful data and need not be preserved.

!4 = !{ i64 0, i64 4, !1, i64 8, i64 4, !2 }

Builds a TBAA Type Descriptor.

Type descriptors describe the type system of the higher level language being compiled and come in two variants:

Scalar Type Descriptors

Scalar type descriptors describe types that do not contain other types, such as fixed-width integral and floating-point types. A scalar type has a single parent, which is required to be another scalar type or the TBAA root node. For example, in C, int32_t would be described be a scalar type node with a parent pointer to unsigned char which, in turn, points to the root for C.

+----------+   +------+   +-----------+
|          |   |      |   |           |
| uint32_t +---> char +---> TBAA Root |
|          |   |      |   |           |
+----------+   +------+   +-----------+

Struct Type Descriptors

Struct type descriptors describe types that contain a sequence of other type descriptors, at known offsets, as fields. These field type descriptors can either be struct type descriptors themselves or scalar type descriptors.

              +----------+
              |          |
      +-------> uint32_t +----+
      |       |          |    |
      |       +----------+    |
+------------+            +---v--+   +-----------+
|            |            |      |   |           |
| SomeStruct |            | char +---> TBAA Root |
|            |            |      |   |           |
+------------+            +---^--+   +-----------+
      |          +-------+    |
      |          |       |    |
      +----------> float +----+
                 |       |
                 +-------+

Builds a TBAA Access Tag.

Access tags are metadata nodes attached to load and store instructions. Access tags use type descriptors to describe the location being accessed in terms of the type system of the higher level language. Access tags are tuples consisting of a base type, an access type and an offset. The base type is a scalar type descriptor or a struct type descriptor, the access type is a scalar type descriptor, and the offset is a constant integer.

Tag Structure

The access tag (BaseTy, AccessTy, Offset) can describe one of two things:

• If BaseTy is a struct type, the tag describes a memory access (load or store) of a value of type AccessTy contained in the struct type BaseTy at offset Offset.

• If BaseTy is a scalar type, Offset must be 0 and BaseTy and AccessTy must be the same; and the access tag describes a scalar access with scalar type AccessTy.

Builds irreducible loop metadata.