examples/Kaleidoscope/Chapter8/toy.cpp

   1 #include "llvm/ADT/STLExtras.h"
   2 #include "llvm/ADT/Triple.h"
   3 #include "llvm/Analysis/Passes.h"
   4 #include "llvm/ExecutionEngine/ExecutionEngine.h"
   5 #include "llvm/ExecutionEngine/MCJIT.h"
   6 #include "llvm/ExecutionEngine/SectionMemoryManager.h"
   7 #include "llvm/IR/DIBuilder.h"
   8 #include "llvm/IR/DataLayout.h"
   9 #include "llvm/IR/DerivedTypes.h"
  10 #include "llvm/IR/IRBuilder.h"
  11 #include "llvm/IR/LLVMContext.h"
  12 #include "llvm/IR/LegacyPassManager.h"
  13 #include "llvm/IR/Module.h"
  14 #include "llvm/IR/Verifier.h"
  15 #include "llvm/Support/Host.h"
  16 #include "llvm/Support/TargetSelect.h"
  17 #include "llvm/Transforms/Scalar.h"
  18 #include <cctype>
  19 #include <cstdio>
  20 #include <iostream>
  21 #include <map>
  22 #include <string>
  23 #include <vector>
  24 using namespace llvm;
  25
  26 //===----------------------------------------------------------------------===//
  27 // Lexer
  28 //===----------------------------------------------------------------------===//
  29
  30 // The lexer returns tokens [0-255] if it is an unknown character, otherwise one
  31 // of these for known things.
  32 enum Token {
  33   tok_eof = -1,
  34
  35   // commands
  36   tok_def = -2,
  37   tok_extern = -3,
  38
  39   // primary
  40   tok_identifier = -4,
  41   tok_number = -5,
  42
  43   // control
  44   tok_if = -6,
  45   tok_then = -7,
  46   tok_else = -8,
  47   tok_for = -9,
  48   tok_in = -10,
  49
  50   // operators
  51   tok_binary = -11,
  52   tok_unary = -12,
  53
  54   // var definition
  55   tok_var = -13
  56 };
  57
  58 std::string getTokName(int Tok) {
  59   switch (Tok) {
  60   case tok_eof:
  61     return "eof";
  62   case tok_def:
  63     return "def";
  64   case tok_extern:
  65     return "extern";
  66   case tok_identifier:
  67     return "identifier";
  68   case tok_number:
  69     return "number";
  70   case tok_if:
  71     return "if";
  72   case tok_then:
  73     return "then";
  74   case tok_else:
  75     return "else";
  76   case tok_for:
  77     return "for";
  78   case tok_in:
  79     return "in";
  80   case tok_binary:
  81     return "binary";
  82   case tok_unary:
  83     return "unary";
  84   case tok_var:
  85     return "var";
  86   }
  87   return std::string(1, (char)Tok);
  88 }
  89
  90 namespace {
  91 class PrototypeAST;
  92 class ExprAST;
  93 }
  94 static IRBuilder<> Builder(getGlobalContext());
  95 struct DebugInfo {
  96   DICompileUnit TheCU;
  97   DIType DblTy;
  98   std::vector<DIScope *> LexicalBlocks;
  99   std::map<const PrototypeAST *, DIScope> FnScopeMap;
 100
 101   void emitLocation(ExprAST *AST);
 102   DIType getDoubleTy();
 103 } KSDbgInfo;
 104
 105 static std::string IdentifierStr; // Filled in if tok_identifier
 106 static double NumVal;             // Filled in if tok_number
 107 struct SourceLocation {
 108   int Line;
 109   int Col;
 110 };
 111 static SourceLocation CurLoc;
 112 static SourceLocation LexLoc = { 1, 0 };
 113
 114 static int advance() {
 115   int LastChar = getchar();
 116
 117   if (LastChar == '\n' || LastChar == '\r') {
 118     LexLoc.Line++;
 119     LexLoc.Col = 0;
 120   } else
 121     LexLoc.Col++;
 122   return LastChar;
 123 }
 124
 125 /// gettok - Return the next token from standard input.
 126 static int gettok() {
 127   static int LastChar = ' ';
 128
 129   // Skip any whitespace.
 130   while (isspace(LastChar))
 131     LastChar = advance();
 132
 133   CurLoc = LexLoc;
 134
 135   if (isalpha(LastChar)) { // identifier: [a-zA-Z][a-zA-Z0-9]*
 136     IdentifierStr = LastChar;
 137     while (isalnum((LastChar = advance())))
 138       IdentifierStr += LastChar;
 139
 140     if (IdentifierStr == "def")
 141       return tok_def;
 142     if (IdentifierStr == "extern")
 143       return tok_extern;
 144     if (IdentifierStr == "if")
 145       return tok_if;
 146     if (IdentifierStr == "then")
 147       return tok_then;
 148     if (IdentifierStr == "else")
 149       return tok_else;
 150     if (IdentifierStr == "for")
 151       return tok_for;
 152     if (IdentifierStr == "in")
 153       return tok_in;
 154     if (IdentifierStr == "binary")
 155       return tok_binary;
 156     if (IdentifierStr == "unary")
 157       return tok_unary;
 158     if (IdentifierStr == "var")
 159       return tok_var;
 160     return tok_identifier;
 161   }
 162
 163   if (isdigit(LastChar) || LastChar == '.') { // Number: [0-9.]+
 164     std::string NumStr;
 165     do {
 166       NumStr += LastChar;
 167       LastChar = advance();
 168     } while (isdigit(LastChar) || LastChar == '.');
 169
 170     NumVal = strtod(NumStr.c_str(), 0);
 171     return tok_number;
 172   }
 173
 174   if (LastChar == '#') {
 175     // Comment until end of line.
 176     do
 177       LastChar = advance();
 178     while (LastChar != EOF && LastChar != '\n' && LastChar != '\r');
 179
 180     if (LastChar != EOF)
 181       return gettok();
 182   }
 183
 184   // Check for end of file.  Don't eat the EOF.
 185   if (LastChar == EOF)
 186     return tok_eof;
 187
 188   // Otherwise, just return the character as its ascii value.
 189   int ThisChar = LastChar;
 190   LastChar = advance();
 191   return ThisChar;
 192 }
 193
 194 //===----------------------------------------------------------------------===//
 195 // Abstract Syntax Tree (aka Parse Tree)
 196 //===----------------------------------------------------------------------===//
 197 namespace {
 198
 199 std::ostream &indent(std::ostream &O, int size) {
 200   return O << std::string(size, ' ');
 201 }
 202
 203 /// ExprAST - Base class for all expression nodes.
 204 class ExprAST {
 205   SourceLocation Loc;
 206
 207 public:
 208   int getLine() const { return Loc.Line; }
 209   int getCol() const { return Loc.Col; }
 210   ExprAST(SourceLocation Loc = CurLoc) : Loc(Loc) {}
 211   virtual std::ostream &dump(std::ostream &out, int ind) {
 212     return out << ':' << getLine() << ':' << getCol() << '\n';
 213   }
 214   virtual ~ExprAST() {}
 215   virtual Value *Codegen() = 0;
 216 };
 217
 218 /// NumberExprAST - Expression class for numeric literals like "1.0".
 219 class NumberExprAST : public ExprAST {
 220   double Val;
 221
 222 public:
 223   NumberExprAST(double val) : Val(val) {}
 224   std::ostream &dump(std::ostream &out, int ind) override {
 225     return ExprAST::dump(out << Val, ind);
 226   }
 227   Value *Codegen() override;
 228 };
 229
 230 /// VariableExprAST - Expression class for referencing a variable, like "a".
 231 class VariableExprAST : public ExprAST {
 232   std::string Name;
 233
 234 public:
 235   VariableExprAST(SourceLocation Loc, const std::string &name)
 236       : ExprAST(Loc), Name(name) {}
 237   const std::string &getName() const { return Name; }
 238   std::ostream &dump(std::ostream &out, int ind) override {
 239     return ExprAST::dump(out << Name, ind);
 240   }
 241   Value *Codegen() override;
 242 };
 243
 244 /// UnaryExprAST - Expression class for a unary operator.
 245 class UnaryExprAST : public ExprAST {
 246   char Opcode;
 247   ExprAST *Operand;
 248
 249 public:
 250   UnaryExprAST(char opcode, ExprAST *operand)
 251       : Opcode(opcode), Operand(operand) {}
 252   std::ostream &dump(std::ostream &out, int ind) override {
 253     ExprAST::dump(out << "unary" << Opcode, ind);
 254     Operand->dump(out, ind + 1);
 255     return out;
 256   }
 257   Value *Codegen() override;
 258 };
 259
 260 /// BinaryExprAST - Expression class for a binary operator.
 261 class BinaryExprAST : public ExprAST {
 262   char Op;
 263   ExprAST *LHS, *RHS;
 264
 265 public:
 266   BinaryExprAST(SourceLocation Loc, char op, ExprAST *lhs, ExprAST *rhs)
 267       : ExprAST(Loc), Op(op), LHS(lhs), RHS(rhs) {}
 268   std::ostream &dump(std::ostream &out, int ind) override {
 269     ExprAST::dump(out << "binary" << Op, ind);
 270     LHS->dump(indent(out, ind) << "LHS:", ind + 1);
 271     RHS->dump(indent(out, ind) << "RHS:", ind + 1);
 272     return out;
 273   }
 274   Value *Codegen() override;
 275 };
 276
 277 /// CallExprAST - Expression class for function calls.
 278 class CallExprAST : public ExprAST {
 279   std::string Callee;
 280   std::vector<ExprAST *> Args;
 281
 282 public:
 283   CallExprAST(SourceLocation Loc, const std::string &callee,
 284               std::vector<ExprAST *> &args)
 285       : ExprAST(Loc), Callee(callee), Args(args) {}
 286   std::ostream &dump(std::ostream &out, int ind) override {
 287     ExprAST::dump(out << "call " << Callee, ind);
 288     for (ExprAST *Arg : Args)
 289       Arg->dump(indent(out, ind + 1), ind + 1);
 290     return out;
 291   }
 292   Value *Codegen() override;
 293 };
 294
 295 /// IfExprAST - Expression class for if/then/else.
 296 class IfExprAST : public ExprAST {
 297   ExprAST *Cond, *Then, *Else;
 298
 299 public:
 300   IfExprAST(SourceLocation Loc, ExprAST *cond, ExprAST *then, ExprAST *_else)
 301       : ExprAST(Loc), Cond(cond), Then(then), Else(_else) {}
 302   std::ostream &dump(std::ostream &out, int ind) override {
 303     ExprAST::dump(out << "if", ind);
 304     Cond->dump(indent(out, ind) << "Cond:", ind + 1);
 305     Then->dump(indent(out, ind) << "Then:", ind + 1);
 306     Else->dump(indent(out, ind) << "Else:", ind + 1);
 307     return out;
 308   }
 309   Value *Codegen() override;
 310 };
 311
 312 /// ForExprAST - Expression class for for/in.
 313 class ForExprAST : public ExprAST {
 314   std::string VarName;
 315   ExprAST *Start, *End, *Step, *Body;
 316
 317 public:
 318   ForExprAST(const std::string &varname, ExprAST *start, ExprAST *end,
 319              ExprAST *step, ExprAST *body)
 320       : VarName(varname), Start(start), End(end), Step(step), Body(body) {}
 321   std::ostream &dump(std::ostream &out, int ind) override {
 322     ExprAST::dump(out << "for", ind);
 323     Start->dump(indent(out, ind) << "Cond:", ind + 1);
 324     End->dump(indent(out, ind) << "End:", ind + 1);
 325     Step->dump(indent(out, ind) << "Step:", ind + 1);
 326     Body->dump(indent(out, ind) << "Body:", ind + 1);
 327     return out;
 328   }
 329   Value *Codegen() override;
 330 };
 331
 332 /// VarExprAST - Expression class for var/in
 333 class VarExprAST : public ExprAST {
 334   std::vector<std::pair<std::string, ExprAST *> > VarNames;
 335   ExprAST *Body;
 336
 337 public:
 338   VarExprAST(const std::vector<std::pair<std::string, ExprAST *> > &varnames,
 339              ExprAST *body)
 340       : VarNames(varnames), Body(body) {}
 341
 342   std::ostream &dump(std::ostream &out, int ind) override {
 343     ExprAST::dump(out << "var", ind);
 344     for (const auto &NamedVar : VarNames)
 345       NamedVar.second->dump(indent(out, ind) << NamedVar.first << ':', ind + 1);
 346     Body->dump(indent(out, ind) << "Body:", ind + 1);
 347     return out;
 348   }
 349   Value *Codegen() override;
 350 };
 351
 352 /// PrototypeAST - This class represents the "prototype" for a function,
 353 /// which captures its argument names as well as if it is an operator.
 354 class PrototypeAST {
 355   std::string Name;
 356   std::vector<std::string> Args;
 357   bool isOperator;
 358   unsigned Precedence; // Precedence if a binary op.
 359   int Line;
 360
 361 public:
 362   PrototypeAST(SourceLocation Loc, const std::string &name,
 363                const std::vector<std::string> &args, bool isoperator = false,
 364                unsigned prec = 0)
 365       : Name(name), Args(args), isOperator(isoperator), Precedence(prec),
 366         Line(Loc.Line) {}
 367
 368   bool isUnaryOp() const { return isOperator && Args.size() == 1; }
 369   bool isBinaryOp() const { return isOperator && Args.size() == 2; }
 370
 371   char getOperatorName() const {
 372     assert(isUnaryOp() || isBinaryOp());
 373     return Name[Name.size() - 1];
 374   }
 375
 376   unsigned getBinaryPrecedence() const { return Precedence; }
 377
 378   Function *Codegen();
 379
 380   void CreateArgumentAllocas(Function *F);
 381   const std::vector<std::string> &getArgs() const { return Args; }
 382 };
 383
 384 /// FunctionAST - This class represents a function definition itself.
 385 class FunctionAST {
 386   PrototypeAST *Proto;
 387   ExprAST *Body;
 388
 389 public:
 390   FunctionAST(PrototypeAST *proto, ExprAST *body) : Proto(proto), Body(body) {}
 391
 392   std::ostream &dump(std::ostream &out, int ind) {
 393     indent(out, ind) << "FunctionAST\n";
 394     ++ind;
 395     indent(out, ind) << "Body:";
 396     return Body ? Body->dump(out, ind) : out << "null\n";
 397   }
 398
 399   Function *Codegen();
 400 };
 401 } // end anonymous namespace
 402
 403 //===----------------------------------------------------------------------===//
 404 // Parser
 405 //===----------------------------------------------------------------------===//
 406
 407 /// CurTok/getNextToken - Provide a simple token buffer.  CurTok is the current
 408 /// token the parser is looking at.  getNextToken reads another token from the
 409 /// lexer and updates CurTok with its results.
 410 static int CurTok;
 411 static int getNextToken() { return CurTok = gettok(); }
 412
 413 /// BinopPrecedence - This holds the precedence for each binary operator that is
 414 /// defined.
 415 static std::map<char, int> BinopPrecedence;
 416
 417 /// GetTokPrecedence - Get the precedence of the pending binary operator token.
 418 static int GetTokPrecedence() {
 419   if (!isascii(CurTok))
 420     return -1;
 421
 422   // Make sure it's a declared binop.
 423   int TokPrec = BinopPrecedence[CurTok];
 424   if (TokPrec <= 0)
 425     return -1;
 426   return TokPrec;
 427 }
 428
 429 /// Error* - These are little helper functions for error handling.
 430 ExprAST *Error(const char *Str) {
 431   fprintf(stderr, "Error: %s\n", Str);
 432   return 0;
 433 }
 434 PrototypeAST *ErrorP(const char *Str) {
 435   Error(Str);
 436   return 0;
 437 }
 438 FunctionAST *ErrorF(const char *Str) {
 439   Error(Str);
 440   return 0;
 441 }
 442
 443 static ExprAST *ParseExpression();
 444
 445 /// identifierexpr
 446 ///   ::= identifier
 447 ///   ::= identifier '(' expression* ')'
 448 static ExprAST *ParseIdentifierExpr() {
 449   std::string IdName = IdentifierStr;
 450
 451   SourceLocation LitLoc = CurLoc;
 452
 453   getNextToken(); // eat identifier.
 454
 455   if (CurTok != '(') // Simple variable ref.
 456     return new VariableExprAST(LitLoc, IdName);
 457
 458   // Call.
 459   getNextToken(); // eat (
 460   std::vector<ExprAST *> Args;
 461   if (CurTok != ')') {
 462     while (1) {
 463       ExprAST *Arg = ParseExpression();
 464       if (!Arg)
 465         return 0;
 466       Args.push_back(Arg);
 467
 468       if (CurTok == ')')
 469         break;
 470
 471       if (CurTok != ',')
 472         return Error("Expected ')' or ',' in argument list");
 473       getNextToken();
 474     }
 475   }
 476
 477   // Eat the ')'.
 478   getNextToken();
 479
 480   return new CallExprAST(LitLoc, IdName, Args);
 481 }
 482
 483 /// numberexpr ::= number
 484 static ExprAST *ParseNumberExpr() {
 485   ExprAST *Result = new NumberExprAST(NumVal);
 486   getNextToken(); // consume the number
 487   return Result;
 488 }
 489
 490 /// parenexpr ::= '(' expression ')'
 491 static ExprAST *ParseParenExpr() {
 492   getNextToken(); // eat (.
 493   ExprAST *V = ParseExpression();
 494   if (!V)
 495     return 0;
 496
 497   if (CurTok != ')')
 498     return Error("expected ')'");
 499   getNextToken(); // eat ).
 500   return V;
 501 }
 502
 503 /// ifexpr ::= 'if' expression 'then' expression 'else' expression
 504 static ExprAST *ParseIfExpr() {
 505   SourceLocation IfLoc = CurLoc;
 506
 507   getNextToken(); // eat the if.
 508
 509   // condition.
 510   ExprAST *Cond = ParseExpression();
 511   if (!Cond)
 512     return 0;
 513
 514   if (CurTok != tok_then)
 515     return Error("expected then");
 516   getNextToken(); // eat the then
 517
 518   ExprAST *Then = ParseExpression();
 519   if (Then == 0)
 520     return 0;
 521
 522   if (CurTok != tok_else)
 523     return Error("expected else");
 524
 525   getNextToken();
 526
 527   ExprAST *Else = ParseExpression();
 528   if (!Else)
 529     return 0;
 530
 531   return new IfExprAST(IfLoc, Cond, Then, Else);
 532 }
 533
 534 /// forexpr ::= 'for' identifier '=' expr ',' expr (',' expr)? 'in' expression
 535 static ExprAST *ParseForExpr() {
 536   getNextToken(); // eat the for.
 537
 538   if (CurTok != tok_identifier)
 539     return Error("expected identifier after for");
 540
 541   std::string IdName = IdentifierStr;
 542   getNextToken(); // eat identifier.
 543
 544   if (CurTok != '=')
 545     return Error("expected '=' after for");
 546   getNextToken(); // eat '='.
 547
 548   ExprAST *Start = ParseExpression();
 549   if (Start == 0)
 550     return 0;
 551   if (CurTok != ',')
 552     return Error("expected ',' after for start value");
 553   getNextToken();
 554
 555   ExprAST *End = ParseExpression();
 556   if (End == 0)
 557     return 0;
 558
 559   // The step value is optional.
 560   ExprAST *Step = 0;
 561   if (CurTok == ',') {
 562     getNextToken();
 563     Step = ParseExpression();
 564     if (Step == 0)
 565       return 0;
 566   }
 567
 568   if (CurTok != tok_in)
 569     return Error("expected 'in' after for");
 570   getNextToken(); // eat 'in'.
 571
 572   ExprAST *Body = ParseExpression();
 573   if (Body == 0)
 574     return 0;
 575
 576   return new ForExprAST(IdName, Start, End, Step, Body);
 577 }
 578
 579 /// varexpr ::= 'var' identifier ('=' expression)?
 580 //                    (',' identifier ('=' expression)?)* 'in' expression
 581 static ExprAST *ParseVarExpr() {
 582   getNextToken(); // eat the var.
 583
 584   std::vector<std::pair<std::string, ExprAST *> > VarNames;
 585
 586   // At least one variable name is required.
 587   if (CurTok != tok_identifier)
 588     return Error("expected identifier after var");
 589
 590   while (1) {
 591     std::string Name = IdentifierStr;
 592     getNextToken(); // eat identifier.
 593
 594     // Read the optional initializer.
 595     ExprAST *Init = 0;
 596     if (CurTok == '=') {
 597       getNextToken(); // eat the '='.
 598
 599       Init = ParseExpression();
 600       if (Init == 0)
 601         return 0;
 602     }
 603
 604     VarNames.push_back(std::make_pair(Name, Init));
 605
 606     // End of var list, exit loop.
 607     if (CurTok != ',')
 608       break;
 609     getNextToken(); // eat the ','.
 610
 611     if (CurTok != tok_identifier)
 612       return Error("expected identifier list after var");
 613   }
 614
 615   // At this point, we have to have 'in'.
 616   if (CurTok != tok_in)
 617     return Error("expected 'in' keyword after 'var'");
 618   getNextToken(); // eat 'in'.
 619
 620   ExprAST *Body = ParseExpression();
 621   if (Body == 0)
 622     return 0;
 623
 624   return new VarExprAST(VarNames, Body);
 625 }
 626
 627 /// primary
 628 ///   ::= identifierexpr
 629 ///   ::= numberexpr
 630 ///   ::= parenexpr
 631 ///   ::= ifexpr
 632 ///   ::= forexpr
 633 ///   ::= varexpr
 634 static ExprAST *ParsePrimary() {
 635   switch (CurTok) {
 636   default:
 637     return Error("unknown token when expecting an expression");
 638   case tok_identifier:
 639     return ParseIdentifierExpr();
 640   case tok_number:
 641     return ParseNumberExpr();
 642   case '(':
 643     return ParseParenExpr();
 644   case tok_if:
 645     return ParseIfExpr();
 646   case tok_for:
 647     return ParseForExpr();
 648   case tok_var:
 649     return ParseVarExpr();
 650   }
 651 }
 652
 653 /// unary
 654 ///   ::= primary
 655 ///   ::= '!' unary
 656 static ExprAST *ParseUnary() {
 657   // If the current token is not an operator, it must be a primary expr.
 658   if (!isascii(CurTok) || CurTok == '(' || CurTok == ',')
 659     return ParsePrimary();
 660
 661   // If this is a unary operator, read it.
 662   int Opc = CurTok;
 663   getNextToken();
 664   if (ExprAST *Operand = ParseUnary())
 665     return new UnaryExprAST(Opc, Operand);
 666   return 0;
 667 }
 668
 669 /// binoprhs
 670 ///   ::= ('+' unary)*
 671 static ExprAST *ParseBinOpRHS(int ExprPrec, ExprAST *LHS) {
 672   // If this is a binop, find its precedence.
 673   while (1) {
 674     int TokPrec = GetTokPrecedence();
 675
 676     // If this is a binop that binds at least as tightly as the current binop,
 677     // consume it, otherwise we are done.
 678     if (TokPrec < ExprPrec)
 679       return LHS;
 680
 681     // Okay, we know this is a binop.
 682     int BinOp = CurTok;
 683     SourceLocation BinLoc = CurLoc;
 684     getNextToken(); // eat binop
 685
 686     // Parse the unary expression after the binary operator.
 687     ExprAST *RHS = ParseUnary();
 688     if (!RHS)
 689       return 0;
 690
 691     // If BinOp binds less tightly with RHS than the operator after RHS, let
 692     // the pending operator take RHS as its LHS.
 693     int NextPrec = GetTokPrecedence();
 694     if (TokPrec < NextPrec) {
 695       RHS = ParseBinOpRHS(TokPrec + 1, RHS);
 696       if (RHS == 0)
 697         return 0;
 698     }
 699
 700     // Merge LHS/RHS.
 701     LHS = new BinaryExprAST(BinLoc, BinOp, LHS, RHS);
 702   }
 703 }
 704
 705 /// expression
 706 ///   ::= unary binoprhs
 707 ///
 708 static ExprAST *ParseExpression() {
 709   ExprAST *LHS = ParseUnary();
 710   if (!LHS)
 711     return 0;
 712
 713   return ParseBinOpRHS(0, LHS);
 714 }
 715
 716 /// prototype
 717 ///   ::= id '(' id* ')'
 718 ///   ::= binary LETTER number? (id, id)
 719 ///   ::= unary LETTER (id)
 720 static PrototypeAST *ParsePrototype() {
 721   std::string FnName;
 722
 723   SourceLocation FnLoc = CurLoc;
 724
 725   unsigned Kind = 0; // 0 = identifier, 1 = unary, 2 = binary.
 726   unsigned BinaryPrecedence = 30;
 727
 728   switch (CurTok) {
 729   default:
 730     return ErrorP("Expected function name in prototype");
 731   case tok_identifier:
 732     FnName = IdentifierStr;
 733     Kind = 0;
 734     getNextToken();
 735     break;
 736   case tok_unary:
 737     getNextToken();
 738     if (!isascii(CurTok))
 739       return ErrorP("Expected unary operator");
 740     FnName = "unary";
 741     FnName += (char)CurTok;
 742     Kind = 1;
 743     getNextToken();
 744     break;
 745   case tok_binary:
 746     getNextToken();
 747     if (!isascii(CurTok))
 748       return ErrorP("Expected binary operator");
 749     FnName = "binary";
 750     FnName += (char)CurTok;
 751     Kind = 2;
 752     getNextToken();
 753
 754     // Read the precedence if present.
 755     if (CurTok == tok_number) {
 756       if (NumVal < 1 || NumVal > 100)
 757         return ErrorP("Invalid precedecnce: must be 1..100");
 758       BinaryPrecedence = (unsigned)NumVal;
 759       getNextToken();
 760     }
 761     break;
 762   }
 763
 764   if (CurTok != '(')
 765     return ErrorP("Expected '(' in prototype");
 766
 767   std::vector<std::string> ArgNames;
 768   while (getNextToken() == tok_identifier)
 769     ArgNames.push_back(IdentifierStr);
 770   if (CurTok != ')')
 771     return ErrorP("Expected ')' in prototype");
 772
 773   // success.
 774   getNextToken(); // eat ')'.
 775
 776   // Verify right number of names for operator.
 777   if (Kind && ArgNames.size() != Kind)
 778     return ErrorP("Invalid number of operands for operator");
 779
 780   return new PrototypeAST(FnLoc, FnName, ArgNames, Kind != 0, BinaryPrecedence);
 781 }
 782
 783 /// definition ::= 'def' prototype expression
 784 static FunctionAST *ParseDefinition() {
 785   getNextToken(); // eat def.
 786   PrototypeAST *Proto = ParsePrototype();
 787   if (Proto == 0)
 788     return 0;
 789
 790   if (ExprAST *E = ParseExpression())
 791     return new FunctionAST(Proto, E);
 792   return 0;
 793 }
 794
 795 /// toplevelexpr ::= expression
 796 static FunctionAST *ParseTopLevelExpr() {
 797   SourceLocation FnLoc = CurLoc;
 798   if (ExprAST *E = ParseExpression()) {
 799     // Make an anonymous proto.
 800     PrototypeAST *Proto =
 801         new PrototypeAST(FnLoc, "main", std::vector<std::string>());
 802     return new FunctionAST(Proto, E);
 803   }
 804   return 0;
 805 }
 806
 807 /// external ::= 'extern' prototype
 808 static PrototypeAST *ParseExtern() {
 809   getNextToken(); // eat extern.
 810   return ParsePrototype();
 811 }
 812
 813 //===----------------------------------------------------------------------===//
 814 // Debug Info Support
 815 //===----------------------------------------------------------------------===//
 816
 817 static DIBuilder *DBuilder;
 818
 819 DIType DebugInfo::getDoubleTy() {
 820   if (DblTy)
 821     return DblTy;
 822
 823   DblTy = DBuilder->createBasicType("double", 64, 64, dwarf::DW_ATE_float);
 824   return DblTy;
 825 }
 826
 827 void DebugInfo::emitLocation(ExprAST *AST) {
 828   if (!AST)
 829     return Builder.SetCurrentDebugLocation(DebugLoc());
 830   MDScope *Scope;
 831   if (LexicalBlocks.empty())
 832     Scope = TheCU;
 833   else
 834     Scope = *LexicalBlocks.back();
 835   Builder.SetCurrentDebugLocation(
 836       DebugLoc::get(AST->getLine(), AST->getCol(), Scope));
 837 }
 838
 839 static DICompositeType CreateFunctionType(unsigned NumArgs, DIFile Unit) {
 840   SmallVector<Metadata *, 8> EltTys;
 841   DIType DblTy = KSDbgInfo.getDoubleTy();
 842
 843   // Add the result type.
 844   EltTys.push_back(DblTy);
 845
 846   for (unsigned i = 0, e = NumArgs; i != e; ++i)
 847     EltTys.push_back(DblTy);
 848
 849   DITypeArray EltTypeArray = DBuilder->getOrCreateTypeArray(EltTys);
 850   return DBuilder->createSubroutineType(Unit, EltTypeArray);
 851 }
 852
 853 //===----------------------------------------------------------------------===//
 854 // Code Generation
 855 //===----------------------------------------------------------------------===//
 856
 857 static Module *TheModule;
 858 static std::map<std::string, AllocaInst *> NamedValues;
 859 static legacy::FunctionPassManager *TheFPM;
 860
 861 Value *ErrorV(const char *Str) {
 862   Error(Str);
 863   return 0;
 864 }
 865
 866 /// CreateEntryBlockAlloca - Create an alloca instruction in the entry block of
 867 /// the function.  This is used for mutable variables etc.
 868 static AllocaInst *CreateEntryBlockAlloca(Function *TheFunction,
 869                                           const std::string &VarName) {
 870   IRBuilder<> TmpB(&TheFunction->getEntryBlock(),
 871                    TheFunction->getEntryBlock().begin());
 872   return TmpB.CreateAlloca(Type::getDoubleTy(getGlobalContext()), 0,
 873                            VarName.c_str());
 874 }
 875
 876 Value *NumberExprAST::Codegen() {
 877   KSDbgInfo.emitLocation(this);
 878   return ConstantFP::get(getGlobalContext(), APFloat(Val));
 879 }
 880
 881 Value *VariableExprAST::Codegen() {
 882   // Look this variable up in the function.
 883   Value *V = NamedValues[Name];
 884   if (V == 0)
 885     return ErrorV("Unknown variable name");
 886
 887   KSDbgInfo.emitLocation(this);
 888   // Load the value.
 889   return Builder.CreateLoad(V, Name.c_str());
 890 }
 891
 892 Value *UnaryExprAST::Codegen() {
 893   Value *OperandV = Operand->Codegen();
 894   if (OperandV == 0)
 895     return 0;
 896
 897   Function *F = TheModule->getFunction(std::string("unary") + Opcode);
 898   if (F == 0)
 899     return ErrorV("Unknown unary operator");
 900
 901   KSDbgInfo.emitLocation(this);
 902   return Builder.CreateCall(F, OperandV, "unop");
 903 }
 904
 905 Value *BinaryExprAST::Codegen() {
 906   KSDbgInfo.emitLocation(this);
 907
 908   // Special case '=' because we don't want to emit the LHS as an expression.
 909   if (Op == '=') {
 910     // Assignment requires the LHS to be an identifier.
 911     VariableExprAST *LHSE = dynamic_cast<VariableExprAST *>(LHS);
 912     if (!LHSE)
 913       return ErrorV("destination of '=' must be a variable");
 914     // Codegen the RHS.
 915     Value *Val = RHS->Codegen();
 916     if (Val == 0)
 917       return 0;
 918
 919     // Look up the name.
 920     Value *Variable = NamedValues[LHSE->getName()];
 921     if (Variable == 0)
 922       return ErrorV("Unknown variable name");
 923
 924     Builder.CreateStore(Val, Variable);
 925     return Val;
 926   }
 927
 928   Value *L = LHS->Codegen();
 929   Value *R = RHS->Codegen();
 930   if (L == 0 || R == 0)
 931     return 0;
 932
 933   switch (Op) {
 934   case '+':
 935     return Builder.CreateFAdd(L, R, "addtmp");
 936   case '-':
 937     return Builder.CreateFSub(L, R, "subtmp");
 938   case '*':
 939     return Builder.CreateFMul(L, R, "multmp");
 940   case '<':
 941     L = Builder.CreateFCmpULT(L, R, "cmptmp");
 942     // Convert bool 0/1 to double 0.0 or 1.0
 943     return Builder.CreateUIToFP(L, Type::getDoubleTy(getGlobalContext()),
 944                                 "booltmp");
 945   default:
 946     break;
 947   }
 948
 949   // If it wasn't a builtin binary operator, it must be a user defined one. Emit
 950   // a call to it.
 951   Function *F = TheModule->getFunction(std::string("binary") + Op);
 952   assert(F && "binary operator not found!");
 953
 954   Value *Ops[] = { L, R };
 955   return Builder.CreateCall(F, Ops, "binop");
 956 }
 957
 958 Value *CallExprAST::Codegen() {
 959   KSDbgInfo.emitLocation(this);
 960
 961   // Look up the name in the global module table.
 962   Function *CalleeF = TheModule->getFunction(Callee);
 963   if (CalleeF == 0)
 964     return ErrorV("Unknown function referenced");
 965
 966   // If argument mismatch error.
 967   if (CalleeF->arg_size() != Args.size())
 968     return ErrorV("Incorrect # arguments passed");
 969
 970   std::vector<Value *> ArgsV;
 971   for (unsigned i = 0, e = Args.size(); i != e; ++i) {
 972     ArgsV.push_back(Args[i]->Codegen());
 973     if (ArgsV.back() == 0)
 974       return 0;
 975   }
 976
 977   return Builder.CreateCall(CalleeF, ArgsV, "calltmp");
 978 }
 979
 980 Value *IfExprAST::Codegen() {
 981   KSDbgInfo.emitLocation(this);
 982
 983   Value *CondV = Cond->Codegen();
 984   if (CondV == 0)
 985     return 0;
 986
 987   // Convert condition to a bool by comparing equal to 0.0.
 988   CondV = Builder.CreateFCmpONE(
 989       CondV, ConstantFP::get(getGlobalContext(), APFloat(0.0)), "ifcond");
 990
 991   Function *TheFunction = Builder.GetInsertBlock()->getParent();
 992
 993   // Create blocks for the then and else cases.  Insert the 'then' block at the
 994   // end of the function.
 995   BasicBlock *ThenBB =
 996       BasicBlock::Create(getGlobalContext(), "then", TheFunction);
 997   BasicBlock *ElseBB = BasicBlock::Create(getGlobalContext(), "else");
 998   BasicBlock *MergeBB = BasicBlock::Create(getGlobalContext(), "ifcont");
 999
1000   Builder.CreateCondBr(CondV, ThenBB, ElseBB);
1001
1002   // Emit then value.
1003   Builder.SetInsertPoint(ThenBB);
1004
1005   Value *ThenV = Then->Codegen();
1006   if (ThenV == 0)
1007     return 0;
1008
1009   Builder.CreateBr(MergeBB);
1010   // Codegen of 'Then' can change the current block, update ThenBB for the PHI.
1011   ThenBB = Builder.GetInsertBlock();
1012
1013   // Emit else block.
1014   TheFunction->getBasicBlockList().push_back(ElseBB);
1015   Builder.SetInsertPoint(ElseBB);
1016
1017   Value *ElseV = Else->Codegen();
1018   if (ElseV == 0)
1019     return 0;
1020
1021   Builder.CreateBr(MergeBB);
1022   // Codegen of 'Else' can change the current block, update ElseBB for the PHI.
1023   ElseBB = Builder.GetInsertBlock();
1024
1025   // Emit merge block.
1026   TheFunction->getBasicBlockList().push_back(MergeBB);
1027   Builder.SetInsertPoint(MergeBB);
1028   PHINode *PN =
1029       Builder.CreatePHI(Type::getDoubleTy(getGlobalContext()), 2, "iftmp");
1030
1031   PN->addIncoming(ThenV, ThenBB);
1032   PN->addIncoming(ElseV, ElseBB);
1033   return PN;
1034 }
1035
1036 Value *ForExprAST::Codegen() {
1037   // Output this as:
1038   //   var = alloca double
1039   //   ...
1040   //   start = startexpr
1041   //   store start -> var
1042   //   goto loop
1043   // loop:
1044   //   ...
1045   //   bodyexpr
1046   //   ...
1047   // loopend:
1048   //   step = stepexpr
1049   //   endcond = endexpr
1050   //
1051   //   curvar = load var
1052   //   nextvar = curvar + step
1053   //   store nextvar -> var
1054   //   br endcond, loop, endloop
1055   // outloop:
1056
1057   Function *TheFunction = Builder.GetInsertBlock()->getParent();
1058
1059   // Create an alloca for the variable in the entry block.
1060   AllocaInst *Alloca = CreateEntryBlockAlloca(TheFunction, VarName);
1061
1062   KSDbgInfo.emitLocation(this);
1063
1064   // Emit the start code first, without 'variable' in scope.
1065   Value *StartVal = Start->Codegen();
1066   if (StartVal == 0)
1067     return 0;
1068
1069   // Store the value into the alloca.
1070   Builder.CreateStore(StartVal, Alloca);
1071
1072   // Make the new basic block for the loop header, inserting after current
1073   // block.
1074   BasicBlock *LoopBB =
1075       BasicBlock::Create(getGlobalContext(), "loop", TheFunction);
1076
1077   // Insert an explicit fall through from the current block to the LoopBB.
1078   Builder.CreateBr(LoopBB);
1079
1080   // Start insertion in LoopBB.
1081   Builder.SetInsertPoint(LoopBB);
1082
1083   // Within the loop, the variable is defined equal to the PHI node.  If it
1084   // shadows an existing variable, we have to restore it, so save it now.
1085   AllocaInst *OldVal = NamedValues[VarName];
1086   NamedValues[VarName] = Alloca;
1087
1088   // Emit the body of the loop.  This, like any other expr, can change the
1089   // current BB.  Note that we ignore the value computed by the body, but don't
1090   // allow an error.
1091   if (Body->Codegen() == 0)
1092     return 0;
1093
1094   // Emit the step value.
1095   Value *StepVal;
1096   if (Step) {
1097     StepVal = Step->Codegen();
1098     if (StepVal == 0)
1099       return 0;
1100   } else {
1101     // If not specified, use 1.0.
1102     StepVal = ConstantFP::get(getGlobalContext(), APFloat(1.0));
1103   }
1104
1105   // Compute the end condition.
1106   Value *EndCond = End->Codegen();
1107   if (EndCond == 0)
1108     return EndCond;
1109
1110   // Reload, increment, and restore the alloca.  This handles the case where
1111   // the body of the loop mutates the variable.
1112   Value *CurVar = Builder.CreateLoad(Alloca, VarName.c_str());
1113   Value *NextVar = Builder.CreateFAdd(CurVar, StepVal, "nextvar");
1114   Builder.CreateStore(NextVar, Alloca);
1115
1116   // Convert condition to a bool by comparing equal to 0.0.
1117   EndCond = Builder.CreateFCmpONE(
1118       EndCond, ConstantFP::get(getGlobalContext(), APFloat(0.0)), "loopcond");
1119
1120   // Create the "after loop" block and insert it.
1121   BasicBlock *AfterBB =
1122       BasicBlock::Create(getGlobalContext(), "afterloop", TheFunction);
1123
1124   // Insert the conditional branch into the end of LoopEndBB.
1125   Builder.CreateCondBr(EndCond, LoopBB, AfterBB);
1126
1127   // Any new code will be inserted in AfterBB.
1128   Builder.SetInsertPoint(AfterBB);
1129
1130   // Restore the unshadowed variable.
1131   if (OldVal)
1132     NamedValues[VarName] = OldVal;
1133   else
1134     NamedValues.erase(VarName);
1135
1136   // for expr always returns 0.0.
1137   return Constant::getNullValue(Type::getDoubleTy(getGlobalContext()));
1138 }
1139
1140 Value *VarExprAST::Codegen() {
1141   std::vector<AllocaInst *> OldBindings;
1142
1143   Function *TheFunction = Builder.GetInsertBlock()->getParent();
1144
1145   // Register all variables and emit their initializer.
1146   for (unsigned i = 0, e = VarNames.size(); i != e; ++i) {
1147     const std::string &VarName = VarNames[i].first;
1148     ExprAST *Init = VarNames[i].second;
1149
1150     // Emit the initializer before adding the variable to scope, this prevents
1151     // the initializer from referencing the variable itself, and permits stuff
1152     // like this:
1153     //  var a = 1 in
1154     //    var a = a in ...   # refers to outer 'a'.
1155     Value *InitVal;
1156     if (Init) {
1157       InitVal = Init->Codegen();
1158       if (InitVal == 0)
1159         return 0;
1160     } else { // If not specified, use 0.0.
1161       InitVal = ConstantFP::get(getGlobalContext(), APFloat(0.0));
1162     }
1163
1164     AllocaInst *Alloca = CreateEntryBlockAlloca(TheFunction, VarName);
1165     Builder.CreateStore(InitVal, Alloca);
1166
1167     // Remember the old variable binding so that we can restore the binding when
1168     // we unrecurse.
1169     OldBindings.push_back(NamedValues[VarName]);
1170
1171     // Remember this binding.
1172     NamedValues[VarName] = Alloca;
1173   }
1174
1175   KSDbgInfo.emitLocation(this);
1176
1177   // Codegen the body, now that all vars are in scope.
1178   Value *BodyVal = Body->Codegen();
1179   if (BodyVal == 0)
1180     return 0;
1181
1182   // Pop all our variables from scope.
1183   for (unsigned i = 0, e = VarNames.size(); i != e; ++i)
1184     NamedValues[VarNames[i].first] = OldBindings[i];
1185
1186   // Return the body computation.
1187   return BodyVal;
1188 }
1189
1190 Function *PrototypeAST::Codegen() {
1191   // Make the function type:  double(double,double) etc.
1192   std::vector<Type *> Doubles(Args.size(),
1193                               Type::getDoubleTy(getGlobalContext()));
1194   FunctionType *FT =
1195       FunctionType::get(Type::getDoubleTy(getGlobalContext()), Doubles, false);
1196
1197   Function *F =
1198       Function::Create(FT, Function::ExternalLinkage, Name, TheModule);
1199
1200   // If F conflicted, there was already something named 'Name'.  If it has a
1201   // body, don't allow redefinition or reextern.
1202   if (F->getName() != Name) {
1203     // Delete the one we just made and get the existing one.
1204     F->eraseFromParent();
1205     F = TheModule->getFunction(Name);
1206
1207     // If F already has a body, reject this.
1208     if (!F->empty()) {
1209       ErrorF("redefinition of function");
1210       return 0;
1211     }
1212
1213     // If F took a different number of args, reject.
1214     if (F->arg_size() != Args.size()) {
1215       ErrorF("redefinition of function with different # args");
1216       return 0;
1217     }
1218   }
1219
1220   // Set names for all arguments.
1221   unsigned Idx = 0;
1222   for (Function::arg_iterator AI = F->arg_begin(); Idx != Args.size();
1223        ++AI, ++Idx)
1224     AI->setName(Args[Idx]);
1225
1226   // Create a subprogram DIE for this function.
1227   DIFile Unit = DBuilder->createFile(KSDbgInfo.TheCU->getFilename(),
1228                                      KSDbgInfo.TheCU->getDirectory());
1229   DIDescriptor FContext = Unit;
1230   unsigned LineNo = Line;
1231   unsigned ScopeLine = Line;
1232   DISubprogram SP = DBuilder->createFunction(
1233       FContext, Name, StringRef(), Unit, LineNo,
1234       CreateFunctionType(Args.size(), Unit), false /* internal linkage */,
1235       true /* definition */, ScopeLine, DIDescriptor::FlagPrototyped, false, F);
1236
1237   KSDbgInfo.FnScopeMap[this] = SP;
1238   return F;
1239 }
1240
1241 /// CreateArgumentAllocas - Create an alloca for each argument and register the
1242 /// argument in the symbol table so that references to it will succeed.
1243 void PrototypeAST::CreateArgumentAllocas(Function *F) {
1244   Function::arg_iterator AI = F->arg_begin();
1245   for (unsigned Idx = 0, e = Args.size(); Idx != e; ++Idx, ++AI) {
1246     // Create an alloca for this variable.
1247     AllocaInst *Alloca = CreateEntryBlockAlloca(F, Args[Idx]);
1248
1249     // Create a debug descriptor for the variable.
1250     DIScope *Scope = KSDbgInfo.LexicalBlocks.back();
1251     DIFile Unit = DBuilder->createFile(KSDbgInfo.TheCU->getFilename(),
1252                                        KSDbgInfo.TheCU->getDirectory());
1253     DIVariable D = DBuilder->createLocalVariable(dwarf::DW_TAG_arg_variable,
1254                                                  *Scope, Args[Idx], Unit, Line,
1255                                                  KSDbgInfo.getDoubleTy(), Idx);
1256
1257     DBuilder->insertDeclare(Alloca, D, DBuilder->createExpression(),
1258                             DebugLoc::get(Line, 0, *Scope),
1259                             Builder.GetInsertBlock());
1260
1261     // Store the initial value into the alloca.
1262     Builder.CreateStore(AI, Alloca);
1263
1264     // Add arguments to variable symbol table.
1265     NamedValues[Args[Idx]] = Alloca;
1266   }
1267 }
1268
1269 Function *FunctionAST::Codegen() {
1270   NamedValues.clear();
1271
1272   Function *TheFunction = Proto->Codegen();
1273   if (TheFunction == 0)
1274     return 0;
1275
1276   // Push the current scope.
1277   KSDbgInfo.LexicalBlocks.push_back(&KSDbgInfo.FnScopeMap[Proto]);
1278
1279   // Unset the location for the prologue emission (leading instructions with no
1280   // location in a function are considered part of the prologue and the debugger
1281   // will run past them when breaking on a function)
1282   KSDbgInfo.emitLocation(nullptr);
1283
1284   // If this is an operator, install it.
1285   if (Proto->isBinaryOp())
1286     BinopPrecedence[Proto->getOperatorName()] = Proto->getBinaryPrecedence();
1287
1288   // Create a new basic block to start insertion into.
1289   BasicBlock *BB = BasicBlock::Create(getGlobalContext(), "entry", TheFunction);
1290   Builder.SetInsertPoint(BB);
1291
1292   // Add all arguments to the symbol table and create their allocas.
1293   Proto->CreateArgumentAllocas(TheFunction);
1294
1295   KSDbgInfo.emitLocation(Body);
1296
1297   if (Value *RetVal = Body->Codegen()) {
1298     // Finish off the function.
1299     Builder.CreateRet(RetVal);
1300
1301     // Pop off the lexical block for the function.
1302     KSDbgInfo.LexicalBlocks.pop_back();
1303
1304     // Validate the generated code, checking for consistency.
1305     verifyFunction(*TheFunction);
1306
1307     // Optimize the function.
1308     TheFPM->run(*TheFunction);
1309
1310     return TheFunction;
1311   }
1312
1313   // Error reading body, remove function.
1314   TheFunction->eraseFromParent();
1315
1316   if (Proto->isBinaryOp())
1317     BinopPrecedence.erase(Proto->getOperatorName());
1318
1319   // Pop off the lexical block for the function since we added it
1320   // unconditionally.
1321   KSDbgInfo.LexicalBlocks.pop_back();
1322
1323   return 0;
1324 }
1325
1326 //===----------------------------------------------------------------------===//
1327 // Top-Level parsing and JIT Driver
1328 //===----------------------------------------------------------------------===//
1329
1330 static ExecutionEngine *TheExecutionEngine;
1331
1332 static void HandleDefinition() {
1333   if (FunctionAST *F = ParseDefinition()) {
1334     if (!F->Codegen()) {
1335       fprintf(stderr, "Error reading function definition:");
1336     }
1337   } else {
1338     // Skip token for error recovery.
1339     getNextToken();
1340   }
1341 }
1342
1343 static void HandleExtern() {
1344   if (PrototypeAST *P = ParseExtern()) {
1345     if (!P->Codegen()) {
1346       fprintf(stderr, "Error reading extern");
1347     }
1348   } else {
1349     // Skip token for error recovery.
1350     getNextToken();
1351   }
1352 }
1353
1354 static void HandleTopLevelExpression() {
1355   // Evaluate a top-level expression into an anonymous function.
1356   if (FunctionAST *F = ParseTopLevelExpr()) {
1357     if (!F->Codegen()) {
1358       fprintf(stderr, "Error generating code for top level expr");
1359     }
1360   } else {
1361     // Skip token for error recovery.
1362     getNextToken();
1363   }
1364 }
1365
1366 /// top ::= definition | external | expression | ';'
1367 static void MainLoop() {
1368   while (1) {
1369     switch (CurTok) {
1370     case tok_eof:
1371       return;
1372     case ';':
1373       getNextToken();
1374       break; // ignore top-level semicolons.
1375     case tok_def:
1376       HandleDefinition();
1377       break;
1378     case tok_extern:
1379       HandleExtern();
1380       break;
1381     default:
1382       HandleTopLevelExpression();
1383       break;
1384     }
1385   }
1386 }
1387
1388 //===----------------------------------------------------------------------===//
1389 // "Library" functions that can be "extern'd" from user code.
1390 //===----------------------------------------------------------------------===//
1391
1392 /// putchard - putchar that takes a double and returns 0.
1393 extern "C" double putchard(double X) {
1394   putchar((char)X);
1395   return 0;
1396 }
1397
1398 /// printd - printf that takes a double prints it as "%f\n", returning 0.
1399 extern "C" double printd(double X) {
1400   printf("%f\n", X);
1401   return 0;
1402 }
1403
1404 //===----------------------------------------------------------------------===//
1405 // Main driver code.
1406 //===----------------------------------------------------------------------===//
1407
1408 int main() {
1409   InitializeNativeTarget();
1410   InitializeNativeTargetAsmPrinter();
1411   InitializeNativeTargetAsmParser();
1412   LLVMContext &Context = getGlobalContext();
1413
1414   // Install standard binary operators.
1415   // 1 is lowest precedence.
1416   BinopPrecedence['='] = 2;
1417   BinopPrecedence['<'] = 10;
1418   BinopPrecedence['+'] = 20;
1419   BinopPrecedence['-'] = 20;
1420   BinopPrecedence['*'] = 40; // highest.
1421
1422   // Prime the first token.
1423   getNextToken();
1424
1425   // Make the module, which holds all the code.
1426   std::unique_ptr<Module> Owner = make_unique<Module>("my cool jit", Context);
1427   TheModule = Owner.get();
1428
1429   // Add the current debug info version into the module.
1430   TheModule->addModuleFlag(Module::Warning, "Debug Info Version",
1431                            DEBUG_METADATA_VERSION);
1432
1433   // Darwin only supports dwarf2.
1434   if (Triple(sys::getProcessTriple()).isOSDarwin())
1435     TheModule->addModuleFlag(llvm::Module::Warning, "Dwarf Version", 2);
1436
1437   // Construct the DIBuilder, we do this here because we need the module.
1438   DBuilder = new DIBuilder(*TheModule);
1439
1440   // Create the compile unit for the module.
1441   // Currently down as "fib.ks" as a filename since we're redirecting stdin
1442   // but we'd like actual source locations.
1443   KSDbgInfo.TheCU = DBuilder->createCompileUnit(
1444       dwarf::DW_LANG_C, "fib.ks", ".", "Kaleidoscope Compiler", 0, "", 0);
1445
1446   // Create the JIT.  This takes ownership of the module.
1447   std::string ErrStr;
1448   TheExecutionEngine =
1449       EngineBuilder(std::move(Owner))
1450           .setErrorStr(&ErrStr)
1451           .setMCJITMemoryManager(llvm::make_unique<SectionMemoryManager>())
1452           .create();
1453   if (!TheExecutionEngine) {
1454     fprintf(stderr, "Could not create ExecutionEngine: %s\n", ErrStr.c_str());
1455     exit(1);
1456   }
1457
1458   legacy::FunctionPassManager OurFPM(TheModule);
1459
1460   // Set up the optimizer pipeline.  Start with registering info about how the
1461   // target lays out data structures.
1462   TheModule->setDataLayout(*TheExecutionEngine->getDataLayout());
1463 #if 0
1464   // Provide basic AliasAnalysis support for GVN.
1465   OurFPM.add(createBasicAliasAnalysisPass());
1466   // Promote allocas to registers.
1467   OurFPM.add(createPromoteMemoryToRegisterPass());
1468   // Do simple "peephole" optimizations and bit-twiddling optzns.
1469   OurFPM.add(createInstructionCombiningPass());
1470   // Reassociate expressions.
1471   OurFPM.add(createReassociatePass());
1472   // Eliminate Common SubExpressions.
1473   OurFPM.add(createGVNPass());
1474   // Simplify the control flow graph (deleting unreachable blocks, etc).
1475   OurFPM.add(createCFGSimplificationPass());
1476   #endif
1477   OurFPM.doInitialization();
1478
1479   // Set the global so the code gen can use this.
1480   TheFPM = &OurFPM;
1481
1482   // Run the main "interpreter loop" now.
1483   MainLoop();
1484
1485   TheFPM = 0;
1486
1487   // Finalize the debug info.
1488   DBuilder->finalize();
1489
1490   // Print out all of the generated code.
1491   TheModule->dump();
1492
1493   return 0;
1494 }