Structures

The abstract layout of a type, describing the relative offsets of its stored properties.

The evaluation context of an abstract interpreter.

Undocumented

An object in an abstract interpreter.

A control-flow graph.

This data structure describes relation between the basic blocks of a function. The direction of the graph’s edges denotes the direction of the control flow from one block to another: there an edge from A to B if the former’s terminator points to the latter.

A tree whose nodes are basic blocks and where a node immediately dominates its children.

Definitions:

• A block b1 in a control-flow graph dominates a block b2 if every path from the entry to b2 must go through b1. By definition, every node dominates itself.
• A block b1 strictly dominates a block b2 if b1 dominates b2 and b1 != b2.
• A block b1 immediately dominates a block b2 if b1 strictly dominates b2 and there is no block b3 that strictly dominates b2.

A dominator tree encodes the dominance relation of a control graph as a tree where a node is a basic blocks and its children are those it immediately dominates.

A spanning tree of a control flow graph.

A region of the program rooted at a definition.

A lifetime rooted at a definition d is a region starting immediately after d and covering a set of uses dominated by d. The “upper boundaries” of a lifetime are the program points immediately after the uses sequenced last in that region.

A module lowered to Hylo IR.

A lowered module is a collection of IR functions and a collection of constant IR values, which represent nominal types, traits, and global bindings. These entities may not necessarily have a definition. When they don’t, they denote a declaration known to be defined in another module.

Creates an access on an object.

IR generation sometimes cannot determine the capability used to access an object, as this information is kept implicit in Hylo sources. For example, a let-binding declaration will actually request a sink capability on its right hand side if the binding escapes. In these cases, IR generation will emit access instructions with the set capabilities that may be inferred from the syntax. These instructions are expected to be “reifed” during IR analysis so that only a single capability is requested.

Projects a value from a subscript bundle.

Computes a source address value advanced by offset bytes.

Computes a source address advanced by count strides of its referred type.

The stride of a type is the number of bytes from the start of an instance to the start of the next when stored in contiguous memory.

Exposes a captured access.

Projects the address of a union payload, viewed as an instance of a given type.

Projects a value.

Computes the address of storage for a field or sub-field of a record, given the record’s address.

Does not access memory.

Creates existential container wrapping the address of a witness.

An instruction marking an exit from a region.

The monomorphization of a function.

How to translate the contents of a function being inlined.

Classification of a record type’s subfields into uninitialized, initialized, and consumed sets.

A basic block in a Hylo IR function.

A basic blocks is sequence of instructions free of conditional control flow. It may also accept arguments representing values that are notionally defined before its first instruction.

A reference to a method or subscript bundle.

The witness of a type’s conformance to the Collection trait from the standard library.

Where, how, and under what conditions a type satisfies the requirements of a trait.

Hylo’s IR emitter.

The emitter transforms well-formed, typed ASTs to a representation suitable for flow-sensitive analysis. IR generated from the emitter may be incomplete and must go through mandatory passes before it can be fed to code generation.

You create an instance by calling Emitter.withInstance, providing the module in which IR should be incorporated and a diagnostic log. Then, the two main entry points are:

• incorporateTopLevelDeclarations: incorporates the top-level declarations of a module’s AST into its corresponding IR form.
• incorporateSyntheticDeclarations: generates the implementations of the synthesized declarations that are notionally part of a module. This method is called after definite deinitialization.

Other entry points may be used during IR passes (e.g., emitDeinit).

A collection of basic blocks representing a lowered function.

The stable identity of an instruction in its module.

Unlike an identity, an index is not stable: inserting or removing instructions from the containing block may invalidate existing indices.

The witness of a type’s conformance to the Iterator trait from the standard library.

A digit in base 64.

The textual description of a Base64Digit is a single printable ASCII character, determined with the following table:

┌────────────────────────────────────────────────────────┐
| 00 ... 09 | \u{0030} ... \u{0039} | decimal digits     |
| 10 ... 35 | \u{0061} ... \u{007a} | lower case letters |
| 36 ... 61 | \u{0041} ... \u{005a} | upper case letters |
| 62        | \u{002e}              | period             |
| 63        | \u{005f}              | underscore         |
└────────────────────────────────────────────────────────┘

This character set is suitable for use in LLVM assembly identifiers.

An unsigned integer whose textual representation uses a variable-length code in base 64.

The textual representation of a Base64VarUInt is satisfies the following properties:

• Small values use fewer characters than larger values.
• The length of the representation can be determined by looking at just the first character.

The textual representation of v is composed of 1 to n ASCII characters (0 < n < 12), written an. v is decoded as follows:

• If a0 < 51, then n = 1 and v = a0.
• If a0 == 51, then n = 2 and v = 50 + a1.
• If a0 == 52, then n = 3 and v = 114 + 64 * a1 + a2.
• Otherwise, n = a0 and v is the sum of ai * 64^(a0 - i) for 1 <= i < a0.

The payload of a DemangledSymbol.entity.

The demangled description of a synthesized function.

Hylo’s demangling algorithm.

Hylo’s mangling algorithm.

A floating-point number Hylo IR constant.

A Hylo IR reference to a user function.

An unsigned integer Hylo IR constant.

A void constant.

The type and conformances of a value acting as the witness of an existential container.

The type of a witness table.

Undocumented

Converts an address to a built-in pointer value.

This instruction doesn’t extend the lifetime of its operand. The value of the converted pointer is only valid within the scope of the source address.

Allocates memory on the stack.

Branches unconditionally to the start of a basic block.

Invokes callee with arguments and writes its result to output.

callee must have a lambda type; the type of the instruction must be the same as output type of the callee. operands must contain as many operands as the callee’s type.

Invokes the built-in function callee, passing operands as the argument list.

Invokes one variant of bundle with arguments and writes its result to output.

Invokes callee, which is a foreign function interface, with operands.

Captures and stores a remote part.

Well-formed IR guarantees the following invariants:

• The provenances of target contain a single alloc_stack.
• A capture ... in is post-dominated by at least one release_captures on the storage in which it has stored an access.

Branches conditionally to the start of a basic block.

Creates the internal representation of constant string allocated statically.

The result is a 64-bit integer corresponding to the byte representation of a string in Hylo.

Deallocates memory previously allocated by alloc_stack.

Accesses the value passed to a generic parameter.

Returns the address of a global binding.

A load instruction.

Unsafely sets the initialization state of storage.

Copies the memory representation of the value stored source to target.

Initializes or assigns storage with a value.

Converts a built-in pointer value to an address.

This instruction doesn’t extend the lifetime of its operand. The address unsafely refers to the memory referenced by the pointer.

Releases accesses captures in an allocation.

A return instruction.

Stores object at the specified location.

Branches to one of several basic blocks.

Copy the discriminator of a union container.

Branches to one of several basic blocks based on the discriminator of a union.

Marks this execution path as unreachable, causing a fatal error otherwise.

Projects the address of an object.

The possibly synthetic declaration of a parameter to a Hylo IR function.

A program lowered to Hylo IR.

The address of some statically allocated storage.

The lowered (static) type of an entity.

Note: when qualified, this must be spelled IR.Type (https://github.com/apple/swift/issues/67378)

A pair representing the use of a value in an instruction.