LLVM IRBuilder and pass：2/2.通过llvm提供的api和IRBuilder生成LLVM-IR

最新推荐文章于 2024-04-24 16:42:51 发布

动弹动弹

最新推荐文章于 2024-04-24 16:42:51 发布

阅读量257

点赞数 2

分类专栏： LLVM 文章标签： c++

本文链接：https://blog.csdn.net/qq_43566431/article/details/129697173

版权

LLVM 专栏收录该内容

10 篇文章 11 订阅

订阅专栏

文章目录

7.算术运算语句Arithmetic Statement
8.控制流语句if-else
9.控制流语句if-else-phi
10.控制流语句for
11. 控制流语句while

7.算术运算语句Arithmetic Statement

一个基本的逻辑块（BasicBlock）是由一系列的指令（Instruction）所组成的。一条指令主要是为了完成某个任务（操作），比如一个算术运算操作。为了简单起见，我们在这里可以把一个简单的算术运算语句理解为一条指令。

在LLVM中，一个简单的算舒运算操作需要用到操作符和操作数。例如一个乘法操作用到了一个乘法操作符和两个乘数。所以，要创建爱你一条乘法运算指令，我们首先要得到两个操作数，他们可以来自于函数的参数、数值变量、数值常量等等。乘法操作是一个二元操作，IRBuilder里面提供了很多的API，可以用来方便地创建二元操作指令。

本节，我们就在一个函数里创建一条简单的算术运算指令。

为了简单起见，假定这个函数带有两个整数型参数，他们的名称分别为a 和b。我们把第一个参数乘以3，其结果就是函数的返回值。代码如下（示例）：

// HelloArithmeticStatement.cpp

#include "llvm/IR/BasicBlock.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/GlobalVariable.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("HelloModule", context);

    // Add a global variable
    module->getOrInsertGlobal("helloGlobalVariable", builder.getInt32Ty());
    GlobalVariable* globalVariable = module->getNamedGlobal("helloGlobalVariable");
    globalVariable->setLinkage(GlobalValue::CommonLinkage);
    globalVariable->setAlignment(MaybeAlign(4));

    // Add a function with parameters
    std::vector<Type*> parameters(2, builder.getInt32Ty());
    FunctionType* functionType = FunctionType::get(builder.getInt32Ty(), parameters, false);
    Function* function = Function::Create(functionType, GlobalValue::ExternalLinkage, "HelloFunction", module);

    // Set arguments for the function
    function->getArg(0)->setName("a");
    function->getArg(1)->setName("b");

    // Create a block
    BasicBlock* block = BasicBlock::Create(context, "entry", function);
    builder.SetInsertPoint(block);

    // Create an arithmetic statement
    Value* arg1 = function->getArg(0);
    ConstantInt* three = builder.getInt32(3);
    Value* result = builder.CreateMul(arg1, three, "multiplyResult");

    // Add a return
    builder.CreateRet(result);

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

    return 0;
}

7.1编译

clang++ -O3 HelloArithmeticStatement.cpp -o HelloArithmeticStatement `llvm-config --cflags --ldflags` `llvm-config --libs` `llvm-config --system-libs`

此时在当前路径下生成了一个HelloFunctionArguments的可执行程序

7.2运行
运行HelloArithmeticStatement（示例）:

./HelloArithmeticStatement

输出结果如下（示例）：

; ModuleID = 'HelloModule'
source_filename = "HelloModule"

@helloGlobalVariable = common global i32, align 4

define i32 @HelloFunction(i32 %a, i32 %b) {
entry:
  %multiplyResult = mul i32 %a, 3
  ret i32 %multiplyResult
}

以上的IR代码中，变量%multiplyResult就是乘法运算的结果了，也是函数的返回值。

8.控制流语句if-else

我们知道，一个if-else语句包含了一个条件判断和两个逻辑分支，至于最终会运行哪个分支的代码，取决于条件判断的结果为真还是假。而“条件”则一般是一个比较表达式。

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

// Test.c

int Test(int a)
{
    int b;
    if (a > 33)
    {
        b = 66;
    }
    else
    {
        b = 77;
    }

    return b;
}

上述代码中存在一个可变变量b，当然它也是一个局部变量，我们可以在栈上创建一个可变变量。LLVM IR提供了一个指令，可以让我们在栈上申明变量，即alloca指令。使用方法如下：

%variable.address = alloca i32

LLVM也提供了相应的C++ API用于在栈上申明变量：

AllocaInst * llvm::IRBuilderBase::CreateAlloca(Type * Ty, Value * ArraySize = nullptr, const Twine & Name = "")

注意用alloca指令申明的变量，其实得到的是变量的地址。如果要访问他，我们需要用store和load指令，store指令可以把变量值写入改地址（示例）：

store i32 66, i32* %variable.address, align 4

