X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;ds=sidebyside;f=examples%2FKaleidoscope%2FOrc%2Finitial%2Ftoy.cpp;h=662c871904cedffd212bb3db833cd73a0fce10f8;hb=fc85502bf60ee6d47d570580611502aee3a34651;hp=8716f09915e8c06b7977ffe937a44789386d2ef2;hpb=eddb26303b1810f1b2e3d0dbc02687374525600a;p=oota-llvm.git diff --git a/examples/Kaleidoscope/Orc/initial/toy.cpp b/examples/Kaleidoscope/Orc/initial/toy.cpp index 8716f09915e..662c871904c 100644 --- a/examples/Kaleidoscope/Orc/initial/toy.cpp +++ b/examples/Kaleidoscope/Orc/initial/toy.cpp @@ -1,23 +1,28 @@ #include "llvm/Analysis/Passes.h" #include "llvm/ExecutionEngine/Orc/CompileUtils.h" #include "llvm/ExecutionEngine/Orc/IRCompileLayer.h" +#include "llvm/ExecutionEngine/Orc/LambdaResolver.h" #include "llvm/ExecutionEngine/Orc/LazyEmittingLayer.h" #include "llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h" #include "llvm/IR/DataLayout.h" #include "llvm/IR/DerivedTypes.h" #include "llvm/IR/IRBuilder.h" +#include "llvm/IR/LegacyPassManager.h" #include "llvm/IR/LLVMContext.h" #include "llvm/IR/Module.h" #include "llvm/IR/Verifier.h" -#include "llvm/PassManager.h" #include "llvm/Support/TargetSelect.h" #include "llvm/Transforms/Scalar.h" #include -#include +#include +#include #include +#include #include #include + using namespace llvm; +using namespace llvm::orc; //===----------------------------------------------------------------------===// // Lexer @@ -33,14 +38,14 @@ enum Token { // primary tok_identifier = -4, tok_number = -5, - + // control tok_if = -6, tok_then = -7, tok_else = -8, tok_for = -9, tok_in = -10, - + // operators tok_binary = -11, tok_unary = -12, - + // var definition tok_var = -13 }; @@ -89,11 +94,11 @@ static int gettok() { // Comment until end of line. do LastChar = getchar(); while (LastChar != EOF && LastChar != '\n' && LastChar != '\r'); - + if (LastChar != EOF) return gettok(); } - + // Check for end of file. Don't eat the EOF. if (LastChar == EOF) return tok_eof; @@ -113,13 +118,13 @@ class IRGenContext; /// ExprAST - Base class for all expression nodes. struct ExprAST { virtual ~ExprAST() {} - virtual Value* IRGen(IRGenContext &C) = 0; + virtual Value *IRGen(IRGenContext &C) const = 0; }; /// NumberExprAST - Expression class for numeric literals like "1.0". struct NumberExprAST : public ExprAST { NumberExprAST(double Val) : Val(Val) {} - Value* IRGen(IRGenContext &C) override; + Value *IRGen(IRGenContext &C) const override; double Val; }; @@ -127,17 +132,17 @@ struct NumberExprAST : public ExprAST { /// VariableExprAST - Expression class for referencing a variable, like "a". struct VariableExprAST : public ExprAST { VariableExprAST(std::string Name) : Name(std::move(Name)) {} - Value* IRGen(IRGenContext &C) override; + Value *IRGen(IRGenContext &C) const override; std::string Name; }; /// UnaryExprAST - Expression class for a unary operator. struct UnaryExprAST : public ExprAST { - UnaryExprAST(char Opcode, std::unique_ptr Operand) + UnaryExprAST(char Opcode, std::unique_ptr Operand) : Opcode(std::move(Opcode)), Operand(std::move(Operand)) {} - Value* IRGen(IRGenContext &C) override; + Value *IRGen(IRGenContext &C) const override; char Opcode; std::unique_ptr Operand; @@ -146,10 +151,10 @@ struct UnaryExprAST : public ExprAST { /// BinaryExprAST - Expression class for a binary operator. struct BinaryExprAST : public ExprAST { BinaryExprAST(char Op, std::unique_ptr LHS, - std::unique_ptr RHS) + std::unique_ptr RHS) : Op(Op), LHS(std::move(LHS)), RHS(std::move(RHS)) {} - Value* IRGen(IRGenContext &C) override; + Value *IRGen(IRGenContext &C) const override; char Op; std::unique_ptr LHS, RHS; @@ -161,7 +166,7 @@ struct CallExprAST : public ExprAST { std::vector> Args) : CalleeName(std::move(CalleeName)), Args(std::move(Args)) {} - Value* IRGen(IRGenContext &C) override; + Value *IRGen(IRGenContext &C) const override; std::string CalleeName; std::vector> Args; @@ -172,7 +177,7 @@ struct IfExprAST : public ExprAST { IfExprAST(std::unique_ptr Cond, std::unique_ptr Then, std::unique_ptr Else) : Cond(std::move(Cond)), Then(std::move(Then)), Else(std::move(Else)) {} - Value* IRGen(IRGenContext &C) override; + Value *IRGen(IRGenContext &C) const override; std::unique_ptr Cond, Then, Else; }; @@ -185,7 +190,7 @@ struct ForExprAST : public ExprAST { : VarName(std::move(VarName)), Start(std::move(Start)), End(std::move(End)), Step(std::move(Step)), Body(std::move(Body)) {} - Value* IRGen(IRGenContext &C) override; + Value *IRGen(IRGenContext &C) const override; std::string VarName; std::unique_ptr Start, End, Step, Body; @@ -198,8 +203,8 @@ struct VarExprAST : public ExprAST { VarExprAST(BindingList VarBindings, std::unique_ptr Body) : VarBindings(std::move(VarBindings)), Body(std::move(Body)) {} - - Value* IRGen(IRGenContext &C) override; + + Value *IRGen(IRGenContext &C) const override; BindingList VarBindings; std::unique_ptr Body; @@ -213,12 +218,12 @@ struct PrototypeAST { : Name(std::move(Name)), Args(std::move(Args)), IsOperator(IsOperator), Precedence(Precedence) {} - Function* IRGen(IRGenContext &C); + Function *IRGen(IRGenContext &C) const; void CreateArgumentAllocas(Function *F, IRGenContext &C); bool isUnaryOp() const { return IsOperator && Args.size() == 1; } bool isBinaryOp() const { return IsOperator && Args.size() == 2; } - + char getOperatorName() const { assert(isUnaryOp() || isBinaryOp()); return Name[Name.size()-1]; @@ -236,7 +241,7 @@ struct FunctionAST { std::unique_ptr Body) : Proto(std::move(Proto)), Body(std::move(Body)) {} - Function* IRGen(IRGenContext &C); + Function *IRGen(IRGenContext &C) const; std::unique_ptr Proto; std::unique_ptr Body; @@ -262,7 +267,7 @@ static std::map BinopPrecedence; static int GetTokPrecedence() { if (!isascii(CurTok)) return -1; - + // Make sure it's a declared binop. int TokPrec = BinopPrecedence[CurTok]; if (TokPrec <= 0) return -1; @@ -270,14 +275,14 @@ static int GetTokPrecedence() { } template -std::unique_ptr ErrorU(const char *Str) { - fprintf(stderr, "Error: %s\n", Str); +std::unique_ptr ErrorU(const std::string &Str) { + std::cerr << "Error: " << Str << "\n"; return nullptr; } template -T* ErrorP(const char *Str) { - fprintf(stderr, "Error: %s\n", Str); +T* ErrorP(const std::string &Str) { + std::cerr << "Error: " << Str << "\n"; return nullptr; } @@ -288,12 +293,12 @@ static std::unique_ptr ParseExpression(); /// ::= identifier '(' expression* ')' static std::unique_ptr ParseIdentifierExpr() { std::string IdName = IdentifierStr; - + getNextToken(); // eat identifier. - + if (CurTok != '(') // Simple variable ref. return llvm::make_unique(IdName); - + // Call. getNextToken(); // eat ( std::vector> Args; @@ -313,7 +318,7 @@ static std::unique_ptr ParseIdentifierExpr() { // Eat the ')'. getNextToken(); - + return llvm::make_unique(IdName, std::move(Args)); } @@ -330,7 +335,7 @@ static std::unique_ptr ParseParenExpr() { auto V = ParseExpression(); if (!V) return nullptr; - + if (CurTok != ')') return ErrorU("expected ')'"); getNextToken(); // eat ). @@ -340,29 +345,29 @@ static std::unique_ptr ParseParenExpr() { /// ifexpr ::= 'if' expression 'then' expression 'else' expression static std::unique_ptr ParseIfExpr() { getNextToken(); // eat the if. - + // condition. auto Cond = ParseExpression(); if (!Cond) return nullptr; - + if (CurTok != tok_then) return ErrorU("expected then"); getNextToken(); // eat the then - + auto Then = ParseExpression(); if (!Then) return nullptr; - + if (CurTok != tok_else) return ErrorU("expected else"); - + getNextToken(); - + auto Else = ParseExpression(); if (!Else) return nullptr; - + return llvm::make_unique(std::move(Cond), std::move(Then), std::move(Else)); } @@ -373,26 +378,26 @@ static std::unique_ptr ParseForExpr() { if (CurTok != tok_identifier) return ErrorU("expected identifier after for"); - + std::string IdName = IdentifierStr; getNextToken(); // eat identifier. - + if (CurTok != '=') return ErrorU("expected '=' after for"); getNextToken(); // eat '='. - - + + auto Start = ParseExpression(); if (!Start) return nullptr; if (CurTok != ',') return ErrorU("expected ',' after for start value"); getNextToken(); - + auto End = ParseExpression(); if (!End) return nullptr; - + // The step value is optional. std::unique_ptr Step; if (CurTok == ',') { @@ -401,11 +406,11 @@ static std::unique_ptr ParseForExpr() { if (!Step) return nullptr; } - + if (CurTok != tok_in) return ErrorU("expected 'in' after for"); getNextToken(); // eat 'in'. - + auto Body = ParseExpression(); if (Body) return nullptr; @@ -414,7 +419,7 @@ static std::unique_ptr ParseForExpr() { std::move(Step), std::move(Body)); } -/// varexpr ::= 'var' identifier ('=' expression)? +/// varexpr ::= 'var' identifier ('=' expression)? // (',' identifier ('=' expression)?)* 'in' expression static std::unique_ptr ParseVarExpr() { getNextToken(); // eat the var. @@ -424,7 +429,7 @@ static std::unique_ptr ParseVarExpr() { // At least one variable name is required. if (CurTok != tok_identifier) return ErrorU("expected identifier after var"); - + while (1) { std::string Name = IdentifierStr; getNextToken(); // eat identifier. @@ -433,31 +438,31 @@ static std::unique_ptr ParseVarExpr() { std::unique_ptr Init; if (CurTok == '=') { getNextToken(); // eat the '='. - + Init = ParseExpression(); if (!Init) return nullptr; } - + VarBindings.push_back(VarExprAST::Binding(Name, std::move(Init))); - + // End of var list, exit loop. if (CurTok != ',') break; getNextToken(); // eat the ','. - + if (CurTok != tok_identifier) return ErrorU("expected identifier list after var"); } - + // At this point, we have to have 'in'. if (CurTok != tok_in) return ErrorU("expected 'in' keyword after 'var'"); getNextToken(); // eat 'in'. - + auto Body = ParseExpression(); if (!Body) return nullptr; - + return llvm::make_unique(std::move(VarBindings), std::move(Body)); } @@ -487,7 +492,7 @@ static std::unique_ptr ParseUnary() { // If the current token is not an operator, it must be a primary expr. if (!isascii(CurTok) || CurTok == '(' || CurTok == ',') return ParsePrimary(); - + // If this is a unary operator, read it. int Opc = CurTok; getNextToken(); @@ -503,21 +508,21 @@ static std::unique_ptr ParseBinOpRHS(int ExprPrec, // If this is a binop, find its precedence. while (1) { int TokPrec = GetTokPrecedence(); - + // If this is a binop that binds at least as tightly as the current binop, // consume it, otherwise we are done. if (TokPrec < ExprPrec) return LHS; - + // Okay, we know this is a binop. int BinOp = CurTok; getNextToken(); // eat binop - + // Parse the unary expression after the binary operator. auto RHS = ParseUnary(); if (!RHS) return nullptr; - + // If BinOp binds less tightly with RHS than the operator after RHS, let // the pending operator take RHS as its LHS. int NextPrec = GetTokPrecedence(); @@ -526,7 +531,7 @@ static std::unique_ptr ParseBinOpRHS(int ExprPrec, if (!RHS) return nullptr; } - + // Merge LHS/RHS. LHS = llvm::make_unique(BinOp, std::move(LHS), std::move(RHS)); } @@ -539,7 +544,7 @@ static std::unique_ptr ParseExpression() { auto LHS = ParseUnary(); if (!LHS) return nullptr; - + return ParseBinOpRHS(0, std::move(LHS)); } @@ -549,10 +554,10 @@ static std::unique_ptr ParseExpression() { /// ::= unary LETTER (id) static std::unique_ptr ParsePrototype() { std::string FnName; - + unsigned Kind = 0; // 0 = identifier, 1 = unary, 2 = binary. unsigned BinaryPrecedence = 30; - + switch (CurTok) { default: return ErrorU("Expected function name in prototype"); @@ -578,7 +583,7 @@ static std::unique_ptr ParsePrototype() { FnName += (char)CurTok; Kind = 2; getNextToken(); - + // Read the precedence if present. if (CurTok == tok_number) { if (NumVal < 1 || NumVal > 100) @@ -588,23 +593,23 @@ static std::unique_ptr ParsePrototype() { } break; } - + if (CurTok != '(') return ErrorU("Expected '(' in prototype"); - + std::vector ArgNames; while (getNextToken() == tok_identifier) ArgNames.push_back(IdentifierStr); if (CurTok != ')') return ErrorU("Expected ')' in prototype"); - + // success. getNextToken(); // eat ')'. - + // Verify right number of names for operator. if (Kind && ArgNames.size() != Kind) return ErrorU("Invalid number of operands for operator"); - + return llvm::make_unique(FnName, std::move(ArgNames), Kind != 0, BinaryPrecedence); } @@ -643,13 +648,11 @@ static std::unique_ptr ParseExtern() { //===----------------------------------------------------------------------===// // FIXME: Obviously we can do better than this -std::string GenerateUniqueName(const char *root) -{ +std::string GenerateUniqueName(const std::string &Root) { static int i = 0; - char s[16]; - sprintf(s, "%s%d", root, i++); - std::string S = s; - return S; + std::ostringstream NameStream; + NameStream << Root << ++i; + return NameStream.str(); } std::string MakeLegalFunctionName(std::string Name) @@ -669,10 +672,9 @@ std::string MakeLegalFunctionName(std::string Name) std::string legal_elements = "_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"; size_t pos; while ((pos = NewName.find_first_not_of(legal_elements)) != std::string::npos) { - char old_c = NewName.at(pos); - char new_str[16]; - sprintf(new_str, "%d", (int)old_c); - NewName = NewName.replace(pos, 1, new_str); + std::ostringstream NumStream; + NumStream << (int)NewName.at(pos); + NewName = NewName.replace(pos, 1, NumStream.str()); } return NewName; @@ -680,13 +682,18 @@ std::string MakeLegalFunctionName(std::string Name) class SessionContext { public: - SessionContext(LLVMContext &C) : Context(C) {} + SessionContext(LLVMContext &C) + : Context(C), TM(EngineBuilder().selectTarget()) {} LLVMContext& getLLVMContext() const { return Context; } + TargetMachine& getTarget() { return *TM; } void addPrototypeAST(std::unique_ptr P); PrototypeAST* getPrototypeAST(const std::string &Name); private: typedef std::map> PrototypeMap; + LLVMContext &Context; + std::unique_ptr TM; + PrototypeMap Prototypes; }; @@ -699,7 +706,7 @@ PrototypeAST* SessionContext::getPrototypeAST(const std::string &Name) { if (I != Prototypes.end()) return I->second.get(); return nullptr; -} +} class IRGenContext { public: @@ -708,7 +715,9 @@ public: : Session(S), M(new Module(GenerateUniqueName("jit_module_"), Session.getLLVMContext())), - Builder(Session.getLLVMContext()) {} + Builder(Session.getLLVMContext()) { + M->setDataLayout(Session.getTarget().createDataLayout()); + } SessionContext& getSession() { return Session; } Module& getM() const { return *M; } @@ -742,25 +751,22 @@ static AllocaInst *CreateEntryBlockAlloca(Function *TheFunction, VarName.c_str()); } -Value *NumberExprAST::IRGen(IRGenContext &C) { +Value *NumberExprAST::IRGen(IRGenContext &C) const { return ConstantFP::get(C.getLLVMContext(), APFloat(Val)); } -Value *VariableExprAST::IRGen(IRGenContext &C) { +Value *VariableExprAST::IRGen(IRGenContext &C) const { // Look this variable up in the function. Value *V = C.NamedValues[Name]; - if (V == 0) { - char ErrStr[256]; - sprintf(ErrStr, "Unknown variable name %s", Name.c_str()); - return ErrorP(ErrStr); - } + if (V == 0) + return ErrorP("Unknown variable name '" + Name + "'"); // Load the value. return C.getBuilder().CreateLoad(V, Name.c_str()); } -Value *UnaryExprAST::IRGen(IRGenContext &C) { +Value *UnaryExprAST::IRGen(IRGenContext &C) const { if (Value *OperandV = Operand->IRGen(C)) { std::string FnName = MakeLegalFunctionName(std::string("unary")+Opcode); if (Function *F = C.getPrototype(FnName)) @@ -772,7 +778,7 @@ Value *UnaryExprAST::IRGen(IRGenContext &C) { return nullptr; } -Value *BinaryExprAST::IRGen(IRGenContext &C) { +Value *BinaryExprAST::IRGen(IRGenContext &C) const { // Special case '=' because we don't want to emit the LHS as an expression. if (Op == '=') { // Assignment requires the LHS to be an identifier. @@ -788,11 +794,11 @@ Value *BinaryExprAST::IRGen(IRGenContext &C) { } return ErrorP("Unknown variable name"); } - + Value *L = LHS->IRGen(C); Value *R = RHS->IRGen(C); if (!L || !R) return nullptr; - + switch (Op) { case '+': return C.getBuilder().CreateFAdd(L, R, "addtmp"); case '-': return C.getBuilder().CreateFSub(L, R, "subtmp"); @@ -805,7 +811,7 @@ Value *BinaryExprAST::IRGen(IRGenContext &C) { "booltmp"); default: break; } - + // If it wasn't a builtin binary operator, it must be a user defined one. Emit // a call to it. std::string FnName = MakeLegalFunctionName(std::string("binary")+Op); @@ -813,11 +819,11 @@ Value *BinaryExprAST::IRGen(IRGenContext &C) { Value *Ops[] = { L, R }; return C.getBuilder().CreateCall(F, Ops, "binop"); } - + return ErrorP("Unknown binary operator"); } -Value *CallExprAST::IRGen(IRGenContext &C) { +Value *CallExprAST::IRGen(IRGenContext &C) const { // Look up the name in the global module table. if (auto CalleeF = C.getPrototype(CalleeName)) { // If argument mismatch error. @@ -829,72 +835,72 @@ Value *CallExprAST::IRGen(IRGenContext &C) { ArgsV.push_back(Args[i]->IRGen(C)); if (!ArgsV.back()) return nullptr; } - + return C.getBuilder().CreateCall(CalleeF, ArgsV, "calltmp"); } return ErrorP("Unknown function referenced"); } -Value *IfExprAST::IRGen(IRGenContext &C) { +Value *IfExprAST::IRGen(IRGenContext &C) const { Value *CondV = Cond->IRGen(C); if (!CondV) return nullptr; - + // Convert condition to a bool by comparing equal to 0.0. - ConstantFP *FPZero = + ConstantFP *FPZero = ConstantFP::get(C.getLLVMContext(), APFloat(0.0)); CondV = C.getBuilder().CreateFCmpONE(CondV, FPZero, "ifcond"); - + Function *TheFunction = C.getBuilder().GetInsertBlock()->getParent(); - + // Create blocks for the then and else cases. Insert the 'then' block at the // end of the function. BasicBlock *ThenBB = BasicBlock::Create(C.getLLVMContext(), "then", TheFunction); BasicBlock *ElseBB = BasicBlock::Create(C.getLLVMContext(), "else"); BasicBlock *MergeBB = BasicBlock::Create(C.getLLVMContext(), "ifcont"); - + C.getBuilder().CreateCondBr(CondV, ThenBB, ElseBB); - + // Emit then value. C.getBuilder().SetInsertPoint(ThenBB); - + Value *ThenV = Then->IRGen(C); if (!ThenV) return nullptr; - + C.getBuilder().CreateBr(MergeBB); // Codegen of 'Then' can change the current block, update ThenBB for the PHI. ThenBB = C.getBuilder().GetInsertBlock(); - + // Emit else block. TheFunction->getBasicBlockList().push_back(ElseBB); C.getBuilder().SetInsertPoint(ElseBB); - + Value *ElseV = Else->IRGen(C); if (!ElseV) return nullptr; - + C.getBuilder().CreateBr(MergeBB); // Codegen of 'Else' can change the current block, update ElseBB for the PHI. ElseBB = C.getBuilder().GetInsertBlock(); - + // Emit merge block. TheFunction->getBasicBlockList().push_back(MergeBB); C.getBuilder().SetInsertPoint(MergeBB); PHINode *PN = C.getBuilder().CreatePHI(Type::getDoubleTy(getGlobalContext()), 2, "iftmp"); - + PN->addIncoming(ThenV, ThenBB); PN->addIncoming(ElseV, ElseBB); return PN; } -Value *ForExprAST::IRGen(IRGenContext &C) { +Value *ForExprAST::IRGen(IRGenContext &C) const { // Output this as: // var = alloca double // ... // start = startexpr // store start -> var // goto loop - // loop: + // loop: // ... // bodyexpr // ... @@ -907,40 +913,40 @@ Value *ForExprAST::IRGen(IRGenContext &C) { // store nextvar -> var // br endcond, loop, endloop // outloop: - + Function *TheFunction = C.getBuilder().GetInsertBlock()->getParent(); // Create an alloca for the variable in the entry block. AllocaInst *Alloca = CreateEntryBlockAlloca(TheFunction, VarName); - + // Emit the start code first, without 'variable' in scope. Value *StartVal = Start->IRGen(C); if (!StartVal) return nullptr; - + // Store the value into the alloca. C.getBuilder().CreateStore(StartVal, Alloca); - + // Make the new basic block for the loop header, inserting after current // block. BasicBlock *LoopBB = BasicBlock::Create(getGlobalContext(), "loop", TheFunction); - + // Insert an explicit fall through from the current block to the LoopBB. C.getBuilder().CreateBr(LoopBB); // Start insertion in LoopBB. C.getBuilder().SetInsertPoint(LoopBB); - + // Within the loop, the variable is defined equal to the PHI node. If it // shadows an existing variable, we have to restore it, so save it now. AllocaInst *OldVal = C.NamedValues[VarName]; C.NamedValues[VarName] = Alloca; - + // Emit the body of the loop. This, like any other expr, can change the // current BB. Note that we ignore the value computed by the body, but don't // allow an error. if (!Body->IRGen(C)) return nullptr; - + // Emit the step value. Value *StepVal; if (Step) { @@ -950,52 +956,52 @@ Value *ForExprAST::IRGen(IRGenContext &C) { // If not specified, use 1.0. StepVal = ConstantFP::get(getGlobalContext(), APFloat(1.0)); } - + // Compute the end condition. Value *EndCond = End->IRGen(C); if (EndCond == 0) return EndCond; - + // Reload, increment, and restore the alloca. This handles the case where // the body of the loop mutates the variable. Value *CurVar = C.getBuilder().CreateLoad(Alloca, VarName.c_str()); Value *NextVar = C.getBuilder().CreateFAdd(CurVar, StepVal, "nextvar"); C.getBuilder().CreateStore(NextVar, Alloca); - + // Convert condition to a bool by comparing equal to 0.0. - EndCond = C.getBuilder().CreateFCmpONE(EndCond, + EndCond = C.getBuilder().CreateFCmpONE(EndCond, ConstantFP::get(getGlobalContext(), APFloat(0.0)), "loopcond"); - + // Create the "after loop" block and insert it. BasicBlock *AfterBB = BasicBlock::Create(getGlobalContext(), "afterloop", TheFunction); - + // Insert the conditional branch into the end of LoopEndBB. C.getBuilder().CreateCondBr(EndCond, LoopBB, AfterBB); - + // Any new code will be inserted in AfterBB. C.getBuilder().SetInsertPoint(AfterBB); - + // Restore the unshadowed variable. if (OldVal) C.NamedValues[VarName] = OldVal; else C.NamedValues.erase(VarName); - + // for expr always returns 0.0. return Constant::getNullValue(Type::getDoubleTy(getGlobalContext())); } -Value *VarExprAST::IRGen(IRGenContext &C) { +Value *VarExprAST::IRGen(IRGenContext &C) const { std::vector OldBindings; - + Function *TheFunction = C.getBuilder().GetInsertBlock()->getParent(); // Register all variables and emit their initializer. for (unsigned i = 0, e = VarBindings.size(); i != e; ++i) { auto &VarName = VarBindings[i].first; auto &Init = VarBindings[i].second; - + // Emit the initializer before adding the variable to scope, this prevents // the initializer from referencing the variable itself, and permits stuff // like this: @@ -1007,22 +1013,22 @@ Value *VarExprAST::IRGen(IRGenContext &C) { if (!InitVal) return nullptr; } else // If not specified, use 0.0. InitVal = ConstantFP::get(getGlobalContext(), APFloat(0.0)); - + AllocaInst *Alloca = CreateEntryBlockAlloca(TheFunction, VarName); C.getBuilder().CreateStore(InitVal, Alloca); // Remember the old variable binding so that we can restore the binding when // we unrecurse. OldBindings.push_back(C.NamedValues[VarName]); - + // Remember this binding. C.NamedValues[VarName] = Alloca; } - + // Codegen the body, now that all vars are in scope. Value *BodyVal = Body->IRGen(C); if (!BodyVal) return nullptr; - + // Pop all our variables from scope. for (unsigned i = 0, e = VarBindings.size(); i != e; ++i) C.NamedValues[VarBindings[i].first] = OldBindings[i]; @@ -1031,11 +1037,11 @@ Value *VarExprAST::IRGen(IRGenContext &C) { return BodyVal; } -Function *PrototypeAST::IRGen(IRGenContext &C) { +Function *PrototypeAST::IRGen(IRGenContext &C) const { std::string FnName = MakeLegalFunctionName(Name); // Make the function type: double(double,double) etc. - std::vector Doubles(Args.size(), + std::vector Doubles(Args.size(), Type::getDoubleTy(getGlobalContext())); FunctionType *FT = FunctionType::get(Type::getDoubleTy(getGlobalContext()), Doubles, false); @@ -1048,26 +1054,26 @@ Function *PrototypeAST::IRGen(IRGenContext &C) { // Delete the one we just made and get the existing one. F->eraseFromParent(); F = C.getM().getFunction(Name); - + // If F already has a body, reject this. if (!F->empty()) { ErrorP("redefinition of function"); return nullptr; } - + // If F took a different number of args, reject. if (F->arg_size() != Args.size()) { ErrorP("redefinition of function with different # args"); return nullptr; } } - + // Set names for all arguments. unsigned Idx = 0; for (Function::arg_iterator AI = F->arg_begin(); Idx != Args.size(); ++AI, ++Idx) AI->setName(Args[Idx]); - + return F; } @@ -1087,21 +1093,21 @@ void PrototypeAST::CreateArgumentAllocas(Function *F, IRGenContext &C) { } } -Function *FunctionAST::IRGen(IRGenContext &C) { +Function *FunctionAST::IRGen(IRGenContext &C) const { C.NamedValues.clear(); - + Function *TheFunction = Proto->IRGen(C); if (!TheFunction) return nullptr; - + // If this is an operator, install it. if (Proto->isBinaryOp()) BinopPrecedence[Proto->getOperatorName()] = Proto->Precedence; - + // Create a new basic block to start insertion into. BasicBlock *BB = BasicBlock::Create(getGlobalContext(), "entry", TheFunction); C.getBuilder().SetInsertPoint(BB); - + // Add all arguments to the symbol table and create their allocas. Proto->CreateArgumentAllocas(TheFunction, C); @@ -1114,7 +1120,7 @@ Function *FunctionAST::IRGen(IRGenContext &C) { return TheFunction; } - + // Error reading body, remove function. TheFunction->eraseFromParent(); @@ -1127,72 +1133,84 @@ Function *FunctionAST::IRGen(IRGenContext &C) { // Top-Level parsing and JIT Driver //===----------------------------------------------------------------------===// +static std::unique_ptr IRGen(SessionContext &S, + const FunctionAST &F) { + IRGenContext C(S); + auto LF = F.IRGen(C); + if (!LF) + return nullptr; +#ifndef MINIMAL_STDERR_OUTPUT + fprintf(stderr, "Read function definition:"); + LF->dump(); +#endif + return C.takeM(); +} + +template +static std::vector singletonSet(T t) { + std::vector Vec; + Vec.push_back(std::move(t)); + return Vec; +} + class KaleidoscopeJIT { public: typedef ObjectLinkingLayer<> ObjLayerT; typedef IRCompileLayer CompileLayerT; - typedef CompileLayerT::ModuleSetHandleT ModuleHandleT; - KaleidoscopeJIT() - : TM(EngineBuilder().selectTarget()), - Mang(TM->getDataLayout()), - CompileLayer(ObjectLayer, SimpleCompiler(*TM)) {} - - ModuleHandleT addModule(std::unique_ptr M) { - if (!M->getDataLayout()) - M->setDataLayout(TM->getDataLayout()); + KaleidoscopeJIT(SessionContext &Session) + : DL(Session.getTarget().createDataLayout()), + CompileLayer(ObjectLayer, SimpleCompiler(Session.getTarget())) {} - // The LazyEmitLayer takes lists of modules, rather than single modules, so - // we'll just build a single-element list. - std::vector> S; - S.push_back(std::move(M)); + std::string mangle(const std::string &Name) { + std::string MangledName; + { + raw_string_ostream MangledNameStream(MangledName); + Mangler::getNameWithPrefix(MangledNameStream, Name, DL); + } + return MangledName; + } + ModuleHandleT addModule(std::unique_ptr M) { // We need a memory manager to allocate memory and resolve symbols for this - // new module. Create one that resolves symbols by looking back into the JIT. - auto MM = createLookasideRTDyldMM( - [&](const std::string &S) { - return getUnmangledSymbolAddress(S); - }, - [](const std::string &S) { return 0; } ); - - return CompileLayer.addModuleSet(std::move(S), std::move(MM)); + // new module. Create one that resolves symbols by looking back into the + // JIT. + auto Resolver = createLambdaResolver( + [&](const std::string &Name) { + if (auto Sym = findSymbol(Name)) + return RuntimeDyld::SymbolInfo(Sym.getAddress(), + Sym.getFlags()); + return RuntimeDyld::SymbolInfo(nullptr); + }, + [](const std::string &S) { return nullptr; } + ); + return CompileLayer.addModuleSet(singletonSet(std::move(M)), + make_unique(), + std::move(Resolver)); } void removeModule(ModuleHandleT H) { CompileLayer.removeModuleSet(H); } - uint64_t getUnmangledSymbolAddress(const std::string &Name) { - return CompileLayer.getSymbolAddress(Name, false); + JITSymbol findSymbol(const std::string &Name) { + return CompileLayer.findSymbol(Name, true); } - uint64_t getSymbolAddress(const std::string Name) { - std::string MangledName; - { - raw_string_ostream MangledNameStream(MangledName); - Mang.getNameWithPrefix(MangledNameStream, Name); - } - return getUnmangledSymbolAddress(MangledName); + JITSymbol findUnmangledSymbol(const std::string Name) { + return findSymbol(mangle(Name)); } private: - - std::unique_ptr TM; - Mangler Mang; - + const DataLayout DL; ObjLayerT ObjectLayer; CompileLayerT CompileLayer; }; static void HandleDefinition(SessionContext &S, KaleidoscopeJIT &J) { if (auto F = ParseDefinition()) { - IRGenContext C(S); - if (auto LF = F->IRGen(C)) { -#ifndef MINIMAL_STDERR_OUTPUT - fprintf(stderr, "Read function definition:"); - LF->dump(); -#endif - J.addModule(C.takeM()); + if (auto M = IRGen(S, *F)) { S.addPrototypeAST(llvm::make_unique(*F->Proto)); + J.addModule(std::move(M)); } } else { // Skip token for error recovery. @@ -1215,7 +1233,7 @@ static void HandleTopLevelExpression(SessionContext &S, KaleidoscopeJIT &J) { IRGenContext C(S); if (auto ExprFunc = F->IRGen(C)) { #ifndef MINIMAL_STDERR_OUTPUT - fprintf(stderr, "Expression function:\n"); + std::cerr << "Expression function:\n"; ExprFunc->dump(); #endif // Add the CodeGen'd module to the JIT. Keep a handle to it: We can remove @@ -1223,15 +1241,15 @@ static void HandleTopLevelExpression(SessionContext &S, KaleidoscopeJIT &J) { auto H = J.addModule(C.takeM()); // Get the address of the JIT'd function in memory. - uint64_t ExprFuncAddr = J.getSymbolAddress("__anon_expr"); - + auto ExprSymbol = J.findUnmangledSymbol("__anon_expr"); + // Cast it to the right type (takes no arguments, returns a double) so we // can call it as a native function. - double (*FP)() = (double (*)())(intptr_t)ExprFuncAddr; + double (*FP)() = (double (*)())(intptr_t)ExprSymbol.getAddress(); #ifdef MINIMAL_STDERR_OUTPUT FP(); #else - fprintf(stderr, "Evaluated to %f\n", FP()); + std::cerr << "Evaluated to " << FP() << "\n"; #endif // Remove the function. @@ -1245,20 +1263,20 @@ static void HandleTopLevelExpression(SessionContext &S, KaleidoscopeJIT &J) { /// top ::= definition | external | expression | ';' static void MainLoop() { - KaleidoscopeJIT J; SessionContext S(getGlobalContext()); + KaleidoscopeJIT J(S); while (1) { -#ifndef MINIMAL_STDERR_OUTPUT - fprintf(stderr, "ready> "); -#endif switch (CurTok) { case tok_eof: return; - case ';': getNextToken(); break; // ignore top-level semicolons. + case ';': getNextToken(); continue; // ignore top-level semicolons. case tok_def: HandleDefinition(S, J); break; case tok_extern: HandleExtern(S); break; default: HandleTopLevelExpression(S, J); break; } +#ifndef MINIMAL_STDERR_OUTPUT + std::cerr << "ready> "; +#endif } } @@ -1267,20 +1285,20 @@ static void MainLoop() { //===----------------------------------------------------------------------===// /// putchard - putchar that takes a double and returns 0. -extern "C" +extern "C" double putchard(double X) { putchar((char)X); return 0; } /// printd - printf that takes a double prints it as "%f\n", returning 0. -extern "C" +extern "C" double printd(double X) { printf("%f", X); return 0; } -extern "C" +extern "C" double printlf() { printf("\n"); return 0; @@ -1294,7 +1312,6 @@ int main() { InitializeNativeTarget(); InitializeNativeTargetAsmPrinter(); InitializeNativeTargetAsmParser(); - LLVMContext &Context = getGlobalContext(); // Install standard binary operators. // 1 is lowest precedence. @@ -1307,13 +1324,14 @@ int main() { // Prime the first token. #ifndef MINIMAL_STDERR_OUTPUT - fprintf(stderr, "ready> "); + std::cerr << "ready> "; #endif getNextToken(); + std::cerr << std::fixed; + // Run the main "interpreter loop" now. MainLoop(); return 0; } -