使用Flex Bison 和LLVM编写自己的编译器[zz]

01.

#include<stack>

02.

#include<llvm/Module.h>

03.

#include<llvm/Function.h>

04.

#include<llvm/PassManager.h>

05.

#include<llvm/CallingConv.h>

06.

#include<llvm/Bitcode/ReaderWriter.h>

07.

#include<llvm/Analysis/Verifier.h>

08.

#include<llvm/Assembly/PrintModulePass.h>

09.

#include<llvm/Support/IRBuilder.h>

10.

#include<llvm/ModuleProvider.h>

11.

#include<llvm/ExecutionEngine/GenericValue.h>

12.

#include<llvm/ExecutionEngine/JIT.h>

13.

#include<llvm/Support/raw_ostream.h>

14.

15.

using

namespace

llvm;

16.

17.

class

NBlock;

18.

19.

class

CodeGenBlock{

20.

public

:

21.

BasicBlock*block;

22.

std::map<std::string,Value*>locals;

23.

};

24.

25.

class

CodeGenContext{

26.

std::stack<codegenblock*>blocks;

27.

Function*mainFunction;

28.

29.

public

:

30.

Module*module;

31.

CodeGenContext(){module=

new

Module(

"main"

);}

32.

33.

void

generateCode(NBlock&root);

34.

GenericValuerunCode();

35.

std::map<std::string,Value*>&locals(){

return

blocks.top()->locals;}

36.

BasicBlock*currentBlock(){

return

blocks.top()->block;}

37.

void

pushBlock(BasicBlock*block){blocks.push(

new

CodeGenBlock());blocks.top()->block=block;}

38.

void

popBlock(){CodeGenBlock*top=blocks.top();blocks.pop();

delete

top;}

39.

};

001.

#include"node.h"

002.

#include"codegen.h"

003.

#include"parser.hpp"

004.

005.

using

namespace

std;

006.

007.

/*CompiletheASTintoamodule*/

008.

void

CodeGenContext::generateCode(NBlock&root)

009.

{

010.

std::cout<<

"Generatingcode...\n"

;

011.

012.

/*Createthetoplevelinterpreterfunctiontocallasentry*/

013.

vector<

const

type*>argTypes;

014.

FunctionType*ftype=FunctionType::get(Type::VoidTy,argTypes,

false

);

015.

mainFunction=Function::Create(ftype,GlobalValue::InternalLinkage,

"main"

,module);

016.

BasicBlock*bblock=BasicBlock::Create(

"entry"

,mainFunction,0);

017.

018.

/*Pushanewvariable/blockcontext*/

019.

pushBlock(bblock);

020.

root.codeGen(*

this

);

/*
emitbytecodeforthetoplevelblock*/

021.

ReturnInst::Create(bblock);

022.

popBlock();

023.

024.

/*Printthebytecodeinahuman-readableformat

025.

toseeifourprogramcompiledproperly

026.

*/

027.

std::cout<<

"Codeisgenerated.\n"

;

028.

PassManagerpm;

029.

pm.add(createPrintModulePass(&outs()));

030.

pm.run(*module);

031.

}

032.

033.

/*ExecutestheASTbyrunningthemainfunction*/

034.

GenericValueCodeGenContext::runCode(){

035.

std::cout<<

"Runningcode...\n"

;

036.

ExistingModuleProvider*mp=

new

ExistingModuleProvider(module);

037.

ExecutionEngine*ee=ExecutionEngine::create(mp,

false

);

038.

vector<genericvalue>noargs;

039.

GenericValuev=ee->runFunction(mainFunction,noargs);

040.

std::cout<<

"Codewasrun.\n"

;

041.

return

v;

042.

}

043.

044.

/*ReturnsanLLVMtypebasedontheidentifier*/

045.

static

const

Type*typeOf(

const

NIdentifier&type)

046.

