[Kaleidoscope] Update code snippets in text to match full code listings

[0xdc03]

Summary

There were quite a few places in the tutorial where the snippets were not up to date with the full code listings given. I have updated all of the ones I could find, which mostly involves changing . to -> when accessing through a std::unique_ptr, changing while (1) to while (true), and other such small changes.

There are still however a few places where I am not sure what to do, such as:

• Chapter 4: ParseTopLevelExpr() in chapter 3 sets the ProtoTypeAST name to "", however it is referred to as "__anon_expr" in chapter 4. Would it be required to mention this change in chapter 4?
• Chapter 9: The code snippets refer to the top level expression as "main", however the full code listing refers to it as "__anon_expr". I think given the context of the chapter it makes sense to refer to it as "main", so I have updated the code listing to reflect that.
• Chapter 9: In chapter 9 the diff given for HandleTopLevelExpression() deletes code that is not mentioned anywhere else, so I am not sure what is to be done there.
• Miscellaneous: I don't think this is very important, however the casing used for the first word of error messages tends to vary between upper and lower case between chapters and I do not know if it is worth reconciling these differences.

[xgupta]

Thank you for the patch!

I went through all the changes, they look good to me.

llvm/docs/tutorial/MyFirstLanguageFrontend/LangImpl04.rst

300

we may remove this line.

llvm/docs/tutorial/MyFirstLanguageFrontend/LangImpl07.rst

582

Not sure about this, why not use static_cast then by default? @kazu might better review this.

llvm/examples/Kaleidoscope/Chapter9/toy.cpp

802–803

// Make an anonymous proto.

This comment is better suited for __anon_expr. we should keep it.

[0xdc03]

llvm/docs/tutorial/MyFirstLanguageFrontend/LangImpl04.rst

300

I thought it would be more useful to know what the type of ExitOnErr was, as this variable has never been referenced before, and it would help not having to scroll to the very end for that

llvm/docs/tutorial/MyFirstLanguageFrontend/LangImpl07.rst

582

Yeah, I was a little confused at this point so I decided to stick with what the tutorial had before and mention how the code listing did it

llvm/examples/Kaleidoscope/Chapter9/toy.cpp

802–803

Oh, I completely missed this comment! This was also one of the points where I wasn't sure what to do. Given that the start of the chapter explicitly says

First we make our anonymous function that contains our top level statement be our “main”:

under section 9.3, I feel it'd be better to update the comment to say something like // Make the top level expression be our "main" function

[0xdc03]

• Update the comment in the code listing to match the code below it

[0xdc03]

@xgupta I have updated the comment in the code listing to match the code that creates the function. I think it is better to keep the ExitOnError variable as I was quite confused as to what ExitOnErr was when reading the tutorial and I only realized it once I scrolled to the end and found the declaration. If this seems correct to you, can you land this patch for me as I do not have commit access? Please use "Dhruv Chawla <[e-mail]>" to commit the change.

Thanks!

PS: I am a little concerned if I updated my revision correctly: I used arc diff --update to commit my second change, and I am not sure if that is correct as phabricator is only showing the diff against the second commit...

[xgupta]

llvm/docs/tutorial/MyFirstLanguageFrontend/LangImpl04.rst

300

Fine, I agree.

llvm/docs/tutorial/MyFirstLanguageFrontend/LangImpl07.rst

582

I think the code listing is using static_cast, you should change dynamic_cast here to static_cast imo.

llvm/examples/Kaleidoscope/Chapter9/toy.cpp

802–803

Yeah, then it sounds reasonable to update it to main.

[xgupta]

In D142323#4092577, @0xdc03 wrote:

@xgupta I have updated the comment in the code listing to match the code that creates the function. I think it is better to keep the ExitOnError variable as I was quite confused as to what ExitOnErr was when reading the tutorial and I only realized it once I scrolled to the end and found the declaration. If this seems correct to you, can you land this patch for me as I do not have commit access? Please use "Dhruv Chawla <[e-mail]>" to commit the change.

Thanks!

PS: I am a little concerned if I updated my revision correctly: I used arc diff --update to commit my second change, and I am not sure if that is correct as phabricator is only showing the diff against the second commit...

I used to do arc diff to update review. It works fine.

[0xdc03]

• [Kaleidoscope]: Update code to address review comments

[0xdc03]

Okay, I have fixed the code and I think the patch is ready now. It turns out you have to specify the number of commits to push to the patch, arc doesn't pick up on it automatically. Also, in my case it didn't pick up on the fact that I already had a patch (or is it revision?) made, so I had to use the command arc diff HEAD~~ --update D142323 and everything seems fine.

Thank you so much for reviewing my first patch :>

[xgupta]

In D142323#4093787, @0xdc03 wrote:

Okay, I have fixed the code and I think the patch is ready now. It turns out you have to specify the number of commits to push to the patch, arc doesn't pick up on it automatically. Also, in my case it didn't pick up on the fact that I already had a patch (or is it revision?) made, so I had to use the command arc diff HEAD~~ --update D142323 and everything seems fine.

