LLVM Cookbook

Book Image

LLVM Cookbook

Book Image

LLVM Cookbook

Overview of this book

LLVM Cookbook

Credits

About the Authors

About the Authors

About the Reviewers

About the Reviewers

www.PacktPub.com

www.PacktPub.com

Preface

Free Chapter

LLVM Design and Use

LLVM Design and Use

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

Steps in Writing a Frontend

Steps in Writing a Frontend

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

Extending the Frontend and Adding JIT Support

Extending the Frontend and Adding JIT Support

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

Preparing Optimizations

Preparing Optimizations

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

Implementing Optimizations

Implementing Optimizations

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

Other optimization passes

Target-independent Code Generator

Target-independent Code Generator

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

Optimizing the Machine Code

Optimizing the Machine Code

Eliminating common subexpression from machine code

Analyzing live intervals

Allocating registers

Inserting the prologue-epilogue code

Tail call optimization

Sibling call optimisation

Writing an LLVM Backend

Writing an LLVM Backend

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

Using LLVM for Various Useful Projects

Using LLVM for Various Useful Projects

Exception handling in LLVM

Using sanitizers

Writing the garbage collector with LLVM

Converting LLVM IR to JavaScript

Using the Clang Static Analyzer

Using LLVM utility passes

Index

Customer Reviews

5 star

0

4 star

0

3 star

0

2 star

0

1 star

0

Converting LLVM bitcode back to LLVM assembly

In this recipe, you will convert LLVM bitcode back to LLVM IR. Well, this is actually possible using the LLVM disassembler tool called llvm-dis.

Getting ready

To do this, you need the llvm-dis tool installed.

How to do it...

To see how the bitcode file is getting converted to IR, use the test.bc file generated in the recipe Converting IR to LLVM Bitcode. The test.bc file is provided as the input to the llvm-dis tool. Now proceed with the following steps:

Using the following command shows how to convert a bitcode file to an the one we had created in the IR file:
```
$ llvm-dis test.bc –o test.ll
```
Have a look at the generated LLVM IR by the following:
```
| $ cat test.ll
; ModuleID = 'test.bc'

define i32 @mult(i32 %a, i32 %b) #0 {
  %1 = mul nsw i32 %a, %b
  ret i32 %1
}
```
The output test.ll file is the same as the one we created in the recipe Converting IR to LLVM Bitcode.

How it works...

The llvm-dis command is the LLVM disassembler. It takes an LLVM bitcode file and converts it into LLVM assembly language.

Here, the input file is test.bc, which is transformed to test.ll by llvm-dis.

If the filename is omitted, llvm-dis reads its input from standard input.