系列文章目录

LLVM系列第一章：编译LLVM源码
LLVM系列第二章：模块Module
LLVM系列第三章：函数Function
LLVM系列第四章：逻辑代码块Block
LLVM系列第五章：全局变量Global Variable
LLVM系列第六章：函数返回值Return
LLVM系列第七章：函数参数Function Arguments
LLVM系列第八章：算术运算语句Arithmetic Statement
LLVM系列第九章：控制流语句if-else
LLVM系列第十章：控制流语句if-else-phi
LLVM系列第十一章：写一个Hello World
LLVM系列第十二章：写一个简单的词法分析器Lexer
LLVM系列第十三章：写一个简单的语法分析器Parser
LLVM系列第十四章：写一个简单的语义分析器Semantic Analyzer
LLVM系列第十五章：写一个简单的中间代码生成器IR Generator
LLVM系列第十六章：写一个简单的编译器
LLVM系列第十七章：for循环
LLVM系列第十八章：写一个简单的IR处理流程Pass

---

---

前言

在此记录下用LLVM创建控制流语句(for循环语句)的过程，以备查阅。

开发环境的配置请参考第一章 《LLVM系列第一章：编译LLVM源码》。

我们知道，一个for语句包含了条件判断以及循环执行的任务。具体循环多少次，取决于条件判断的结果。而“条件”则包含了循环的起点、终止条件、步进长度。

这里的for循环语句IR，其实跟前面章节的if-else语句有些相似的地方。它们都需要用到比较指令、跳转指令、栈上的变量等。

本章，我们就来创建简单的for控制流语句。

一、Hello For Loop

为简单起见，我就来为以下这个简单的C函数生成IR代码（示例）：

// Test.c

int Test(int a)
{
    int b = 0;

    for (int i = 0; i < a; i++)
    {
        b = b + i;
    }

    return b;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

这里有个可变变量b，我们可以用alloca 指令在栈上申明一个局部变量b。注意用alloca 指令申明的变量，其实得到是变量的地址。如果要访问它，我们需要用store和load指令。关于这两个指令的用法，请参考前面章节。

以下就是我们调用LLVM C++ API来生成IR的代码（示例）：

// HelloLoop.cpp

#include "llvm/IR/Function.h"
#include "llvm/IR/IRBuilder.h"
#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/Verifier.h"

#include <vector>

using namespace llvm;

int main(int argc, char* argv[])
{
    LLVMContext context;
    IRBuilder<> builder(context);

    // Create a module
    Module* module = new Module("Test.c", context);

    // Add a function with argument
    //   int Test(int a)
    std::vector<Type*> parameters(1, builder.getInt32Ty());
    FunctionType* functionType = FunctionType::get(builder.getInt32Ty(), parameters, false);
    Function* function = Function::Create(functionType, GlobalValue::ExternalLinkage, "Test", module);
    Value* a = function->getArg(0);
    a->setName("a");

    // Add some basic blocks to the function
    BasicBlock* entryBlock = BasicBlock::Create(context, "entry", function);
    BasicBlock* forConditionBlock = BasicBlock::Create(context, "for.condition", function);
    BasicBlock* forBodyBlock = BasicBlock::Create(context, "for.body", function);
    BasicBlock* forIncrementBlock = BasicBlock::Create(context, "for.increment", function);
    BasicBlock* forEndBlock = BasicBlock::Create(context, "for.end", function);

    // Fill the "entry" block (1):
    //   int b = 0;
    builder.SetInsertPoint(entryBlock);
    Value* bPtr = builder.CreateAlloca(builder.getInt32Ty(), nullptr, "b.address");
    builder.CreateStore(builder.getInt32(1), bPtr);

    // Fill the "entry" block (2):
    //   for (int i = 0; ...)
    Value* iPtr = builder.CreateAlloca(builder.getInt32Ty(), nullptr, "i.address");
    builder.CreateStore(builder.getInt32(0), iPtr);
    builder.CreateBr(forConditionBlock);

    // Fill the "for.condition" block:
    //   for (... i < a; ...)
    builder.SetInsertPoint(forConditionBlock);
    Value* i0 = builder.CreateLoad(iPtr);
    Value* forConditionCompare = builder.CreateICmpSLT(i0, a, "for.condition.compare.result");
    builder.CreateCondBr(forConditionCompare, forBodyBlock, forEndBlock);

    // Fill the "for.body" block:
    //   b = b + i;
    builder.SetInsertPoint(forBodyBlock);
    Value* b0 = builder.CreateLoad(bPtr);
    Value* i1 = builder.CreateLoad(iPtr);
    Value* addResult = builder.CreateAdd(b0, i1, "add.result");
    builder.CreateStore(addResult, bPtr);
    builder.CreateBr(forIncrementBlock);

    // Fill the "for.increment" block:
    //   for (... i++)
    builder.SetInsertPoint(forIncrementBlock);
    Value* i2 = builder.CreateLoad(iPtr);
    Value* incrementedI = builder.CreateAdd(i2, builder.getInt32(1), "i.incremented");
    builder.CreateStore(incrementedI, iPtr);
    builder.CreateBr(forConditionBlock);

    // Fill the "for.end" block:
    //   return b;
    builder.SetInsertPoint(forEndBlock);
    Value* returnValue = builder.CreateLoad(bPtr, "return.value");
    builder.CreateRet(returnValue);

    // Print the IR
    verifyFunction(*function);
    module->print(outs(), nullptr);

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

二、编译

用clang++进行编译（示例）：

# Set up C++ standard library and header path
export SDKROOT=$(xcrun --sdk macosx --show-sdk-path)

# Compile
clang++ -w -o HelloLoop `llvm-config --cxxflags --ldflags --system-libs --libs core` HelloLoop.cpp
1
2
3
4
5

以上命令会生成一个名为HelloLoop的可执行程序。

三、运行

运行HelloLoop（示例）：

./HelloLoop
1

输出结果如下（示例）：

; ModuleID = 'Test.c'
source_filename = "Test.c"

define i32 @Test(i32 %a) {
entry:
  %b.address = alloca i32, align 4
  store i32 1, i32* %b.address, align 4
  %i.address = alloca i32, align 4
  store i32 0, i32* %i.address, align 4
  br label %for.condition

for.condition:                                    ; preds = %for.increment, %entry
  %0 = load i32, i32* %i.address, align 4
  %for.condition.compare.result = icmp slt i32 %0, %a
  br i1 %for.condition.compare.result, label %for.body, label %for.end

for.body:                                         ; preds = %for.condition
  %1 = load i32, i32* %b.address, align 4
  %2 = load i32, i32* %i.address, align 4
  %add.result = add i32 %1, %2
  store i32 %add.result, i32* %b.address, align 4
  br label %for.increment

for.increment:                                    ; preds = %for.body
  %3 = load i32, i32* %i.address, align 4
  %i.incremented = add i32 %3, 1
  store i32 %i.incremented, i32* %i.address, align 4
  br label %for.condition

for.end:                                          ; preds = %for.condition
  %return.value = load i32, i32* %b.address, align 4
  ret i32 %return.value
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

四、总结

我们用LLVM提供的C++ API，创建了简单的for循环语句，并打印出了它的IR代码。完整源码示例请参看：
https://github.com/wuzhanglin/llvm-IR-examples