{

047.

if

(type.name.compare(

"int"

)
==0){

048.

return

Type::Int64Ty;

049.

}

050.

else

if

(type.name.compare(

"double"

)==0){

051.

return

Type::FP128Ty;

052.

}

053.

return

Type::VoidTy;

054.

}

055.

056.

/*--CodeGeneration--*/

057.

058.

Value*NInteger::codeGen(CodeGenContext&context)

059.

{

060.

std::cout<<

"Creatinginteger:"

<<value<<endl;

061.

return

ConstantInt::get(Type::Int64Ty,value,

true

);

062.

}

063.

064.

Value*NDouble::codeGen(CodeGenContext&context)

065.

{

066.

std::cout<<

"Creatingdouble:"

<<value<<endl;

067.

return

ConstantFP::get(Type::FP128Ty,value);

068.

}

069.

070.

Value*NIdentifier::codeGen(CodeGenContext&context)

071.

{

072.

std::cout<<

"Creatingidentifierreference:"

<<name<<endl;

073.

if

(context.locals().find(name)==context.locals().end())
{

074.

std::cerr<<

"undeclaredvariable"

<<name<<endl;

075.

return

NULL;

076.

}

077.

return

new

LoadInst(context.locals()[name],

""

,

false

,context.currentBlock());

078.

}

079.

080.

Value*NMethodCall::codeGen(CodeGenContext&context)

081.

{

082.

Function*function=context.module->getFunction(id.name.c_str());

083.

if

(function==NULL){

084.

std::cerr<<

"nosuchfunction"

<<id.name<<endl;

085.

}

086.

std::vector<value*>args;

087.

ExpressionList::const_iteratorit;

088.

for

(it=arguments.begin();it!=arguments.end();it++){

089.

args.push_back((**it).codeGen(context));

090.

}

091.

CallInst*call=CallInst::Create(function,args.begin(),args.end(),

""

,context.currentBlock());

092.

std::cout<<

"Creatingmethodcall:"

<<id.name<<endl;

093.

return

call;

094.

}

095.

096.

Value*NBinaryOperator::codeGen(CodeGenContext&context)

097.

{

098.

std::cout<<

"Creatingbinaryoperation"

<<op<<endl;

099.

Instruction::BinaryOpsinstr;

100.

switch

(op){

101.

case

TPLUS:instr=Instruction::Add;

goto

math;

102.

case

TMINUS:instr=Instruction::Sub;

goto

math;

103.

case

TMUL:instr=Instruction::Mul;

goto

math;

104.

case

TDIV:instr=Instruction::SDiv;

goto

math;

105.

106.

/*TODOcomparison*/

107.

}

108.

109.

return

NULL;

110.

math:

111.

return

BinaryOperator::Create(instr,lhs.codeGen(context),

112.

rhs.codeGen(context),

""

,context.currentBlock());

113.

}

114.

115.

Value*NAssignment::codeGen(CodeGenContext&context)

116.

{

117.

std::cout<<

"Creatingassignmentfor"

<<lhs.name<<endl;

118.

if

(context.locals().find(lhs.name)==context.locals().end())
{

119.

std::cerr<<

"undeclaredvariable"

<<lhs.name<<endl;

120.

return

NULL;

121.

}

122.

return

new

StoreInst(rhs.codeGen(context),context.locals()[lhs.name],

false

,context.currentBlock());

123.

}

124.

125.

Value*NBlock::codeGen(CodeGenContext&context)

126.

{

127.

StatementList::const_iteratorit;

128.

Value*last=NULL;

129.

for

(it=statements.begin();it!=statements.end();it++){

130.

std::cout<<

"Generatingcodefor"

<<

typeid

(**it).name()<<endl;

131.

last=(**it).codeGen(context);

132.

}

133.

std::cout<<

"Creatingblock"

<<endl;

134.

return

last;

135.

}

136.

137.

Value*NExpressionStatement::codeGen(CodeGenContext&context)

138.

