LLVM IR Data Types

The Importance of Strong Typing

Before diving into the types themselves, it's worth reinforcing why this matters. In a low-level representation, explicit and strict typing eliminates ambiguity, which is a prerequisite for safe and aggressive optimization. The compiler must know the exact size and properties of the data it's manipulating.

The following short video segment emphasizes this point, showing how types are pervasive in the IR and how the compiler flags mismatches.

Primitive Types: The Atoms of Data

Primitive types are the fundamental, indivisible units of data in LLVM IR. All more complex types are built from these.

Integer Types (iN)

You've already seen i32 and the boolean-like i1. The general form is iN, where N is the number of bits. This allows for arbitrary-bit-width integers (e.g., i1, i8, i24, i32, i64).

A crucial point for anyone with a systems programming background is that LLVM IR integers do not have inherent signedness. An i32 is just a collection of 32 bits. Whether it's treated as signed or unsigned depends entirely on the instruction using it. For example:

• sdiv performs a signed division.
• udiv performs an unsigned division.
• add doesn't care about signedness, as the two's complement arithmetic is the same for both.

When you need to change the size of an integer, you must use an explicit conversion instruction:

• trunc: Truncates a larger integer to a smaller one (e.g., i64 to i32).
• zext: Zero-extends an integer to a larger size (for unsigned semantics).
• sext: Sign-extends an integer to a larger size (for signed semantics).

Floating-Point Types

LLVM supports standard floating-point types that correspond to the IEEE 754 standard:

• float: 32-bit single-precision.
• double: 64-bit double-precision.
• Other more exotic types exist, like half, bfloat, fp128, which are important in performance-critical domains like machine learning and high-performance computing.

The void and ptr Types

• void: Represents the absence of a value. Its only use is as a return type for functions that don't return anything.
• ptr: Represents a pointer to a memory location. In modern LLVM IR, this is an opaque pointer type. Unlike in C++, where you might have int* or char*, the ptr type itself doesn't specify what it points to. The type of the data is specified by the instruction that uses the pointer, such as load or store. For example, load i32, ptr %my_ptr tells the compiler to load a 32-bit integer from the address in %my_ptr. This design simplifies the IR.

To convert between pointers and integers, you use ptrtoint and inttoptr. To cast between pointer types (which is less common with opaque pointers but still necessary sometimes, especially when interacting with legacy code or specific intrinsics), you use bitcast.

The following reading selection provides a comprehensive tour of these types and their associated conversion instructions.

Derived Types: Composing Data

Derived types, also known as composite types, are aggregates built from primitive types or other derived types. They allow you to represent complex data structures from your source language.

Array Types

An array is a sequence of elements of the same type. The syntax is [<number_of_elements> x <element_type>]. For example, [10 x i32] is an array of ten 32-bit integers. The size is fixed and known at compile time.

Struct Types

A struct represents a collection of elements that can have different types. The syntax is { <type1>, <type2>, ... }. For example, { i8, i32, ptr } could represent a simple struct. Unlike C structs, the fields in LLVM IR are anonymous and are accessed by a zero-based index.

For fine-grained memory layout control, which is often critical in systems and performance programming, LLVM also provides packed structs. These are written as <{ ... }> and instruct the compiler to lay out the fields without any padding, even if it means unaligned access.

Vector Types

A vector is a sequence of elements of the same primitive type, similar to an array. However, its purpose is different. The syntax is < <number_of_elements> x <element_type> >, for example, <4 x float>.

Vectors are specifically for SIMD (Single Instruction, Multiple Data) operations. A single instruction can operate on all elements of a vector in parallel. For example, an fadd on two <4 x float> vectors would perform four additions simultaneously on a CPU with appropriate hardware support. This is a cornerstone of high-performance code generation.

We will now turn back to the "A Gentle Introduction to LLVM IR" article to see how these derived types are defined.

Identifying Types in Practice

Let's look at the LLVM IR Quick Reference for a concise, tabular summary of the types we've discussed. This format is useful for quick lookups when you're analyzing IR files.

Conclusion

In this lesson, you've taken a deep dive into the LLVM IR type system, a crucial step toward fluency in the language of the compiler. You now have the vocabulary to describe the data being manipulated in any piece of IR you encounter.

Key Takeaways:

• Strongly Typed: LLVM IR is strictly typed, which enables safe and powerful optimizations.
• Primitive Types: The basic building blocks are iN (arbitrary-width integers), float/double (floating-point), void (absence of a value), and ptr (opaque pointer).
• Signless Integers: Integer types themselves have no sign; signedness is determined by the instructions that operate on them.
• Derived Types: Complex data structures are represented using [N x T] (arrays), {...} (structs), and <N x T> (vectors for SIMD).
• Access by Index: Elements of arrays and fields of structs are accessed by a numerical index.

In our next lesson, we will tackle control flow in more detail. You'll learn how LLVM represents conditional logic and loops using br instructions and, most importantly, how phi instructions are used to merge values from different control flow paths, a concept that brings together SSA, branching, and the type system.