I use arc diff to upload and update the patch every time (I heard people saying arcanist is smart) and arc patch D142323 to review the author's patch.

Thank you so much for reviewing my first patch :>

Congratulations! Thank you very much for contributing. Hope a lot more patches will come soon :)

llvm/docs/tutorial/MyFirstLanguageFrontend/LangImpl02.rst

 Kaleidoscope, we have expressions, a prototype, and a function object.
 We'll start with expressions first:
 
 .. code-block:: c++
 
     /// ExprAST - Base class for all expression nodes.
     class ExprAST {
     public:
-      virtual ~ExprAST() {}
+      virtual ~ExprAST() = default;
     };
 
     /// NumberExprAST - Expression class for numeric literals like "1.0".
     class NumberExprAST : public ExprAST {
       double Val;
 
     public:
       NumberExprAST(double Val) : Val(Val) {}
.. code-block:: c++
     };
 
     /// BinaryExprAST - Expression class for a binary operator.
     class BinaryExprAST : public ExprAST {
       char Op;
       std::unique_ptr<ExprAST> LHS, RHS;
 
     public:
-      BinaryExprAST(char op, std::unique_ptr<ExprAST> LHS,
+      BinaryExprAST(char Op, std::unique_ptr<ExprAST> LHS,
                     std::unique_ptr<ExprAST> RHS)
-        : Op(op), LHS(std::move(LHS)), RHS(std::move(RHS)) {}
+        : Op(Op), LHS(std::move(LHS)), RHS(std::move(RHS)) {}
     };
 
     /// CallExprAST - Expression class for function calls.
     class CallExprAST : public ExprAST {
       std::string Callee;
       std::vector<std::unique_ptr<ExprAST>> Args;
 
     public:
.. code-block:: c++
     /// PrototypeAST - This class represents the "prototype" for a function,
     /// which captures its name, and its argument names (thus implicitly the number
     /// 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)) {}
+      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;

 in our parser will assume that CurTok is the current token that needs to
 be parsed.
 
 .. code-block:: c++
 
 
     /// LogError* - These are little helper functions for error handling.
     std::unique_ptr<ExprAST> LogError(const char *Str) {
-      fprintf(stderr, "LogError: %s\n", Str);
+      fprintf(stderr, "Error: %s\n", Str);
       return nullptr;
     }
     std::unique_ptr<PrototypeAST> LogErrorP(const char *Str) {
       LogError(Str);
       return nullptr;
     }
 
 The ``LogError`` routines are simple helper routines that our parser will
static std::unique_ptr<ExprAST> ParseIdentifierExpr() {
 
       if (CurTok != '(') // Simple variable ref.
         return std::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;
 

 
 .. code-block:: c++
 
     /// 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;
 
 This code gets the precedence of the current token and checks to see if

 top-level dispatch loop. There isn't much interesting here, so I'll just
 include the top-level loop. See `below <#full-code-listing>`_ for full code in the
 "Top-Level Parsing" section.
 
 .. code-block:: c++
 
     /// 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/docs/tutorial/MyFirstLanguageFrontend/LangImpl03.rst

 simplest.
 
 The second thing we want is a "LogError" method like we used for the
 parser, which will be used to report errors found during code generation
 (for example, use of an undeclared parameter):
 
 .. code-block:: c++
 
-    static LLVMContext TheContext;
-    static IRBuilder<> Builder(TheContext);
+    static std::unique_ptr<LLVMContext> TheContext;
+    static std::unique_ptr<IRBuilder<>> Builder(TheContext);
     static std::unique_ptr<Module> TheModule;
     static std::map<std::string, Value *> NamedValues;
 
     Value *LogErrorV(const char *Str) {
       LogError(Str);
       return nullptr;
     }
 

 
 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(TheContext, 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
.. code-block:: c++
     Value *BinaryExprAST::codegen() {
       Value *L = LHS->codegen();
       Value *R = RHS->codegen();
       if (!L || !R)
         return nullptr;
 
       switch (Op) {
       case '+':
-        return Builder.CreateFAdd(L, R, "addtmp");
+        return Builder->CreateFAdd(L, R, "addtmp");
       case '-':
-        return Builder.CreateFSub(L, R, "subtmp");
+        return Builder->CreateFSub(L, R, "subtmp");
       case '*':
-        return Builder.CreateFMul(L, R, "multmp");
+        return Builder->CreateFMul(L, R, "multmp");
       case '<':
-        L = Builder.CreateFCmpULT(L, R, "cmptmp");
+        L = Builder->CreateFCmpULT(L, R, "cmptmp");
         // Convert bool 0/1 to double 0.0 or 1.0
-        return Builder.CreateUIToFP(L, Type::getDoubleTy(TheContext),
+        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,
 then the right-hand side, then we compute the result of the binary
Value *CallExprAST::codegen() {
 
       std::vector<Value *> ArgsV;
       for (unsigned i = 0, e = Args.size(); i != e; ++i) {
         ArgsV.push_back(Args[i]->codegen());
         if (!ArgsV.back())
           return nullptr;
       }
 
-      return Builder.CreateCall(CalleeF, ArgsV, "calltmp");
+      return Builder->CreateCall(CalleeF, ArgsV, "calltmp");
     }
 
 Code generation for function calls is quite straightforward with LLVM. The code
 above initially does a function name lookup in the LLVM Module's symbol table.
 Recall that the LLVM Module is the container that holds the functions we are
 JIT'ing. By giving each function the same name as what the user specifies, we
 can use the LLVM symbol table to resolve function names for us.
 

 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(TheContext));
+                                 Type::getDoubleTy(*TheContext));
       FunctionType *FT =
-        FunctionType::get(Type::getDoubleTy(TheContext), Doubles, false);
+        FunctionType::get(Type::getDoubleTy(*TheContext), Doubles, false);
 
       Function *F =
         Function::Create(FT, Function::ExternalLinkage, Name, TheModule.get());
 
 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(TheContext, "entry", TheFunction);
-  Builder.SetInsertPoint(BB);
+  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;
+    NamedValues[std::string(Arg.getName())] = &Arg;
 
 Now we get to the point where the ``Builder`` is set up. The first line
 creates a new `basic block <http://en.wikipedia.org/wiki/Basic_block>`_
 (named "entry"), which is inserted into ``TheFunction``. The second line
 then tells the builder that new instructions should be inserted into the
 end of the new basic block. Basic blocks in LLVM are an important part
 of functions that define the `Control Flow
 Graph <http://en.wikipedia.org/wiki/Control_flow_graph>`_. Since we
 don't have any control flow, our functions will only contain one block
 at this point. We'll fix this in `Chapter 5 <LangImpl05.html>`_ :).
 
 Next we add the function arguments to the NamedValues map (after first clearing
 it out) so that they're accessible to ``VariableExprAST`` nodes.
 
 .. code-block:: c++
 
       if (Value *RetVal = Body->codegen()) {
         // Finish off the function.
-        Builder.CreateRet(RetVal);
+        Builder->CreateRet(RetVal);
 
         // Validate the generated code, checking for consistency.
         verifyFunction(*TheFunction);
 
         return TheFunction;
       }
 
 Once the insertion point has been set up and the NamedValues map populated,

llvm/docs/tutorial/MyFirstLanguageFrontend/LangImpl04.rst

 that, we can add a set of optimizations to run. We'll need a new
 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.
-      TheModule = std::make_unique<Module>("my cool jit", TheContext);
+      // Open a new context and module.
+      TheModule = std::make_unique<Module>("my cool jit", *TheContext);
 
       // Create a new pass manager attached to it.
       TheFPM = std::make_unique<legacy::FunctionPassManager>(TheModule.get());
 
       // Do simple "peephole" optimizations and bit-twiddling optzns.
       TheFPM->add(createInstructionCombiningPass());
       // Reassociate expressions.
       TheFPM->add(createReassociatePass());
int main() {
       return 0;
     }
 
 We also need to setup the data layout for the JIT:
 
 .. code-block:: c++
 
     void InitializeModuleAndPassManager(void) {
-      // Open a new module.
+      // Open a new context and module.
+      TheContext = std::make_unique<LLVMContext>();
       TheModule = std::make_unique<Module>("my cool jit", TheContext);
-      TheModule->setDataLayout(TheJIT->getTargetMachine().createDataLayout());
+      TheModule->setDataLayout(TheJIT->getDataLayout());
+
+      // Create a new builder for the module.
+      Builder = std::make_unique<IRBuilder<>>(*TheContext);
 
       // Create a new pass manager attached to it.
       TheFPM = std::make_unique<legacy::FunctionPassManager>(TheModule.get());
       ...
 
 The KaleidoscopeJIT class is a simple JIT built specifically for these
 tutorials, available inside the LLVM source code
-at llvm-src/examples/Kaleidoscope/include/KaleidoscopeJIT.h.
+at `llvm-src/examples/Kaleidoscope/include/KaleidoscopeJIT.h
+<https://github.com/llvm/llvm-project/blob/main/llvm/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.
+available for execution (with its memory managed by a ``ResourceTracker``); and
+``lookup`` 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:
 
 .. code-block:: c++
 
+    static ExitOnError ExitOnErr;
+    ...
     static void HandleTopLevelExpression() {
       // Evaluate a top-level expression into an anonymous function.
       if (auto FnAST = ParseTopLevelExpr()) {
         if (FnAST->codegen()) {
+          // Create a ResourceTracker to track JIT'd memory allocated to our
+          // anonymous expression -- that way we can free it after executing.
+          auto RT = TheJIT->getMainJITDylib().createResourceTracker();
 
-          // JIT the module containing the anonymous expression, keeping a handle so
-          // we can free it later.
-          auto H = TheJIT->addModule(std::move(TheModule));
+          auto TSM = ThreadSafeModule(std::move(TheModule), std::move(TheContext));
+          ExitOnErr(TheJIT->addModule(std::move(TSM), RT));
           InitializeModuleAndPassManager();
 
           // Search the JIT for the __anon_expr symbol.
-          auto ExprSymbol = TheJIT->findSymbol("__anon_expr");
+          auto ExprSymbol = ExitOnErr(TheJIT->lookup("__anon_expr"));
           assert(ExprSymbol && "Function not found");
 
           // Get the symbol's address and cast it to the right type (takes no
           // arguments, returns a double) so we can call it as a native function.
           double (*FP)() = (double (*)())(intptr_t)ExprSymbol.getAddress();
           fprintf(stderr, "Evaluated to %f\n", FP());
 
           // Delete the anonymous expression module from the JIT.
-          TheJIT->removeModule(H);
+          ExitOnErr(RT->remove());
         }
 
 If parsing and codegen succeed, the next step is to add the module containing
 the top-level expression to the JIT. We do this by calling addModule, which
-triggers code generation for all the functions in the module, and returns a
-handle that can be used to remove the module from the JIT later. Once the module
+triggers code generation for all the functions in the module, and accepts a
+``ResourceTracker`` which can be used to remove the module from the JIT later. Once the module
 has been added to the JIT it can no longer be modified, so we also open a new
 module to hold subsequent code by calling ``InitializeModuleAndPassManager()``.
 
 Once we've added the module to the JIT we need to get a pointer to the final
-generated code. We do this by calling the JIT's findSymbol method, and passing
+generated code. We do this by calling the JIT's ``lookup`` method, and passing
 the name of the top-level expression function: ``__anon_expr``. Since we just
-added this function, we assert that findSymbol returned a result.
+added this function, we assert that ``lookup`` returned a result.
 
 Next, we get the in-memory address of the ``__anon_expr`` function by calling
 ``getAddress()`` on the symbol. Recall that we compile top-level expressions
 into a self-contained LLVM function that takes no arguments and returns the
 computed double. Because the LLVM JIT compiler matches the native platform ABI,
 this means that you can just cast the result pointer to a function pointer of
 that type and call it directly. This means, there is no difference between JIT
 compiled code and native machine code that is statically linked into your

 .. code-block:: c++
 
     static void HandleDefinition() {
       if (auto FnAST = ParseDefinition()) {
         if (auto *FnIR = FnAST->codegen()) {
           fprintf(stderr, "Read function definition:");
           FnIR->print(errs());
           fprintf(stderr, "\n");
-          TheJIT->addModule(std::move(TheModule));
+          ExitOnErr(TheJIT->addModule(
+              ThreadSafeModule(std::move(TheModule), std::move(TheContext))));
           InitializeModuleAndPassManager();
         }
       } else {
         // Skip token for error recovery.
          getNextToken();
       }
     }
 
.. code-block:: c++
 
     /// putchard - putchar that takes a double and returns 0.
     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.
+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

llvm/docs/tutorial/MyFirstLanguageFrontend/LangImpl05.rst

 .. code-block:: c++
 
     Value *IfExprAST::codegen() {
       Value *CondV = Cond->codegen();
       if (!CondV)
         return nullptr;
 
       // Convert condition to a bool by comparing non-equal to 0.0.
-      CondV = Builder.CreateFCmpONE(
-          CondV, ConstantFP::get(TheContext, APFloat(0.0)), "ifcond");
+      CondV = Builder->CreateFCmpONE(
+          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();
+      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);
-      BasicBlock *ElseBB = BasicBlock::Create(TheContext, "else");
-      BasicBlock *MergeBB = BasicBlock::Create(TheContext, "ifcont");
+          BasicBlock::Create(*TheContext, "then", TheFunction);
+      BasicBlock *ElseBB = BasicBlock::Create(*TheContext, "else");
+      BasicBlock *MergeBB = BasicBlock::Create(*TheContext, "ifcont");
 
-      Builder.CreateCondBr(CondV, ThenBB, ElseBB);
+      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
 into).
 

 condition went into. Also note that it is creating a branch to the
 "then" block and the "else" block, even though the "else" block isn't
 inserted into the function yet. This is all ok: it is the standard way
 that LLVM supports forward references.
 
 .. code-block:: c++
 
       // Emit then value.
-      Builder.SetInsertPoint(ThenBB);
+      Builder->SetInsertPoint(ThenBB);
 
       Value *ThenV = Then->codegen();
       if (!ThenV)
         return nullptr;
 
-      Builder.CreateBr(MergeBB);
+      Builder->CreateBr(MergeBB);
       // Codegen of 'Then' can change the current block, update ThenBB for the PHI.
-      ThenBB = Builder.GetInsertBlock();
+      ThenBB = Builder->GetInsertBlock();
 
 After the conditional branch is inserted, we move the builder to start
 inserting into the "then" block. Strictly speaking, this call moves the
 insertion point to be at the end of the specified block. However, since
 the "then" block is empty, it also starts out by inserting at the
 beginning of the block. :)
 
 Once the insertion point is set, we recursively codegen the "then"

 expression. Because calling ``codegen()`` recursively could arbitrarily change
 the notion of the current block, we are required to get an up-to-date
 value for code that will set up the Phi node.
 
 .. code-block:: c++
 
       // Emit else block.
       TheFunction->insert(TheFunction->end(), ElseBB);
-      Builder.SetInsertPoint(ElseBB);
+      Builder->SetInsertPoint(ElseBB);
 
       Value *ElseV = Else->codegen();
       if (!ElseV)
         return nullptr;
 
-      Builder.CreateBr(MergeBB);
+      Builder->CreateBr(MergeBB);
       // codegen of 'Else' can change the current block, update ElseBB for the PHI.
-      ElseBB = Builder.GetInsertBlock();
+      ElseBB = Builder->GetInsertBlock();
 
 Code generation for the 'else' block is basically identical to codegen
 for the 'then' block. The only significant difference is the first line,
 which adds the 'else' block to the function. Recall previously that the
 'else' block was created, but not added to the function. Now that the
 'then' and 'else' blocks are emitted, we can finish up with the merge
 code:
 
 .. code-block:: c++
 
       // Emit merge block.
       TheFunction->insert(TheFunction->end(), MergeBB);
-      Builder.SetInsertPoint(MergeBB);
+      Builder->SetInsertPoint(MergeBB);
       PHINode *PN =
-        Builder.CreatePHI(Type::getDoubleTy(TheContext), 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

 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();
+      Function *TheFunction = Builder->GetInsertBlock()->getParent();
+      BasicBlock *PreheaderBB = Builder->GetInsertBlock();
       BasicBlock *LoopBB =
-          BasicBlock::Create(TheContext, "loop", TheFunction);
+          BasicBlock::Create(*TheContext, "loop", TheFunction);
 
       // Insert an explicit fall through from the current block to the LoopBB.
-      Builder.CreateBr(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);
+      Builder->SetInsertPoint(LoopBB);
 
       // Start the PHI node with an entry for Start.
-      PHINode *Variable = Builder.CreatePHI(Type::getDoubleTy(TheContext),
-                                            2, VarName.c_str());
+      PHINode *Variable = Builder->CreatePHI(Type::getDoubleTy(*TheContext),
+                                             2, VarName);
       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
 backedge, but we can't set it up yet (because it doesn't exist!).
.. 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(TheContext, APFloat(1.0));
+        StepVal = ConstantFP::get(*TheContext, APFloat(1.0));
       }
 
-      Value *NextVar = Builder.CreateFAdd(Variable, StepVal, "nextvar");
+      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 non-equal to 0.0.
-      EndCond = Builder.CreateFCmpONE(
-          EndCond, ConstantFP::get(TheContext, APFloat(0.0)), "loopcond");
+      EndCond = Builder->CreateFCmpONE(
+          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 *LoopEndBB = Builder->GetInsertBlock();
       BasicBlock *AfterBB =
-          BasicBlock::Create(TheContext, "afterloop", TheFunction);
+          BasicBlock::Create(*TheContext, "afterloop", TheFunction);
 
       // Insert the conditional branch into the end of LoopEndBB.
-      Builder.CreateCondBr(EndCond, LoopBB, AfterBB);
+      Builder->CreateCondBr(EndCond, LoopBB, AfterBB);
 
       // Any new code will be inserted in AfterBB.
-      Builder.SetInsertPoint(AfterBB);
+      Builder->SetInsertPoint(AfterBB);
 
 With the code for the body of the loop complete, we just need to finish
 up the control flow for it. This code remembers the end block (for the
 phi node), then creates the block for the loop exit ("afterloop"). Based
 on the value of the exit condition, it creates a conditional branch that
 chooses between executing the loop again and exiting the loop. Any
 future code is emitted in the "afterloop" block, so it sets the
 insertion position to it.
 
 .. code-block:: c++
 
       // Add a new entry to the PHI node for the backedge.
       Variable->addIncoming(NextVar, LoopEndBB);
 
       // Restore the unshadowed variable.
       if (OldVal)
         NamedValues[VarName] = OldVal;
       else
         NamedValues.erase(VarName);
 
       // for expr always returns 0.0.
-      return Constant::getNullValue(Type::getDoubleTy(TheContext));
+      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()``.

llvm/docs/tutorial/MyFirstLanguageFrontend/LangImpl06.rst

.. code-block:: c++
     /// which captures its argument names as well as if it is an operator.
     class PrototypeAST {
       std::string Name;
       std::vector<std::string> Args;
       bool IsOperator;
       unsigned Precedence;  // Precedence if a binary op.
 
     public:
-      PrototypeAST(const std::string &name, std::vector<std::string> Args,
+      PrototypeAST(const std::string &Name, std::vector<std::string> Args,
                    bool IsOperator = false, unsigned Prec = 0)
-      : Name(name), Args(std::move(Args)), IsOperator(IsOperator),
+      : 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; }
 
.. code-block:: c++
     Value *BinaryExprAST::codegen() {
       Value *L = LHS->codegen();
       Value *R = RHS->codegen();
       if (!L || !R)
         return nullptr;
 
       switch (Op) {
       case '+':
-        return Builder.CreateFAdd(L, R, "addtmp");
+        return Builder->CreateFAdd(L, R, "addtmp");
       case '-':
-        return Builder.CreateFSub(L, R, "subtmp");
+        return Builder->CreateFSub(L, R, "subtmp");
       case '*':
-        return Builder.CreateFMul(L, R, "multmp");
+        return Builder->CreateFMul(L, R, "multmp");
       case '<':
-        L = Builder.CreateFCmpULT(L, R, "cmptmp");
+        L = Builder->CreateFCmpULT(L, R, "cmptmp");
         // Convert bool 0/1 to double 0.0 or 1.0
-        return Builder.CreateUIToFP(L, Type::getDoubleTy(TheContext),
+        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 = getFunction(std::string("binary") + Op);
       assert(F && "binary operator not found!");
 
       Value *Ops[2] = { L, R };
-      return Builder.CreateCall(F, Ops, "binop");
+      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.
 
Function *FunctionAST::codegen() {
       if (!TheFunction)
         return nullptr;
 
       // If this is an operator, install it.
       if (P.isBinaryOp())
         BinopPrecedence[P.getOperatorName()] = P.getBinaryPrecedence();
 
       // Create a new basic block to start insertion into.
-      BasicBlock *BB = BasicBlock::Create(TheContext, "entry", TheFunction);
+      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".
 
Value *UnaryExprAST::codegen() {
       Value *OperandV = Operand->codegen();
       if (!OperandV)
         return nullptr;
 
       Function *F = getFunction(std::string("unary") + Opcode);
       if (!F)
         return LogErrorV("Unknown unary operator");
 
-      return Builder.CreateCall(F, OperandV, "unop");
+      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
 predefined operators.
 
 Kicking the Tires
 =================

llvm/docs/tutorial/MyFirstLanguageFrontend/LangImpl07.rst

 
 At this point in Kaleidoscope's development, it only supports variables
 for two things: incoming arguments to functions and the induction
 variable of 'for' loops. For consistency, we'll allow mutation of these
 variables in addition to other user-defined variables. This means that
 these will both need memory locations.
 
 To start our transformation of Kaleidoscope, we'll change the
-NamedValues map so that it maps to AllocaInst\* instead of Value\*. Once
+``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 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(TheContext), 0,
-                               VarName.c_str());
+      return TmpB.CreateAlloca(Type::getDoubleTy(*TheContext), nullptr,
+                               VarName);
     }
 
 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 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.
-      Value *V = NamedValues[Name];
-      if (!V)
+      AllocaInst *A = NamedValues[Name];
+      if (!A)
         return LogErrorV("Unknown variable name");
 
       // Load the value.
-      return Builder.CreateLoad(V, Name.c_str());
+      return Builder->CreateLoad(A->getAllocatedType(), A, Name.c_str());
     }
 
 As you can see, this is pretty straightforward. Now we need to update
 the things that define the variables to set up the alloca. We'll start
 with ``ForExprAST::codegen()`` (see the `full code listing <#id1>`_ for
 the unabridged code):
 
 .. code-block:: c++
 
-      Function *TheFunction = Builder.GetInsertBlock()->getParent();
+      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);
+      Builder->CreateStore(StartVal, Alloca);
       ...
 
       // Compute the end condition.
       Value *EndCond = End->codegen();
       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);
-      Value *NextVar = Builder.CreateFAdd(CurVar, StepVal, "nextvar");
-      Builder.CreateStore(NextVar, Alloca);
+      Value *CurVar = Builder->CreateLoad(Alloca->getAllocatedType(), Alloca,
+                                          VarName.c_str());
+      Value *NextVar = Builder->CreateFAdd(CurVar, StepVal, "nextvar");
+      Builder->CreateStore(NextVar, Alloca);
       ...
 
 This code is virtually identical to the code `before we allowed mutable
 variables <LangImpl05.html#code-generation-for-the-for-loop>`_. The big difference is that we
 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++
 
     Function *FunctionAST::codegen() {
       ...
-      Builder.SetInsertPoint(BB);
+      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(TheFunction, Arg.getName());
 
         // Store the initial value into the alloca.
-        Builder.CreateStore(&Arg, Alloca);
+        Builder->CreateStore(&Arg, Alloca);
 
         // Add arguments to variable symbol table.
-        NamedValues[Arg.getName()] = Alloca;
+        NamedValues[std::string(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()``

 takes care of all the parsing and AST generation. We just need to
 implement codegen for the assignment operator. This looks like:
 
 .. code-block:: c++
 
     Value *BinaryExprAST::codegen() {
       // Special case '=' because we don't want to emit the LHS as an expression.
       if (Op == '=') {
-        // Assignment requires the LHS to be an identifier.
-        VariableExprAST *LHSE = dynamic_cast<VariableExprAST*>(LHS.get());
+        // This assume we're building without RTTI because LLVM builds that way by
+        // default. If you build LLVM with RTTI this can be changed to a
+        // dynamic_cast for automatic error checking.
+        VariableExprAST *LHSE = static_cast<VariableExprAST*>(LHS.get());
         if (!LHSE)
           return LogErrorV("destination of '=' must be a variable");
 
 Unlike the rest of the binary operators, our assignment operator doesn't
 follow the "emit LHS, emit RHS, do computation" model. As such, it is
 handled as a special case before the other binary operators are handled.
 The other strange thing is that it requires the LHS to be a variable. It
 is invalid to have "(x+1) = expr" - only things like "x = expr" are
 allowed.
 
 .. code-block:: c++
 
         // Codegen the RHS.
         Value *Val = RHS->codegen();
         if (!Val)
           return nullptr;
 
         // Look up the name.
         Value *Variable = NamedValues[LHSE->getName()];
         if (!Variable)
           return LogErrorV("Unknown variable name");
 
-        Builder.CreateStore(Val, Variable);
+        Builder->CreateStore(Val, Variable);
         return Val;
       }
       ...
 
 Once we have the variable, codegen'ing the assignment is
 straightforward: we emit the RHS of the assignment, create a store, and
 return the computed value. Returning a value allows for chained
 assignments like "X = (Y = Z)".
static std::unique_ptr<ExprAST> ParseVarExpr() {
       if (CurTok != tok_identifier)
         return LogError("expected identifier after var");
 
 The first part of this code parses the list of identifier/expr pairs
 into the local ``VarNames`` vector.
 
 .. code-block:: c++
 
-      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 '='.
 

 Now that we can parse and represent the code, we need to support
 emission of LLVM IR for it. This code starts out with:
 
 .. code-block:: c++
 
     Value *VarExprAST::codegen() {
       std::vector<AllocaInst *> OldBindings;
 
-      Function *TheFunction = Builder.GetInsertBlock()->getParent();
+      Function *TheFunction = Builder->GetInsertBlock()->getParent();
 
       // Register all variables and emit their initializer.
       for (unsigned i = 0, e = VarNames.size(); i != e; ++i) {
         const std::string &VarName = VarNames[i].first;
         ExprAST *Init = VarNames[i].second.get();
 
 Basically it loops over all the variables, installing them one at a
 time. For each variable we put into the symbol table, we remember the
 previous value that we replace in OldBindings.
 
 .. code-block:: c++
 
         // Emit the initializer before adding the variable to scope, this prevents
         // the initializer from referencing the variable itself, and permits stuff
         // like this:
         //  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(TheContext, APFloat(0.0));
+          InitVal = ConstantFP::get(*TheContext, APFloat(0.0));
         }
 
         AllocaInst *Alloca = CreateEntryBlockAlloca(TheFunction, VarName);
-        Builder.CreateStore(InitVal, Alloca);
+        Builder->CreateStore(InitVal, Alloca);
 
         // Remember the old variable binding so that we can restore the binding when
         // we unrecurse.
         OldBindings.push_back(NamedValues[VarName]);
 
         // Remember this binding.
         NamedValues[VarName] = Alloca;
       }

llvm/docs/tutorial/MyFirstLanguageFrontend/LangImpl08.rst

 features, options or relocation model.
 
 .. code-block:: c++
 
   auto CPU = "generic";
   auto Features = "";
 
   TargetOptions opt;
-  auto RM = Optional<Reloc::Model>();
+  auto RM = std::optional<Reloc::Model>();
   auto TargetMachine = Target->createTargetMachine(TargetTriple, CPU, Features, opt, RM);
 
 
 Configuring the Module
 ======================
 
 We're now ready to configure our module, to specify the target and
 data layout. This isn't strictly necessary, but the `frontend

llvm/docs/tutorial/MyFirstLanguageFrontend/LangImpl09.rst

 
 Then we're going to remove the command line code wherever it exists:
 
 .. code-block:: udiff
 
   @@ -1129,7 +1129,6 @@ static void HandleTopLevelExpression() {
    /// top ::= definition | external | expression | ';'
    static void MainLoop() {
-     while (1) {
+     while (true) {
   -    fprintf(stderr, "ready> ");
        switch (CurTok) {
        case tok_eof:
          return;
   @@ -1184,7 +1183,6 @@ int main() {
      BinopPrecedence['*'] = 40; // highest.
 
      // Prime the first token.
.. code-block:: udiff
   -      // JIT the function, returning a function pointer.
   -      void *FPtr = TheExecutionEngine->getPointerToFunction(FnIR);
   -
   -      // Cast it to the right type (takes no arguments, returns a double) so we
   -      // can call it as a native function.
   -      double (*FP)() = (double (*)())(intptr_t)FPtr;
   -      // Ignore the return value for this.
   -      (void)FP;
-  +    if (!F->codegen()) {
+  +    if (!FnAST->codegen()) {
   +      fprintf(stderr, "Error generating code for top level expr");
        }
      } else {
        // Skip token for error recovery.
   @@ -1439,11 +1459,11 @@ int main() {
      // target lays out data structures.
      TheModule->setDataLayout(TheExecutionEngine->getDataLayout());
      OurFPM.add(new DataLayoutPass());

 
 Next we're going to create a small container to cache some of our frequent
 data. The first will be our compile unit, but we'll also write a bit of
 code for our one type since we won't have to worry about multiple typed
 expressions:
 
 .. code-block:: c++
 
-  static DIBuilder *DBuilder;
+  static std::unique_ptr<DIBuilder> DBuilder;
 
   struct DebugInfo {
     DICompileUnit *TheCU;
     DIType *DblTy;
 
     DIType *getDoubleTy();
   } KSDbgInfo;
 
   DIType *DebugInfo::getDoubleTy() {
     if (DblTy)
       return DblTy;
 
     DblTy = DBuilder->createBasicType("double", 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);
+  DBuilder = std::make_unique<DIBuilder>(*TheModule);
 
   KSDbgInfo.TheCU = DBuilder->createCompileUnit(
       dwarf::DW_LANG_C, DBuilder->createFile("fib.ks", "."),
-      "Kaleidoscope Compiler", 0, "", 0);
+      "Kaleidoscope Compiler", false, "", 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
 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
.. code-block:: c++
   DBuilder->finalize();
 
 before you dump out the module.
 
 Functions
 =========
 
 Now that we have our ``Compile Unit`` and our source locations, we can add
-function definitions to the debug info. So in ``PrototypeAST::codegen()`` we
+function definitions to the debug info. So in ``FunctionAST::codegen()`` we
 add a few lines of code to describe a context for our subprogram, in this
 case the "File", and the actual definition of the function itself.
 
 So the context:
 
 .. code-block:: c++
 
-  DIFile *Unit = DBuilder->createFile(KSDbgInfo.TheCU.getFilename(),
-                                      KSDbgInfo.TheCU.getDirectory());
+  DIFile *Unit = DBuilder->createFile(KSDbgInfo.TheCU->getFilename(),
+                                      KSDbgInfo.TheCU->getDirectory());
 
 giving us an DIFile and asking the ``Compile Unit`` we created above for the
 directory and filename where we are currently. Then, for now, we use some
 source locations of 0 (since our AST doesn't currently have source location
 information) and construct our function definition:
 
 .. code-block:: c++
 

 
 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) {
+    if (!AST)
+      return Builder->SetCurrentDebugLocation(DebugLoc());
     DIScope *Scope;
     if (LexicalBlocks.empty())
       Scope = TheCU;
     else
       Scope = LexicalBlocks.back();
-    Builder.SetCurrentDebugLocation(
+    Builder->SetCurrentDebugLocation(
         DILocation::get(Scope->getContext(), AST->getLine(), AST->getCol(), Scope));
   }
 
 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:
+To represent this we create a stack of scopes in ``DebugInfo``:
 
 .. code-block:: c++
 
    std::vector<DIScope *> LexicalBlocks;
 
 and push the scope (function) to the top of the stack when we start
 generating the code for each function:
 
for (auto &Arg : TheFunction->args()) {
 
       // 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(),
                               DILocation::get(SP->getContext(), LineNo, 0, SP),
-                              Builder.GetInsertBlock());
+                              Builder->GetInsertBlock());
 
       // Store the initial value into the alloca.
-      Builder.CreateStore(&Arg, Alloca);
+      Builder->CreateStore(&Arg, Alloca);
 
       // Add arguments to variable symbol table.
-      NamedValues[Arg.getName()] = Alloca;
+      NamedValues[std::string(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. 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

llvm/examples/Kaleidoscope/Chapter9/toy.cpp

if (auto E = ParseExpression())
     return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
   return nullptr;
 }
 
 /// toplevelexpr ::= expression
 static std::unique_ptr<FunctionAST> ParseTopLevelExpr() {
   SourceLocation FnLoc = CurLoc;
   if (auto E = ParseExpression()) {
-    // Make an anonymous proto.
-    auto Proto = std::make_unique<PrototypeAST>(FnLoc, "__anon_expr",
+    // Make the top-level expression be our "main" function.
+    auto Proto = std::make_unique<PrototypeAST>(FnLoc, "main",
                                                  std::vector<std::string>());
     return std::make_unique<FunctionAST>(std::move(Proto), std::move(E));
   }
   return nullptr;
 }
 
 /// external ::= 'extern' prototype
 static std::unique_ptr<PrototypeAST> ParseExtern() {