Update Kaleidoscope tutorial and improve Windows support

[mkroll]

Summary

Many quoted code blocks were not in sync with the actual toy.cpp files.
Improved tutorial text slightly in several places.
Added some step descriptions crucial to avoid crashes (like InitializeNativeTarget* calls).
Solve/workaround problems with Windows (JIT'ed method not found, using custom and standard library functions from host process)

[mehdi_amini]

docs/tutorial/LangImpl03.rst

536–537

80 cols?
(and in multiple places below)

[Wilfred]

Looks fine from my perspective. :)

[mkroll]

Fixed some too long lines

[mehdi_amini]

LGTM overall. I trust you to have tested the windows part.

[mehdi_amini]

Do you have commit access?

[mkroll]

Sure, the Windows specific changes work fine on Windows.

No, I don't have commit access.

[chapuni]

I wish if this patch were split to;

• Documentation fixes
• Tweaks for current implementation
• Win32 changes

(I don't know how to process multiple patchset on phab in better way, though)

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

1119 ↗

(On Diff #88108)

It requires TransformUtils. Fixed in r294881.

[mkroll]

I would also prefer to provide a patch set to have sensibly grouped changes like with git.

About TransformUtils, sorry, I'm building with MSVC and already had all libraries in my project from step 8.
The tutorial steps don't mention the make file, but they use llvm-config to select the libraries.
So "clang++ -g toy.cpp llvm-config --cxxflags --ldflags --system-libs --libs core mcjit native -O3 -o toy" should be updated to "clang++ -g toy.cpp llvm-config --cxxflags --ldflags --system-libs --libs core mcjit native transformutils -O3 -o toy".
I created a patch for this: https://reviews.llvm.org/D29875

docs/tutorial/BuildingAJIT1.rst

.. code-block:: c++
   #include "llvm/IR/Mangler.h"
   #include "llvm/Support/DynamicLibrary.h"
 
   namespace llvm {
   namespace orc {
 
   class KaleidoscopeJIT {
   private:
-
     std::unique_ptr<TargetMachine> TM;
     const DataLayout DL;
     ObjectLinkingLayer<> ObjectLayer;
     IRCompileLayer<decltype(ObjectLayer)> CompileLayer;
 
   public:
-
     typedef decltype(CompileLayer)::ModuleSetHandleT ModuleHandleT;
 
 Our class begins with four members: A TargetMachine, TM, which will be used
 to build our LLVM compiler instance; A DataLayout, DL, which will be used for
 symbol mangling (more on that later), and two ORC *layers*: an
 ObjectLinkingLayer and a IRCompileLayer. We'll be talking more about layers in
 the next chapter, but for now you can think of them as analogous to LLVM
 Passes: they wrap up useful JIT utilities behind an easy to compose interface.
 The first layer, ObjectLinkingLayer, is the foundation of our JIT: it takes
 in-memory object files produced by a compiler and links them on the fly to make
 them executable. This JIT-on-top-of-a-linker design was introduced in MCJIT,
 however the linker was hidden inside the MCJIT class. In ORC we expose the
 linker so that clients can access and configure it directly if they need to. In
 this tutorial our ObjectLinkingLayer will just be used to support the next layer
 in our stack: the IRCompileLayer, which will be responsible for taking LLVM IR,
 compiling it, and passing the resulting in-memory object files down to the
 object linking layer below.
 
 That's it for member variables, after that we have a single typedef:
-ModuleHandle. This is the handle type that will be returned from our JIT's
+ModuleHandleT. This is the handle type that will be returned from our JIT's
 addModule method, and can be passed to the removeModule method to remove a
 module. The IRCompileLayer class already provides a convenient handle type
-(IRCompileLayer::ModuleSetHandleT), so we just alias our ModuleHandle to this.
+(IRCompileLayer::ModuleSetHandleT), so we just alias our ModuleHandleT to this.
 
 .. code-block:: c++
 
   KaleidoscopeJIT()
       : TM(EngineBuilder().selectTarget()), DL(TM->createDataLayout()),
         CompileLayer(ObjectLayer, SimpleCompiler(*TM)) {
     llvm::sys::DynamicLibrary::LoadLibraryPermanently(nullptr);
   }
 
   TargetMachine &getTargetMachine() { return *TM; }
 
 Next up we have our class constructor. We begin by initializing TM using the
 EngineBuilder::selectTarget helper method, which constructs a TargetMachine for
 the current process. Next we use our newly created TargetMachine to initialize
auto Resolver = createLambdaResolver(
         },
         [](const std::string &S) {
           if (auto SymAddr =
                 RTDyldMemoryManager::getSymbolAddressInProcess(Name))
             return JITSymbol(SymAddr, JITSymbolFlags::Exported);
           return JITSymbol(nullptr);
         });
 
-    // Build a singlton module set to hold our module.
+    // Build a singleton module set to hold our module.
     std::vector<std::unique_ptr<Module>> Ms;
     Ms.push_back(std::move(M));
 
     // Add the set to the JIT with the resolver we created above and a newly
     // created SectionMemoryManager.
     return CompileLayer.addModuleSet(std::move(Ms),
                                      make_unique<SectionMemoryManager>(),
                                      std::move(Resolver));

 then the linker will call the second symbol resolver method, called findSymbol,
 which searches for symbols that should be thought of as external to (but
 visibile from) the module and its logical dylib. In this tutorial we will adopt
 the following simple scheme: All modules added to the JIT will behave as if they
 were linked into a single, ever-growing logical dylib. To implement this our
 first lambda (the one defining findSymbolInLogicalDylib) will just search for
 JIT'd code by calling the CompileLayer's findSymbol method. If we don't find a
 symbol in the JIT itself we'll fall back to our second lambda, which implements
-findSymbol. This will use the RTDyldMemoyrManager::getSymbolAddressInProcess
+findSymbol. This will use the RTDyldMemoryManager::getSymbolAddressInProcess
 method to search for the symbol within the program itself. If we can't find a
-symbol definition via either of these paths the JIT will refuse to accept our
+symbol definition via either of these paths, the JIT will refuse to accept our
 module, returning a "symbol not found" error.
 
-Now that we've built our symbol resolver we're ready to add our module to the
+Now that we've built our symbol resolver, we're ready to add our module to the
 JIT. We do this by calling the CompileLayer's addModuleSet method [4]_. Since
 we only have a single Module and addModuleSet expects a collection, we will
 create a vector of modules and add our module as the only member. Since we
-have already typedef'd our ModuleHandle type to be the same as the
+have already typedef'd our ModuleHandleT type to be the same as the
 CompileLayer's handle type, we can return the handle from addModuleSet
 directly from our addModule method.
 
 .. code-block:: c++
 
   JITSymbol findSymbol(const std::string Name) {
     std::string MangledName;
     raw_string_ostream MangledNameStream(MangledName);

 responsible for destructing the MemoryManager and SymbolResolver that were
 added with a given module, freeing any resources they were using in the
 process. In our Kaleidoscope demo we rely on this method to remove the module
 representing the most recent top-level expression, preventing it from being
 treated as a duplicate definition when the next top-level expression is
 entered. It is generally good to free any module that you know you won't need
 to call further, just to free up the resources dedicated to it. However, you
 don't strictly need to do this: All resources will be cleaned up when your
-JIT class is destructed, if the haven't been freed before then.
+JIT class is destructed, if they haven't been freed before then.
 
 This brings us to the end of Chapter 1 of Building a JIT. You now have a basic
 but fully functioning JIT stack that you can use to take LLVM IR and make it
 executable within the context of your JIT process. In the next chapter we'll
 look at how to extend this JIT to produce better quality code, and in the
 process take a deeper look at the ORC layer concept.
 
 `Next: Extending the KaleidoscopeJIT <BuildingAJIT2.html>`_

docs/tutorial/LangImpl02.rst

.. code-block:: c++
     /// of arguments the function takes).
     class PrototypeAST {
       std::string Name;
       std::vector<std::string> Args;
 
     public:
       PrototypeAST(const std::string &name, std::vector<std::string> Args)
         : Name(name), Args(std::move(Args)) {}
+
+      const std::string &getName() const { return Name; }
     };
 
     /// FunctionAST - This class represents a function definition itself.
     class FunctionAST {
       std::unique_ptr<PrototypeAST> Proto;
       std::unique_ptr<ExprAST> Body;
 
     public:

docs/tutorial/LangImpl03.rst

 
 Generating LLVM code for expression nodes is very straightforward: less
 than 45 lines of commented code for all four of our expression nodes.
 First we'll do numeric literals:
 
 .. code-block:: c++
 
     Value *NumberExprAST::codegen() {
-      return ConstantFP::get(LLVMContext, APFloat(Val));
+      return ConstantFP::get(TheContext, APFloat(Val));
     }
 
 In the LLVM IR, numeric constants are represented with the
 ``ConstantFP`` class, which holds the numeric value in an ``APFloat``
 internally (``APFloat`` has the capability of holding floating point
 constants of Arbitrary Precision). This code basically just creates
 and returns a ``ConstantFP``. Note that in the LLVM IR that constants
 are all uniqued together and shared. For this reason, the API uses the
Value *BinaryExprAST::codegen() {
         return Builder.CreateFAdd(L, R, "addtmp");
       case '-':
         return Builder.CreateFSub(L, R, "subtmp");
       case '*':
         return Builder.CreateFMul(L, R, "multmp");
       case '<':
         L = Builder.CreateFCmpULT(L, R, "cmptmp");
         // Convert bool 0/1 to double 0.0 or 1.0
-        return Builder.CreateUIToFP(L, Type::getDoubleTy(LLVMContext),
+        return Builder.CreateUIToFP(L, Type::getDoubleTy(TheContext),
                                     "booltmp");
       default:
         return LogErrorV("invalid binary operator");
       }
     }
 
 Binary operators start to get more interesting. The basic idea here is
 that we recursively emit code for the left-hand side of the expression,

 function bodies and external function declarations. The code starts
 with:
 
 .. code-block:: c++
 
     Function *PrototypeAST::codegen() {
       // Make the function type:  double(double,double) etc.
       std::vector<Type*> Doubles(Args.size(),
-                                 Type::getDoubleTy(LLVMContext));
+                                 Type::getDoubleTy(TheContext));
       FunctionType *FT =
-        FunctionType::get(Type::getDoubleTy(LLVMContext), Doubles, false);
+        FunctionType::get(Type::getDoubleTy(TheContext), Doubles, false);
 
       Function *F =
         Function::Create(FT, Function::ExternalLinkage, Name, TheModule);
 
 This code packs a lot of power into a few lines. Note first that this
 function returns a "Function\*" instead of a "Value\*". Because a
 "prototype" really talks about the external interface for a function
 (not the value computed by an expression), it makes sense for it to

 existing version of this function, in case one has already been created using an
 'extern' statement. If Module::getFunction returns null then no previous version
 exists, so we'll codegen one from the Prototype. In either case, we want to
 assert that the function is empty (i.e. has no body yet) before we start.
 
 .. code-block:: c++
 
   // Create a new basic block to start insertion into.
-  BasicBlock *BB = BasicBlock::Create(LLVMContext, "entry", TheFunction);
+  BasicBlock *BB = BasicBlock::Create(TheContext, "entry", TheFunction);
   Builder.SetInsertPoint(BB);
 
   // Record the function arguments in the NamedValues map.
   NamedValues.clear();
   for (auto &Arg : TheFunction->args())
     NamedValues[Arg.getName()] = &Arg;
 
 Now we get to the point where the ``Builder`` is set up. The first line
::
     declare double @cos(double)
 
     define double @1() {
     entry:
       %calltmp = call double @cos(double 1.234000e+00)
       ret double %calltmp
     }
 
-When you quit the current demo, it dumps out the IR for the entire
+When you quit the current demo (by sending an EOF via CTRL+D on Linux
+or CTRL+Z and ENTER on Windows), it dumps out the IR for the entire
 module generated. Here you can see the big picture with all the
 functions referencing each other.
 
 This wraps up the third chapter of the Kaleidoscope tutorial. Up next,
 we'll describe how to `add JIT codegen and optimizer
 support <LangImpl4.html>`_ to this so we can actually start running
 code!
 

docs/tutorial/LangImpl04.rst

 FunctionPassManager for each module that we want to optimize, so we'll
 write a function to create and initialize both the module and pass manager
 for us:
 
 .. code-block:: c++
 
     void InitializeModuleAndPassManager(void) {
       // Open a new module.
-      Context LLVMContext;
-      TheModule = llvm::make_unique<Module>("my cool jit", LLVMContext);
-      TheModule->setDataLayout(TheJIT->getTargetMachine().createDataLayout());
+      TheModule = llvm::make_unique<Module>("my cool jit", TheContext);
 
       // Create a new pass manager attached to it.
       TheFPM = llvm::make_unique<FunctionPassManager>(TheModule.get());
 
-      // Provide basic AliasAnalysis support for GVN.
-      TheFPM.add(createBasicAliasAnalysisPass());
       // Do simple "peephole" optimizations and bit-twiddling optzns.
-      TheFPM.add(createInstructionCombiningPass());
+      TheFPM->add(createInstructionCombiningPass());
       // Reassociate expressions.
-      TheFPM.add(createReassociatePass());
+      TheFPM->add(createReassociatePass());
       // Eliminate Common SubExpressions.
-      TheFPM.add(createGVNPass());
+      TheFPM->add(createGVNPass());
       // Simplify the control flow graph (deleting unreachable blocks, etc).
-      TheFPM.add(createCFGSimplificationPass());
+      TheFPM->add(createCFGSimplificationPass());
 
-      TheFPM.doInitialization();
+      TheFPM->doInitialization();
     }
 
 This code initializes the global module ``TheModule``, and the function pass
 manager ``TheFPM``, which is attached to ``TheModule``. Once the pass manager is
 set up, we use a series of "add" calls to add a bunch of LLVM passes.
 
-In this case, we choose to add five passes: one analysis pass (alias analysis),
-and four optimization passes. The passes we choose here are a pretty standard set
+In this case, we choose to add four optimization passes.
+The passes we choose here are a pretty standard set
 of "cleanup" optimizations that are useful for a wide variety of code. I won't
 delve into what they do but, believe me, they are a good starting place :).
 
 Once the PassManager is set up, we need to make use of it. We do this by
 running it after our newly created function is constructed (in
 ``FunctionAST::codegen()``), but before it is returned to the client:
 
 .. code-block:: c++

 
 In this section, we'll add JIT compiler support to our interpreter. The
 basic idea that we want for Kaleidoscope is to have the user enter
 function bodies as they do now, but immediately evaluate the top-level
 expressions they type in. For example, if they type in "1 + 2;", we
 should evaluate and print out 3. If they define a function, they should
 be able to call it from the command line.
 
-In order to do this, we first declare and initialize the JIT. This is
-done by adding a global variable ``TheJIT``, and initializing it in
+In order to do this, we first prepare the environment to create code for
+the current native target and declare and initialize the JIT. This is
+done by calling some ``InitializeNativeTarget\*`` functions and
+adding a global variable ``TheJIT``, and initializing it in
 ``main``:
 
 .. code-block:: c++
 
     static std::unique_ptr<KaleidoscopeJIT> TheJIT;
     ...
     int main() {
-      ..
+      InitializeNativeTarget();
+      InitializeNativeTargetAsmPrinter();
+      InitializeNativeTargetAsmParser();
+
+      // Install standard binary operators.
+      // 1 is lowest precedence.
+      BinopPrecedence['<'] = 10;
+      BinopPrecedence['+'] = 20;
+      BinopPrecedence['-'] = 20;
+      BinopPrecedence['*'] = 40; // highest.
+
+      // Prime the first token.
+      fprintf(stderr, "ready> ");
+      getNextToken();
+  
       TheJIT = llvm::make_unique<KaleidoscopeJIT>();
 
       // Run the main "interpreter loop" now.
       MainLoop();
 
       return 0;
     }
 
+We also need to setup the data layout for the JIT:
+
+.. code-block:: c++
+
+    void InitializeModuleAndPassManager(void) {
+      // Open a new module.
+      TheModule = llvm::make_unique<Module>("my cool jit", TheContext);
+      TheModule->setDataLayout(TheJIT->getTargetMachine().createDataLayout());
+
+      // Create a new pass manager attached to it.
+      TheFPM = llvm::make_unique<FunctionPassManager>(TheModule.get());
+      ...
+
 The KaleidoscopeJIT class is a simple JIT built specifically for these
-tutorials. In later chapters we will look at how it works and extend it with
-new features, but for now we will take it as given. Its API is very simple::
+tutorials, available inside the LLVM source code
+at llvm-src/examples/Kaleidoscope/include/KaleidoscopeJIT.h.
+In later chapters we will look at how it works and extend it with
+new features, but for now we will take it as given. Its API is very simple:
 ``addModule`` adds an LLVM IR module to the JIT, making its functions
 available for execution; ``removeModule`` removes a module, freeing any
 memory associated with the code in that module; and ``findSymbol`` allows us
 to look up pointers to the compiled code.
 
 We can take this simple API and change our code that parses top-level expressions to
 look like this:
 

 Whoa, how does the JIT know about sin and cos? The answer is surprisingly
 simple: The KaleidoscopeJIT has a straightforward symbol resolution rule that
 it uses to find symbols that aren't available in any given module: First
 it searches all the modules that have already been added to the JIT, from the
 most recent to the oldest, to find the newest definition. If no definition is
 found inside the JIT, it falls back to calling "``dlsym("sin")``" on the
 Kaleidoscope process itself. Since "``sin``" is defined within the JIT's
 address space, it simply patches up calls in the module to call the libm
-version of ``sin`` directly.
+version of ``sin`` directly. But in some cases this even goes further:
+as sin and cos are names of standard math functions, the constant folder
+will directly evaluate the function calls to the correct result when called
+with constants like in the "``sin(1.0)``" above.
 
 In the future we'll see how tweaking this symbol resolution rule can be used to
 enable all sorts of useful features, from security (restricting the set of
 symbols available to JIT'd code), to dynamic code generation based on symbol
 names, and even lazy compilation.
 
 One immediate benefit of the symbol resolution rule is that we can now extend
 the language by writing arbitrary C++ code to implement operations. For example,
 if we add:
 
 .. code-block:: c++
 
+    #ifdef LLVM_ON_WIN32
+    #define DLLEXPORT __declspec(dllexport)
+    #else
+    #define DLLEXPORT
+    #endif
+
     /// putchard - putchar that takes a double and returns 0.
-    extern "C" double putchard(double X) {
+    extern "C" DLLEXPORT double putchard(double X) {
       fputc((char)X, stderr);
       return 0;
     }
 
+Note, that for Windows we need to actually export the functions because
+the dynamic symbol loader will use GetProcAddress to find the symbols.
+
 Now we can produce simple output to the console by using things like:
 "``extern putchard(x); putchard(120);``", which prints a lowercase 'x'
 on the console (120 is the ASCII code for 'x'). Similar code could be
 used to implement file I/O, console input, and many other capabilities
 in Kaleidoscope.
 
 This completes the JIT and optimizer chapter of the Kaleidoscope
 tutorial. At this point, we can compile a non-Turing-complete

docs/tutorial/LangImpl05.rst

.. code-block:: c++
     /// IfExprAST - Expression class for if/then/else.
     class IfExprAST : public ExprAST {
       std::unique_ptr<ExprAST> Cond, Then, Else;
 
     public:
       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)) {}
-      virtual Value *codegen();
+
+      Value *codegen() override;
     };
 
 The AST node just has pointers to the various subexpressions.
 
 Parser Extensions for If/Then/Else
 ----------------------------------
 
 Now that we have the relevant tokens coming from the lexer and we have

 
 .. code-block:: c++
 
     Value *IfExprAST::codegen() {
       Value *CondV = Cond->codegen();
       if (!CondV)
         return nullptr;
 
-      // Convert condition to a bool by comparing equal to 0.0.
+      // Convert condition to a bool by comparing non-equal to 0.0.
       CondV = Builder.CreateFCmpONE(
-          CondV, ConstantFP::get(LLVMContext, APFloat(0.0)), "ifcond");
+          CondV, ConstantFP::get(TheContext, APFloat(0.0)), "ifcond");
 
 This code is straightforward and similar to what we saw before. We emit
 the expression for the condition, then compare that value to zero to get
 a truth value as a 1-bit (bool) value.
 
 .. code-block:: c++
 
       Function *TheFunction = Builder.GetInsertBlock()->getParent();
 
       // Create blocks for the then and else cases.  Insert the 'then' block at the
       // end of the function.
       BasicBlock *ThenBB =
-          BasicBlock::Create(LLVMContext, "then", TheFunction);
-      BasicBlock *ElseBB = BasicBlock::Create(LLVMContext, "else");
-      BasicBlock *MergeBB = BasicBlock::Create(LLVMContext, "ifcont");
+          BasicBlock::Create(TheContext, "then", TheFunction);
+      BasicBlock *ElseBB = BasicBlock::Create(TheContext, "else");
+      BasicBlock *MergeBB = BasicBlock::Create(TheContext, "ifcont");
 
       Builder.CreateCondBr(CondV, ThenBB, ElseBB);
 
 This code creates the basic blocks that are related to the if/then/else
 statement, and correspond directly to the blocks in the example above.
 The first line gets the current Function object that is being built. It
 gets this by asking the builder for the current BasicBlock, and asking
 that block for its "parent" (the function it is currently embedded

 code:
 
 .. code-block:: c++
 
       // Emit merge block.
       TheFunction->getBasicBlockList().push_back(MergeBB);
       Builder.SetInsertPoint(MergeBB);
       PHINode *PN =
-        Builder.CreatePHI(Type::getDoubleTy(LLVMContext), 2, "iftmp");
+        Builder.CreatePHI(Type::getDoubleTy(TheContext), 2, "iftmp");
 
       PN->addIncoming(ThenV, ThenBB);
       PN->addIncoming(ElseV, ElseBB);
       return PN;
     }
 
 The first two lines here are now familiar: the first adds the "merge"
 block to the Function object (it was previously floating, like the else

 =====================
 
 Now that we know how to add basic control flow constructs to the
 language, we have the tools to add more powerful things. Lets add
 something more aggressive, a 'for' expression:
 
 ::
 
-     extern putchard(char)
+     extern putchard(char);
      def printstar(n)
        for i = 1, i < n, 1.0 in
          putchard(42);  # ascii 42 = '*'
 
      # print 100 '*' characters
      printstar(100);
 
 This expression defines a new variable ("i" in this case) which iterates
class ForExprAST : public ExprAST {
       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)) {}
-      virtual Value *codegen();
+
+      Value *codegen() override;
     };
 
 Parser Extensions for the 'for' Loop
 ------------------------------------
 
 The parser code is also fairly standard. The only interesting thing here
 is handling of the optional step value. The parser code handles it by
 checking to see if the second comma is present. If not, it sets the step
static std::unique_ptr<ExprAST> ParseForExpr() {
       if (!Body)
         return nullptr;
 
       return llvm::make_unique<ForExprAST>(IdName, std::move(Start),
                                            std::move(End), std::move(Step),
                                            std::move(Body));
     }
 
+And again we hook it up as a primary expression:
+
+.. code-block:: c++
+
+    static std::unique_ptr<ExprAST> ParsePrimary() {
+      switch (CurTok) {
+      default:
+        return LogError("unknown token when expecting an expression");
+      case tok_identifier:
+        return ParseIdentifierExpr();
+      case tok_number:
+        return ParseNumberExpr();
+      case '(':
+        return ParseParenExpr();
+      case tok_if:
+        return ParseIfExpr();
+      case tok_for:
+        return ParseForExpr();
+      }
+    }
+
 LLVM IR for the 'for' Loop
 --------------------------
 
 Now we get to the good part: the LLVM IR we want to generate for this
 thing. With the simple example above, we get this LLVM IR (note that
 this dump is generated with optimizations disabled for clarity):
 
 .. code-block:: llvm

 The first part of codegen is very simple: we just output the start
 expression for the loop value:
 
 .. code-block:: c++
 
     Value *ForExprAST::codegen() {
       // Emit the start code first, without 'variable' in scope.
       Value *StartVal = Start->codegen();
-      if (StartVal == 0) return 0;
+      if (!StartVal)
+        return nullptr;
 
 With this out of the way, the next step is to set up the LLVM basic
 block for the start of the loop body. In the case above, the whole loop
 body is one block, but remember that the body code itself could consist
 of multiple blocks (e.g. if it contains an if/then/else or a for/in
 expression).
 
 .. code-block:: c++
 
       // Make the new basic block for the loop header, inserting after current
       // block.
       Function *TheFunction = Builder.GetInsertBlock()->getParent();
       BasicBlock *PreheaderBB = Builder.GetInsertBlock();
       BasicBlock *LoopBB =
-          BasicBlock::Create(LLVMContext, "loop", TheFunction);
+          BasicBlock::Create(TheContext, "loop", TheFunction);
 
       // Insert an explicit fall through from the current block to the LoopBB.
       Builder.CreateBr(LoopBB);
 
 This code is similar to what we saw for if/then/else. Because we will
 need it to create the Phi node, we remember the block that falls through
 into the loop. Once we have that, we create the actual block that starts
 the loop and create an unconditional branch for the fall-through between
 the two blocks.
 
 .. code-block:: c++
 
       // Start insertion in LoopBB.
       Builder.SetInsertPoint(LoopBB);
 
       // Start the PHI node with an entry for Start.
-      PHINode *Variable = Builder.CreatePHI(Type::getDoubleTy(LLVMContext),
+      PHINode *Variable = Builder.CreatePHI(Type::getDoubleTy(TheContext),
                                             2, VarName.c_str());
       Variable->addIncoming(StartVal, PreheaderBB);
 
 Now that the "preheader" for the loop is set up, we switch to emitting
 code for the loop body. To begin with, we move the insertion point and
 create the PHI node for the loop induction variable. Since we already
 know the incoming value for the starting value, we add it to the Phi
 node. Note that the Phi will eventually get a second value for the
.. code-block:: c++
       // Emit the step value.
       Value *StepVal = nullptr;
       if (Step) {
         StepVal = Step->codegen();
         if (!StepVal)
           return nullptr;
       } else {
         // If not specified, use 1.0.
-        StepVal = ConstantFP::get(LLVMContext, APFloat(1.0));
+        StepVal = ConstantFP::get(TheContext, APFloat(1.0));
       }
 
       Value *NextVar = Builder.CreateFAdd(Variable, StepVal, "nextvar");
 
 Now that the body is emitted, we compute the next value of the iteration
 variable by adding the step value, or 1.0 if it isn't present.
 '``NextVar``' will be the value of the loop variable on the next
 iteration of the loop.
 
 .. code-block:: c++
 
       // Compute the end condition.
       Value *EndCond = End->codegen();
       if (!EndCond)
         return nullptr;
 
-      // Convert condition to a bool by comparing equal to 0.0.
+      // Convert condition to a bool by comparing non-equal to 0.0.
       EndCond = Builder.CreateFCmpONE(
-          EndCond, ConstantFP::get(LLVMContext, APFloat(0.0)), "loopcond");
+          EndCond, ConstantFP::get(TheContext, APFloat(0.0)), "loopcond");
 
 Finally, we evaluate the exit value of the loop, to determine whether
 the loop should exit. This mirrors the condition evaluation for the
 if/then/else statement.
 
 .. code-block:: c++
 
       // Create the "after loop" block and insert it.
       BasicBlock *LoopEndBB = Builder.GetInsertBlock();
       BasicBlock *AfterBB =
-          BasicBlock::Create(LLVMContext, "afterloop", TheFunction);
+          BasicBlock::Create(TheContext, "afterloop", TheFunction);
 
       // Insert the conditional branch into the end of LoopEndBB.
       Builder.CreateCondBr(EndCond, LoopBB, AfterBB);
 
       // Any new code will be inserted in AfterBB.
       Builder.SetInsertPoint(AfterBB);
 
 With the code for the body of the loop complete, we just need to finish
.. code-block:: c++
 
       // Restore the unshadowed variable.
       if (OldVal)
         NamedValues[VarName] = OldVal;
       else
         NamedValues.erase(VarName);
 
       // for expr always returns 0.0.
-      return Constant::getNullValue(Type::getDoubleTy(LLVMContext));
+      return Constant::getNullValue(Type::getDoubleTy(TheContext));
     }
 
 The final code handles various cleanups: now that we have the "NextVar"
 value, we can add the incoming value to the loop PHI node. After that,
 we remove the loop variable from the symbol table, so that it isn't in
 scope after the for loop. Finally, code generation of the for loop
 always returns 0.0, so that is what we return from
 ``ForExprAST::codegen()``.
 
 With this, we conclude the "adding control flow to Kaleidoscope" chapter
 of the tutorial. In this chapter we added two control flow constructs,
 and used them to motivate a couple of aspects of the LLVM IR that are
 important for front-end implementors to know. In the next chapter of our
 saga, we will get a bit crazier and add `user-defined
 operators <LangImpl6.html>`_ to our poor innocent language.
 
 Full Code Listing
 =================
 
 Here is the complete code listing for our running example, enhanced with
-the if/then/else and for expressions.. To build this example, use:
+the if/then/else and for expressions. To build this example, use:
 
 .. code-block:: bash
 
     # Compile
     clang++ -g toy.cpp `llvm-config --cxxflags --ldflags --system-libs --libs core mcjit native` -O3 -o toy
     # Run
     ./toy
 
 Here is the code:
 
 .. literalinclude:: ../../examples/Kaleidoscope/Chapter5/toy.cpp
    :language: c++
 
 `Next: Extending the language: user-defined operators <LangImpl06.html>`_
 

docs/tutorial/LangImpl06.rst

 At the end of this tutorial, we'll run through an example Kaleidoscope
 application that `renders the Mandelbrot set <#kicking-the-tires>`_. This gives an
 example of what you can build with Kaleidoscope and its feature set.
 
 User-defined Operators: the Idea
 ================================
 
 The "operator overloading" that we will add to Kaleidoscope is more
-general than languages like C++. In C++, you are only allowed to
+general than in languages like C++. In C++, you are only allowed to
 redefine existing operators: you can't programmatically change the
 grammar, introduce new operators, change precedence levels, etc. In this
 chapter, we will add this capability to Kaleidoscope, which will let the
 user round out the set of operators that are supported.
 
 The point of going into user-defined operators in a tutorial like this
 is to show the power and flexibility of using a hand-written parser.
 Thus far, the parser we have been implementing uses recursive descent
 for most parts of the grammar and operator precedence parsing for the
-expressions. See `Chapter 2 <LangImpl2.html>`_ for details. Without
-using operator precedence parsing, it would be very difficult to allow
+expressions. See `Chapter 2 <LangImpl2.html>`_ for details. By
+using operator precedence parsing, it is very easy to allow
 the programmer to introduce new operators into the grammar: the grammar
 is dynamically extensible as the JIT runs.
 
 The two specific features we'll add are programmable unary operators
 (right now, Kaleidoscope has no unary operators at all) as well as
 binary operators. An example of this is:
 
 ::
class PrototypeAST {
       unsigned Precedence;  // Precedence if a binary op.
 
     public:
       PrototypeAST(const std::string &name, std::vector<std::string> Args,
                    bool IsOperator = false, unsigned Prec = 0)
       : Name(name), Args(std::move(Args)), IsOperator(IsOperator),
         Precedence(Prec) {}
 
+      Function *codegen();
+      const std::string &getName() const { return Name; }
+
       bool isUnaryOp() const { return IsOperator && Args.size() == 1; }
       bool isBinaryOp() const { return IsOperator && Args.size() == 2; }
 
       char getOperatorName() const {
         assert(isUnaryOp() || isBinaryOp());
-        return Name[Name.size()-1];
+        return Name[Name.size() - 1];
       }
 
       unsigned getBinaryPrecedence() const { return Precedence; }
-
-      Function *codegen();
     };
 
 Basically, in addition to knowing a name for the prototype, we now keep
 track of whether it was an operator, and if it was, what precedence
 level the operator is at. The precedence is only used for binary
 operators (as you'll see below, it just doesn't apply for unary
 operators). Now that we have a way to represent the prototype for a
 user-defined operator, we need to parse it:
static std::unique_ptr<PrototypeAST> ParsePrototype() {
         FnName = "binary";
         FnName += (char)CurTok;
         Kind = 2;
         getNextToken();
 
         // Read the precedence if present.
         if (CurTok == tok_number) {
           if (NumVal < 1 || NumVal > 100)
-            return LogErrorP("Invalid precedecnce: must be 1..100");
+            return LogErrorP("Invalid precedence: must be 1..100");
           BinaryPrecedence = (unsigned)NumVal;
           getNextToken();
         }
         break;
       }
 
       if (CurTok != '(')
         return LogErrorP("Expected '(' in prototype");
static std::unique_ptr<PrototypeAST> ParsePrototype() {
       return llvm::make_unique<PrototypeAST>(FnName, std::move(ArgNames), Kind != 0,
                                              BinaryPrecedence);
     }
 
 This is all fairly straightforward parsing code, and we have already
 seen a lot of similar code in the past. One interesting part about the
 code above is the couple lines that set up ``FnName`` for binary
 operators. This builds names like "binary@" for a newly defined "@"
-operator. This then takes advantage of the fact that symbol names in the
+operator. It then takes advantage of the fact that symbol names in the
 LLVM symbol table are allowed to have any character in them, including
 embedded nul characters.
 
 The next interesting thing to add, is codegen support for these binary
 operators. Given our current structure, this is a simple addition of a
 default case for our existing binary operator node:
 
 .. code-block:: c++
Value *BinaryExprAST::codegen() {
         return Builder.CreateFAdd(L, R, "addtmp");
       case '-':
         return Builder.CreateFSub(L, R, "subtmp");
       case '*':
         return Builder.CreateFMul(L, R, "multmp");
       case '<':
         L = Builder.CreateFCmpULT(L, R, "cmptmp");
         // Convert bool 0/1 to double 0.0 or 1.0
-        return Builder.CreateUIToFP(L, Type::getDoubleTy(LLVMContext),
+        return Builder.CreateUIToFP(L, Type::getDoubleTy(TheContext),
                                     "booltmp");
       default:
         break;
       }
 
       // If it wasn't a builtin binary operator, it must be a user defined one. Emit
       // a call to it.
-      Function *F = TheModule->getFunction(std::string("binary") + Op);
+      Function *F = getFunction(std::string("binary") + Op);
       assert(F && "binary operator not found!");
 
       Value *Ops[2] = { L, R };
       return Builder.CreateCall(F, Ops, "binop");
     }
 
 As you can see above, the new code is actually really simple. It just
 does a lookup for the appropriate operator in the symbol table and
 generates a function call to it. Since user-defined operators are just
 built as normal functions (because the "prototype" boils down to a
 function with the right name) everything falls into place.
 
 The final piece of code we are missing, is a bit of top-level magic:
 
 .. code-block:: c++
 
     Function *FunctionAST::codegen() {
-      NamedValues.clear();
-
-      Function *TheFunction = Proto->codegen();
+      // Transfer ownership of the prototype to the FunctionProtos map, but keep a
+      // reference to it for use below.
+      auto &P = *Proto;
+      FunctionProtos[Proto->getName()] = std::move(Proto);
+      Function *TheFunction = getFunction(P.getName());
       if (!TheFunction)
         return nullptr;
 
       // If this is an operator, install it.
-      if (Proto->isBinaryOp())
-        BinopPrecedence[Proto->getOperatorName()] = Proto->getBinaryPrecedence();
+      if (P.isBinaryOp())
+        BinopPrecedence[P.getOperatorName()] = P.getBinaryPrecedence();
 
       // Create a new basic block to start insertion into.
-      BasicBlock *BB = BasicBlock::Create(LLVMContext, "entry", TheFunction);
-      Builder.SetInsertPoint(BB);
-
-      if (Value *RetVal = Body->codegen()) {
-        ...
+      BasicBlock *BB = BasicBlock::Create(TheContext, "entry", TheFunction);
 
 Basically, before codegening a function, if it is a user-defined
 operator, we register it in the precedence table. This allows the binary
 operator parsing logic we already have in place to handle it. Since we
 are working on a fully-general operator precedence parser, this is all
 we need to do to "extend the grammar".
 
 Now we have useful user-defined binary operators. This builds a lot on
.. code-block:: c++
     /// 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)) {}
-      virtual Value *codegen();
+
+      Value *codegen() override;
     };
 
 This AST node is very simple and obvious by now. It directly mirrors the
 binary operator AST node, except that it only has one child. With this,
 we need to add the parsing logic. Parsing a unary operator is pretty
 simple: we'll add a new function to do it:
 
 .. code-block:: c++
 
     /// unary
     ///   ::= primary
     ///   ::= '!' unary
     static std::unique_ptr<ExprAST> ParseUnary() {
       // If the current token is not an operator, it must be a primary expr.
       if (!isascii(CurTok) || CurTok == '(' || CurTok == ',')
         return ParsePrimary();
 
       // If this is a unary operator, read it.
       int Opc = CurTok;
       getNextToken();
       if (auto Operand = ParseUnary())
-        return llvm::unique_ptr<UnaryExprAST>(Opc, std::move(Operand));
+        return llvm::make_unique<UnaryExprAST>(Opc, std::move(Operand));
       return nullptr;
     }
 
 The grammar we add is pretty straightforward here. If we see a unary
 operator when parsing a primary operator, we eat the operator as a
 prefix and parse the remaining piece as another unary operator. This
 allows us to handle multiple unary operators (e.g. "!!x"). Note that
 unary operators can't have ambiguous parses like binary operators can,

 
 .. code-block:: c++
 
     Value *UnaryExprAST::codegen() {
       Value *OperandV = Operand->codegen();
       if (!OperandV)
         return nullptr;
 
-      Function *F = TheModule->getFunction(std::string("unary")+Opcode);
+      Function *F = getFunction(std::string("unary") + Opcode);
       if (!F)
         return LogErrorV("Unknown unary operator");
 
       return Builder.CreateCall(F, OperandV, "unop");
     }
 
 This code is similar to, but simpler than, the code for binary
 operators. It is simpler primarily because it doesn't need to handle any

 
 ::
 
     ready> extern printd(x);
     Read extern:
     declare double @printd(double)
 
     ready> def binary : 1 (x y) 0;  # Low-precedence operator that ignores operands.
-    ..
+    ...
     ready> printd(123) : printd(456) : printd(789);
     123.000000
     456.000000
     789.000000
     Evaluated to 0.000000
 
 We can also define a bunch of other "primitive" operations, such as:
 

 
 Given the previous if/then/else support, we can also define interesting
 functions for I/O. For example, the following prints out a character
 whose "density" reflects the value passed in: the lower the value, the
 denser the character:
 
 ::
 
-    ready>
-
-    extern putchard(char)
-    def printdensity(d)
+    ready> extern putchard(char);
+    ...
+    ready> def printdensity(d)
       if d > 8 then
         putchard(32)  # ' '
       else if d > 4 then
         putchard(46)  # '.'
       else if d > 2 then
         putchard(43)  # '+'
       else
         putchard(42); # '*'
     ...
     ready> printdensity(1): printdensity(2): printdensity(3):
            printdensity(4): printdensity(5): printdensity(9):
            putchard(10);
     **++.
     Evaluated to 0.000000
 
 Based on these simple primitive operations, we can start to define more
-interesting things. For example, here's a little function that solves
-for the number of iterations it takes a function in the complex plane to
-converge:
+interesting things. For example, here's a little function that determines
+the number of iterations it takes for a certain function in the complex
+plane to diverge:
 
 ::
 
     # Determine whether the specific location diverges.
     # Solve for z = z^2 + c in the complex plane.
     def mandelconverger(real imag iters creal cimag)
       if iters > 255 | (real*real + imag*imag > 4) then
         iters

 variables <LangImpl7.html>`_ without having to add an "SSA construction"
 phase to your front-end. In the next chapter, we will describe how you
 can add variable mutation without building SSA in your front-end.
 
 Full Code Listing
 =================
 
 Here is the complete code listing for our running example, enhanced with
-the if/then/else and for expressions.. To build this example, use:
+the support for user-defined operators. To build this example, use:
 
 .. code-block:: bash
 
     # Compile
     clang++ -g toy.cpp `llvm-config --cxxflags --ldflags --system-libs --libs core mcjit native` -O3 -o toy
     # Run
     ./toy
 

docs/tutorial/LangImpl07.rst

 NamedValues map so that it maps to AllocaInst\* instead of Value\*. Once
 we do this, the C++ compiler will tell us what parts of the code we need
 to update:
 
 .. code-block:: c++
 
     static std::map<std::string, AllocaInst*> NamedValues;
 
-Also, since we will need to create these alloca's, we'll use a helper
+Also, since we will need to create these allocas, we'll use a helper
 function that ensures that the allocas are created in the entry block of
 the function:
 
 .. code-block:: c++
 
     /// 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(LLVMContext), 0,
+      return TmpB.CreateAlloca(Type::getDoubleTy(TheContext), 0,
                                VarName.c_str());
     }
 
 This funny looking code creates an IRBuilder object that is pointing at
 the first instruction (.begin()) of the entry block. It then creates an
 alloca with the expected name and returns it. Because all values in
 Kaleidoscope are doubles, there is no need to pass in a type to use.
 
-With this in place, the first functionality change we want to make is to
+With this in place, the first functionality change we want to make belongs to
 variable references. In our new scheme, variables live on the stack, so
 code generating a reference to them actually needs to produce a load
 from the stack slot:
 
 .. code-block:: c++
 
     Value *VariableExprAST::codegen() {
       // Look this variable up in the function.

 
 .. code-block:: c++
 
       Function *TheFunction = Builder.GetInsertBlock()->getParent();
 
       // Create an alloca for the variable in the entry block.
       AllocaInst *Alloca = CreateEntryBlockAlloca(TheFunction, VarName);
 
-        // Emit the start code first, without 'variable' in scope.
       Value *StartVal = Start->codegen();
       if (!StartVal)
         return nullptr;
 
       // Store the value into the alloca.
       Builder.CreateStore(StartVal, Alloca);
       ...
 

 no longer have to construct a PHI node, and we use load/store to access
 the variable as needed.
 
 To support mutable argument variables, we need to also make allocas for
 them. The code for this is also pretty simple:
 
 .. code-block:: c++
 
-    /// CreateArgumentAllocas - Create an alloca for each argument and register the
-    /// argument in the symbol table so that references to it will succeed.
-    void PrototypeAST::CreateArgumentAllocas(Function *F) {
-      Function::arg_iterator AI = F->arg_begin();
-      for (unsigned Idx = 0, e = Args.size(); Idx != e; ++Idx, ++AI) {
+    Function *FunctionAST::codegen() {
+      ...
+      Builder.SetInsertPoint(BB);
+
+      // Record the function arguments in the NamedValues map.
+      NamedValues.clear();
+      for (auto &Arg : TheFunction->args()) {
         // Create an alloca for this variable.
-        AllocaInst *Alloca = CreateEntryBlockAlloca(F, Args[Idx]);
+        AllocaInst *Alloca = CreateEntryBlockAlloca(TheFunction, Arg.getName());
 
         // Store the initial value into the alloca.
-        Builder.CreateStore(AI, Alloca);
+        Builder.CreateStore(&Arg, Alloca);
 
         // Add arguments to variable symbol table.
-        NamedValues[Args[Idx]] = Alloca;
-      }
+        NamedValues[Arg.getName()] = Alloca;
       }
 
+      if (Value *RetVal = Body->codegen()) {
+        ...
+
 For each argument, we make an alloca, store the input value to the
 function into the alloca, and register the alloca as the memory location
 for the argument. This method gets invoked by ``FunctionAST::codegen()``
 right after it sets up the entry block for the function.
 
 The final missing piece is adding the mem2reg pass, which allows us to
 get good codegen once again:
 
 .. code-block:: c++
 
-        // Set up the optimizer pipeline.  Start with registering info about how the
-        // target lays out data structures.
-        OurFPM.add(new DataLayout(*TheExecutionEngine->getDataLayout()));
         // Promote allocas to registers.
-        OurFPM.add(createPromoteMemoryToRegisterPass());
+        TheFPM->add(createPromoteMemoryToRegisterPass());
         // Do simple "peephole" optimizations and bit-twiddling optzns.
-        OurFPM.add(createInstructionCombiningPass());
+        TheFPM->add(createInstructionCombiningPass());
         // Reassociate expressions.
-        OurFPM.add(createReassociatePass());
+        TheFPM->add(createReassociatePass());
+        ...
 
 It is interesting to see what the code looks like before and after the
 mem2reg optimization runs. For example, this is the before/after code
 for our recursive fib function. Before the optimization:
 
 .. code-block:: llvm
 
     define double @fib(double %x) {
     entry:
       %x1 = alloca double
       store double %x, double* %x1
-      %x2 = load double* %x1
+      %x2 = load double, double* %x1
       %cmptmp = fcmp ult double %x2, 3.000000e+00
       %booltmp = uitofp i1 %cmptmp to double
       %ifcond = fcmp one double %booltmp, 0.000000e+00
       br i1 %ifcond, label %then, label %else
 
     then:       ; preds = %entry
       br label %ifcont
 
     else:       ; preds = %entry
-      %x3 = load double* %x1
+      %x3 = load double, double* %x1
       %subtmp = fsub double %x3, 1.000000e+00
       %calltmp = call double @fib(double %subtmp)
-      %x4 = load double* %x1
+      %x4 = load double, double* %x1
       %subtmp5 = fsub double %x4, 2.000000e+00
       %calltmp6 = call double @fib(double %subtmp5)
       %addtmp = fadd double %calltmp, %calltmp6
       br label %ifcont
 
     ifcont:     ; preds = %else, %then
       %iftmp = phi double [ 1.000000e+00, %then ], [ %addtmp, %else ]
       ret double %iftmp
.. code-block:: c++
 
     /// 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)
+                 std::unique_ptr<ExprAST> Body)
         : VarNames(std::move(VarNames)), Body(std::move(Body)) {}
 
-      virtual Value *codegen();
+      Value *codegen() override;
     };
 
 var/in allows a list of names to be defined all at once, and each name
 can optionally have an initializer value. As such, we capture this
 information in the VarNames vector. Also, var/in has a body, this body
 is allowed to access the variables defined by the var/in.
 
 With this in place, we can define the parser pieces. The first thing we
.. code-block:: c++
         //  var a = 1 in
         //    var a = a in ...   # refers to outer 'a'.
         Value *InitVal;
         if (Init) {
           InitVal = Init->codegen();
           if (!InitVal)
             return nullptr;
         } else { // If not specified, use 0.0.
-          InitVal = ConstantFP::get(LLVMContext, APFloat(0.0));
+          InitVal = ConstantFP::get(TheContext, APFloat(0.0));
         }
 
         AllocaInst *Alloca = CreateEntryBlockAlloca(TheFunction, VarName);
         Builder.CreateStore(InitVal, Alloca);
 
         // Remember the old variable binding so that we can restore the binding when
         // we unrecurse.
         OldBindings.push_back(NamedValues[VarName]);

docs/tutorial/LangImpl09.rst

@@ -1184,7 +1183,6 @@ int main() {
      BinopPrecedence['*'] = 40; // highest.
  
      // Prime the first token.
   -  fprintf(stderr, "ready> ");
      getNextToken();
  
 Lastly we're going to disable all of the optimization passes and the JIT so
 that the only thing that happens after we're done parsing and generating
-code is that the llvm IR goes to standard error:
+code is that the LLVM IR goes to standard error:
 
 .. code-block:: udiff
 
   @@ -1108,17 +1108,8 @@ static void HandleExtern() {
    static void HandleTopLevelExpression() {
      // Evaluate a top-level expression into an anonymous function.
      if (auto FnAST = ParseTopLevelExpr()) {
   -    if (auto *FnIR = FnAST->codegen()) {

 (read: one file of source code). So the first thing we need to do is
 construct one for our fib.ks file.
 
 DWARF Emission Setup
 ====================
 
 Similar to the ``IRBuilder`` class we have a
 `DIBuilder <http://llvm.org/doxygen/classllvm_1_1DIBuilder.html>`_ class
-that helps in constructing debug metadata for an llvm IR file. It
-corresponds 1:1 similarly to ``IRBuilder`` and llvm IR, but with nicer names.
+that helps in constructing debug metadata for an LLVM IR file. It
+corresponds 1:1 similarly to ``IRBuilder`` and LLVM IR, but with nicer names.
 Using it does require that you be more familiar with DWARF terminology than
 you needed to be with ``IRBuilder`` and ``Instruction`` names, but if you
 read through the general documentation on the
 `Metadata Format <http://llvm.org/docs/SourceLevelDebugging.html>`_ it
 should be a little more clear. We'll be using this class to construct all
 of our IR level descriptions. Construction for it takes a module so we
 need to construct it shortly after we construct our module. We've left it
 as a global static variable to make it a bit easier to use.
.. code-block:: c++
   struct DebugInfo {
     DICompileUnit *TheCU;
     DIType *DblTy;
 
     DIType *getDoubleTy();
   } KSDbgInfo;
 
   DIType *DebugInfo::getDoubleTy() {
-    if (DblTy.isValid())
+    if (DblTy)
       return DblTy;
 
     DblTy = DBuilder->createBasicType("double", 64, 64, dwarf::DW_ATE_float);
     return DblTy;
   }
 
 And then later on in ``main`` when we're constructing our module:
 
 .. code-block:: c++
 
   DBuilder = new DIBuilder(*TheModule);
 
   KSDbgInfo.TheCU = DBuilder->createCompileUnit(
       dwarf::DW_LANG_C, "fib.ks", ".", "Kaleidoscope Compiler", 0, "", 0);
 
 There are a couple of things to note here. First, while we're producing a
 compile unit for a language called Kaleidoscope we used the language
 constant for C. This is because a debugger wouldn't necessarily understand
 the calling conventions or default ABI for a language it doesn't recognize
-and we follow the C ABI in our llvm code generation so it's the closest
+and we follow the C ABI in our LLVM code generation so it's the closest
 thing to accurate. This ensures we can actually call functions from the
 debugger and have them execute. Secondly, you'll see the "fib.ks" in the
 call to ``createCompileUnit``. This is a default hard coded value since
 we're using shell redirection to put our source into the Kaleidoscope
 compiler. In a usual front end you'd have an input file name and it would
 go there.
 
 One last thing as part of emitting debug information via DIBuilder is that

 information) and construct our function definition:
 
 .. code-block:: c++
 
   DIScope *FContext = Unit;
   unsigned LineNo = 0;
   unsigned ScopeLine = 0;
   DISubprogram *SP = DBuilder->createFunction(
-      FContext, Name, StringRef(), Unit, LineNo,
-      CreateFunctionType(Args.size(), Unit), false /* internal linkage */,
-      true /* definition */, ScopeLine, DINode::FlagPrototyped, false);
-  F->setSubprogram(SP);
+      FContext, P.getName(), StringRef(), Unit, LineNo,
+      CreateFunctionType(TheFunction->arg_size(), Unit),
+      false /* internal linkage */, true /* definition */, ScopeLine,
+      DINode::FlagPrototyped, false);
+  TheFunction->setSubprogram(SP);
 
 and we now have an DISubprogram that contains a reference to all of our
 metadata for the function.
 
 Source Locations
 ================
 
 The most important thing for debug information is accurate source location -

 
 .. code-block:: c++
 
    LHS = llvm::make_unique<BinaryExprAST>(BinLoc, BinOp, std::move(LHS),
                                           std::move(RHS));
 
 giving us locations for each of our expressions and variables.
 
-From this we can make sure to tell ``DIBuilder`` when we're at a new source
-location so it can use that when we generate the rest of our code and make
-sure that each instruction has source location information. We do this
-by constructing another small function:
+To make sure that every instruction gets proper source location information,
+we have to tell ``Builder`` whenever we're at a new source location.
+We use a small helper function for this:
 
 .. code-block:: c++
 
   void DebugInfo::emitLocation(ExprAST *AST) {
     DIScope *Scope;
     if (LexicalBlocks.empty())
       Scope = TheCU;
     else
       Scope = LexicalBlocks.back();
     Builder.SetCurrentDebugLocation(
         DebugLoc::get(AST->getLine(), AST->getCol(), Scope));
   }
 
-that both tells the main ``IRBuilder`` where we are, but also what scope
-we're in. Since we've just created a function above we can either be in
-the main file scope (like when we created our function), or now we can be
-in the function scope we just created. To represent this we create a stack
-of scopes:
+This both tells the main ``IRBuilder`` where we are, but also what scope
+we're in. The scope can either be on compile-unit level or be the nearest
+enclosing lexical block like the current function. 
+To represent this we create a stack of scopes:
 
 .. code-block:: c++
 
    std::vector<DIScope *> LexicalBlocks;
-   std::map<const PrototypeAST *, DIScope *> FnScopeMap;
 
-and keep a map of each function to the scope that it represents (an
-DISubprogram is also an DIScope).
-
-Then we make sure to:
-
-.. code-block:: c++
-
-   KSDbgInfo.emitLocation(this);
-
-emit the location every time we start to generate code for a new AST, and
-also:
+and push the scope (function) to the top of the stack when we start
+generating the code for each function:
 
 .. code-block:: c++
 
-  KSDbgInfo.FnScopeMap[this] = SP;
+  KSDbgInfo.LexicalBlocks.push_back(SP);
 
-store the scope (function) when we create it and use it:
-
-  KSDbgInfo.LexicalBlocks.push_back(&KSDbgInfo.FnScopeMap[Proto]);
-
-when we start generating the code for each function.
-
-also, don't forget to pop the scope back off of your scope stack at the
+Also, we may not forget to pop the scope back off of the scope stack at the
 end of the code generation for the function:
 
 .. code-block:: c++
 
   // Pop off the lexical block for the function since we added it
   // unconditionally.
   KSDbgInfo.LexicalBlocks.pop_back();
 
+Then we make sure to emit the location every time we start to generate code
+for a new AST object:
+
+.. code-block:: c++
+
+   KSDbgInfo.emitLocation(this);
+
 Variables
 =========
 
 Now that we have functions, we need to be able to print out the variables
 we have in scope. Let's get our function arguments set up so we can get
 decent backtraces and see how our functions are being called. It isn't
 a lot of code, and we generally handle it when we're creating the
-argument allocas in ``PrototypeAST::CreateArgumentAllocas``.
+argument allocas in ``FunctionAST::codegen``.
 
 .. code-block:: c++
 
-  DIScope *Scope = KSDbgInfo.LexicalBlocks.back();
-  DIFile *Unit = DBuilder->createFile(KSDbgInfo.TheCU.getFilename(),
-                                      KSDbgInfo.TheCU.getDirectory());
-  DILocalVariable D = DBuilder->createParameterVariable(
-      Scope, Args[Idx], Idx + 1, Unit, Line, KSDbgInfo.getDoubleTy(), true);
+    // Record the function arguments in the NamedValues map.
+    NamedValues.clear();
+    unsigned ArgIdx = 0;
+    for (auto &Arg : TheFunction->args()) {
+      // Create an alloca for this variable.
+      AllocaInst *Alloca = CreateEntryBlockAlloca(TheFunction, Arg.getName());
+
+      // Create a debug descriptor for the variable.
+      DILocalVariable *D = DBuilder->createParameterVariable(
+          SP, Arg.getName(), ++ArgIdx, Unit, LineNo, KSDbgInfo.getDoubleTy(),
+          true);
 
       DBuilder->insertDeclare(Alloca, D, DBuilder->createExpression(),
-                          DebugLoc::get(Line, 0, Scope),
+                              DebugLoc::get(LineNo, 0, SP),
                               Builder.GetInsertBlock());
 
-Here we're doing a few things. First, we're grabbing our current scope
-for the variable so we can say what range of code our variable is valid
-through. Second, we're creating the variable, giving it the scope,
+      // Store the initial value into the alloca.
+      Builder.CreateStore(&Arg, Alloca);
+
+      // Add arguments to variable symbol table.
+      NamedValues[Arg.getName()] = Alloca;
+    }
+
+
+Here we're first creating the variable, giving it the scope (``SP``),
 the name, source location, type, and since it's an argument, the argument
-index. Third, we create an ``lvm.dbg.declare`` call to indicate at the IR
+index. Next, we create an ``lvm.dbg.declare`` call to indicate at the IR
 level that we've got a variable in an alloca (and it gives a starting
 location for the variable), and setting a source location for the
 beginning of the scope on the declare.
 
 One interesting thing to note at this point is that various debuggers have
 assumptions based on how code and debug information was generated for them
 in the past. In this case we need to do a little bit of a hack to avoid
 generating line information for the function prologue so that the debugger
 knows to skip over those instructions when setting a breakpoint. So in
-``FunctionAST::CodeGen`` we add a couple of lines:
+``FunctionAST::CodeGen`` we add some more lines:
 
 .. code-block:: c++
 
   // Unset the location for the prologue emission (leading instructions with no
   // location in a function are considered part of the prologue and the debugger
   // will run past them when breaking on a function)
   KSDbgInfo.emitLocation(nullptr);
 
 and then emit a new location when we actually start generating code for the
 body of the function:
 
 .. code-block:: c++
 
-  KSDbgInfo.emitLocation(Body);
+  KSDbgInfo.emitLocation(Body.get());
 
 With this we have enough debug information to set breakpoints in functions,
 print out argument variables, and call functions. Not too bad for just a
 few simple lines of code!
 
 Full Code Listing
 =================
 

examples/Kaleidoscope/Chapter2/toy.cpp

 /// of arguments the function takes).
 class PrototypeAST {
   std::string Name;
   std::vector<std::string> Args;
 
 public:
   PrototypeAST(const std::string &Name, std::vector<std::string> Args)
       : Name(Name), Args(std::move(Args)) {}
+
+  const std::string &getName() const { return Name; }
 };
 
 /// FunctionAST - This class represents a function definition itself.
 class FunctionAST {
   std::unique_ptr<PrototypeAST> Proto;
   std::unique_ptr<ExprAST> Body;
 
 public:

examples/Kaleidoscope/Chapter4/toy.cpp

while (true) {
     }
   }
 }
 
 //===----------------------------------------------------------------------===//
 // "Library" functions that can be "extern'd" from user code.
 //===----------------------------------------------------------------------===//
 
+#ifdef LLVM_ON_WIN32
+#define DLLEXPORT __declspec(dllexport)
+#else
+#define DLLEXPORT
+#endif
+
 /// putchard - putchar that takes a double and returns 0.
-extern "C" double putchard(double X) {
+extern "C" DLLEXPORT double putchard(double X) {
   fputc((char)X, stderr);
   return 0;
 }
 
 /// printd - printf that takes a double prints it as "%f\n", returning 0.
-extern "C" double printd(double X) {
+extern "C" DLLEXPORT double printd(double X) {
   fprintf(stderr, "%f\n", X);
   return 0;
 }
 
 //===----------------------------------------------------------------------===//
 // Main driver code.
 //===----------------------------------------------------------------------===//
 

examples/Kaleidoscope/Chapter5/toy.cpp

Value *CallExprAST::codegen() {
   return Builder.CreateCall(CalleeF, ArgsV, "calltmp");
 }
 
 Value *IfExprAST::codegen() {
   Value *CondV = Cond->codegen();
   if (!CondV)
     return nullptr;
 
-  // Convert condition to a bool by comparing equal to 0.0.
+  // Convert condition to a bool by comparing non-equal to 0.0.
   CondV = Builder.CreateFCmpONE(
       CondV, ConstantFP::get(TheContext, APFloat(0.0)), "ifcond");
 
   Function *TheFunction = Builder.GetInsertBlock()->getParent();
 
   // Create blocks for the then and else cases.  Insert the 'then' block at the
   // end of the function.
   BasicBlock *ThenBB = BasicBlock::Create(TheContext, "then", TheFunction);
Value *ForExprAST::codegen() {
 
   Value *NextVar = Builder.CreateFAdd(Variable, StepVal, "nextvar");
 
   // Compute the end condition.
   Value *EndCond = End->codegen();
   if (!EndCond)
     return nullptr;
 
-  // Convert condition to a bool by comparing equal to 0.0.
+  // Convert condition to a bool by comparing non-equal to 0.0.
   EndCond = Builder.CreateFCmpONE(
       EndCond, ConstantFP::get(TheContext, APFloat(0.0)), "loopcond");
 
   // Create the "after loop" block and insert it.
   BasicBlock *LoopEndBB = Builder.GetInsertBlock();
   BasicBlock *AfterBB =
       BasicBlock::Create(TheContext, "afterloop", TheFunction);
 
while (true) {
     }
   }
 }
 
 //===----------------------------------------------------------------------===//
 // "Library" functions that can be "extern'd" from user code.
 //===----------------------------------------------------------------------===//
 
+#ifdef LLVM_ON_WIN32
+#define DLLEXPORT __declspec(dllexport)
+#else
+#define DLLEXPORT
+#endif
+
 /// putchard - putchar that takes a double and returns 0.
-extern "C" double putchard(double X) {
+extern "C" DLLEXPORT double putchard(double X) {
   fputc((char)X, stderr);
   return 0;
 }
 
 /// printd - printf that takes a double prints it as "%f\n", returning 0.
-extern "C" double printd(double X) {
+extern "C" DLLEXPORT double printd(double X) {
   fprintf(stderr, "%f\n", X);
   return 0;
 }
 
 //===----------------------------------------------------------------------===//
 // Main driver code.
 //===----------------------------------------------------------------------===//
 

examples/Kaleidoscope/Chapter6/toy.cpp

case tok_binary:
     FnName = "binary";
     FnName += (char)CurTok;
     Kind = 2;
     getNextToken();
 
     // Read the precedence if present.
     if (CurTok == tok_number) {
       if (NumVal < 1 || NumVal > 100)
-        return LogErrorP("Invalid precedecnce: must be 1..100");
+        return LogErrorP("Invalid precedence: must be 1..100");
       BinaryPrecedence = (unsigned)NumVal;
       getNextToken();
     }
     break;
   }
 
   if (CurTok != '(')
     return LogErrorP("Expected '(' in prototype");
Value *CallExprAST::codegen() {
   return Builder.CreateCall(CalleeF, ArgsV, "calltmp");
 }
 
 Value *IfExprAST::codegen() {
   Value *CondV = Cond->codegen();
   if (!CondV)
     return nullptr;
 
-  // Convert condition to a bool by comparing equal to 0.0.
+  // Convert condition to a bool by comparing non-equal to 0.0.
   CondV = Builder.CreateFCmpONE(
       CondV, ConstantFP::get(TheContext, APFloat(0.0)), "ifcond");
 
   Function *TheFunction = Builder.GetInsertBlock()->getParent();
 
   // Create blocks for the then and else cases.  Insert the 'then' block at the
   // end of the function.
   BasicBlock *ThenBB = BasicBlock::Create(TheContext, "then", TheFunction);
Value *ForExprAST::codegen() {
 
   Value *NextVar = Builder.CreateFAdd(Variable, StepVal, "nextvar");
 
   // Compute the end condition.
   Value *EndCond = End->codegen();
   if (!EndCond)
     return nullptr;
 
-  // Convert condition to a bool by comparing equal to 0.0.
+  // Convert condition to a bool by comparing non-equal to 0.0.
   EndCond = Builder.CreateFCmpONE(
       EndCond, ConstantFP::get(TheContext, APFloat(0.0)), "loopcond");
 
   // Create the "after loop" block and insert it.
   BasicBlock *LoopEndBB = Builder.GetInsertBlock();
   BasicBlock *AfterBB =
       BasicBlock::Create(TheContext, "afterloop", TheFunction);
 
while (true) {
     }
   }
 }
 
 //===----------------------------------------------------------------------===//
 // "Library" functions that can be "extern'd" from user code.
 //===----------------------------------------------------------------------===//
 
+#ifdef LLVM_ON_WIN32
+#define DLLEXPORT __declspec(dllexport)
+#else
+#define DLLEXPORT
+#endif
+
 /// putchard - putchar that takes a double and returns 0.
-extern "C" double putchard(double X) {
+extern "C" DLLEXPORT double putchard(double X) {
   fputc((char)X, stderr);
   return 0;
 }
 
 /// printd - printf that takes a double prints it as "%f\n", returning 0.
-extern "C" double printd(double X) {
+extern "C" DLLEXPORT double printd(double X) {
   fprintf(stderr, "%f\n", X);
   return 0;
 }
 
 //===----------------------------------------------------------------------===//
 // Main driver code.
 //===----------------------------------------------------------------------===//
 

examples/Kaleidoscope/Chapter7/toy.cpp

case tok_binary:
     FnName = "binary";
     FnName += (char)CurTok;
     Kind = 2;
     getNextToken();
 
     // Read the precedence if present.
     if (CurTok == tok_number) {
       if (NumVal < 1 || NumVal > 100)
-        return LogErrorP("Invalid precedecnce: must be 1..100");
+        return LogErrorP("Invalid precedence: must be 1..100");
       BinaryPrecedence = (unsigned)NumVal;
       getNextToken();
     }
     break;
   }
 
   if (CurTok != '(')
     return LogErrorP("Expected '(' in prototype");
Value *CallExprAST::codegen() {
   return Builder.CreateCall(CalleeF, ArgsV, "calltmp");
 }
 
 Value *IfExprAST::codegen() {
   Value *CondV = Cond->codegen();
   if (!CondV)
     return nullptr;
 
-  // Convert condition to a bool by comparing equal to 0.0.
+  // Convert condition to a bool by comparing non-equal to 0.0.
   CondV = Builder.CreateFCmpONE(
       CondV, ConstantFP::get(TheContext, APFloat(0.0)), "ifcond");
 
   Function *TheFunction = Builder.GetInsertBlock()->getParent();
 
   // Create blocks for the then and else cases.  Insert the 'then' block at the
   // end of the function.
   BasicBlock *ThenBB = BasicBlock::Create(TheContext, "then", TheFunction);
if (!EndCond)
     return nullptr;
 
   // Reload, increment, and restore the alloca.  This handles the case where
   // the body of the loop mutates the variable.
   Value *CurVar = Builder.CreateLoad(Alloca, VarName.c_str());
   Value *NextVar = Builder.CreateFAdd(CurVar, StepVal, "nextvar");
   Builder.CreateStore(NextVar, Alloca);
 
-  // Convert condition to a bool by comparing equal to 0.0.
+  // Convert condition to a bool by comparing non-equal to 0.0.
   EndCond = Builder.CreateFCmpONE(
       EndCond, ConstantFP::get(TheContext, APFloat(0.0)), "loopcond");
 
   // Create the "after loop" block and insert it.
   BasicBlock *AfterBB =
       BasicBlock::Create(TheContext, "afterloop", TheFunction);
 
   // Insert the conditional branch into the end of LoopEndBB.

 static void InitializeModuleAndPassManager() {
   // Open a new module.
   TheModule = llvm::make_unique<Module>("my cool jit", TheContext);
   TheModule->setDataLayout(TheJIT->getTargetMachine().createDataLayout());
 
   // Create a new pass manager attached to it.
   TheFPM = llvm::make_unique<legacy::FunctionPassManager>(TheModule.get());
 
+  // Promote allocas to registers.
+  TheFPM->add(createPromoteMemoryToRegisterPass());
   // Do simple "peephole" optimizations and bit-twiddling optzns.
   TheFPM->add(createInstructionCombiningPass());
   // Reassociate expressions.
   TheFPM->add(createReassociatePass());
   // Eliminate Common SubExpressions.
   TheFPM->add(createGVNPass());
   // Simplify the control flow graph (deleting unreachable blocks, etc).
   TheFPM->add(createCFGSimplificationPass());
while (true) {
     }
   }
 }
 
 //===----------------------------------------------------------------------===//
 // "Library" functions that can be "extern'd" from user code.
 //===----------------------------------------------------------------------===//
 
+#ifdef LLVM_ON_WIN32
+#define DLLEXPORT __declspec(dllexport)
+#else
+#define DLLEXPORT
+#endif
+
 /// putchard - putchar that takes a double and returns 0.
-extern "C" double putchard(double X) {
+extern "C" DLLEXPORT double putchard(double X) {
   fputc((char)X, stderr);
   return 0;
 }
 
 /// printd - printf that takes a double prints it as "%f\n", returning 0.
-extern "C" double printd(double X) {
+extern "C" DLLEXPORT double printd(double X) {
   fprintf(stderr, "%f\n", X);
   return 0;
 }
 
 //===----------------------------------------------------------------------===//
 // Main driver code.
 //===----------------------------------------------------------------------===//
 

examples/Kaleidoscope/Chapter8/toy.cpp

case tok_binary:
     FnName = "binary";
     FnName += (char)CurTok;
     Kind = 2;
     getNextToken();
 
     // Read the precedence if present.
     if (CurTok == tok_number) {
       if (NumVal < 1 || NumVal > 100)
-        return LogErrorP("Invalid precedecnce: must be 1..100");
+        return LogErrorP("Invalid precedence: must be 1..100");
       BinaryPrecedence = (unsigned)NumVal;
       getNextToken();
     }
     break;
   }
 
   if (CurTok != '(')
     return LogErrorP("Expected '(' in prototype");
Value *CallExprAST::codegen() {
   return Builder.CreateCall(CalleeF, ArgsV, "calltmp");
 }
 
 Value *IfExprAST::codegen() {
   Value *CondV = Cond->codegen();
   if (!CondV)
     return nullptr;
 
-  // Convert condition to a bool by comparing equal to 0.0.
+  // Convert condition to a bool by comparing non-equal to 0.0.
   CondV = Builder.CreateFCmpONE(
       CondV, ConstantFP::get(TheContext, APFloat(0.0)), "ifcond");
 
   Function *TheFunction = Builder.GetInsertBlock()->getParent();
 
   // Create blocks for the then and else cases.  Insert the 'then' block at the
   // end of the function.
   BasicBlock *ThenBB = BasicBlock::Create(TheContext, "then", TheFunction);
if (!EndCond)
     return nullptr;
 
   // Reload, increment, and restore the alloca.  This handles the case where
   // the body of the loop mutates the variable.
   Value *CurVar = Builder.CreateLoad(Alloca, VarName.c_str());
   Value *NextVar = Builder.CreateFAdd(CurVar, StepVal, "nextvar");
   Builder.CreateStore(NextVar, Alloca);
 
-  // Convert condition to a bool by comparing equal to 0.0.
+  // Convert condition to a bool by comparing non-equal to 0.0.
   EndCond = Builder.CreateFCmpONE(
       EndCond, ConstantFP::get(TheContext, APFloat(0.0)), "loopcond");
 
   // Create the "after loop" block and insert it.
   BasicBlock *AfterBB =
       BasicBlock::Create(TheContext, "afterloop", TheFunction);
 
   // Insert the conditional branch into the end of LoopEndBB.
while (true) {
     }
   }
 }
 
 //===----------------------------------------------------------------------===//
 // "Library" functions that can be "extern'd" from user code.
 //===----------------------------------------------------------------------===//
 
+#ifdef LLVM_ON_WIN32
+#define DLLEXPORT __declspec(dllexport)
+#else
+#define DLLEXPORT
+#endif
+
 /// putchard - putchar that takes a double and returns 0.
-extern "C" double putchard(double X) {
+extern "C" DLLEXPORT double putchard(double X) {
   fputc((char)X, stderr);
   return 0;
 }
 
 /// printd - printf that takes a double prints it as "%f\n", returning 0.
-extern "C" double printd(double X) {
+extern "C" DLLEXPORT double printd(double X) {
   fprintf(stderr, "%f\n", X);
   return 0;
 }
 
 //===----------------------------------------------------------------------===//
 // Main driver code.
 //===----------------------------------------------------------------------===//
 

examples/Kaleidoscope/Chapter9/toy.cpp

case tok_binary:
     FnName = "binary";
     FnName += (char)CurTok;
     Kind = 2;
     getNextToken();
 
     // Read the precedence if present.
     if (CurTok == tok_number) {
       if (NumVal < 1 || NumVal > 100)
-        return LogErrorP("Invalid precedecnce: must be 1..100");
+        return LogErrorP("Invalid precedence: must be 1..100");
       BinaryPrecedence = (unsigned)NumVal;
       getNextToken();
     }
     break;
   }
 
   if (CurTok != '(')
     return LogErrorP("Expected '(' in prototype");

 
 Value *IfExprAST::codegen() {
   KSDbgInfo.emitLocation(this);
 
   Value *CondV = Cond->codegen();
   if (!CondV)
     return nullptr;
 
-  // Convert condition to a bool by comparing equal to 0.0.
+  // Convert condition to a bool by comparing non-equal to 0.0.
   CondV = Builder.CreateFCmpONE(
       CondV, ConstantFP::get(TheContext, APFloat(0.0)), "ifcond");
 
   Function *TheFunction = Builder.GetInsertBlock()->getParent();
 
   // Create blocks for the then and else cases.  Insert the 'then' block at the
   // end of the function.
   BasicBlock *ThenBB = BasicBlock::Create(TheContext, "then", TheFunction);
if (!EndCond)
     return nullptr;
 
   // Reload, increment, and restore the alloca.  This handles the case where
   // the body of the loop mutates the variable.
   Value *CurVar = Builder.CreateLoad(Alloca, VarName.c_str());
   Value *NextVar = Builder.CreateFAdd(CurVar, StepVal, "nextvar");
   Builder.CreateStore(NextVar, Alloca);
 
-  // Convert condition to a bool by comparing equal to 0.0.
+  // Convert condition to a bool by comparing non-equal to 0.0.
   EndCond = Builder.CreateFCmpONE(
       EndCond, ConstantFP::get(TheContext, APFloat(0.0)), "loopcond");
 
   // Create the "after loop" block and insert it.
   BasicBlock *AfterBB =
       BasicBlock::Create(TheContext, "afterloop", TheFunction);
 
   // Insert the conditional branch into the end of LoopEndBB.
while (1) {
     }
   }
 }
 
 //===----------------------------------------------------------------------===//
 // "Library" functions that can be "extern'd" from user code.
 //===----------------------------------------------------------------------===//
 
+#ifdef LLVM_ON_WIN32
+#define DLLEXPORT __declspec(dllexport)
+#else
+#define DLLEXPORT
+#endif
+
 /// putchard - putchar that takes a double and returns 0.
-extern "C" double putchard(double X) {
+extern "C" DLLEXPORT double putchard(double X) {
   fputc((char)X, stderr);
   return 0;
 }
 
 /// printd - printf that takes a double prints it as "%f\n", returning 0.
-extern "C" double printd(double X) {
+extern "C" DLLEXPORT double printd(double X) {
   fprintf(stderr, "%f\n", X);
   return 0;
 }
 
 //===----------------------------------------------------------------------===//
 // Main driver code.
 //===----------------------------------------------------------------------===//
 

examples/Kaleidoscope/include/KaleidoscopeJIT.h

private:
 
   template <typename T> static std::vector<T> singletonSet(T t) {
     std::vector<T> Vec;
     Vec.push_back(std::move(t));
     return Vec;
   }
 
   JITSymbol findMangledSymbol(const std::string &Name) {
+#ifdef LLVM_ON_WIN32
+    // The symbol lookup of ObjectLinkingLayer uses the SymbolRef::SF_Exported
+    // flag to decide whether a symbol will be visible or not, when we call
+    // IRCompileLayer::findSymbolIn with ExportedSymbolsOnly set to true.
+    // 
+    // But for Windows COFF objects, this flag is currently never set.
+    // For a potential solution see: https://reviews.llvm.org/rL258665
+    // For now, we allow non-exported symbols on Windows as a workaround.
+    const bool ExportedSymbolsOnly = false;
+#else
+    const bool ExportedSymbolsOnly = true;
+#endif
+  
     // Search modules in reverse order: from last added to first added.
     // This is the opposite of the usual search order for dlsym, but makes more
     // sense in a REPL where we want to bind to the newest available definition.
     for (auto H : make_range(ModuleHandles.rbegin(), ModuleHandles.rend()))
-      if (auto Sym = CompileLayer.findSymbolIn(H, Name, true))
+      if (auto Sym = CompileLayer.findSymbolIn(H, Name, ExportedSymbolsOnly))
         return Sym;
 
     // If we can't find the symbol in the JIT, try looking in the host process.
     if (auto SymAddr = RTDyldMemoryManager::getSymbolAddressInProcess(Name))
       return JITSymbol(SymAddr, JITSymbolFlags::Exported);
 
+#ifdef LLVM_ON_WIN32
+    // For Windows retry without "_" at begining, as RTDyldMemoryManager uses
+    // GetProcAddress and standard libraries like msvcrt.dll use names
+    // with and without "_" (for example "_itoa" but "sin").
+    if (Name.length() > 2 && Name[0] == '_')
+      if (auto SymAddr = RTDyldMemoryManager::getSymbolAddressInProcess(
+            Name.substr(1)))
+        return JITSymbol(SymAddr, JITSymbolFlags::Exported);
+#endif 
+
     return nullptr;
   }
 
   std::unique_ptr<TargetMachine> TM;
   const DataLayout DL;
   ObjLayerT ObjectLayer;
   CompileLayerT CompileLayer;
   std::vector<ModuleHandleT> ModuleHandles;
 };
 
 } // end namespace orc
 } // end namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_ORC_KALEIDOSCOPEJIT_H