而load指令则可以把变量值从改地址读取出来（示例）：

%actual.value = load i32, i32* %variable.address, align 4

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

// HelloIfElse.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
    std::vector<Type*> parameters(1, builder.getInt32Ty());
    FunctionType* functionType = FunctionType::get(builder.getInt32Ty(), parameters, false);
    Function* function = Function::Create(functionType, GlobalValue::ExternalLinkage, "Test", module);

    // Add an argument to the function
    Value* arg = function->getArg(0);
    arg->setName("a");

    // Add some basic blocks to the function
    BasicBlock* entryBlock = BasicBlock::Create(context, "entry", function);
    BasicBlock* thenBlock = BasicBlock::Create(context, "if.then", function);
    BasicBlock* elseBlock = BasicBlock::Create(context, "if.else", function);
    BasicBlock* returnBlock = BasicBlock::Create(context, "if.end", function);

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

    // Fill the "entry" block (2):
    //   if (a > 33)
    ConstantInt* value33 = builder.getInt32(33);
    Value* condition = builder.CreateICmpSGT(arg, value33, "compare.result");
    builder.CreateCondBr(condition, thenBlock, elseBlock);

    // Fill the "if.then" block:
    //   b = 66;
    builder.SetInsertPoint(thenBlock);
    ConstantInt* value66 = builder.getInt32(66);
    builder.CreateStore(value66, bPtr);
    builder.CreateBr(returnBlock);

    // Fill the "if.else" block:
    //   b = 77;
    builder.SetInsertPoint(elseBlock);
    ConstantInt* value77 = builder.getInt32(77);
    builder.CreateStore(value77, bPtr);
    builder.CreateBr(returnBlock);

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

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

    return 0;
}

8.1编译

clang++ -O3 HelloIfElse.cpp -o HelloIfElse `llvm-config --cflags --ldflags` `llvm-config --libs` `llvm-config --system-libs`

此时在当前路径下生成了一个HelloIfElse的可执行程序

8.2运行
运行HelloIfElse（示例）:

./HelloIfElse

输出结果如下（示例）：

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

define i32 @Test(i32 %a) {
entry:
  %b.address = alloca i32, align 4
  %compare.result = icmp sgt i32 %a, 33
  br i1 %compare.result, label %if.then, label %if.else

if.then:                                          ; preds = %entry
  store i32 66, i32* %b.address, align 4
  br label %if.end

if.else:                                          ; preds = %entry
  store i32 77, i32* %b.address, align 4
  br label %if.end

if.end:                                           ; preds = %if.else, %if.then
  %return.value = load i32, i32* %b.address, align 4
  ret i32 %return.value
}

9.控制流语句if-else-phi

本节中依然是在处理if-else语句。不过这一次我们用一个特殊的指令来生成IR代码，即phi指令。

一个if-else语句包含了一个条件判断和两个逻辑分支。最终会运行哪个分支的代码，取决于条件判断结果是真还是假。而“条件”则一般是一个比较表达式。

在很多情况下，控制流只是为了给某一个变量赋值，而phi指令，可以根据控制流来选择合适的值。它的用法如下（示例）：

%value = phi i32 [66, %branch1], [77, %branch2], [88, %branch3]

可以看到phi指令可以接收多个输入参数，参数的个数也是不固定的。第一个参数表示的是phi指令的返回值类型，如在以上示例中为i32。接下来的每一个参数都是一个数组，代表了每一个分支及其对应的返回值。例如，如果前一步执行的是branch1分支，则返回值为66；当执行的是branch2，则返回值为77；以此类推…

LLVM也提供了相应的C++API用于创建phi指令：

PHINode * llvm::IRBuilderBase::CreatePHI(Type * Ty, unsigned NumReservedValues, const Twine & Name = "")

以及向phi指令中添加条件返回值：

void llvm::PHINode::addIncoming(Value * V, BasicBlock * BB)

本节，我们利用phi指令来处理简单的if-else控制流语句。

为了简单起见，用一个简单的C函数生成IR代码。C函数如下（示例）：

// Test.c

int Test(int a)
{
    int b;

    if (a > 33)
    {
        b = 66;
    }
    else
    {
        b = 77;
    }

    return b;
}

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

