Nuke getGlobalContext() from LLVM (but the C API)

[mehdi_amini]

Summary

At the same time, fixes InstructionsTest::CastInst unittest: yes
you can leave the IR in an invalid state and exit when you don't
destroy the context (like the global one), no longer now.

[mehdi_amini]

Add an entry in the release notes

[deadalnix]

Red diffs are the best diffs.

lib/Target/Target.cpp

16

This tends to be a compile time disaster. Can you add a comment that it is for the global context and that we want to kill it eventually ?

Maybe you could declare the function locally instead of importing the whole Core.h thing ?

[mehdi_amini]

Fwd-declare instead of including "llvm-c/Core.h"

[mehdi_amini]

Add missing extern "C" in fwd-decl.

[• rafael]

This looks awesome, but maybe split this in two? One changes all uses and
another does the removal just in case we find something in another project?

[echristo]

... This patch is hilarious.

OK.

-eric

[mehdi_amini]

r266379 for updating all the uses.
r266380 for nuking the API.

[chapuni]

tools/lli/lli.cpp

388

I guess it might cause undefined behavior. See do_shutdown().
It seems EE depends on LLVMContext and EE is alive after Context has been destroyed.

Appeased in r266441, or we should do;

1. Make destructors in EE to be unaware of LLVMContext.
2. Don't use return in main(), but exit().
3. Make lli not to use do_shutdown().

[mehdi_amini]

Tried to clean it in r266652 by removing global variables in lli.

Thanks for the notification!

[mehdi_amini]

If anyone comes here looking for a fix on the client side, there is a very easy solution:

LLVMContext &getMyLLVMGlobalContext() {
  static LLVMContext MyGlobalContext;
  return MyGlobalContext;
}

I encourage people to avoid global mutable state in general though :)

bindings/ocaml/llvm/llvm.mli

 (** [create_context ()] creates a context for storing the "global" state in
     LLVM. See the constructor [llvm::LLVMContext]. *)
 val create_context : unit -> llcontext
 
 (** [destroy_context ()] destroys a context. See the destructor
     [llvm::LLVMContext::~LLVMContext]. *)
 val dispose_context : llcontext -> unit
 
-(** See the function [llvm::getGlobalContext]. *)
+(** See the function [LLVMGetGlobalContext]. *)
 val global_context : unit -> llcontext
 
 (** [mdkind_id context name] returns the MDKind ID that corresponds to the
     name [name] in the context [context].  See the function
     [llvm::LLVMContext::getMDKindID]. *)
 val mdkind_id : llcontext -> string -> llmdkind
 
 

docs/ProgrammersManual.rst

 
 In practice, very few places in the API require the explicit specification of a
 ``LLVMContext``, other than the ``Type`` creation/lookup APIs.  Because every
 ``Type`` carries a reference to its owning context, most other entities can
 determine what context they belong to by looking at their own ``Type``.  If you
 are adding new entities to LLVM IR, please try to maintain this interface
 design.
 
-For clients that do *not* require the benefits of isolation, LLVM provides a
-convenience API ``getGlobalContext()``.  This returns a global, lazily
-initialized ``LLVMContext`` that may be used in situations where isolation is
-not a concern.
-
 .. _jitthreading:
 
 Threads and the JIT
 -------------------
 
 LLVM's "eager" JIT compiler is safe to use in threaded programs.  Multiple
 threads can call ``ExecutionEngine::getPointerToFunction()`` or
 ``ExecutionEngine::runFunction()`` concurrently, and multiple threads can run

docs/ReleaseNotes.rst

 
 Non-comprehensive list of changes in this release
 =================================================
 * The LLVMContext gains a new runtime check (see
   LLVMContext::discardValueNames()) that can be set to discard Value names
   (other than GlobalValue). This is intended to be used in release builds by
   clients that are interested in saving CPU/memory as much as possible.
 
+* There is no longer a "global context" available in LLVM, except for the C API.
+
 * .. note about autoconf build having been removed.
 
 * .. note about C API functions LLVMParseBitcode,
    LLVMParseBitcodeInContext, LLVMGetBitcodeModuleInContext and
    LLVMGetBitcodeModule having been removed. LLVMGetTargetMachineData has been
    removed (use LLVMGetDataLayout instead).
 
 * The C API function LLVMLinkModules has been removed.

docs/tutorial/LangImpl3.rst

 
 The second thing we want is an "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 std::unique_ptr<Module> *TheModule;
-    static IRBuilder<> Builder(getGlobalContext());
+    static IRBuilder<> Builder(LLVMContext);
     static std::map<std::string, Value*> NamedValues;
 
     Value *LogErrorV(const char *Str) {
       LogError(Str);
       return nullptr;
     }
 
 The static variables will be used during code generation. ``TheModule``

 
 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(getGlobalContext(), APFloat(Val));
