LLVM核心库入门指南：实践解析

LLVM

PDF

需积分: 13 94 浏览量更新于2024-07-17 收藏 18.5MB PDF 举报

身份认证购VIP最低享 7 折!

30元优惠券

"Getting Started with LLVM Core Libraries" 是一本实践指南，旨在帮助读者理解LLVM核心库，通过源代码参考和片段、编译器阶段之间的连接分析、重要数据结构的描述以及如何使用LLVM提供的工具来深入学习LLVM框架。这本书面向对LLVM感兴趣的爱好者、计算机科学学生和编译器工程师，要求读者具备C++背景，了解一些编译器理论（但非必须）。无论你是初学者还是经验丰富的编译专家，这本书都提供了一个实用的LLVM入门，避免了复杂的场景。主要内容中提到，作者Bruno Cardoso Lopes和Rafael Auler通过本书引导读者掌握LLVM的基本要素，并利用核心库构建高级工具。书中包含丰富的实际操作示例，鼓励读者亲自尝试，以便更好地理解和应用所学知识。 LLVM是一个开源的编译器基础设施项目，由一系列库组成，支持多语言、跨平台的编译、优化和代码生成。它最初设计用于替代GCC，但后来发展成为一套广泛使用的编译器工具链，用于各种软件开发任务，包括静态分析、动态调试和代码优化。通过学习本书，你可以了解到： 1. LLVM的基本概念：了解LLVM架构，包括前端（frontend）、中间表示（IR，Intermediate Representation）和后端（backend）。 2. 中间表示IR：学习LLVM IR语言，它是LLVM进行优化的基础，理解其语法和结构。 3. 编译器阶段：探索编译过程的不同阶段，如词法分析、语法分析、语义分析、优化和代码生成，以及这些阶段在LLVM中的实现。 4. 数据结构：理解LLVM中重要的数据结构，如基本块（Basic Block）、指令（Instruction）、函数（Function）和模块（Module）等。 5. 工具使用：学习如何使用LLVM工具集，如Clang（C/C++/Objective-C前端）、Opt（静态优化工具）和LLVM Disassembler（反汇编器）等。 6. 实践案例：通过书中给出的示例代码和练习，动手实践LLVM编程，加深对LLVM的理解和应用能力。 "Getting Started with LLVM Core Libraries" 是一个全面了解和学习LLVM的起点，无论你是想要开发新的编译器特性，还是希望通过LLVM进行性能优化，这本书都将提供宝贵的指导和资源。

资源详情

资源推荐

Preface

LLVM is an inspiring software project that started with the passion for compilers of a

single person, Chris Lattner. The events that followed the rst versions of LLVM and

how it became widely adopted later reveal a pattern that may be observed across the

history of other successful open source projects: they did not start within a company,

but instead they are the product of simple human curiosity with respect to a given

subject. For example, the rst Linux kernel was the result of a Finnish student being

intrigued by the area of operating systems and being motivated to understand and

see in practice how a real operating system should work.

For Linux or LLVM, the contribution of many other programmers matured and

leveraged the project to a rst-class software that rivals, in quality, any other

established competitor. It is unfair, therefore, to attribute the success of any big

project to a single person. However, in the open source community, the leap from

a student's project to an incredibly complex yet robust software depends on a key

factor: attracting contributors and programmers who enjoy spending their time on

the project.

Schools create a fascinating atmosphere because education involves the art of teaching

people how things work. For these people, the feeling of unraveling how intricate

mechanisms work and surpassing the state of being puzzled to nally mastering them

is full of victory and overcoming. In this environment, at the University of Illinois at

Urbana-Champaign (UIUC), the LLVM project grew by being used both as a research

prototype and as a teaching framework for compiler classes lectured by Vikram Adve,

Lattner's Master's advisor. Students contributed to the rst bug reports, setting in

motion the LLVM trajectory as a well-designed and easy-to-study piece of software.

Preface

[ 2 ]

The blatant disparity between software theory and practice befuddles many Computer

Science students. A clean and simple concept in computing theory may involve

so many levels of implementation details such that they disguise real-life software

projects to become simply too complex for the human mind to grasp, especially all of

its nuances. A clever design with powerful abstractions is the key to aid the human

brain to navigate all the levels of a project: from the high-level view, which implements

how the program works in a broader sense, to the lowest level of detail.

This is particularly true for compilers. Students who have a great passion to learn

how compilers work often face a tough challenge when it comes to understanding

