Sign In Start Free Trial

Book Overview & Buying
Table Of Contents
Feedback & Rating

LLVM Cookbook

By : Mayur Pandey, Suyog Sarda

2 (9)

LLVM Cookbook

2 (9)

By: Mayur Pandey, Suyog Sarda

Overview of this book

The book is for compiler programmers who are familiar with concepts of compilers and want to indulge in understanding, exploring, and using LLVM infrastructure in a meaningful way in their work. This book is also for programmers who are not directly involved in compiler projects but are often involved in development phases where they write thousands of lines of code. With knowledge of how compilers work, they will be able to code in an optimal way and improve performance with clean code.

Preface

Preface

What this book covers

What you need for this book

Who this book is for

Sections

Conventions

Reader feedback

Customer support

Free Chapter

1. LLVM Design and Use

1. LLVM Design and Use

Introduction

Understanding modular design

Cross-compiling Clang/LLVM

Converting a C source code to LLVM assembly

Converting IR to LLVM bitcode

Converting LLVM bitcode to target machine assembly

Converting LLVM bitcode back to LLVM assembly

Transforming LLVM IR

Linking LLVM bitcode

Executing LLVM bitcode

Using the C frontend Clang

Using the GO frontend

Using DragonEgg

2. Steps in Writing a Frontend

2. Steps in Writing a Frontend

Introduction

Defining a TOY language

Implementing a lexer

Defining Abstract Syntax Tree

Implementing a parser

Parsing simple expressions

Parsing binary expressions

Invoking a driver for parsing

Running lexer and parser on our TOY language

Defining IR code generation methods for each AST class

Generating IR code for expressions

Generating IR code for functions

Adding IR optimization support

3. Extending the Frontend and Adding JIT Support

3. Extending the Frontend and Adding JIT Support

Introduction

Handling decision making paradigms – if/then/else constructs

Generating code for loops

Handling user-defined operators – binary operators

Handling user-defined operators – unary operators

Adding JIT support

4. Preparing Optimizations

4. Preparing Optimizations

Introduction

Various levels of optimization

Writing your own LLVM pass

Running your own pass with the opt tool

Using another pass in a new pass

Registering a pass with pass manager

Writing an analysis pass

Writing an alias analysis pass

Using other analysis passes

5. Implementing Optimizations

5. Implementing Optimizations

Introduction

Writing a dead code elimination pass

Writing an inlining transformation pass

Writing a pass for memory optimization

Combining LLVM IR

Transforming and optimizing loops

Reassociating expressions

Vectorizing IR

Other optimization passes

6. Target-independent Code Generator

6. Target-independent Code Generator

Introduction

The life of an LLVM IR instruction

Visualizing LLVM IR CFG using GraphViz

Describing targets using TableGen

Defining an instruction set

Adding a machine code descriptor

Implementing the MachineInstrBuilder class

Implementing the MachineBasicBlock class

Implementing the MachineFunction class

Writing an instruction selector

Legalizing SelectionDAG

Optimizing SelectionDAG

Selecting instruction from the DAG

Scheduling instructions in SelectionDAG

7. Optimizing the Machine Code

7. Optimizing the Machine Code

Introduction

Eliminating common subexpression from machine code

Analyzing live intervals

Allocating registers

Inserting the prologue-epilogue code

Code emission

Tail call optimization

Sibling call optimisation

8. Writing an LLVM Backend

8. Writing an LLVM Backend

Introduction

Defining registers and registers sets

Defining the calling convention

Defining the instruction set

Implementing frame lowering

Printing an instruction

Selecting an instruction

Adding instruction encoding

Supporting a subtarget

Lowering to multiple instructions

Registering a target

9. Using LLVM for Various Useful Projects

9. Using LLVM for Various Useful Projects

Introduction

Exception handling in LLVM

Using sanitizers

Writing the garbage collector with LLVM

Converting LLVM IR to JavaScript

Using the Clang Static Analyzer

Using bugpoint

Using LLDB

Using LLVM utility passes

Index

Index

Customer Reviews

2 (9)

5 star

22.2%

4 star

0%

3 star

0%

2 star

11.1%

1 star

66.7%

Converting a C source code to LLVM assembly

Here we will convert a C code to intermediate representation in LLVM using the C frontend Clang.

Getting ready

Clang must be installed in the PATH.

How to do it...

Lets create a C code in the multiply.c file, which will look something like the following:
```
$ cat multiply.c
int mult() {
int a =5;
int b = 3;
int c = a * b;
return c;
}
```
Use the following command to generate LLVM IR from the C code:
```
$ clang -emit-llvm -S multiply.c -o multiply.ll
```

Have a look at the generated IR:

$ cat multiply.ll
; ModuleID = 'multiply.c'
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"

; Function Attrs: nounwind uwtable
define i32 @mult() #0 {
  %a = alloca i32, align 4
  %b = alloca i32, align 4
  %c = alloca i32, align 4
  store i32 5, i32* %a, align 4
  store i32 3, i32* %b, align 4
  %1 = load i32* %a, align 4
  %2 = load i32* %b, align 4
  %3 = mul nsw i32 %1, %2
  store i32 %3, i32* %c, align 4
  %4 = load i32* %c, align 4
  ret i32 %4
}

We can also use the cc1 for generating IR:

$ clang -cc1 -emit-llvm testfile.c -o testfile.ll

How it works...

The process of C code getting converted to IR starts with the process of lexing, wherein the C code is broken into a token stream, with each token representing an Identifier, Literal, Operator, and so on. This stream of tokens is fed to the parser, which builds up an abstract syntax tree with the help of Context free grammar (CFG) for the language. Semantic analysis is done afterwards to check whether the code is semantically correct, and then we generate code to IR.

Here we use the Clang frontend to generate the IR file from C code.

See also

In the next chapter, we will see how the lexer and parser work and how code generation is done. To understand the basics of LLVM IR, you can refer to http://llvm.org/docs/LangRef.html.

Visually different images

CONTINUE READING

83

Tech Concepts

36

Programming languages

73

Tech Tools

Unlimited access to the largest independent learning library in tech of over 8,000 expert-authored tech books and videos.

Innovative learning tools, including AI book assistants, code context explainers, and text-to-speech.

50+ new titles added per month and exclusive early access to books as they are being written.

LLVM Cookbook

Search

Your notes and bookmarks