// HelloIfElsePhi.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
    std::vector<Type*> parameters(1, builder.getInt32Ty());
    FunctionType* functionType = FunctionType::get(builder.getInt32Ty(), parameters, false);
    Function* function = Function::Create(functionType, GlobalValue::ExternalLinkage, "Test", module);

    // Add an argument to the function
    Value* arg = function->getArg(0);
    arg->setName("a");

    // Add some basic blocks to the function
    BasicBlock* entryBlock = BasicBlock::Create(context, "entry", function);
    BasicBlock* thenBlock = BasicBlock::Create(context, "if.then", function);
    BasicBlock* elseBlock = BasicBlock::Create(context, "if.else", function);
    BasicBlock* returnBlock = BasicBlock::Create(context, "if.end", function);

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

    // Fill the "entry" block (2):
    //   if (a > 33)
    ConstantInt* value33 = builder.getInt32(33);
    Value* condition = builder.CreateICmpSGT(arg, value33, "compare.result");
    builder.CreateCondBr(condition, thenBlock, elseBlock);

    // Fill the "if.then" block:
    //   b = 66;
    builder.SetInsertPoint(thenBlock);
    ConstantInt* value66 = builder.getInt32(66);
    builder.CreateBr(returnBlock);

    // Fill the "if.else" block:
    //   b = 77;
    builder.SetInsertPoint(elseBlock);
    ConstantInt* value77 = builder.getInt32(77);
    builder.CreateBr(returnBlock);

    // Fill the "if.end" block with phi instruction:
    //   return b;
    builder.SetInsertPoint(returnBlock);
    PHINode* phi = builder.CreatePHI(builder.getInt32Ty(), 2);
    phi->addIncoming(value66, thenBlock);
    phi->addIncoming(value77, elseBlock);
    builder.CreateStore(phi, b);
    Value* returnValue = builder.CreateLoad(b, "return.value");
    builder.CreateRet(returnValue);

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

    return 0;
}

9.1编译

clang++ -O3 HelloIfElsePhi.cpp -o HelloIfElsePhi `llvm-config --cflags --ldflags` `llvm-config --libs` `llvm-config --system-libs`

此时在当前路径下生成了一个HelloIfElsePhi的可执行程序

9.2运行
运行HelloIfElsePhi（示例）:

./HelloIfElsePhi

输出结果如下（示例）：

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

define i32 @Test(i32 %a) {
entry:
  %b.address = alloca i32, align 4
  %compare.result = icmp sgt i32 %a, 33
  br i1 %compare.result, label %if.then, label %if.else

if.then:                                          ; preds = %entry
  br label %if.end

if.else:                                          ; preds = %entry
  br label %if.end

if.end:                                           ; preds = %if.else, %if.then
  %0 = phi i32 [ 66, %if.then ], [ 77, %if.else ]
  store i32 %0, i32* %b.address, align 4
  %return.value = load i32, i32* %b.address, align 4
  ret i32 %return.value
}

10.控制流语句for

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

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

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

//Test.c
int Test(int a)
{
	int b = 0;
	for(int i=0; i<a; i++)
	{
		b = b + i;	
	}
	return b;
}

以下就是我们调用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;
}

10.1编译

clang++ -O3 HelloLoop.cpp -o HelloLoop `llvm-config --cflags --ldflags` `llvm-config --libs` `llvm-config --system-libs`

此时在当前路径下生成了一个HelloIfElsePhi的可执行程序

10.2运行
运行HelloLoop（示例）:

./HelloLoop

输出结果如下（示例）：

; 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
}

11. 控制流语句while

while循环和for循环比较类似，循环的次数取决于判断结果，它们也都用到了比较指令、跳转指令、栈上的变量等。

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

int main(){
	int n = 10;
	return sum(n);
}

int sum(int n){
	int i = 0;
	int sum = 0;
	while(i <= n){
		sum = sum + i;
		i++;
	}
	return sum;
}

以下是我们调用LLVM C++ API 来生成LLVM IR的代码

//HelloWhile.cpp

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

#include <vector>

using namespace llvm;