+      return ConstantFP::get(LLVMContext, 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(getGlobalContext()),
+        return Builder.CreateUIToFP(L, Type::getDoubleTy(LLVMContext),
                                     "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(getGlobalContext()));
+                                 Type::getDoubleTy(LLVMContext));
       FunctionType *FT =
-        FunctionType::get(Type::getDoubleTy(getGlobalContext()), Doubles, false);
+        FunctionType::get(Type::getDoubleTy(LLVMContext), 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(getGlobalContext(), "entry", TheFunction);
+  BasicBlock *BB = BasicBlock::Create(LLVMContext, "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

docs/tutorial/LangImpl4.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.
-      TheModule = llvm::make_unique<Module>("my cool jit", getGlobalContext());
+      Context LLVMContext;
+      TheModule = llvm::make_unique<Module>("my cool jit", LLVMContext);
       TheModule->setDataLayout(TheJIT->getTargetMachine().createDataLayout());
 
       // 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.

docs/tutorial/LangImpl5.rst

.. 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.
       CondV = Builder.CreateFCmpONE(
-          CondV, ConstantFP::get(getGlobalContext(), APFloat(0.0)), "ifcond");
+          CondV, ConstantFP::get(LLVMContext, 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(getGlobalContext(), "then", TheFunction);
-      BasicBlock *ElseBB = BasicBlock::Create(getGlobalContext(), "else");
-      BasicBlock *MergeBB = BasicBlock::Create(getGlobalContext(), "ifcont");
+          BasicBlock::Create(LLVMContext, "then", TheFunction);
+      BasicBlock *ElseBB = BasicBlock::Create(LLVMContext, "else");
+      BasicBlock *MergeBB = BasicBlock::Create(LLVMContext, "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(getGlobalContext()), 2, "iftmp");
+        Builder.CreatePHI(Type::getDoubleTy(LLVMContext), 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

 
 .. 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(getGlobalContext(), "loop", TheFunction);
+          BasicBlock::Create(LLVMContext, "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(getGlobalContext()),
+      PHINode *Variable = Builder.CreatePHI(Type::getDoubleTy(LLVMContext),
                                             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(getGlobalContext(), APFloat(1.0));
+        StepVal = ConstantFP::get(LLVMContext, 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.
       EndCond = Builder.CreateFCmpONE(
-          EndCond, ConstantFP::get(getGlobalContext(), APFloat(0.0)), "loopcond");
+          EndCond, ConstantFP::get(LLVMContext, 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(getGlobalContext(), "afterloop", TheFunction);
+          BasicBlock::Create(LLVMContext, "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(getGlobalContext()));
+      return Constant::getNullValue(Type::getDoubleTy(LLVMContext));
     }
 
 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()``.

docs/tutorial/LangImpl6.rst

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(getGlobalContext()),
+        return Builder.CreateUIToFP(L, Type::getDoubleTy(LLVMContext),
                                     "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 *FunctionAST::codegen() {
       if (!TheFunction)
         return nullptr;
 
       // If this is an operator, install it.
       if (Proto->isBinaryOp())
         BinopPrecedence[Proto->getOperatorName()] = Proto->getBinaryPrecedence();
 
       // Create a new basic block to start insertion into.
-      BasicBlock *BB = BasicBlock::Create(getGlobalContext(), "entry", TheFunction);
+      BasicBlock *BB = BasicBlock::Create(LLVMContext, "entry", TheFunction);
       Builder.SetInsertPoint(BB);
 
       if (Value *RetVal = Body->codegen()) {
         ...
 
 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

docs/tutorial/LangImpl7.rst

 .. 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(getGlobalContext()), 0,
+      return TmpB.CreateAlloca(Type::getDoubleTy(LLVMContext), 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.
 
.. 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(getGlobalContext(), APFloat(0.0));
+          InitVal = ConstantFP::get(LLVMContext, 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]);

examples/BrainF/BrainFDriver.cpp

void addMainFunction(Module *mod) {
   //ret i32 0
   ReturnInst::Create(mod->getContext(),
                      ConstantInt::get(mod->getContext(), APInt(32, 0)), bb);
 }
 
 int main(int argc, char **argv) {
   cl::ParseCommandLineOptions(argc, argv, " BrainF compiler\n");
 
-  LLVMContext &Context = getGlobalContext();
+  LLVMContext Context;
 
   if (InputFilename == "") {
     errs() << "Error: You must specify the filename of the program to "
     "be compiled.  Use --help to see the options.\n";
     abort();
   }
 
   //Get the output stream

examples/ExceptionDemo/ExceptionDemo.cpp

if (argc == 1) {
     return(0);
   }
 
   // If not set, exception handling will not be turned on
   llvm::TargetOptions Opts;
 
   llvm::InitializeNativeTarget();
   llvm::InitializeNativeTargetAsmPrinter();
-  llvm::LLVMContext &context = llvm::getGlobalContext();
-  llvm::IRBuilder<> theBuilder(context);
+  llvm::LLVMContext Context;
+  llvm::IRBuilder<> theBuilder(Context);
 
   // Make the module, which holds all the code.
   std::unique_ptr<llvm::Module> Owner =
-      llvm::make_unique<llvm::Module>("my cool jit", context);
+      llvm::make_unique<llvm::Module>("my cool jit", Context);
   llvm::Module *module = Owner.get();
 
   std::unique_ptr<llvm::RTDyldMemoryManager> MemMgr(new llvm::SectionMemoryManager());
 
   // Build engine with JIT
   llvm::EngineBuilder factory(std::move(Owner));
   factory.setEngineKind(llvm::EngineKind::JIT);
   factory.setTargetOptions(Opts);

examples/Kaleidoscope/Chapter3/toy.cpp

static std::unique_ptr<PrototypeAST> ParseExtern() {
   return ParsePrototype();
 }
 
 //===----------------------------------------------------------------------===//
 // Code Generation
 //===----------------------------------------------------------------------===//
 
 static std::unique_ptr<Module> TheModule;
-static IRBuilder<> Builder(getGlobalContext());
+static LLVMContext TheContext;
+static IRBuilder<> Builder(TheContext);
 static std::map<std::string, Value *> NamedValues;
 
 Value *LogErrorV(const char *Str) {
   LogError(Str);
   return nullptr;
 }
 
 Value *NumberExprAST::codegen() {
-  return ConstantFP::get(getGlobalContext(), APFloat(Val));
+  return ConstantFP::get(TheContext, APFloat(Val));
 }
 
 Value *VariableExprAST::codegen() {
   // Look this variable up in the function.
   Value *V = NamedValues[Name];
   if (!V)
     return LogErrorV("Unknown variable name");
   return V;
case '+':
     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(getGlobalContext()),
+    return Builder.CreateUIToFP(L, Type::getDoubleTy(TheContext),
                                 "booltmp");
   default:
     return LogErrorV("invalid binary operator");
   }
 }
 
 Value *CallExprAST::codegen() {
   // Look up the name in the global module table.
Value *CallExprAST::codegen() {
   }
 
   return Builder.CreateCall(CalleeF, ArgsV, "calltmp");
 }
 
 Function *PrototypeAST::codegen() {
   // Make the function type:  double(double,double) etc.
   std::vector<Type *> Doubles(Args.size(),
-                              Type::getDoubleTy(getGlobalContext()));
+                              Type::getDoubleTy(TheContext));
   FunctionType *FT =
-      FunctionType::get(Type::getDoubleTy(getGlobalContext()), Doubles, false);
+      FunctionType::get(Type::getDoubleTy(TheContext), Doubles, false);
 
   Function *F =
       Function::Create(FT, Function::ExternalLinkage, Name, TheModule.get());
 
   // Set names for all arguments.
   unsigned Idx = 0;
   for (auto &Arg : F->args())
     Arg.setName(Args[Idx++]);
 
   return F;
 }
 
 Function *FunctionAST::codegen() {
   // First, check for an existing function from a previous 'extern' declaration.
   Function *TheFunction = TheModule->getFunction(Proto->getName());
 
   if (!TheFunction)
     TheFunction = Proto->codegen();
 
   if (!TheFunction)
     return nullptr;
 
   // Create a new basic block to start insertion into.
-  BasicBlock *BB = BasicBlock::Create(getGlobalContext(), "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;
 
   if (Value *RetVal = Body->codegen()) {
int main() {
   BinopPrecedence['-'] = 20;
   BinopPrecedence['*'] = 40; // highest.
 
   // Prime the first token.
   fprintf(stderr, "ready> ");
   getNextToken();
 
   // Make the module, which holds all the code.
-  TheModule = llvm::make_unique<Module>("my cool jit", getGlobalContext());
+  TheModule = llvm::make_unique<Module>("my cool jit", TheContext);
 
   // Run the main "interpreter loop" now.
   MainLoop();
 
   // Print out all of the generated code.
   TheModule->dump();
 
   return 0;
 }

examples/Kaleidoscope/Chapter4/toy.cpp

static std::unique_ptr<PrototypeAST> ParseExtern() {
   return ParsePrototype();
 }
 
 //===----------------------------------------------------------------------===//
 // Code Generation
 //===----------------------------------------------------------------------===//
 
 static std::unique_ptr<Module> TheModule;
-static IRBuilder<> Builder(getGlobalContext());
+static LLVMContext TheContext;
+static IRBuilder<> Builder(TheContext);
 static std::map<std::string, Value *> NamedValues;
 static std::unique_ptr<legacy::FunctionPassManager> TheFPM;
 static std::unique_ptr<KaleidoscopeJIT> TheJIT;
 static std::map<std::string, std::unique_ptr<PrototypeAST>> FunctionProtos;
 
 Value *LogErrorV(const char *Str) {
   LogError(Str);
   return nullptr;
Function *getFunction(std::string Name) {
   if (FI != FunctionProtos.end())
     return FI->second->codegen();
 
   // If no existing prototype exists, return null.
   return nullptr;
 }
 
 Value *NumberExprAST::codegen() {
-  return ConstantFP::get(getGlobalContext(), APFloat(Val));
+  return ConstantFP::get(TheContext, APFloat(Val));
 }
 
 Value *VariableExprAST::codegen() {
   // Look this variable up in the function.
   Value *V = NamedValues[Name];
   if (!V)
     return LogErrorV("Unknown variable name");
   return V;
case '+':
     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(getGlobalContext()),
+    return Builder.CreateUIToFP(L, Type::getDoubleTy(TheContext),
                                 "booltmp");
   default:
     return LogErrorV("invalid binary operator");
   }
 }
 
 Value *CallExprAST::codegen() {
   // Look up the name in the global module table.
Value *CallExprAST::codegen() {
   }
 
   return Builder.CreateCall(CalleeF, ArgsV, "calltmp");
 }
 
 Function *PrototypeAST::codegen() {
   // Make the function type:  double(double,double) etc.
   std::vector<Type *> Doubles(Args.size(),
-                              Type::getDoubleTy(getGlobalContext()));
+                              Type::getDoubleTy(TheContext));
   FunctionType *FT =
-      FunctionType::get(Type::getDoubleTy(getGlobalContext()), Doubles, false);
+      FunctionType::get(Type::getDoubleTy(TheContext), Doubles, false);
 
   Function *F =
       Function::Create(FT, Function::ExternalLinkage, Name, TheModule.get());
 
   // Set names for all arguments.
   unsigned Idx = 0;
   for (auto &Arg : F->args())
     Arg.setName(Args[Idx++]);
 
   return F;
 }
 
 Function *FunctionAST::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;
 
   // Create a new basic block to start insertion into.
-  BasicBlock *BB = BasicBlock::Create(getGlobalContext(), "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;
 
   if (Value *RetVal = Body->codegen()) {

 }
 
 //===----------------------------------------------------------------------===//
 // Top-Level parsing and JIT Driver
 //===----------------------------------------------------------------------===//
 
 static void InitializeModuleAndPassManager() {
   // Open a new module.
-  TheModule = llvm::make_unique<Module>("my cool jit", getGlobalContext());
+  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());
 
   // Do simple "peephole" optimizations and bit-twiddling optzns.
   TheFPM->add(createInstructionCombiningPass());
   // Reassociate expressions.

examples/Kaleidoscope/Chapter5/toy.cpp

static std::unique_ptr<PrototypeAST> ParseExtern() {
   return ParsePrototype();
 }
 
 //===----------------------------------------------------------------------===//
 // Code Generation
 //===----------------------------------------------------------------------===//
 
 static std::unique_ptr<Module> TheModule;
-static IRBuilder<> Builder(getGlobalContext());
+static LLVMContext TheContext;
+static IRBuilder<> Builder(TheContext);
 static std::map<std::string, Value *> NamedValues;
 static std::unique_ptr<legacy::FunctionPassManager> TheFPM;
 static std::unique_ptr<KaleidoscopeJIT> TheJIT;
 static std::map<std::string, std::unique_ptr<PrototypeAST>> FunctionProtos;
 
 Value *LogErrorV(const char *Str) {
   LogError(Str);
   return nullptr;
Function *getFunction(std::string Name) {
   if (FI != FunctionProtos.end())
     return FI->second->codegen();
 
   // If no existing prototype exists, return null.
   return nullptr;
 }
 
 Value *NumberExprAST::codegen() {
-  return ConstantFP::get(getGlobalContext(), APFloat(Val));
+  return ConstantFP::get(TheContext, APFloat(Val));
 }
 
 Value *VariableExprAST::codegen() {
   // Look this variable up in the function.
   Value *V = NamedValues[Name];
   if (!V)
     return LogErrorV("Unknown variable name");
   return V;
case '+':
     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(getGlobalContext()),
+    return Builder.CreateUIToFP(L, Type::getDoubleTy(TheContext),
                                 "booltmp");
   default:
     return LogErrorV("invalid binary operator");
   }
 }
 
 Value *CallExprAST::codegen() {
   // Look up the name in the global module table.

 
 Value *IfExprAST::codegen() {
   Value *CondV = Cond->codegen();
   if (!CondV)
     return nullptr;
 
   // Convert condition to a bool by comparing equal to 0.0.
   CondV = Builder.CreateFCmpONE(
-      CondV, ConstantFP::get(getGlobalContext(), APFloat(0.0)), "ifcond");
+      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(getGlobalContext(), "then", TheFunction);
-  BasicBlock *ElseBB = BasicBlock::Create(getGlobalContext(), "else");
-  BasicBlock *MergeBB = BasicBlock::Create(getGlobalContext(), "ifcont");
+      BasicBlock::Create(TheContext, "then", TheFunction);
+  BasicBlock *ElseBB = BasicBlock::Create(TheContext, "else");
+  BasicBlock *MergeBB = BasicBlock::Create(TheContext, "ifcont");
 
   Builder.CreateCondBr(CondV, ThenBB, ElseBB);
 
   // Emit then value.
   Builder.SetInsertPoint(ThenBB);
 
   Value *ThenV = Then->codegen();
   if (!ThenV)
Value *IfExprAST::codegen() {
   Builder.CreateBr(MergeBB);
   // Codegen of 'Else' can change the current block, update ElseBB for the PHI.
   ElseBB = Builder.GetInsertBlock();
 
   // Emit merge block.
   TheFunction->getBasicBlockList().push_back(MergeBB);
   Builder.SetInsertPoint(MergeBB);
   PHINode *PN =
-      Builder.CreatePHI(Type::getDoubleTy(getGlobalContext()), 2, "iftmp");
+      Builder.CreatePHI(Type::getDoubleTy(TheContext), 2, "iftmp");
 
   PN->addIncoming(ThenV, ThenBB);
   PN->addIncoming(ElseV, ElseBB);
   return PN;
 }
 
 // Output for-loop as:
 //   ...
Value *ForExprAST::codegen() {
   if (!StartVal)
     return nullptr;
 
   // 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(getGlobalContext(), "loop", TheFunction);
+      BasicBlock::Create(TheContext, "loop", TheFunction);
 
   // Insert an explicit fall through from the current block to the LoopBB.
   Builder.CreateBr(LoopBB);
 
   // Start insertion in LoopBB.
   Builder.SetInsertPoint(LoopBB);
 
   // Start the PHI node with an entry for Start.
-  PHINode *Variable = Builder.CreatePHI(Type::getDoubleTy(getGlobalContext()),
+  PHINode *Variable = Builder.CreatePHI(Type::getDoubleTy(TheContext),
                                         2, VarName.c_str());
   Variable->addIncoming(StartVal, PreheaderBB);
 
   // Within the loop, the variable is defined equal to the PHI node.  If it
   // shadows an existing variable, we have to restore it, so save it now.
   Value *OldVal = NamedValues[VarName];
   NamedValues[VarName] = Variable;
 
   // Emit the body of the loop.  This, like any other expr, can change the
   // current BB.  Note that we ignore the value computed by the body, but don't
   // allow an error.
   if (!Body->codegen())
     return nullptr;
 
   // 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(getGlobalContext(), APFloat(1.0));
+    StepVal = ConstantFP::get(TheContext, APFloat(1.0));
   }
 
   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.
   EndCond = Builder.CreateFCmpONE(
-      EndCond, ConstantFP::get(getGlobalContext(), APFloat(0.0)), "loopcond");
+      EndCond, ConstantFP::get(TheContext, APFloat(0.0)), "loopcond");
 
   // Create the "after loop" block and insert it.
   BasicBlock *LoopEndBB = Builder.GetInsertBlock();
   BasicBlock *AfterBB =
-      BasicBlock::Create(getGlobalContext(), "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);
 
   // 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(getGlobalContext()));
+  return Constant::getNullValue(Type::getDoubleTy(TheContext));
 }
 
 Function *PrototypeAST::codegen() {
   // Make the function type:  double(double,double) etc.
   std::vector<Type *> Doubles(Args.size(),
-                              Type::getDoubleTy(getGlobalContext()));
+                              Type::getDoubleTy(TheContext));
   FunctionType *FT =
-      FunctionType::get(Type::getDoubleTy(getGlobalContext()), Doubles, false);
+      FunctionType::get(Type::getDoubleTy(TheContext), Doubles, false);
 
   Function *F =
       Function::Create(FT, Function::ExternalLinkage, Name, TheModule.get());
 
   // Set names for all arguments.
   unsigned Idx = 0;
   for (auto &Arg : F->args())
     Arg.setName(Args[Idx++]);
 
   return F;
 }
 
 Function *FunctionAST::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;
 
   // Create a new basic block to start insertion into.
-  BasicBlock *BB = BasicBlock::Create(getGlobalContext(), "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;
 
   if (Value *RetVal = Body->codegen()) {

 }
 
 //===----------------------------------------------------------------------===//
 // Top-Level parsing and JIT Driver
 //===----------------------------------------------------------------------===//
 
 static void InitializeModuleAndPassManager() {
   // Open a new module.
-  TheModule = llvm::make_unique<Module>("my cool jit", getGlobalContext());
+  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());
 
   // Do simple "peephole" optimizations and bit-twiddling optzns.
   TheFPM->add(createInstructionCombiningPass());
   // Reassociate expressions.

examples/Kaleidoscope/Chapter6/toy.cpp

static std::unique_ptr<PrototypeAST> ParseExtern() {
   return ParsePrototype();
 }
 
 //===----------------------------------------------------------------------===//
 // Code Generation
 //===----------------------------------------------------------------------===//
 
 static std::unique_ptr<Module> TheModule;
-static IRBuilder<> Builder(getGlobalContext());
+static LLVMContext TheContext;
+static IRBuilder<> Builder(TheContext);
 static std::map<std::string, Value *> NamedValues;
 static std::unique_ptr<legacy::FunctionPassManager> TheFPM;
 static std::unique_ptr<KaleidoscopeJIT> TheJIT;
 static std::map<std::string, std::unique_ptr<PrototypeAST>> FunctionProtos;
 
 Value *LogErrorV(const char *Str) {
   LogError(Str);
   return nullptr;
Function *getFunction(std::string Name) {
   if (FI != FunctionProtos.end())
     return FI->second->codegen();
 
   // If no existing prototype exists, return null.
   return nullptr;
 }
 
 Value *NumberExprAST::codegen() {
-  return ConstantFP::get(getGlobalContext(), APFloat(Val));
+  return ConstantFP::get(TheContext, APFloat(Val));
 }
 
 Value *VariableExprAST::codegen() {
   // Look this variable up in the function.
   Value *V = NamedValues[Name];
   if (!V)
     return LogErrorV("Unknown variable name");
   return V;
case '+':
     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(getGlobalContext()),
+    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);

 
 Value *IfExprAST::codegen() {
   Value *CondV = Cond->codegen();
   if (!CondV)
     return nullptr;
 
   // Convert condition to a bool by comparing equal to 0.0.
   CondV = Builder.CreateFCmpONE(
-      CondV, ConstantFP::get(getGlobalContext(), APFloat(0.0)), "ifcond");
+      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(getGlobalContext(), "then", TheFunction);
-  BasicBlock *ElseBB = BasicBlock::Create(getGlobalContext(), "else");
-  BasicBlock *MergeBB = BasicBlock::Create(getGlobalContext(), "ifcont");
+      BasicBlock::Create(TheContext, "then", TheFunction);
+  BasicBlock *ElseBB = BasicBlock::Create(TheContext, "else");
+  BasicBlock *MergeBB = BasicBlock::Create(TheContext, "ifcont");
 
   Builder.CreateCondBr(CondV, ThenBB, ElseBB);
 
   // Emit then value.
   Builder.SetInsertPoint(ThenBB);
 
   Value *ThenV = Then->codegen();
   if (!ThenV)
Value *IfExprAST::codegen() {
   Builder.CreateBr(MergeBB);
   // Codegen of 'Else' can change the current block, update ElseBB for the PHI.
   ElseBB = Builder.GetInsertBlock();
 
   // Emit merge block.
   TheFunction->getBasicBlockList().push_back(MergeBB);
   Builder.SetInsertPoint(MergeBB);
   PHINode *PN =
-      Builder.CreatePHI(Type::getDoubleTy(getGlobalContext()), 2, "iftmp");
+      Builder.CreatePHI(Type::getDoubleTy(TheContext), 2, "iftmp");
 
   PN->addIncoming(ThenV, ThenBB);
   PN->addIncoming(ElseV, ElseBB);
   return PN;
 }
 
 // Output for-loop as:
 //   ...
Value *ForExprAST::codegen() {
   if (!StartVal)
     return nullptr;
 
   // 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(getGlobalContext(), "loop", TheFunction);
+      BasicBlock::Create(TheContext, "loop", TheFunction);
 
   // Insert an explicit fall through from the current block to the LoopBB.
   Builder.CreateBr(LoopBB);
 
   // Start insertion in LoopBB.
   Builder.SetInsertPoint(LoopBB);
 
   // Start the PHI node with an entry for Start.
-  PHINode *Variable = Builder.CreatePHI(Type::getDoubleTy(getGlobalContext()),
+  PHINode *Variable = Builder.CreatePHI(Type::getDoubleTy(TheContext),
                                         2, VarName.c_str());
   Variable->addIncoming(StartVal, PreheaderBB);
 
   // Within the loop, the variable is defined equal to the PHI node.  If it
   // shadows an existing variable, we have to restore it, so save it now.
   Value *OldVal = NamedValues[VarName];
   NamedValues[VarName] = Variable;
 
   // Emit the body of the loop.  This, like any other expr, can change the
   // current BB.  Note that we ignore the value computed by the body, but don't
   // allow an error.
   if (!Body->codegen())
     return nullptr;
 
   // 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(getGlobalContext(), APFloat(1.0));
+    StepVal = ConstantFP::get(TheContext, APFloat(1.0));
   }
 
   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.
   EndCond = Builder.CreateFCmpONE(
-      EndCond, ConstantFP::get(getGlobalContext(), APFloat(0.0)), "loopcond");
+      EndCond, ConstantFP::get(TheContext, APFloat(0.0)), "loopcond");
 
   // Create the "after loop" block and insert it.
   BasicBlock *LoopEndBB = Builder.GetInsertBlock();
   BasicBlock *AfterBB =
-      BasicBlock::Create(getGlobalContext(), "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);
 
   // 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(getGlobalContext()));
+  return Constant::getNullValue(Type::getDoubleTy(TheContext));
 }
 
 Function *PrototypeAST::codegen() {
   // Make the function type:  double(double,double) etc.
   std::vector<Type *> Doubles(Args.size(),
-                              Type::getDoubleTy(getGlobalContext()));
+                              Type::getDoubleTy(TheContext));
   FunctionType *FT =
-      FunctionType::get(Type::getDoubleTy(getGlobalContext()), Doubles, false);
+      FunctionType::get(Type::getDoubleTy(TheContext), Doubles, false);
 
   Function *F =
       Function::Create(FT, Function::ExternalLinkage, Name, TheModule.get());
 
   // Set names for all arguments.
   unsigned Idx = 0;
   for (auto &Arg : F->args())
     Arg.setName(Args[Idx++]);
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(getGlobalContext(), "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;
 
   if (Value *RetVal = Body->codegen()) {

 }
 
 //===----------------------------------------------------------------------===//
 // Top-Level parsing and JIT Driver
 //===----------------------------------------------------------------------===//
 
 static void InitializeModuleAndPassManager() {
   // Open a new module.
-  TheModule = llvm::make_unique<Module>("my cool jit", getGlobalContext());
+  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());
 
   // Do simple "peephole" optimizations and bit-twiddling optzns.
   TheFPM->add(createInstructionCombiningPass());
   // Reassociate expressions.

examples/Kaleidoscope/Chapter7/toy.cpp

static std::unique_ptr<PrototypeAST> ParseExtern() {
   return ParsePrototype();
 }
 
 //===----------------------------------------------------------------------===//
 // Code Generation
 //===----------------------------------------------------------------------===//
 
 static std::unique_ptr<Module> TheModule;
-static IRBuilder<> Builder(getGlobalContext());
+static LLVMContext TheContext;
+static IRBuilder<> Builder(TheContext);
 static std::map<std::string, AllocaInst *> NamedValues;
 static std::unique_ptr<legacy::FunctionPassManager> TheFPM;
 static std::unique_ptr<KaleidoscopeJIT> TheJIT;
 static std::map<std::string, std::unique_ptr<PrototypeAST>> FunctionProtos;
 
 Value *LogErrorV(const char *Str) {
   LogError(Str);
   return nullptr;

 }
 
 /// CreateEntryBlockAlloca - Create an alloca instruction in the entry block of
 /// the function.  This is used for mutable variables etc.
 static AllocaInst *CreateEntryBlockAlloca(Function *TheFunction,
                                           const std::string &VarName) {
   IRBuilder<> TmpB(&TheFunction->getEntryBlock(),
                    TheFunction->getEntryBlock().begin());
-  return TmpB.CreateAlloca(Type::getDoubleTy(getGlobalContext()), nullptr,
+  return TmpB.CreateAlloca(Type::getDoubleTy(TheContext), nullptr,
                            VarName.c_str());
 }
 
 Value *NumberExprAST::codegen() {
-  return ConstantFP::get(getGlobalContext(), APFloat(Val));
+  return ConstantFP::get(TheContext, APFloat(Val));
 }
 
 Value *VariableExprAST::codegen() {
   // Look this variable up in the function.
   Value *V = NamedValues[Name];
   if (!V)
     return LogErrorV("Unknown variable name");
 
case '+':
     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(getGlobalContext()),
+    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);

 
 Value *IfExprAST::codegen() {
   Value *CondV = Cond->codegen();
   if (!CondV)
     return nullptr;
 
   // Convert condition to a bool by comparing equal to 0.0.
   CondV = Builder.CreateFCmpONE(
-      CondV, ConstantFP::get(getGlobalContext(), APFloat(0.0)), "ifcond");
+      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(getGlobalContext(), "then", TheFunction);
-  BasicBlock *ElseBB = BasicBlock::Create(getGlobalContext(), "else");
-  BasicBlock *MergeBB = BasicBlock::Create(getGlobalContext(), "ifcont");
+      BasicBlock::Create(TheContext, "then", TheFunction);
+  BasicBlock *ElseBB = BasicBlock::Create(TheContext, "else");
+  BasicBlock *MergeBB = BasicBlock::Create(TheContext, "ifcont");
 
   Builder.CreateCondBr(CondV, ThenBB, ElseBB);
 
   // Emit then value.
   Builder.SetInsertPoint(ThenBB);
 
   Value *ThenV = Then->codegen();
   if (!ThenV)
Value *IfExprAST::codegen() {
   Builder.CreateBr(MergeBB);
   // Codegen of 'Else' can change the current block, update ElseBB for the PHI.
   ElseBB = Builder.GetInsertBlock();
 
   // Emit merge block.
   TheFunction->getBasicBlockList().push_back(MergeBB);
   Builder.SetInsertPoint(MergeBB);
   PHINode *PN =
-      Builder.CreatePHI(Type::getDoubleTy(getGlobalContext()), 2, "iftmp");
+      Builder.CreatePHI(Type::getDoubleTy(TheContext), 2, "iftmp");
 
   PN->addIncoming(ThenV, ThenBB);
   PN->addIncoming(ElseV, ElseBB);
   return PN;
 }
 
 // Output for-loop as:
 //   var = alloca double
if (!StartVal)
     return nullptr;
 
   // Store the value into the alloca.
   Builder.CreateStore(StartVal, Alloca);
 
   // Make the new basic block for the loop header, inserting after current
   // block.
   BasicBlock *LoopBB =
-      BasicBlock::Create(getGlobalContext(), "loop", TheFunction);
+      BasicBlock::Create(TheContext, "loop", TheFunction);
 
   // Insert an explicit fall through from the current block to the LoopBB.
   Builder.CreateBr(LoopBB);
 
   // Start insertion in LoopBB.
   Builder.SetInsertPoint(LoopBB);
 
   // Within the loop, the variable is defined equal to the PHI node.  If it
Value *ForExprAST::codegen() {
   // 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(getGlobalContext(), APFloat(1.0));
+    StepVal = ConstantFP::get(TheContext, APFloat(1.0));
   }
 
   // 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, 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.
   EndCond = Builder.CreateFCmpONE(
-      EndCond, ConstantFP::get(getGlobalContext(), APFloat(0.0)), "loopcond");
+      EndCond, ConstantFP::get(TheContext, APFloat(0.0)), "loopcond");
 
   // Create the "after loop" block and insert it.
   BasicBlock *AfterBB =
-      BasicBlock::Create(getGlobalContext(), "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);
 
   // Restore the unshadowed variable.
   if (OldVal)
     NamedValues[VarName] = OldVal;
   else
     NamedValues.erase(VarName);
 
   // for expr always returns 0.0.
-  return Constant::getNullValue(Type::getDoubleTy(getGlobalContext()));
+  return Constant::getNullValue(Type::getDoubleTy(TheContext));
 }
 
 Value *VarExprAST::codegen() {
   std::vector<AllocaInst *> OldBindings;
 
   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();
 
     // 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(getGlobalContext(), 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]);
Value *VarExprAST::codegen() {
 
   // Return the body computation.
   return BodyVal;
 }
 
 Function *PrototypeAST::codegen() {
   // Make the function type:  double(double,double) etc.
   std::vector<Type *> Doubles(Args.size(),
-                              Type::getDoubleTy(getGlobalContext()));
+                              Type::getDoubleTy(TheContext));
   FunctionType *FT =
-      FunctionType::get(Type::getDoubleTy(getGlobalContext()), Doubles, false);
+      FunctionType::get(Type::getDoubleTy(TheContext), Doubles, false);
 
   Function *F =
       Function::Create(FT, Function::ExternalLinkage, Name, TheModule.get());
 
   // Set names for all arguments.
   unsigned Idx = 0;
   for (auto &Arg : F->args())
     Arg.setName(Args[Idx++]);
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(getGlobalContext(), "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()) {
     // Create an alloca for this variable.
     AllocaInst *Alloca = CreateEntryBlockAlloca(TheFunction, Arg.getName());
 

 }
 
 //===----------------------------------------------------------------------===//
 // Top-Level parsing and JIT Driver
 //===----------------------------------------------------------------------===//
 
 static void InitializeModuleAndPassManager() {
   // Open a new module.
-  TheModule = llvm::make_unique<Module>("my cool jit", getGlobalContext());
+  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());
 
   // Do simple "peephole" optimizations and bit-twiddling optzns.
   TheFPM->add(createInstructionCombiningPass());
   // Reassociate expressions.

examples/Kaleidoscope/Chapter8/toy.cpp

std::string getTokName(int Tok) {
   }
   return std::string(1, (char)Tok);
 }
 
 namespace {
 class PrototypeAST;
 class ExprAST;
 }
-static IRBuilder<> Builder(getGlobalContext());
+static LLVMContext TheContext;
+static IRBuilder<> Builder(TheContext);
 struct DebugInfo {
   DICompileUnit *TheCU;
   DIType *DblTy;
   std::vector<DIScope *> LexicalBlocks;
 
   void emitLocation(ExprAST *AST);
   DIType *getDoubleTy();
 } KSDbgInfo;

 }
 
 /// 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(getGlobalContext()), nullptr,
+  return TmpB.CreateAlloca(Type::getDoubleTy(TheContext), nullptr,
                            VarName.c_str());
 }
 
 Value *NumberExprAST::codegen() {
   KSDbgInfo.emitLocation(this);
-  return ConstantFP::get(getGlobalContext(), APFloat(Val));
+  return ConstantFP::get(TheContext, APFloat(Val));
 }
 
 Value *VariableExprAST::codegen() {
   // Look this variable up in the function.
   Value *V = NamedValues[Name];
   if (!V)
     return LogErrorV("Unknown variable name");
 
case '+':
     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(getGlobalContext()),
+    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);
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.
   CondV = Builder.CreateFCmpONE(
-      CondV, ConstantFP::get(getGlobalContext(), APFloat(0.0)), "ifcond");
+      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(getGlobalContext(), "then", TheFunction);
-  BasicBlock *ElseBB = BasicBlock::Create(getGlobalContext(), "else");
-  BasicBlock *MergeBB = BasicBlock::Create(getGlobalContext(), "ifcont");
+      BasicBlock::Create(TheContext, "then", TheFunction);
+  BasicBlock *ElseBB = BasicBlock::Create(TheContext, "else");
+  BasicBlock *MergeBB = BasicBlock::Create(TheContext, "ifcont");
 
   Builder.CreateCondBr(CondV, ThenBB, ElseBB);
 
   // Emit then value.
   Builder.SetInsertPoint(ThenBB);
 
   Value *ThenV = Then->codegen();
   if (!ThenV)
Value *IfExprAST::codegen() {
   Builder.CreateBr(MergeBB);
   // Codegen of 'Else' can change the current block, update ElseBB for the PHI.
   ElseBB = Builder.GetInsertBlock();
 
   // Emit merge block.
   TheFunction->getBasicBlockList().push_back(MergeBB);
   Builder.SetInsertPoint(MergeBB);
   PHINode *PN =
-      Builder.CreatePHI(Type::getDoubleTy(getGlobalContext()), 2, "iftmp");
+      Builder.CreatePHI(Type::getDoubleTy(TheContext), 2, "iftmp");
 
   PN->addIncoming(ThenV, ThenBB);
   PN->addIncoming(ElseV, ElseBB);
   return PN;
 }
 
 // Output for-loop as:
 //   var = alloca double
if (!StartVal)
     return nullptr;
 
   // Store the value into the alloca.
   Builder.CreateStore(StartVal, Alloca);
 
   // Make the new basic block for the loop header, inserting after current
   // block.
   BasicBlock *LoopBB =
-      BasicBlock::Create(getGlobalContext(), "loop", TheFunction);
+      BasicBlock::Create(TheContext, "loop", TheFunction);
 
   // Insert an explicit fall through from the current block to the LoopBB.
   Builder.CreateBr(LoopBB);
 
   // Start insertion in LoopBB.
   Builder.SetInsertPoint(LoopBB);
 
   // Within the loop, the variable is defined equal to the PHI node.  If it
Value *ForExprAST::codegen() {
   // 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(getGlobalContext(), APFloat(1.0));
+    StepVal = ConstantFP::get(TheContext, APFloat(1.0));
   }
 
   // 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, 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.
   EndCond = Builder.CreateFCmpONE(
-      EndCond, ConstantFP::get(getGlobalContext(), APFloat(0.0)), "loopcond");
+      EndCond, ConstantFP::get(TheContext, APFloat(0.0)), "loopcond");
 
   // Create the "after loop" block and insert it.
   BasicBlock *AfterBB =
-      BasicBlock::Create(getGlobalContext(), "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);
 
   // Restore the unshadowed variable.
   if (OldVal)
     NamedValues[VarName] = OldVal;
   else
     NamedValues.erase(VarName);
 
   // for expr always returns 0.0.
-  return Constant::getNullValue(Type::getDoubleTy(getGlobalContext()));
+  return Constant::getNullValue(Type::getDoubleTy(TheContext));
 }
 
 Value *VarExprAST::codegen() {
   std::vector<AllocaInst *> OldBindings;
 
   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();
 
     // 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(getGlobalContext(), 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]);
Value *VarExprAST::codegen() {
 
   // Return the body computation.
   return BodyVal;
 }
 
 Function *PrototypeAST::codegen() {
   // Make the function type:  double(double,double) etc.
   std::vector<Type *> Doubles(Args.size(),
-                              Type::getDoubleTy(getGlobalContext()));
+                              Type::getDoubleTy(TheContext));
   FunctionType *FT =
-      FunctionType::get(Type::getDoubleTy(getGlobalContext()), Doubles, false);
+      FunctionType::get(Type::getDoubleTy(TheContext), Doubles, false);
 
   Function *F =
       Function::Create(FT, Function::ExternalLinkage, Name, TheModule.get());
 
   // Set names for all arguments.
   unsigned Idx = 0;
   for (auto &Arg : F->args())
     Arg.setName(Args[Idx++]);
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(getGlobalContext(), "entry", TheFunction);
+  BasicBlock *BB = BasicBlock::Create(TheContext, "entry", TheFunction);
   Builder.SetInsertPoint(BB);
 
   // Create a subprogram DIE for this function.
   DIFile *Unit = DBuilder->createFile(KSDbgInfo.TheCU->getFilename(),
                                       KSDbgInfo.TheCU->getDirectory());
   DIScope *FContext = Unit;
   unsigned LineNo = P.getLine();
   unsigned ScopeLine = LineNo;

 }
 
 //===----------------------------------------------------------------------===//
 // Top-Level parsing and JIT Driver
 //===----------------------------------------------------------------------===//
 
 static void InitializeModule() {
   // Open a new module.
-  TheModule = llvm::make_unique<Module>("my cool jit", getGlobalContext());
+  TheModule = llvm::make_unique<Module>("my cool jit", TheContext);
   TheModule->setDataLayout(TheJIT->getTargetMachine().createDataLayout());
 }
 
 static void HandleDefinition() {
   if (auto FnAST = ParseDefinition()) {
     if (!FnAST->codegen())
       fprintf(stderr, "Error reading function definition:");
   } else {

examples/Kaleidoscope/MCJIT/cached/toy-jit.cpp

 }
 
 //===----------------------------------------------------------------------===//
 // Code Generation
 //===----------------------------------------------------------------------===//
 
 static Module *TheModule;
 static FunctionPassManager *TheFPM;
-static IRBuilder<> Builder(getGlobalContext());
+static LLVMContext TheContext;
+static IRBuilder<> Builder(TheContext);
 static std::map<std::string, AllocaInst*> NamedValues;
 
 Value *ErrorV(const char *Str) { Error(Str); return 0; }
 
 /// 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(getGlobalContext()), 0,
+  return TmpB.CreateAlloca(Type::getDoubleTy(TheContext), 0,
                            VarName.c_str());
 }
 
 Value *NumberExprAST::Codegen() {
-  return ConstantFP::get(getGlobalContext(), APFloat(Val));
+  return ConstantFP::get(TheContext, APFloat(Val));
 }
 
 Value *VariableExprAST::Codegen() {
   // Look this variable up in the function.
   Value *V = NamedValues[Name];
   if (V == 0) return ErrorV("Unknown variable name");
 
   // Load the value.
Value *BinaryExprAST::Codegen() {
   switch (Op) {
   case '+': return Builder.CreateFAdd(L, R, "addtmp");
   case '-': return Builder.CreateFSub(L, R, "subtmp");
   case '*': return Builder.CreateFMul(L, R, "multmp");
   case '/': return Builder.CreateFDiv(L, R, "divtmp");
   case '<':
     L = Builder.CreateFCmpULT(L, R, "cmptmp");
     // Convert bool 0/1 to double 0.0 or 1.0
-    return Builder.CreateUIToFP(L, Type::getDoubleTy(getGlobalContext()),
+    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);
   assert(F && "binary operator not found!");

 }
 
 Value *IfExprAST::Codegen() {
   Value *CondV = Cond->Codegen();
   if (CondV == 0) return 0;
   
   // Convert condition to a bool by comparing equal to 0.0.
   CondV = Builder.CreateFCmpONE(CondV, 
-                              ConstantFP::get(getGlobalContext(), APFloat(0.0)),
+                              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(getGlobalContext(), "then", TheFunction);
-  BasicBlock *ElseBB = BasicBlock::Create(getGlobalContext(), "else");
-  BasicBlock *MergeBB = BasicBlock::Create(getGlobalContext(), "ifcont");
+  BasicBlock *ThenBB = BasicBlock::Create(TheContext, "then", TheFunction);
+  BasicBlock *ElseBB = BasicBlock::Create(TheContext, "else");
+  BasicBlock *MergeBB = BasicBlock::Create(TheContext, "ifcont");
   
   Builder.CreateCondBr(CondV, ThenBB, ElseBB);
   
   // Emit then value.
   Builder.SetInsertPoint(ThenBB);
   
   Value *ThenV = Then->Codegen();
   if (ThenV == 0) return 0;
Value *IfExprAST::Codegen() {
   
   Builder.CreateBr(MergeBB);
   // Codegen of 'Else' can change the current block, update ElseBB for the PHI.
   ElseBB = Builder.GetInsertBlock();
   
   // Emit merge block.
   TheFunction->getBasicBlockList().push_back(MergeBB);
   Builder.SetInsertPoint(MergeBB);
-  PHINode *PN = Builder.CreatePHI(Type::getDoubleTy(getGlobalContext()), 2,
+  PHINode *PN = Builder.CreatePHI(Type::getDoubleTy(TheContext), 2,
                                   "iftmp");
   
   PN->addIncoming(ThenV, ThenBB);
   PN->addIncoming(ElseV, ElseBB);
   return PN;
 }
 
 Value *ForExprAST::Codegen() {
Value *ForExprAST::Codegen() {
   Value *StartVal = Start->Codegen();
   if (StartVal == 0) return 0;
   
   // Store the value into the alloca.
   Builder.CreateStore(StartVal, Alloca);
   
   // Make the new basic block for the loop header, inserting after current
   // block.
-  BasicBlock *LoopBB = BasicBlock::Create(getGlobalContext(), "loop", TheFunction);
+  BasicBlock *LoopBB = BasicBlock::Create(TheContext, "loop", TheFunction);
   
   // Insert an explicit fall through from the current block to the LoopBB.
   Builder.CreateBr(LoopBB);
 
   // Start insertion in LoopBB.
   Builder.SetInsertPoint(LoopBB);
   
   // Within the loop, the variable is defined equal to the PHI node.  If it
Value *ForExprAST::Codegen() {
   
   // Emit the step value.
   Value *StepVal;
   if (Step) {
     StepVal = Step->Codegen();
     if (StepVal == 0) return 0;
   } else {
     // If not specified, use 1.0.
-    StepVal = ConstantFP::get(getGlobalContext(), APFloat(1.0));
+    StepVal = ConstantFP::get(TheContext, APFloat(1.0));
   }
   
   // Compute the end condition.
   Value *EndCond = End->Codegen();
   if (EndCond == 0) return EndCond;
   
   // Reload, increment, and restore the alloca.  This handles the case where
   // the body of the loop mutates the variable.
   Value *CurVar = 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.
   EndCond = Builder.CreateFCmpONE(EndCond, 
-                              ConstantFP::get(getGlobalContext(), APFloat(0.0)),
+                              ConstantFP::get(TheContext, APFloat(0.0)),
                                   "loopcond");
   
   // Create the "after loop" block and insert it.
-  BasicBlock *AfterBB = BasicBlock::Create(getGlobalContext(), "afterloop", TheFunction);
+  BasicBlock *AfterBB = 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);
   
   // Restore the unshadowed variable.
   if (OldVal)
     NamedValues[VarName] = OldVal;
   else
     NamedValues.erase(VarName);
 
   
   // for expr always returns 0.0.
-  return Constant::getNullValue(Type::getDoubleTy(getGlobalContext()));
+  return Constant::getNullValue(Type::getDoubleTy(TheContext));
 }
 
 Value *VarExprAST::Codegen() {
   std::vector<AllocaInst *> OldBindings;
   
   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;
     
     // 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 == 0) return 0;
     } else { // If not specified, use 0.0.
-      InitVal = ConstantFP::get(getGlobalContext(), 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]);
Value *VarExprAST::Codegen() {
 
   // Return the body computation.
   return BodyVal;
 }
 
 Function *PrototypeAST::Codegen() {
   // Make the function type:  double(double,double) etc.
   std::vector<Type*> Doubles(Args.size(), 
-                             Type::getDoubleTy(getGlobalContext()));
-  FunctionType *FT = FunctionType::get(Type::getDoubleTy(getGlobalContext()),
+                             Type::getDoubleTy(TheContext));
+  FunctionType *FT = FunctionType::get(Type::getDoubleTy(TheContext),
                                        Doubles, false);
 
   Function *F = Function::Create(FT, Function::ExternalLinkage, Name, TheModule);
   // If F conflicted, there was already something named 'Name'.  If it has a
   // body, don't allow redefinition or reextern.
   if (F->getName() != Name) {
     // Delete the one we just made and get the existing one.
     F->eraseFromParent();
Function *FunctionAST::Codegen() {
   if (TheFunction == 0)
     return 0;
 
   // If this is an operator, install it.
   if (Proto->isBinaryOp())
     BinopPrecedence[Proto->getOperatorName()] = Proto->getBinaryPrecedence();
 
   // Create a new basic block to start insertion into.
-  BasicBlock *BB = BasicBlock::Create(getGlobalContext(), "entry", TheFunction);
+  BasicBlock *BB = BasicBlock::Create(TheContext, "entry", TheFunction);
   Builder.SetInsertPoint(BB);
   
   // Add all arguments to the symbol table and create their allocas.
   Proto->CreateArgumentAllocas(TheFunction);
 
   if (Value *RetVal = Body->Codegen()) {
     // Finish off the function.
     Builder.CreateRet(RetVal);

 }
 
 //===----------------------------------------------------------------------===//
 // Command line input file handlers
 //===----------------------------------------------------------------------===//
 
 Module* parseInputIR(std::string InputFile) {
   SMDiagnostic Err;
-  Module *M = ParseIRFile(InputFile, Err, getGlobalContext());
+  Module *M = ParseIRFile(InputFile, Err, TheContext);
   if (!M) {
     Err.print("IR parsing failed: ", errs());
     return NULL;
   }
 
   return M;
 }
 
 //===----------------------------------------------------------------------===//
 // Main driver code.
 //===----------------------------------------------------------------------===//
 
 int main(int argc, char **argv) {
   InitializeNativeTarget();
-  LLVMContext &Context = getGlobalContext();
+  LLVMContext &Context = TheContext;
 
   cl::ParseCommandLineOptions(argc, argv,
                               "Kaleidoscope example program\n");
 
   // Install standard binary operators.
   // 1 is lowest precedence.
   BinopPrecedence['='] = 2;
   BinopPrecedence['<'] = 10;

examples/Kaleidoscope/MCJIT/cached/toy.cpp

for (it = begin; it != end; ++it)
     (*it)->dump();
 }
 
 //===----------------------------------------------------------------------===//
 // Code Generation
 //===----------------------------------------------------------------------===//
 
 static MCJITHelper *TheHelper;
-static IRBuilder<> Builder(getGlobalContext());
+static LLVMContext TheContext;
+static IRBuilder<> Builder(TheContext);
 static std::map<std::string, AllocaInst*> NamedValues;
 
 Value *ErrorV(const char *Str) { Error(Str); return 0; }
 
 /// 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(getGlobalContext()), 0,
+  return TmpB.CreateAlloca(Type::getDoubleTy(TheContext), 0,
                            VarName.c_str());
 }
 
 Value *NumberExprAST::Codegen() {
-  return ConstantFP::get(getGlobalContext(), APFloat(Val));
+  return ConstantFP::get(TheContext, APFloat(Val));
 }
 
 Value *VariableExprAST::Codegen() {
   // Look this variable up in the function.
   Value *V = NamedValues[Name];
   char ErrStr[256];
   sprintf(ErrStr, "Unknown variable name %s", Name.c_str());
   if (V == 0) return ErrorV(ErrStr);
Value *BinaryExprAST::Codegen() {
   switch (Op) {
   case '+': return Builder.CreateFAdd(L, R, "addtmp");
   case '-': return Builder.CreateFSub(L, R, "subtmp");
   case '*': return Builder.CreateFMul(L, R, "multmp");
   case '/': return Builder.CreateFDiv(L, R, "divtmp");
   case '<':
     L = Builder.CreateFCmpULT(L, R, "cmptmp");
     // Convert bool 0/1 to double 0.0 or 1.0
-    return Builder.CreateUIToFP(L, Type::getDoubleTy(getGlobalContext()),
+    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 = TheHelper->getFunction(MakeLegalFunctionName(std::string("binary")+Op));
   assert(F && "binary operator not found!");

 }
 
 Value *IfExprAST::Codegen() {
   Value *CondV = Cond->Codegen();
   if (CondV == 0) return 0;
 
   // Convert condition to a bool by comparing equal to 0.0.
   CondV = Builder.CreateFCmpONE(CondV,
-                              ConstantFP::get(getGlobalContext(), APFloat(0.0)),
+                              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(getGlobalContext(), "then", TheFunction);
-  BasicBlock *ElseBB = BasicBlock::Create(getGlobalContext(), "else");
-  BasicBlock *MergeBB = BasicBlock::Create(getGlobalContext(), "ifcont");
+  BasicBlock *ThenBB = BasicBlock::Create(TheContext, "then", TheFunction);
+  BasicBlock *ElseBB = BasicBlock::Create(TheContext, "else");
+  BasicBlock *MergeBB = BasicBlock::Create(TheContext, "ifcont");
 
   Builder.CreateCondBr(CondV, ThenBB, ElseBB);
 
   // Emit then value.
   Builder.SetInsertPoint(ThenBB);
 
   Value *ThenV = Then->Codegen();
   if (ThenV == 0) return 0;
Value *IfExprAST::Codegen() {
 
   Builder.CreateBr(MergeBB);
   // Codegen of 'Else' can change the current block, update ElseBB for the PHI.
   ElseBB = Builder.GetInsertBlock();
 
   // Emit merge block.
   TheFunction->getBasicBlockList().push_back(MergeBB);
   Builder.SetInsertPoint(MergeBB);
-  PHINode *PN = Builder.CreatePHI(Type::getDoubleTy(getGlobalContext()), 2,
+  PHINode *PN = Builder.CreatePHI(Type::getDoubleTy(TheContext), 2,
                                   "iftmp");
 
   PN->addIncoming(ThenV, ThenBB);
   PN->addIncoming(ElseV, ElseBB);
   return PN;
 }
 
 Value *ForExprAST::Codegen() {
Value *ForExprAST::Codegen() {
   Value *StartVal = Start->Codegen();
   if (StartVal == 0) return 0;
 
   // Store the value into the alloca.
   Builder.CreateStore(StartVal, Alloca);
 
   // Make the new basic block for the loop header, inserting after current
   // block.
-  BasicBlock *LoopBB = BasicBlock::Create(getGlobalContext(), "loop", TheFunction);
+  BasicBlock *LoopBB = BasicBlock::Create(TheContext, "loop", TheFunction);
 
   // Insert an explicit fall through from the current block to the LoopBB.
   Builder.CreateBr(LoopBB);
 
   // Start insertion in LoopBB.
   Builder.SetInsertPoint(LoopBB);
 
   // Within the loop, the variable is defined equal to the PHI node.  If it
Value *ForExprAST::Codegen() {
 
   // Emit the step value.
   Value *StepVal;
   if (Step) {
     StepVal = Step->Codegen();
     if (StepVal == 0) return 0;
   } else {
     // If not specified, use 1.0.
-    StepVal = ConstantFP::get(getGlobalContext(), APFloat(1.0));
+    StepVal = ConstantFP::get(TheContext, APFloat(1.0));
   }
 
   // Compute the end condition.
   Value *EndCond = End->Codegen();
   if (EndCond == 0) return EndCond;
 
   // Reload, increment, and restore the alloca.  This handles the case where
   // the body of the loop mutates the variable.
   Value *CurVar = 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.
   EndCond = Builder.CreateFCmpONE(EndCond,
-                              ConstantFP::get(getGlobalContext(), APFloat(0.0)),
+                              ConstantFP::get(TheContext, APFloat(0.0)),
                                   "loopcond");
 
   // Create the "after loop" block and insert it.
-  BasicBlock *AfterBB = BasicBlock::Create(getGlobalContext(), "afterloop", TheFunction);
+  BasicBlock *AfterBB = 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);
 
   // Restore the unshadowed variable.
   if (OldVal)
     NamedValues[VarName] = OldVal;
   else
     NamedValues.erase(VarName);
 
 
   // for expr always returns 0.0.
-  return Constant::getNullValue(Type::getDoubleTy(getGlobalContext()));
+  return Constant::getNullValue(Type::getDoubleTy(TheContext));
 }
 
 Value *VarExprAST::Codegen() {
   std::vector<AllocaInst *> OldBindings;
 
   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;
 
     // 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 == 0) return 0;
     } else { // If not specified, use 0.0.
-      InitVal = ConstantFP::get(getGlobalContext(), 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]);
Value *VarExprAST::Codegen() {
 
   // Return the body computation.
   return BodyVal;
 }
 
 Function *PrototypeAST::Codegen() {
   // Make the function type:  double(double,double) etc.
   std::vector<Type*> Doubles(Args.size(),
-                             Type::getDoubleTy(getGlobalContext()));
-  FunctionType *FT = FunctionType::get(Type::getDoubleTy(getGlobalContext()),
+                             Type::getDoubleTy(TheContext));
+  FunctionType *FT = FunctionType::get(Type::getDoubleTy(TheContext),
                                        Doubles, false);
 
   std::string FnName = MakeLegalFunctionName(Name);
 
   Module* M = TheHelper->getModuleForNewFunction();
 
   Function *F = Function::Create(FT, Function::ExternalLinkage, FnName, M);
 
Function *FunctionAST::Codegen() {
   if (TheFunction == 0)
     return 0;
 
   // If this is an operator, install it.
   if (Proto->isBinaryOp())
     BinopPrecedence[Proto->getOperatorName()] = Proto->getBinaryPrecedence();
 
   // Create a new basic block to start insertion into.
-  BasicBlock *BB = BasicBlock::Create(getGlobalContext(), "entry", TheFunction);
+  BasicBlock *BB = BasicBlock::Create(TheContext, "entry", TheFunction);
   Builder.SetInsertPoint(BB);
 
   // Add all arguments to the symbol table and create their allocas.
   Proto->CreateArgumentAllocas(TheFunction);
 
   if (Value *RetVal = Body->Codegen()) {
     // Finish off the function.
     Builder.CreateRet(RetVal);

 }
 
 //===----------------------------------------------------------------------===//
 // Command line input file handler
 //===----------------------------------------------------------------------===//
 
 Module* parseInputIR(std::string InputFile) {
   SMDiagnostic Err;
-  Module *M = ParseIRFile(InputFile, Err, getGlobalContext());
+  Module *M = ParseIRFile(InputFile, Err, TheContext);
   if (!M) {
     Err.print("IR parsing failed: ", errs());
     return NULL;
   }
 
   char ModID[256];
   sprintf(ModID, "IR:%s", InputFile.c_str());
   M->setModuleIdentifier(ModID);
 
   TheHelper->addModule(M);
   return M;
 }
 
 //===----------------------------------------------------------------------===//
 // Main driver code.
 //===----------------------------------------------------------------------===//
 
 int main(int argc, char **argv) {
   InitializeNativeTarget();
   InitializeNativeTargetAsmPrinter();
   InitializeNativeTargetAsmParser();
-  LLVMContext &Context = getGlobalContext();
+  LLVMContext &Context = TheContext;
 
   cl::ParseCommandLineOptions(argc, argv,
                               "Kaleidoscope example program\n");
 
   // Install standard binary operators.
   // 1 is lowest precedence.
   BinopPrecedence['='] = 2;
   BinopPrecedence['<'] = 10;

examples/Kaleidoscope/MCJIT/complete/toy.cpp

for (it = begin; it != end; ++it)
     (*it)->dump();
 }
 
 //===----------------------------------------------------------------------===//
 // Code Generation
 //===----------------------------------------------------------------------===//
 
 static BaseHelper *TheHelper;
-static IRBuilder<> Builder(getGlobalContext());
+static LLVMContext TheContext;
+static IRBuilder<> Builder(TheContext);
 static std::map<std::string, AllocaInst*> NamedValues;
 
 Value *ErrorV(const char *Str) { Error(Str); return 0; }
 
 /// 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(getGlobalContext()), 0,
+  return TmpB.CreateAlloca(Type::getDoubleTy(TheContext), 0,
                            VarName.c_str());
 }
 
 Value *NumberExprAST::Codegen() {
-  return ConstantFP::get(getGlobalContext(), APFloat(Val));
+  return ConstantFP::get(TheContext, APFloat(Val));
 }
 
 Value *VariableExprAST::Codegen() {
   // Look this variable up in the function.
   Value *V = NamedValues[Name];
   if (V == 0) return ErrorV("Unknown variable name");
 
   // Load the value.
Value *BinaryExprAST::Codegen() {
   switch (Op) {
   case '+': return Builder.CreateFAdd(L, R, "addtmp");
   case '-': return Builder.CreateFSub(L, R, "subtmp");
   case '*': return Builder.CreateFMul(L, R, "multmp");
   case '/': return Builder.CreateFDiv(L, R, "divtmp");
   case '<':
     L = Builder.CreateFCmpULT(L, R, "cmptmp");
     // Convert bool 0/1 to double 0.0 or 1.0
-    return Builder.CreateUIToFP(L, Type::getDoubleTy(getGlobalContext()),
+    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;
   F = TheHelper->getFunction(MakeLegalFunctionName(std::string("binary")+Op));

 }
 
 Value *IfExprAST::Codegen() {
   Value *CondV = Cond->Codegen();
   if (CondV == 0) return 0;
 
   // Convert condition to a bool by comparing equal to 0.0.
   CondV = Builder.CreateFCmpONE(CondV,
-                              ConstantFP::get(getGlobalContext(), APFloat(0.0)),
+                              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(getGlobalContext(), "then", TheFunction);
-  BasicBlock *ElseBB = BasicBlock::Create(getGlobalContext(), "else");
-  BasicBlock *MergeBB = BasicBlock::Create(getGlobalContext(), "ifcont");
+  BasicBlock *ThenBB = BasicBlock::Create(TheContext, "then", TheFunction);
+  BasicBlock *ElseBB = BasicBlock::Create(TheContext, "else");
+  BasicBlock *MergeBB = BasicBlock::Create(TheContext, "ifcont");
 
   Builder.CreateCondBr(CondV, ThenBB, ElseBB);
 
   // Emit then value.
   Builder.SetInsertPoint(ThenBB);
 
   Value *ThenV = Then->Codegen();
   if (ThenV == 0) return 0;
Value *IfExprAST::Codegen() {
 
   Builder.CreateBr(MergeBB);
   // Codegen of 'Else' can change the current block, update ElseBB for the PHI.
   ElseBB = Builder.GetInsertBlock();
 
   // Emit merge block.
   TheFunction->getBasicBlockList().push_back(MergeBB);
   Builder.SetInsertPoint(MergeBB);
-  PHINode *PN = Builder.CreatePHI(Type::getDoubleTy(getGlobalContext()), 2,
+  PHINode *PN = Builder.CreatePHI(Type::getDoubleTy(TheContext), 2,
                                   "iftmp");
 
   PN->addIncoming(ThenV, ThenBB);
   PN->addIncoming(ElseV, ElseBB);
   return PN;
 }
 
 Value *ForExprAST::Codegen() {
Value *ForExprAST::Codegen() {
   Value *StartVal = Start->Codegen();
   if (StartVal == 0) return 0;
 
   // Store the value into the alloca.
   Builder.CreateStore(StartVal, Alloca);
 
   // Make the new basic block for the loop header, inserting after current
   // block.
-  BasicBlock *LoopBB = BasicBlock::Create(getGlobalContext(), "loop", TheFunction);
+  BasicBlock *LoopBB = BasicBlock::Create(TheContext, "loop", TheFunction);
 
   // Insert an explicit fall through from the current block to the LoopBB.
   Builder.CreateBr(LoopBB);
 
   // Start insertion in LoopBB.
   Builder.SetInsertPoint(LoopBB);
 
   // Within the loop, the variable is defined equal to the PHI node.  If it
Value *ForExprAST::Codegen() {
 
   // Emit the step value.
   Value *StepVal;
   if (Step) {
     StepVal = Step->Codegen();
     if (StepVal == 0) return 0;
   } else {
     // If not specified, use 1.0.
-    StepVal = ConstantFP::get(getGlobalContext(), APFloat(1.0));
+    StepVal = ConstantFP::get(TheContext, APFloat(1.0));
   }
 
   // Compute the end condition.
   Value *EndCond = End->Codegen();
   if (EndCond == 0) return EndCond;
 
   // Reload, increment, and restore the alloca.  This handles the case where
   // the body of the loop mutates the variable.
   Value *CurVar = 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.
   EndCond = Builder.CreateFCmpONE(EndCond,
-                              ConstantFP::get(getGlobalContext(), APFloat(0.0)),
+                              ConstantFP::get(TheContext, APFloat(0.0)),
                                   "loopcond");
 
   // Create the "after loop" block and insert it.
-  BasicBlock *AfterBB = BasicBlock::Create(getGlobalContext(), "afterloop", TheFunction);
+  BasicBlock *AfterBB = 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);
 
   // Restore the unshadowed variable.
   if (OldVal)
     NamedValues[VarName] = OldVal;
   else
     NamedValues.erase(VarName);
 
 
   // for expr always returns 0.0.
-  return Constant::getNullValue(Type::getDoubleTy(getGlobalContext()));
+  return Constant::getNullValue(Type::getDoubleTy(TheContext));
 }
 
 Value *VarExprAST::Codegen() {
   std::vector<AllocaInst *> OldBindings;
 
   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;
 
     // 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 == 0) return 0;
     } else { // If not specified, use 0.0.
-      InitVal = ConstantFP::get(getGlobalContext(), 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]);
Value *VarExprAST::Codegen() {
 
   // Return the body computation.
   return BodyVal;
 }
 
 Function *PrototypeAST::Codegen() {
   // Make the function type:  double(double,double) etc.
   std::vector<Type*> Doubles(Args.size(),
-                             Type::getDoubleTy(getGlobalContext()));
-  FunctionType *FT = FunctionType::get(Type::getDoubleTy(getGlobalContext()),
+                             Type::getDoubleTy(TheContext));
+  FunctionType *FT = FunctionType::get(Type::getDoubleTy(TheContext),
                                        Doubles, false);
 
   std::string FnName;
   FnName = MakeLegalFunctionName(Name);
 
   Module* M = TheHelper->getModuleForNewFunction();
   Function *F = Function::Create(FT, Function::ExternalLinkage, FnName, M);
 
Function *FunctionAST::Codegen() {
   if (TheFunction == 0)
     return 0;
 
   // If this is an operator, install it.
   if (Proto->isBinaryOp())
     BinopPrecedence[Proto->getOperatorName()] = Proto->getBinaryPrecedence();
 
   // Create a new basic block to start insertion into.
-  BasicBlock *BB = BasicBlock::Create(getGlobalContext(), "entry", TheFunction);
+  BasicBlock *BB = BasicBlock::Create(TheContext, "entry", TheFunction);
   Builder.SetInsertPoint(BB);
 
   // Add all arguments to the symbol table and create their allocas.
   Proto->CreateArgumentAllocas(TheFunction);
 
   if (Value *RetVal = Body->Codegen()) {
     // Finish off the function.
     Builder.CreateRet(RetVal);

 //===----------------------------------------------------------------------===//
 // Main driver code.
 //===----------------------------------------------------------------------===//
 
 int main(int argc, char **argv) {
   InitializeNativeTarget();
   InitializeNativeTargetAsmPrinter();
   InitializeNativeTargetAsmParser();
-  LLVMContext &Context = getGlobalContext();
+  LLVMContext &Context = TheContext;
 
   cl::ParseCommandLineOptions(argc, argv,
                               "Kaleidoscope example program\n");
 
   // Install standard binary operators.
   // 1 is lowest precedence.
   BinopPrecedence['='] = 2;
   BinopPrecedence['<'] = 10;

examples/Kaleidoscope/MCJIT/initial/toy.cpp

for (it = begin; it != end; ++it)
     (*it)->dump();
 }
 
 //===----------------------------------------------------------------------===//
 // Code Generation
 //===----------------------------------------------------------------------===//
 
 static MCJITHelper *TheHelper;
-static IRBuilder<> Builder(getGlobalContext());
+static LLVMContext TheContext;
+static IRBuilder<> Builder(TheContext);
 static std::map<std::string, AllocaInst*> NamedValues;
 
 Value *ErrorV(const char *Str) { Error(Str); return 0; }
 
 /// 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(getGlobalContext()), 0,
+  return TmpB.CreateAlloca(Type::getDoubleTy(TheContext), 0,
                            VarName.c_str());
 }
 
 Value *NumberExprAST::Codegen() {
-  return ConstantFP::get(getGlobalContext(), APFloat(Val));
+  return ConstantFP::get(TheContext, APFloat(Val));
 }
 
 Value *VariableExprAST::Codegen() {
   // Look this variable up in the function.
   Value *V = NamedValues[Name];
   char ErrStr[256];
   sprintf(ErrStr, "Unknown variable name %s", Name.c_str());
   if (V == 0) return ErrorV(ErrStr);
Value *BinaryExprAST::Codegen() {
   switch (Op) {
   case '+': return Builder.CreateFAdd(L, R, "addtmp");
   case '-': return Builder.CreateFSub(L, R, "subtmp");
   case '*': return Builder.CreateFMul(L, R, "multmp");
   case '/': return Builder.CreateFDiv(L, R, "divtmp");
   case '<':
     L = Builder.CreateFCmpULT(L, R, "cmptmp");
     // Convert bool 0/1 to double 0.0 or 1.0
-    return Builder.CreateUIToFP(L, Type::getDoubleTy(getGlobalContext()),
+    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 = TheHelper->getFunction(MakeLegalFunctionName(std::string("binary")+Op));
   assert(F && "binary operator not found!");

 }
 
 Value *IfExprAST::Codegen() {
   Value *CondV = Cond->Codegen();
   if (CondV == 0) return 0;
 
   // Convert condition to a bool by comparing equal to 0.0.
   CondV = Builder.CreateFCmpONE(CondV,
-                              ConstantFP::get(getGlobalContext(), APFloat(0.0)),
+                              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(getGlobalContext(), "then", TheFunction);
-  BasicBlock *ElseBB = BasicBlock::Create(getGlobalContext(), "else");
-  BasicBlock *MergeBB = BasicBlock::Create(getGlobalContext(), "ifcont");
+  BasicBlock *ThenBB = BasicBlock::Create(TheContext, "then", TheFunction);
+  BasicBlock *ElseBB = BasicBlock::Create(TheContext, "else");
+  BasicBlock *MergeBB = BasicBlock::Create(TheContext, "ifcont");
 
   Builder.CreateCondBr(CondV, ThenBB, ElseBB);
 
   // Emit then value.
   Builder.SetInsertPoint(ThenBB);
 
   Value *ThenV = Then->Codegen();
   if (ThenV == 0) return 0;
Value *IfExprAST::Codegen() {
 
   Builder.CreateBr(MergeBB);
   // Codegen of 'Else' can change the current block, update ElseBB for the PHI.
   ElseBB = Builder.GetInsertBlock();
 
   // Emit merge block.
   TheFunction->getBasicBlockList().push_back(MergeBB);
   Builder.SetInsertPoint(MergeBB);
-  PHINode *PN = Builder.CreatePHI(Type::getDoubleTy(getGlobalContext()), 2,
+  PHINode *PN = Builder.CreatePHI(Type::getDoubleTy(TheContext), 2,
                                   "iftmp");
 
   PN->addIncoming(ThenV, ThenBB);
   PN->addIncoming(ElseV, ElseBB);
   return PN;
 }
 
 Value *ForExprAST::Codegen() {
Value *ForExprAST::Codegen() {
   Value *StartVal = Start->Codegen();
   if (StartVal == 0) return 0;
 
   // Store the value into the alloca.
   Builder.CreateStore(StartVal, Alloca);
 
   // Make the new basic block for the loop header, inserting after current
   // block.
-  BasicBlock *LoopBB = BasicBlock::Create(getGlobalContext(), "loop", TheFunction);
+  BasicBlock *LoopBB = BasicBlock::Create(TheContext, "loop", TheFunction);
 
   // Insert an explicit fall through from the current block to the LoopBB.
   Builder.CreateBr(LoopBB);
 
   // Start insertion in LoopBB.
   Builder.SetInsertPoint(LoopBB);
 
   // Within the loop, the variable is defined equal to the PHI node.  If it
Value *ForExprAST::Codegen() {
 
   // Emit the step value.
   Value *StepVal;
   if (Step) {
     StepVal = Step->Codegen();
     if (StepVal == 0) return 0;
   } else {
     // If not specified, use 1.0.
-    StepVal = ConstantFP::get(getGlobalContext(), APFloat(1.0));
+    StepVal = ConstantFP::get(TheContext, APFloat(1.0));
   }
 
   // Compute the end condition.
   Value *EndCond = End->Codegen();
   if (EndCond == 0) return EndCond;
 
   // Reload, increment, and restore the alloca.  This handles the case where
   // the body of the loop mutates the variable.
   Value *CurVar = 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.
   EndCond = Builder.CreateFCmpONE(EndCond,
-                              ConstantFP::get(getGlobalContext(), APFloat(0.0)),
+                              ConstantFP::get(TheContext, APFloat(0.0)),
                                   "loopcond");
 
   // Create the "after loop" block and insert it.
-  BasicBlock *AfterBB = BasicBlock::Create(getGlobalContext(), "afterloop", TheFunction);
+  BasicBlock *AfterBB = 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);
 
   // Restore the unshadowed variable.
   if (OldVal)
     NamedValues[VarName] = OldVal;
   else
     NamedValues.erase(VarName);
 
 
   // for expr always returns 0.0.
-  return Constant::getNullValue(Type::getDoubleTy(getGlobalContext()));
+  return Constant::getNullValue(Type::getDoubleTy(TheContext));
 }
 
 Value *VarExprAST::Codegen() {
   std::vector<AllocaInst *> OldBindings;
 
   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;
 
     // 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 == 0) return 0;
     } else { // If not specified, use 0.0.
-      InitVal = ConstantFP::get(getGlobalContext(), 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]);
Value *VarExprAST::Codegen() {
 
   // Return the body computation.
   return BodyVal;
 }
 
 Function *PrototypeAST::Codegen() {
   // Make the function type:  double(double,double) etc.
   std::vector<Type*> Doubles(Args.size(),
-                             Type::getDoubleTy(getGlobalContext()));
-  FunctionType *FT = FunctionType::get(Type::getDoubleTy(getGlobalContext()),
+                             Type::getDoubleTy(TheContext));
+  FunctionType *FT = FunctionType::get(Type::getDoubleTy(TheContext),
                                        Doubles, false);
 
   std::string FnName = MakeLegalFunctionName(Name);
 
   Module* M = TheHelper->getModuleForNewFunction();
 
   Function *F = Function::Create(FT, Function::ExternalLinkage, FnName, M);
 
Function *FunctionAST::Codegen() {
   if (TheFunction == 0)
     return 0;
 
   // If this is an operator, install it.
   if (Proto->isBinaryOp())
     BinopPrecedence[Proto->getOperatorName()] = Proto->getBinaryPrecedence();
 
   // Create a new basic block to start insertion into.
-  BasicBlock *BB = BasicBlock::Create(getGlobalContext(), "entry", TheFunction);
+  BasicBlock *BB = BasicBlock::Create(TheContext, "entry", TheFunction);
   Builder.SetInsertPoint(BB);
 
   // Add all arguments to the symbol table and create their allocas.
   Proto->CreateArgumentAllocas(TheFunction);
 
   if (Value *RetVal = Body->Codegen()) {
     // Finish off the function.
     Builder.CreateRet(RetVal);

 //===----------------------------------------------------------------------===//
 // Main driver code.
 //===----------------------------------------------------------------------===//
 
 int main() {
   InitializeNativeTarget();
   InitializeNativeTargetAsmPrinter();
   InitializeNativeTargetAsmParser();
-  LLVMContext &Context = getGlobalContext();
+  LLVMContext &Context = TheContext;
 
   // Install standard binary operators.
   // 1 is lowest precedence.
   BinopPrecedence['='] = 2;
   BinopPrecedence['<'] = 10;
   BinopPrecedence['+'] = 20;
   BinopPrecedence['-'] = 20;
   BinopPrecedence['/'] = 40;

examples/Kaleidoscope/MCJIT/lazy/toy-jit.cpp

 }
 
 //===----------------------------------------------------------------------===//
 // Code Generation
 //===----------------------------------------------------------------------===//
 
 static Module *TheModule;
 static FunctionPassManager *TheFPM;
-static IRBuilder<> Builder(getGlobalContext());
+static LLVMContext TheContext;
+static IRBuilder<> Builder(TheContext);
 static std::map<std::string, AllocaInst*> NamedValues;
 
 Value *ErrorV(const char *Str) { Error(Str); return 0; }
 
 /// 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(getGlobalContext()), 0,
+  return TmpB.CreateAlloca(Type::getDoubleTy(TheContext), 0,
                            VarName.c_str());
 }
 
 Value *NumberExprAST::Codegen() {
-  return ConstantFP::get(getGlobalContext(), APFloat(Val));
+  return ConstantFP::get(TheContext, APFloat(Val));
 }
 
 Value *VariableExprAST::Codegen() {
   // Look this variable up in the function.
   Value *V = NamedValues[Name];
   if (V == 0) return ErrorV("Unknown variable name");
 
   // Load the value.
Value *BinaryExprAST::Codegen() {
   switch (Op) {
   case '+': return Builder.CreateFAdd(L, R, "addtmp");
   case '-': return Builder.CreateFSub(L, R, "subtmp");
   case '*': return Builder.CreateFMul(L, R, "multmp");
   case '/': return Builder.CreateFDiv(L, R, "divtmp");
   case '<':
     L = Builder.CreateFCmpULT(L, R, "cmptmp");
     // Convert bool 0/1 to double 0.0 or 1.0
-    return Builder.CreateUIToFP(L, Type::getDoubleTy(getGlobalContext()),
+    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);
   assert(F && "binary operator not found!");

 }
 
 Value *IfExprAST::Codegen() {
   Value *CondV = Cond->Codegen();
   if (CondV == 0) return 0;
   
   // Convert condition to a bool by comparing equal to 0.0.
   CondV = Builder.CreateFCmpONE(CondV, 
-                              ConstantFP::get(getGlobalContext(), APFloat(0.0)),
+                              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(getGlobalContext(), "then", TheFunction);
-  BasicBlock *ElseBB = BasicBlock::Create(getGlobalContext(), "else");
-  BasicBlock *MergeBB = BasicBlock::Create(getGlobalContext(), "ifcont");
+  BasicBlock *ThenBB = BasicBlock::Create(TheContext, "then", TheFunction);
+  BasicBlock *ElseBB = BasicBlock::Create(TheContext, "else");
+  BasicBlock *MergeBB = BasicBlock::Create(TheContext, "ifcont");
   
   Builder.CreateCondBr(CondV, ThenBB, ElseBB);
   
   // Emit then value.
   Builder.SetInsertPoint(ThenBB);
   
   Value *ThenV = Then->Codegen();
   if (ThenV == 0) return 0;
Value *IfExprAST::Codegen() {
   
   Builder.CreateBr(MergeBB);
   // Codegen of 'Else' can change the current block, update ElseBB for the PHI.
   ElseBB = Builder.GetInsertBlock();
   
   // Emit merge block.
   TheFunction->getBasicBlockList().push_back(MergeBB);
   Builder.SetInsertPoint(MergeBB);
-  PHINode *PN = Builder.CreatePHI(Type::getDoubleTy(getGlobalContext()), 2,
+  PHINode *PN = Builder.CreatePHI(Type::getDoubleTy(TheContext), 2,
                                   "iftmp");
   
   PN->addIncoming(ThenV, ThenBB);
   PN->addIncoming(ElseV, ElseBB);
   return PN;
 }
 
 Value *ForExprAST::Codegen() {
Value *ForExprAST::Codegen() {
   Value *StartVal = Start->Codegen();
   if (StartVal == 0) return 0;
   
   // Store the value into the alloca.
   Builder.CreateStore(StartVal, Alloca);
   
   // Make the new basic block for the loop header, inserting after current
   // block.
-  BasicBlock *LoopBB = BasicBlock::Create(getGlobalContext(), "loop", TheFunction);
+  BasicBlock *LoopBB = BasicBlock::Create(TheContext, "loop", TheFunction);
   
   // Insert an explicit fall through from the current block to the LoopBB.
   Builder.CreateBr(LoopBB);
 
   // Start insertion in LoopBB.
   Builder.SetInsertPoint(LoopBB);
   
   // Within the loop, the variable is defined equal to the PHI node.  If it
Value *ForExprAST::Codegen() {
   
   // Emit the step value.
   Value *StepVal;
   if (Step) {
     StepVal = Step->Codegen();
     if (StepVal == 0) return 0;
   } else {
     // If not specified, use 1.0.
-    StepVal = ConstantFP::get(getGlobalContext(), APFloat(1.0));
+    StepVal = ConstantFP::get(TheContext, APFloat(1.0));
   }
   
   // Compute the end condition.
   Value *EndCond = End->Codegen();
   if (EndCond == 0) return EndCond;
   
   // Reload, increment, and restore the alloca.  This handles the case where
   // the body of the loop mutates the variable.
   Value *CurVar = 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.
   EndCond = Builder.CreateFCmpONE(EndCond, 
-                              ConstantFP::get(getGlobalContext(), APFloat(0.0)),
+                              ConstantFP::get(TheContext, APFloat(0.0)),
                                   "loopcond");
   
   // Create the "after loop" block and insert it.
-  BasicBlock *AfterBB = BasicBlock::Create(getGlobalContext(), "afterloop", TheFunction);
+  BasicBlock *AfterBB = 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);
   
   // Restore the unshadowed variable.
   if (OldVal)
     NamedValues[VarName] = OldVal;
   else
     NamedValues.erase(VarName);
 
   
   // for expr always returns 0.0.
-  return Constant::getNullValue(Type::getDoubleTy(getGlobalContext()));
+  return Constant::getNullValue(Type::getDoubleTy(TheContext));
 }
 
 Value *VarExprAST::Codegen() {
   std::vector<AllocaInst *> OldBindings;
   
   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;
     
     // 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 == 0) return 0;
     } else { // If not specified, use 0.0.
-      InitVal = ConstantFP::get(getGlobalContext(), 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]);
Value *VarExprAST::Codegen() {
 
   // Return the body computation.
   return BodyVal;
 }
 
 Function *PrototypeAST::Codegen() {
   // Make the function type:  double(double,double) etc.
   std::vector<Type*> Doubles(Args.size(), 
-                             Type::getDoubleTy(getGlobalContext()));
-  FunctionType *FT = FunctionType::get(Type::getDoubleTy(getGlobalContext()),
+                             Type::getDoubleTy(TheContext));
+  FunctionType *FT = FunctionType::get(Type::getDoubleTy(TheContext),
                                        Doubles, false);
 
   Function *F = Function::Create(FT, Function::ExternalLinkage, Name, TheModule);
   // If F conflicted, there was already something named 'Name'.  If it has a
   // body, don't allow redefinition or reextern.
   if (F->getName() != Name) {
     // Delete the one we just made and get the existing one.
     F->eraseFromParent();
Function *FunctionAST::Codegen() {
   if (TheFunction == 0)
     return 0;
 
   // If this is an operator, install it.
   if (Proto->isBinaryOp())
     BinopPrecedence[Proto->getOperatorName()] = Proto->getBinaryPrecedence();
 
   // Create a new basic block to start insertion into.
-  BasicBlock *BB = BasicBlock::Create(getGlobalContext(), "entry", TheFunction);
+  BasicBlock *BB = BasicBlock::Create(TheContext, "entry", TheFunction);
   Builder.SetInsertPoint(BB);
   
   // Add all arguments to the symbol table and create their allocas.
   Proto->CreateArgumentAllocas(TheFunction);
 
   if (Value *RetVal = Body->Codegen()) {
     // Finish off the function.
     Builder.CreateRet(RetVal);

 }
 
 //===----------------------------------------------------------------------===//
 // Main driver code.
 //===----------------------------------------------------------------------===//
 
 int main(int argc, char **argv) {
   InitializeNativeTarget();
-  LLVMContext &Context = getGlobalContext();
+  LLVMContext &Context = TheContext;
 
   // Install standard binary operators.
   // 1 is lowest precedence.
   BinopPrecedence['='] = 2;
   BinopPrecedence['<'] = 10;
   BinopPrecedence['+'] = 20;
   BinopPrecedence['-'] = 20;
   BinopPrecedence['/'] = 40;

examples/Kaleidoscope/MCJIT/lazy/toy.cpp

for (it = begin; it != end; ++it)
     (*it)->dump();
 }
 
 //===----------------------------------------------------------------------===//
 // Code Generation
 //===----------------------------------------------------------------------===//
 
 static MCJITHelper *TheHelper;
-static IRBuilder<> Builder(getGlobalContext());
+static LLVMContext TheContext;
+static IRBuilder<> Builder(TheContext);
 static std::map<std::string, AllocaInst*> NamedValues;
 
 Value *ErrorV(const char *Str) { Error(Str); return 0; }
 
 /// 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(getGlobalContext()), 0,
+  return TmpB.CreateAlloca(Type::getDoubleTy(TheContext), 0,
                            VarName.c_str());
 }
 
 Value *NumberExprAST::Codegen() {
-  return ConstantFP::get(getGlobalContext(), APFloat(Val));
+  return ConstantFP::get(TheContext, APFloat(Val));
 }
 
 Value *VariableExprAST::Codegen() {
   // Look this variable up in the function.
   Value *V = NamedValues[Name];
   char ErrStr[256];
   sprintf(ErrStr, "Unknown variable name %s", Name.c_str());
   if (V == 0) return ErrorV(ErrStr);
Value *BinaryExprAST::Codegen() {
   switch (Op) {
   case '+': return Builder.CreateFAdd(L, R, "addtmp");
   case '-': return Builder.CreateFSub(L, R, "subtmp");
   case '*': return Builder.CreateFMul(L, R, "multmp");
   case '/': return Builder.CreateFDiv(L, R, "divtmp");
   case '<':
     L = Builder.CreateFCmpULT(L, R, "cmptmp");
     // Convert bool 0/1 to double 0.0 or 1.0
-    return Builder.CreateUIToFP(L, Type::getDoubleTy(getGlobalContext()),
+    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 = TheHelper->getFunction(MakeLegalFunctionName(std::string("binary")+Op));
   assert(F && "binary operator not found!");

 }
 
 Value *IfExprAST::Codegen() {
   Value *CondV = Cond->Codegen();
   if (CondV == 0) return 0;
 
   // Convert condition to a bool by comparing equal to 0.0.
   CondV = Builder.CreateFCmpONE(CondV,
-                              ConstantFP::get(getGlobalContext(), APFloat(0.0)),
+                              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(getGlobalContext(), "then", TheFunction);
-  BasicBlock *ElseBB = BasicBlock::Create(getGlobalContext(), "else");
-  BasicBlock *MergeBB = BasicBlock::Create(getGlobalContext(), "ifcont");
+  BasicBlock *ThenBB = BasicBlock::Create(TheContext, "then", TheFunction);
+  BasicBlock *ElseBB = BasicBlock::Create(TheContext, "else");
+  BasicBlock *MergeBB = BasicBlock::Create(TheContext, "ifcont");
 
   Builder.CreateCondBr(CondV, ThenBB, ElseBB);
 
   // Emit then value.
   Builder.SetInsertPoint(ThenBB);
 
   Value *ThenV = Then->Codegen();
   if (ThenV == 0) return 0;
Value *IfExprAST::Codegen() {
 
   Builder.CreateBr(MergeBB);
   // Codegen of 'Else' can change the current block, update ElseBB for the PHI.
   ElseBB = Builder.GetInsertBlock();
 
   // Emit merge block.
   TheFunction->getBasicBlockList().push_back(MergeBB);
   Builder.SetInsertPoint(MergeBB);
-  PHINode *PN = Builder.CreatePHI(Type::getDoubleTy(getGlobalContext()), 2,
+  PHINode *PN = Builder.CreatePHI(Type::getDoubleTy(TheContext), 2,
                                   "iftmp");
 
   PN->addIncoming(ThenV, ThenBB);
   PN->addIncoming(ElseV, ElseBB);
   return PN;
 }
 
 Value *ForExprAST::Codegen() {
Value *ForExprAST::Codegen() {
   Value *StartVal = Start->Codegen();
   if (StartVal == 0) return 0;
 
   // Store the value into the alloca.
   Builder.CreateStore(StartVal, Alloca);
 
   // Make the new basic block for the loop header, inserting after current
   // block.
-  BasicBlock *LoopBB = BasicBlock::Create(getGlobalContext(), "loop", TheFunction);
+  BasicBlock *LoopBB = BasicBlock::Create(TheContext, "loop", TheFunction);
 
   // Insert an explicit fall through from the current block to the LoopBB.
   Builder.CreateBr(LoopBB);
 
   // Start insertion in LoopBB.
   Builder.SetInsertPoint(LoopBB);
 
   // Within the loop, the variable is defined equal to the PHI node.  If it
Value *ForExprAST::Codegen() {
 
   // Emit the step value.
   Value *StepVal;
   if (Step) {
     StepVal = Step->Codegen();
     if (StepVal == 0) return 0;
   } else {
     // If not specified, use 1.0.
-    StepVal = ConstantFP::get(getGlobalContext(), APFloat(1.0));
+    StepVal = ConstantFP::get(TheContext, APFloat(1.0));
   }
 
   // Compute the end condition.
   Value *EndCond = End->Codegen();
   if (EndCond == 0) return EndCond;
 
   // Reload, increment, and restore the alloca.  This handles the case where
   // the body of the loop mutates the variable.
   Value *CurVar = 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.
   EndCond = Builder.CreateFCmpONE(EndCond,
-                              ConstantFP::get(getGlobalContext(), APFloat(0.0)),
+                              ConstantFP::get(TheContext, APFloat(0.0)),
                                   "loopcond");
 
   // Create the "after loop" block and insert it.
-  BasicBlock *AfterBB = BasicBlock::Create(getGlobalContext(), "afterloop", TheFunction);
+  BasicBlock *AfterBB = 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);
 
   // Restore the unshadowed variable.
   if (OldVal)
     NamedValues[VarName] = OldVal;
   else
     NamedValues.erase(VarName);
 
 
   // for expr always returns 0.0.
-  return Constant::getNullValue(Type::getDoubleTy(getGlobalContext()));
+  return Constant::getNullValue(Type::getDoubleTy(TheContext));
 }
 
 Value *VarExprAST::Codegen() {
   std::vector<AllocaInst *> OldBindings;
 
   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;
 
     // 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 == 0) return 0;
     } else { // If not specified, use 0.0.
-      InitVal = ConstantFP::get(getGlobalContext(), 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]);
Value *VarExprAST::Codegen() {
 
   // Return the body computation.
   return BodyVal;
 }
 
 Function *PrototypeAST::Codegen() {
   // Make the function type:  double(double,double) etc.
   std::vector<Type*> Doubles(Args.size(),
-                             Type::getDoubleTy(getGlobalContext()));
-  FunctionType *FT = FunctionType::get(Type::getDoubleTy(getGlobalContext()),
+                             Type::getDoubleTy(TheContext));
+  FunctionType *FT = FunctionType::get(Type::getDoubleTy(TheContext),
                                        Doubles, false);
 
   std::string FnName = MakeLegalFunctionName(Name);
 
   Module* M = TheHelper->getModuleForNewFunction();
 
   Function *F = Function::Create(FT, Function::ExternalLinkage, FnName, M);
 
Function *FunctionAST::Codegen() {
   if (TheFunction == 0)
     return 0;
 
   // If this is an operator, install it.
   if (Proto->isBinaryOp())
     BinopPrecedence[Proto->getOperatorName()] = Proto->getBinaryPrecedence();
 
   // Create a new basic block to start insertion into.
-  BasicBlock *BB = BasicBlock::Create(getGlobalContext(), "entry", TheFunction);
+  BasicBlock *BB = BasicBlock::Create(TheContext, "entry", TheFunction);
   Builder.SetInsertPoint(BB);
 
   // Add all arguments to the symbol table and create their allocas.
   Proto->CreateArgumentAllocas(TheFunction);
 
   if (Value *RetVal = Body->Codegen()) {
     // Finish off the function.
     Builder.CreateRet(RetVal);

 //===----------------------------------------------------------------------===//
 // Main driver code.
 //===----------------------------------------------------------------------===//
 
 int main() {
   InitializeNativeTarget();
   InitializeNativeTargetAsmPrinter();
   InitializeNativeTargetAsmParser();
-  LLVMContext &Context = getGlobalContext();
+  LLVMContext &Context = TheContext;
 
   // Install standard binary operators.
   // 1 is lowest precedence.
   BinopPrecedence['='] = 2;
   BinopPrecedence['<'] = 10;
   BinopPrecedence['+'] = 20;
   BinopPrecedence['-'] = 20;
   BinopPrecedence['/'] = 40;

examples/Kaleidoscope/Orc/fully_lazy/toy.cpp

 }
 
 /// 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(getGlobalContext()), nullptr,
+  return TmpB.CreateAlloca(Type::getDoubleTy(TheFunction->getContext()), nullptr,
                            VarName.c_str());
 }
 
 Value *NumberExprAST::IRGen(IRGenContext &C) const {
   return ConstantFP::get(C.getLLVMContext(), APFloat(Val));
 }
 
 Value *VariableExprAST::IRGen(IRGenContext &C) const {
Value *BinaryExprAST::IRGen(IRGenContext &C) const {
   switch (Op) {
   case '+': return C.getBuilder().CreateFAdd(L, R, "addtmp");
   case '-': return C.getBuilder().CreateFSub(L, R, "subtmp");
   case '*': return C.getBuilder().CreateFMul(L, R, "multmp");
   case '/': return C.getBuilder().CreateFDiv(L, R, "divtmp");
   case '<':
     L = C.getBuilder().CreateFCmpULT(L, R, "cmptmp");
     // Convert bool 0/1 to double 0.0 or 1.0
-    return C.getBuilder().CreateUIToFP(L, Type::getDoubleTy(getGlobalContext()),
+    return C.getBuilder().CreateUIToFP(L, Type::getDoubleTy(C.getLLVMContext()),
                                 "booltmp");
   default: break;
   }
 
   // If it wasn't a builtin binary operator, it must be a user defined one. Emit
   // a call to it.
   std::string FnName = MakeLegalFunctionName(std::string("binary")+Op);
   if (Function *F = C.getPrototype(FnName)) {
Value *IfExprAST::IRGen(IRGenContext &C) const {
 
   C.getBuilder().CreateBr(MergeBB);
   // Codegen of 'Else' can change the current block, update ElseBB for the PHI.
   ElseBB = C.getBuilder().GetInsertBlock();
 
   // Emit merge block.
   TheFunction->getBasicBlockList().push_back(MergeBB);
   C.getBuilder().SetInsertPoint(MergeBB);
-  PHINode *PN = C.getBuilder().CreatePHI(Type::getDoubleTy(getGlobalContext()), 2,
+  PHINode *PN = C.getBuilder().CreatePHI(Type::getDoubleTy(C.getLLVMContext()), 2,
                                   "iftmp");
 
   PN->addIncoming(ThenV, ThenBB);
   PN->addIncoming(ElseV, ElseBB);
   return PN;
 }
 
 Value *ForExprAST::IRGen(IRGenContext &C) const {
Value *ForExprAST::IRGen(IRGenContext &C) const {
   Value *StartVal = Start->IRGen(C);
   if (!StartVal) return nullptr;
 
   // Store the value into the alloca.
   C.getBuilder().CreateStore(StartVal, Alloca);
 
   // Make the new basic block for the loop header, inserting after current
   // block.
-  BasicBlock *LoopBB = BasicBlock::Create(getGlobalContext(), "loop", TheFunction);
+  BasicBlock *LoopBB = BasicBlock::Create(C.getLLVMContext(), "loop", TheFunction);
 
   // Insert an explicit fall through from the current block to the LoopBB.
   C.getBuilder().CreateBr(LoopBB);
 
   // Start insertion in LoopBB.
   C.getBuilder().SetInsertPoint(LoopBB);
 
   // Within the loop, the variable is defined equal to the PHI node.  If it
Value *ForExprAST::IRGen(IRGenContext &C) const {
 
   // Emit the step value.
   Value *StepVal;
   if (Step) {
     StepVal = Step->IRGen(C);
     if (!StepVal) return nullptr;
   } else {
     // If not specified, use 1.0.
-    StepVal = ConstantFP::get(getGlobalContext(), APFloat(1.0));
+    StepVal = ConstantFP::get(C.getLLVMContext(), APFloat(1.0));
   }
 
   // Compute the end condition.
   Value *EndCond = End->IRGen(C);
   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 = C.getBuilder().CreateLoad(Alloca, VarName.c_str());
   Value *NextVar = C.getBuilder().CreateFAdd(CurVar, StepVal, "nextvar");
   C.getBuilder().CreateStore(NextVar, Alloca);
 
   // Convert condition to a bool by comparing equal to 0.0.
   EndCond = C.getBuilder().CreateFCmpONE(EndCond,
-                              ConstantFP::get(getGlobalContext(), APFloat(0.0)),
+                              ConstantFP::get(C.getLLVMContext(), APFloat(0.0)),
                                   "loopcond");
 
   // Create the "after loop" block and insert it.
-  BasicBlock *AfterBB = BasicBlock::Create(getGlobalContext(), "afterloop", TheFunction);
+  BasicBlock *AfterBB = BasicBlock::Create(C.getLLVMContext(), "afterloop", TheFunction);
 
   // Insert the conditional branch into the end of LoopEndBB.
   C.getBuilder().CreateCondBr(EndCond, LoopBB, AfterBB);
 
   // Any new code will be inserted in AfterBB.
   C.getBuilder().SetInsertPoint(AfterBB);
 
   // Restore the unshadowed variable.
   if (OldVal)
     C.NamedValues[VarName] = OldVal;
   else
     C.NamedValues.erase(VarName);
 
   // for expr always returns 0.0.
-  return Constant::getNullValue(Type::getDoubleTy(getGlobalContext()));
+  return Constant::getNullValue(Type::getDoubleTy(C.getLLVMContext()));
 }
 
 Value *VarExprAST::IRGen(IRGenContext &C) const {
   std::vector<AllocaInst *> OldBindings;
 
   Function *TheFunction = C.getBuilder().GetInsertBlock()->getParent();
 
   // Register all variables and emit their initializer.
   for (unsigned i = 0, e = VarBindings.size(); i != e; ++i) {
     auto &VarName = VarBindings[i].first;
     auto &Init = VarBindings[i].second;
 
     // Emit the initializer before adding the variable to scope, this prevents
     // the initializer from referencing the variable itself, and permits stuff
     // like this:
     //  var a = 1 in
     //    var a = a in ...   # refers to outer 'a'.
     Value *InitVal;
     if (Init) {
       InitVal = Init->IRGen(C);
       if (!InitVal) return nullptr;
     } else // If not specified, use 0.0.
-      InitVal = ConstantFP::get(getGlobalContext(), APFloat(0.0));
+      InitVal = ConstantFP::get(C.getLLVMContext(), APFloat(0.0));
 
     AllocaInst *Alloca = CreateEntryBlockAlloca(TheFunction, VarName);
     C.getBuilder().CreateStore(InitVal, Alloca);
 
     // Remember the old variable binding so that we can restore the binding when
     // we unrecurse.
     OldBindings.push_back(C.NamedValues[VarName]);
 
Value *VarExprAST::IRGen(IRGenContext &C) const {
   return BodyVal;
 }
 
 Function *PrototypeAST::IRGen(IRGenContext &C) const {
   std::string FnName = MakeLegalFunctionName(Name);
 
   // Make the function type:  double(double,double) etc.
   std::vector<Type*> Doubles(Args.size(),
-                             Type::getDoubleTy(getGlobalContext()));
-  FunctionType *FT = FunctionType::get(Type::getDoubleTy(getGlobalContext()),
+                             Type::getDoubleTy(C.getLLVMContext()));
+  FunctionType *FT = FunctionType::get(Type::getDoubleTy(C.getLLVMContext()),
                                        Doubles, false);
   Function *F = Function::Create(FT, Function::ExternalLinkage, FnName,
                                  &C.getM());
 
   // If F conflicted, there was already something named 'FnName'.  If it has a
   // body, don't allow redefinition or reextern.
   if (F->getName() != FnName) {
     // Delete the one we just made and get the existing one.
Function *FunctionAST::IRGen(IRGenContext &C) const {
   if (!TheFunction)
     return nullptr;
 
   // If this is an operator, install it.
   if (Proto->isBinaryOp())
     BinopPrecedence[Proto->getOperatorName()] = Proto->Precedence;
 
   // Create a new basic block to start insertion into.
-  BasicBlock *BB = BasicBlock::Create(getGlobalContext(), "entry", TheFunction);
+  BasicBlock *BB = BasicBlock::Create(C.getLLVMContext(), "entry", TheFunction);
   C.getBuilder().SetInsertPoint(BB);
 
   // Add all arguments to the symbol table and create their allocas.
   Proto->CreateArgumentAllocas(TheFunction, C);
 
   if (Value *RetVal = Body->IRGen(C)) {
     // Finish off the function.
     C.getBuilder().CreateRet(RetVal);
#endif
   } else {
     // Skip token for error recovery.
     getNextToken();
   }
 }
 
 /// top ::= definition | external | expression | ';'
 static void MainLoop() {
-  SessionContext S(getGlobalContext());
+  LLVMContext TheContext;
+  SessionContext S(TheContext);
   KaleidoscopeJIT J(S);
 
   while (1) {
     switch (CurTok) {
     case tok_eof:    return;
     case ';':        getNextToken(); continue;  // ignore top-level semicolons.
     case tok_def:    HandleDefinition(S, J); break;
     case tok_extern: HandleExtern(S); break;

examples/Kaleidoscope/Orc/initial/toy.cpp

 }
 
 /// 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(getGlobalContext()), nullptr,
+  return TmpB.CreateAlloca(Type::getDoubleTy(TheFunction->getContext()), nullptr,
                            VarName.c_str());
 }
 
 Value *NumberExprAST::IRGen(IRGenContext &C) const {
   return ConstantFP::get(C.getLLVMContext(), APFloat(Val));
 }
 
 Value *VariableExprAST::IRGen(IRGenContext &C) const {
Value *BinaryExprAST::IRGen(IRGenContext &C) const {
   switch (Op) {
   case '+': return C.getBuilder().CreateFAdd(L, R, "addtmp");
   case '-': return C.getBuilder().CreateFSub(L, R, "subtmp");
   case '*': return C.getBuilder().CreateFMul(L, R, "multmp");
   case '/': return C.getBuilder().CreateFDiv(L, R, "divtmp");
   case '<':
     L = C.getBuilder().CreateFCmpULT(L, R, "cmptmp");
     // Convert bool 0/1 to double 0.0 or 1.0
-    return C.getBuilder().CreateUIToFP(L, Type::getDoubleTy(getGlobalContext()),
+    return C.getBuilder().CreateUIToFP(L, Type::getDoubleTy(C.getLLVMContext()),
                                 "booltmp");
   default: break;
   }
 
   // If it wasn't a builtin binary operator, it must be a user defined one. Emit
   // a call to it.
   std::string FnName = MakeLegalFunctionName(std::string("binary")+Op);
   if (Function *F = C.getPrototype(FnName)) {
Value *IfExprAST::IRGen(IRGenContext &C) const {
 
   C.getBuilder().CreateBr(MergeBB);
   // Codegen of 'Else' can change the current block, update ElseBB for the PHI.
   ElseBB = C.getBuilder().GetInsertBlock();
 
   // Emit merge block.
   TheFunction->getBasicBlockList().push_back(MergeBB);
   C.getBuilder().SetInsertPoint(MergeBB);
-  PHINode *PN = C.getBuilder().CreatePHI(Type::getDoubleTy(getGlobalContext()), 2,
+  PHINode *PN = C.getBuilder().CreatePHI(Type::getDoubleTy(C.getLLVMContext()), 2,
                                   "iftmp");
 
   PN->addIncoming(ThenV, ThenBB);
   PN->addIncoming(ElseV, ElseBB);
   return PN;
 }
 
 Value *ForExprAST::IRGen(IRGenContext &C) const {
Value *ForExprAST::IRGen(IRGenContext &C) const {
   Value *StartVal = Start->IRGen(C);
   if (!StartVal) return nullptr;
 
   // Store the value into the alloca.
   C.getBuilder().CreateStore(StartVal, Alloca);
 
   // Make the new basic block for the loop header, inserting after current
   // block.
-  BasicBlock *LoopBB = BasicBlock::Create(getGlobalContext(), "loop", TheFunction);
+  BasicBlock *LoopBB = BasicBlock::Create(C.getLLVMContext(), "loop", TheFunction);
 
   // Insert an explicit fall through from the current block to the LoopBB.
   C.getBuilder().CreateBr(LoopBB);
 
   // Start insertion in LoopBB.
   C.getBuilder().SetInsertPoint(LoopBB);
 
   // Within the loop, the variable is defined equal to the PHI node.  If it
Value *ForExprAST::IRGen(IRGenContext &C) const {
 
   // Emit the step value.
   Value *StepVal;
   if (Step) {
     StepVal = Step->IRGen(C);
     if (!StepVal) return nullptr;
   } else {
     // If not specified, use 1.0.
-    StepVal = ConstantFP::get(getGlobalContext(), APFloat(1.0));
+    StepVal = ConstantFP::get(C.getLLVMContext(), APFloat(1.0));
   }
 
   // Compute the end condition.
   Value *EndCond = End->IRGen(C);
   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 = C.getBuilder().CreateLoad(Alloca, VarName.c_str());
   Value *NextVar = C.getBuilder().CreateFAdd(CurVar, StepVal, "nextvar");
   C.getBuilder().CreateStore(NextVar, Alloca);
 
   // Convert condition to a bool by comparing equal to 0.0.
   EndCond = C.getBuilder().CreateFCmpONE(EndCond,
-                              ConstantFP::get(getGlobalContext(), APFloat(0.0)),
+                              ConstantFP::get(C.getLLVMContext(), APFloat(0.0)),
                                   "loopcond");
 
   // Create the "after loop" block and insert it.
-  BasicBlock *AfterBB = BasicBlock::Create(getGlobalContext(), "afterloop", TheFunction);
+  BasicBlock *AfterBB = BasicBlock::Create(C.getLLVMContext(), "afterloop", TheFunction);
 
   // Insert the conditional branch into the end of LoopEndBB.
   C.getBuilder().CreateCondBr(EndCond, LoopBB, AfterBB);
 
   // Any new code will be inserted in AfterBB.
   C.getBuilder().SetInsertPoint(AfterBB);
 
   // Restore the unshadowed variable.
   if (OldVal)
     C.NamedValues[VarName] = OldVal;
   else
     C.NamedValues.erase(VarName);
 
   // for expr always returns 0.0.
-  return Constant::getNullValue(Type::getDoubleTy(getGlobalContext()));
+  return Constant::getNullValue(Type::getDoubleTy(C.getLLVMContext()));
 }
 
 Value *VarExprAST::IRGen(IRGenContext &C) const {
   std::vector<AllocaInst *> OldBindings;
 
   Function *TheFunction = C.getBuilder().GetInsertBlock()->getParent();
 
   // Register all variables and emit their initializer.
   for (unsigned i = 0, e = VarBindings.size(); i != e; ++i) {
     auto &VarName = VarBindings[i].first;
     auto &Init = VarBindings[i].second;
 
     // Emit the initializer before adding the variable to scope, this prevents
     // the initializer from referencing the variable itself, and permits stuff
     // like this:
     //  var a = 1 in
     //    var a = a in ...   # refers to outer 'a'.
     Value *InitVal;
     if (Init) {
       InitVal = Init->IRGen(C);
       if (!InitVal) return nullptr;
     } else // If not specified, use 0.0.
-      InitVal = ConstantFP::get(getGlobalContext(), APFloat(0.0));
+      InitVal = ConstantFP::get(C.getLLVMContext(), APFloat(0.0));
 
     AllocaInst *Alloca = CreateEntryBlockAlloca(TheFunction, VarName);
     C.getBuilder().CreateStore(InitVal, Alloca);
 
     // Remember the old variable binding so that we can restore the binding when
     // we unrecurse.
     OldBindings.push_back(C.NamedValues[VarName]);
 
Value *VarExprAST::IRGen(IRGenContext &C) const {
   return BodyVal;
 }
 
 Function *PrototypeAST::IRGen(IRGenContext &C) const {
   std::string FnName = MakeLegalFunctionName(Name);
 
   // Make the function type:  double(double,double) etc.
   std::vector<Type*> Doubles(Args.size(),
-                             Type::getDoubleTy(getGlobalContext()));
-  FunctionType *FT = FunctionType::get(Type::getDoubleTy(getGlobalContext()),
+                             Type::getDoubleTy(C.getLLVMContext()));
+  FunctionType *FT = FunctionType::get(Type::getDoubleTy(C.getLLVMContext()),
                                        Doubles, false);
   Function *F = Function::Create(FT, Function::ExternalLinkage, FnName,
                                  &C.getM());
 
   // If F conflicted, there was already something named 'FnName'.  If it has a
   // body, don't allow redefinition or reextern.
   if (F->getName() != FnName) {
     // Delete the one we just made and get the existing one.
Function *FunctionAST::IRGen(IRGenContext &C) const {
   if (!TheFunction)
     return nullptr;
 
   // If this is an operator, install it.
   if (Proto->isBinaryOp())
     BinopPrecedence[Proto->getOperatorName()] = Proto->Precedence;
 
   // Create a new basic block to start insertion into.
-  BasicBlock *BB = BasicBlock::Create(getGlobalContext(), "entry", TheFunction);
+  BasicBlock *BB = BasicBlock::Create(C.getLLVMContext(), "entry", TheFunction);
   C.getBuilder().SetInsertPoint(BB);
 
   // Add all arguments to the symbol table and create their allocas.
   Proto->CreateArgumentAllocas(TheFunction, C);
 
   if (Value *RetVal = Body->IRGen(C)) {
     // Finish off the function.
     C.getBuilder().CreateRet(RetVal);
#endif
   } else {
     // Skip token for error recovery.
     getNextToken();
   }
 }
 
 /// top ::= definition | external | expression | ';'
 static void MainLoop() {
-  SessionContext S(getGlobalContext());
+  LLVMContext TheContext;
+  SessionContext S(TheContext);
   KaleidoscopeJIT J(S);
 
   while (1) {
     switch (CurTok) {
     case tok_eof:    return;
     case ';':        getNextToken(); continue;  // ignore top-level semicolons.
     case tok_def:    HandleDefinition(S, J); break;
     case tok_extern: HandleExtern(S); break;

examples/Kaleidoscope/Orc/lazy_codegen/toy.cpp

 }
 
 /// 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(getGlobalContext()), nullptr,
+  return TmpB.CreateAlloca(Type::getDoubleTy(TheFunction->getContext()), nullptr,
                            VarName.c_str());
 }
 
 Value *NumberExprAST::IRGen(IRGenContext &C) const {
   return ConstantFP::get(C.getLLVMContext(), APFloat(Val));
 }
 
 Value *VariableExprAST::IRGen(IRGenContext &C) const {
Value *BinaryExprAST::IRGen(IRGenContext &C) const {
   switch (Op) {
   case '+': return C.getBuilder().CreateFAdd(L, R, "addtmp");
   case '-': return C.getBuilder().CreateFSub(L, R, "subtmp");
   case '*': return C.getBuilder().CreateFMul(L, R, "multmp");
   case '/': return C.getBuilder().CreateFDiv(L, R, "divtmp");
   case '<':
     L = C.getBuilder().CreateFCmpULT(L, R, "cmptmp");
     // Convert bool 0/1 to double 0.0 or 1.0
-    return C.getBuilder().CreateUIToFP(L, Type::getDoubleTy(getGlobalContext()),
+    return C.getBuilder().CreateUIToFP(L, Type::getDoubleTy(C.getLLVMContext()),
                                 "booltmp");
   default: break;
   }
 
   // If it wasn't a builtin binary operator, it must be a user defined one. Emit
   // a call to it.
   std::string FnName = MakeLegalFunctionName(std::string("binary")+Op);
   if (Function *F = C.getPrototype(FnName)) {
Value *IfExprAST::IRGen(IRGenContext &C) const {
 
   C.getBuilder().CreateBr(MergeBB);
   // Codegen of 'Else' can change the current block, update ElseBB for the PHI.
   ElseBB = C.getBuilder().GetInsertBlock();
 
   // Emit merge block.
   TheFunction->getBasicBlockList().push_back(MergeBB);
   C.getBuilder().SetInsertPoint(MergeBB);
-  PHINode *PN = C.getBuilder().CreatePHI(Type::getDoubleTy(getGlobalContext()), 2,
+  PHINode *PN = C.getBuilder().CreatePHI(Type::getDoubleTy(C.getLLVMContext()), 2,
                                   "iftmp");
 
   PN->addIncoming(ThenV, ThenBB);
   PN->addIncoming(ElseV, ElseBB);
   return PN;
 }
 
 Value *ForExprAST::IRGen(IRGenContext &C) const {
Value *ForExprAST::IRGen(IRGenContext &C) const {
   Value *StartVal = Start->IRGen(C);
   if (!StartVal) return nullptr;
 
   // Store the value into the alloca.
   C.getBuilder().CreateStore(StartVal, Alloca);
 
   // Make the new basic block for the loop header, inserting after current
   // block.
-  BasicBlock *LoopBB = BasicBlock::Create(getGlobalContext(), "loop", TheFunction);
+  BasicBlock *LoopBB = BasicBlock::Create(C.getLLVMContext(), "loop", TheFunction);
 
   // Insert an explicit fall through from the current block to the LoopBB.
   C.getBuilder().CreateBr(LoopBB);
 
   // Start insertion in LoopBB.
   C.getBuilder().SetInsertPoint(LoopBB);
 
   // Within the loop, the variable is defined equal to the PHI node.  If it
Value *ForExprAST::IRGen(IRGenContext &C) const {
 
   // Emit the step value.
   Value *StepVal;
   if (Step) {
     StepVal = Step->IRGen(C);
     if (!StepVal) return nullptr;
   } else {
     // If not specified, use 1.0.
-    StepVal = ConstantFP::get(getGlobalContext(), APFloat(1.0));
+    StepVal = ConstantFP::get(C.getLLVMContext(), APFloat(1.0));
   }
 
   // Compute the end condition.
   Value *EndCond = End->IRGen(C);
   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 = C.getBuilder().CreateLoad(Alloca, VarName.c_str());
   Value *NextVar = C.getBuilder().CreateFAdd(CurVar, StepVal, "nextvar");
   C.getBuilder().CreateStore(NextVar, Alloca);
 
   // Convert condition to a bool by comparing equal to 0.0.
   EndCond = C.getBuilder().CreateFCmpONE(EndCond,
-                              ConstantFP::get(getGlobalContext(), APFloat(0.0)),
+                              ConstantFP::get(C.getLLVMContext(), APFloat(0.0)),
                                   "loopcond");
 
   // Create the "after loop" block and insert it.
-  BasicBlock *AfterBB = BasicBlock::Create(getGlobalContext(), "afterloop", TheFunction);
+  BasicBlock *AfterBB = BasicBlock::Create(C.getLLVMContext(), "afterloop", TheFunction);
 
   // Insert the conditional branch into the end of LoopEndBB.
   C.getBuilder().CreateCondBr(EndCond, LoopBB, AfterBB);
 
   // Any new code will be inserted in AfterBB.
   C.getBuilder().SetInsertPoint(AfterBB);
 
   // Restore the unshadowed variable.
   if (OldVal)
     C.NamedValues[VarName] = OldVal;
   else
     C.NamedValues.erase(VarName);
 
   // for expr always returns 0.0.
-  return Constant::getNullValue(Type::getDoubleTy(getGlobalContext()));
+  return Constant::getNullValue(Type::getDoubleTy(C.getLLVMContext()));
 }
 
 Value *VarExprAST::IRGen(IRGenContext &C) const {
   std::vector<AllocaInst *> OldBindings;
 
   Function *TheFunction = C.getBuilder().GetInsertBlock()->getParent();
 
   // Register all variables and emit their initializer.
   for (unsigned i = 0, e = VarBindings.size(); i != e; ++i) {
     auto &VarName = VarBindings[i].first;
     auto &Init = VarBindings[i].second;
 
     // Emit the initializer before adding the variable to scope, this prevents
     // the initializer from referencing the variable itself, and permits stuff
     // like this:
     //  var a = 1 in
     //    var a = a in ...   # refers to outer 'a'.
     Value *InitVal;
     if (Init) {
       InitVal = Init->IRGen(C);
       if (!InitVal) return nullptr;
     } else // If not specified, use 0.0.
-      InitVal = ConstantFP::get(getGlobalContext(), APFloat(0.0));
+      InitVal = ConstantFP::get(C.getLLVMContext(), APFloat(0.0));
 
     AllocaInst *Alloca = CreateEntryBlockAlloca(TheFunction, VarName);
     C.getBuilder().CreateStore(InitVal, Alloca);
 
     // Remember the old variable binding so that we can restore the binding when
     // we unrecurse.
     OldBindings.push_back(C.NamedValues[VarName]);
 
Value *VarExprAST::IRGen(IRGenContext &C) const {
   return BodyVal;
 }
 
 Function *PrototypeAST::IRGen(IRGenContext &C) const {
   std::string FnName = MakeLegalFunctionName(Name);
 
   // Make the function type:  double(double,double) etc.
   std::vector<Type*> Doubles(Args.size(),
-                             Type::getDoubleTy(getGlobalContext()));
-  FunctionType *FT = FunctionType::get(Type::getDoubleTy(getGlobalContext()),
+                             Type::getDoubleTy(C.getLLVMContext()));
+  FunctionType *FT = FunctionType::get(Type::getDoubleTy(C.getLLVMContext()),
                                        Doubles, false);
   Function *F = Function::Create(FT, Function::ExternalLinkage, FnName,
                                  &C.getM());
 
   // If F conflicted, there was already something named 'FnName'.  If it has a
   // body, don't allow redefinition or reextern.
   if (F->getName() != FnName) {
     // Delete the one we just made and get the existing one.
Function *FunctionAST::IRGen(IRGenContext &C) const {
   if (!TheFunction)
     return nullptr;
 
   // If this is an operator, install it.
   if (Proto->isBinaryOp())
     BinopPrecedence[Proto->getOperatorName()] = Proto->Precedence;
 
   // Create a new basic block to start insertion into.
-  BasicBlock *BB = BasicBlock::Create(getGlobalContext(), "entry", TheFunction);
+  BasicBlock *BB = BasicBlock::Create(C.getLLVMContext(), "entry", TheFunction);
   C.getBuilder().SetInsertPoint(BB);
 
   // Add all arguments to the symbol table and create their allocas.
   Proto->CreateArgumentAllocas(TheFunction, C);
 
   if (Value *RetVal = Body->IRGen(C)) {
     // Finish off the function.
     C.getBuilder().CreateRet(RetVal);
#endif
   } else {
     // Skip token for error recovery.
     getNextToken();
   }
 }
 
 /// top ::= definition | external | expression | ';'
 static void MainLoop() {
-  SessionContext S(getGlobalContext());
+  LLVMContext TheContext;
+  SessionContext S(TheContext);
   KaleidoscopeJIT J(S);
 
   while (1) {
     switch (CurTok) {
     case tok_eof:    return;
     case ';':        getNextToken(); continue;  // ignore top-level semicolons.
     case tok_def:    HandleDefinition(S, J); break;
     case tok_extern: HandleExtern(S); break;

examples/Kaleidoscope/Orc/lazy_irgen/toy.cpp

 }
 
 /// 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(getGlobalContext()), nullptr,
+  return TmpB.CreateAlloca(Type::getDoubleTy(TheFunction->getContext()), nullptr,
                            VarName.c_str());
 }
 
 Value *NumberExprAST::IRGen(IRGenContext &C) const {
   return ConstantFP::get(C.getLLVMContext(), APFloat(Val));
 }
 
 Value *VariableExprAST::IRGen(IRGenContext &C) const {
Value *BinaryExprAST::IRGen(IRGenContext &C) const {
   switch (Op) {
   case '+': return C.getBuilder().CreateFAdd(L, R, "addtmp");
   case '-': return C.getBuilder().CreateFSub(L, R, "subtmp");
   case '*': return C.getBuilder().CreateFMul(L, R, "multmp");
   case '/': return C.getBuilder().CreateFDiv(L, R, "divtmp");
   case '<':
     L = C.getBuilder().CreateFCmpULT(L, R, "cmptmp");
     // Convert bool 0/1 to double 0.0 or 1.0
-    return C.getBuilder().CreateUIToFP(L, Type::getDoubleTy(getGlobalContext()),
+    return C.getBuilder().CreateUIToFP(L, Type::getDoubleTy(C.getLLVMContext()),
                                 "booltmp");
   default: break;
   }
 
   // If it wasn't a builtin binary operator, it must be a user defined one. Emit
   // a call to it.
   std::string FnName = MakeLegalFunctionName(std::string("binary")+Op);
   if (Function *F = C.getPrototype(FnName)) {
Value *IfExprAST::IRGen(IRGenContext &C) const {
 
   C.getBuilder().CreateBr(MergeBB);
   // Codegen of 'Else' can change the current block, update ElseBB for the PHI.
   ElseBB = C.getBuilder().GetInsertBlock();
 
   // Emit merge block.
   TheFunction->getBasicBlockList().push_back(MergeBB);
   C.getBuilder().SetInsertPoint(MergeBB);
-  PHINode *PN = C.getBuilder().CreatePHI(Type::getDoubleTy(getGlobalContext()), 2,
+  PHINode *PN = C.getBuilder().CreatePHI(Type::getDoubleTy(C.getLLVMContext()), 2,
                                   "iftmp");
 
   PN->addIncoming(ThenV, ThenBB);
   PN->addIncoming(ElseV, ElseBB);
   return PN;
 }
 
 Value *ForExprAST::IRGen(IRGenContext &C) const {
Value *ForExprAST::IRGen(IRGenContext &C) const {
   Value *StartVal = Start->IRGen(C);
   if (!StartVal) return nullptr;
 
   // Store the value into the alloca.
   C.getBuilder().CreateStore(StartVal, Alloca);
 
   // Make the new basic block for the loop header, inserting after current
   // block.
-  BasicBlock *LoopBB = BasicBlock::Create(getGlobalContext(), "loop", TheFunction);
+  BasicBlock *LoopBB = BasicBlock::Create(C.getLLVMContext(), "loop", TheFunction);
 
   // Insert an explicit fall through from the current block to the LoopBB.
   C.getBuilder().CreateBr(LoopBB);
 
   // Start insertion in LoopBB.
   C.getBuilder().SetInsertPoint(LoopBB);
 
   // Within the loop, the variable is defined equal to the PHI node.  If it
Value *ForExprAST::IRGen(IRGenContext &C) const {
 
   // Emit the step value.
   Value *StepVal;
   if (Step) {
     StepVal = Step->IRGen(C);
     if (!StepVal) return nullptr;
   } else {
     // If not specified, use 1.0.
-    StepVal = ConstantFP::get(getGlobalContext(), APFloat(1.0));
+    StepVal = ConstantFP::get(C.getLLVMContext(), APFloat(1.0));
   }
 
   // Compute the end condition.
   Value *EndCond = End->IRGen(C);
   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 = C.getBuilder().CreateLoad(Alloca, VarName.c_str());
   Value *NextVar = C.getBuilder().CreateFAdd(CurVar, StepVal, "nextvar");
   C.getBuilder().CreateStore(NextVar, Alloca);
 
   // Convert condition to a bool by comparing equal to 0.0.
   EndCond = C.getBuilder().CreateFCmpONE(EndCond,
-                              ConstantFP::get(getGlobalContext(), APFloat(0.0)),
+                              ConstantFP::get(C.getLLVMContext(), APFloat(0.0)),
                                   "loopcond");
 
   // Create the "after loop" block and insert it.
-  BasicBlock *AfterBB = BasicBlock::Create(getGlobalContext(), "afterloop", TheFunction);
+  BasicBlock *AfterBB = BasicBlock::Create(C.getLLVMContext(), "afterloop", TheFunction);
 
   // Insert the conditional branch into the end of LoopEndBB.
   C.getBuilder().CreateCondBr(EndCond, LoopBB, AfterBB);
 
   // Any new code will be inserted in AfterBB.
   C.getBuilder().SetInsertPoint(AfterBB);
 
   // Restore the unshadowed variable.
   if (OldVal)
     C.NamedValues[VarName] = OldVal;
   else
     C.NamedValues.erase(VarName);
 
   // for expr always returns 0.0.
-  return Constant::getNullValue(Type::getDoubleTy(getGlobalContext()));
+  return Constant::getNullValue(Type::getDoubleTy(C.getLLVMContext()));
 }
 
 Value *VarExprAST::IRGen(IRGenContext &C) const {
   std::vector<AllocaInst *> OldBindings;
 
   Function *TheFunction = C.getBuilder().GetInsertBlock()->getParent();
 
   // Register all variables and emit their initializer.
   for (unsigned i = 0, e = VarBindings.size(); i != e; ++i) {
     auto &VarName = VarBindings[i].first;
     auto &Init = VarBindings[i].second;
 
     // Emit the initializer before adding the variable to scope, this prevents
     // the initializer from referencing the variable itself, and permits stuff
     // like this:
     //  var a = 1 in
     //    var a = a in ...   # refers to outer 'a'.
     Value *InitVal;
     if (Init) {
       InitVal = Init->IRGen(C);
       if (!InitVal) return nullptr;
     } else // If not specified, use 0.0.
-      InitVal = ConstantFP::get(getGlobalContext(), APFloat(0.0));
+      InitVal = ConstantFP::get(C.getLLVMContext(), APFloat(0.0));
 
     AllocaInst *Alloca = CreateEntryBlockAlloca(TheFunction, VarName);
     C.getBuilder().CreateStore(InitVal, Alloca);
 
     // Remember the old variable binding so that we can restore the binding when
     // we unrecurse.
     OldBindings.push_back(C.NamedValues[VarName]);
 
Value *VarExprAST::IRGen(IRGenContext &C) const {
   return BodyVal;
 }
 
 Function *PrototypeAST::IRGen(IRGenContext &C) const {
   std::string FnName = MakeLegalFunctionName(Name);
 
   // Make the function type:  double(double,double) etc.
   std::vector<Type*> Doubles(Args.size(),
-                             Type::getDoubleTy(getGlobalContext()));
-  FunctionType *FT = FunctionType::get(Type::getDoubleTy(getGlobalContext()),
+                             Type::getDoubleTy(C.getLLVMContext()));
+  FunctionType *FT = FunctionType::get(Type::getDoubleTy(C.getLLVMContext()),
                                        Doubles, false);
   Function *F = Function::Create(FT, Function::ExternalLinkage, FnName,
                                  &C.getM());
 
   // If F conflicted, there was already something named 'FnName'.  If it has a
   // body, don't allow redefinition or reextern.
   if (F->getName() != FnName) {
     // Delete the one we just made and get the existing one.
Function *FunctionAST::IRGen(IRGenContext &C) const {
   if (!TheFunction)
     return nullptr;
 
   // If this is an operator, install it.
   if (Proto->isBinaryOp())
     BinopPrecedence[Proto->getOperatorName()] = Proto->Precedence;
 
   // Create a new basic block to start insertion into.
-  BasicBlock *BB = BasicBlock::Create(getGlobalContext(), "entry", TheFunction);
+  BasicBlock *BB = BasicBlock::Create(C.getLLVMContext(), "entry", TheFunction);
   C.getBuilder().SetInsertPoint(BB);
 
   // Add all arguments to the symbol table and create their allocas.
   Proto->CreateArgumentAllocas(TheFunction, C);
 
   if (Value *RetVal = Body->IRGen(C)) {
     // Finish off the function.
     C.getBuilder().CreateRet(RetVal);
#endif
   } else {
     // Skip token for error recovery.
     getNextToken();
   }
 }
 
 /// top ::= definition | external | expression | ';'
 static void MainLoop() {
-  SessionContext S(getGlobalContext());
+  LLVMContext TheContext;
+  SessionContext S(TheContext);
   KaleidoscopeJIT J(S);
 
   while (1) {
     switch (CurTok) {
     case tok_eof:    return;
     case ';':        getNextToken(); continue;  // ignore top-level semicolons.
     case tok_def:    HandleDefinition(S, J); break;
     case tok_extern: HandleExtern(S); break;

include/llvm/IR/LLVMContext.h

private:
 
   /// removeModule - Unregister a module from this context.
   void removeModule(Module*);
 
   // Module needs access to the add/removeModule methods.
   friend class Module;
 };
 
-/// getGlobalContext - Returns a global context.  This is for LLVM clients that
-/// only care about operating on a single thread.
-extern LLVMContext &getGlobalContext();
-
 // Create wrappers for C Binding types (see CBindingWrapping.h).
 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(LLVMContext, LLVMContextRef)
 
 /* Specialized opaque context conversions.
  */
 inline LLVMContext **unwrap(LLVMContextRef* Tys) {
   return reinterpret_cast<LLVMContext**>(Tys);
 }
 
 inline LLVMContextRef *wrap(const LLVMContext **Tys) {
   return reinterpret_cast<LLVMContextRef*>(const_cast<LLVMContext**>(Tys));
 }
 
 }
 
 #endif

include/llvm/LinkAllIR.h

namespace {
   struct ForceVMCoreLinking {
     ForceVMCoreLinking() {
       // We must reference VMCore in such a way that compilers will not
       // delete it all as dead code, even with whole program optimization,
       // yet is effectively a NO-OP. As the compiler isn't smart enough
       // to know that getenv() never returns -1, this will do the job.
       if (std::getenv("bar") != (char*) -1)
         return;
-      (void)new llvm::Module("", llvm::getGlobalContext());
-      (void)new llvm::UnreachableInst(llvm::getGlobalContext());
+      llvm::LLVMContext Context;
+      (void)new llvm::Module("", Context);
+      (void)new llvm::UnreachableInst(Context);
       (void)    llvm::createVerifierPass(); 
     }
   } ForceVMCoreLinking;
 }
 
 #endif

lib/Bitcode/Reader/BitReader.cpp

 
 using namespace llvm;
 
 /* Builds a module from the bitcode in the specified memory buffer, returning a
    reference to the module via the OutModule parameter. Returns 0 on success.
    Optionally returns a human-readable error message via OutMessage. */
 LLVMBool LLVMParseBitcode(LLVMMemoryBufferRef MemBuf, LLVMModuleRef *OutModule,
                           char **OutMessage) {
-  return LLVMParseBitcodeInContext(wrap(&getGlobalContext()), MemBuf, OutModule,
+  return LLVMParseBitcodeInContext(LLVMGetGlobalContext(), MemBuf, OutModule,
                                    OutMessage);
 }
 
 LLVMBool LLVMParseBitcode2(LLVMMemoryBufferRef MemBuf,
                            LLVMModuleRef *OutModule) {
-  return LLVMParseBitcodeInContext2(wrap(&getGlobalContext()), MemBuf,
+  return LLVMParseBitcodeInContext2(LLVMGetGlobalContext(), MemBuf,
                                     OutModule);
 }
 
 static void diagnosticHandler(const DiagnosticInfo &DI, void *C) {
   auto *Message = reinterpret_cast<std::string *>(C);
   raw_string_ostream Stream(*Message);
   DiagnosticPrinterRawOStream DP(Stream);
   DI.print(DP);

lib/IR/Core.cpp

 
 void LLVMDisposeMessage(char *Message) {
   free(Message);
 }
 
 
 /*===-- Operations on contexts --------------------------------------------===*/
 
+static ManagedStatic<LLVMContext> GlobalContext;
+
 LLVMContextRef LLVMContextCreate() {
   return wrap(new LLVMContext());
 }
 
 LLVMContextRef LLVMGetGlobalContext() {
-  return wrap(&getGlobalContext());
+  return wrap(&*GlobalContext);
 }
 
 void LLVMContextSetDiagnosticHandler(LLVMContextRef C,
                                      LLVMDiagnosticHandler Handler,
                                      void *DiagnosticContext) {
   unwrap(C)->setDiagnosticHandler(
       LLVM_EXTENSION reinterpret_cast<LLVMContext::DiagnosticHandlerTy>(
           Handler),
LLVMDiagnosticSeverity LLVMGetDiagInfoSeverity(LLVMDiagnosticInfoRef DI) {
 
     return severity;
 }
 
 
 /*===-- Operations on modules ---------------------------------------------===*/
 
 LLVMModuleRef LLVMModuleCreateWithName(const char *ModuleID) {
-  return wrap(new Module(ModuleID, getGlobalContext()));
+  return wrap(new Module(ModuleID, *GlobalContext));
 }
 
 LLVMModuleRef LLVMModuleCreateWithNameInContext(const char *ModuleID,
                                                 LLVMContextRef C) {
   return wrap(new Module(ModuleID, *unwrap(C)));
 }
 
 void LLVMDisposeModule(LLVMModuleRef M) {

lib/IR/LLVMContext.cpp

 #include "llvm/IR/DiagnosticPrinter.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/SourceMgr.h"
 #include <cctype>
 using namespace llvm;
 
-static ManagedStatic<LLVMContext> GlobalContext;
-
-LLVMContext& llvm::getGlobalContext() {
-  return *GlobalContext;
-}
-
 LLVMContext::LLVMContext() : pImpl(new LLVMContextImpl(*this)) {
   // Create the fixed metadata kinds. This is done in the same order as the
   // MD_* enum values so that they correspond.
 
   // Create the 'dbg' metadata kind.
   unsigned DbgID = getMDKindID("dbg");
   assert(DbgID == MD_dbg && "dbg kind id drifted"); (void)DbgID;
 

lib/Target/CppBackend/CPPBackend.cpp

void CppWriter::printProgram(const std::string& fname,
   Out << "#include <llvm/IR/Instructions.h>\n";
   Out << "#include <llvm/IR/LLVMContext.h>\n";
   Out << "#include <llvm/IR/LegacyPassManager.h>\n";
   Out << "#include <llvm/IR/Module.h>\n";
   Out << "#include <llvm/Support/FormattedStream.h>\n";
   Out << "#include <llvm/Support/MathExtras.h>\n";
   Out << "#include <algorithm>\n";
   Out << "using namespace llvm;\n\n";
+  Out << "static LLVMContext TheContext;\n\n";
   Out << "Module* " << fname << "();\n\n";
   Out << "int main(int argc, char**argv) {\n";
   Out << "  Module* Mod = " << fname << "();\n";
   Out << "  verifyModule(*Mod, PrintMessageAction);\n";
   Out << "  PassManager PM;\n";
   Out << "  PM.add(createPrintModulePass(&outs()));\n";
   Out << "  PM.run(*Mod);\n";
   Out << "  return 0;\n";
   Out << "}\n\n";
   printModule(fname,mName);
 }
 
 void CppWriter::printModule(const std::string& fname,
                             const std::string& mName) {
   nl(Out) << "Module* " << fname << "() {";
   nl(Out,1) << "// Module Construction";
   nl(Out) << "Module* mod = new Module(\"";
   printEscapedString(mName);
-  Out << "\", getGlobalContext());";
+  Out << "\", TheContext);";
   if (!TheModule->getTargetTriple().empty()) {
     nl(Out) << "mod->setDataLayout(\"" << TheModule->getDataLayoutStr()
             << "\");";
   }
   if (!TheModule->getTargetTriple().empty()) {
     nl(Out) << "mod->setTargetTriple(\"" << TheModule->getTargetTriple()
             << "\");";
   }

lib/Target/Target.cpp

 //===-- Target.cpp --------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the common infrastructure (including C bindings) for 
 // libLLVMTarget.a, which implements target information.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm-c/Target.h"
 #include "llvm-c/Initialization.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Value.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/IR/LegacyPassManager.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include <cstring>
 
 using namespace llvm;
 
+// Avoid including "llvm-c/Core.h" for compile time, fwd-declare this instead.
+extern "C" LLVMContextRef LLVMGetGlobalContext(void);
+
 inline TargetLibraryInfoImpl *unwrap(LLVMTargetLibraryInfoRef P) {
   return reinterpret_cast<TargetLibraryInfoImpl*>(P);
 }
 
 inline LLVMTargetLibraryInfoRef wrap(const TargetLibraryInfoImpl *P) {
   TargetLibraryInfoImpl *X = const_cast<TargetLibraryInfoImpl*>(P);
   return reinterpret_cast<LLVMTargetLibraryInfoRef>(X);
 }
unsigned LLVMPointerSize(LLVMTargetDataRef TD) {
   return unwrap(TD)->getPointerSize(0);
 }
 
 unsigned LLVMPointerSizeForAS(LLVMTargetDataRef TD, unsigned AS) {
   return unwrap(TD)->getPointerSize(AS);
 }
 
 LLVMTypeRef LLVMIntPtrType(LLVMTargetDataRef TD) {
-  return wrap(unwrap(TD)->getIntPtrType(getGlobalContext()));
+  return wrap(unwrap(TD)->getIntPtrType(*unwrap(LLVMGetGlobalContext())));
 }
 
 LLVMTypeRef LLVMIntPtrTypeForAS(LLVMTargetDataRef TD, unsigned AS) {
-  return wrap(unwrap(TD)->getIntPtrType(getGlobalContext(), AS));
+  return wrap(unwrap(TD)->getIntPtrType(*unwrap(LLVMGetGlobalContext()), AS));
 }
 
 LLVMTypeRef LLVMIntPtrTypeInContext(LLVMContextRef C, LLVMTargetDataRef TD) {
   return wrap(unwrap(TD)->getIntPtrType(*unwrap(C)));
 }
 
 LLVMTypeRef LLVMIntPtrTypeForASInContext(LLVMContextRef C, LLVMTargetDataRef TD, unsigned AS) {
   return wrap(unwrap(TD)->getIntPtrType(*unwrap(C), AS));

tools/bugpoint/bugpoint.cpp

#endif
   cl::ParseCommandLineOptions(argc, argv,
                               "LLVM automatic testcase reducer. See\nhttp://"
                               "llvm.org/cmds/bugpoint.html"
                               " for more information.\n");
 #ifndef DEBUG_BUGPOINT
   sys::SetInterruptFunction(BugpointInterruptFunction);
 #endif
 
-  LLVMContext& Context = getGlobalContext();
+  LLVMContext Context;
   // If we have an override, set it and then track the triple we want Modules
   // to use.
   if (!OverrideTriple.empty()) {
     TargetTriple.setTriple(Triple::normalize(OverrideTriple));
     outs() << "Override triple set to '" << TargetTriple.getTriple() << "'\n";
   }
 
   if (MemoryLimit < 0) {

tools/llc/llc.cpp

 //
 int main(int argc, char **argv) {
   sys::PrintStackTraceOnErrorSignal();
   PrettyStackTraceProgram X(argc, argv);
 
   // Enable debug stream buffering.
   EnableDebugBuffering = true;
 
-  LLVMContext &Context = getGlobalContext();
+  LLVMContext Context;
   llvm_shutdown_obj Y;  // Call llvm_shutdown() on exit.
 
   // Initialize targets first, so that --version shows registered targets.
   InitializeAllTargets();
   InitializeAllTargetMCs();
   InitializeAllAsmPrinters();
   InitializeAllAsmParsers();
 

tools/lli/lli.cpp

 
 //===----------------------------------------------------------------------===//
 // main Driver function
 //
 int main(int argc, char **argv, char * const *envp) {
   sys::PrintStackTraceOnErrorSignal();
   PrettyStackTraceProgram X(argc, argv);
 
-  LLVMContext &Context = getGlobalContext();
+  LLVMContext Context;
   atexit(do_shutdown);  // Call llvm_shutdown() on exit.
 
   // If we have a native target, initialize it to ensure it is linked in and
   // usable by the JIT.
   InitializeNativeTarget();
   InitializeNativeTargetAsmPrinter();
   InitializeNativeTargetAsmParser();
 

tools/llvm-as-fuzzer/llvm-as-fuzzer.cpp

extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {
   // Allocate space for locals before setjmp so that memory can be collected
   // if parse exits prematurely (via longjmp).
   StringRef Input((const char *)Data, Size);
   // Note: We need to create a buffer to add a null terminator to the
   // end of the input string. The parser assumes that the string
   // parsed is always null terminated.
   std::unique_ptr<MemoryBuffer> MemBuf = MemoryBuffer::getMemBufferCopy(Input);
   SMDiagnostic Err;
-  LLVMContext &Context = getGlobalContext();
+  LLVMContext Context;
   std::unique_ptr<Module> M;
 
   if (setjmp(JmpBuf))
     // If reached, we have returned with non-zero status, so exit.
     return 0;
 
   // TODO(kschimpf) Write a main to do this initialization.
   if (!InstalledHandler) {

tools/llvm-as/llvm-as.cpp

static void WriteOutputFile(const Module *M) {
   // Declare success.
   Out->keep();
 }
 
 int main(int argc, char **argv) {
   // Print a stack trace if we signal out.
   sys::PrintStackTraceOnErrorSignal();
   PrettyStackTraceProgram X(argc, argv);
-  LLVMContext &Context = getGlobalContext();
+  LLVMContext Context;
   llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
   cl::ParseCommandLineOptions(argc, argv, "llvm .ll -> .bc assembler\n");
 
   // Parse the file now...
   SMDiagnostic Err;
   std::unique_ptr<Module> M = parseAssemblyFile(InputFilename, Err, Context);
   if (!M.get()) {
     Err.print(argv[0], errs());

tools/llvm-dis/llvm-dis.cpp

if (DI.getSeverity() == DS_Error)
     exit(1);
 }
 
 int main(int argc, char **argv) {
   // Print a stack trace if we signal out.
   sys::PrintStackTraceOnErrorSignal();
   PrettyStackTraceProgram X(argc, argv);
 
-  LLVMContext &Context = getGlobalContext();
+  LLVMContext Context;
   llvm_shutdown_obj Y;  // Call llvm_shutdown() on exit.
 
   Context.setDiagnosticHandler(diagnosticHandler, argv[0]);
 
   cl::ParseCommandLineOptions(argc, argv, "llvm .bc -> .ll disassembler\n");
 
   std::string ErrorMessage;
   std::unique_ptr<Module> M;

tools/llvm-extract/llvm-extract.cpp

static cl::opt<bool> PreserveAssemblyUseListOrder(
     cl::desc("Preserve use-list order when writing LLVM assembly."),
     cl::init(false), cl::Hidden);
 
 int main(int argc, char **argv) {
   // Print a stack trace if we signal out.
   sys::PrintStackTraceOnErrorSignal();
   PrettyStackTraceProgram X(argc, argv);
 
-  LLVMContext &Context = getGlobalContext();
+  LLVMContext Context;
   llvm_shutdown_obj Y;  // Call llvm_shutdown() on exit.
   cl::ParseCommandLineOptions(argc, argv, "llvm extractor\n");
 
   // Use lazy loading, since we only care about selected global values.
   SMDiagnostic Err;
   std::unique_ptr<Module> M = getLazyIRFileModule(InputFilename, Err, Context);
 
   if (!M.get()) {

tools/llvm-jitlistener/llvm-jitlistener.cpp

 unsigned int GetNewMethodID(void) {
   static unsigned int id = 0;
   return ++id;
 }
 
 class JitEventListenerTest {
 protected:
   void InitEE(const std::string &IRFile) {
-    LLVMContext &Context = getGlobalContext();
-
     // If we have a native target, initialize it to ensure it is linked in and
     // usable by the JIT.
     InitializeNativeTarget();
     InitializeNativeTargetAsmPrinter();
 
     // Parse the bitcode...
     SMDiagnostic Err;
     std::unique_ptr<Module> TheModule(parseIRFile(IRFile, Err, Context));

tools/llvm-link/llvm-link.cpp

static bool linkFiles(const char *argv0, LLVMContext &Context, Linker &L,
   return true;
 }
 
 int main(int argc, char **argv) {
   // Print a stack trace if we signal out.
   sys::PrintStackTraceOnErrorSignal();
   PrettyStackTraceProgram X(argc, argv);
 
-  LLVMContext &Context = getGlobalContext();
+  LLVMContext Context;
   Context.setDiagnosticHandler(diagnosticHandlerWithContext, nullptr, true);
 
   llvm_shutdown_obj Y;  // Call llvm_shutdown() on exit.
   cl::ParseCommandLineOptions(argc, argv, "llvm linker\n");
 
   auto Composite = make_unique<Module>("llvm-link", Context);
   Linker L(*Composite);
 

tools/llvm-nm/llvm-nm.cpp

 }
 
 static void dumpSymbolNamesFromFile(std::string &Filename) {
   ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr =
       MemoryBuffer::getFileOrSTDIN(Filename);
   if (error(BufferOrErr.getError(), Filename))
     return;
 
-  LLVMContext &Context = getGlobalContext();
+  LLVMContext Context;
   Expected<std::unique_ptr<Binary>> BinaryOrErr = createBinary(
       BufferOrErr.get()->getMemBufferRef(), NoLLVMBitcode ? nullptr : &Context);
   if (!BinaryOrErr) {
     error(errorToErrorCode(BinaryOrErr.takeError()), Filename);
     return;
   }
   Binary &Bin = *BinaryOrErr.get();
 

tools/llvm-profdata/llvm-profdata.cpp

static void mergeSampleProfile(const WeightedFileVector &Inputs,
   auto WriterOrErr =
       SampleProfileWriter::create(OutputFilename, FormatMap[OutputFormat]);
   if (std::error_code EC = WriterOrErr.getError())
     exitWithErrorCode(EC, OutputFilename);
 
   auto Writer = std::move(WriterOrErr.get());
   StringMap<FunctionSamples> ProfileMap;
   SmallVector<std::unique_ptr<sampleprof::SampleProfileReader>, 5> Readers;
+  LLVMContext Context;
   for (const auto &Input : Inputs) {
     auto ReaderOrErr =
-        SampleProfileReader::create(Input.Filename, getGlobalContext());
+        SampleProfileReader::create(Input.Filename, Context);
     if (std::error_code EC = ReaderOrErr.getError())
       exitWithErrorCode(EC, Input.Filename);
 
     // We need to keep the readers around until after all the files are
     // read so that we do not lose the function names stored in each
     // reader's memory. The function names are needed to write out the
     // merged profile map.
     Readers.push_back(std::move(ReaderOrErr.get()));
static int showInstrProfile(std::string Filename, bool ShowCounts,
   }
   return 0;
 }
 
 static int showSampleProfile(std::string Filename, bool ShowCounts,
                              bool ShowAllFunctions, std::string ShowFunction,
                              raw_fd_ostream &OS) {
   using namespace sampleprof;
-  auto ReaderOrErr = SampleProfileReader::create(Filename, getGlobalContext());
+  LLVMContext Context;
+  auto ReaderOrErr = SampleProfileReader::create(Filename, Context);
   if (std::error_code EC = ReaderOrErr.getError())
     exitWithErrorCode(EC, Filename);
 
   auto Reader = std::move(ReaderOrErr.get());
   if (std::error_code EC = Reader->read())
     exitWithErrorCode(EC, Filename);
 
   if (ShowAllFunctions || ShowFunction.empty())

tools/llvm-split/llvm-split.cpp

 static cl::opt<unsigned> NumOutputs("j", cl::Prefix, cl::init(2),
                                     cl::desc("Number of output files"));
 
 static cl::opt<bool>
     PreserveLocals("preserve-locals", cl::Prefix, cl::init(false),
                    cl::desc("Split without externalizing locals"));
 
 int main(int argc, char **argv) {
-  LLVMContext &Context = getGlobalContext();
+  LLVMContext Context;
   SMDiagnostic Err;
   cl::ParseCommandLineOptions(argc, argv, "LLVM module splitter\n");
 
   std::unique_ptr<Module> M = parseIRFile(InputFilename, Err, Context);
 
   if (!M) {
     Err.print(argv[0], errs());
     return 1;

tools/llvm-stress/llvm-stress.cpp

static cl::opt<unsigned> SeedCL("seed",
   cl::desc("Seed used for randomness"), cl::init(0));
 static cl::opt<unsigned> SizeCL("size",
   cl::desc("The estimated size of the generated function (# of instrs)"),
   cl::init(100));
 static cl::opt<std::string>
 OutputFilename("o", cl::desc("Override output filename"),
                cl::value_desc("filename"));
 
+static LLVMContext Context;
+
 namespace cl {
 template <> class parser<Type*> final : public basic_parser<Type*> {
 public:
   parser(Option &O) : basic_parser(O) {}
 
   // Parse options as IR types. Return true on error.
   bool parse(Option &O, StringRef, StringRef Arg, Type *&Value) {
-    auto &Context = getGlobalContext();
     if      (Arg == "half")      Value = Type::getHalfTy(Context);
     else if (Arg == "fp128")     Value = Type::getFP128Ty(Context);
     else if (Arg == "x86_fp80")  Value = Type::getX86_FP80Ty(Context);
     else if (Arg == "ppc_fp128") Value = Type::getPPC_FP128Ty(Context);
     else if (Arg == "x86_mmx")   Value = Type::getX86_MMXTy(Context);
     else if (Arg.startswith("i")) {
       unsigned N = 0;
       Arg.drop_front().getAsInteger(10, N);

 int main(int argc, char **argv) {
   using namespace llvm;
 
   // Init LLVM, call llvm_shutdown() on exit, parse args, etc.
   PrettyStackTraceProgram X(argc, argv);
   cl::ParseCommandLineOptions(argc, argv, "llvm codegen stress-tester\n");
   llvm_shutdown_obj Y;
 
-  auto M = make_unique<Module>("/tmp/autogen.bc", getGlobalContext());
+  auto M = make_unique<Module>("/tmp/autogen.bc", Context);
   Function *F = GenEmptyFunction(M.get());
 
   // Pick an initial seed value
   Random R(SeedCL);
   // Generate lots of random instructions inside a single basic block.
   FillFunction(F, R);
   // Break the basic block into many loops.
   IntroduceControlFlow(F, R);

tools/lto/lto.cpp

#endif
 
     InitializeAllTargetInfos();
     InitializeAllTargets();
     InitializeAllTargetMCs();
     InitializeAllAsmParsers();
     InitializeAllAsmPrinters();
     InitializeAllDisassemblers();
 
-    LTOContext = &getGlobalContext();
+    static LLVMContext Context;
+    LTOContext = &Context;
     LTOContext->setDiagnosticHandler(diagnosticHandler, nullptr, true);
     initialized = true;
   }
 }
 
 namespace {
 
 static void handleLibLTODiagnostic(lto_codegen_diagnostic_severity_t Severity,

tools/opt/opt.cpp

 int main(int argc, char **argv) {
   sys::PrintStackTraceOnErrorSignal();
   llvm::PrettyStackTraceProgram X(argc, argv);
 
   // Enable debug stream buffering.
   EnableDebugBuffering = true;
 
   llvm_shutdown_obj Y;  // Call llvm_shutdown() on exit.
-  LLVMContext &Context = getGlobalContext();
+  LLVMContext Context;
 
   InitializeAllTargets();
   InitializeAllTargetMCs();
   InitializeAllAsmPrinters();
 
   // Initialize passes
   PassRegistry &Registry = *PassRegistry::getPassRegistry();
   initializeCore(Registry);

tools/verify-uselistorder/verify-uselistorder.cpp

 int main(int argc, char **argv) {
   sys::PrintStackTraceOnErrorSignal();
   llvm::PrettyStackTraceProgram X(argc, argv);
 
   // Enable debug stream buffering.
   EnableDebugBuffering = true;
 
   llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
-  LLVMContext &Context = getGlobalContext();
+  LLVMContext Context;
 
   cl::ParseCommandLineOptions(argc, argv,
                               "llvm tool to verify use-list order\n");
 
   SMDiagnostic Err;
 
   // Load the input module...
   std::unique_ptr<Module> M = parseIRFile(InputFilename, Err, Context);

unittests/Analysis/AliasAnalysisTest.cpp

TEST_F(AliasAnalysisTest, getModRefInfo) {
   EXPECT_EQ(AA.getModRefInfo(CmpXChg1, MemoryLocation()), MRI_ModRef);
   EXPECT_EQ(AA.getModRefInfo(CmpXChg1), MRI_ModRef);
   EXPECT_EQ(AA.getModRefInfo(AtomicRMW, MemoryLocation()), MRI_ModRef);
   EXPECT_EQ(AA.getModRefInfo(AtomicRMW), MRI_ModRef);
 }
 
 class AAPassInfraTest : public testing::Test {
 protected:
-  LLVMContext &C;
+  LLVMContext C;
   SMDiagnostic Err;
   std::unique_ptr<Module> M;
 
 public:
   AAPassInfraTest()
-      : C(getGlobalContext()),
-        M(parseAssemblyString("define i32 @f(i32* %x, i32* %y) {\n"
+      : M(parseAssemblyString("define i32 @f(i32* %x, i32* %y) {\n"
                               "entry:\n"
                               "  %lx = load i32, i32* %x\n"
                               "  %ly = load i32, i32* %y\n"
                               "  %sum = add i32 %lx, %ly\n"
                               "  ret i32 %sum\n"
                               "}\n",
                               Err, C)) {
     assert(M && "Failed to build the module!");

unittests/Analysis/BlockFrequencyInfoTest.cpp

 namespace llvm {
 namespace {
 
 class BlockFrequencyInfoTest : public testing::Test {
 protected:
   std::unique_ptr<BranchProbabilityInfo> BPI;
   std::unique_ptr<DominatorTree> DT;
   std::unique_ptr<LoopInfo> LI;
+  LLVMContext C;
 
   BlockFrequencyInfo buildBFI(Function &F) {
     DT.reset(new DominatorTree(F));
     LI.reset(new LoopInfo(*DT));
     BPI.reset(new BranchProbabilityInfo(F, *LI));
     return BlockFrequencyInfo(F, *BPI, *LI);
   }
   std::unique_ptr<Module> makeLLVMModule() {
     const char *ModuleStrig = "define i32 @f(i32 %x) {\n"
                               "bb0:\n"
                               "  %y1 = icmp eq i32 %x, 0 \n"
                               "  br i1 %y1, label %bb1, label %bb2 \n"
                               "bb1:\n"
                               "  br label %bb3\n"
                               "bb2:\n"
                               "  br label %bb3\n"
                               "bb3:\n"
                               "  %y2 = phi i32 [0, %bb1], [1, %bb2] \n"
                               "  ret i32 %y2\n"
                               "}\n";
-    LLVMContext &C = getGlobalContext();
     SMDiagnostic Err;
     return parseAssemblyString(ModuleStrig, Err, C);
   }
 };
 
 TEST_F(BlockFrequencyInfoTest, Basic) {
   auto M = makeLLVMModule();
   Function *F = M->getFunction("f");

unittests/Analysis/CFGTest.cpp

 namespace {
 
 // This fixture assists in running the isPotentiallyReachable utility four ways
 // and ensuring it produces the correct answer each time.
 class IsPotentiallyReachableTest : public testing::Test {
 protected:
   void ParseAssembly(const char *Assembly) {
     SMDiagnostic Error;
-    M = parseAssemblyString(Assembly, Error, getGlobalContext());
+    M = parseAssemblyString(Assembly, Error, Context);
 
     std::string errMsg;
     raw_string_ostream os(errMsg);
     Error.print("", os);
 
     // A failure here means that the test itself is buggy.
     if (!M)
       report_fatal_error(os.str().c_str());
void ExpectPath(bool ExpectedResult) {
 
     IsPotentiallyReachableTestPass *P =
         new IsPotentiallyReachableTestPass(ExpectedResult, A, B);
     legacy::PassManager PM;
     PM.add(P);
     PM.run(*M);
   }
 
+  LLVMContext Context;
   std::unique_ptr<Module> M;
   Instruction *A, *B;
 };
 
 }
 
 TEST_F(IsPotentiallyReachableTest, SameBlockNoPath) {
   ParseAssembly(

unittests/Analysis/CGSCCPassManagerTest.cpp

PreservedAnalyses run(Function &M) {
     return PreservedAnalyses::none();
   }
 
   static StringRef name() { return "TestFunctionPass"; }
 
   int &RunCount;
 };
 
-std::unique_ptr<Module> parseIR(const char *IR) {
-  LLVMContext &C = getGlobalContext();
+std::unique_ptr<Module> parseIR(LLVMContext &C, const char *IR) {
   SMDiagnostic Err;
   return parseAssemblyString(IR, Err, C);
 }
 
 class CGSCCPassManagerTest : public ::testing::Test {
 protected:
+  LLVMContext Context;
   std::unique_ptr<Module> M;
 
 public:
   CGSCCPassManagerTest()
-      : M(parseIR("define void @f() {\n"
+      : M(parseIR(Context,
+                  "define void @f() {\n"
                   "entry:\n"
                   "  call void @g()\n"
                   "  call void @h1()\n"
                   "  ret void\n"
                   "}\n"
                   "define void @g() {\n"
                   "entry:\n"
                   "  call void @g()\n"

unittests/Analysis/CallGraphTest.cpp

template <typename Ty> void canSpecializeGraphTraitsIterators(Ty *G) {
   // Should be able to iterate over immediate successors of a node.
   static_assert(std::is_same<decltype(*S), NodeTy *>::value,
                 "Node type does not match");
   static_assert(std::is_same<decltype(*F), NodeTy *>::value,
                 "Node type does not match");
 }
 
 TEST(CallGraphTest, GraphTraitsSpecialization) {
-  Module M("", getGlobalContext());
+  LLVMContext Context;
+  Module M("", Context);
   CallGraph CG(M);
 
   canSpecializeGraphTraitsIterators(&CG);
 }
 
 TEST(CallGraphTest, GraphTraitsConstSpecialization) {
-  Module M("", getGlobalContext());
+  LLVMContext Context;
+  Module M("", Context);
   CallGraph CG(M);
 
   canSpecializeGraphTraitsIterators(const_cast<const CallGraph *>(&CG));
 }
 }

unittests/Analysis/LazyCallGraphTest.cpp

 #include "llvm/Support/SourceMgr.h"
 #include "gtest/gtest.h"
 #include <memory>
 
 using namespace llvm;
 
 namespace {
 
-std::unique_ptr<Module> parseAssembly(const char *Assembly) {
+std::unique_ptr<Module> parseAssembly(LLVMContext &Context, const char *Assembly) {
   SMDiagnostic Error;
   std::unique_ptr<Module> M =
-      parseAssemblyString(Assembly, Error, getGlobalContext());
+      parseAssemblyString(Assembly, Error, Context);
 
   std::string ErrMsg;
   raw_string_ostream OS(ErrMsg);
   Error.print("", OS);
 
   // A failure here means that the test itself is buggy.
   if (!M)
     report_fatal_error(OS.str().c_str());
static const char DiamondOfTriangles[] =
      "}\n"
      "define void @d3() {\n"
      "entry:\n"
      "  call void @d1()\n"
      "  ret void\n"
      "}\n";
 
 TEST(LazyCallGraphTest, BasicGraphFormation) {
-  std::unique_ptr<Module> M = parseAssembly(DiamondOfTriangles);
+  LLVMContext Context;
+  std::unique_ptr<Module> M = parseAssembly(Context, DiamondOfTriangles);
   LazyCallGraph CG(*M);
 
   // The order of the entry nodes should be stable w.r.t. the source order of
   // the IR, and everything in our module is an entry node, so just directly
   // build variables for each node.
   auto I = CG.begin();
   LazyCallGraph::Node &A1 = (I++)->getNode(CG);
   EXPECT_EQ("a1", A1.getFunction().getName());

 static Function &lookupFunction(Module &M, StringRef Name) {
   for (Function &F : M)
     if (F.getName() == Name)
       return F;
   report_fatal_error("Couldn't find function!");
 }
 
 TEST(LazyCallGraphTest, BasicGraphMutation) {
-  std::unique_ptr<Module> M = parseAssembly(
+  LLVMContext Context;
+  std::unique_ptr<Module> M = parseAssembly(Context,
       "define void @a() {\n"
       "entry:\n"
       "  call void @b()\n"
       "  call void @c()\n"
       "  ret void\n"
       "}\n"
       "define void @b() {\n"
       "entry:\n"
TEST(LazyCallGraphTest, BasicGraphMutation) {
   CG.removeEdge(C, C.getFunction());
   EXPECT_EQ(0, std::distance(C.begin(), C.end()));
 
   CG.removeEdge(B, C.getFunction());
   EXPECT_EQ(0, std::distance(B.begin(), B.end()));
 }
 
 TEST(LazyCallGraphTest, InnerSCCFormation) {
-  std::unique_ptr<Module> M = parseAssembly(DiamondOfTriangles);
+  LLVMContext Context;
+  std::unique_ptr<Module> M = parseAssembly(Context, DiamondOfTriangles);
   LazyCallGraph CG(*M);
 
   // Now mutate the graph to connect every node into a single RefSCC to ensure
   // that our inner SCC formation handles the rest.
   CG.insertEdge(lookupFunction(*M, "d1"), lookupFunction(*M, "a1"),
                 LazyCallGraph::Edge::Ref);
 
   // Build vectors and sort them for the rest of the assertions to make them
TEST(LazyCallGraphTest, InnerSCCFormation) {
   EXPECT_EQ("a2", Nodes[1]);
   EXPECT_EQ("a3", Nodes[2]);
   Nodes.clear();
 
   EXPECT_EQ(RC.end(), J);
 }
 
 TEST(LazyCallGraphTest, MultiArmSCC) {
+  LLVMContext Context;
   // Two interlocking cycles. The really useful thing about this SCC is that it
   // will require Tarjan's DFS to backtrack and finish processing all of the
   // children of each node in the SCC. Since this involves call edges, both
   // Tarjan implementations will have to successfully navigate the structure.
-  std::unique_ptr<Module> M = parseAssembly(
+  std::unique_ptr<Module> M = parseAssembly(Context,
       "define void @f1() {\n"
       "entry:\n"
       "  call void @f2()\n"
       "  call void @f4()\n"
       "  ret void\n"
       "}\n"
       "define void @f2() {\n"
       "entry:\n"
TEST(LazyCallGraphTest, MultiArmSCC) {
   EXPECT_EQ(&C, CG.lookupSCC(N1));
   EXPECT_EQ(&C, CG.lookupSCC(N2));
   EXPECT_EQ(&C, CG.lookupSCC(N3));
   EXPECT_EQ(&C, CG.lookupSCC(N4));
   EXPECT_EQ(&C, CG.lookupSCC(N5));
 }
 
 TEST(LazyCallGraphTest, OutgoingEdgeMutation) {
-  std::unique_ptr<Module> M = parseAssembly(
+  LLVMContext Context;
+  std::unique_ptr<Module> M = parseAssembly(Context,
       "define void @a() {\n"
       "entry:\n"
       "  call void @b()\n"
       "  call void @c()\n"
       "  ret void\n"
       "}\n"
       "define void @b() {\n"
       "entry:\n"
TEST(LazyCallGraphTest, OutgoingEdgeMutation) {
   EXPECT_EQ(&DC, CG.lookupSCC(D));
   EXPECT_EQ(&ARC, CG.lookupRefSCC(A));
   EXPECT_EQ(&BRC, CG.lookupRefSCC(B));
   EXPECT_EQ(&CRC, CG.lookupRefSCC(C));
   EXPECT_EQ(&DRC, CG.lookupRefSCC(D));
 }
 
 TEST(LazyCallGraphTest, IncomingEdgeInsertion) {
+  LLVMContext Context;
   // We want to ensure we can add edges even across complex diamond graphs, so
   // we use the diamond of triangles graph defined above. The ascii diagram is
   // repeated here for easy reference.
   //
   //         d1       |
   //        /  \      |
   //       d3--d2     |
   //      /     \     |
   //     b1     c1    |
   //   /  \    /  \   |
   //  b3--b2  c3--c2  |
   //       \  /       |
   //        a1        |
   //       /  \       |
   //      a3--a2      |
   //
-  std::unique_ptr<Module> M = parseAssembly(DiamondOfTriangles);
+  std::unique_ptr<Module> M = parseAssembly(Context, DiamondOfTriangles);
   LazyCallGraph CG(*M);
 
   // Force the graph to be fully expanded.
   for (LazyCallGraph::RefSCC &RC : CG.postorder_ref_sccs())
     (void)RC;
 
   LazyCallGraph::Node &A1 = *CG.lookup(lookupFunction(*M, "a1"));
   LazyCallGraph::Node &A2 = *CG.lookup(lookupFunction(*M, "a2"));
TEST(LazyCallGraphTest, IncomingEdgeInsertion) {
   EXPECT_EQ(&CRC, CG.lookupRefSCC(D3));
 
   // And that ancestry tests have been updated.
   EXPECT_TRUE(ARC.isParentOf(CRC));
   EXPECT_TRUE(BRC.isParentOf(CRC));
 }
 
 TEST(LazyCallGraphTest, IncomingEdgeInsertionMidTraversal) {
+  LLVMContext Context;
   // This is the same fundamental test as the previous, but we perform it
   // having only partially walked the RefSCCs of the graph.
-  std::unique_ptr<Module> M = parseAssembly(DiamondOfTriangles);
+  std::unique_ptr<Module> M = parseAssembly(Context, DiamondOfTriangles);
   LazyCallGraph CG(*M);
 
   // Walk the RefSCCs until we find the one containing 'c1'.
   auto I = CG.postorder_ref_scc_begin(), E = CG.postorder_ref_scc_end();
   ASSERT_NE(I, E);
   LazyCallGraph::RefSCC &DRC = *I;
   ASSERT_NE(&DRC, nullptr);
   ++I;
TEST(LazyCallGraphTest, IncomingEdgeInsertionMidTraversal) {
   EXPECT_EQ(&ARC, CG.lookupRefSCC(*CG.lookup(lookupFunction(*M, "a2"))));
   EXPECT_EQ(&ARC, CG.lookupRefSCC(*CG.lookup(lookupFunction(*M, "a3"))));
   EXPECT_TRUE(ARC.isParentOf(CRC));
   ++I;
   EXPECT_EQ(E, I);
 }
 
 TEST(LazyCallGraphTest, InternalEdgeMutation) {
-  std::unique_ptr<Module> M = parseAssembly(
+  LLVMContext Context;
+  std::unique_ptr<Module> M = parseAssembly(Context,
       "define void @a() {\n"
       "entry:\n"
       "  call void @b()\n"
       "  ret void\n"
       "}\n"
       "define void @b() {\n"
       "entry:\n"
       "  call void @c()\n"
TEST(LazyCallGraphTest, InternalEdgeMutation) {
   EXPECT_EQ(&CC, CG.lookupSCC(C));
   J = RC.begin();
   EXPECT_EQ(&*J++, CG.lookupSCC(B));
   EXPECT_EQ(&*J++, CG.lookupSCC(C));
   EXPECT_EQ(RC.end(), J);
 }
 
 TEST(LazyCallGraphTest, InternalEdgeRemoval) {
+  LLVMContext Context;
   // A nice fully connected (including self-edges) RefSCC.
-  std::unique_ptr<Module> M = parseAssembly(
+  std::unique_ptr<Module> M = parseAssembly(Context,
       "define void @a(i8** %ptr) {\n"
       "entry:\n"
       "  store i8* bitcast (void(i8**)* @a to i8*), i8** %ptr\n"
       "  store i8* bitcast (void(i8**)* @b to i8*), i8** %ptr\n"
       "  store i8* bitcast (void(i8**)* @c to i8*), i8** %ptr\n"
       "  ret void\n"
       "}\n"
       "define void @b(i8** %ptr) {\n"
TEST(LazyCallGraphTest, InternalEdgeRemoval) {
   EXPECT_EQ(&RC, CG.lookupRefSCC(A));
   EXPECT_EQ(1, std::distance(RC.begin(), RC.end()));
   LazyCallGraph::RefSCC *RC2 = CG.lookupRefSCC(B);
   EXPECT_EQ(RC2, CG.lookupRefSCC(C));
   EXPECT_EQ(RC2, NewRCs[0]);
 }
 
 TEST(LazyCallGraphTest, InternalCallEdgeToRef) {
+  LLVMContext Context;
   // A nice fully connected (including self-edges) SCC (and RefSCC)
-  std::unique_ptr<Module> M = parseAssembly(
+  std::unique_ptr<Module> M = parseAssembly(Context,
       "define void @a() {\n"
       "entry:\n"
       "  call void @a()\n"
       "  call void @b()\n"
       "  call void @c()\n"
       "  ret void\n"
       "}\n"
       "define void @b() {\n"
TEST(LazyCallGraphTest, InternalCallEdgeToRef) {
   --J;
   EXPECT_EQ(&BCallC, &*J);
   --J;
   EXPECT_EQ(&CCallC, &*J);
   EXPECT_EQ(RC.begin(), J);
 }
 
 TEST(LazyCallGraphTest, InternalRefEdgeToCall) {
+  LLVMContext Context;
   // Basic tests for making a ref edge a call. This hits the basics of the
   // process only.
-  std::unique_ptr<Module> M = parseAssembly(
+  std::unique_ptr<Module> M = parseAssembly(Context,
       "define void @a() {\n"
       "entry:\n"
       "  call void @b()\n"
       "  call void @c()\n"
       "  store void()* @d, void()** undef\n"
       "  ret void\n"
       "}\n"
       "define void @b() {\n"
TEST(LazyCallGraphTest, InternalRefEdgeToCall) {
   EXPECT_EQ(&BC, &RC[1]);
   EXPECT_EQ(&AC, &RC[2]);
   EXPECT_EQ(2, BC.size());
   EXPECT_EQ(&BC, CG.lookupSCC(B));
   EXPECT_EQ(&BC, CG.lookupSCC(C));
 }
 
 TEST(LazyCallGraphTest, InternalRefEdgeToCallNoCycleInterleaved) {
+  LLVMContext Context;
   // Test for having a post-order prior to changing a ref edge to a call edge
   // with SCCs connecting to the source and connecting to the target, but not
   // connecting to both, interleaved between the source and target. This
   // ensures we correctly partition the range rather than simply moving one or
   // the other.
-  std::unique_ptr<Module> M = parseAssembly(
+  std::unique_ptr<Module> M = parseAssembly(Context,
       "define void @a() {\n"
       "entry:\n"
       "  call void @b1()\n"
       "  call void @c1()\n"
       "  ret void\n"
       "}\n"
       "define void @b1() {\n"
       "entry:\n"
TEST(LazyCallGraphTest, InternalRefEdgeToCallNoCycleInterleaved) {
   EXPECT_EQ(&B1C, &RC[3]);
   EXPECT_EQ(&C3C, &RC[4]);
   EXPECT_EQ(&C2C, &RC[5]);
   EXPECT_EQ(&C1C, &RC[6]);
   EXPECT_EQ(&AC, &RC[7]);
 }
 
 TEST(LazyCallGraphTest, InternalRefEdgeToCallBothPartitionAndMerge) {
+  LLVMContext Context;
   // Test for having a postorder where between the source and target are all
   // three kinds of other SCCs:
   // 1) One connected to the target only that have to be shifted below the
   //    source.
   // 2) One connected to the source only that have to be shifted below the
   //    target.
   // 3) One connected to both source and target that has to remain and get
   //    merged away.
TEST(LazyCallGraphTest, InternalRefEdgeToCallBothPartitionAndMerge) {
   // |\  |  |  |\  |  |
   // | D |  |  C-D-E  |
   // |  \|  |  |  \|  |
   // C   F  |  \   F  |
   //  \ /   |   \ /   |
   //   G    |    G    |
   //
   // And we form a cycle by connecting F to B.
-  std::unique_ptr<Module> M = parseAssembly(
+  std::unique_ptr<Module> M = parseAssembly(Context,
       "define void @a() {\n"
       "entry:\n"
       "  call void @b()\n"
       "  call void @e()\n"
       "  ret void\n"
       "}\n"
       "define void @b() {\n"
       "entry:\n"

unittests/Analysis/LoopPassManagerTest.cpp

public:
   PreservedAnalyses run(Loop &L, AnalysisManager<Loop> &AM) {
     return L.getName() == Name ? PreservedAnalyses::none()
                                : PreservedAnalyses::all();
   }
 
   static StringRef name() { return "TestLoopInvalidatingPass"; }
 };
 
-std::unique_ptr<Module> parseIR(const char *IR) {
-  LLVMContext &C = getGlobalContext();
+std::unique_ptr<Module> parseIR(LLVMContext &C, const char *IR) {
   SMDiagnostic Err;
   return parseAssemblyString(IR, Err, C);
 }
 
 class LoopPassManagerTest : public ::testing::Test {
 protected:
+  LLVMContext Context;
   std::unique_ptr<Module> M;
 
 public:
   LoopPassManagerTest()
-      : M(parseIR("define void @f() {\n"
+      : M(parseIR(Context,
+                  "define void @f() {\n"
                   "entry:\n"
                   "  br label %loop.0\n"
                   "loop.0:\n"
                   "  br i1 undef, label %loop.0.0, label %end\n"
                   "loop.0.0:\n"
                   "  br i1 undef, label %loop.0.0, label %loop.0.1\n"
                   "loop.0.1:\n"
                   "  br i1 undef, label %loop.0.1, label %loop.0\n"

unittests/Analysis/UnrollAnalyzer.cpp

struct UnrollAnalyzerTest : public FunctionPass {
   UnrollAnalyzerTest() : FunctionPass(ID) {
     initializeUnrollAnalyzerTestPass(*PassRegistry::getPassRegistry());
   }
 };
 }
 
 char UnrollAnalyzerTest::ID = 0;
 
-std::unique_ptr<Module> makeLLVMModule(UnrollAnalyzerTest *P,
+std::unique_ptr<Module> makeLLVMModule(LLVMContext &Context,
+                                       UnrollAnalyzerTest *P,
                                        const char *ModuleStr) {
-  LLVMContext &C = getGlobalContext();
   SMDiagnostic Err;
-  return parseAssemblyString(ModuleStr, Err, C);
+  return parseAssemblyString(ModuleStr, Err, Context);
 }
 
 TEST(UnrollAnalyzerTest, BasicSimplifications) {
   const char *ModuleStr =
       "target datalayout = \"e-m:o-i64:64-f80:128-n8:16:32:64-S128\"\n"
       "define i64 @propagate_loop_phis() {\n"
       "entry:\n"
       "  br label %loop\n"
       "loop:\n"
       "  %iv = phi i64 [ 0, %entry ], [ %inc, %loop ]\n"
       "  %x0 = phi i64 [ 0, %entry ], [ %x2, %loop ]\n"
       "  %x1 = or i64 %x0, 1\n"
       "  %x2 = or i64 %x1, 2\n"
       "  %inc = add nuw nsw i64 %iv, 1\n"
       "  %cond = icmp sge i64 %inc, 8\n"
       "  br i1 %cond, label %loop.end, label %loop\n"
       "loop.end:\n"
       "  %x.lcssa = phi i64 [ %x2, %loop ]\n"
       "  ret i64 %x.lcssa\n"
       "}\n";
   UnrollAnalyzerTest *P = new UnrollAnalyzerTest();
-  std::unique_ptr<Module> M = makeLLVMModule(P, ModuleStr);
+  LLVMContext Context;
+  std::unique_ptr<Module> M = makeLLVMModule(Context, P, ModuleStr);
   legacy::PassManager Passes;
   Passes.add(P);
   Passes.run(*M);
 
   // Perform checks
   Module::iterator MI = M->begin();
   Function *F = &*MI++;
   Function::iterator FI = F->begin();
const char *ModuleStr =
       "  %iv.outer.next = add nuw nsw i64 %iv.outer, 1\n"
       "  %exitcond.outer = icmp eq i64 %iv.outer.next, 40\n"
       "  br i1 %exitcond.outer, label %exit, label %outer.loop\n"
       "exit:\n"
       "  ret void\n"
       "}\n";
 
   UnrollAnalyzerTest *P = new UnrollAnalyzerTest();
-  std::unique_ptr<Module> M = makeLLVMModule(P, ModuleStr);
+  LLVMContext Context;
+  std::unique_ptr<Module> M = makeLLVMModule(Context, P, ModuleStr);
   legacy::PassManager Passes;
   Passes.add(P);
   Passes.run(*M);
 
   Module::iterator MI = M->begin();
   Function *F = &*MI++;
   Function::iterator FI = F->begin();
   FI++;
const char *ModuleStr =
       "  %cmp3 = icmp eq i32 %tmp2, 5\n"
       "  %tmp3 = add nuw nsw i64 %indvars.iv, 1\n"
       "  %exitcond = icmp eq i64 %tmp3, 10\n"
       "  br i1 %exitcond, label %for.end, label %for.body\n"
       "for.end:\n"
       "  ret void\n"
       "}\n";
   UnrollAnalyzerTest *P = new UnrollAnalyzerTest();
-  std::unique_ptr<Module> M = makeLLVMModule(P, ModuleStr);
+  LLVMContext Context;
+  std::unique_ptr<Module> M = makeLLVMModule(Context, P, ModuleStr);
   legacy::PassManager Passes;
   Passes.add(P);
   Passes.run(*M);
 
   // Perform checks
   Module::iterator MI = M->begin();
   Function *F = &*MI++;
   Function::iterator FI = F->begin();
const char *ModuleStr =
       "  %iv.1 = getelementptr inbounds i8, i8* %iv.0, i64 1\n"
       "  %iv2.1 = getelementptr inbounds i8, i8* %iv2.0, i64 1\n"
       "  %exitcond = icmp ne i8* %iv.1, %limit\n"
       "  br i1 %exitcond, label %loop.body, label %loop.exit\n"
       "loop.exit:\n"
       "  ret void\n"
       "}\n";
   UnrollAnalyzerTest *P = new UnrollAnalyzerTest();
-  std::unique_ptr<Module> M = makeLLVMModule(P, ModuleStr);
+  LLVMContext Context;
+  std::unique_ptr<Module> M = makeLLVMModule(Context, P, ModuleStr);
   legacy::PassManager Passes;
   Passes.add(P);
   Passes.run(*M);
 
   // Perform checks
   Module::iterator MI = M->begin();
   Function *F = &*MI++;
   Function::iterator FI = F->begin();
const char *ModuleStr =
       "  %exitcond86.i = icmp eq i64 %inc, 10\n"
       "  br i1 %exitcond86.i, label %loop.end, label %loop\n"
       "\n"
       "loop.end:\n"
       "  ret void\n"
       "}\n";
 
   UnrollAnalyzerTest *P = new UnrollAnalyzerTest();
-  std::unique_ptr<Module> M = makeLLVMModule(P, ModuleStr);
+  LLVMContext Context;
+  std::unique_ptr<Module> M = makeLLVMModule(Context, P, ModuleStr);
   legacy::PassManager Passes;
   Passes.add(P);
   Passes.run(*M);
 
   // Perform checks
   Module::iterator MI = M->begin();
   Function *F = &*MI++;
   Function::iterator FI = F->begin();

unittests/Analysis/ValueTrackingTest.cpp

 using namespace llvm;
 
 namespace {
 
 class MatchSelectPatternTest : public testing::Test {
 protected:
   void parseAssembly(const char *Assembly) {
     SMDiagnostic Error;
-    M = parseAssemblyString(Assembly, Error, getGlobalContext());
+    M = parseAssemblyString(Assembly, Error, Context);
 
     std::string errMsg;
     raw_string_ostream os(errMsg);
     Error.print("", os);
 
     // A failure here means that the test itself is buggy.
     if (!M)
       report_fatal_error(os.str());
void expectPattern(const SelectPatternResult &P) {
     Value *LHS, *RHS;
     Instruction::CastOps CastOp;
     SelectPatternResult R = matchSelectPattern(A, LHS, RHS, &CastOp);
     EXPECT_EQ(P.Flavor, R.Flavor);
     EXPECT_EQ(P.NaNBehavior, R.NaNBehavior);
     EXPECT_EQ(P.Ordered, R.Ordered);
   }
 
+  LLVMContext Context;
   std::unique_ptr<Module> M;
   Instruction *A, *B;
 };
 
 }
 
 TEST_F(MatchSelectPatternTest, SimpleFMin) {
   parseAssembly(

unittests/AsmParser/AsmParserTest.cpp

 #include "llvm/Support/SourceMgr.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 
 namespace {
 
 TEST(AsmParserTest, NullTerminatedInput) {
-  LLVMContext &Ctx = getGlobalContext();
+  LLVMContext Ctx;
   StringRef Source = "; Empty module \n";
   SMDiagnostic Error;
   auto Mod = parseAssemblyString(Source, Error, Ctx);
 
   EXPECT_TRUE(Mod != nullptr);
   EXPECT_TRUE(Error.getMessage().empty());
 }
 
 #ifdef GTEST_HAS_DEATH_TEST
 #ifndef NDEBUG
 
 TEST(AsmParserTest, NonNullTerminatedInput) {
-  LLVMContext &Ctx = getGlobalContext();
+  LLVMContext Ctx;
   StringRef Source = "; Empty module \n\1\2";
   SMDiagnostic Error;
   std::unique_ptr<Module> Mod;
   EXPECT_DEATH(Mod = parseAssemblyString(Source.substr(0, Source.size() - 2),
                                          Error, Ctx),
                "Buffer is not null terminated!");
 }
 
 #endif
 #endif
 
 TEST(AsmParserTest, SlotMappingTest) {
-  LLVMContext &Ctx = getGlobalContext();
+  LLVMContext Ctx;
   StringRef Source = "@0 = global i32 0\n !0 = !{}\n !42 = !{i32 42}";
   SMDiagnostic Error;
   SlotMapping Mapping;
   auto Mod = parseAssemblyString(Source, Error, Ctx, &Mapping);
 
   EXPECT_TRUE(Mod != nullptr);
   EXPECT_TRUE(Error.getMessage().empty());
 
   ASSERT_EQ(Mapping.GlobalValues.size(), 1u);
   EXPECT_TRUE(isa<GlobalVariable>(Mapping.GlobalValues[0]));
 
   EXPECT_EQ(Mapping.MetadataNodes.size(), 2u);
   EXPECT_EQ(Mapping.MetadataNodes.count(0), 1u);
   EXPECT_EQ(Mapping.MetadataNodes.count(42), 1u);
   EXPECT_EQ(Mapping.MetadataNodes.count(1), 0u);
 }
 
 TEST(AsmParserTest, TypeAndConstantValueParsing) {
-  LLVMContext &Ctx = getGlobalContext();
+  LLVMContext Ctx;
   SMDiagnostic Error;
   StringRef Source = "define void @test() {\n  entry:\n  ret void\n}";
   auto Mod = parseAssemblyString(Source, Error, Ctx);
   ASSERT_TRUE(Mod != nullptr);
   auto &M = *Mod;
 
   const Value *V;
   V = parseConstantValue("double 3.5", Error, M);
TEST(AsmParserTest, TypeAndConstantValueParsing) {
   EXPECT_FALSE(parseConstantValue("i32* @foo", Error, M));
   EXPECT_EQ(Error.getMessage(), "expected a constant value");
 
   EXPECT_FALSE(parseConstantValue("i32 3, ", Error, M));
   EXPECT_EQ(Error.getMessage(), "expected end of string");
 }
 
 TEST(AsmParserTest, TypeAndConstantValueWithSlotMappingParsing) {
-  LLVMContext &Ctx = getGlobalContext();
+  LLVMContext Ctx;
   SMDiagnostic Error;
   StringRef Source =
       "%st = type { i32, i32 }\n"
       "@v = common global [50 x %st] zeroinitializer, align 16\n"
       "%0 = type { i32, i32, i32, i32 }\n"
       "@g = common global [50 x %0] zeroinitializer, align 16\n"
       "define void @marker4(i64 %d) {\n"
       "entry:\n"
TEST(AsmParserTest, TypeAndConstantValueWithSlotMappingParsing) {
   V = parseConstantValue("i32* getelementptr inbounds ([50 x %0], [50 x %0]* "
                          "@g, i64 0, i64 0, i32 0)",
                          Error, M, &Mapping);
   ASSERT_TRUE(V);
   ASSERT_TRUE(isa<ConstantExpr>(V));
 }
 
 TEST(AsmParserTest, TypeWithSlotMappingParsing) {
-  LLVMContext &Ctx = getGlobalContext();
+  LLVMContext Ctx;
   SMDiagnostic Error;
   StringRef Source =
       "%st = type { i32, i32 }\n"
       "@v = common global [50 x %st] zeroinitializer, align 16\n"
       "%0 = type { i32, i32, i32, i32 }\n"
       "@g = common global [50 x %0] zeroinitializer, align 16\n"
       "define void @marker4(i64 %d) {\n"
       "entry:\n"
TEST(AsmParserTest, TypeWithSlotMappingParsing) {
   ASSERT_TRUE(Ty->getPrimitiveSizeInBits() == 32);
 
   // Check that we reject types with garbage.
   Ty = parseType("i32 garbage", Error, M, &Mapping);
   ASSERT_TRUE(!Ty);
 }
 
 TEST(AsmParserTest, TypeAtBeginningWithSlotMappingParsing) {
-  LLVMContext &Ctx = getGlobalContext();
+  LLVMContext Ctx;
   SMDiagnostic Error;
   StringRef Source =
       "%st = type { i32, i32 }\n"
       "@v = common global [50 x %st] zeroinitializer, align 16\n"
       "%0 = type { i32, i32, i32, i32 }\n"
       "@g = common global [50 x %0] zeroinitializer, align 16\n"
       "define void @marker4(i64 %d) {\n"
       "entry:\n"

unittests/Bitcode/BitReaderTest.cpp

 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/StreamingMemoryObject.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 
 namespace {
 
-std::unique_ptr<Module> parseAssembly(const char *Assembly) {
+std::unique_ptr<Module> parseAssembly(LLVMContext &Context, const char *Assembly) {
   SMDiagnostic Error;
   std::unique_ptr<Module> M =
-      parseAssemblyString(Assembly, Error, getGlobalContext());
+      parseAssemblyString(Assembly, Error, Context);
 
   std::string ErrMsg;
   raw_string_ostream OS(ErrMsg);
   Error.print("", OS);
 
   // A failure here means that the test itself is buggy.
   if (!M)
     report_fatal_error(OS.str().c_str());
 
   return M;
 }
 
 static void writeModuleToBuffer(std::unique_ptr<Module> Mod,
                                 SmallVectorImpl<char> &Buffer) {
   raw_svector_ostream OS(Buffer);
   WriteBitcodeToFile(Mod.get(), OS);
 }
 
 static std::unique_ptr<Module> getLazyModuleFromAssembly(LLVMContext &Context,
                                                          SmallString<1024> &Mem,
                                                          const char *Assembly) {
-  writeModuleToBuffer(parseAssembly(Assembly), Mem);
+  writeModuleToBuffer(parseAssembly(Context, Assembly), Mem);
   std::unique_ptr<MemoryBuffer> Buffer =
       MemoryBuffer::getMemBuffer(Mem.str(), "test", false);
   ErrorOr<std::unique_ptr<Module>> ModuleOrErr =
       getLazyBitcodeModule(std::move(Buffer), Context);
   return std::move(ModuleOrErr.get());
 }
 
 class BufferDataStreamer : public DataStreamer {

 public:
   BufferDataStreamer(std::unique_ptr<MemoryBuffer> Buffer)
       : Buffer(std::move(Buffer)) {}
 };
 
 static std::unique_ptr<Module>
 getStreamedModuleFromAssembly(LLVMContext &Context, SmallString<1024> &Mem,
                               const char *Assembly) {
-  writeModuleToBuffer(parseAssembly(Assembly), Mem);
+  writeModuleToBuffer(parseAssembly(Context, Assembly), Mem);
   std::unique_ptr<MemoryBuffer> Buffer =
       MemoryBuffer::getMemBuffer(Mem.str(), "test", false);
   auto Streamer = llvm::make_unique<BufferDataStreamer>(std::move(Buffer));
   ErrorOr<std::unique_ptr<Module>> ModuleOrErr =
       getStreamedBitcodeModule("test", std::move(Streamer), Context);
   return std::move(ModuleOrErr.get());
 }
 

unittests/ExecutionEngine/ExecutionEngineTest.cpp

 namespace {
 
 class ExecutionEngineTest : public testing::Test {
 private:
   llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
 
 protected:
   ExecutionEngineTest() {
-    auto Owner = make_unique<Module>("<main>", getGlobalContext());
+    auto Owner = make_unique<Module>("<main>", Context);
     M = Owner.get();
     Engine.reset(EngineBuilder(std::move(Owner)).setErrorStr(&Error).create());
   }
 
   void SetUp() override {
     ASSERT_TRUE(Engine.get() != nullptr) << "EngineBuilder returned error: '"
       << Error << "'";
   }
 
   GlobalVariable *NewExtGlobal(Type *T, const Twine &Name) {
     return new GlobalVariable(*M, T, false,  // Not constant.
                               GlobalValue::ExternalLinkage, nullptr, Name);
   }
 
   std::string Error;
+  LLVMContext Context;
   Module *M;  // Owned by ExecutionEngine.
   std::unique_ptr<ExecutionEngine> Engine;
 };
 
 TEST_F(ExecutionEngineTest, ForwardGlobalMapping) {
   GlobalVariable *G1 =
-      NewExtGlobal(Type::getInt32Ty(getGlobalContext()), "Global1");
+      NewExtGlobal(Type::getInt32Ty(Context), "Global1");
   int32_t Mem1 = 3;
   Engine->addGlobalMapping(G1, &Mem1);
   EXPECT_EQ(&Mem1, Engine->getPointerToGlobalIfAvailable(G1));
   EXPECT_EQ(&Mem1, Engine->getPointerToGlobalIfAvailable("Global1"));
   int32_t Mem2 = 4;
   Engine->updateGlobalMapping(G1, &Mem2);
   EXPECT_EQ(&Mem2, Engine->getPointerToGlobalIfAvailable(G1));
   Engine->updateGlobalMapping(G1, nullptr);
   EXPECT_EQ(nullptr, Engine->getPointerToGlobalIfAvailable(G1));
   Engine->updateGlobalMapping(G1, &Mem2);
   EXPECT_EQ(&Mem2, Engine->getPointerToGlobalIfAvailable(G1));
 
   GlobalVariable *G2 =
-      NewExtGlobal(Type::getInt32Ty(getGlobalContext()), "Global1");
+      NewExtGlobal(Type::getInt32Ty(Context), "Global1");
   EXPECT_EQ(nullptr, Engine->getPointerToGlobalIfAvailable(G2))
     << "The NULL return shouldn't depend on having called"
     << " updateGlobalMapping(..., NULL)";
   // Check that update...() can be called before add...().
   Engine->updateGlobalMapping(G2, &Mem1);
   EXPECT_EQ(&Mem1, Engine->getPointerToGlobalIfAvailable(G2));
   EXPECT_EQ(&Mem2, Engine->getPointerToGlobalIfAvailable(G1))
     << "A second mapping shouldn't affect the first.";
 }
 
 TEST_F(ExecutionEngineTest, ReverseGlobalMapping) {
   GlobalVariable *G1 =
-      NewExtGlobal(Type::getInt32Ty(getGlobalContext()), "Global1");
+      NewExtGlobal(Type::getInt32Ty(Context), "Global1");
 
   int32_t Mem1 = 3;
   Engine->addGlobalMapping(G1, &Mem1);
   EXPECT_EQ(G1, Engine->getGlobalValueAtAddress(&Mem1));
   int32_t Mem2 = 4;
   Engine->updateGlobalMapping(G1, &Mem2);
   EXPECT_EQ(nullptr, Engine->getGlobalValueAtAddress(&Mem1));
   EXPECT_EQ(G1, Engine->getGlobalValueAtAddress(&Mem2));
 
   GlobalVariable *G2 =
-      NewExtGlobal(Type::getInt32Ty(getGlobalContext()), "Global2");
+      NewExtGlobal(Type::getInt32Ty(Context), "Global2");
   Engine->updateGlobalMapping(G2, &Mem1);
   EXPECT_EQ(G2, Engine->getGlobalValueAtAddress(&Mem1));
   EXPECT_EQ(G1, Engine->getGlobalValueAtAddress(&Mem2));
   Engine->updateGlobalMapping(G1, nullptr);
   EXPECT_EQ(G2, Engine->getGlobalValueAtAddress(&Mem1))
     << "Removing one mapping doesn't affect a different one.";
   EXPECT_EQ(nullptr, Engine->getGlobalValueAtAddress(&Mem2));
   Engine->updateGlobalMapping(G2, &Mem2);
   EXPECT_EQ(nullptr, Engine->getGlobalValueAtAddress(&Mem1));
   EXPECT_EQ(G2, Engine->getGlobalValueAtAddress(&Mem2))
     << "Once a mapping is removed, we can point another GV at the"
     << " now-free address.";
 }
 
 TEST_F(ExecutionEngineTest, ClearModuleMappings) {
   GlobalVariable *G1 =
-      NewExtGlobal(Type::getInt32Ty(getGlobalContext()), "Global1");
+      NewExtGlobal(Type::getInt32Ty(Context), "Global1");
 
   int32_t Mem1 = 3;
   Engine->addGlobalMapping(G1, &Mem1);
   EXPECT_EQ(G1, Engine->getGlobalValueAtAddress(&Mem1));
 
   Engine->clearGlobalMappingsFromModule(M);
 
   EXPECT_EQ(nullptr, Engine->getGlobalValueAtAddress(&Mem1));
 
   GlobalVariable *G2 =
-      NewExtGlobal(Type::getInt32Ty(getGlobalContext()), "Global2");
+      NewExtGlobal(Type::getInt32Ty(Context), "Global2");
   // After clearing the module mappings, we can assign a new GV to the
   // same address.
   Engine->addGlobalMapping(G2, &Mem1);
   EXPECT_EQ(G2, Engine->getGlobalValueAtAddress(&Mem1));
 }
 
 TEST_F(ExecutionEngineTest, DestructionRemovesGlobalMapping) {
   GlobalVariable *G1 =
-    NewExtGlobal(Type::getInt32Ty(getGlobalContext()), "Global1");
+    NewExtGlobal(Type::getInt32Ty(Context), "Global1");
   int32_t Mem1 = 3;
   Engine->addGlobalMapping(G1, &Mem1);
   // Make sure the reverse mapping is enabled.
   EXPECT_EQ(G1, Engine->getGlobalValueAtAddress(&Mem1));
   // When the GV goes away, the ExecutionEngine should remove any
   // mappings that refer to it.
   G1->eraseFromParent();
   EXPECT_EQ(nullptr, Engine->getGlobalValueAtAddress(&Mem1));

unittests/ExecutionEngine/Orc/IndirectionUtilsTest.cpp

 #include "llvm/ExecutionEngine/Orc/IndirectionUtils.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 
 namespace {
 
 TEST(IndirectionUtilsTest, MakeStub) {
-  ModuleBuilder MB(getGlobalContext(), "x86_64-apple-macosx10.10", "");
+  LLVMContext Context;
+  ModuleBuilder MB(Context, "x86_64-apple-macosx10.10", "");
   Function *F = MB.createFunctionDecl<void(DummyStruct, DummyStruct)>("");
   SmallVector<AttributeSet, 4> Attrs;
   Attrs.push_back(
     AttributeSet::get(MB.getModule()->getContext(), 1U,
                       AttrBuilder().addAttribute(Attribute::StructRet)));
   Attrs.push_back(
     AttributeSet::get(MB.getModule()->getContext(), 2U,
                       AttrBuilder().addAttribute(Attribute::ByVal)));

unittests/ExecutionEngine/Orc/ObjectLinkingLayerTest.cpp

 
 using namespace llvm;
 using namespace llvm::orc;
 
 namespace {
 
 class ObjectLinkingLayerExecutionTest : public testing::Test,
                                         public OrcExecutionTest {
+
 };
 
 class SectionMemoryManagerWrapper : public SectionMemoryManager {
 public:
   int FinalizationCount = 0;
   int NeedsToReserveAllocationSpaceCount = 0;
 
   bool needsToReserveAllocationSpace() override {
uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment,
                                                          IsReadOnly);
     }
   private:
     bool DebugSeen;
   };
 
   ObjectLinkingLayer<> ObjLayer;
 
-  auto M = llvm::make_unique<Module>("", getGlobalContext());
+  LLVMContext Context;
+  auto M = llvm::make_unique<Module>("", Context);
   M->setTargetTriple("x86_64-unknown-linux-gnu");
-  Type *Int32Ty = IntegerType::get(getGlobalContext(), 32);
+  Type *Int32Ty = IntegerType::get(Context, 32);
   GlobalVariable *GV =
     new GlobalVariable(*M, Int32Ty, false, GlobalValue::ExternalLinkage,
                          ConstantInt::get(Int32Ty, 42), "foo");
 
   GV->setSection(".debug_str");
 
   std::unique_ptr<TargetMachine> TM(
     EngineBuilder().selectTarget(Triple(M->getTargetTriple()), "", "",
TEST_F(ObjectLinkingLayerExecutionTest, NoDuplicateFinalization) {
   //   int bar();
   //   int foo() { return bar(); }
   //
   // Verify that the memory manager is only finalized once (for Module 2).
   // Failure suggests that finalize is being called on the inner RTDyld
   // instance (for Module 1) which is unsafe, as it will prevent relocation of
   // Module 2.
 
-  ModuleBuilder MB1(getGlobalContext(), "", "dummy");
+  ModuleBuilder MB1(Context, "", "dummy");
   {
     MB1.getModule()->setDataLayout(TM->createDataLayout());
     Function *BarImpl = MB1.createFunctionDecl<int32_t(void)>("bar");
-    BasicBlock *BarEntry = BasicBlock::Create(getGlobalContext(), "entry",
+    BasicBlock *BarEntry = BasicBlock::Create(Context, "entry",
                                               BarImpl);
     IRBuilder<> Builder(BarEntry);
-    IntegerType *Int32Ty = IntegerType::get(getGlobalContext(), 32);
+    IntegerType *Int32Ty = IntegerType::get(Context, 32);
     Value *FourtyTwo = ConstantInt::getSigned(Int32Ty, 42);
     Builder.CreateRet(FourtyTwo);
   }
 
   auto Obj1 = Compile(*MB1.getModule());
   std::vector<object::ObjectFile*> Obj1Set;
   Obj1Set.push_back(Obj1.getBinary());
 
-  ModuleBuilder MB2(getGlobalContext(), "", "dummy");
+  ModuleBuilder MB2(Context, "", "dummy");
   {
     MB2.getModule()->setDataLayout(TM->createDataLayout());
     Function *BarDecl = MB2.createFunctionDecl<int32_t(void)>("bar");
     Function *FooImpl = MB2.createFunctionDecl<int32_t(void)>("foo");
-    BasicBlock *FooEntry = BasicBlock::Create(getGlobalContext(), "entry",
+    BasicBlock *FooEntry = BasicBlock::Create(Context, "entry",
                                               FooImpl);
     IRBuilder<> Builder(FooEntry);
     Builder.CreateRet(Builder.CreateCall(BarDecl));
   }
   auto Obj2 = Compile(*MB2.getModule());
   std::vector<object::ObjectFile*> Obj2Set;
   Obj2Set.push_back(Obj2.getBinary());
 
TEST_F(ObjectLinkingLayerExecutionTest, NoPrematureAllocation) {
   //   int bar() { return 7; }
   //
   // Both modules will share a memory manager. We want to verify that the
   // second object is not loaded before the first one is finalized. To do this
   // in a portable way, we abuse the
   // RuntimeDyld::MemoryManager::needsToReserveAllocationSpace hook, which is
   // called once per object before any sections are allocated.
 
-  ModuleBuilder MB1(getGlobalContext(), "", "dummy");
+  ModuleBuilder MB1(Context, "", "dummy");
   {
     MB1.getModule()->setDataLayout(TM->createDataLayout());
     Function *BarImpl = MB1.createFunctionDecl<int32_t(void)>("foo");
-    BasicBlock *BarEntry = BasicBlock::Create(getGlobalContext(), "entry",
+    BasicBlock *BarEntry = BasicBlock::Create(Context, "entry",
                                               BarImpl);
     IRBuilder<> Builder(BarEntry);
-    IntegerType *Int32Ty = IntegerType::get(getGlobalContext(), 32);
+    IntegerType *Int32Ty = IntegerType::get(Context, 32);
     Value *FourtyTwo = ConstantInt::getSigned(Int32Ty, 42);
     Builder.CreateRet(FourtyTwo);
   }
 
   auto Obj1 = Compile(*MB1.getModule());
   std::vector<object::ObjectFile*> Obj1Set;
   Obj1Set.push_back(Obj1.getBinary());
 
-  ModuleBuilder MB2(getGlobalContext(), "", "dummy");
+  ModuleBuilder MB2(Context, "", "dummy");
   {
     MB2.getModule()->setDataLayout(TM->createDataLayout());
     Function *BarImpl = MB2.createFunctionDecl<int32_t(void)>("bar");
-    BasicBlock *BarEntry = BasicBlock::Create(getGlobalContext(), "entry",
+    BasicBlock *BarEntry = BasicBlock::Create(Context, "entry",
                                               BarImpl);
     IRBuilder<> Builder(BarEntry);
-    IntegerType *Int32Ty = IntegerType::get(getGlobalContext(), 32);
+    IntegerType *Int32Ty = IntegerType::get(Context, 32);
     Value *Seven = ConstantInt::getSigned(Int32Ty, 7);
     Builder.CreateRet(Seven);
   }
   auto Obj2 = Compile(*MB2.getModule());
   std::vector<object::ObjectFile*> Obj2Set;
   Obj2Set.push_back(Obj2.getBinary());
 
   SectionMemoryManagerWrapper SMMW;

unittests/ExecutionEngine/Orc/OrcCAPITest.cpp

 
 namespace llvm {
 
 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(TargetMachine, LLVMTargetMachineRef)
 
 class OrcCAPIExecutionTest : public testing::Test, public OrcExecutionTest {
 protected:
   std::unique_ptr<Module> createTestModule(const Triple &TT) {
-    ModuleBuilder MB(getGlobalContext(), TT.str(), "");
+    ModuleBuilder MB(Context, TT.str(), "");
     Function *TestFunc = MB.createFunctionDecl<int()>("testFunc");
     Function *Main = MB.createFunctionDecl<int(int, char*[])>("main");
 
-    Main->getBasicBlockList().push_back(BasicBlock::Create(getGlobalContext()));
+    Main->getBasicBlockList().push_back(BasicBlock::Create(Context));
     IRBuilder<> B(&Main->back());
     Value* Result = B.CreateCall(TestFunc);
     B.CreateRet(Result);
 
     return MB.takeModule();
   }
 
   typedef int (*MainFnTy)();

unittests/ExecutionEngine/Orc/OrcTestCommon.h

if (TM) {
 
       if ((TT.getArch() != Triple::x86_64 && TT.getArch() != Triple::x86) ||
           TT.isOSWindows())
         TM = nullptr;
     }
   };
 
 protected:
+  LLVMContext Context;
   std::unique_ptr<TargetMachine> TM;
 private:
   static bool NativeTargetInitialized;
 };
 
 class ModuleBuilder {
 public:
   ModuleBuilder(LLVMContext &Context, StringRef Triple,

unittests/IR/ConstantsTest.cpp

 #include "llvm/Support/SourceMgr.h"
 #include "llvm-c/Core.h"
 #include "gtest/gtest.h"
 
 namespace llvm {
 namespace {
 
 TEST(ConstantsTest, Integer_i1) {
-  IntegerType* Int1 = IntegerType::get(getGlobalContext(), 1);
+  LLVMContext Context;
+  IntegerType* Int1 = IntegerType::get(Context, 1);
   Constant* One = ConstantInt::get(Int1, 1, true);
   Constant* Zero = ConstantInt::get(Int1, 0);
   Constant* NegOne = ConstantInt::get(Int1, static_cast<uint64_t>(-1), true);
   EXPECT_EQ(NegOne, ConstantInt::getSigned(Int1, -1));
   Constant* Undef = UndefValue::get(Int1);
 
   // Input:  @b = constant i1 add(i1 1 , i1 1)
   // Output: @b = constant i1 false
TEST(ConstantsTest, Integer_i1) {
   EXPECT_EQ(Zero, ConstantExpr::getURem(NegOne, One));
 
   // @u = constant i1 srem(i1  1, i1 -1) ; overflow
   // @u = constant i1 false
   EXPECT_EQ(Zero, ConstantExpr::getSRem(One, NegOne));
 }
 
 TEST(ConstantsTest, IntSigns) {
-  IntegerType* Int8Ty = Type::getInt8Ty(getGlobalContext());
+  LLVMContext Context;
+  IntegerType* Int8Ty = Type::getInt8Ty(Context);
   EXPECT_EQ(100, ConstantInt::get(Int8Ty, 100, false)->getSExtValue());
   EXPECT_EQ(100, ConstantInt::get(Int8Ty, 100, true)->getSExtValue());
   EXPECT_EQ(100, ConstantInt::getSigned(Int8Ty, 100)->getSExtValue());
   EXPECT_EQ(-50, ConstantInt::get(Int8Ty, 206)->getSExtValue());
   EXPECT_EQ(-50, ConstantInt::getSigned(Int8Ty, -50)->getSExtValue());
   EXPECT_EQ(206U, ConstantInt::getSigned(Int8Ty, -50)->getZExtValue());
 
   // Overflow is handled by truncation.
   EXPECT_EQ(0x3b, ConstantInt::get(Int8Ty, 0x13b)->getSExtValue());
 }
 
 TEST(ConstantsTest, FP128Test) {
-  Type *FP128Ty = Type::getFP128Ty(getGlobalContext());
+  LLVMContext Context;
+  Type *FP128Ty = Type::getFP128Ty(Context);
 
-  IntegerType *Int128Ty = Type::getIntNTy(getGlobalContext(), 128);
+  IntegerType *Int128Ty = Type::getIntNTy(Context, 128);
   Constant *Zero128 = Constant::getNullValue(Int128Ty);
   Constant *X = ConstantExpr::getUIToFP(Zero128, FP128Ty);
   EXPECT_TRUE(isa<ConstantFP>(X));
 }
 
 TEST(ConstantsTest, PointerCast) {
-  LLVMContext &C(getGlobalContext());
+  LLVMContext C;
   Type *Int8PtrTy = Type::getInt8PtrTy(C);
   Type *Int32PtrTy = Type::getInt32PtrTy(C);
   Type *Int64Ty = Type::getInt64Ty(C);
   VectorType *Int8PtrVecTy = VectorType::get(Int8PtrTy, 4);
   VectorType *Int32PtrVecTy = VectorType::get(Int32PtrTy, 4);
   VectorType *Int64VecTy = VectorType::get(Int64Ty, 4);
 
   // ptrtoint i8* to i64
#define CHECK(x, y) {                                             \
     Instruction *__I = cast<ConstantExpr>(x)->getAsInstruction();  \
     __I->print(__o);                 \
     delete __I;               \
     __o.flush();                                                  \
     EXPECT_EQ(std::string("  <badref> = " y), __s);               \
   }
 
 TEST(ConstantsTest, AsInstructionsTest) {
-  std::unique_ptr<Module> M(new Module("MyModule", getGlobalContext()));
+  LLVMContext Context;
+  std::unique_ptr<Module> M(new Module("MyModule", Context));
 
-  Type *Int64Ty = Type::getInt64Ty(getGlobalContext());
-  Type *Int32Ty = Type::getInt32Ty(getGlobalContext());
-  Type *Int16Ty = Type::getInt16Ty(getGlobalContext());
-  Type *Int1Ty = Type::getInt1Ty(getGlobalContext());
-  Type *FloatTy = Type::getFloatTy(getGlobalContext());
-  Type *DoubleTy = Type::getDoubleTy(getGlobalContext());
+  Type *Int64Ty = Type::getInt64Ty(Context);
+  Type *Int32Ty = Type::getInt32Ty(Context);
+  Type *Int16Ty = Type::getInt16Ty(Context);
+  Type *Int1Ty = Type::getInt1Ty(Context);
+  Type *FloatTy = Type::getFloatTy(Context);
+  Type *DoubleTy = Type::getDoubleTy(Context);
 
   Constant *Global = M->getOrInsertGlobal("dummy",
                                          PointerType::getUnqual(Int32Ty));
   Constant *Global2 = M->getOrInsertGlobal("dummy2",
                                          PointerType::getUnqual(Int32Ty));
 
   Constant *P0 = ConstantExpr::getPtrToInt(Global, Int32Ty);
   Constant *P1 = ConstantExpr::getUIToFP(P0, FloatTy);
   Constant *P2 = ConstantExpr::getUIToFP(P0, DoubleTy);
   Constant *P3 = ConstantExpr::getTrunc(P0, Int1Ty);
   Constant *P4 = ConstantExpr::getPtrToInt(Global2, Int32Ty);
   Constant *P5 = ConstantExpr::getUIToFP(P4, FloatTy);
   Constant *P6 = ConstantExpr::getBitCast(P4, VectorType::get(Int16Ty, 2));
 
   Constant *One = ConstantInt::get(Int32Ty, 1);
   Constant *Two = ConstantInt::get(Int64Ty, 2);
-  Constant *Big = ConstantInt::get(getGlobalContext(),
+  Constant *Big = ConstantInt::get(Context,
                                    APInt{256, uint64_t(-1), true});
   Constant *Elt = ConstantInt::get(Int16Ty, 2015);
   Constant *Undef16  = UndefValue::get(Int16Ty);
   Constant *Undef64  = UndefValue::get(Int64Ty);
   Constant *UndefV16 = UndefValue::get(P6->getType());
 
   #define P0STR "ptrtoint (i32** @dummy to i32)"
   #define P1STR "uitofp (i32 ptrtoint (i32** @dummy to i32) to float)"
TEST(ConstantsTest, AsInstructionsTest) {
   EXPECT_EQ(UndefV16, ConstantExpr::getInsertElement(P6, Elt, Two));
   EXPECT_EQ(UndefV16, ConstantExpr::getInsertElement(P6, Elt, Big));
   EXPECT_EQ(UndefV16, ConstantExpr::getInsertElement(P6, Elt, Undef64));
 }
 
 #ifdef GTEST_HAS_DEATH_TEST
 #ifndef NDEBUG
 TEST(ConstantsTest, ReplaceWithConstantTest) {
-  std::unique_ptr<Module> M(new Module("MyModule", getGlobalContext()));
+  LLVMContext Context;
+  std::unique_ptr<Module> M(new Module("MyModule", Context));
 
-  Type *Int32Ty = Type::getInt32Ty(getGlobalContext());
+  Type *Int32Ty = Type::getInt32Ty(Context);
   Constant *One = ConstantInt::get(Int32Ty, 1);
 
   Constant *Global =
       M->getOrInsertGlobal("dummy", PointerType::getUnqual(Int32Ty));
   Constant *GEP = ConstantExpr::getGetElementPtr(
       PointerType::getUnqual(Int32Ty), Global, One);
   EXPECT_DEATH(Global->replaceAllUsesWith(GEP),
                "this->replaceAllUsesWith\\(expr\\(this\\)\\) is NOT valid!");

unittests/IR/DominatorTreeTest.cpp

struct DPass : public FunctionPass {
         AU.addRequired<PostDominatorTreeWrapperPass>();
       }
       DPass() : FunctionPass(ID) {
         initializeDPassPass(*PassRegistry::getPassRegistry());
       }
     };
     char DPass::ID = 0;
 
-    std::unique_ptr<Module> makeLLVMModule(DPass *P) {
+    std::unique_ptr<Module> makeLLVMModule(LLVMContext &Context, DPass *P) {
       const char *ModuleStrig =
         "declare i32 @g()\n" \
         "define void @f(i32 %x) personality i32 ()* @g {\n" \
         "bb0:\n" \
         "  %y1 = add i32 %x, 1\n" \
         "  %y2 = add i32 %x, 1\n" \
         "  %y3 = invoke i32 @g() to label %bb1 unwind label %bb2\n" \
         "bb1:\n" \
         "  %y4 = add i32 %x, 1\n" \
         "  br label %bb4\n" \
         "bb2:\n" \
         "  %y5 = landingpad i32\n" \
         "          cleanup\n" \
         "  br label %bb4\n" \
         "bb3:\n" \
         "  %y6 = add i32 %x, 1\n" \
         "  %y7 = add i32 %x, 1\n" \
         "  ret void\n" \
         "bb4:\n" \
         "  %y8 = phi i32 [0, %bb2], [%y4, %bb1]\n"
         "  %y9 = phi i32 [0, %bb2], [%y4, %bb1]\n"
         "  ret void\n" \
         "}\n";
-      LLVMContext &C = getGlobalContext();
       SMDiagnostic Err;
-      return parseAssemblyString(ModuleStrig, Err, C);
+      return parseAssemblyString(ModuleStrig, Err, Context);
     }
 
     TEST(DominatorTree, Unreachable) {
       DPass *P = new DPass();
-      std::unique_ptr<Module> M = makeLLVMModule(P);
+      LLVMContext Context;
+      std::unique_ptr<Module> M = makeLLVMModule(Context, P);
       legacy::PassManager Passes;
       Passes.add(P);
       Passes.run(*M);
     }
   }
 }
 
 INITIALIZE_PASS_BEGIN(DPass, "dpass", "dpass", false, false)
 INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(PostDominatorTreeWrapperPass)
 INITIALIZE_PASS_END(DPass, "dpass", "dpass", false, false)

unittests/IR/InstructionsTest.cpp

 #include "llvm/IR/Operator.h"
 #include "gtest/gtest.h"
 #include <memory>
 
 namespace llvm {
 namespace {
 
 TEST(InstructionsTest, ReturnInst) {
-  LLVMContext &C(getGlobalContext());
+  LLVMContext C;
 
   // test for PR6589
   const ReturnInst* r0 = ReturnInst::Create(C);
   EXPECT_EQ(r0->getNumOperands(), 0U);
   EXPECT_EQ(r0->op_begin(), r0->op_end());
 
   IntegerType* Int1 = IntegerType::get(C, 1);
   Constant* One = ConstantInt::get(Int1, 1, true);
TEST_F(ModuleWithFunctionTest, InvokeInst) {
   for (Value *Arg : Invoke->arg_operands()) {
     EXPECT_EQ(FArgTypes[Idx], Arg->getType());
     EXPECT_EQ(Invoke->getArgOperand(Idx)->getType(), Arg->getType());
     Idx++;
   }
 }
 
 TEST(InstructionsTest, BranchInst) {
-  LLVMContext &C(getGlobalContext());
+  LLVMContext C;
 
   // Make a BasicBlocks
   BasicBlock* bb0 = BasicBlock::Create(C);
   BasicBlock* bb1 = BasicBlock::Create(C);
 
   // Mandatory BranchInst
   const BranchInst* b0 = BranchInst::Create(bb0);
 
TEST(InstructionsTest, BranchInst) {
   delete b0;
   delete b1;
 
   delete bb0;
   delete bb1;
 }
 
 TEST(InstructionsTest, CastInst) {
-  LLVMContext &C(getGlobalContext());
+  LLVMContext C;
 
   Type *Int8Ty = Type::getInt8Ty(C);
   Type *Int16Ty = Type::getInt16Ty(C);
   Type *Int32Ty = Type::getInt32Ty(C);
   Type *Int64Ty = Type::getInt64Ty(C);
   Type *V8x8Ty = VectorType::get(Int8Ty, 8);
   Type *V8x64Ty = VectorType::get(Int64Ty, 8);
   Type *X86MMXTy = Type::getX86_MMXTy(C);
EXPECT_FALSE(CastInst::castIsValid(Instruction::AddrSpaceCast,
                                      V4Int32PtrAS1Ty));
 
 
   // Check that assertion is not hit when creating a cast with a vector of
   // pointers
   // First form
   BasicBlock *BB = BasicBlock::Create(C);
   Constant *NullV2I32Ptr = Constant::getNullValue(V2Int32PtrTy);
-  CastInst::CreatePointerCast(NullV2I32Ptr, V2Int32Ty, "foo", BB);
+  auto Inst1 = CastInst::CreatePointerCast(NullV2I32Ptr, V2Int32Ty, "foo", BB);
 
   // Second form
-  CastInst::CreatePointerCast(NullV2I32Ptr, V2Int32Ty);
+  auto Inst2 = CastInst::CreatePointerCast(NullV2I32Ptr, V2Int32Ty);
+
+  delete Inst2;
+  Inst1->eraseFromParent();
+  delete BB;
 }
 
 TEST(InstructionsTest, VectorGep) {
-  LLVMContext &C(getGlobalContext());
+  LLVMContext C;
 
   // Type Definitions
   Type *I8Ty = IntegerType::get(C, 8);
   Type *I32Ty = IntegerType::get(C, 32);
   PointerType *Ptri8Ty = PointerType::get(I8Ty, 0);
   PointerType *Ptri32Ty = PointerType::get(I32Ty, 0);
 
   VectorType *V2xi8PTy = VectorType::get(Ptri8Ty, 2);
TEST(InstructionsTest, VectorGep) {
 
   delete ICmp0;
   delete ICmp1;
   delete PtrVecA;
   delete PtrVecB;
 }
 
 TEST(InstructionsTest, FPMathOperator) {
-  LLVMContext &Context = getGlobalContext();
+  LLVMContext Context;
   IRBuilder<> Builder(Context);
   MDBuilder MDHelper(Context);
   Instruction *I = Builder.CreatePHI(Builder.getDoubleTy(), 0);
   MDNode *MD1 = MDHelper.createFPMath(1.0);
   Value *V1 = Builder.CreateFAdd(I, I, "", MD1);
   EXPECT_TRUE(isa<FPMathOperator>(V1));
   FPMathOperator *O1 = cast<FPMathOperator>(V1);
   EXPECT_EQ(O1->getFPAccuracy(), 1.0);
   delete V1;
   delete I;
 }
 
 
 TEST(InstructionsTest, isEliminableCastPair) {
-  LLVMContext &C(getGlobalContext());
+  LLVMContext C;
 
   Type* Int16Ty = Type::getInt16Ty(C);
   Type* Int32Ty = Type::getInt32Ty(C);
   Type* Int64Ty = Type::getInt64Ty(C);
   Type* Int64PtrTy = Type::getInt64PtrTy(C);
 
   // Source and destination pointers have same size -> bitcast.
   EXPECT_EQ(CastInst::isEliminableCastPair(CastInst::PtrToInt,
EXPECT_EQ(CastInst::isEliminableCastPair(CastInst::IntToPtr,
                                            CastInst::BitCast,
                                            Int16Ty, Int64PtrTyAS1, Int64PtrTyAS1,
                                            nullptr, nullptr, nullptr),
             CastInst::IntToPtr);
 
 }
 
 TEST(InstructionsTest, CloneCall) {
-  LLVMContext &C(getGlobalContext());
+  LLVMContext C;
   Type *Int32Ty = Type::getInt32Ty(C);
   Type *ArgTys[] = {Int32Ty, Int32Ty, Int32Ty};
   Type *FnTy = FunctionType::get(Int32Ty, ArgTys, /*isVarArg=*/false);
   Value *Callee = Constant::getNullValue(FnTy->getPointerTo());
   Value *Args[] = {
     ConstantInt::get(Int32Ty, 1),
     ConstantInt::get(Int32Ty, 2),
     ConstantInt::get(Int32Ty, 3)
// Test cloning an attribute.
     AB.addAttribute(Attribute::ReadOnly);
     Call->setAttributes(AttributeSet::get(C, AttributeSet::FunctionIndex, AB));
     std::unique_ptr<CallInst> Clone(cast<CallInst>(Call->clone()));
     EXPECT_TRUE(Clone->onlyReadsMemory());
   }
 }
 
 TEST(InstructionsTest, AlterCallBundles) {
-  LLVMContext &C(getGlobalContext());
+  LLVMContext C;
   Type *Int32Ty = Type::getInt32Ty(C);
   Type *FnTy = FunctionType::get(Int32Ty, Int32Ty, /*isVarArg=*/false);
   Value *Callee = Constant::getNullValue(FnTy->getPointerTo());
   Value *Args[] = {ConstantInt::get(Int32Ty, 42)};
   OperandBundleDef OldBundle("before", UndefValue::get(Int32Ty));
   std::unique_ptr<CallInst> Call(
       CallInst::Create(Callee, Args, OldBundle, "result"));
   Call->setTailCallKind(CallInst::TailCallKind::TCK_NoTail);
TEST(InstructionsTest, AlterCallBundles) {
   EXPECT_EQ(Call->getTailCallKind(), Clone->getTailCallKind());
   EXPECT_TRUE(Clone->hasFnAttr(Attribute::AttrKind::Cold));
   EXPECT_EQ(Call->getDebugLoc(), Clone->getDebugLoc());
   EXPECT_EQ(Clone->getNumOperandBundles(), 1U);
   EXPECT_TRUE(Clone->getOperandBundle("after").hasValue());
 }
 
 TEST(InstructionsTest, AlterInvokeBundles) {
-  LLVMContext &C(getGlobalContext());
+  LLVMContext C;
   Type *Int32Ty = Type::getInt32Ty(C);
   Type *FnTy = FunctionType::get(Int32Ty, Int32Ty, /*isVarArg=*/false);
   Value *Callee = Constant::getNullValue(FnTy->getPointerTo());
   Value *Args[] = {ConstantInt::get(Int32Ty, 42)};
   std::unique_ptr<BasicBlock> NormalDest(BasicBlock::Create(C));
   std::unique_ptr<BasicBlock> UnwindDest(BasicBlock::Create(C));
   OperandBundleDef OldBundle("before", UndefValue::get(Int32Ty));
   std::unique_ptr<InvokeInst> Invoke(InvokeInst::Create(

unittests/IR/LegacyPassManagerTest.cpp

public:
       }
       void getAnalysisUsage(AnalysisUsage &AU) const override {
         AU.addRequired<FPass>();
       }
     };
     char OnTheFlyTest::ID=0;
 
     TEST(PassManager, RunOnce) {
-      Module M("test-once", getGlobalContext());
+      LLVMContext Context;
+      Module M("test-once", Context);
       struct ModuleNDNM *mNDNM = new ModuleNDNM();
       struct ModuleDNM *mDNM = new ModuleDNM();
       struct ModuleNDM *mNDM = new ModuleNDM();
       struct ModuleNDM2 *mNDM2 = new ModuleNDM2();
 
       mNDM->run = mNDNM->run = mDNM->run = mNDM2->run = 0;
 
       legacy::PassManager Passes;
       Passes.add(mNDM2);
       Passes.add(mNDM);
       Passes.add(mNDNM);
       Passes.add(mDNM);
 
       Passes.run(M);
       // each pass must be run exactly once, since nothing invalidates them
       EXPECT_EQ(1, mNDM->run);
       EXPECT_EQ(1, mNDNM->run);
       EXPECT_EQ(1, mDNM->run);
       EXPECT_EQ(1, mNDM2->run);
     }
 
     TEST(PassManager, ReRun) {
-      Module M("test-rerun", getGlobalContext());
+      LLVMContext Context;
+      Module M("test-rerun", Context);
       struct ModuleNDNM *mNDNM = new ModuleNDNM();
       struct ModuleDNM *mDNM = new ModuleDNM();
       struct ModuleNDM *mNDM = new ModuleNDM();
       struct ModuleNDM2 *mNDM2 = new ModuleNDM2();
 
       mNDM->run = mNDNM->run = mDNM->run = mNDM2->run = 0;
 
       legacy::PassManager Passes;
       Passes.add(mNDM);
       Passes.add(mNDNM);
       Passes.add(mNDM2);// invalidates mNDM needed by mDNM
       Passes.add(mDNM);
 
       Passes.run(M);
       // Some passes must be rerun because a pass that modified the
       // module/function was run in between
       EXPECT_EQ(2, mNDM->run);
       EXPECT_EQ(1, mNDNM->run);
       EXPECT_EQ(1, mNDM2->run);
       EXPECT_EQ(1, mDNM->run);
     }
 
-    Module* makeLLVMModule();
+    Module* makeLLVMModule(LLVMContext &Context);
 
     template<typename T>
     void MemoryTestHelper(int run) {
-      std::unique_ptr<Module> M(makeLLVMModule());
+      LLVMContext Context;
+      std::unique_ptr<Module> M(makeLLVMModule(Context));
       T *P = new T();
       legacy::PassManager Passes;
       Passes.add(P);
       Passes.run(*M);
       T::finishedOK(run);
     }
 
     template<typename T>
     void MemoryTestHelper(int run, int N) {
-      Module *M = makeLLVMModule();
+      LLVMContext Context;
+      Module *M = makeLLVMModule(Context);
       T *P = new T();
       legacy::PassManager Passes;
       Passes.add(P);
       Passes.run(*M);
       T::finishedOK(run, N);
       delete M;
     }
 
TEST(PassManager, Memory) {
       {
         SCOPED_TRACE("Basic block pass");
         MemoryTestHelper<BPass>(7, 4); //9 basic blocks
       }
 
     }
 
     TEST(PassManager, MemoryOnTheFly) {
-      Module *M = makeLLVMModule();
+      LLVMContext Context;
+      Module *M = makeLLVMModule(Context);
       {
         SCOPED_TRACE("Running OnTheFlyTest");
         struct OnTheFlyTest *O = new OnTheFlyTest();
         legacy::PassManager Passes;
         Passes.add(O);
         Passes.run(*M);
 
         FPass::finishedOK(4);
       }
       delete M;
     }
 
-    Module* makeLLVMModule() {
+    Module* makeLLVMModule(LLVMContext &Context) {
       // Module Construction
-      Module* mod = new Module("test-mem", getGlobalContext());
+      Module* mod = new Module("test-mem", Context);
       mod->setDataLayout("e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
                          "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
                          "a:0:64-s:64:64-f80:128:128");
       mod->setTargetTriple("x86_64-unknown-linux-gnu");
 
       // Type Definitions
       std::vector<Type*>FuncTy_0_args;
       FunctionType* FuncTy_0 = FunctionType::get(
-        /*Result=*/IntegerType::get(getGlobalContext(), 32),
+        /*Result=*/IntegerType::get(Context, 32),
         /*Params=*/FuncTy_0_args,
         /*isVarArg=*/false);
 
       std::vector<Type*>FuncTy_2_args;
-      FuncTy_2_args.push_back(IntegerType::get(getGlobalContext(), 1));
+      FuncTy_2_args.push_back(IntegerType::get(Context, 1));
       FunctionType* FuncTy_2 = FunctionType::get(
-        /*Result=*/Type::getVoidTy(getGlobalContext()),
+        /*Result=*/Type::getVoidTy(Context),
         /*Params=*/FuncTy_2_args,
         /*isVarArg=*/false);
 
 
       // Function Declarations
 
       Function* func_test1 = Function::Create(
         /*Type=*/FuncTy_0,
Module* makeLLVMModule(LLVMContext &Context) {
 
       // Global Variable Definitions
 
       // Function Definitions
 
       // Function: test1 (func_test1)
       {
 
-        BasicBlock* label_entry = BasicBlock::Create(getGlobalContext(), "entry",func_test1,nullptr);
+        BasicBlock* label_entry = BasicBlock::Create(Context, "entry",func_test1,nullptr);
 
         // Block entry (label_entry)
         CallInst* int32_3 = CallInst::Create(func_test2, "", label_entry);
         int32_3->setCallingConv(CallingConv::C);
         int32_3->setTailCall(false);AttributeSet int32_3_PAL;
         int32_3->setAttributes(int32_3_PAL);
 
-        ReturnInst::Create(getGlobalContext(), int32_3, label_entry);
+        ReturnInst::Create(Context, int32_3, label_entry);
 
       }
 
       // Function: test2 (func_test2)
       {
 
-        BasicBlock* label_entry_5 = BasicBlock::Create(getGlobalContext(), "entry",func_test2,nullptr);
+        BasicBlock* label_entry_5 = BasicBlock::Create(Context, "entry",func_test2,nullptr);
 
         // Block entry (label_entry_5)
         CallInst* int32_6 = CallInst::Create(func_test3, "", label_entry_5);
         int32_6->setCallingConv(CallingConv::C);
         int32_6->setTailCall(false);AttributeSet int32_6_PAL;
         int32_6->setAttributes(int32_6_PAL);
 
-        ReturnInst::Create(getGlobalContext(), int32_6, label_entry_5);
+        ReturnInst::Create(Context, int32_6, label_entry_5);
 
       }
 
       // Function: test3 (func_test3)
       {
 
-        BasicBlock* label_entry_8 = BasicBlock::Create(getGlobalContext(), "entry",func_test3,nullptr);
+        BasicBlock* label_entry_8 = BasicBlock::Create(Context, "entry",func_test3,nullptr);
 
         // Block entry (label_entry_8)
         CallInst* int32_9 = CallInst::Create(func_test1, "", label_entry_8);
         int32_9->setCallingConv(CallingConv::C);
         int32_9->setTailCall(false);AttributeSet int32_9_PAL;
         int32_9->setAttributes(int32_9_PAL);
 
-        ReturnInst::Create(getGlobalContext(), int32_9, label_entry_8);
+        ReturnInst::Create(Context, int32_9, label_entry_8);
 
       }
 
       // Function: test4 (func_test4)
       {
         Function::arg_iterator args = func_test4->arg_begin();
         Value *int1_f = &*args++;
         int1_f->setName("f");
 
-        BasicBlock* label_entry_11 = BasicBlock::Create(getGlobalContext(), "entry",func_test4,nullptr);
-        BasicBlock* label_bb = BasicBlock::Create(getGlobalContext(), "bb",func_test4,nullptr);
-        BasicBlock* label_bb1 = BasicBlock::Create(getGlobalContext(), "bb1",func_test4,nullptr);
-        BasicBlock* label_return = BasicBlock::Create(getGlobalContext(), "return",func_test4,nullptr);
+        BasicBlock* label_entry_11 = BasicBlock::Create(Context, "entry",func_test4,nullptr);
+        BasicBlock* label_bb = BasicBlock::Create(Context, "bb",func_test4,nullptr);
+        BasicBlock* label_bb1 = BasicBlock::Create(Context, "bb1",func_test4,nullptr);
+        BasicBlock* label_return = BasicBlock::Create(Context, "return",func_test4,nullptr);
 
         // Block entry (label_entry_11)
         BranchInst::Create(label_bb, label_entry_11);
 
         // Block bb (label_bb)
         BranchInst::Create(label_bb, label_bb1, int1_f, label_bb);
 
         // Block bb1 (label_bb1)
         BranchInst::Create(label_bb1, label_return, int1_f, label_bb1);
 
         // Block return (label_return)
-        ReturnInst::Create(getGlobalContext(), label_return);
+        ReturnInst::Create(Context, label_return);
 
       }
       return mod;
     }
 
   }
 }
 

unittests/IR/MetadataTest.cpp

 // Test the two constructors, and containing other Constants.
 TEST_F(MDNodeTest, Simple) {
   char x[3] = { 'a', 'b', 'c' };
   char y[3] = { '1', '2', '3' };
 
   MDString *s1 = MDString::get(Context, StringRef(&x[0], 3));
   MDString *s2 = MDString::get(Context, StringRef(&y[0], 3));
   ConstantAsMetadata *CI = ConstantAsMetadata::get(
-      ConstantInt::get(getGlobalContext(), APInt(8, 0)));
+      ConstantInt::get(Context, APInt(8, 0)));
 
   std::vector<Metadata *> V;
   V.push_back(s1);
   V.push_back(CI);
   V.push_back(s2);
 
   MDNode *n1 = MDNode::get(Context, V);
   Metadata *const c1 = n1;
TEST_F(MDNodeTest, Simple) {
   EXPECT_EQ(CI, n1->getOperand(1));
   EXPECT_EQ(s2, n1->getOperand(2));
 
   EXPECT_EQ(1u, n2->getNumOperands());
   EXPECT_EQ(n1, n2->getOperand(0));
 }
 
 TEST_F(MDNodeTest, Delete) {
-  Constant *C = ConstantInt::get(Type::getInt32Ty(getGlobalContext()), 1);
-  Instruction *I = new BitCastInst(C, Type::getInt32Ty(getGlobalContext()));
+  Constant *C = ConstantInt::get(Type::getInt32Ty(Context), 1);
+  Instruction *I = new BitCastInst(C, Type::getInt32Ty(Context));
 
   Metadata *const V = LocalAsMetadata::get(I);
   MDNode *n = MDNode::get(Context, V);
   TrackingMDRef wvh(n);
 
   EXPECT_EQ(n, wvh);
 
   delete I;
std::unique_ptr<GlobalVariable> GV1(
       new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage));
   GV0->replaceAllUsesWith(GV1.get());
   EXPECT_TRUE(MD->getValue() == GV1.get());
 }
 
 TEST_F(ValueAsMetadataTest, TempTempReplacement) {
   // Create a constant.
   ConstantAsMetadata *CI = ConstantAsMetadata::get(
-      ConstantInt::get(getGlobalContext(), APInt(8, 0)));
+      ConstantInt::get(Context, APInt(8, 0)));
 
   auto Temp1 = MDTuple::getTemporary(Context, None);
   auto Temp2 = MDTuple::getTemporary(Context, {CI});
   auto *N = MDTuple::get(Context, {Temp1.get()});
 
   // Test replacing a temporary node with another temporary node.
   Temp1->replaceAllUsesWith(Temp2.get());
   EXPECT_EQ(N->getOperand(0), Temp2.get());
 
   // Clean up Temp2 for teardown.
   Temp2->replaceAllUsesWith(nullptr);
 }
 
 TEST_F(ValueAsMetadataTest, CollidingDoubleUpdates) {
   // Create a constant.
   ConstantAsMetadata *CI = ConstantAsMetadata::get(
-      ConstantInt::get(getGlobalContext(), APInt(8, 0)));
+      ConstantInt::get(Context, APInt(8, 0)));
 
   // Create a temporary to prevent nodes from resolving.
   auto Temp = MDTuple::getTemporary(Context, None);
 
   // When the first operand of N1 gets reset to nullptr, it'll collide with N2.
   Metadata *Ops1[] = {CI, CI, Temp.get()};
   Metadata *Ops2[] = {nullptr, CI, Temp.get()};
 

unittests/IR/PassManagerTest.cpp

struct TestInvalidationFunctionPass
   PreservedAnalyses run(Function &F) {
     return F.getName() == Name ? PreservedAnalyses::none()
                                : PreservedAnalyses::all();
   }
 
   StringRef Name;
 };
 
-std::unique_ptr<Module> parseIR(const char *IR) {
-  LLVMContext &C = getGlobalContext();
+std::unique_ptr<Module> parseIR(LLVMContext &Context, const char *IR) {
   SMDiagnostic Err;
-  return parseAssemblyString(IR, Err, C);
+  return parseAssemblyString(IR, Err, Context);
 }
 
 class PassManagerTest : public ::testing::Test {
 protected:
+  LLVMContext Context;
   std::unique_ptr<Module> M;
 
 public:
   PassManagerTest()
-      : M(parseIR("define void @f() {\n"
+      : M(parseIR(Context,
+                  "define void @f() {\n"
                   "entry:\n"
                   "  call void @g()\n"
                   "  call void @h()\n"
                   "  ret void\n"
                   "}\n"
                   "define void @g() {\n"
                   "  ret void\n"
                   "}\n"

unittests/IR/TypeBuilderTest.cpp

 #include "llvm/IR/LLVMContext.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 
 namespace {
 
 TEST(TypeBuilderTest, Void) {
-  EXPECT_EQ(Type::getVoidTy(getGlobalContext()), (TypeBuilder<void, true>::get(getGlobalContext())));
-  EXPECT_EQ(Type::getVoidTy(getGlobalContext()), (TypeBuilder<void, false>::get(getGlobalContext())));
+  LLVMContext Context;
+  EXPECT_EQ(Type::getVoidTy(Context), (TypeBuilder<void, true>::get(Context)));
+  EXPECT_EQ(Type::getVoidTy(Context), (TypeBuilder<void, false>::get(Context)));
   // Special cases for C compatibility:
-  EXPECT_EQ(Type::getInt8PtrTy(getGlobalContext()),
-            (TypeBuilder<void*, false>::get(getGlobalContext())));
-  EXPECT_EQ(Type::getInt8PtrTy(getGlobalContext()),
-            (TypeBuilder<const void*, false>::get(getGlobalContext())));
-  EXPECT_EQ(Type::getInt8PtrTy(getGlobalContext()),
-            (TypeBuilder<volatile void*, false>::get(getGlobalContext())));
-  EXPECT_EQ(Type::getInt8PtrTy(getGlobalContext()),
+  EXPECT_EQ(Type::getInt8PtrTy(Context),
+            (TypeBuilder<void*, false>::get(Context)));
+  EXPECT_EQ(Type::getInt8PtrTy(Context),
+            (TypeBuilder<const void*, false>::get(Context)));
+  EXPECT_EQ(Type::getInt8PtrTy(Context),
+            (TypeBuilder<volatile void*, false>::get(Context)));
+  EXPECT_EQ(Type::getInt8PtrTy(Context),
             (TypeBuilder<const volatile void*, false>::get(
-              getGlobalContext())));
+              Context)));
 }
 
 TEST(TypeBuilderTest, HostIntegers) {
-  EXPECT_EQ(Type::getInt8Ty(getGlobalContext()), (TypeBuilder<int8_t, false>::get(getGlobalContext())));
-  EXPECT_EQ(Type::getInt8Ty(getGlobalContext()), (TypeBuilder<uint8_t, false>::get(getGlobalContext())));
-  EXPECT_EQ(Type::getInt16Ty(getGlobalContext()), (TypeBuilder<int16_t, false>::get(getGlobalContext())));
-  EXPECT_EQ(Type::getInt16Ty(getGlobalContext()), (TypeBuilder<uint16_t, false>::get(getGlobalContext())));
-  EXPECT_EQ(Type::getInt32Ty(getGlobalContext()), (TypeBuilder<int32_t, false>::get(getGlobalContext())));
-  EXPECT_EQ(Type::getInt32Ty(getGlobalContext()), (TypeBuilder<uint32_t, false>::get(getGlobalContext())));
-  EXPECT_EQ(Type::getInt64Ty(getGlobalContext()), (TypeBuilder<int64_t, false>::get(getGlobalContext())));
-  EXPECT_EQ(Type::getInt64Ty(getGlobalContext()), (TypeBuilder<uint64_t, false>::get(getGlobalContext())));
-
-  EXPECT_EQ(IntegerType::get(getGlobalContext(), sizeof(size_t) * CHAR_BIT),
-            (TypeBuilder<size_t, false>::get(getGlobalContext())));
-  EXPECT_EQ(IntegerType::get(getGlobalContext(), sizeof(ptrdiff_t) * CHAR_BIT),
-            (TypeBuilder<ptrdiff_t, false>::get(getGlobalContext())));
+  LLVMContext Context;
+  EXPECT_EQ(Type::getInt8Ty(Context), (TypeBuilder<int8_t, false>::get(Context)));
+  EXPECT_EQ(Type::getInt8Ty(Context), (TypeBuilder<uint8_t, false>::get(Context)));
+  EXPECT_EQ(Type::getInt16Ty(Context), (TypeBuilder<int16_t, false>::get(Context)));
+  EXPECT_EQ(Type::getInt16Ty(Context), (TypeBuilder<uint16_t, false>::get(Context)));
+  EXPECT_EQ(Type::getInt32Ty(Context), (TypeBuilder<int32_t, false>::get(Context)));
+  EXPECT_EQ(Type::getInt32Ty(Context), (TypeBuilder<uint32_t, false>::get(Context)));
+  EXPECT_EQ(Type::getInt64Ty(Context), (TypeBuilder<int64_t, false>::get(Context)));
+  EXPECT_EQ(Type::getInt64Ty(Context), (TypeBuilder<uint64_t, false>::get(Context)));
+
+  EXPECT_EQ(IntegerType::get(Context, sizeof(size_t) * CHAR_BIT),
+            (TypeBuilder<size_t, false>::get(Context)));
+  EXPECT_EQ(IntegerType::get(Context, sizeof(ptrdiff_t) * CHAR_BIT),
+            (TypeBuilder<ptrdiff_t, false>::get(Context)));
 }
 
 TEST(TypeBuilderTest, CrossCompilableIntegers) {
-  EXPECT_EQ(IntegerType::get(getGlobalContext(), 1), (TypeBuilder<types::i<1>, true>::get(getGlobalContext())));
-  EXPECT_EQ(IntegerType::get(getGlobalContext(), 1), (TypeBuilder<types::i<1>, false>::get(getGlobalContext())));
-  EXPECT_EQ(IntegerType::get(getGlobalContext(), 72), (TypeBuilder<types::i<72>, true>::get(getGlobalContext())));
-  EXPECT_EQ(IntegerType::get(getGlobalContext(), 72), (TypeBuilder<types::i<72>, false>::get(getGlobalContext())));
+  LLVMContext Context;
+  EXPECT_EQ(IntegerType::get(Context, 1), (TypeBuilder<types::i<1>, true>::get(Context)));
+  EXPECT_EQ(IntegerType::get(Context, 1), (TypeBuilder<types::i<1>, false>::get(Context)));
+  EXPECT_EQ(IntegerType::get(Context, 72), (TypeBuilder<types::i<72>, true>::get(Context)));
+  EXPECT_EQ(IntegerType::get(Context, 72), (TypeBuilder<types::i<72>, false>::get(Context)));
 }
 
 TEST(TypeBuilderTest, Float) {
-  EXPECT_EQ(Type::getFloatTy(getGlobalContext()), (TypeBuilder<float, false>::get(getGlobalContext())));
-  EXPECT_EQ(Type::getDoubleTy(getGlobalContext()), (TypeBuilder<double, false>::get(getGlobalContext())));
+  LLVMContext Context;
+  EXPECT_EQ(Type::getFloatTy(Context), (TypeBuilder<float, false>::get(Context)));
+  EXPECT_EQ(Type::getDoubleTy(Context), (TypeBuilder<double, false>::get(Context)));
   // long double isn't supported yet.
-  EXPECT_EQ(Type::getFloatTy(getGlobalContext()), (TypeBuilder<types::ieee_float, true>::get(getGlobalContext())));
-  EXPECT_EQ(Type::getFloatTy(getGlobalContext()), (TypeBuilder<types::ieee_float, false>::get(getGlobalContext())));
-  EXPECT_EQ(Type::getDoubleTy(getGlobalContext()), (TypeBuilder<types::ieee_double, true>::get(getGlobalContext())));
-  EXPECT_EQ(Type::getDoubleTy(getGlobalContext()), (TypeBuilder<types::ieee_double, false>::get(getGlobalContext())));
-  EXPECT_EQ(Type::getX86_FP80Ty(getGlobalContext()), (TypeBuilder<types::x86_fp80, true>::get(getGlobalContext())));
-  EXPECT_EQ(Type::getX86_FP80Ty(getGlobalContext()), (TypeBuilder<types::x86_fp80, false>::get(getGlobalContext())));
-  EXPECT_EQ(Type::getFP128Ty(getGlobalContext()), (TypeBuilder<types::fp128, true>::get(getGlobalContext())));
-  EXPECT_EQ(Type::getFP128Ty(getGlobalContext()), (TypeBuilder<types::fp128, false>::get(getGlobalContext())));
-  EXPECT_EQ(Type::getPPC_FP128Ty(getGlobalContext()), (TypeBuilder<types::ppc_fp128, true>::get(getGlobalContext())));
-  EXPECT_EQ(Type::getPPC_FP128Ty(getGlobalContext()), (TypeBuilder<types::ppc_fp128, false>::get(getGlobalContext())));
+  EXPECT_EQ(Type::getFloatTy(Context), (TypeBuilder<types::ieee_float, true>::get(Context)));
+  EXPECT_EQ(Type::getFloatTy(Context), (TypeBuilder<types::ieee_float, false>::get(Context)));
+  EXPECT_EQ(Type::getDoubleTy(Context), (TypeBuilder<types::ieee_double, true>::get(Context)));
+  EXPECT_EQ(Type::getDoubleTy(Context), (TypeBuilder<types::ieee_double, false>::get(Context)));
+  EXPECT_EQ(Type::getX86_FP80Ty(Context), (TypeBuilder<types::x86_fp80, true>::get(Context)));
+  EXPECT_EQ(Type::getX86_FP80Ty(Context), (TypeBuilder<types::x86_fp80, false>::get(Context)));
+  EXPECT_EQ(Type::getFP128Ty(Context), (TypeBuilder<types::fp128, true>::get(Context)));
+  EXPECT_EQ(Type::getFP128Ty(Context), (TypeBuilder<types::fp128, false>::get(Context)));
+  EXPECT_EQ(Type::getPPC_FP128Ty(Context), (TypeBuilder<types::ppc_fp128, true>::get(Context)));
+  EXPECT_EQ(Type::getPPC_FP128Ty(Context), (TypeBuilder<types::ppc_fp128, false>::get(Context)));
 }
 
 TEST(TypeBuilderTest, Derived) {
-  EXPECT_EQ(PointerType::getUnqual(Type::getInt8PtrTy(getGlobalContext())),
-            (TypeBuilder<int8_t**, false>::get(getGlobalContext())));
-  EXPECT_EQ(ArrayType::get(Type::getInt8Ty(getGlobalContext()), 7),
-            (TypeBuilder<int8_t[7], false>::get(getGlobalContext())));
-  EXPECT_EQ(ArrayType::get(Type::getInt8Ty(getGlobalContext()), 0),
-            (TypeBuilder<int8_t[], false>::get(getGlobalContext())));
-
-  EXPECT_EQ(PointerType::getUnqual(Type::getInt8PtrTy(getGlobalContext())),
-            (TypeBuilder<types::i<8>**, false>::get(getGlobalContext())));
-  EXPECT_EQ(ArrayType::get(Type::getInt8Ty(getGlobalContext()), 7),
-            (TypeBuilder<types::i<8>[7], false>::get(getGlobalContext())));
-  EXPECT_EQ(ArrayType::get(Type::getInt8Ty(getGlobalContext()), 0),
-            (TypeBuilder<types::i<8>[], false>::get(getGlobalContext())));
-
-  EXPECT_EQ(PointerType::getUnqual(Type::getInt8PtrTy(getGlobalContext())),
-            (TypeBuilder<types::i<8>**, true>::get(getGlobalContext())));
-  EXPECT_EQ(ArrayType::get(Type::getInt8Ty(getGlobalContext()), 7),
-            (TypeBuilder<types::i<8>[7], true>::get(getGlobalContext())));
-  EXPECT_EQ(ArrayType::get(Type::getInt8Ty(getGlobalContext()), 0),
-            (TypeBuilder<types::i<8>[], true>::get(getGlobalContext())));
-
-
-  EXPECT_EQ(Type::getInt8Ty(getGlobalContext()),
-            (TypeBuilder<const int8_t, false>::get(getGlobalContext())));
-  EXPECT_EQ(Type::getInt8Ty(getGlobalContext()),
-            (TypeBuilder<volatile int8_t, false>::get(getGlobalContext())));
-  EXPECT_EQ(Type::getInt8Ty(getGlobalContext()),
-            (TypeBuilder<const volatile int8_t, false>::get(getGlobalContext())));
-
-  EXPECT_EQ(Type::getInt8Ty(getGlobalContext()),
-            (TypeBuilder<const types::i<8>, false>::get(getGlobalContext())));
-  EXPECT_EQ(Type::getInt8Ty(getGlobalContext()),
-            (TypeBuilder<volatile types::i<8>, false>::get(getGlobalContext())));
-  EXPECT_EQ(Type::getInt8Ty(getGlobalContext()),
-            (TypeBuilder<const volatile types::i<8>, false>::get(getGlobalContext())));
-
-  EXPECT_EQ(Type::getInt8Ty(getGlobalContext()),
-            (TypeBuilder<const types::i<8>, true>::get(getGlobalContext())));
-  EXPECT_EQ(Type::getInt8Ty(getGlobalContext()),
-            (TypeBuilder<volatile types::i<8>, true>::get(getGlobalContext())));
-  EXPECT_EQ(Type::getInt8Ty(getGlobalContext()),
-            (TypeBuilder<const volatile types::i<8>, true>::get(getGlobalContext())));
+  LLVMContext Context;
+  EXPECT_EQ(PointerType::getUnqual(Type::getInt8PtrTy(Context)),
+            (TypeBuilder<int8_t**, false>::get(Context)));
+  EXPECT_EQ(ArrayType::get(Type::getInt8Ty(Context), 7),
+            (TypeBuilder<int8_t[7], false>::get(Context)));
+  EXPECT_EQ(ArrayType::get(Type::getInt8Ty(Context), 0),
+            (TypeBuilder<int8_t[], false>::get(Context)));
+
+  EXPECT_EQ(PointerType::getUnqual(Type::getInt8PtrTy(Context)),
+            (TypeBuilder<types::i<8>**, false>::get(Context)));
+  EXPECT_EQ(ArrayType::get(Type::getInt8Ty(Context), 7),
+            (TypeBuilder<types::i<8>[7], false>::get(Context)));
+  EXPECT_EQ(ArrayType::get(Type::getInt8Ty(Context), 0),
+            (TypeBuilder<types::i<8>[], false>::get(Context)));
+
+  EXPECT_EQ(PointerType::getUnqual(Type::getInt8PtrTy(Context)),
+            (TypeBuilder<types::i<8>**, true>::get(Context)));
+  EXPECT_EQ(ArrayType::get(Type::getInt8Ty(Context), 7),
+            (TypeBuilder<types::i<8>[7], true>::get(Context)));
+  EXPECT_EQ(ArrayType::get(Type::getInt8Ty(Context), 0),
+            (TypeBuilder<types::i<8>[], true>::get(Context)));
+
+
+  EXPECT_EQ(Type::getInt8Ty(Context),
+            (TypeBuilder<const int8_t, false>::get(Context)));
+  EXPECT_EQ(Type::getInt8Ty(Context),
+            (TypeBuilder<volatile int8_t, false>::get(Context)));
+  EXPECT_EQ(Type::getInt8Ty(Context),
+            (TypeBuilder<const volatile int8_t, false>::get(Context)));
+
+  EXPECT_EQ(Type::getInt8Ty(Context),
+            (TypeBuilder<const types::i<8>, false>::get(Context)));
+  EXPECT_EQ(Type::getInt8Ty(Context),
+            (TypeBuilder<volatile types::i<8>, false>::get(Context)));
+  EXPECT_EQ(Type::getInt8Ty(Context),
+            (TypeBuilder<const volatile types::i<8>, false>::get(Context)));
+
+  EXPECT_EQ(Type::getInt8Ty(Context),
+            (TypeBuilder<const types::i<8>, true>::get(Context)));
+  EXPECT_EQ(Type::getInt8Ty(Context),
+            (TypeBuilder<volatile types::i<8>, true>::get(Context)));
+  EXPECT_EQ(Type::getInt8Ty(Context),
+            (TypeBuilder<const volatile types::i<8>, true>::get(Context)));
 
-  EXPECT_EQ(Type::getInt8PtrTy(getGlobalContext()),
-            (TypeBuilder<const volatile int8_t*const volatile, false>::get(getGlobalContext())));
+  EXPECT_EQ(Type::getInt8PtrTy(Context),
+            (TypeBuilder<const volatile int8_t*const volatile, false>::get(Context)));
 }
 
 TEST(TypeBuilderTest, Functions) {
+  LLVMContext Context;
   std::vector<Type*> params;
-  EXPECT_EQ(FunctionType::get(Type::getVoidTy(getGlobalContext()), params, false),
-            (TypeBuilder<void(), true>::get(getGlobalContext())));
-  EXPECT_EQ(FunctionType::get(Type::getInt8Ty(getGlobalContext()), params, true),
-            (TypeBuilder<int8_t(...), false>::get(getGlobalContext())));
-  params.push_back(TypeBuilder<int32_t*, false>::get(getGlobalContext()));
-  EXPECT_EQ(FunctionType::get(Type::getInt8Ty(getGlobalContext()), params, false),
-            (TypeBuilder<int8_t(const int32_t*), false>::get(getGlobalContext())));
-  EXPECT_EQ(FunctionType::get(Type::getInt8Ty(getGlobalContext()), params, true),
-            (TypeBuilder<int8_t(const int32_t*, ...), false>::get(getGlobalContext())));
-  params.push_back(TypeBuilder<char*, false>::get(getGlobalContext()));
-  EXPECT_EQ(FunctionType::get(Type::getInt8Ty(getGlobalContext()), params, false),
-            (TypeBuilder<int8_t(int32_t*, void*), false>::get(getGlobalContext())));
-  EXPECT_EQ(FunctionType::get(Type::getInt8Ty(getGlobalContext()), params, true),
-            (TypeBuilder<int8_t(int32_t*, char*, ...), false>::get(getGlobalContext())));
-  params.push_back(TypeBuilder<char, false>::get(getGlobalContext()));
-  EXPECT_EQ(FunctionType::get(Type::getInt8Ty(getGlobalContext()), params, false),
-            (TypeBuilder<int8_t(int32_t*, void*, char), false>::get(getGlobalContext())));
-  EXPECT_EQ(FunctionType::get(Type::getInt8Ty(getGlobalContext()), params, true),
-            (TypeBuilder<int8_t(int32_t*, char*, char, ...), false>::get(getGlobalContext())));
-  params.push_back(TypeBuilder<char, false>::get(getGlobalContext()));
-  EXPECT_EQ(FunctionType::get(Type::getInt8Ty(getGlobalContext()), params, false),
-            (TypeBuilder<int8_t(int32_t*, void*, char, char), false>::get(getGlobalContext())));
-  EXPECT_EQ(FunctionType::get(Type::getInt8Ty(getGlobalContext()), params, true),
+  EXPECT_EQ(FunctionType::get(Type::getVoidTy(Context), params, false),
+            (TypeBuilder<void(), true>::get(Context)));
+  EXPECT_EQ(FunctionType::get(Type::getInt8Ty(Context), params, true),
+            (TypeBuilder<int8_t(...), false>::get(Context)));
+  params.push_back(TypeBuilder<int32_t*, false>::get(Context));
+  EXPECT_EQ(FunctionType::get(Type::getInt8Ty(Context), params, false),
+            (TypeBuilder<int8_t(const int32_t*), false>::get(Context)));
+  EXPECT_EQ(FunctionType::get(Type::getInt8Ty(Context), params, true),
+            (TypeBuilder<int8_t(const int32_t*, ...), false>::get(Context)));
+  params.push_back(TypeBuilder<char*, false>::get(Context));
+  EXPECT_EQ(FunctionType::get(Type::getInt8Ty(Context), params, false),
+            (TypeBuilder<int8_t(int32_t*, void*), false>::get(Context)));
+  EXPECT_EQ(FunctionType::get(Type::getInt8Ty(Context), params, true),
+            (TypeBuilder<int8_t(int32_t*, char*, ...), false>::get(Context)));
+  params.push_back(TypeBuilder<char, false>::get(Context));
+  EXPECT_EQ(FunctionType::get(Type::getInt8Ty(Context), params, false),
+            (TypeBuilder<int8_t(int32_t*, void*, char), false>::get(Context)));
+  EXPECT_EQ(FunctionType::get(Type::getInt8Ty(Context), params, true),
+            (TypeBuilder<int8_t(int32_t*, char*, char, ...), false>::get(Context)));
+  params.push_back(TypeBuilder<char, false>::get(Context));
+  EXPECT_EQ(FunctionType::get(Type::getInt8Ty(Context), params, false),
+            (TypeBuilder<int8_t(int32_t*, void*, char, char), false>::get(Context)));
+  EXPECT_EQ(FunctionType::get(Type::getInt8Ty(Context), params, true),
             (TypeBuilder<int8_t(int32_t*, char*, char, char, ...),
-                         false>::get(getGlobalContext())));
-  params.push_back(TypeBuilder<char, false>::get(getGlobalContext()));
-  EXPECT_EQ(FunctionType::get(Type::getInt8Ty(getGlobalContext()), params, false),
+                         false>::get(Context)));
+  params.push_back(TypeBuilder<char, false>::get(Context));
+  EXPECT_EQ(FunctionType::get(Type::getInt8Ty(Context), params, false),
             (TypeBuilder<int8_t(int32_t*, void*, char, char, char),
-                         false>::get(getGlobalContext())));
-  EXPECT_EQ(FunctionType::get(Type::getInt8Ty(getGlobalContext()), params, true),
+                         false>::get(Context)));
+  EXPECT_EQ(FunctionType::get(Type::getInt8Ty(Context), params, true),
             (TypeBuilder<int8_t(int32_t*, char*, char, char, char, ...),
-                         false>::get(getGlobalContext())));
+                         false>::get(Context)));
 }
 
 TEST(TypeBuilderTest, Context) {
   // We used to cache TypeBuilder results in static local variables.  This
   // produced the same type for different contexts, which of course broke
   // things.
   LLVMContext context1;
   EXPECT_EQ(&context1,
enum Fields {
     FIELD_B,
     FIELD_ARRAY
   };
 };
 }  // namespace llvm
 namespace {
 
 TEST(TypeBuilderTest, Extensions) {
+  LLVMContext Context;
   EXPECT_EQ(PointerType::getUnqual(StructType::get(
-                                     TypeBuilder<int, false>::get(getGlobalContext()),
-                                     TypeBuilder<int*, false>::get(getGlobalContext()),
-                                     TypeBuilder<void*[], false>::get(getGlobalContext()),
+                                     TypeBuilder<int, false>::get(Context),
+                                     TypeBuilder<int*, false>::get(Context),
+                                     TypeBuilder<void*[], false>::get(Context),
                                      (void*)nullptr)),
-            (TypeBuilder<MyType*, false>::get(getGlobalContext())));
+            (TypeBuilder<MyType*, false>::get(Context)));
   EXPECT_EQ(PointerType::getUnqual(StructType::get(
-                                     TypeBuilder<types::i<32>, false>::get(getGlobalContext()),
-                                     TypeBuilder<types::i<32>*, false>::get(getGlobalContext()),
-                                     TypeBuilder<types::i<8>*[], false>::get(getGlobalContext()),
+                                     TypeBuilder<types::i<32>, false>::get(Context),
+                                     TypeBuilder<types::i<32>*, false>::get(Context),
+                                     TypeBuilder<types::i<8>*[], false>::get(Context),
                                      (void*)nullptr)),
-            (TypeBuilder<MyPortableType*, false>::get(getGlobalContext())));
+            (TypeBuilder<MyPortableType*, false>::get(Context)));
   EXPECT_EQ(PointerType::getUnqual(StructType::get(
-                                     TypeBuilder<types::i<32>, false>::get(getGlobalContext()),
-                                     TypeBuilder<types::i<32>*, false>::get(getGlobalContext()),
-                                     TypeBuilder<types::i<8>*[], false>::get(getGlobalContext()),
+                                     TypeBuilder<types::i<32>, false>::get(Context),
+                                     TypeBuilder<types::i<32>*, false>::get(Context),
+                                     TypeBuilder<types::i<8>*[], false>::get(Context),
                                      (void*)nullptr)),
-            (TypeBuilder<MyPortableType*, true>::get(getGlobalContext())));
+            (TypeBuilder<MyPortableType*, true>::get(Context)));
 }
 
 }  // anonymous namespace

unittests/IR/UserTest.cpp

TEST(UserTest, ValueOpIteration) {
   EXPECT_EQ(std::next(P.value_op_begin(), 3), I);
   EXPECT_EQ(P.getOperand(3), *I);
   I++;
   EXPECT_EQ(P.getOperand(6), I[2]);
   EXPECT_EQ(P.value_op_end(), (I - 2) + 8);
 }
 
 TEST(UserTest, PersonalityUser) {
-  Module M("", getGlobalContext());
+  LLVMContext Context;
+  Module M("", Context);
   FunctionType *RetVoidTy =
-      FunctionType::get(Type::getVoidTy(getGlobalContext()), false);
+      FunctionType::get(Type::getVoidTy(Context), false);
   Function *PersonalityF = Function::Create(
       RetVoidTy, GlobalValue::ExternalLinkage, "PersonalityFn", &M);
   Function *TestF =
       Function::Create(RetVoidTy, GlobalValue::ExternalLinkage, "TestFn", &M);
 
   // Set up the personality function
   TestF->setPersonalityFn(PersonalityF);
   auto PersonalityUsers = PersonalityF->user_begin();

unittests/IR/ValueHandleTest.cpp

 #include <memory>
 
 using namespace llvm;
 
 namespace {
 
 class ValueHandle : public testing::Test {
 protected:
+  LLVMContext Context;
   Constant *ConstantV;
   std::unique_ptr<BitCastInst> BitcastV;
 
   ValueHandle() :
-    ConstantV(ConstantInt::get(Type::getInt32Ty(getGlobalContext()), 0)),
-    BitcastV(new BitCastInst(ConstantV, Type::getInt32Ty(getGlobalContext()))) {
+    ConstantV(ConstantInt::get(Type::getInt32Ty(Context), 0)),
+    BitcastV(new BitCastInst(ConstantV, Type::getInt32Ty(Context))) {
   }
 };
 
 class ConcreteCallbackVH final : public CallbackVH {
 public:
   ConcreteCallbackVH(Value *V) : CallbackVH(V) {}
 };
 
 TEST_F(ValueHandle, WeakVH_BasicOperation) {
   WeakVH WVH(BitcastV.get());
   EXPECT_EQ(BitcastV.get(), WVH);
   WVH = ConstantV;
   EXPECT_EQ(ConstantV, WVH);
 
   // Make sure I can call a method on the underlying Value.  It
   // doesn't matter which method.
-  EXPECT_EQ(Type::getInt32Ty(getGlobalContext()), WVH->getType());
-  EXPECT_EQ(Type::getInt32Ty(getGlobalContext()), (*WVH).getType());
+  EXPECT_EQ(Type::getInt32Ty(Context), WVH->getType());
+  EXPECT_EQ(Type::getInt32Ty(Context), (*WVH).getType());
 }
 
 TEST_F(ValueHandle, WeakVH_Comparisons) {
   WeakVH BitcastWVH(BitcastV.get());
   WeakVH ConstantWVH(ConstantV);
 
   EXPECT_TRUE(BitcastWVH == BitcastWVH);
   EXPECT_TRUE(BitcastV.get() == BitcastWVH);

 TEST_F(ValueHandle, CallbackVH_BasicOperation) {
   ConcreteCallbackVH CVH(BitcastV.get());
   EXPECT_EQ(BitcastV.get(), CVH);
   CVH = ConstantV;
   EXPECT_EQ(ConstantV, CVH);
 
   // Make sure I can call a method on the underlying Value.  It
   // doesn't matter which method.
-  EXPECT_EQ(Type::getInt32Ty(getGlobalContext()), CVH->getType());
-  EXPECT_EQ(Type::getInt32Ty(getGlobalContext()), (*CVH).getType());
+  EXPECT_EQ(Type::getInt32Ty(Context), CVH->getType());
+  EXPECT_EQ(Type::getInt32Ty(Context), (*CVH).getType());
 }
 
 TEST_F(ValueHandle, CallbackVH_Comparisons) {
   ConcreteCallbackVH BitcastCVH(BitcastV.get());
   ConcreteCallbackVH ConstantCVH(ConstantV);
 
   EXPECT_TRUE(BitcastCVH == BitcastCVH);
   EXPECT_TRUE(BitcastV.get() == BitcastCVH);

 
 TEST_F(ValueHandle, CallbackVH_DeletionCanRAUW) {
   class RecoveringVH final : public CallbackVH {
   public:
     int DeletedCalls;
     Value *AURWArgument;
     LLVMContext *Context;
 
-    RecoveringVH() : DeletedCalls(0), AURWArgument(nullptr), 
-                     Context(&getGlobalContext()) {}
-    RecoveringVH(Value *V)
-      : CallbackVH(V), DeletedCalls(0), AURWArgument(nullptr), 
-        Context(&getGlobalContext()) {}
+    RecoveringVH(LLVMContext &TheContext) : DeletedCalls(0), AURWArgument(nullptr),
+                     Context(&TheContext) {}
+
+    RecoveringVH(LLVMContext &TheContext, Value *V)
+      : CallbackVH(V), DeletedCalls(0), AURWArgument(nullptr),
+          Context(&TheContext) {}
 
   private:
     void deleted() override {
-      getValPtr()->replaceAllUsesWith(Constant::getNullValue(Type::getInt32Ty(getGlobalContext())));
+      getValPtr()->replaceAllUsesWith(Constant::getNullValue(Type::getInt32Ty(*Context)));
       setValPtr(nullptr);
     }
     void allUsesReplacedWith(Value *new_value) override {
       ASSERT_TRUE(nullptr != getValPtr());
       EXPECT_EQ(1U, getValPtr()->getNumUses());
       EXPECT_EQ(nullptr, AURWArgument);
       AURWArgument = new_value;
     }
   };
 
   // Normally, if a value has uses, deleting it will crash.  However, we can use
   // a CallbackVH to remove the uses before the check for no uses.
-  RecoveringVH RVH;
-  RVH = BitcastV.get();
+  RecoveringVH RVH(Context);
+  RVH = RecoveringVH(Context, BitcastV.get());
   std::unique_ptr<BinaryOperator> BitcastUser(
     BinaryOperator::CreateAdd(RVH, 
-                              Constant::getNullValue(Type::getInt32Ty(getGlobalContext()))));
+                              Constant::getNullValue(Type::getInt32Ty(Context))));
   EXPECT_EQ(BitcastV.get(), BitcastUser->getOperand(0));
   BitcastV.reset();  // Would crash without the ValueHandler.
-  EXPECT_EQ(Constant::getNullValue(Type::getInt32Ty(getGlobalContext())), RVH.AURWArgument);
-  EXPECT_EQ(Constant::getNullValue(Type::getInt32Ty(getGlobalContext())),
+  EXPECT_EQ(Constant::getNullValue(Type::getInt32Ty(Context)), RVH.AURWArgument);
+  EXPECT_EQ(Constant::getNullValue(Type::getInt32Ty(Context)),
             BitcastUser->getOperand(0));
 }
 
 TEST_F(ValueHandle, DestroyingOtherVHOnSameValueDoesntBreakIteration) {
   // When a CallbackVH modifies other ValueHandles in its callbacks,
   // that shouldn't interfere with non-modified ValueHandles receiving
   // their appropriate callbacks.
   //

unittests/IR/ValueMapTest.cpp

 using namespace llvm;
 
 namespace {
 
 // Test fixture
 template<typename T>
 class ValueMapTest : public testing::Test {
 protected:
+  LLVMContext Context;
   Constant *ConstantV;
   std::unique_ptr<BitCastInst> BitcastV;
   std::unique_ptr<BinaryOperator> AddV;
 
   ValueMapTest() :
-    ConstantV(ConstantInt::get(Type::getInt32Ty(getGlobalContext()), 0)),
-    BitcastV(new BitCastInst(ConstantV, Type::getInt32Ty(getGlobalContext()))),
+    ConstantV(ConstantInt::get(Type::getInt32Ty(Context), 0)),
+    BitcastV(new BitCastInst(ConstantV, Type::getInt32Ty(Context))),
     AddV(BinaryOperator::CreateAdd(ConstantV, ConstantV)) {
   }
 };
 
 // Run everything on Value*, a subtype to make sure that casting works as
 // expected, and a const subtype to make sure we cast const correctly.
 typedef ::testing::Types<Value, Instruction, const Instruction> KeyTypes;
 TYPED_TEST_CASE(ValueMapTest, KeyTypes);

unittests/IR/ValueTest.cpp

TEST(ValueTest, UsedInBasicBlock) {
   Function *F = M->getFunction("f");
 
   EXPECT_FALSE(F->isUsedInBasicBlock(&F->front()));
   EXPECT_TRUE((++F->arg_begin())->isUsedInBasicBlock(&F->front()));
   EXPECT_TRUE(F->arg_begin()->isUsedInBasicBlock(&F->front()));
 }
 
 TEST(GlobalTest, CreateAddressSpace) {
-  LLVMContext &Ctx = getGlobalContext();
+  LLVMContext Ctx;
   std::unique_ptr<Module> M(new Module("TestModule", Ctx));
   Type *Int8Ty = Type::getInt8Ty(Ctx);
   Type *Int32Ty = Type::getInt32Ty(Ctx);
 
   GlobalVariable *Dummy0
     = new GlobalVariable(*M,
                          Int32Ty,
                          true,
TEST(GlobalTest, CreateAddressSpace) {
   Constant *DummyCast1 = M->getOrInsertGlobal("dummy_cast", Int8Ty);
   EXPECT_EQ(1u, DummyCast1->getType()->getPointerAddressSpace());
   EXPECT_NE(DummyCast0, DummyCast1) << *DummyCast1;
 }
 
 #ifdef GTEST_HAS_DEATH_TEST
 #ifndef NDEBUG
 TEST(GlobalTest, AlignDeath) {
-  LLVMContext &Ctx = getGlobalContext();
+  LLVMContext Ctx;
   std::unique_ptr<Module> M(new Module("TestModule", Ctx));
   Type *Int32Ty = Type::getInt32Ty(Ctx);
   GlobalVariable *Var =
       new GlobalVariable(*M, Int32Ty, true, GlobalValue::ExternalLinkage,
                          Constant::getAllOnesValue(Int32Ty), "var", nullptr,
                          GlobalVariable::NotThreadLocal, 1);
 
   EXPECT_DEATH(Var->setAlignment(536870913U), "Alignment is not a power of 2");

unittests/IR/VerifierTest.cpp

 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "gtest/gtest.h"
 
 namespace llvm {
 namespace {
 
 TEST(VerifierTest, Branch_i1) {
-  LLVMContext &C = getGlobalContext();
+  LLVMContext C;
   Module M("M", C);
   FunctionType *FTy = FunctionType::get(Type::getVoidTy(C), /*isVarArg=*/false);
   Function *F = cast<Function>(M.getOrInsertFunction("foo", FTy));
   BasicBlock *Entry = BasicBlock::Create(C, "entry", F);
   BasicBlock *Exit = BasicBlock::Create(C, "exit", F);
   ReturnInst::Create(C, Exit);
 
   // To avoid triggering an assertion in BranchInst::Create, we first create
   // a branch with an 'i1' condition ...
 
   Constant *False = ConstantInt::getFalse(C);
   BranchInst *BI = BranchInst::Create(Exit, Exit, False, Entry);
 
   // ... then use setOperand to redirect it to a value of different type.
 
   Constant *Zero32 = ConstantInt::get(IntegerType::get(C, 32), 0);
   BI->setOperand(0, Zero32);
 
   EXPECT_TRUE(verifyFunction(*F));
 }
 
 TEST(VerifierTest, InvalidRetAttribute) {
-  LLVMContext &C = getGlobalContext();
+  LLVMContext C;
   Module M("M", C);
   FunctionType *FTy = FunctionType::get(Type::getInt32Ty(C), /*isVarArg=*/false);
   Function *F = cast<Function>(M.getOrInsertFunction("foo", FTy));
   AttributeSet AS = F->getAttributes();
   F->setAttributes(AS.addAttribute(C, AttributeSet::ReturnIndex,
                                    Attribute::UWTable));
 
   std::string Error;
   raw_string_ostream ErrorOS(Error);
   EXPECT_TRUE(verifyModule(M, &ErrorOS));
   EXPECT_TRUE(StringRef(ErrorOS.str()).startswith(
       "Attribute 'uwtable' only applies to functions!"));
 }
 
 TEST(VerifierTest, CrossModuleRef) {
-  LLVMContext &C = getGlobalContext();
+  LLVMContext C;
   Module M1("M1", C);
   Module M2("M2", C);
   Module M3("M3", C);
   FunctionType *FTy = FunctionType::get(Type::getInt32Ty(C), /*isVarArg=*/false);
   Function *F1 = cast<Function>(M1.getOrInsertFunction("foo1", FTy));
   Function *F2 = cast<Function>(M2.getOrInsertFunction("foo2", FTy));
   Function *F3 = cast<Function>(M3.getOrInsertFunction("foo3", FTy));
 
EXPECT_TRUE(StringRef(ErrorOS.str()).startswith(
       "Referencing personality function in another module!"));
 
   // Erase bad methods to avoid triggering an assertion failure on destruction
   F1->eraseFromParent();
   F3->eraseFromParent();
 }
 
 TEST(VerifierTest, CrossModuleMetadataRef) {
-  LLVMContext &C = getGlobalContext();
+  LLVMContext C;
   Module M1("M1", C);
   Module M2("M2", C);
   GlobalVariable *newGV =
       new GlobalVariable(M1, Type::getInt8Ty(C), false,
                          GlobalVariable::ExternalLinkage, nullptr,
                          "Some Global");
 
   DIBuilder dbuilder(M2);

unittests/IR/WaymarkTest.cpp

 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/LLVMContext.h"
 #include "gtest/gtest.h"
 #include <algorithm>
 
 namespace llvm {
 namespace {
 
-Constant *char2constant(char c) {
-  return ConstantInt::get(Type::getInt8Ty(getGlobalContext()), c);
-}
-
-
 TEST(WaymarkTest, NativeArray) {
+  LLVMContext Context;
   static uint8_t tail[22] = "s02s33s30y2y0s1x0syxS";
   Value * values[22];
-  std::transform(tail, tail + 22, values, char2constant);
-  FunctionType *FT = FunctionType::get(Type::getVoidTy(getGlobalContext()), true);
+  std::transform(tail, tail + 22, values, [&] (char c) {
+    return ConstantInt::get(Type::getInt8Ty(Context), c);
+  });
+  FunctionType *FT = FunctionType::get(Type::getVoidTy(Context), true);
   std::unique_ptr<Function> F(
       Function::Create(FT, GlobalValue::ExternalLinkage));
   const CallInst *A = CallInst::Create(F.get(), makeArrayRef(values));
   ASSERT_NE(A, (const CallInst*)nullptr);
   ASSERT_EQ(1U + 22, A->getNumOperands());
   const Use *U = &A->getOperandUse(0);
   const Use *Ue = &A->getOperandUse(22);
   for (; U != Ue; ++U)

unittests/ProfileData/InstrProfTest.cpp

auto VerifySummary = [](InstrProfSummary &IPS) mutable {
     ASSERT_EQ(288230376151711744U, NinetyPerc->MinCount);
     ASSERT_EQ(288230376151711744U, NinetyFivePerc->MinCount);
     ASSERT_EQ(72057594037927936U, NinetyNinePerc->MinCount);
   };
   InstrProfSummary &PS = Reader->getSummary();
   VerifySummary(PS);
 
   // Test that conversion of summary to and from Metadata works.
-  Metadata *MD = PS.getMD(getGlobalContext());
+  LLVMContext Context;
+  Metadata *MD = PS.getMD(Context);
   ASSERT_TRUE(MD);
   ProfileSummary *PSFromMD = ProfileSummary::getFromMD(MD);
   ASSERT_TRUE(PSFromMD);
   ASSERT_TRUE(isa<InstrProfSummary>(PSFromMD));
   InstrProfSummary *IPS = cast<InstrProfSummary>(PSFromMD);
   VerifySummary(*IPS);
   delete IPS;
 
   // Test that summary can be attached to and read back from module.
-  Module M("my_module", getGlobalContext());
+  Module M("my_module", Context);
   M.setProfileSummary(MD);
   MD = M.getProfileSummary();
   ASSERT_TRUE(MD);
   PSFromMD = ProfileSummary::getFromMD(MD);
   ASSERT_TRUE(PSFromMD);
   ASSERT_TRUE(isa<InstrProfSummary>(PSFromMD));
   IPS = cast<InstrProfSummary>(PSFromMD);
   VerifySummary(*IPS);

unittests/ProfileData/SampleProfTest.cpp

static ::testing::AssertionResult NoError(std::error_code EC) {
   return ::testing::AssertionFailure() << "error " << EC.value() << ": "
                                        << EC.message();
 }
 
 namespace {
 
 struct SampleProfTest : ::testing::Test {
   std::string Data;
+  LLVMContext Context;
   std::unique_ptr<raw_ostream> OS;
   std::unique_ptr<SampleProfileWriter> Writer;
   std::unique_ptr<SampleProfileReader> Reader;
 
   SampleProfTest()
       : Data(), OS(new raw_string_ostream(Data)), Writer(), Reader() {}
 
   void createWriter(SampleProfileFormat Format) {
     auto WriterOrErr = SampleProfileWriter::create(OS, Format);
     ASSERT_TRUE(NoError(WriterOrErr.getError()));
     Writer = std::move(WriterOrErr.get());
   }
 
   void readProfile(std::unique_ptr<MemoryBuffer> &Profile) {
-    auto ReaderOrErr = SampleProfileReader::create(Profile, getGlobalContext());
+    auto ReaderOrErr = SampleProfileReader::create(Profile, Context);
     ASSERT_TRUE(NoError(ReaderOrErr.getError()));
     Reader = std::move(ReaderOrErr.get());
   }
 
   void testRoundTrip(SampleProfileFormat Format) {
     createWriter(Format);
 
     StringRef FooName("_Z3fooi");
auto VerifySummary = [](SampleProfileSummary &Summary) mutable {
       ASSERT_EQ(60000u, NinetyFivePerc->MinCount);
       ASSERT_EQ(610u, NinetyNinePerc->MinCount);
     };
 
     SampleProfileSummary &Summary = Reader->getSummary();
     VerifySummary(Summary);
 
     // Test that conversion of summary to and from Metadata works.
-    Metadata *MD = Summary.getMD(getGlobalContext());
+    Metadata *MD = Summary.getMD(Context);
     ASSERT_TRUE(MD);
     ProfileSummary *PS = ProfileSummary::getFromMD(MD);
     ASSERT_TRUE(PS);
     ASSERT_TRUE(isa<SampleProfileSummary>(PS));
     SampleProfileSummary *SPS = cast<SampleProfileSummary>(PS);
     VerifySummary(*SPS);
     delete SPS;
 
     // Test that summary can be attached to and read back from module.
-    Module M("my_module", getGlobalContext());
+    Module M("my_module", Context);
     M.setProfileSummary(MD);
     MD = M.getProfileSummary();
     ASSERT_TRUE(MD);
     PS = ProfileSummary::getFromMD(MD);
     ASSERT_TRUE(PS);
     ASSERT_TRUE(isa<SampleProfileSummary>(PS));
     SPS = cast<SampleProfileSummary>(PS);
     VerifySummary(*SPS);

unittests/Transforms/Utils/IntegerDivision.cpp

 #include "gtest/gtest.h"
 
 using namespace llvm;
 
 namespace {
 
 
 TEST(IntegerDivision, SDiv) {
-  LLVMContext &C(getGlobalContext());
+  LLVMContext C;
   Module M("test division", C);
   IRBuilder<> Builder(C);
 
   SmallVector<Type*, 2> ArgTys(2, Builder.getInt32Ty());
   Function *F = Function::Create(FunctionType::get(Builder.getInt32Ty(),
                                                    ArgTys, false),
                                  GlobalValue::ExternalLinkage, "F", &M);
   assert(F->getArgumentList().size() == 2);
TEST(IntegerDivision, SDiv) {
   expandDivision(cast<BinaryOperator>(Div));
   EXPECT_TRUE(BB->front().getOpcode() == Instruction::AShr);
 
   Instruction* Quotient = dyn_cast<Instruction>(cast<User>(Ret)->getOperand(0));
   EXPECT_TRUE(Quotient && Quotient->getOpcode() == Instruction::Sub);
 }
 
 TEST(IntegerDivision, UDiv) {
-  LLVMContext &C(getGlobalContext());
+  LLVMContext C;
   Module M("test division", C);
   IRBuilder<> Builder(C);
 
   SmallVector<Type*, 2> ArgTys(2, Builder.getInt32Ty());
   Function *F = Function::Create(FunctionType::get(Builder.getInt32Ty(),
                                                    ArgTys, false),
                                  GlobalValue::ExternalLinkage, "F", &M);
   assert(F->getArgumentList().size() == 2);
TEST(IntegerDivision, UDiv) {
   expandDivision(cast<BinaryOperator>(Div));
   EXPECT_TRUE(BB->front().getOpcode() == Instruction::ICmp);
 
   Instruction* Quotient = dyn_cast<Instruction>(cast<User>(Ret)->getOperand(0));
   EXPECT_TRUE(Quotient && Quotient->getOpcode() == Instruction::PHI);
 }
 
 TEST(IntegerDivision, SRem) {
-  LLVMContext &C(getGlobalContext());
+  LLVMContext C;
   Module M("test remainder", C);
   IRBuilder<> Builder(C);
 
   SmallVector<Type*, 2> ArgTys(2, Builder.getInt32Ty());
   Function *F = Function::Create(FunctionType::get(Builder.getInt32Ty(),
                                                    ArgTys, false),
                                  GlobalValue::ExternalLinkage, "F", &M);
   assert(F->getArgumentList().size() == 2);
TEST(IntegerDivision, SRem) {
   expandRemainder(cast<BinaryOperator>(Rem));
   EXPECT_TRUE(BB->front().getOpcode() == Instruction::AShr);
 
   Instruction* Remainder = dyn_cast<Instruction>(cast<User>(Ret)->getOperand(0));
   EXPECT_TRUE(Remainder && Remainder->getOpcode() == Instruction::Sub);
 }
 
 TEST(IntegerDivision, URem) {
-  LLVMContext &C(getGlobalContext());
+  LLVMContext C;
   Module M("test remainder", C);
   IRBuilder<> Builder(C);
 
   SmallVector<Type*, 2> ArgTys(2, Builder.getInt32Ty());
   Function *F = Function::Create(FunctionType::get(Builder.getInt32Ty(),
                                                    ArgTys, false),
                                  GlobalValue::ExternalLinkage, "F", &M);
   assert(F->getArgumentList().size() == 2);
TEST(IntegerDivision, URem) {
   EXPECT_TRUE(BB->front().getOpcode() == Instruction::ICmp);
 
   Instruction* Remainder = dyn_cast<Instruction>(cast<User>(Ret)->getOperand(0));
   EXPECT_TRUE(Remainder && Remainder->getOpcode() == Instruction::Sub);
 }
 
 
 TEST(IntegerDivision, SDiv64) {
-  LLVMContext &C(getGlobalContext());
+  LLVMContext C;
   Module M("test division", C);
   IRBuilder<> Builder(C);
 
   SmallVector<Type*, 2> ArgTys(2, Builder.getInt64Ty());
   Function *F = Function::Create(FunctionType::get(Builder.getInt64Ty(),
                                                    ArgTys, false),
                                  GlobalValue::ExternalLinkage, "F", &M);
   assert(F->getArgumentList().size() == 2);
TEST(IntegerDivision, SDiv64) {
   expandDivision(cast<BinaryOperator>(Div));
   EXPECT_TRUE(BB->front().getOpcode() == Instruction::AShr);
 
   Instruction* Quotient = dyn_cast<Instruction>(cast<User>(Ret)->getOperand(0));
   EXPECT_TRUE(Quotient && Quotient->getOpcode() == Instruction::Sub);
 }
 
 TEST(IntegerDivision, UDiv64) {
-  LLVMContext &C(getGlobalContext());
+  LLVMContext C;
   Module M("test division", C);
   IRBuilder<> Builder(C);
 
   SmallVector<Type*, 2> ArgTys(2, Builder.getInt64Ty());
   Function *F = Function::Create(FunctionType::get(Builder.getInt64Ty(),
                                                    ArgTys, false),
                                  GlobalValue::ExternalLinkage, "F", &M);
   assert(F->getArgumentList().size() == 2);
TEST(IntegerDivision, UDiv64) {
   expandDivision(cast<BinaryOperator>(Div));
   EXPECT_TRUE(BB->front().getOpcode() == Instruction::ICmp);
 
   Instruction* Quotient = dyn_cast<Instruction>(cast<User>(Ret)->getOperand(0));
   EXPECT_TRUE(Quotient && Quotient->getOpcode() == Instruction::PHI);
 }
 
 TEST(IntegerDivision, SRem64) {
-  LLVMContext &C(getGlobalContext());
+  LLVMContext C;
   Module M("test remainder", C);
   IRBuilder<> Builder(C);
 
   SmallVector<Type*, 2> ArgTys(2, Builder.getInt64Ty());
   Function *F = Function::Create(FunctionType::get(Builder.getInt64Ty(),
                                                    ArgTys, false),
                                  GlobalValue::ExternalLinkage, "F", &M);
   assert(F->getArgumentList().size() == 2);
TEST(IntegerDivision, SRem64) {
   expandRemainder(cast<BinaryOperator>(Rem));
   EXPECT_TRUE(BB->front().getOpcode() == Instruction::AShr);
 
   Instruction* Remainder = dyn_cast<Instruction>(cast<User>(Ret)->getOperand(0));
   EXPECT_TRUE(Remainder && Remainder->getOpcode() == Instruction::Sub);
 }
 
 TEST(IntegerDivision, URem64) {
-  LLVMContext &C(getGlobalContext());
+  LLVMContext C;
   Module M("test remainder", C);
   IRBuilder<> Builder(C);
 
   SmallVector<Type*, 2> ArgTys(2, Builder.getInt64Ty());
   Function *F = Function::Create(FunctionType::get(Builder.getInt64Ty(),
                                                    ArgTys, false),
                                  GlobalValue::ExternalLinkage, "F", &M);
   assert(F->getArgumentList().size() == 2);

unittests/Transforms/Utils/Local.cpp

 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/LLVMContext.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 
 TEST(Local, RecursivelyDeleteDeadPHINodes) {
-  LLVMContext &C(getGlobalContext());
+  LLVMContext C;
 
   IRBuilder<> builder(C);
 
   // Make blocks
   BasicBlock *bb0 = BasicBlock::Create(C);
   BasicBlock *bb1 = BasicBlock::Create(C);
 
   builder.SetInsertPoint(bb0);
TEST(Local, RecursivelyDeleteDeadPHINodes) {
 
   bb0->dropAllReferences();
   bb1->dropAllReferences();
   delete bb0;
   delete bb1;
 }
 
 TEST(Local, RemoveDuplicatePHINodes) {
-  LLVMContext &C(getGlobalContext());
+  LLVMContext C;
   IRBuilder<> B(C);
 
   std::unique_ptr<Function> F(
       Function::Create(FunctionType::get(B.getVoidTy(), false),
                        GlobalValue::ExternalLinkage, "F"));
   BasicBlock *Entry(BasicBlock::Create(C, "", F.get()));
   BasicBlock *BB(BasicBlock::Create(C, "", F.get()));
   BranchInst::Create(BB, Entry);

unittests/Transforms/Utils/MemorySSA.cpp

 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/LLVMContext.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 
 TEST(MemorySSA, RemoveMemoryAccess) {
-  LLVMContext &C(getGlobalContext());
+  LLVMContext C;
   std::unique_ptr<Module> M(new Module("Remove memory access", C));
   IRBuilder<> B(C);
   DataLayout DL("e-i64:64-f80:128-n8:16:32:64-S128");
   TargetLibraryInfoImpl TLII;
   TargetLibraryInfo TLI(TLII);
 
   // We create a diamond where there is a store on one side, and then a load
   // after the merge point.  This enables us to test a bunch of different