LLVM示例使用简介
什么是LLVM？
编译器？
什么是LLVM？
● 编译器？
● 一组格式、库和工具。
什么是LLVM？
● 编译器？
● 一组格式、库和工具。
–一个简单的、键入的IR（位代码）
–程序分析/优化库
–机器代码生成库
–组成库以执行任务的工具
什么是LLVM？
● 编译器？
● 一组格式、库和工具。
–一个简单的、键入的IR（位代码）
–程序分析/优化库
–机器代码生成库
–组成库以执行任务的工具
● 易于添加/删除/更改的功能
你将如何使用它？
● 将程序编译为位代码：
clang -g -c -emit-llvm -o .bc
你将如何使用它？
● 将程序编译为位代码：
clang -g -c -emit-llvm -o .bc
● 正在分析位代码：
opt -load .so -- -analyze .bc
你将如何使用它？
● 将程序编译为位代码：
clang -g -c -emit-llvm -o .bc
● 正在分析位代码：
opt -load .so -- -analyze .bc
报告程序的属性：
[main] : [A], [C], [F]
[A] : [B]
[C] : [E], [D]
什么是LLVM比特码？
● A（相对）简单的IR
代码：
#include
void foo(unsigned e)
{
for (unsigned i = 0; i < e; ++i)
{
printf("Hello\n");
}
}
int main(int argc, char **argv)
{
foo(argc);
return 0;
}
使用clang -c -emit-llvm (and llvm-dis)，生成对应代码的IR：
@str = private constant [6 x i8] c"Hello\00"
define void @foo(i32 %e) {
%1 = icmp eq i32 %e, 0
br i1 %1, label %._crit_edge, label %.lr.ph
.lr.ph: ; preds = %.lr.ph, %0
%i = phi i32 [ %2, %.lr.ph ], [ 0, %0 ]
%str1 = getelementptr
[6 x i8]* @str, i64 0, i64 0
%puts = tail call i32 @puts(i8* %str1)
%2 = add i32 %i, 1
%cond = icmp eq i32 %2, %e
br i1 %cond, label %.exit, label %.lr.ph
.exit: ; preds = %.lr.ph, %0
ret void
}
define i32 @main(i32 %argc, i8** %argv) {
tail call void @foo(i32 %argc)
ret i32 0
}
什么是LLVM比特码？
● A（相对）简单的IR
#include<stdio.h>
void
foo(unsigned e) {
for (unsigned i = 0; i < e; ++i) {
printf("Hello\n");
}
}
int
main(int argc, char **argv) {
foo(argc);
return 0;
}
使用clang -c -emit-llvm (and llvm-dis)，生成对应的IR：
@str = private constant [6 x i8] c"Hello\00"
define void @foo(i32 %e) {
%1 = icmp eq i32 %e, 0
br i1 %1, label %._crit_edge, label %.lr.ph
.lr.ph: ; preds = %.lr.ph, %0
%i = phi i32 [ %2, %.lr.ph ], [ 0, %0 ]
%str1 = getelementptr
[6 x i8]* @str, i64 0, i64 0
%puts = tail call i32 @puts(i8* %str1)
%2 = add i32 %i, 1
%cond = icmp eq i32 %2, %e
br i1 %cond, label %.exit, label %.lr.ph
.exit: ; preds = %.lr.ph, %0
ret void
}
define i32 @main(i32 %argc, i8** %argv) {
tail call void @foo(i32 %argc)
ret i32 0
}
什么是LLVM比特码？
● A（相对）简单的IR
#include<stdio.h>
void
foo(unsigned e) {
for (unsigned i = 0; i < e; ++i) {
printf("Hello\n");
}
}
int
main(int argc, char **argv) {
foo(argc);
return 0;
}
生成IR：
@str = private constant [6 x i8] c"Hello\00"
define void @foo(i32 %e) {
%1 = icmp eq i32 %e, 0
br i1 %1, label %._crit_edge, label %.lr.ph
.lr.ph: ; preds = %.lr.ph, %0
%i = phi i32 [ %2, %.lr.ph ], [ 0, %0 ]
%str1 = getelementptr
[6 x i8]* @str, i64 0, i64 0
%puts = tail call i32 @puts(i8* %str1)
%2 = add i32 %i, 1
%cond = icmp eq i32 %2, %e
br i1 %cond, label %.exit, label %.lr.ph
.exit: ; preds = %.lr.ph, %0
ret void
}
define i32 @main(i32 %argc, i8** %argv) {
tail call void @foo(i32 %argc)
ret i32 0
}
什么是LLVM比特码？
● A（相对）简单的IR
#include<stdio.h>
void
foo(unsigned e) {
for (unsigned i = 0; i < e; ++i) {
printf("Hello\n");
}
}
int
main(int argc, char **argv) {
foo(argc);
return 0;
}
生成基本块：
@str = private constant [6 x i8] c"Hello\00"
define void @foo(i32 %e) {
%1 = icmp eq i32 %e, 0
br i1 %1, label %._crit_edge, label %.lr.ph
.lr.ph: ; preds = %.lr.ph, %0
%i = phi i32 [ %2, %.lr.ph ], [ 0, %0 ]
%str1 = getelementptr
[6 x i8]* @str, i64 0, i64 0
%puts = tail call i32 @puts(i8* %str1)
%2 = add i32 %i, 1
%cond = icmp eq i32 %2, %e
br i1 %cond, label %.exit, label %.lr.ph
.exit: ; preds = %.lr.ph, %0
ret void
}
define i32 @main(i32 %argc, i8** %argv) {
tail call void @foo(i32 %argc)
ret i32 0
}
#include<stdio.h>
void
foo(unsigned e) {
for (unsigned i = 0; i < e; ++i) {
printf("Hello\n");
}
}
int
main(int argc, char **argv) {
foo(argc);
return 0;
}
基本块
标签和前置
@str = private constant [6 x i8] c"Hello\00"
define void @foo(i32 %e) {
%1 = icmp eq i32 %e, 0
br i1 %1, label %._crit_edge, label %.lr.ph
.lr.ph: ; preds = %.lr.ph, %0
%i = phi i32 [ %2, %.lr.ph ], [ 0, %0 ]
%str1 = getelementptr
[6 x i8]* @str, i64 0, i64 0
%puts = tail call i32 @puts(i8* %str1)
%2 = add i32 %i, 1
%cond = icmp eq i32 %2, %e
br i1 %cond, label %.exit, label %.lr.ph
.exit: ; preds = %.lr.ph, %0
ret void
}
define i32 @main(i32 %argc, i8** %argv) {
tail call void @foo(i32 %argc)
ret i32 0
}
示例：
#include<stdio.h>
void
foo(unsigned e) {
for (unsigned i = 0; i < e; ++i) {
printf("Hello\n");
}
}
int
main(int argc, char **argv) {
foo(argc);
return 0;
}
生成基本块，标签和前置
@str = private constant [6 x i8] c"Hello\00"
define void @foo(i32 %e) {
%1 = icmp eq i32 %e, 0
br i1 %1, label %._crit_edge, label %.lr.ph
.lr.ph: ; preds = %.lr.ph, %0
%i = phi i32 [ %2, %.lr.ph ], [ 0, %0 ]
%str1 = getelementptr
[6 x i8]* @str, i64 0, i64 0
%puts = tail call i32 @puts(i8* %str1)
%2 = add i32 %i, 1
%cond = icmp eq i32 %2, %e
br i1 %cond, label %.exit, label %.lr.ph
.exit: ; preds = %.lr.ph, %0
ret void
}
define i32 @main(i32 %argc, i8** %argv) {
tail call void @foo(i32 %argc)
ret i32 0
}
示例：
#include<stdio.h>
void
foo(unsigned e) {
for (unsigned i = 0; i < e; ++i) {
printf("Hello\n");
}
}
int
main(int argc, char **argv) {
foo(argc);
return 0;
}
生成指令集：
@str = private constant [6 x i8] c"Hello\00"
define void @foo(i32 %e) {
%1 = icmp eq i32 %e, 0
br i1 %1, label %._crit_edge, label %.lr.ph
.lr.ph: ; preds = %.lr.ph, %0
%i = phi i32 [ %2, %.lr.ph ], [ 0, %0 ]
%str1 = getelementptr
[6 x i8]* @str, i64 0, i64 0
%puts = tail call i32 @puts(i8* %str1)
%2 = add i32 %i, 1
%cond = icmp eq i32 %2, %e
br i1 %cond, label %.exit, label %.lr.ph
.exit: ; preds = %.lr.ph, %0
ret void
}
define i32 @main(i32 %argc, i8** %argv) {
tail call void @foo(i32 %argc)
ret i32 0
}
检查比特码
● LLVM库有助于检查位代码
–易于检查和/或操作
检查比特码
● LLVM库有助于检查位代码
–易于检查和/或操作
–许多助手（例如CallSite、outs（）、dyn_cast）
Module &module = ...;
for (Function &fun : module) {
for (BasicBlock &bb : fun) {
for (Instruction &i : bb) {
CallSite cs(&i);
if (!cs.getInstruction()) {
continue;
}
...
CallSite可帮助从Call和I nvoke指令中提取信息。
检查比特码
● LLVM库有助于检查位代码
–易于检查和/或操作
–许多助手（例如CallSite、outs（）、dyn_cast）
Module &module = ...;
for (Function &fun : module) {
for (BasicBlock &bb : fun) {
for (Instruction &i : bb) {
CallSite cs(&i);
if (!cs.getInstruction()) {
continue;
}
outs() << "Found a function call: " << i << "\n";
...
检查比特码
● LLVM库有助于检查位代码
–易于检查和/或操作
–许多助手（例如CallSite、outs（）、dyn_cast）
Module &module = ...;
for (Function &fun : module) {
for (BasicBlock &bb : fun) {
for (Instruction &i : bb) {
CallSite cs(&i);
if (!cs.getInstruction()) {
continue;
}
outs() << "Found a function call: " << i << "\n";
Value *called = cs.getCalledValue()->stripPointerCasts();
if (Function *f = dyn_cast<Function>(called)) {
outs() << "Direct call to function: " << f->getName() << "\n";
...
dyn_cast（）有效地检查LLVM IR组件的运行时类型。
处理SSA
● 你可能会问某些价值观是从哪里来的
–有助于跟踪相关性
–“这个变量是在哪里定义的？”
处理SSA
● 你可能会问某些价值观是从哪里来的
● LLVM IR为SSA形式
–一行中可以包含多少个首字母缩略词？
–这意味着什么？
–为什么这很重要？
处理SSA
● 你可能会问某些价值观是从哪里来的
● LLVM IR为SSA形式
–一行中可以包含多少个首字母缩略词？
–这意味着什么？
–为什么这很重要？
void foo()
unsigned i = 0;
while (i < 10) {
i = i + 1;
}
}
处理SSA
● 你可能会问某些价值观是从哪里来的
● LLVM IR为SSA形式
–一行中可以包含多少个首字母缩略词？
–这意味着什么？
–为什么这很重要？
void foo()
unsigned i = 0;
while (i < 10) {
i = i + 1;
}
}
在这一点上，i的唯一定义是什么？
处理SSA
● 因此phi指令
–它选择要使用的定义
–始终处于基本块的开头
处理SSA
● 因此phi指令
–它选择要使用的定义
–始终处于基本块的开头
void foo()
unsigned i = 0;
while (i < 10) {
i = i + 1;
}
}
define void @foo() {
br label %1
; <label>:1 ; preds = %1, %0
%i.phi = phi i32 [ 0, %0 ], [ %2, %1 ]
%2 = add i32 %i.phi, 1
%exitcond = icmp eq i32 %2, 10
br i1 %exitcond, label %3, label %1
; <label>:3 ; preds = %1
ret void
}
void foo()
unsigned i = 0;
while (i < 10) {
i = i + 1;
}
}
define void @foo() {
br label %1
; <label>:1 ; preds = %1, %0
%i.phi = phi i32 [ 0, %0 ], [ %2, %1 ]
%2 = add i32 %i.phi, 1
%exitcond = icmp eq i32 %2, 10
br i1 %exitcond, label %3, label %1
; <label>:3 ; preds = %1
ret void
}
一般依赖项
● 可以循环指令使用的值
for (auto i = inst->op_begin(), e = inst->op_end(); i != e; ++i) {
// inst uses the Value i
}
一般依赖项
● 可以循环指令使用的值
for (auto i = inst->op_begin(), e = inst->op_end(); i != e; ++i) {
// inst uses the Value i
}
for %a = %b + %c:
[%b, %c]
一般依赖项
● 可以循环指令使用的值
for (auto i = inst->op_begin(), e = inst->op_end(); i != e; ++i) {
// inst uses the Value i
}
● 可以循环使用使用特定值的指令
Instruction *inst = ...;
for (auto i = inst->use_begin(), e = inst->use_end(); i != e; ++i)
if (auto *user = dyn_cast<Instruction>(*i)) {
// inst is used by Instruction user
}
处理类型
● LLVM IR是强类型的
–每个值都有一个类型→ getType（）
处理类型
● LLVM IR是强类型的
–每个值都有一个类型→ getType（）
● 值必须显式转换为新类型
define i64 @trunc(i16 zeroext %a) {
%1 = zext i16 %a to i64
ret i64 %1
}
处理类型
● LLVM IR是强类型的
–每个值都有一个类型→ getType（）
● 值必须显式转换为新类型
define i64 @trunc(i16 zeroext %a) {
%1 = zext i16 %a to i64
ret i64 %1
}
处理类型
● LLVM IR是强类型的
–每个值都有一个类型→ getType（）
● 值必须显式转换为新类型
define i64 @trunc(i16 zeroext %a) {
%1 = zext i16 %a to i64
ret i64 %1
}
● 还有指针、数组、结构等的类型。
–打字能力强意味着他们需要更多的工作
处理类型：GEP
● 有时需要提取元素/字段
来自数组/结构
–指针算术
–使用GetElementPointer（GEP）完成
struct rec {
int x;
int y;
};
struct rec *buf;
void foo() {
buffer[5].y = 7;
}
%struct.rec = type { i32, i32 }
@buf = global %struct.rec* null
define void @foo() {
%1 = load %struct.rec** @buf
%2 = getelementptr %struct.rec* %1, i64 5, i32 1
store i32 7, i32* %2
ret void
}
struct rec {
int x;
int y;
};
struct rec *buf;
void foo() {
buffer[5].y = 7;
}
%struct.rec = type { i32, i32 }
@buf = global %struct.rec* null
define void @foo() {
%1 = load %struct.rec** @buf
%2 = getelementptr %struct.rec* %1, i64 5, i32 1
store i32 7, i32* %2
ret void
}
在哪里可以获得信息？
● 在线文档内容丰富：
–LLVM程序员手册
–LLVM语言参考手册
● 头文件！
– All in llvm-3.x.src/include/llvm/
Function.h
BasicBlock.h
Instructions.h
InstrTypes.h
Support/CallSite.h
Support/InstVisitor.h
Type.h
DerivedTypes.h
进行新的分析
● 分析分为各个环节
–模块pass
–FunctionPass
–LoopPass
–…
源自
适当的基类
Pass
3个步骤
1） 申报pass
2） 注册pass
3） 定义pass
制作ModulePass（1）
● 声明ModulePass
struct CallPrinterPass : public llvm::ModulePass {
static char ID;
DenseMap<Function*, uint64_t> counts;
CallPrinterPass()
: ModulePass(ID)
{ }
virtual bool runOnModule(Module &m) override;
virtual void print(raw_ostream &out, const Module *m) const override;
void handleInstruction(CallSite cs);
};
struct CallPrinterPass : public llvm::ModulePass {
static char ID;
DenseMap<Function*, uint64_t> counts;
CallPrinterPass()
: ModulePass(ID)
{ }
virtual bool runOnModule(Module &m) override;
virtual void print(raw_ostream &out, const Module *m) const override;
void handleInstruction(CallSite cs);
};
制作模块pass（3）
● 定义模块pass
–需要覆盖runOnModule（）和print（）
bool
CallPrinterPass::runOnModule(Module &m) {
for (auto &f : m)
for (auto &bb : f)
for (auto &i : bb)
handleInstruction(&i);
return false; // False because we didn't change the Module
}
制作模块pass（3）
● 分析继续。。。
void
CallPrinterPass::handleInstruction(CallSite cs) {
// Check whether the instruction is actually a call
if (!cs.getInstruction()) { return; }
// Check whether the called function is directly invoked
auto called = cs.getCalledValue()->stripPointerCasts();
auto fun = dyn_cast<Function>(called);
if (!fun) { return; }
// Update the count for the particular call
auto count = counts.find(fun);
if (counts.end() == count) {
count = counts.insert(std::make_pair(fun, 0)).first;
}
++count->second;
}
制作模块pass（3）
● 打印出结果
void
CallPrinterPass::print(raw_ostream &out, const Module *m) const {
out << "Function Counts\n"
<< "===============\n";
for (auto &kvPair : counts) {
auto *function = kvPair.first;
uint64_t count = kvPair.second;
out << function->getName() << " : " << count << "\n";
}
}
把它们放在一起
● LLVM组织pass和工具组
进入项目
● 最简单的开始方法是使用他们的样本
项目
–llvmsrc/projects/sample
● 在大多数情况下，可以按照
在线指导和项目说明
把它们放在一起
● LLVM组织pass和工具组
进入项目
● 最简单的开始方法是使用他们的样本
项目
–llvmsrc/projects/sample关于创建项目的说明
● 发布在网上，在自己的时间阅读：
–构建
● 将示例项目复制到新目录<proj>
● 为生成<projbuild>创建另一个目录
● <proj>/configure--禁用优化--启用调试
–带有clang=/path/to/clang
–自定义
● 在<proj>/lib/sample中构建整个项目/
● 删除现有的源代码，改为在那里编写模块
● 将这些行添加到库目录中的Makefile中：
LOADABLE_MODULE=1
CPPFLAGS+=-std=c++11
● 在大多数情况下，可以按照
在线指导和项目说明
额外提示
● 有一个指针指向某个东西。它是什么？
–getName（）方法适用于大多数情况。
–通常可以：out（）<<X
● 如何看待的C++API调用
构建模块？
– llc -march=cpp .bc -o .cpp