int main(int argc, char* argv[])
{
    LLVMContext context;

    //create a IRBuilder
    IRBuilder<> builder(context);

    //create a module
    Module* module = new Module("HelloModule", context);

    //create a sum function
    std::vector<Type*> parameters(1, builder.getInt32Ty());
    FunctionType* functionType1 = FunctionType::get(builder.getInt32Ty(), parameters, false);
    Function* function1 = Function::Create(functionType1, GlobalValue::ExternalLinkage, "sum", module); 
    Value* sum_n = function1->getArg(0);
    sum_n->setName("sum_n");


    //create some BasicBlock 
    BasicBlock* entryBlock = BasicBlock::Create(context, "entry.Block", function1);
    BasicBlock* whileConditionBlock = BasicBlock::Create(context, "while.condition", function1);
    BasicBlock* whileBodyBlock = BasicBlock::Create(context, "while.body", function1);

    BasicBlock* whileEndBlock = BasicBlock::Create(context, "while.end", function1);

    //fill the entry block
    //int i = 0;
    //int sum = 0;
    builder.SetInsertPoint(entryBlock);
    Value* iPtr = builder.CreateAlloca(builder.getInt32Ty(), nullptr, "i.address");
    Value* sumPtr = builder.CreateAlloca(builder.getInt32Ty(), nullptr, "sum.address");
    builder.CreateStore(builder.getInt32(0), iPtr);
    builder.CreateStore(builder.getInt32(0), sumPtr);
    builder.CreateBr(whileConditionBlock);

    //fill the while.condition.block
    //while(i<=n)
    builder.SetInsertPoint(whileConditionBlock);
    Value* i0 = builder.CreateLoad(builder.getInt32Ty(),iPtr);
    Value* conditionCmpResult = builder.CreateICmpSLE(i0, sum_n);
    builder.CreateCondBr(conditionCmpResult, whileBodyBlock, whileEndBlock);

    //fill the while.body.block
    //sum = sum + i
    //i++
    builder.SetInsertPoint(whileBodyBlock);
    Value* sum0 = builder.CreateLoad(builder.getInt32Ty(), sumPtr);
    sum0 = builder.CreateAdd(builder.getInt32(1), sum0);
    builder.CreateStore(sum0, sumPtr);

    Value* i1 = builder.CreateLoad(builder.getInt32Ty(), iPtr);
    i1 = builder.CreateAdd(builder.getInt32(1), iPtr);
    builder.CreateStore(i1, iPtr);

    builder.CreateBr(whileConditionBlock);

    //fill the while.end.block
    //return sum
    builder.SetInsertPoint(whileEndBlock);
    Value* sumResult = builder.CreateLoad(builder.getInt32Ty(), sumPtr);
    builder.CreateRet(sumResult);


    //create main function IRbuider

    FunctionType* functionTyp2 = FunctionType::get(builder.getInt32Ty(), false);
    Function* function2 = Function::Create(functionTyp2, GlobalValue::ExternalLinkage, "main", module);

    //create function block
    //  int n = 10
    //  return sum(n)
    BasicBlock* mainBlock = BasicBlock::Create(context, "main.block", function2);

    builder.SetInsertPoint(mainBlock);
    Value* nPtr = builder.CreateAlloca(builder.getInt32Ty(), nullptr, "n.address");
    Value* n0 = builder.CreateStore(builder.getInt32(10), nPtr);

    Value* MainReturn = builder.CreateCall(function1, n0);
    builder.CreateRet(MainReturn);


    //print the IR
    verifyFunction(*function1);
    verifyFunction(*function2);
    module->print(outs(), nullptr);

    return 0;
}

上述代码中出现了函数调用builder.CreateCall()，第一个参数是函数名，第二个参数是传参。

11.1编译

clang++ -O3 HelloWhile.cpp -o HelloWhile `llvm-config --cflags --ldflags` `llvm-config --libs` `llvm-config --system-libs`

此时在当前路径下生成了一个HelloIfElsePhi的可执行程序

11.2运行
运行HelloWhile（示例）:

./HelloWhile

输出结果如下（示例）：

; ModuleID = 'HelloModule'
source_filename = "HelloModule"

define i32 @sum(i32 %sum_n) {
entry.Block:
  %i.address = alloca i32, align 4
  %sum.address = alloca i32, align 4
  store i32 0, ptr %i.address, align 4
  store i32 0, ptr %sum.address, align 4
  br label %while.condition

while.condition:                                  ; preds = %while.body, %entry.Block
  %0 = load i32, ptr %i.address, align 4
  %1 = icmp sle i32 %0, %sum_n
  br i1 %1, label %while.body, label %while.end

while.body:                                       ; preds = %while.condition
  %2 = load i32, ptr %sum.address, align 4
  %3 = add i32 1, %2
  store i32 %3, ptr %sum.address, align 4
  %4 = load i32, ptr %i.address, align 4
  %5 = add i32 1, ptr %i.address
  store i32 %5, ptr %i.address, align 4
  br label %while.condition

while.end:                                        ; preds = %while.condition
  %6 = load i32, ptr %sum.address, align 4
  ret i32 %6
}

define i32 @main() {
main.block:
  %n.address = alloca i32, align 4
  store i32 10, ptr %n.address, align 4
  %0 = call i32 @sum(void <badref>)
  ret i32 %0
}

动弹动弹

关注

2
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
LLVM IRBuilder and pass：2/2.通过llvm提供的api和IRBuilder生成LLVM-IR

所以，要创建爱你一条乘法运算指令，我们首先要得到两个操作数，他们可以来自于函数的参数、数值变量、数值常量等等。接下来的每一个参数都是一个数组，代表了每一个分支及其对应的返回值。我们知道，一个if-else语句包含了一个条件判断和两个逻辑分支，至于最终会运行哪个分支的代码，取决于条件判断的结果为真还是假。while循环和for循环比较类似，循环的次数取决于判断结果，它们也都用到了比较指令、跳转指令、栈上的变量等。以上的IR代码中，变量%multiplyResult就是乘法运算的结果了，也是函数的返回值。
复制链接

扫一扫