the factual compiler implementation. Before LLVM, GCC was one of the few open

source options for hackers and curious students to learn how a real compiler is

implemented, despite the theory taught in schools.

However, a software project reects, in its purest sense, the view of the programmers

who created it. This happens through the abstractions employed to distinguish

modules and data representation across several components. Programmers may

have different views about the same topic. In this way, old and large software

bases such as GCC, which is almost 30 years old, frequently embody a collection of

different views of different generation of programmers, which makes the software

increasingly difcult for newer programmers and curious observers to understand.

The LLVM project not only attracted experienced compiler programmers, but also a

lot of young and curious minds that saw in it a much cleaner and simpler hackable

piece of software, which represented a compiler with a lot of potential. This was

clearly observed by the incredible number of scientic papers that chose LLVM as a

prototype to do research. The reason is simple; in academia, students are frequently

in charge of the practical aspects of the implementation, and thus, it is of paramount

importance for research projects that the student be able to master its experimental

framework code base. Seduced by its newer design using the C++ language (instead

of C used in GCC), modularity (instead of the monolithic structure of GCC), and

concepts that map more easily to the theory being taught in modern compiler

courses, many researchers found it easy to hack LLVM in order to implement their

ideas, and they were successful. The success of LLVM in academia, therefore, was a

consequence of this reduced gap between theory and practice.

Preface

[ 3 ]

Beyond an experimental framework for scientic research, the LLVM project also

attracted industry interest due to its considerably more liberal license in comparison

with the GPL license of GCC. As a project that grew in academia, a big frustration

for researchers who write code is the fear that it will only be used for a single

experiment and be immediately discarded afterwards. To ght this fate, Chris

Lattner, in his Master's project at UIUC that gave birth to LLVM, decided to license

the project under the University of Illinois/NCSA Open Source License, allowing its

use, commercial or not, as long as the copyright notice is maintained. The goal was

to maximize LLVM adoption, and this goal was fullled with honor. In 2012, LLVM

was awarded the ACM Software System Award, a highly distinguished recognition

of notable software that contributed to science.

Many companies embraced the LLVM project with different necessities and performed

different contributions, widening the range of languages that an LLVM-based

compiler can operate with as well as the range of machines for which the compiler

is able to generate code. This new phase of the project provided an unprecedented

level of maturity to the library and tools, allowing it to permanently leave the state

of experimental academia software to enter the status of a robust framework used in

commercial products. With this, the name of the project also changed from Low Level

Virtual Machine to the acronym LLVM.

The decision to retire the name Low Level Virtual Machine in favor of just LLVM

reects the change of goals of the project across its history. As a Master's project,

LLVM was created as a framework to study lifelong program optimizations.

These ideas were initially published in a 2003 MICRO (International Symposium

on Microarchitecture) paper entitled LLVA: A Low-level Virtual Instruction Set

Architecture, describing its instruction set, and in a 2004 CGO (International

Symposium on Code Generation and Optimization) paper entitled LLVM: A

Compilation Framework for Lifelong Program Analysis & Transformation.

Outside of an academic context, LLVM became a well-designed compiler with the

interesting property of writing its intermediate representation to disk. In commercial

systems, it was never truly used as a virtual machine such as the Java Virtual

Machine (JVM), and thus, it made little sense to continue with the Low Level Virtual

Machine name. On the other hand, some other curious names remained as a legacy.

The le on the disk that stores a program in the LLVM intermediate representation

is referred to as the LLVM bitcode, a parody of the Java bytecode, as a reference to

the amount of space necessary to represent programs in the LLVM intermediate

representation versus the Java one.

Preface

[ 4 ]

Our goal in writing this book is twofold. First, since the LLVM project grew a lot,

we want to present it to you in small pieces, a component at a time, making it as

simple as possible to understand while providing you with the joy of working with

a powerful compiler library. Second, we want to evoke the spirit of an open source

hacker, inspiring you to go far beyond the concepts presented here and never stop

expanding your knowledge.

Happy hacking!

What this book covers

Chapter 1, Build and Install LLVM, will show you how to install the Clang/LLVM

package on Linux, Windows, or Mac, including a discussion about building LLVM

on Visual Studio and Xcode. It will also discuss the different avors of LLVM

distributions and discuss which distribution is best for you: pre-built binaries,

distribution packages, or source codes.

Chapter 2, External Projects, will present external LLVM projects that live in separate

