[LLVM] Fix some Clang-tidy modernize-use-bool-literals and Include What You Use warnings in examples; other minor fixes

[hans]

lgtm

llvm/trunk/examples/Kaleidoscope/Chapter2/toy.cpp

 #include <cctype>
 #include <cstdio>
+#include <cstdlib>
 #include <map>
 #include <memory>
 #include <string>
 #include <vector>
 
 namespace helper {
 // Cloning make_unique here until it's standard in C++14.
 // Using a namespace to avoid conflicting with MSVC's std::make_unique (which
 // ADL can sometimes find in unqualified calls).
 template <class T, class... Args>
 static
     typename std::enable_if<!std::is_array<T>::value, std::unique_ptr<T>>::type
     make_unique(Args &&... args) {
   return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
 }
-}
+} // end namespace helper
 
 //===----------------------------------------------------------------------===//
 // Lexer
 //===----------------------------------------------------------------------===//
 
 // The lexer returns tokens [0-255] if it is an unknown character, otherwise one
 // of these for known things.
 enum Token {
static std::unique_ptr<ExprAST> ParseIdentifierExpr() {
 
   if (CurTok != '(') // Simple variable ref.
     return helper::make_unique<VariableExprAST>(IdName);
 
   // Call.
   getNextToken(); // eat (
   std::vector<std::unique_ptr<ExprAST>> Args;
   if (CurTok != ')') {
-    while (1) {
+    while (true) {
       if (auto Arg = ParseExpression())
         Args.push_back(std::move(Arg));
       else
         return nullptr;
 
       if (CurTok == ')')
         break;
 
static std::unique_ptr<ExprAST> ParsePrimary() {
   }
 }
 
 /// binoprhs
 ///   ::= ('+' primary)*
 static std::unique_ptr<ExprAST> ParseBinOpRHS(int ExprPrec,
                                               std::unique_ptr<ExprAST> LHS) {
   // If this is a binop, find its precedence.
-  while (1) {
+  while (true) {
     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.
static void HandleTopLevelExpression() {
   } else {
     // Skip token for error recovery.
     getNextToken();
   }
 }
 
 /// top ::= definition | external | expression | ';'
 static void MainLoop() {
-  while (1) {
+  while (true) {
     fprintf(stderr, "ready> ");
     switch (CurTok) {
     case tok_eof:
       return;
     case ';': // ignore top-level semicolons.
       getNextToken();
       break;
     case tok_def:

llvm/trunk/examples/Kaleidoscope/Chapter3/toy.cpp

+#include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/IR/BasicBlock.h"
+#include "llvm/IR/Constants.h"
+#include "llvm/IR/DerivedTypes.h"
+#include "llvm/IR/Function.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
+#include "llvm/IR/Type.h"
 #include "llvm/IR/Verifier.h"
 #include <cctype>
 #include <cstdio>
+#include <cstdlib>
 #include <map>
+#include <memory>
 #include <string>
 #include <vector>
 
 using namespace llvm;
 
 //===----------------------------------------------------------------------===//
 // Lexer
 //===----------------------------------------------------------------------===//
static std::unique_ptr<ExprAST> ParseIdentifierExpr() {
 
   if (CurTok != '(') // Simple variable ref.
     return llvm::make_unique<VariableExprAST>(IdName);
 
   // Call.
   getNextToken(); // eat (
   std::vector<std::unique_ptr<ExprAST>> Args;
   if (CurTok != ')') {
-    while (1) {
+    while (true) {
       if (auto Arg = ParseExpression())
         Args.push_back(std::move(Arg));
       else
         return nullptr;
 
       if (CurTok == ')')
         break;
 
static std::unique_ptr<ExprAST> ParsePrimary() {
   }
 }
 
 /// binoprhs
 ///   ::= ('+' primary)*
 static std::unique_ptr<ExprAST> ParseBinOpRHS(int ExprPrec,
                                               std::unique_ptr<ExprAST> LHS) {
   // If this is a binop, find its precedence.
-  while (1) {
+  while (true) {
     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.
static void HandleTopLevelExpression() {
   } else {
     // Skip token for error recovery.
     getNextToken();
   }
 }
 
 /// top ::= definition | external | expression | ';'
 static void MainLoop() {
-  while (1) {
+  while (true) {
     fprintf(stderr, "ready> ");
     switch (CurTok) {
     case tok_eof:
       return;
     case ';': // ignore top-level semicolons.
       getNextToken();
       break;
     case tok_def:

llvm/trunk/examples/Kaleidoscope/Chapter4/toy.cpp

+#include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/STLExtras.h"
-#include "llvm/Analysis/Passes.h"
+#include "llvm/IR/BasicBlock.h"
+#include "llvm/IR/Constants.h"
+#include "llvm/IR/DerivedTypes.h"
+#include "llvm/IR/Function.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/LegacyPassManager.h"
 #include "llvm/IR/Module.h"
+#include "llvm/IR/Type.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/Support/TargetSelect.h"
+#include "llvm/Target/TargetMachine.h"
 #include "llvm/Transforms/Scalar.h"
 #include "llvm/Transforms/Scalar/GVN.h"
+#include "../include/KaleidoscopeJIT.h"
+#include <cassert>
 #include <cctype>
+#include <cstdint>
 #include <cstdio>
+#include <cstdlib>
 #include <map>
+#include <memory>
 #include <string>
 #include <vector>
-#include "../include/KaleidoscopeJIT.h"
 
 using namespace llvm;
 using namespace llvm::orc;
 
 //===----------------------------------------------------------------------===//
 // Lexer
 //===----------------------------------------------------------------------===//
 
static std::unique_ptr<ExprAST> ParseIdentifierExpr() {
 
   if (CurTok != '(') // Simple variable ref.
     return llvm::make_unique<VariableExprAST>(IdName);
 
   // Call.
   getNextToken(); // eat (
   std::vector<std::unique_ptr<ExprAST>> Args;
   if (CurTok != ')') {
-    while (1) {
+    while (true) {
       if (auto Arg = ParseExpression())
         Args.push_back(std::move(Arg));
       else
         return nullptr;
 
       if (CurTok == ')')
         break;
 
static std::unique_ptr<ExprAST> ParsePrimary() {
   }
 }
 
 /// binoprhs
 ///   ::= ('+' primary)*
 static std::unique_ptr<ExprAST> ParseBinOpRHS(int ExprPrec,
                                               std::unique_ptr<ExprAST> LHS) {
   // If this is a binop, find its precedence.
-  while (1) {
+  while (true) {
     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.
if (auto ProtoAST = ParseExtern()) {
     getNextToken();
   }
 }
 
 static void HandleTopLevelExpression() {
   // Evaluate a top-level expression into an anonymous function.
   if (auto FnAST = ParseTopLevelExpr()) {
     if (FnAST->codegen()) {
-
       // JIT the module containing the anonymous expression, keeping a handle so
       // we can free it later.
       auto H = TheJIT->addModule(std::move(TheModule));
       InitializeModuleAndPassManager();
 
       // Search the JIT for the __anon_expr symbol.
       auto ExprSymbol = TheJIT->findSymbol("__anon_expr");
       assert(ExprSymbol && "Function not found");
static void HandleTopLevelExpression() {
   } else {
     // Skip token for error recovery.
     getNextToken();
   }
 }
 
 /// top ::= definition | external | expression | ';'
 static void MainLoop() {
-  while (1) {
+  while (true) {
     fprintf(stderr, "ready> ");
     switch (CurTok) {
     case tok_eof:
       return;
     case ';': // ignore top-level semicolons.
       getNextToken();
       break;
     case tok_def:

llvm/trunk/examples/Kaleidoscope/Chapter5/toy.cpp

+#include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/STLExtras.h"
-#include "llvm/Analysis/Passes.h"
+#include "llvm/IR/BasicBlock.h"
+#include "llvm/IR/Constants.h"
+#include "llvm/IR/DerivedTypes.h"
+#include "llvm/IR/Function.h"
+#include "llvm/IR/Instructions.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/LegacyPassManager.h"
 #include "llvm/IR/Module.h"
+#include "llvm/IR/Type.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/Support/TargetSelect.h"
+#include "llvm/Target/TargetMachine.h"
 #include "llvm/Transforms/Scalar.h"
 #include "llvm/Transforms/Scalar/GVN.h"
+#include "../include/KaleidoscopeJIT.h"
+#include <cassert>
 #include <cctype>
+#include <cstdint>
 #include <cstdio>
+#include <cstdlib>
 #include <map>
+#include <memory>
 #include <string>
 #include <vector>
-#include "../include/KaleidoscopeJIT.h"
 
 using namespace llvm;
 using namespace llvm::orc;
 
 //===----------------------------------------------------------------------===//
 // Lexer
 //===----------------------------------------------------------------------===//
 
static std::unique_ptr<ExprAST> ParseIdentifierExpr() {
 
   if (CurTok != '(') // Simple variable ref.
     return llvm::make_unique<VariableExprAST>(IdName);
 
   // Call.
   getNextToken(); // eat (
   std::vector<std::unique_ptr<ExprAST>> Args;
   if (CurTok != ')') {
-    while (1) {
+    while (true) {
       if (auto Arg = ParseExpression())
         Args.push_back(std::move(Arg));
       else
         return nullptr;
 
       if (CurTok == ')')
         break;
 
static std::unique_ptr<ExprAST> ParsePrimary() {
   }
 }
 
 /// binoprhs
 ///   ::= ('+' primary)*
 static std::unique_ptr<ExprAST> ParseBinOpRHS(int ExprPrec,
                                               std::unique_ptr<ExprAST> LHS) {
   // If this is a binop, find its precedence.
-  while (1) {
+  while (true) {
     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.
Value *ForExprAST::codegen() {
   // Insert an explicit fall through from the current block to the LoopBB.
   Builder.CreateBr(LoopBB);
 
   // Start insertion in LoopBB.
   Builder.SetInsertPoint(LoopBB);
 
   // Start the PHI node with an entry for Start.
   PHINode *Variable =
-      Builder.CreatePHI(Type::getDoubleTy(TheContext), 2, VarName.c_str());
+      Builder.CreatePHI(Type::getDoubleTy(TheContext), 2, VarName);
   Variable->addIncoming(StartVal, PreheaderBB);
 
   // 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.
   Value *OldVal = NamedValues[VarName];
   NamedValues[VarName] = Variable;
 
   // Emit the body of the loop.  This, like any other expr, can change the
if (auto ProtoAST = ParseExtern()) {
     getNextToken();
   }
 }
 
 static void HandleTopLevelExpression() {
   // Evaluate a top-level expression into an anonymous function.
   if (auto FnAST = ParseTopLevelExpr()) {
     if (FnAST->codegen()) {
-
       // JIT the module containing the anonymous expression, keeping a handle so
       // we can free it later.
       auto H = TheJIT->addModule(std::move(TheModule));
       InitializeModuleAndPassManager();
 
       // Search the JIT for the __anon_expr symbol.
       auto ExprSymbol = TheJIT->findSymbol("__anon_expr");
       assert(ExprSymbol && "Function not found");
static void HandleTopLevelExpression() {
   } else {
     // Skip token for error recovery.
     getNextToken();
   }
 }
 
 /// top ::= definition | external | expression | ';'
 static void MainLoop() {
-  while (1) {
+  while (true) {
     fprintf(stderr, "ready> ");
     switch (CurTok) {
     case tok_eof:
       return;
     case ';': // ignore top-level semicolons.
       getNextToken();
       break;
     case tok_def:

llvm/trunk/examples/Kaleidoscope/Chapter6/toy.cpp

+#include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/STLExtras.h"
-#include "llvm/Analysis/Passes.h"
+#include "llvm/IR/BasicBlock.h"
+#include "llvm/IR/Constants.h"
+#include "llvm/IR/DerivedTypes.h"
+#include "llvm/IR/Function.h"
+#include "llvm/IR/Instructions.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/LegacyPassManager.h"
 #include "llvm/IR/Module.h"
+#include "llvm/IR/Type.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/Support/TargetSelect.h"
+#include "llvm/Target/TargetMachine.h"
 #include "llvm/Transforms/Scalar.h"
 #include "llvm/Transforms/Scalar/GVN.h"
+#include "../include/KaleidoscopeJIT.h"
+#include <cassert>
 #include <cctype>
+#include <cstdint>
 #include <cstdio>
+#include <cstdlib>
 #include <map>
+#include <memory>
 #include <string>
 #include <vector>
-#include "../include/KaleidoscopeJIT.h"
 
 using namespace llvm;
 using namespace llvm::orc;
 
 //===----------------------------------------------------------------------===//
 // Lexer
 //===----------------------------------------------------------------------===//
 
static std::unique_ptr<ExprAST> ParseIdentifierExpr() {
 
   if (CurTok != '(') // Simple variable ref.
     return llvm::make_unique<VariableExprAST>(IdName);
 
   // Call.
   getNextToken(); // eat (
   std::vector<std::unique_ptr<ExprAST>> Args;
   if (CurTok != ')') {
-    while (1) {
+    while (true) {
       if (auto Arg = ParseExpression())
         Args.push_back(std::move(Arg));
       else
         return nullptr;
 
       if (CurTok == ')')
         break;
 
static std::unique_ptr<ExprAST> ParseUnary() {
   return nullptr;
 }
 
 /// binoprhs
 ///   ::= ('+' unary)*
 static std::unique_ptr<ExprAST> ParseBinOpRHS(int ExprPrec,
                                               std::unique_ptr<ExprAST> LHS) {
   // If this is a binop, find its precedence.
-  while (1) {
+  while (true) {
     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.
Value *ForExprAST::codegen() {
   // Insert an explicit fall through from the current block to the LoopBB.
   Builder.CreateBr(LoopBB);
 
   // Start insertion in LoopBB.
   Builder.SetInsertPoint(LoopBB);
 
   // Start the PHI node with an entry for Start.
   PHINode *Variable =
-      Builder.CreatePHI(Type::getDoubleTy(TheContext), 2, VarName.c_str());
+      Builder.CreatePHI(Type::getDoubleTy(TheContext), 2, VarName);
   Variable->addIncoming(StartVal, PreheaderBB);
 
   // 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.
   Value *OldVal = NamedValues[VarName];
   NamedValues[VarName] = Variable;
 
   // Emit the body of the loop.  This, like any other expr, can change the
if (auto ProtoAST = ParseExtern()) {
     getNextToken();
   }
 }
 
 static void HandleTopLevelExpression() {
   // Evaluate a top-level expression into an anonymous function.
   if (auto FnAST = ParseTopLevelExpr()) {
     if (FnAST->codegen()) {
-
       // JIT the module containing the anonymous expression, keeping a handle so
       // we can free it later.
       auto H = TheJIT->addModule(std::move(TheModule));
       InitializeModuleAndPassManager();
 
       // Search the JIT for the __anon_expr symbol.
       auto ExprSymbol = TheJIT->findSymbol("__anon_expr");
       assert(ExprSymbol && "Function not found");
static void HandleTopLevelExpression() {
   } else {
     // Skip token for error recovery.
     getNextToken();
   }
 }
 
 /// top ::= definition | external | expression | ';'
 static void MainLoop() {
-  while (1) {
+  while (true) {
     fprintf(stderr, "ready> ");
     switch (CurTok) {
     case tok_eof:
       return;
     case ';': // ignore top-level semicolons.
       getNextToken();
       break;
     case tok_def:

llvm/trunk/examples/Kaleidoscope/Chapter7/toy.cpp

+#include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/STLExtras.h"
-#include "llvm/Analysis/Passes.h"
+#include "llvm/IR/BasicBlock.h"
+#include "llvm/IR/Constants.h"
+#include "llvm/IR/DerivedTypes.h"
+#include "llvm/IR/Function.h"
+#include "llvm/IR/Instructions.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/LegacyPassManager.h"
 #include "llvm/IR/Module.h"
+#include "llvm/IR/Type.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/Support/TargetSelect.h"
+#include "llvm/Target/TargetMachine.h"
 #include "llvm/Transforms/Scalar.h"
 #include "llvm/Transforms/Scalar/GVN.h"
+#include "../include/KaleidoscopeJIT.h"
+#include <cassert>
 #include <cctype>
+#include <cstdint>
 #include <cstdio>
+#include <cstdlib>
 #include <map>
+#include <memory>
 #include <string>
+#include <utility>
 #include <vector>
-#include "../include/KaleidoscopeJIT.h"
 
 using namespace llvm;
 using namespace llvm::orc;
 
 //===----------------------------------------------------------------------===//
 // Lexer
 //===----------------------------------------------------------------------===//
 
static std::unique_ptr<ExprAST> ParseIdentifierExpr() {
 
   if (CurTok != '(') // Simple variable ref.
     return llvm::make_unique<VariableExprAST>(IdName);
 
   // Call.
   getNextToken(); // eat (
   std::vector<std::unique_ptr<ExprAST>> Args;
   if (CurTok != ')') {
-    while (1) {
+    while (true) {
       if (auto Arg = ParseExpression())
         Args.push_back(std::move(Arg));
       else
         return nullptr;
 
       if (CurTok == ')')
         break;
 
static std::unique_ptr<ExprAST> ParseVarExpr() {
   getNextToken(); // eat the var.
 
   std::vector<std::pair<std::string, std::unique_ptr<ExprAST>>> VarNames;
 
   // At least one variable name is required.
   if (CurTok != tok_identifier)
     return LogError("expected identifier after var");
 
-  while (1) {
+  while (true) {
     std::string Name = IdentifierStr;
     getNextToken(); // eat identifier.
 
     // Read the optional initializer.
     std::unique_ptr<ExprAST> Init = nullptr;
     if (CurTok == '=') {
       getNextToken(); // eat the '='.
 
static std::unique_ptr<ExprAST> ParseUnary() {
   return nullptr;
 }
 
 /// binoprhs
 ///   ::= ('+' unary)*
 static std::unique_ptr<ExprAST> ParseBinOpRHS(int ExprPrec,
                                               std::unique_ptr<ExprAST> LHS) {
   // If this is a binop, find its precedence.
-  while (1) {
+  while (true) {
     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.

 }
 
 /// CreateEntryBlockAlloca - Create an alloca instruction in the entry block of
 /// the function.  This is used for mutable variables etc.
 static AllocaInst *CreateEntryBlockAlloca(Function *TheFunction,
                                           const std::string &VarName) {
   IRBuilder<> TmpB(&TheFunction->getEntryBlock(),
                    TheFunction->getEntryBlock().begin());
-  return TmpB.CreateAlloca(Type::getDoubleTy(TheContext), nullptr,
-                           VarName.c_str());
+  return TmpB.CreateAlloca(Type::getDoubleTy(TheContext), nullptr, VarName);
 }
 
 Value *NumberExprAST::codegen() {
   return ConstantFP::get(TheContext, APFloat(Val));
 }
 
 Value *VariableExprAST::codegen() {
   // Look this variable up in the function.
if (auto ProtoAST = ParseExtern()) {
     getNextToken();
   }
 }
 
 static void HandleTopLevelExpression() {
   // Evaluate a top-level expression into an anonymous function.
   if (auto FnAST = ParseTopLevelExpr()) {
     if (FnAST->codegen()) {
-
       // JIT the module containing the anonymous expression, keeping a handle so
       // we can free it later.
       auto H = TheJIT->addModule(std::move(TheModule));
       InitializeModuleAndPassManager();
 
       // Search the JIT for the __anon_expr symbol.
       auto ExprSymbol = TheJIT->findSymbol("__anon_expr");
       assert(ExprSymbol && "Function not found");
static void HandleTopLevelExpression() {
   } else {
     // Skip token for error recovery.
     getNextToken();
   }
 }
 
 /// top ::= definition | external | expression | ';'
 static void MainLoop() {
-  while (1) {
+  while (true) {
     fprintf(stderr, "ready> ");
     switch (CurTok) {
     case tok_eof:
       return;
     case ';': // ignore top-level semicolons.
       getNextToken();
       break;
     case tok_def:

llvm/trunk/examples/Kaleidoscope/Chapter8/toy.cpp

+#include "llvm/ADT/APFloat.h"
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/STLExtras.h"
-#include "llvm/Analysis/BasicAliasAnalysis.h"
-#include "llvm/Analysis/Passes.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/Triple.h"
+#include "llvm/IR/BasicBlock.h"
+#include "llvm/IR/Constants.h"
+#include "llvm/IR/DebugInfoMetadata.h"
+#include "llvm/IR/DebugLoc.h"
+#include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/DIBuilder.h"
+#include "llvm/IR/Function.h"
+#include "llvm/IR/Instructions.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/LLVMContext.h"
-#include "llvm/IR/LegacyPassManager.h"
+#include "llvm/IR/Metadata.h"
 #include "llvm/IR/Module.h"
+#include "llvm/IR/Type.h"
 #include "llvm/IR/Verifier.h"
+#include "llvm/Support/Host.h"
+#include "llvm/Support/raw_ostream.h"
 #include "llvm/Support/TargetSelect.h"
-#include "llvm/Transforms/Scalar.h"
+#include "llvm/Target/TargetMachine.h"
+#include "../include/KaleidoscopeJIT.h"
+#include <cassert>
 #include <cctype>
 #include <cstdio>
+#include <cstdlib>
 #include <map>
+#include <memory>
 #include <string>
+#include <utility>
 #include <vector>
-#include "../include/KaleidoscopeJIT.h"
 
 using namespace llvm;
 using namespace llvm::orc;
 
 //===----------------------------------------------------------------------===//
 // Lexer
 //===----------------------------------------------------------------------===//
 
case tok_unary:
     return "unary";
   case tok_var:
     return "var";
   }
   return std::string(1, (char)Tok);
 }
 
 namespace {
-class PrototypeAST;
 class ExprAST;
-}
+} // end anonymous namespace
+
 static LLVMContext TheContext;
 static IRBuilder<> Builder(TheContext);
 struct DebugInfo {
   DICompileUnit *TheCU;
   DIType *DblTy;
   std::vector<DIScope *> LexicalBlocks;
 
   void emitLocation(ExprAST *AST);
class ExprAST {
   SourceLocation Loc;
 
 public:
   ExprAST(SourceLocation Loc = CurLoc) : Loc(Loc) {}
   virtual ~ExprAST() {}
   virtual Value *codegen() = 0;
   int getLine() const { return Loc.Line; }
   int getCol() const { return Loc.Col; }
+
   virtual raw_ostream &dump(raw_ostream &out, int ind) {
     return out << ':' << getLine() << ':' << getCol() << '\n';
   }
 };
 
 /// NumberExprAST - Expression class for numeric literals like "1.0".
 class NumberExprAST : public ExprAST {
   double Val;
 
 public:
   NumberExprAST(double Val) : Val(Val) {}
+  Value *codegen() override;
+
   raw_ostream &dump(raw_ostream &out, int ind) override {
     return ExprAST::dump(out << Val, ind);
   }
-  Value *codegen() override;
 };
 
 /// VariableExprAST - Expression class for referencing a variable, like "a".
 class VariableExprAST : public ExprAST {
   std::string Name;
 
 public:
   VariableExprAST(SourceLocation Loc, const std::string &Name)
       : ExprAST(Loc), Name(Name) {}
   const std::string &getName() const { return Name; }
   Value *codegen() override;
+
   raw_ostream &dump(raw_ostream &out, int ind) override {
     return ExprAST::dump(out << Name, ind);
   }
 };
 
 /// UnaryExprAST - Expression class for a unary operator.
 class UnaryExprAST : public ExprAST {
   char Opcode;
   std::unique_ptr<ExprAST> Operand;
 
 public:
   UnaryExprAST(char Opcode, std::unique_ptr<ExprAST> Operand)
       : Opcode(Opcode), Operand(std::move(Operand)) {}
   Value *codegen() override;
+
   raw_ostream &dump(raw_ostream &out, int ind) override {
     ExprAST::dump(out << "unary" << Opcode, ind);
     Operand->dump(out, ind + 1);
     return out;
   }
 };
 
 /// BinaryExprAST - Expression class for a binary operator.
 class BinaryExprAST : public ExprAST {
   char Op;
   std::unique_ptr<ExprAST> LHS, RHS;
 
 public:
   BinaryExprAST(SourceLocation Loc, char Op, std::unique_ptr<ExprAST> LHS,
                 std::unique_ptr<ExprAST> RHS)
       : ExprAST(Loc), Op(Op), LHS(std::move(LHS)), RHS(std::move(RHS)) {}
   Value *codegen() override;
+
   raw_ostream &dump(raw_ostream &out, int ind) override {
     ExprAST::dump(out << "binary" << Op, ind);
     LHS->dump(indent(out, ind) << "LHS:", ind + 1);
     RHS->dump(indent(out, ind) << "RHS:", ind + 1);
     return out;
   }
 };
 
 /// CallExprAST - Expression class for function calls.
 class CallExprAST : public ExprAST {
   std::string Callee;
   std::vector<std::unique_ptr<ExprAST>> Args;
 
 public:
   CallExprAST(SourceLocation Loc, const std::string &Callee,
               std::vector<std::unique_ptr<ExprAST>> Args)
       : ExprAST(Loc), Callee(Callee), Args(std::move(Args)) {}
   Value *codegen() override;
+
   raw_ostream &dump(raw_ostream &out, int ind) override {
     ExprAST::dump(out << "call " << Callee, ind);
     for (const auto &Arg : Args)
       Arg->dump(indent(out, ind + 1), ind + 1);
     return out;
   }
 };
 
 /// IfExprAST - Expression class for if/then/else.
 class IfExprAST : public ExprAST {
   std::unique_ptr<ExprAST> Cond, Then, Else;
 
 public:
   IfExprAST(SourceLocation Loc, std::unique_ptr<ExprAST> Cond,
             std::unique_ptr<ExprAST> Then, std::unique_ptr<ExprAST> Else)
       : ExprAST(Loc), Cond(std::move(Cond)), Then(std::move(Then)),
         Else(std::move(Else)) {}
   Value *codegen() override;
+
   raw_ostream &dump(raw_ostream &out, int ind) override {
     ExprAST::dump(out << "if", ind);
     Cond->dump(indent(out, ind) << "Cond:", ind + 1);
     Then->dump(indent(out, ind) << "Then:", ind + 1);
     Else->dump(indent(out, ind) << "Else:", ind + 1);
     return out;
   }
 };
 
 /// ForExprAST - Expression class for for/in.
 class ForExprAST : public ExprAST {
   std::string VarName;
   std::unique_ptr<ExprAST> Start, End, Step, Body;
 
 public:
   ForExprAST(const std::string &VarName, std::unique_ptr<ExprAST> Start,
              std::unique_ptr<ExprAST> End, std::unique_ptr<ExprAST> Step,
              std::unique_ptr<ExprAST> Body)
       : VarName(VarName), Start(std::move(Start)), End(std::move(End)),
         Step(std::move(Step)), Body(std::move(Body)) {}
   Value *codegen() override;
+
   raw_ostream &dump(raw_ostream &out, int ind) override {
     ExprAST::dump(out << "for", ind);
     Start->dump(indent(out, ind) << "Cond:", ind + 1);
     End->dump(indent(out, ind) << "End:", ind + 1);
     Step->dump(indent(out, ind) << "Step:", ind + 1);
     Body->dump(indent(out, ind) << "Body:", ind + 1);
     return out;
   }
 };
 
 /// VarExprAST - Expression class for var/in
 class VarExprAST : public ExprAST {
   std::vector<std::pair<std::string, std::unique_ptr<ExprAST>>> VarNames;
   std::unique_ptr<ExprAST> Body;
 
 public:
   VarExprAST(
       std::vector<std::pair<std::string, std::unique_ptr<ExprAST>>> VarNames,
       std::unique_ptr<ExprAST> Body)
       : VarNames(std::move(VarNames)), Body(std::move(Body)) {}
   Value *codegen() override;
+
   raw_ostream &dump(raw_ostream &out, int ind) override {
     ExprAST::dump(out << "var", ind);
     for (const auto &NamedVar : VarNames)
       NamedVar.second->dump(indent(out, ind) << NamedVar.first << ':', ind + 1);
     Body->dump(indent(out, ind) << "Body:", ind + 1);
     return out;
   }
 };
class FunctionAST {
   std::unique_ptr<PrototypeAST> Proto;
   std::unique_ptr<ExprAST> Body;
 
 public:
   FunctionAST(std::unique_ptr<PrototypeAST> Proto,
               std::unique_ptr<ExprAST> Body)
       : Proto(std::move(Proto)), Body(std::move(Body)) {}
   Function *codegen();
+
   raw_ostream &dump(raw_ostream &out, int ind) {
     indent(out, ind) << "FunctionAST\n";
     ++ind;
     indent(out, ind) << "Body:";
     return Body ? Body->dump(out, ind) : out << "null\n";
   }
 };
 } // end anonymous namespace
static std::unique_ptr<ExprAST> ParseIdentifierExpr() {
 
   if (CurTok != '(') // Simple variable ref.
     return llvm::make_unique<VariableExprAST>(LitLoc, IdName);
 
   // Call.
   getNextToken(); // eat (
   std::vector<std::unique_ptr<ExprAST>> Args;
   if (CurTok != ')') {
-    while (1) {
+    while (true) {
       if (auto Arg = ParseExpression())
         Args.push_back(std::move(Arg));
       else
         return nullptr;
 
       if (CurTok == ')')
         break;
 
static std::unique_ptr<ExprAST> ParseVarExpr() {
   getNextToken(); // eat the var.
 
   std::vector<std::pair<std::string, std::unique_ptr<ExprAST>>> VarNames;
 
   // At least one variable name is required.
   if (CurTok != tok_identifier)
     return LogError("expected identifier after var");
 
-  while (1) {
+  while (true) {
     std::string Name = IdentifierStr;
     getNextToken(); // eat identifier.
 
     // Read the optional initializer.
     std::unique_ptr<ExprAST> Init = nullptr;
     if (CurTok == '=') {
       getNextToken(); // eat the '='.
 
static std::unique_ptr<ExprAST> ParseUnary() {
   return nullptr;
 }
 
 /// binoprhs
 ///   ::= ('+' unary)*
 static std::unique_ptr<ExprAST> ParseBinOpRHS(int ExprPrec,
                                               std::unique_ptr<ExprAST> LHS) {
   // If this is a binop, find its precedence.
-  while (1) {
+  while (true) {
     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.

 }
 
 /// CreateEntryBlockAlloca - Create an alloca instruction in the entry block of
 /// the function.  This is used for mutable variables etc.
 static AllocaInst *CreateEntryBlockAlloca(Function *TheFunction,
                                           const std::string &VarName) {
   IRBuilder<> TmpB(&TheFunction->getEntryBlock(),
                    TheFunction->getEntryBlock().begin());
-  return TmpB.CreateAlloca(Type::getDoubleTy(TheContext), nullptr,
-                           VarName.c_str());
+  return TmpB.CreateAlloca(Type::getDoubleTy(TheContext), nullptr, VarName);
 }
 
 Value *NumberExprAST::codegen() {
   KSDbgInfo.emitLocation(this);
   return ConstantFP::get(TheContext, APFloat(Val));
 }
 
 Value *VariableExprAST::codegen() {
static void HandleTopLevelExpression() {
   } else {
     // Skip token for error recovery.
     getNextToken();
   }
 }
 
 /// top ::= definition | external | expression | ';'
 static void MainLoop() {
-  while (1) {
+  while (true) {
     switch (CurTok) {
     case tok_eof:
       return;
     case ';': // ignore top-level semicolons.
       getNextToken();
       break;
     case tok_def:
       HandleDefinition();
int main() {
 
   // Construct the DIBuilder, we do this here because we need the module.
   DBuilder = llvm::make_unique<DIBuilder>(*TheModule);
 
   // Create the compile unit for the module.
   // Currently down as "fib.ks" as a filename since we're redirecting stdin
   // but we'd like actual source locations.
   KSDbgInfo.TheCU = DBuilder->createCompileUnit(
-      dwarf::DW_LANG_C, "fib.ks", ".", "Kaleidoscope Compiler", 0, "", 0);
+      dwarf::DW_LANG_C, "fib.ks", ".", "Kaleidoscope Compiler", false, "", 0);
 
   // Run the main "interpreter loop" now.
   MainLoop();
 
   // Finalize the debug info.
   DBuilder->finalize();
 
   // Print out all of the generated code.
   TheModule->dump();
 
   return 0;
 }

llvm/trunk/examples/Kaleidoscope/Orc/fully_lazy/toy.cpp

-#include "llvm/Analysis/Passes.h"
+#include "llvm/ADT/APFloat.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ExecutionEngine/ExecutionEngine.h"
+#include "llvm/ExecutionEngine/RuntimeDyld.h"
+#include "llvm/ExecutionEngine/SectionMemoryManager.h"
 #include "llvm/ExecutionEngine/Orc/CompileUtils.h"
+#include "llvm/ExecutionEngine/Orc/IndirectionUtils.h"
 #include "llvm/ExecutionEngine/Orc/IRCompileLayer.h"
+#include "llvm/ExecutionEngine/Orc/JITSymbol.h"
 #include "llvm/ExecutionEngine/Orc/LambdaResolver.h"
 #include "llvm/ExecutionEngine/Orc/LazyEmittingLayer.h"
 #include "llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h"
 #include "llvm/ExecutionEngine/Orc/OrcABISupport.h"
-#include "llvm/IR/DataLayout.h"
+#include "llvm/IR/BasicBlock.h"
+#include "llvm/IR/Constant.h"
+#include "llvm/IR/Constants.h"
 #include "llvm/IR/DerivedTypes.h"
+#include "llvm/IR/Function.h"
+#include "llvm/IR/GlobalVariable.h"
+#include "llvm/IR/Instructions.h"
 #include "llvm/IR/IRBuilder.h"
-#include "llvm/IR/LegacyPassManager.h"
 #include "llvm/IR/LLVMContext.h"
+#include "llvm/IR/Mangler.h"
 #include "llvm/IR/Module.h"
+#include "llvm/IR/Type.h"
 #include "llvm/IR/Verifier.h"
+#include "llvm/Support/raw_ostream.h"
 #include "llvm/Support/TargetSelect.h"
-#include "llvm/Transforms/Scalar.h"
+#include "llvm/Target/TargetMachine.h"
+#include <cassert>
 #include <cctype>
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
 #include <iomanip>
 #include <iostream>
 #include <map>
+#include <memory>
 #include <sstream>
 #include <string>
+#include <utility>
 #include <vector>
 
 using namespace llvm;
 using namespace llvm::orc;
 
 //===----------------------------------------------------------------------===//
 // Lexer
 //===----------------------------------------------------------------------===//
static std::unique_ptr<ExprAST> ParseIdentifierExpr() {
 
   if (CurTok != '(') // Simple variable ref.
     return llvm::make_unique<VariableExprAST>(IdName);
 
   // Call.
   getNextToken();  // eat (
   std::vector<std::unique_ptr<ExprAST>> Args;
   if (CurTok != ')') {
-    while (1) {
+    while (true) {
       auto Arg = ParseExpression();
       if (!Arg) return nullptr;
       Args.push_back(std::move(Arg));
 
       if (CurTok == ')') break;
 
       if (CurTok != ',')
         return ErrorU<CallExprAST>("Expected ')' or ',' in argument list");
static std::unique_ptr<VarExprAST> ParseVarExpr() {
   getNextToken();  // eat the var.
 
   VarExprAST::BindingList VarBindings;
 
   // At least one variable name is required.
   if (CurTok != tok_identifier)
     return ErrorU<VarExprAST>("expected identifier after var");
 
-  while (1) {
+  while (true) {
     std::string Name = IdentifierStr;
     getNextToken();  // eat identifier.
 
     // Read the optional initializer.
     std::unique_ptr<ExprAST> Init;
     if (CurTok == '=') {
       getNextToken(); // eat the '='.
 
static std::unique_ptr<ExprAST> ParseUnary() {
   return nullptr;
 }
 
 /// binoprhs
 ///   ::= ('+' unary)*
 static std::unique_ptr<ExprAST> ParseBinOpRHS(int ExprPrec,
                                               std::unique_ptr<ExprAST> LHS) {
   // If this is a binop, find its precedence.
-  while (1) {
+  while (true) {
     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.

 class SessionContext {
 public:
   SessionContext(LLVMContext &C)
     : Context(C), TM(EngineBuilder().selectTarget()) {}
   LLVMContext& getLLVMContext() const { return Context; }
   TargetMachine& getTarget() { return *TM; }
   void addPrototypeAST(std::unique_ptr<PrototypeAST> P);
   PrototypeAST* getPrototypeAST(const std::string &Name);
+
 private:
   typedef std::map<std::string, std::unique_ptr<PrototypeAST>> PrototypeMap;
 
   LLVMContext &Context;
   std::unique_ptr<TargetMachine> TM;
 
   PrototypeMap Prototypes;
 };
 
 void SessionContext::addPrototypeAST(std::unique_ptr<PrototypeAST> P) {
   Prototypes[P->Name] = std::move(P);
 }
 
 PrototypeAST* SessionContext::getPrototypeAST(const std::string &Name) {
   PrototypeMap::iterator I = Prototypes.find(Name);
   if (I != Prototypes.end())
     return I->second.get();
   return nullptr;
 }
 
 class IRGenContext {
 public:
-
   IRGenContext(SessionContext &S)
     : Session(S),
       M(new Module(GenerateUniqueName("jit_module_"),
                    Session.getLLVMContext())),
       Builder(Session.getLLVMContext()) {
     M->setDataLayout(Session.getTarget().createDataLayout());
   }
 
   SessionContext& getSession() { return Session; }
   Module& getM() const { return *M; }
   std::unique_ptr<Module> takeM() { return std::move(M); }
   IRBuilder<>& getBuilder() { return Builder; }
   LLVMContext& getLLVMContext() { return Session.getLLVMContext(); }
   Function* getPrototype(const std::string &Name);
 
   std::map<std::string, AllocaInst*> NamedValues;
+
 private:
   SessionContext &Session;
   std::unique_ptr<Module> M;
   IRBuilder<> Builder;
 };
 
 Function* IRGenContext::getPrototype(const std::string &Name) {
   if (Function *ExistingProto = M->getFunction(Name))
     return ExistingProto;
   if (PrototypeAST *ProtoAST = Session.getPrototypeAST(Name))
     return ProtoAST->IRGen(*this);
   return nullptr;
 }
 
 /// CreateEntryBlockAlloca - Create an alloca instruction in the entry block of
 /// the function.  This is used for mutable variables etc.
 static AllocaInst *CreateEntryBlockAlloca(Function *TheFunction,
                                           const std::string &VarName) {
   IRBuilder<> TmpB(&TheFunction->getEntryBlock(),
                    TheFunction->getEntryBlock().begin());
   return TmpB.CreateAlloca(Type::getDoubleTy(TheFunction->getContext()),
-                           nullptr, VarName.c_str());
+                           nullptr, VarName);
 }
 
 Value *NumberExprAST::IRGen(IRGenContext &C) const {
   return ConstantFP::get(C.getLLVMContext(), APFloat(Val));
 }
 
 Value *VariableExprAST::IRGen(IRGenContext &C) const {
   // Look this variable up in the function.
JITSymbol findUnmangledSymbol(const std::string &Name) {
     return findSymbol(mangle(Name));
   }
 
   JITSymbol findUnmangledSymbolIn(ModuleHandleT H, const std::string &Name) {
     return findSymbolIn(H, mangle(Name));
   }
 
 private:
-
   // This method searches the FunctionDefs map for a definition of 'Name'. If it
   // finds one it generates a stub for it and returns the address of the stub.
   RuntimeDyld::SymbolInfo searchFunctionASTs(const std::string &Name) {
     auto DefI = FunctionDefs.find(Name);
     if (DefI == FunctionDefs.end())
       return nullptr;
 
     // Return the address of the stub.

 }
 
 /// top ::= definition | external | expression | ';'
 static void MainLoop() {
   LLVMContext TheContext;
   SessionContext S(TheContext);
   KaleidoscopeJIT J(S);
 
-  while (1) {
+  while (true) {
     switch (CurTok) {
     case tok_eof:    return;
     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

llvm/trunk/examples/Kaleidoscope/Orc/initial/toy.cpp

-#include "llvm/Analysis/Passes.h"
+#include "llvm/ADT/APFloat.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ExecutionEngine/ExecutionEngine.h"
+#include "llvm/ExecutionEngine/RuntimeDyld.h"
+#include "llvm/ExecutionEngine/SectionMemoryManager.h"
 #include "llvm/ExecutionEngine/Orc/CompileUtils.h"
 #include "llvm/ExecutionEngine/Orc/IRCompileLayer.h"
+#include "llvm/ExecutionEngine/Orc/JITSymbol.h"
 #include "llvm/ExecutionEngine/Orc/LambdaResolver.h"
-#include "llvm/ExecutionEngine/Orc/LazyEmittingLayer.h"
 #include "llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h"
+#include "llvm/IR/BasicBlock.h"
+#include "llvm/IR/Constant.h"
+#include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DerivedTypes.h"
+#include "llvm/IR/Function.h"
+#include "llvm/IR/Instructions.h"
 #include "llvm/IR/IRBuilder.h"
-#include "llvm/IR/LegacyPassManager.h"
 #include "llvm/IR/LLVMContext.h"
+#include "llvm/IR/Mangler.h"
 #include "llvm/IR/Module.h"
+#include "llvm/IR/Type.h"
 #include "llvm/IR/Verifier.h"
+#include "llvm/Support/raw_ostream.h"
 #include "llvm/Support/TargetSelect.h"
-#include "llvm/Transforms/Scalar.h"
+#include "llvm/Target/TargetMachine.h"
+#include <cassert>
 #include <cctype>
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
 #include <iomanip>
 #include <iostream>
 #include <map>
+#include <memory>
 #include <sstream>
 #include <string>
+#include <utility>
 #include <vector>
 
 using namespace llvm;
 using namespace llvm::orc;
 
 //===----------------------------------------------------------------------===//
 // Lexer
 //===----------------------------------------------------------------------===//
struct CallExprAST : public ExprAST {
   std::vector<std::unique_ptr<ExprAST>> Args;
 };
 
 /// IfExprAST - Expression class for if/then/else.
 struct IfExprAST : public ExprAST {
   IfExprAST(std::unique_ptr<ExprAST> Cond, std::unique_ptr<ExprAST> Then,
             std::unique_ptr<ExprAST> Else)
     : Cond(std::move(Cond)), Then(std::move(Then)), Else(std::move(Else)) {}
+
   Value *IRGen(IRGenContext &C) const override;
 
   std::unique_ptr<ExprAST> Cond, Then, Else;
 };
 
 /// ForExprAST - Expression class for for/in.
 struct ForExprAST : public ExprAST {
   ForExprAST(std::string VarName, std::unique_ptr<ExprAST> Start,
static std::unique_ptr<ExprAST> ParseIdentifierExpr() {
 
   if (CurTok != '(') // Simple variable ref.
     return llvm::make_unique<VariableExprAST>(IdName);
 
   // Call.
   getNextToken();  // eat (
   std::vector<std::unique_ptr<ExprAST>> Args;
   if (CurTok != ')') {
-    while (1) {
+    while (true) {
       auto Arg = ParseExpression();
       if (!Arg) return nullptr;
       Args.push_back(std::move(Arg));
 
       if (CurTok == ')') break;
 
       if (CurTok != ',')
         return ErrorU<CallExprAST>("Expected ')' or ',' in argument list");
static std::unique_ptr<VarExprAST> ParseVarExpr() {
   getNextToken();  // eat the var.
 
   VarExprAST::BindingList VarBindings;
 
   // At least one variable name is required.
   if (CurTok != tok_identifier)
     return ErrorU<VarExprAST>("expected identifier after var");
 
-  while (1) {
+  while (true) {
     std::string Name = IdentifierStr;
     getNextToken();  // eat identifier.
 
     // Read the optional initializer.
     std::unique_ptr<ExprAST> Init;
     if (CurTok == '=') {
       getNextToken(); // eat the '='.
 
static std::unique_ptr<ExprAST> ParseUnary() {
   return nullptr;
 }
 
 /// binoprhs
 ///   ::= ('+' unary)*
 static std::unique_ptr<ExprAST> ParseBinOpRHS(int ExprPrec,
                                               std::unique_ptr<ExprAST> LHS) {
   // If this is a binop, find its precedence.
-  while (1) {
+  while (true) {
     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.

 class SessionContext {
 public:
   SessionContext(LLVMContext &C)
     : Context(C), TM(EngineBuilder().selectTarget()) {}
   LLVMContext& getLLVMContext() const { return Context; }
   TargetMachine& getTarget() { return *TM; }
   void addPrototypeAST(std::unique_ptr<PrototypeAST> P);
   PrototypeAST* getPrototypeAST(const std::string &Name);
+
 private:
   typedef std::map<std::string, std::unique_ptr<PrototypeAST>> PrototypeMap;
 
   LLVMContext &Context;
   std::unique_ptr<TargetMachine> TM;
 
   PrototypeMap Prototypes;
 };
 
 void SessionContext::addPrototypeAST(std::unique_ptr<PrototypeAST> P) {
   Prototypes[P->Name] = std::move(P);
 }
 
 PrototypeAST* SessionContext::getPrototypeAST(const std::string &Name) {
   PrototypeMap::iterator I = Prototypes.find(Name);
   if (I != Prototypes.end())
     return I->second.get();
   return nullptr;
 }
 
 class IRGenContext {
 public:
-
   IRGenContext(SessionContext &S)
     : Session(S),
       M(new Module(GenerateUniqueName("jit_module_"),
                    Session.getLLVMContext())),
       Builder(Session.getLLVMContext()) {
     M->setDataLayout(Session.getTarget().createDataLayout());
   }
 
   SessionContext& getSession() { return Session; }
   Module& getM() const { return *M; }
   std::unique_ptr<Module> takeM() { return std::move(M); }
   IRBuilder<>& getBuilder() { return Builder; }
   LLVMContext& getLLVMContext() { return Session.getLLVMContext(); }
   Function* getPrototype(const std::string &Name);
 
   std::map<std::string, AllocaInst*> NamedValues;
+
 private:
   SessionContext &Session;
   std::unique_ptr<Module> M;
   IRBuilder<> Builder;
 };
 
 Function* IRGenContext::getPrototype(const std::string &Name) {
   if (Function *ExistingProto = M->getFunction(Name))
     return ExistingProto;
   if (PrototypeAST *ProtoAST = Session.getPrototypeAST(Name))
     return ProtoAST->IRGen(*this);
   return nullptr;
 }
 
 /// CreateEntryBlockAlloca - Create an alloca instruction in the entry block of
 /// the function.  This is used for mutable variables etc.
 static AllocaInst *CreateEntryBlockAlloca(Function *TheFunction,
                                           const std::string &VarName) {
   IRBuilder<> TmpB(&TheFunction->getEntryBlock(),
                    TheFunction->getEntryBlock().begin());
   return TmpB.CreateAlloca(Type::getDoubleTy(TheFunction->getContext()),
-                           nullptr, VarName.c_str());
+                           nullptr, VarName);
 }
 
 Value *NumberExprAST::IRGen(IRGenContext &C) const {
   return ConstantFP::get(C.getLLVMContext(), APFloat(Val));
 }
 
 Value *VariableExprAST::IRGen(IRGenContext &C) const {
   // Look this variable up in the function.

 }
 
 /// top ::= definition | external | expression | ';'
 static void MainLoop() {
   LLVMContext TheContext;
   SessionContext S(TheContext);
   KaleidoscopeJIT J(S);
 
-  while (1) {
+  while (true) {
     switch (CurTok) {
     case tok_eof:    return;
     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

llvm/trunk/examples/Kaleidoscope/Orc/lazy_codegen/toy.cpp

-#include "llvm/Analysis/Passes.h"
+#include "llvm/ADT/APFloat.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ExecutionEngine/ExecutionEngine.h"
+#include "llvm/ExecutionEngine/RuntimeDyld.h"
+#include "llvm/ExecutionEngine/SectionMemoryManager.h"
 #include "llvm/ExecutionEngine/Orc/CompileUtils.h"
 #include "llvm/ExecutionEngine/Orc/IRCompileLayer.h"
+#include "llvm/ExecutionEngine/Orc/JITSymbol.h"
 #include "llvm/ExecutionEngine/Orc/LambdaResolver.h"
 #include "llvm/ExecutionEngine/Orc/LazyEmittingLayer.h"
 #include "llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h"
+#include "llvm/IR/BasicBlock.h"
+#include "llvm/IR/Constant.h"
+#include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DerivedTypes.h"
+#include "llvm/IR/Function.h"
+#include "llvm/IR/Instructions.h"
 #include "llvm/IR/IRBuilder.h"
-#include "llvm/IR/LegacyPassManager.h"
 #include "llvm/IR/LLVMContext.h"
+#include "llvm/IR/Mangler.h"
 #include "llvm/IR/Module.h"
+#include "llvm/IR/Type.h"
 #include "llvm/IR/Verifier.h"
+#include "llvm/Support/raw_ostream.h"
 #include "llvm/Support/TargetSelect.h"
-#include "llvm/Transforms/Scalar.h"
+#include "llvm/Target/TargetMachine.h"
+#include <cassert>
 #include <cctype>
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
 #include <iomanip>
 #include <iostream>
 #include <map>
+#include <memory>
 #include <sstream>
 #include <string>
+#include <utility>
 #include <vector>
 
 using namespace llvm;
 using namespace llvm::orc;
 
 //===----------------------------------------------------------------------===//
 // Lexer
 //===----------------------------------------------------------------------===//
struct CallExprAST : public ExprAST {
   std::vector<std::unique_ptr<ExprAST>> Args;
 };
 
 /// IfExprAST - Expression class for if/then/else.
 struct IfExprAST : public ExprAST {
   IfExprAST(std::unique_ptr<ExprAST> Cond, std::unique_ptr<ExprAST> Then,
             std::unique_ptr<ExprAST> Else)
     : Cond(std::move(Cond)), Then(std::move(Then)), Else(std::move(Else)) {}
+
   Value *IRGen(IRGenContext &C) const override;
 
   std::unique_ptr<ExprAST> Cond, Then, Else;
 };
 
 /// ForExprAST - Expression class for for/in.
 struct ForExprAST : public ExprAST {
   ForExprAST(std::string VarName, std::unique_ptr<ExprAST> Start,
static std::unique_ptr<ExprAST> ParseIdentifierExpr() {
 
   if (CurTok != '(') // Simple variable ref.
     return llvm::make_unique<VariableExprAST>(IdName);
 
   // Call.
   getNextToken();  // eat (
   std::vector<std::unique_ptr<ExprAST>> Args;
   if (CurTok != ')') {
-    while (1) {
+    while (true) {
       auto Arg = ParseExpression();
       if (!Arg) return nullptr;
       Args.push_back(std::move(Arg));
 
       if (CurTok == ')') break;
 
       if (CurTok != ',')
         return ErrorU<CallExprAST>("Expected ')' or ',' in argument list");
static std::unique_ptr<VarExprAST> ParseVarExpr() {
   getNextToken();  // eat the var.
 
   VarExprAST::BindingList VarBindings;
 
   // At least one variable name is required.
   if (CurTok != tok_identifier)
     return ErrorU<VarExprAST>("expected identifier after var");
 
-  while (1) {
+  while (true) {
     std::string Name = IdentifierStr;
     getNextToken();  // eat identifier.
 
     // Read the optional initializer.
     std::unique_ptr<ExprAST> Init;
     if (CurTok == '=') {
       getNextToken(); // eat the '='.
 
static std::unique_ptr<ExprAST> ParseUnary() {
   return nullptr;
 }
 
 /// binoprhs
 ///   ::= ('+' unary)*
 static std::unique_ptr<ExprAST> ParseBinOpRHS(int ExprPrec,
                                               std::unique_ptr<ExprAST> LHS) {
   // If this is a binop, find its precedence.
-  while (1) {
+  while (true) {
     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.

 class SessionContext {
 public:
   SessionContext(LLVMContext &C)
     : Context(C), TM(EngineBuilder().selectTarget()) {}
   LLVMContext& getLLVMContext() const { return Context; }
   TargetMachine& getTarget() { return *TM; }
   void addPrototypeAST(std::unique_ptr<PrototypeAST> P);
   PrototypeAST* getPrototypeAST(const std::string &Name);
+
 private:
   typedef std::map<std::string, std::unique_ptr<PrototypeAST>> PrototypeMap;
 
   LLVMContext &Context;
   std::unique_ptr<TargetMachine> TM;
 
   PrototypeMap Prototypes;
 };
 
 void SessionContext::addPrototypeAST(std::unique_ptr<PrototypeAST> P) {
   Prototypes[P->Name] = std::move(P);
 }
 
 PrototypeAST* SessionContext::getPrototypeAST(const std::string &Name) {
   PrototypeMap::iterator I = Prototypes.find(Name);
   if (I != Prototypes.end())
     return I->second.get();
   return nullptr;
 }
 
 class IRGenContext {
 public:
-
   IRGenContext(SessionContext &S)
     : Session(S),
       M(new Module(GenerateUniqueName("jit_module_"),
                    Session.getLLVMContext())),
       Builder(Session.getLLVMContext()) {
     M->setDataLayout(Session.getTarget().createDataLayout());
   }
 
   SessionContext& getSession() { return Session; }
   Module& getM() const { return *M; }
   std::unique_ptr<Module> takeM() { return std::move(M); }
   IRBuilder<>& getBuilder() { return Builder; }
   LLVMContext& getLLVMContext() { return Session.getLLVMContext(); }
   Function* getPrototype(const std::string &Name);
 
   std::map<std::string, AllocaInst*> NamedValues;
+
 private:
   SessionContext &Session;
   std::unique_ptr<Module> M;
   IRBuilder<> Builder;
 };
 
 Function* IRGenContext::getPrototype(const std::string &Name) {
   if (Function *ExistingProto = M->getFunction(Name))
     return ExistingProto;
   if (PrototypeAST *ProtoAST = Session.getPrototypeAST(Name))
     return ProtoAST->IRGen(*this);
   return nullptr;
 }
 
 /// CreateEntryBlockAlloca - Create an alloca instruction in the entry block of
 /// the function.  This is used for mutable variables etc.
 static AllocaInst *CreateEntryBlockAlloca(Function *TheFunction,
                                           const std::string &VarName) {
   IRBuilder<> TmpB(&TheFunction->getEntryBlock(),
                    TheFunction->getEntryBlock().begin());
   return TmpB.CreateAlloca(Type::getDoubleTy(TheFunction->getContext()),
-                           nullptr, VarName.c_str());
+                           nullptr, VarName);
 }
 
 Value *NumberExprAST::IRGen(IRGenContext &C) const {
   return ConstantFP::get(C.getLLVMContext(), APFloat(Val));
 }
 
 Value *VariableExprAST::IRGen(IRGenContext &C) const {
   // Look this variable up in the function.

 }
 
 /// top ::= definition | external | expression | ';'
 static void MainLoop() {
   LLVMContext TheContext;
   SessionContext S(TheContext);
   KaleidoscopeJIT J(S);
 
-  while (1) {
+  while (true) {
     switch (CurTok) {
     case tok_eof:    return;
     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

llvm/trunk/examples/Kaleidoscope/Orc/lazy_irgen/toy.cpp

-#include "llvm/Analysis/Passes.h"
+#include "llvm/ADT/APFloat.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ExecutionEngine/ExecutionEngine.h"
+#include "llvm/ExecutionEngine/RuntimeDyld.h"
+#include "llvm/ExecutionEngine/SectionMemoryManager.h"
 #include "llvm/ExecutionEngine/Orc/CompileUtils.h"
 #include "llvm/ExecutionEngine/Orc/IRCompileLayer.h"
+#include "llvm/ExecutionEngine/Orc/JITSymbol.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/BasicBlock.h"
+#include "llvm/IR/Constant.h"
+#include "llvm/IR/Constants.h"
 #include "llvm/IR/DerivedTypes.h"
+#include "llvm/IR/Function.h"
+#include "llvm/IR/Instructions.h"
 #include "llvm/IR/IRBuilder.h"
-#include "llvm/IR/LegacyPassManager.h"
 #include "llvm/IR/LLVMContext.h"
+#include "llvm/IR/Mangler.h"
 #include "llvm/IR/Module.h"
+#include "llvm/IR/Type.h"
 #include "llvm/IR/Verifier.h"
+#include "llvm/Support/raw_ostream.h"
 #include "llvm/Support/TargetSelect.h"
-#include "llvm/Transforms/Scalar.h"
+#include "llvm/Target/TargetMachine.h"
+#include <cassert>
 #include <cctype>
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
 #include <iomanip>
 #include <iostream>
 #include <map>
+#include <memory>
 #include <sstream>
 #include <string>
+#include <utility>
 #include <vector>
 
 using namespace llvm;
 using namespace llvm::orc;
 
 //===----------------------------------------------------------------------===//
 // Lexer
 //===----------------------------------------------------------------------===//
struct CallExprAST : public ExprAST {
   std::vector<std::unique_ptr<ExprAST>> Args;
 };
 
 /// IfExprAST - Expression class for if/then/else.
 struct IfExprAST : public ExprAST {
   IfExprAST(std::unique_ptr<ExprAST> Cond, std::unique_ptr<ExprAST> Then,
             std::unique_ptr<ExprAST> Else)
     : Cond(std::move(Cond)), Then(std::move(Then)), Else(std::move(Else)) {}
+
   Value *IRGen(IRGenContext &C) const override;
 
   std::unique_ptr<ExprAST> Cond, Then, Else;
 };
 
 /// ForExprAST - Expression class for for/in.
 struct ForExprAST : public ExprAST {
   ForExprAST(std::string VarName, std::unique_ptr<ExprAST> Start,
static std::unique_ptr<ExprAST> ParseIdentifierExpr() {
 
   if (CurTok != '(') // Simple variable ref.
     return llvm::make_unique<VariableExprAST>(IdName);
 
   // Call.
   getNextToken();  // eat (
   std::vector<std::unique_ptr<ExprAST>> Args;
   if (CurTok != ')') {
-    while (1) {
+    while (true) {
       auto Arg = ParseExpression();
       if (!Arg) return nullptr;
       Args.push_back(std::move(Arg));
 
       if (CurTok == ')') break;
 
       if (CurTok != ',')
         return ErrorU<CallExprAST>("Expected ')' or ',' in argument list");
static std::unique_ptr<VarExprAST> ParseVarExpr() {
   getNextToken();  // eat the var.
 
   VarExprAST::BindingList VarBindings;
 
   // At least one variable name is required.
   if (CurTok != tok_identifier)
     return ErrorU<VarExprAST>("expected identifier after var");
 
-  while (1) {
+  while (true) {
     std::string Name = IdentifierStr;
     getNextToken();  // eat identifier.
 
     // Read the optional initializer.
     std::unique_ptr<ExprAST> Init;
     if (CurTok == '=') {
       getNextToken(); // eat the '='.
 
static std::unique_ptr<ExprAST> ParseUnary() {
   return nullptr;
 }
 
 /// binoprhs
 ///   ::= ('+' unary)*
 static std::unique_ptr<ExprAST> ParseBinOpRHS(int ExprPrec,
                                               std::unique_ptr<ExprAST> LHS) {
   // If this is a binop, find its precedence.
-  while (1) {
+  while (true) {
     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.

 class SessionContext {
 public:
   SessionContext(LLVMContext &C)
     : Context(C), TM(EngineBuilder().selectTarget()) {}
   LLVMContext& getLLVMContext() const { return Context; }
   TargetMachine& getTarget() { return *TM; }
   void addPrototypeAST(std::unique_ptr<PrototypeAST> P);
   PrototypeAST* getPrototypeAST(const std::string &Name);
+
 private:
   typedef std::map<std::string, std::unique_ptr<PrototypeAST>> PrototypeMap;
 
   LLVMContext &Context;
   std::unique_ptr<TargetMachine> TM;
 
   PrototypeMap Prototypes;
 };
 
 void SessionContext::addPrototypeAST(std::unique_ptr<PrototypeAST> P) {
   Prototypes[P->Name] = std::move(P);
 }
 
 PrototypeAST* SessionContext::getPrototypeAST(const std::string &Name) {
   PrototypeMap::iterator I = Prototypes.find(Name);
   if (I != Prototypes.end())
     return I->second.get();
   return nullptr;
 }
 
 class IRGenContext {
 public:
-
   IRGenContext(SessionContext &S)
     : Session(S),
       M(new Module(GenerateUniqueName("jit_module_"),
                    Session.getLLVMContext())),
       Builder(Session.getLLVMContext()) {
     M->setDataLayout(Session.getTarget().createDataLayout());
   }
 
   SessionContext& getSession() { return Session; }
   Module& getM() const { return *M; }
   std::unique_ptr<Module> takeM() { return std::move(M); }
   IRBuilder<>& getBuilder() { return Builder; }
   LLVMContext& getLLVMContext() { return Session.getLLVMContext(); }
   Function* getPrototype(const std::string &Name);
 
   std::map<std::string, AllocaInst*> NamedValues;
+
 private:
   SessionContext &Session;
   std::unique_ptr<Module> M;
   IRBuilder<> Builder;
 };
 
 Function* IRGenContext::getPrototype(const std::string &Name) {
   if (Function *ExistingProto = M->getFunction(Name))
     return ExistingProto;
   if (PrototypeAST *ProtoAST = Session.getPrototypeAST(Name))
     return ProtoAST->IRGen(*this);
   return nullptr;
 }
 
 /// CreateEntryBlockAlloca - Create an alloca instruction in the entry block of
 /// the function.  This is used for mutable variables etc.
 static AllocaInst *CreateEntryBlockAlloca(Function *TheFunction,
                                           const std::string &VarName) {
   IRBuilder<> TmpB(&TheFunction->getEntryBlock(),
                    TheFunction->getEntryBlock().begin());
   return TmpB.CreateAlloca(Type::getDoubleTy(TheFunction->getContext()),
-                           nullptr, VarName.c_str());
+                           nullptr, VarName);
 }
 
 Value *NumberExprAST::IRGen(IRGenContext &C) const {
   return ConstantFP::get(C.getLLVMContext(), APFloat(Val));
 }
 
 Value *VariableExprAST::IRGen(IRGenContext &C) const {
   // Look this variable up in the function.
JITSymbol findSymbolIn(ModuleHandleT H, const std::string &Name) {
     return LazyEmitLayer.findSymbolIn(H, Name, true);
   }
 
   JITSymbol findUnmangledSymbol(const std::string &Name) {
     return findSymbol(mangle(Name));
   }
 
 private:
-
   // This method searches the FunctionDefs map for a definition of 'Name'. If it
   // finds one it generates a stub for it and returns the address of the stub.
   RuntimeDyld::SymbolInfo searchFunctionASTs(const std::string &Name) {
     auto DefI = FunctionDefs.find(Name);
     if (DefI == FunctionDefs.end())
       return nullptr;
 
     // Take the FunctionAST out of the map.

 }
 
 /// top ::= definition | external | expression | ';'
 static void MainLoop() {
   LLVMContext TheContext;
   SessionContext S(TheContext);
   KaleidoscopeJIT J(S);
 
-  while (1) {
+  while (true) {
     switch (CurTok) {
     case tok_eof:    return;
     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