{

139.

std::cout<<

"Generatingcodefor"

<<

typeid

(expression).name()<<endl;

140.

return

expression.codeGen(context);

141.

}

142.

143.

Value*NVariableDeclaration::codeGen(CodeGenContext&context)

144.

{

145.

std::cout<<

"Creatingvariabledeclaration"

<<type.name<<

""

<<id.name<<endl;

146.

AllocaInst*alloc=

new

AllocaInst(typeOf(type),id.name.c_str(),context.currentBlock());

147.

context.locals()[id.name]=alloc;

148.

if

(assignmentExpr!=NULL){

149.

NAssignmentassn(id,*assignmentExpr);

150.

assn.codeGen(context);

151.

}

152.

return

alloc;

153.

}

154.

155.

Value*NFunctionDeclaration::codeGen(CodeGenContext&context)

156.

{

157.

vector<

const

type*>argTypes;

158.

VariableList::const_iteratorit;

159.

for

(it=arguments.begin();it!=arguments.end();it++){

160.

argTypes.push_back(typeOf((**it).type));

161.

}

162.

FunctionType*ftype=FunctionType::get(typeOf(type),argTypes,

false

);

163.

Function*function=Function::Create(ftype,GlobalValue::InternalLinkage,id.name.c_str(),context.module);

164.

BasicBlock*bblock=BasicBlock::Create(

"entry"

,function,0);

165.

166.

context.pushBlock(bblock);

167.

168.

for

(it=arguments.begin();it!=arguments.end();it++){

169.

(**it).codeGen(context);

170.

}

171.

172.

block.codeGen(context);

173.

ReturnInst::Create(bblock);

174.

175.

context.popBlock();

176.

std::cout<<

"Creatingfunction:"

<<id.name<<endl;

177.

return

function;

178.

}

01.

#include<iostream>

02.

#include"codegen.h"

03.

#include"node.h"

04.

05.

using

namespace

std;

06.

07.

extern

int

yyparse();

08.

extern

NBlock*programBlock;

09.

10.

int

main(

int

argc,

char

**argv)

11.

{

12.

yyparse();

13.

std::cout<<programBlock<<endl;

14.

15.

CodeGenContextcontext;

16.

context.generateCode(*programBlock);

17.

context.runCode();

18.

19.

return

0;

20.

}

all:parser

clean:
rmparser.cppparser.hppparsertokens.cpp

parser.cpp:parser.y
bison-d-o$@$^

parser.hpp:parser.cpp

tokens.cpp:tokens.lparser.hpp
lex-o$@$^

parser:parser.cppcodegen.cppmain.cpptokens.cpp
g++-o$@`llvm-config--libscorejitnative--cxxflags--ldflags`*.cpp

$echo'intdo_math(inta){intx=a*5+3}do_math(10)'|./parser
0x100a00f10
Generatingcode...
Generatingcodefor20NFunctionDeclaration
Creatingvariabledeclarationinta
Generatingcodefor20NVariableDeclaration
Creatingvariabledeclarationintx
Creatingassignmentforx
Creatingbinaryoperation276
Creatingbinaryoperation274
Creatinginteger:3
Creatinginteger:5
Creatingidentifierreference:a
Creatingblock
Creatingfunction:do_math
Generatingcodefor20NExpressionStatement
Generatingcodefor11NMethodCall
Creatinginteger:10
Creatingmethodcall:do_math
Creatingblock
Codeisgenerated.
;ModuleID='main'

defineinternalvoid@main(){
entry:
%0=calli64@do_math(i6410)		;[#uses=0]
retvoid
}

defineinternali64@do_math(i64){
entry:
%a=allocai64		;[#uses=1]
%x=allocai64		;[#uses=1]
%1=addi645,3	;[#uses=1]
%2=loadi64*%a	;[#uses=1]
%3=muli64%2,%1	;[#uses=1]
storei64%3,i64*%x
retvoid
}
Runningcode...
Codewasrun.