packages or repositories, such as extra Clang tools, the DragonEgg GCC plugin, the

LLVM debugger (LLDB), and the LLVM test suite.

Chapter 3, Tools and Design, will explain how the LLVM project is organized in

different tools, working out an example on how to use them to go from source

code to assembly language. It will also present how the compiler driver works, and

nally, how to write your very rst LLVM tool.

Chapter 4, The Frontend, will present the LLVM compiler frontend, the Clang project.

It will walk you through all the steps of the frontend while explaining how to write

small programs that use each part of the frontend as it is presented. It nishes by

explaining how to write a small compiler driver with Clang libraries.

Chapter 5, The LLVM Intermediate Representation, will explain a crucial part of the

LLVM design: its intermediate representation. It will show you what characteristics

make it special, present its syntax, structure, and how to write a tool that generates

the LLVM IR.

Chapter 6, The Backend, will introduce you to the LLVM compiler backend, responsible

for translating the LLVM IR to machine code. This chapter will walk you through all

the backend steps and provide you with the knowledge to create your own LLVM

backend. It nishes by showing you how to create a backend pass.

Preface

[ 5 ]

Chapter 7, The Just-in-Time Compiler, will explain the LLVM Just-in-Time compilation

infrastructure, which allows you to generate and execute machine code on demand.

This technology is essential in applications where the program source code is only

known at runtime, such as JavaScript interpreters in Internet browsers. This chapter

walks you through the steps to use the right libraries in order to create your own

JIT compiler.

Chapter 8, Cross-platform Compilation, will guide you through the steps for

Clang/LLVM to create programs for other platforms such as ARM-based ones.

This involves conguring the right environment to correctly compile programs

that will run outside the environment where they were compiled.

Chapter 9, The Clang Static Analyzer, will present a powerful tool for discovering

bugs in large source code bases without even running the program, but simply by

analyzing the code. This chapter will also show you how to extend the Clang Static

Analyzer with your own bug checkers.

Chapter 10, Clang Tools with LibTooling, will present the LibTooling framework and

a series of Clang tools that are built upon this library, which allow you to perform

source code refactoring or simply analyze the source code in an easy way. This

chapter nishes by showing you how to write your own C++ source code refactoring

tool by using this library.

At the time of this writing, LLVM 3.5 had not been released. While this book

focuses on LLVM Version 3.4, we plan to release an appendix updating the

examples in this book to LLVM 3.5 by the third week of September 2014, allowing

you to exercise the content of the book with the newest versions of LLVM. This

appendix will be available at https://www.packtpub.com/sites/default/files/

downloads/6924OS_Appendix.pdf.

What you need for this book

To begin exploring the world of LLVM, you can use a UNIX system, a Mac OS X

system, or a Windows system, as long as they are equipped with a modern C++

compiler. The LLVM source code is very demanding on the C++ compiler used to

compile it and uses the newest standards. This means that on Linux, you will need

at least GCC 4.8.1; on Max OS X, you will need at least Xcode 5.1; and on Windows,

you will need Visual Studio 2012.

Even though we explain how to build LLVM on Windows with Visual Studio, this

book does not focus on this platform because some LLVM features are unavailable

for it. For example, LLVM lacks loadable module support on Windows, but we show

you how to write LLVM plugins that are built as shared libraries. In these cases, the

only way to see this in practice is to use either Linux or Mac OS X.

剩余313页未读，继续阅读

就不呵呵呵

粉丝: 31
资源: 93

LLVM核心库入门指南：实践解析

Getting Started with LLVM Core Libraries.2014

Getting Started with LLVM Core Libraries.zip

interface of llvm investigation

centos7 clang-tidy

LLVM每日谈之三 如何创建一个LLVM工程

llvm安装方式_LLVM安装

llvm 测试套件交叉编译

llvm框架/llvm编译流程/clang前端/llvm ir/llvm应用与实践

如何添加在llvm中添加llvm pass

cmake链接llvm

llvm::Value

RuntimeError: llvm-config failed executing, please point LLVM_CONFIG to the path for llvm-config error: command '/home/maotouying/v_python/spec/bin/python3.7' failed with exit code 1

VSCode配置LLVM环境

Ubuntu上llvm安装

centos安装llvm-config

llvm cookbook 中文版

llvm编译器实战教程

llvm解析AST树

llvm官方文档 中文

最新资源

LLVM每日谈之三如何创建一个LLVM工程

llvm官方文档中文