-
Notifications
You must be signed in to change notification settings - Fork 1
/
chapter02-9.cpp
103 lines (89 loc) · 3.32 KB
/
chapter02-9.cpp
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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
#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;
LLVMContext Context;
static Module *ModuleOb = new Module("my compiler", Context);
static std::vector<std::string> FunArgs;
typedef SmallVector<BasicBlock*, 16> BBList;
typedef SmallVector<Value*, 16> ValList;
Function *createFunc(IRBuilder<> &Builder, std::string Name) {
std::vector<Type *> Integers(FunArgs.size(), Type::getInt32Ty(Context));
FunctionType *funcType =
llvm::FunctionType::get(Builder.getInt32Ty(),Integers, false);
Function *fooFunc = llvm::Function::Create(
funcType, llvm::Function::ExternalLinkage, Name, ModuleOb);
return fooFunc;
}
void setFuncArgs(Function *fooFunc, std::vector<std::string> FunArgs) {
unsigned Idx = 0;
Function::arg_iterator AI, AE;
for(AI = fooFunc->arg_begin(), AE = fooFunc->arg_end(); AI != AE;
++AI, ++Idx)
AI->setName(FunArgs[Idx]);
}
BasicBlock *createBB(Function *fooFunc, std::string Name) {
return BasicBlock::Create(Context, Name, fooFunc);
}
GlobalVariable *createGlob(IRBuilder<> &Builder, std::string Name) {
ModuleOb->getOrInsertGlobal(Name, Builder.getInt32Ty());
GlobalVariable *gVar = ModuleOb->getNamedGlobal(Name);
gVar->setLinkage(GlobalValue::CommonLinkage);
gVar->setAlignment(4);
return gVar;
}
Value *createArith(IRBuilder<> &Builder, Value *L, Value *R) {
return Builder.CreateMul(L, R, "multmp");
}
Value *createLoop(IRBuilder<> &Builder, BBList List, ValList VL,
Value *StartVal, Value *EndVal) {
BasicBlock *PreheaderBB = Builder.GetInsertBlock();
Value *val = VL[0];
BasicBlock *LoopBB = List[0];
Builder.CreateBr(LoopBB);
Builder.SetInsertPoint(LoopBB);
PHINode *IndVar = Builder.CreatePHI(Type::getInt32Ty(Context), 2, "i");
IndVar->addIncoming(StartVal, PreheaderBB);
Value *Add = Builder.CreateAdd(val, Builder.getInt32(5), "addtmp");
Value *StepVal = Builder.getInt32(1);
Value *NextVal = Builder.CreateAdd(IndVar, StepVal, "nextval");
Value *EndCond = Builder.CreateICmpULT(IndVar, EndVal, "endcond");
EndCond = Builder.CreateICmpNE(EndCond, Builder.getInt32(0), "loopcond");
BasicBlock *LoopEndBB = Builder.GetInsertBlock();
BasicBlock *AfterBB = List[1];
Builder.CreateCondBr(EndCond, LoopBB, AfterBB);
Builder.SetInsertPoint(AfterBB);
IndVar->addIncoming(NextVal, LoopEndBB);
return Add;
}
int main(int argc, char *argv[])
{
FunArgs.push_back("a");
FunArgs.push_back("b");
static IRBuilder<> Builder(Context);
GlobalVariable *gVar = createGlob(Builder, "x");
Function *fooFunc = createFunc(Builder, "foo");
setFuncArgs(fooFunc, FunArgs);
BasicBlock *entry = createBB(fooFunc, "entry");
Builder.SetInsertPoint(entry);
Function::arg_iterator AI = fooFunc->arg_begin();
Value *Arg1 = AI++;
Value *Arg2 = AI;
Value *constant = Builder.getInt32(16);
Value *val = createArith(Builder, Arg1, constant);
ValList VL;
VL.push_back(Arg1);
BBList List;
BasicBlock *LoopBB = createBB(fooFunc, "loop");
BasicBlock *AfterBB = createBB(fooFunc, "afterloop");
List.push_back(LoopBB);
List.push_back(AfterBB);
Value *StartVal = Builder.getInt32(1);
Value *Res = createLoop(Builder, List, VL, StartVal, Arg2);
Builder.CreateRet(Res);
verifyFunction(*fooFunc);
ModuleOb->print(llvm::outs(), nullptr);
return 0;
}