diff options
80 files changed, 1108 insertions, 1079 deletions
diff --git a/bindings/ocaml/llvm/llvm.mli b/bindings/ocaml/llvm/llvm.mli index 5d3ce958264..8c068619838 100644 --- a/bindings/ocaml/llvm/llvm.mli +++ b/bindings/ocaml/llvm/llvm.mli @@ -434,7 +434,7 @@ val create_context : unit -> llcontext [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 diff --git a/docs/ProgrammersManual.rst b/docs/ProgrammersManual.rst index 32145550fe2..902d4616ac1 100644 --- a/docs/ProgrammersManual.rst +++ b/docs/ProgrammersManual.rst @@ -2419,11 +2419,6 @@ 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 diff --git a/docs/ReleaseNotes.rst b/docs/ReleaseNotes.rst index 9257a9f2a24..56df1718d38 100644 --- a/docs/ReleaseNotes.rst +++ b/docs/ReleaseNotes.rst @@ -38,6 +38,8 @@ Non-comprehensive list of changes in this release (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, diff --git a/docs/tutorial/LangImpl3.rst b/docs/tutorial/LangImpl3.rst index 89ecee9d729..a74f874fa4a 100644 --- a/docs/tutorial/LangImpl3.rst +++ b/docs/tutorial/LangImpl3.rst @@ -74,7 +74,7 @@ parser, which will be used to report errors found during code generation .. 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) { @@ -116,7 +116,7 @@ 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 @@ -165,7 +165,7 @@ variables <LangImpl7.html#user-defined-local-variables>`_. 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"); @@ -264,9 +264,9 @@ with: 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); @@ -340,7 +340,7 @@ 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. diff --git a/docs/tutorial/LangImpl4.rst b/docs/tutorial/LangImpl4.rst index a671d0c37f9..7668a2974a7 100644 --- a/docs/tutorial/LangImpl4.rst +++ b/docs/tutorial/LangImpl4.rst @@ -131,7 +131,8 @@ for us: 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. diff --git a/docs/tutorial/LangImpl5.rst b/docs/tutorial/LangImpl5.rst index e4dc8ab7d85..eb76e663be5 100644 --- a/docs/tutorial/LangImpl5.rst +++ b/docs/tutorial/LangImpl5.rst @@ -292,7 +292,7 @@ for ``IfExprAST``: // 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 @@ -305,9 +305,9 @@ a truth value as a 1-bit (bool) value. // 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); @@ -400,7 +400,7 @@ code: 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); @@ -625,7 +625,7 @@ expression). 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); @@ -642,7 +642,7 @@ the two blocks. 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); @@ -693,7 +693,7 @@ table. 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"); @@ -712,7 +712,7 @@ iteration of the loop. // 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 @@ -723,7 +723,7 @@ if/then/else statement. // 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); @@ -751,7 +751,7 @@ insertion position to it. 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" diff --git a/docs/tutorial/LangImpl6.rst b/docs/tutorial/LangImpl6.rst index 5a77d6dcd72..2b6c2b117e0 100644 --- a/docs/tutorial/LangImpl6.rst +++ b/docs/tutorial/LangImpl6.rst @@ -251,7 +251,7 @@ default case for our existing binary operator node: 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; @@ -288,7 +288,7 @@ The final piece of code we are missing, is a bit of top-level magic: 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()) { diff --git a/docs/tutorial/LangImpl7.rst b/docs/tutorial/LangImpl7.rst index 5d536bf8572..efc38f62b57 100644 --- a/docs/tutorial/LangImpl7.rst +++ b/docs/tutorial/LangImpl7.rst @@ -339,7 +339,7 @@ the function: 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()); } @@ -812,7 +812,7 @@ previous value that we replace in OldBindings. 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); diff --git a/examples/BrainF/BrainFDriver.cpp b/examples/BrainF/BrainFDriver.cpp index 1a38c67b0d4..b484d758ff0 100644 --- a/examples/BrainF/BrainFDriver.cpp +++ b/examples/BrainF/BrainFDriver.cpp @@ -88,7 +88,7 @@ void addMainFunction(Module *mod) { 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 " diff --git a/examples/ExceptionDemo/ExceptionDemo.cpp b/examples/ExceptionDemo/ExceptionDemo.cpp index 444ee2649fa..0afc3fdf59a 100644 --- a/examples/ExceptionDemo/ExceptionDemo.cpp +++ b/examples/ExceptionDemo/ExceptionDemo.cpp @@ -1951,12 +1951,12 @@ int main(int argc, char *argv[]) { 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()); diff --git a/examples/Kaleidoscope/Chapter3/toy.cpp b/examples/Kaleidoscope/Chapter3/toy.cpp index 8c5252312a7..84113ccdc4c 100644 --- a/examples/Kaleidoscope/Chapter3/toy.cpp +++ b/examples/Kaleidoscope/Chapter3/toy.cpp @@ -381,7 +381,8 @@ static std::unique_ptr<PrototypeAST> ParseExtern() { //===----------------------------------------------------------------------===// 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) { @@ -390,7 +391,7 @@ Value *LogErrorV(const char *Str) { } Value *NumberExprAST::codegen() { - return ConstantFP::get(getGlobalContext(), APFloat(Val)); + return ConstantFP::get(TheContext, APFloat(Val)); } Value *VariableExprAST::codegen() { @@ -417,8 +418,7 @@ Value *BinaryExprAST::codegen() { 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()), - "booltmp"); + return Builder.CreateUIToFP(L, Type::getDoubleTy(TheContext), "booltmp"); default: return LogErrorV("invalid binary operator"); } @@ -446,10 +446,9 @@ Value *CallExprAST::codegen() { Function *PrototypeAST::codegen() { // Make the function type: double(double,double) etc. - std::vector<Type *> Doubles(Args.size(), - Type::getDoubleTy(getGlobalContext())); + std::vector<Type *> Doubles(Args.size(), 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()); @@ -473,7 +472,7 @@ Function *FunctionAST::codegen() { 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. @@ -577,7 +576,7 @@ int main() { 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(); diff --git a/examples/Kaleidoscope/Chapter4/toy.cpp b/examples/Kaleidoscope/Chapter4/toy.cpp index 4b5b1585a3d..f8d85ab56f0 100644 --- a/examples/Kaleidoscope/Chapter4/toy.cpp +++ b/examples/Kaleidoscope/Chapter4/toy.cpp @@ -388,7 +388,8 @@ static std::unique_ptr<PrototypeAST> ParseExtern() { //===----------------------------------------------------------------------===// 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; @@ -415,7 +416,7 @@ Function *getFunction(std::string Name) { } Value *NumberExprAST::codegen() { - return ConstantFP::get(getGlobalContext(), APFloat(Val)); + return ConstantFP::get(TheContext, APFloat(Val)); } Value *VariableExprAST::codegen() { @@ -442,8 +443,7 @@ Value *BinaryExprAST::codegen() { 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()), - "booltmp"); + return Builder.CreateUIToFP(L, Type::getDoubleTy(TheContext), "booltmp"); default: return LogErrorV("invalid binary operator"); } @@ -471,10 +471,9 @@ Value *CallExprAST::codegen() { Function *PrototypeAST::codegen() { // Make the function type: double(double,double) etc. - std::vector<Type *> Doubles(Args.size(), - Type::getDoubleTy(getGlobalContext())); + std::vector<Type *> Doubles(Args.size(), 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()); @@ -497,7 +496,7 @@ Function *FunctionAST::codegen() { 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. @@ -529,7 +528,7 @@ Function *FunctionAST::codegen() { 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. diff --git a/examples/Kaleidoscope/Chapter5/toy.cpp b/examples/Kaleidoscope/Chapter5/toy.cpp index d54c6696266..15646c44dc7 100644 --- a/examples/Kaleidoscope/Chapter5/toy.cpp +++ b/examples/Kaleidoscope/Chapter5/toy.cpp @@ -512,7 +512,8 @@ static std::unique_ptr<PrototypeAST> ParseExtern() { //===----------------------------------------------------------------------===// 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; @@ -539,7 +540,7 @@ Function *getFunction(std::string Name) { } Value *NumberExprAST::codegen() { - return ConstantFP::get(getGlobalContext(), APFloat(Val)); + return ConstantFP::get(TheContext, APFloat(Val)); } Value *VariableExprAST::codegen() { @@ -566,8 +567,7 @@ Value *BinaryExprAST::codegen() { 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()), - "booltmp"); + return Builder.CreateUIToFP(L, Type::getDoubleTy(TheContext), "booltmp"); default: return LogErrorV("invalid binary operator"); } @@ -600,16 +600,15 @@ Value *IfExprAST::codegen() { // 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 *ThenBB = BasicBlock::Create(TheContext, "then", TheFunction); + BasicBlock *ElseBB = BasicBlock::Create(TheContext, "else"); + BasicBlock *MergeBB = BasicBlock::Create(TheContext, "ifcont"); Builder.CreateCondBr(CondV, ThenBB, ElseBB); @@ -639,8 +638,7 @@ Value *IfExprAST::codegen() { // Emit merge block. TheFunction->getBasicBlockList().push_back(MergeBB); Builder.SetInsertPoint(MergeBB); - PHINode *PN = - Builder.CreatePHI(Type::getDoubleTy(getGlobalContext()), 2, "iftmp"); + PHINode *PN = Builder.CreatePHI(Type::getDoubleTy(TheContext), 2, "iftmp"); PN->addIncoming(ThenV, ThenBB); PN->addIncoming(ElseV, ElseBB); @@ -672,8 +670,7 @@ Value *ForExprAST::codegen() { // block. Function *TheFunction = Builder.GetInsertBlock()->getParent(); BasicBlock *PreheaderBB = Builder.GetInsertBlock(); - 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); @@ -682,8 +679,8 @@ Value *ForExprAST::codegen() { Builder.SetInsertPoint(LoopBB); // Start the PHI node with an entry for Start. - PHINode *Variable = Builder.CreatePHI(Type::getDoubleTy(getGlobalContext()), - 2, VarName.c_str()); + 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 @@ -705,7 +702,7 @@ Value *ForExprAST::codegen() { 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"); @@ -717,12 +714,12 @@ Value *ForExprAST::codegen() { // 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); @@ -740,15 +737,14 @@ Value *ForExprAST::codegen() { 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())); + std::vector<Type *> Doubles(Args.size(), 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()); @@ -771,7 +767,7 @@ Function *FunctionAST::codegen() { 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. @@ -803,7 +799,7 @@ Function *FunctionAST::codegen() { 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. diff --git a/examples/Kaleidoscope/Chapter6/toy.cpp b/examples/Kaleidoscope/Chapter6/toy.cpp index 532a59a0c91..433ba7b82b8 100644 --- a/examples/Kaleidoscope/Chapter6/toy.cpp +++ b/examples/Kaleidoscope/Chapter6/toy.cpp @@ -603,7 +603,8 @@ static std::unique_ptr<PrototypeAST> ParseExtern() { //===----------------------------------------------------------------------===// 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; @@ -630,7 +631,7 @@ Function *getFunction(std::string Name) { } Value *NumberExprAST::codegen() { - return ConstantFP::get(getGlobalContext(), APFloat(Val)); + return ConstantFP::get(TheContext, APFloat(Val)); } Value *VariableExprAST::codegen() { @@ -669,8 +670,7 @@ Value *BinaryExprAST::codegen() { 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()), - "booltmp"); + return Builder.CreateUIToFP(L, Type::getDoubleTy(TheContext), "booltmp"); default: break; } @@ -711,16 +711,15 @@ Value *IfExprAST::codegen() { // 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 *ThenBB = BasicBlock::Create(TheContext, "then", TheFunction); + BasicBlock *ElseBB = BasicBlock::Create(TheContext, "else"); + BasicBlock *MergeBB = BasicBlock::Create(TheContext, "ifcont"); Builder.CreateCondBr(CondV, ThenBB, ElseBB); @@ -750,8 +749,7 @@ Value *IfExprAST::codegen() { // Emit merge block. TheFunction->getBasicBlockList().push_back(MergeBB); Builder.SetInsertPoint(MergeBB); - PHINode *PN = - Builder.CreatePHI(Type::getDoubleTy(getGlobalContext()), 2, "iftmp"); + PHINode *PN = Builder.CreatePHI(Type::getDoubleTy(TheContext), 2, "iftmp"); PN->addIncoming(ThenV, ThenBB); PN->addIncoming(ElseV, ElseBB); @@ -783,8 +781,7 @@ Value *ForExprAST::codegen() { // block. Function *TheFunction = Builder.GetInsertBlock()->getParent(); BasicBlock *PreheaderBB = Builder.GetInsertBlock(); - 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); @@ -793,8 +790,8 @@ Value *ForExprAST::codegen() { Builder.SetInsertPoint(LoopBB); // Start the PHI node with an entry for Start. - PHINode *Variable = Builder.CreatePHI(Type::getDoubleTy(getGlobalContext()), - 2, VarName.c_str()); + 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 @@ -816,7 +813,7 @@ Value *ForExprAST::codegen() { 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"); @@ -828,12 +825,12 @@ Value *ForExprAST::codegen() { // 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); @@ -851,15 +848,14 @@ Value *ForExprAST::codegen() { 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())); + std::vector<Type *> Doubles(Args.size(), 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()); @@ -886,7 +882,7 @@ Function *FunctionAST::codegen() { 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. @@ -921,7 +917,7 @@ Function *FunctionAST::codegen() { 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. diff --git a/examples/Kaleidoscope/Chapter7/toy.cpp b/examples/Kaleidoscope/Chapter7/toy.cpp index 5cd062a1b5b..18401de5266 100644 --- a/examples/Kaleidoscope/Chapter7/toy.cpp +++ b/examples/Kaleidoscope/Chapter7/toy.cpp @@ -673,7 +673,8 @@ static std::unique_ptr<PrototypeAST> ParseExtern() { //===----------------------------------------------------------------------===// 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; @@ -705,12 +706,12 @@ 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() { @@ -774,8 +775,7 @@ Value *BinaryExprAST::codegen() { 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()), - "booltmp"); + return Builder.CreateUIToFP(L, Type::getDoubleTy(TheContext), "booltmp"); default: break; } @@ -816,16 +816,15 @@ Value *IfExprAST::codegen() { // 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 *ThenBB = BasicBlock::Create(TheContext, "then", TheFunction); + BasicBlock *ElseBB = BasicBlock::Create(TheContext, "else"); + BasicBlock *MergeBB = BasicBlock::Create(TheContext, "ifcont"); Builder.CreateCondBr(CondV, ThenBB, ElseBB); @@ -855,8 +854,7 @@ Value *IfExprAST::codegen() { // Emit merge block. TheFunction->getBasicBlockList().push_back(MergeBB); Builder.SetInsertPoint(MergeBB); - PHINode *PN = - Builder.CreatePHI(Type::getDoubleTy(getGlobalContext()), 2, "iftmp"); + PHINode *PN = Builder.CreatePHI(Type::getDoubleTy(TheContext), 2, "iftmp"); PN->addIncoming(ThenV, ThenBB); PN->addIncoming(ElseV, ElseBB); @@ -898,8 +896,7 @@ Value *ForExprAST::codegen() { // 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); @@ -926,7 +923,7 @@ Value *ForExprAST::codegen() { 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. @@ -942,11 +939,11 @@ Value *ForExprAST::codegen() { // 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); @@ -961,7 +958,7 @@ Value *ForExprAST::codegen() { NamedValues.erase(VarName); // for expr always returns 0.0. - return Constant::getNullValue(Type::getDoubleTy(getGlobalContext())); + return Constant::getNullValue(Type::getDoubleTy(TheContext)); } Value *VarExprAST::codegen() { @@ -985,7 +982,7 @@ Value *VarExprAST::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); @@ -1014,10 +1011,9 @@ Value *VarExprAST::codegen() { Function *PrototypeAST::codegen() { // Make the function type: double(double,double) etc. - std::vector<Type *> Doubles(Args.size(), - Type::getDoubleTy(getGlobalContext())); + std::vector<Type *> Doubles(Args.size(), 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()); @@ -1044,7 +1040,7 @@ Function *FunctionAST::codegen() { 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. @@ -1087,7 +1083,7 @@ Function *FunctionAST::codegen() { 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. diff --git a/examples/Kaleidoscope/Chapter8/toy.cpp b/examples/Kaleidoscope/Chapter8/toy.cpp index 31a83861a10..a482ccd7352 100644 --- a/examples/Kaleidoscope/Chapter8/toy.cpp +++ b/examples/Kaleidoscope/Chapter8/toy.cpp @@ -87,7 +87,8 @@ namespace { class PrototypeAST; class ExprAST; } -static IRBuilder<> Builder(getGlobalContext()); +static LLVMContext TheContext; +static IRBuilder<> Builder(TheContext); struct DebugInfo { DICompileUnit *TheCU; DIType *DblTy; @@ -886,13 +887,13 @@ 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() { @@ -960,8 +961,7 @@ Value *BinaryExprAST::codegen() { 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()), - "booltmp"); + return Builder.CreateUIToFP(L, Type::getDoubleTy(TheContext), "booltmp"); default: break; } @@ -1006,16 +1006,15 @@ Value *IfExprAST::codegen() { // 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 *ThenBB = BasicBlock::Create(TheContext, "then", TheFunction); + BasicBlock *ElseBB = BasicBlock::Create(TheContext, "else"); + BasicBlock *MergeBB = BasicBlock::Create(TheContext, "ifcont"); Builder.CreateCondBr(CondV, ThenBB, ElseBB); @@ -1045,8 +1044,7 @@ Value *IfExprAST::codegen() { // Emit merge block. TheFunction->getBasicBlockList().push_back(MergeBB); Builder.SetInsertPoint(MergeBB); - PHINode *PN = - Builder.CreatePHI(Type::getDoubleTy(getGlobalContext()), 2, "iftmp"); + PHINode *PN = Builder.CreatePHI(Type::getDoubleTy(TheContext), 2, "iftmp"); PN->addIncoming(ThenV, ThenBB); PN->addIncoming(ElseV, ElseBB); @@ -1090,8 +1088,7 @@ Value *ForExprAST::codegen() { // 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); @@ -1118,7 +1115,7 @@ Value *ForExprAST::codegen() { 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. @@ -1134,11 +1131,11 @@ Value *ForExprAST::codegen() { // 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); @@ -1153,7 +1150,7 @@ Value *ForExprAST::codegen() { NamedValues.erase(VarName); // for expr always returns 0.0. - return Constant::getNullValue(Type::getDoubleTy(getGlobalContext())); + return Constant::getNullValue(Type::getDoubleTy(TheContext)); } Value *VarExprAST::codegen() { @@ -1177,7 +1174,7 @@ Value *VarExprAST::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); @@ -1208,10 +1205,9 @@ Value *VarExprAST::codegen() { Function *PrototypeAST::codegen() { // Make the function type: double(double,double) etc. - std::vector<Type *> Doubles(Args.size(), - Type::getDoubleTy(getGlobalContext())); + std::vector<Type *> Doubles(Args.size(), 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()); @@ -1238,7 +1234,7 @@ Function *FunctionAST::codegen() { 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. @@ -1319,7 +1315,7 @@ Function *FunctionAST::codegen() { 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()); } diff --git a/examples/Kaleidoscope/MCJIT/cached/toy-jit.cpp b/examples/Kaleidoscope/MCJIT/cached/toy-jit.cpp index 77b7f001095..3f3b133703b 100644 --- a/examples/Kaleidoscope/MCJIT/cached/toy-jit.cpp +++ b/examples/Kaleidoscope/MCJIT/cached/toy-jit.cpp @@ -623,7 +623,8 @@ static PrototypeAST *ParseExtern() { 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; } @@ -634,12 +635,11 @@ static AllocaInst *CreateEntryBlockAlloca(Function *TheFunction, const std::string &VarName) { IRBuilder<> TmpB(&TheFunction->getEntryBlock(), TheFunction->getEntryBlock().begin()); - return TmpB.CreateAlloca(Type::getDoubleTy(getGlobalContext()), 0, - VarName.c_str()); + 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() { @@ -699,8 +699,7 @@ Value *BinaryExprAST::Codegen() { 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()), - "booltmp"); + return Builder.CreateUIToFP(L, Type::getDoubleTy(TheContext), "booltmp"); default: break; } @@ -740,18 +739,17 @@ Value *IfExprAST::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)), - "ifcond"); - + CondV = Builder.CreateFCmpONE( + CondV, ConstantFP::get(TheContext, APFloat(0.0)), "ifcond"); + Function *TheFunction = Builder.GetInsertBlock()->getParent(); // Create blocks for the then and else cases. Insert the 'then' block at the // end of the function. - BasicBlock *ThenBB = BasicBlock::Create(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. @@ -778,9 +776,8 @@ Value *IfExprAST::Codegen() { // Emit merge block. TheFunction->getBasicBlockList().push_back(MergeBB); Builder.SetInsertPoint(MergeBB); - PHINode *PN = Builder.CreatePHI(Type::getDoubleTy(getGlobalContext()), 2, - "iftmp"); - + PHINode *PN = Builder.CreatePHI(Type::getDoubleTy(TheContext), 2, "iftmp"); + PN->addIncoming(ThenV, ThenBB); PN->addIncoming(ElseV, ElseBB); return PN; @@ -821,8 +818,8 @@ Value *ForExprAST::Codegen() { // 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); @@ -847,7 +844,7 @@ Value *ForExprAST::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. @@ -861,13 +858,13 @@ Value *ForExprAST::Codegen() { 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 = Builder.CreateFCmpONE( + EndCond, 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); @@ -882,7 +879,7 @@ Value *ForExprAST::Codegen() { // for expr always returns 0.0. - return Constant::getNullValue(Type::getDoubleTy(getGlobalContext())); + return Constant::getNullValue(Type::getDoubleTy(TheContext)); } Value *VarExprAST::Codegen() { @@ -905,7 +902,7 @@ Value *VarExprAST::Codegen() { 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); @@ -933,10 +930,9 @@ Value *VarExprAST::Codegen() { 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()), - Doubles, false); + std::vector<Type *> Doubles(Args.size(), 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 @@ -994,7 +990,7 @@ Function *FunctionAST::Codegen() { 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. @@ -1122,7 +1118,7 @@ double printlf() { 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; @@ -1137,7 +1133,7 @@ Module* parseInputIR(std::string InputFile) { int main(int argc, char **argv) { InitializeNativeTarget(); - LLVMContext &Context = getGlobalContext(); + LLVMContext &Context = TheContext; cl::ParseCommandLineOptions(argc, argv, "Kaleidoscope example program\n"); diff --git a/examples/Kaleidoscope/MCJIT/cached/toy.cpp b/examples/Kaleidoscope/MCJIT/cached/toy.cpp index cc12abcc431..2b9c3da9218 100644 --- a/examples/Kaleidoscope/MCJIT/cached/toy.cpp +++ b/examples/Kaleidoscope/MCJIT/cached/toy.cpp @@ -994,7 +994,8 @@ void MCJITHelper::dump() //===----------------------------------------------------------------------===// 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; } @@ -1005,12 +1006,11 @@ static AllocaInst *CreateEntryBlockAlloca(Function *TheFunction, const std::string &VarName) { IRBuilder<> TmpB(&TheFunction->getEntryBlock(), TheFunction->getEntryBlock().begin()); - return TmpB.CreateAlloca(Type::getDoubleTy(getGlobalContext()), 0, - VarName.c_str()); + 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() { @@ -1066,8 +1066,7 @@ Value *BinaryExprAST::Codegen() { 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()), - "booltmp"); + return Builder.CreateUIToFP(L, Type::getDoubleTy(TheContext), "booltmp"); default: break; } @@ -1104,17 +1103,16 @@ Value *IfExprAST::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)), - "ifcond"); + CondV = Builder.CreateFCmpONE( + CondV, ConstantFP::get(TheContext, APFloat(0.0)), "ifcond"); Function *TheFunction = Builder.GetInsertBlock()->getParent(); // Create blocks for the then and else cases. Insert the 'then' block at the // end of the function. - BasicBlock *ThenBB = BasicBlock::Create(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); @@ -1142,8 +1140,7 @@ Value *IfExprAST::Codegen() { // Emit merge block. TheFunction->getBasicBlockList().push_back(MergeBB); Builder.SetInsertPoint(MergeBB); - PHINode *PN = Builder.CreatePHI(Type::getDoubleTy(getGlobalContext()), 2, - "iftmp"); + PHINode *PN = Builder.CreatePHI(Type::getDoubleTy(TheContext), 2, "iftmp"); PN->addIncoming(ThenV, ThenBB); PN->addIncoming(ElseV, ElseBB); @@ -1185,7 +1182,7 @@ Value *ForExprAST::Codegen() { // 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); @@ -1211,7 +1208,7 @@ Value *ForExprAST::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. @@ -1225,12 +1222,12 @@ Value *ForExprAST::Codegen() { 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 = Builder.CreateFCmpONE( + EndCond, 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); @@ -1246,7 +1243,7 @@ Value *ForExprAST::Codegen() { // for expr always returns 0.0. - return Constant::getNullValue(Type::getDoubleTy(getGlobalContext())); + return Constant::getNullValue(Type::getDoubleTy(TheContext)); } Value *VarExprAST::Codegen() { @@ -1269,7 +1266,7 @@ Value *VarExprAST::Codegen() { 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); @@ -1297,10 +1294,9 @@ Value *VarExprAST::Codegen() { 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()), - Doubles, false); + std::vector<Type *> Doubles(Args.size(), Type::getDoubleTy(TheContext)); + FunctionType *FT = + FunctionType::get(Type::getDoubleTy(TheContext), Doubles, false); std::string FnName = MakeLegalFunctionName(Name); @@ -1365,7 +1361,7 @@ Function *FunctionAST::Codegen() { 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. @@ -1490,7 +1486,7 @@ double printlf() { 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; @@ -1512,7 +1508,7 @@ int main(int argc, char **argv) { InitializeNativeTarget(); InitializeNativeTargetAsmPrinter(); InitializeNativeTargetAsmParser(); - LLVMContext &Context = getGlobalContext(); + LLVMContext &Context = TheContext; cl::ParseCommandLineOptions(argc, argv, "Kaleidoscope example program\n"); diff --git a/examples/Kaleidoscope/MCJIT/complete/toy.cpp b/examples/Kaleidoscope/MCJIT/complete/toy.cpp index c78ec35fa0b..40a00693e8c 100644 --- a/examples/Kaleidoscope/MCJIT/complete/toy.cpp +++ b/examples/Kaleidoscope/MCJIT/complete/toy.cpp @@ -1066,7 +1066,8 @@ void MCJITHelper::dump() //===----------------------------------------------------------------------===// 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; } @@ -1077,12 +1078,11 @@ static AllocaInst *CreateEntryBlockAlloca(Function *TheFunction, const std::string &VarName) { IRBuilder<> TmpB(&TheFunction->getEntryBlock(), TheFunction->getEntryBlock().begin()); - return TmpB.CreateAlloca(Type::getDoubleTy(getGlobalContext()), 0, - VarName.c_str()); + 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() { @@ -1140,8 +1140,7 @@ Value *BinaryExprAST::Codegen() { 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()), - "booltmp"); + return Builder.CreateUIToFP(L, Type::getDoubleTy(TheContext), "booltmp"); default: break; } @@ -1182,17 +1181,16 @@ Value *IfExprAST::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)), - "ifcond"); + CondV = Builder.CreateFCmpONE( + CondV, ConstantFP::get(TheContext, APFloat(0.0)), "ifcond"); Function *TheFunction = Builder.GetInsertBlock()->getParent(); // Create blocks for the then and else cases. Insert the 'then' block at the // end of the function. - BasicBlock *ThenBB = BasicBlock::Create(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); @@ -1220,8 +1218,7 @@ Value *IfExprAST::Codegen() { // Emit merge block. TheFunction->getBasicBlockList().push_back(MergeBB); Builder.SetInsertPoint(MergeBB); - PHINode *PN = Builder.CreatePHI(Type::getDoubleTy(getGlobalContext()), 2, - "iftmp"); + PHINode *PN = Builder.CreatePHI(Type::getDoubleTy(TheContext), 2, "iftmp"); PN->addIncoming(ThenV, ThenBB); PN->addIncoming(ElseV, ElseBB); @@ -1263,7 +1260,7 @@ Value *ForExprAST::Codegen() { // 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); @@ -1289,7 +1286,7 @@ Value *ForExprAST::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. @@ -1303,12 +1300,12 @@ Value *ForExprAST::Codegen() { 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 = Builder.CreateFCmpONE( + EndCond, 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); @@ -1324,7 +1321,7 @@ Value *ForExprAST::Codegen() { // for expr always returns 0.0. - return Constant::getNullValue(Type::getDoubleTy(getGlobalContext())); + return Constant::getNullValue(Type::getDoubleTy(TheContext)); } Value *VarExprAST::Codegen() { @@ -1347,7 +1344,7 @@ Value *VarExprAST::Codegen() { 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); @@ -1375,10 +1372,9 @@ Value *VarExprAST::Codegen() { 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()), - Doubles, false); + std::vector<Type *> Doubles(Args.size(), Type::getDoubleTy(TheContext)); + FunctionType *FT = + FunctionType::get(Type::getDoubleTy(TheContext), Doubles, false); std::string FnName; FnName = MakeLegalFunctionName(Name); @@ -1443,7 +1439,7 @@ Function *FunctionAST::Codegen() { 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. @@ -1565,7 +1561,7 @@ int main(int argc, char **argv) { InitializeNativeTarget(); InitializeNativeTargetAsmPrinter(); InitializeNativeTargetAsmParser(); - LLVMContext &Context = getGlobalContext(); + LLVMContext &Context = TheContext; cl::ParseCommandLineOptions(argc, argv, "Kaleidoscope example program\n"); diff --git a/examples/Kaleidoscope/MCJIT/initial/toy.cpp b/examples/Kaleidoscope/MCJIT/initial/toy.cpp index 9455946087d..1e476aef786 100644 --- a/examples/Kaleidoscope/MCJIT/initial/toy.cpp +++ b/examples/Kaleidoscope/MCJIT/initial/toy.cpp @@ -852,7 +852,8 @@ void MCJITHelper::dump() //===----------------------------------------------------------------------===// 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; } @@ -863,12 +864,11 @@ static AllocaInst *CreateEntryBlockAlloca(Function *TheFunction, const std::string &VarName) { IRBuilder<> TmpB(&TheFunction->getEntryBlock(), TheFunction->getEntryBlock().begin()); - return TmpB.CreateAlloca(Type::getDoubleTy(getGlobalContext()), 0, - VarName.c_str()); + 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() { @@ -924,8 +924,7 @@ Value *BinaryExprAST::Codegen() { 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()), - "booltmp"); + return Builder.CreateUIToFP(L, Type::getDoubleTy(TheContext), "booltmp"); default: break; } @@ -962,17 +961,16 @@ Value *IfExprAST::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)), - "ifcond"); + CondV = Builder.CreateFCmpONE( + CondV, ConstantFP::get(TheContext, APFloat(0.0)), "ifcond"); Function *TheFunction = Builder.GetInsertBlock()->getParent(); // Create blocks for the then and else cases. Insert the 'then' block at the // end of the function. - BasicBlock *ThenBB = BasicBlock::Create(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); @@ -1000,8 +998,7 @@ Value *IfExprAST::Codegen() { // Emit merge block. TheFunction->getBasicBlockList().push_back(MergeBB); Builder.SetInsertPoint(MergeBB); - PHINode *PN = Builder.CreatePHI(Type::getDoubleTy(getGlobalContext()), 2, - "iftmp"); + PHINode *PN = Builder.CreatePHI(Type::getDoubleTy(TheContext), 2, "iftmp"); PN->addIncoming(ThenV, ThenBB); PN->addIncoming(ElseV, ElseBB); @@ -1043,7 +1040,7 @@ Value *ForExprAST::Codegen() { // 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); @@ -1069,7 +1066,7 @@ Value *ForExprAST::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. @@ -1083,12 +1080,12 @@ Value *ForExprAST::Codegen() { 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 = Builder.CreateFCmpONE( + EndCond, 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); @@ -1104,7 +1101,7 @@ Value *ForExprAST::Codegen() { // for expr always returns 0.0. - return Constant::getNullValue(Type::getDoubleTy(getGlobalContext())); + return Constant::getNullValue(Type::getDoubleTy(TheContext)); } Value *VarExprAST::Codegen() { @@ -1127,7 +1124,7 @@ Value *VarExprAST::Codegen() { 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); @@ -1155,10 +1152,9 @@ Value *VarExprAST::Codegen() { 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()), - Doubles, false); + std::vector<Type *> Doubles(Args.size(), Type::getDoubleTy(TheContext)); + FunctionType *FT = + FunctionType::get(Type::getDoubleTy(TheContext), Doubles, false); std::string FnName = MakeLegalFunctionName(Name); @@ -1223,7 +1219,7 @@ Function *FunctionAST::Codegen() { 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. @@ -1349,7 +1345,7 @@ int main() { InitializeNativeTarget(); InitializeNativeTargetAsmPrinter(); InitializeNativeTargetAsmParser(); - LLVMContext &Context = getGlobalContext(); + LLVMContext &Context = TheContext; // Install standard binary operators. // 1 is lowest precedence. diff --git a/examples/Kaleidoscope/MCJIT/lazy/toy-jit.cpp b/examples/Kaleidoscope/MCJIT/lazy/toy-jit.cpp index 07adbd45014..f0c5ad5a46d 100644 --- a/examples/Kaleidoscope/MCJIT/lazy/toy-jit.cpp +++ b/examples/Kaleidoscope/MCJIT/lazy/toy-jit.cpp @@ -608,7 +608,8 @@ static PrototypeAST *ParseExtern() { 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; } @@ -619,12 +620,11 @@ static AllocaInst *CreateEntryBlockAlloca(Function *TheFunction, const std::string &VarName) { IRBuilder<> TmpB(&TheFunction->getEntryBlock(), TheFunction->getEntryBlock().begin()); - return TmpB.CreateAlloca(Type::getDoubleTy(getGlobalContext()), 0, - VarName.c_str()); + 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() { @@ -681,8 +681,7 @@ Value *BinaryExprAST::Codegen() { 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()), - "booltmp"); + return Builder.CreateUIToFP(L, Type::getDoubleTy(TheContext), "booltmp"); default: break; } @@ -722,18 +721,17 @@ Value *IfExprAST::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)), - "ifcond"); - + CondV = Builder.CreateFCmpONE( + CondV, ConstantFP::get(TheContext, APFloat(0.0)), "ifcond"); + Function *TheFunction = Builder.GetInsertBlock()->getParent(); // Create blocks for the then and else cases. Insert the 'then' block at the // end of the function. - BasicBlock *ThenBB = BasicBlock::Create(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. @@ -760,9 +758,8 @@ Value *IfExprAST::Codegen() { // Emit merge block. TheFunction->getBasicBlockList().push_back(MergeBB); Builder.SetInsertPoint(MergeBB); - PHINode *PN = Builder.CreatePHI(Type::getDoubleTy(getGlobalContext()), 2, - "iftmp"); - + PHINode *PN = Builder.CreatePHI(Type::getDoubleTy(TheContext), 2, "iftmp"); + PN->addIncoming(ThenV, ThenBB); PN->addIncoming(ElseV, ElseBB); return PN; @@ -803,8 +800,8 @@ Value *ForExprAST::Codegen() { // 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); @@ -829,7 +826,7 @@ Value *ForExprAST::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. @@ -843,13 +840,13 @@ Value *ForExprAST::Codegen() { 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 = Builder.CreateFCmpONE( + EndCond, 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); @@ -864,7 +861,7 @@ Value *ForExprAST::Codegen() { // for expr always returns 0.0. - return Constant::getNullValue(Type::getDoubleTy(getGlobalContext())); + return Constant::getNullValue(Type::getDoubleTy(TheContext)); } Value *VarExprAST::Codegen() { @@ -887,7 +884,7 @@ Value *VarExprAST::Codegen() { 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); @@ -915,10 +912,9 @@ Value *VarExprAST::Codegen() { 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()), - Doubles, false); + std::vector<Type *> Doubles(Args.size(), 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 @@ -976,7 +972,7 @@ Function *FunctionAST::Codegen() { 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. @@ -1104,7 +1100,7 @@ double printlf() { int main(int argc, char **argv) { InitializeNativeTarget(); - LLVMContext &Context = getGlobalContext(); + LLVMContext &Context = TheContext; // Install standard binary operators. // 1 is lowest precedence. diff --git a/examples/Kaleidoscope/MCJIT/lazy/toy.cpp b/examples/Kaleidoscope/MCJIT/lazy/toy.cpp index 14d758cfa79..37339b60b44 100644 --- a/examples/Kaleidoscope/MCJIT/lazy/toy.cpp +++ b/examples/Kaleidoscope/MCJIT/lazy/toy.cpp @@ -892,7 +892,8 @@ void MCJITHelper::dump() //===----------------------------------------------------------------------===// 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; } @@ -903,12 +904,11 @@ static AllocaInst *CreateEntryBlockAlloca(Function *TheFunction, const std::string &VarName) { IRBuilder<> TmpB(&TheFunction->getEntryBlock(), TheFunction->getEntryBlock().begin()); - return TmpB.CreateAlloca(Type::getDoubleTy(getGlobalContext()), 0, - VarName.c_str()); + 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() { @@ -964,8 +964,7 @@ Value *BinaryExprAST::Codegen() { 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()), - "booltmp"); + return Builder.CreateUIToFP(L, Type::getDoubleTy(TheContext), "booltmp"); default: break; } @@ -1002,17 +1001,16 @@ Value *IfExprAST::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)), - "ifcond"); + CondV = Builder.CreateFCmpONE( + CondV, ConstantFP::get(TheContext, APFloat(0.0)), "ifcond"); Function *TheFunction = Builder.GetInsertBlock()->getParent(); // Create blocks for the then and else cases. Insert the 'then' block at the // end of the function. - BasicBlock *ThenBB = BasicBlock::Create(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); @@ -1040,8 +1038,7 @@ Value *IfExprAST::Codegen() { // Emit merge block. TheFunction->getBasicBlockList().push_back(MergeBB); Builder.SetInsertPoint(MergeBB); - PHINode *PN = Builder.CreatePHI(Type::getDoubleTy(getGlobalContext()), 2, - "iftmp"); + PHINode *PN = Builder.CreatePHI(Type::getDoubleTy(TheContext), 2, "iftmp"); PN->addIncoming(ThenV, ThenBB); PN->addIncoming(ElseV, ElseBB); @@ -1083,7 +1080,7 @@ Value *ForExprAST::Codegen() { // 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); @@ -1109,7 +1106,7 @@ Value *ForExprAST::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. @@ -1123,12 +1120,12 @@ Value *ForExprAST::Codegen() { 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 = Builder.CreateFCmpONE( + EndCond, 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); @@ -1144,7 +1141,7 @@ Value *ForExprAST::Codegen() { // for expr always returns 0.0. - return Constant::getNullValue(Type::getDoubleTy(getGlobalContext())); + return Constant::getNullValue(Type::getDoubleTy(TheContext)); } Value *VarExprAST::Codegen() { @@ -1167,7 +1164,7 @@ Value *VarExprAST::Codegen() { 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); @@ -1195,10 +1192,9 @@ Value *VarExprAST::Codegen() { 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()), - Doubles, false); + std::vector<Type *> Doubles(Args.size(), Type::getDoubleTy(TheContext)); + FunctionType *FT = + FunctionType::get(Type::getDoubleTy(TheContext), Doubles, false); std::string FnName = MakeLegalFunctionName(Name); @@ -1263,7 +1259,7 @@ Function *FunctionAST::Codegen() { 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. @@ -1390,7 +1386,7 @@ int main() { InitializeNativeTarget(); InitializeNativeTargetAsmPrinter(); InitializeNativeTargetAsmParser(); - LLVMContext &Context = getGlobalContext(); + LLVMContext &Context = TheContext; // Install standard binary operators. // 1 is lowest precedence. diff --git a/examples/Kaleidoscope/Orc/fully_lazy/toy.cpp b/examples/Kaleidoscope/Orc/fully_lazy/toy.cpp index 0371a3f76f6..2b90620a207 100644 --- a/examples/Kaleidoscope/Orc/fully_lazy/toy.cpp +++ b/examples/Kaleidoscope/Orc/fully_lazy/toy.cpp @@ -747,8 +747,8 @@ static AllocaInst *CreateEntryBlockAlloca(Function *TheFunction, const std::string &VarName) { IRBuilder<> TmpB(&TheFunction->getEntryBlock(), TheFunction->getEntryBlock().begin()); - return TmpB.CreateAlloca(Type::getDoubleTy(getGlobalContext()), nullptr, - VarName.c_str()); + return TmpB.CreateAlloca(Type::getDoubleTy(TheFunction->getContext()), + nullptr, VarName.c_str()); } Value *NumberExprAST::IRGen(IRGenContext &C) const { @@ -807,8 +807,8 @@ Value *BinaryExprAST::IRGen(IRGenContext &C) const { 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()), - "booltmp"); + return C.getBuilder().CreateUIToFP(L, Type::getDoubleTy(C.getLLVMContext()), + "booltmp"); default: break; } @@ -885,8 +885,8 @@ Value *IfExprAST::IRGen(IRGenContext &C) const { // Emit merge block. TheFunction->getBasicBlockList().push_back(MergeBB); C.getBuilder().SetInsertPoint(MergeBB); - PHINode *PN = C.getBuilder().CreatePHI(Type::getDoubleTy(getGlobalContext()), 2, - "iftmp"); + PHINode *PN = C.getBuilder().CreatePHI(Type::getDoubleTy(C.getLLVMContext()), + 2, "iftmp"); PN->addIncoming(ThenV, ThenBB); PN->addIncoming(ElseV, ElseBB); @@ -928,7 +928,8 @@ Value *ForExprAST::IRGen(IRGenContext &C) const { // 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); @@ -954,7 +955,7 @@ Value *ForExprAST::IRGen(IRGenContext &C) const { 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. @@ -968,12 +969,12 @@ Value *ForExprAST::IRGen(IRGenContext &C) const { 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)), - "loopcond"); + EndCond = C.getBuilder().CreateFCmpONE( + EndCond, 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); @@ -988,7 +989,7 @@ Value *ForExprAST::IRGen(IRGenContext &C) const { 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 { @@ -1011,7 +1012,7 @@ Value *VarExprAST::IRGen(IRGenContext &C) const { 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); @@ -1040,10 +1041,10 @@ 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()), - Doubles, false); + std::vector<Type *> Doubles(Args.size(), + Type::getDoubleTy(C.getLLVMContext())); + FunctionType *FT = + FunctionType::get(Type::getDoubleTy(C.getLLVMContext()), Doubles, false); Function *F = Function::Create(FT, Function::ExternalLinkage, FnName, &C.getM()); @@ -1104,7 +1105,7 @@ Function *FunctionAST::IRGen(IRGenContext &C) const { 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. @@ -1366,7 +1367,8 @@ static void HandleTopLevelExpression(SessionContext &S, KaleidoscopeJIT &J) { /// top ::= definition | external | expression | ';' static void MainLoop() { - SessionContext S(getGlobalContext()); + LLVMContext TheContext; + SessionContext S(TheContext); KaleidoscopeJIT J(S); while (1) { diff --git a/examples/Kaleidoscope/Orc/initial/toy.cpp b/examples/Kaleidoscope/Orc/initial/toy.cpp index 2a6bb92246d..77c8db46ba9 100644 --- a/examples/Kaleidoscope/Orc/initial/toy.cpp +++ b/examples/Kaleidoscope/Orc/initial/toy.cpp @@ -746,8 +746,8 @@ static AllocaInst *CreateEntryBlockAlloca(Function *TheFunction, const std::string &VarName) { IRBuilder<> TmpB(&TheFunction->getEntryBlock(), TheFunction->getEntryBlock().begin()); - return TmpB.CreateAlloca(Type::getDoubleTy(getGlobalContext()), nullptr, - VarName.c_str()); + return TmpB.CreateAlloca(Type::getDoubleTy(TheFunction->getContext()), + nullptr, VarName.c_str()); } Value *NumberExprAST::IRGen(IRGenContext &C) const { @@ -806,8 +806,8 @@ Value *BinaryExprAST::IRGen(IRGenContext &C) const { 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()), - "booltmp"); + return C.getBuilder().CreateUIToFP(L, Type::getDoubleTy(C.getLLVMContext()), + "booltmp"); default: break; } @@ -884,8 +884,8 @@ Value *IfExprAST::IRGen(IRGenContext &C) const { // Emit merge block. TheFunction->getBasicBlockList().push_back(MergeBB); C.getBuilder().SetInsertPoint(MergeBB); - PHINode *PN = C.getBuilder().CreatePHI(Type::getDoubleTy(getGlobalContext()), 2, - "iftmp"); + PHINode *PN = C.getBuilder().CreatePHI(Type::getDoubleTy(C.getLLVMContext()), + 2, "iftmp"); PN->addIncoming(ThenV, ThenBB); PN->addIncoming(ElseV, ElseBB); @@ -927,7 +927,8 @@ Value *ForExprAST::IRGen(IRGenContext &C) const { // 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); @@ -953,7 +954,7 @@ Value *ForExprAST::IRGen(IRGenContext &C) const { 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. @@ -967,12 +968,12 @@ Value *ForExprAST::IRGen(IRGenContext &C) const { 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)), - "loopcond"); + EndCond = C.getBuilder().CreateFCmpONE( + EndCond, 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); @@ -987,7 +988,7 @@ Value *ForExprAST::IRGen(IRGenContext &C) const { 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 { @@ -1010,7 +1011,7 @@ Value *VarExprAST::IRGen(IRGenContext &C) const { 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); @@ -1039,10 +1040,10 @@ 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()), - Doubles, false); + std::vector<Type *> Doubles(Args.size(), + Type::getDoubleTy(C.getLLVMContext())); + FunctionType *FT = + FunctionType::get(Type::getDoubleTy(C.getLLVMContext()), Doubles, false); Function *F = Function::Create(FT, Function::ExternalLinkage, FnName, &C.getM()); @@ -1103,7 +1104,7 @@ Function *FunctionAST::IRGen(IRGenContext &C) const { 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. @@ -1261,7 +1262,8 @@ static void HandleTopLevelExpression(SessionContext &S, KaleidoscopeJIT &J) { /// top ::= definition | external | expression | ';' static void MainLoop() { - SessionContext S(getGlobalContext()); + LLVMContext TheContext; + SessionContext S(TheContext); KaleidoscopeJIT J(S); while (1) { diff --git a/examples/Kaleidoscope/Orc/lazy_codegen/toy.cpp b/examples/Kaleidoscope/Orc/lazy_codegen/toy.cpp index 5205b406ed7..5ab8c4fa9c9 100644 --- a/examples/Kaleidoscope/Orc/lazy_codegen/toy.cpp +++ b/examples/Kaleidoscope/Orc/lazy_codegen/toy.cpp @@ -746,8 +746,8 @@ static AllocaInst *CreateEntryBlockAlloca(Function *TheFunction, const std::string &VarName) { IRBuilder<> TmpB(&TheFunction->getEntryBlock(), TheFunction->getEntryBlock().begin()); - return TmpB.CreateAlloca(Type::getDoubleTy(getGlobalContext()), nullptr, - VarName.c_str()); + return TmpB.CreateAlloca(Type::getDoubleTy(TheFunction->getContext()), + nullptr, VarName.c_str()); } Value *NumberExprAST::IRGen(IRGenContext &C) const { @@ -806,8 +806,8 @@ Value *BinaryExprAST::IRGen(IRGenContext &C) const { 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()), - "booltmp"); + return C.getBuilder().CreateUIToFP(L, Type::getDoubleTy(C.getLLVMContext()), + "booltmp"); default: break; } @@ -884,8 +884,8 @@ Value *IfExprAST::IRGen(IRGenContext &C) const { // Emit merge block. TheFunction->getBasicBlockList().push_back(MergeBB); C.getBuilder().SetInsertPoint(MergeBB); - PHINode *PN = C.getBuilder().CreatePHI(Type::getDoubleTy(getGlobalContext()), 2, - "iftmp"); + PHINode *PN = C.getBuilder().CreatePHI(Type::getDoubleTy(C.getLLVMContext()), + 2, "iftmp"); PN->addIncoming(ThenV, ThenBB); PN->addIncoming(ElseV, ElseBB); @@ -927,7 +927,8 @@ Value *ForExprAST::IRGen(IRGenContext &C) const { // 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); @@ -953,7 +954,7 @@ Value *ForExprAST::IRGen(IRGenContext &C) const { 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. @@ -967,12 +968,12 @@ Value *ForExprAST::IRGen(IRGenContext &C) const { 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)), - "loopcond"); + EndCond = C.getBuilder().CreateFCmpONE( + EndCond, 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); @@ -987,7 +988,7 @@ Value *ForExprAST::IRGen(IRGenContext &C) const { 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 { @@ -1010,7 +1011,7 @@ Value *VarExprAST::IRGen(IRGenContext &C) const { 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); @@ -1039,10 +1040,10 @@ 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()), - Doubles, false); + std::vector<Type *> Doubles(Args.size(), + Type::getDoubleTy(C.getLLVMContext())); + FunctionType *FT = + FunctionType::get(Type::getDoubleTy(C.getLLVMContext()), Doubles, false); Function *F = Function::Create(FT, Function::ExternalLinkage, FnName, &C.getM()); @@ -1103,7 +1104,7 @@ Function *FunctionAST::IRGen(IRGenContext &C) const { 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. @@ -1265,7 +1266,8 @@ static void HandleTopLevelExpression(SessionContext &S, KaleidoscopeJIT &J) { /// top ::= definition | external | expression | ';' static void MainLoop() { - SessionContext S(getGlobalContext()); + LLVMContext TheContext; + SessionContext S(TheContext); KaleidoscopeJIT J(S); while (1) { diff --git a/examples/Kaleidoscope/Orc/lazy_irgen/toy.cpp b/examples/Kaleidoscope/Orc/lazy_irgen/toy.cpp index ebaff49e89b..0a58169e5ea 100644 --- a/examples/Kaleidoscope/Orc/lazy_irgen/toy.cpp +++ b/examples/Kaleidoscope/Orc/lazy_irgen/toy.cpp @@ -746,8 +746,8 @@ static AllocaInst *CreateEntryBlockAlloca(Function *TheFunction, const std::string &VarName) { IRBuilder<> TmpB(&TheFunction->getEntryBlock(), TheFunction->getEntryBlock().begin()); - return TmpB.CreateAlloca(Type::getDoubleTy(getGlobalContext()), nullptr, - VarName.c_str()); + return TmpB.CreateAlloca(Type::getDoubleTy(TheFunction->getContext()), + nullptr, VarName.c_str()); } Value *NumberExprAST::IRGen(IRGenContext &C) const { @@ -806,8 +806,8 @@ Value *BinaryExprAST::IRGen(IRGenContext &C) const { 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()), - "booltmp"); + return C.getBuilder().CreateUIToFP(L, Type::getDoubleTy(C.getLLVMContext()), + "booltmp"); default: break; } @@ -884,8 +884,8 @@ Value *IfExprAST::IRGen(IRGenContext &C) const { // Emit merge block. TheFunction->getBasicBlockList().push_back(MergeBB); C.getBuilder().SetInsertPoint(MergeBB); - PHINode *PN = C.getBuilder().CreatePHI(Type::getDoubleTy(getGlobalContext()), 2, - "iftmp"); + PHINode *PN = C.getBuilder().CreatePHI(Type::getDoubleTy(C.getLLVMContext()), + 2, "iftmp"); PN->addIncoming(ThenV, ThenBB); PN->addIncoming(ElseV, ElseBB); @@ -927,7 +927,8 @@ Value *ForExprAST::IRGen(IRGenContext &C) const { // 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); @@ -953,7 +954,7 @@ Value *ForExprAST::IRGen(IRGenContext &C) const { 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. @@ -967,12 +968,12 @@ Value *ForExprAST::IRGen(IRGenContext &C) const { 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)), - "loopcond"); + EndCond = C.getBuilder().CreateFCmpONE( + EndCond, 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); @@ -987,7 +988,7 @@ Value *ForExprAST::IRGen(IRGenContext &C) const { 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 { @@ -1010,7 +1011,7 @@ Value *VarExprAST::IRGen(IRGenContext &C) const { 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); @@ -1039,10 +1040,10 @@ 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()), - Doubles, false); + std::vector<Type *> Doubles(Args.size(), + Type::getDoubleTy(C.getLLVMContext())); + FunctionType *FT = + FunctionType::get(Type::getDoubleTy(C.getLLVMContext()), Doubles, false); Function *F = Function::Create(FT, Function::ExternalLinkage, FnName, &C.getM()); @@ -1103,7 +1104,7 @@ Function *FunctionAST::IRGen(IRGenContext &C) const { 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. @@ -1296,7 +1297,8 @@ static void HandleTopLevelExpression(SessionContext &S, KaleidoscopeJIT &J) { /// top ::= definition | external | expression | ';' static void MainLoop() { - SessionContext S(getGlobalContext()); + LLVMContext TheContext; + SessionContext S(TheContext); KaleidoscopeJIT J(S); while (1) { diff --git a/include/llvm/LinkAllIR.h b/include/llvm/LinkAllIR.h index 2b0604aee06..77e19ce900e 100644 --- a/include/llvm/LinkAllIR.h +++ b/include/llvm/LinkAllIR.h @@ -43,8 +43,9 @@ namespace { // 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; diff --git a/lib/Bitcode/Reader/BitReader.cpp b/lib/Bitcode/Reader/BitReader.cpp index 385c18a4000..9ac3cb95d08 100644 --- a/lib/Bitcode/Reader/BitReader.cpp +++ b/lib/Bitcode/Reader/BitReader.cpp @@ -25,14 +25,13 @@ using namespace llvm; 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, - OutModule); + return LLVMParseBitcodeInContext2(LLVMGetGlobalContext(), MemBuf, OutModule); } static void diagnosticHandler(const DiagnosticInfo &DI, void *C) { diff --git a/lib/Target/CppBackend/CPPBackend.cpp b/lib/Target/CppBackend/CPPBackend.cpp index a086e710d16..bc2bf155c51 100644 --- a/lib/Target/CppBackend/CPPBackend.cpp +++ b/lib/Target/CppBackend/CPPBackend.cpp @@ -1947,6 +1947,7 @@ void CppWriter::printProgram(const std::string& fname, 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"; @@ -1965,7 +1966,7 @@ void CppWriter::printModule(const std::string& 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() << "\");"; diff --git a/lib/Target/Target.cpp b/lib/Target/Target.cpp index c2b4393fe4c..5d1616d0377 100644 --- a/lib/Target/Target.cpp +++ b/lib/Target/Target.cpp @@ -24,6 +24,9 @@ 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); } @@ -81,11 +84,11 @@ unsigned LLVMPointerSizeForAS(LLVMTargetDataRef TD, unsigned 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) { diff --git a/tools/bugpoint/bugpoint.cpp b/tools/bugpoint/bugpoint.cpp index 48f30e6709f..272aca51148 100644 --- a/tools/bugpoint/bugpoint.cpp +++ b/tools/bugpoint/bugpoint.cpp @@ -143,7 +143,7 @@ int main(int argc, char **argv) { 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()) { diff --git a/tools/llc/llc.cpp b/tools/llc/llc.cpp index 55f458e6be3..5ad86e07469 100644 --- a/tools/llc/llc.cpp +++ b/tools/llc/llc.cpp @@ -187,7 +187,7 @@ int main(int argc, char **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. diff --git a/tools/lli/lli.cpp b/tools/lli/lli.cpp index 9fa2e77f60f..581a11b14dd 100644 --- a/tools/lli/lli.cpp +++ b/tools/lli/lli.cpp @@ -385,7 +385,7 @@ 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 diff --git a/tools/llvm-as-fuzzer/llvm-as-fuzzer.cpp b/tools/llvm-as-fuzzer/llvm-as-fuzzer.cpp index b4024bcaa99..52deca6e9cd 100644 --- a/tools/llvm-as-fuzzer/llvm-as-fuzzer.cpp +++ b/tools/llvm-as-fuzzer/llvm-as-fuzzer.cpp @@ -53,7 +53,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) { // 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)) diff --git a/tools/llvm-as/llvm-as.cpp b/tools/llvm-as/llvm-as.cpp index 1e795083992..ff9c4436ec1 100644 --- a/tools/llvm-as/llvm-as.cpp +++ b/tools/llvm-as/llvm-as.cpp @@ -91,7 +91,7 @@ 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"); diff --git a/tools/llvm-dis/llvm-dis.cpp b/tools/llvm-dis/llvm-dis.cpp index 9fdfcd4256c..092a5f87351 100644 --- a/tools/llvm-dis/llvm-dis.cpp +++ b/tools/llvm-dis/llvm-dis.cpp @@ -137,7 +137,7 @@ int main(int argc, char **argv) { 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]); diff --git a/tools/llvm-extract/llvm-extract.cpp b/tools/llvm-extract/llvm-extract.cpp index 1da456d33f5..b37b8989a04 100644 --- a/tools/llvm-extract/llvm-extract.cpp +++ b/tools/llvm-extract/llvm-extract.cpp @@ -105,7 +105,7 @@ int main(int argc, char **argv) { 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"); diff --git a/tools/llvm-jitlistener/llvm-jitlistener.cpp b/tools/llvm-jitlistener/llvm-jitlistener.cpp index af1a59bdbd3..9e1886ef80b 100644 --- a/tools/llvm-jitlistener/llvm-jitlistener.cpp +++ b/tools/llvm-jitlistener/llvm-jitlistener.cpp @@ -105,8 +105,6 @@ unsigned int GetNewMethodID(void) { 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(); diff --git a/tools/llvm-link/llvm-link.cpp b/tools/llvm-link/llvm-link.cpp index 729f8fd6449..7d02425adb8 100644 --- a/tools/llvm-link/llvm-link.cpp +++ b/tools/llvm-link/llvm-link.cpp @@ -331,7 +331,7 @@ int main(int argc, char **argv) { 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. diff --git a/tools/llvm-nm/llvm-nm.cpp b/tools/llvm-nm/llvm-nm.cpp index 58b28196b53..f2d2976d9d7 100644 --- a/tools/llvm-nm/llvm-nm.cpp +++ b/tools/llvm-nm/llvm-nm.cpp @@ -1020,7 +1020,7 @@ static void dumpSymbolNamesFromFile(std::string &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) { diff --git a/tools/llvm-profdata/llvm-profdata.cpp b/tools/llvm-profdata/llvm-profdata.cpp index 046e82fa6ed..f8489cccef0 100644 --- a/tools/llvm-profdata/llvm-profdata.cpp +++ b/tools/llvm-profdata/llvm-profdata.cpp @@ -164,9 +164,9 @@ static void mergeSampleProfile(const WeightedFileVector &Inputs, 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()); + auto ReaderOrErr = SampleProfileReader::create(Input.Filename, Context); if (std::error_code EC = ReaderOrErr.getError()) exitWithErrorCode(EC, Input.Filename); @@ -365,7 +365,8 @@ 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); diff --git a/tools/llvm-split/llvm-split.cpp b/tools/llvm-split/llvm-split.cpp index 010b1eb7320..024363547f9 100644 --- a/tools/llvm-split/llvm-split.cpp +++ b/tools/llvm-split/llvm-split.cpp @@ -41,7 +41,7 @@ static cl::opt<bool> 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"); diff --git a/tools/llvm-stress/llvm-stress.cpp b/tools/llvm-stress/llvm-stress.cpp index 99d2afdcd30..d4549e5d95e 100644 --- a/tools/llvm-stress/llvm-stress.cpp +++ b/tools/llvm-stress/llvm-stress.cpp @@ -43,6 +43,8 @@ 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: @@ -50,7 +52,6 @@ public: // 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); @@ -687,7 +688,7 @@ int main(int argc, char **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 diff --git a/tools/lto/lto.cpp b/tools/lto/lto.cpp index e22b198b3e1..5a179728e7c 100644 --- a/tools/lto/lto.cpp +++ b/tools/lto/lto.cpp @@ -101,7 +101,8 @@ static void lto_initialize() { InitializeAllAsmPrinters(); InitializeAllDisassemblers(); - LTOContext = &getGlobalContext(); + static LLVMContext Context; + LTOContext = &Context; LTOContext->setDiagnosticHandler(diagnosticHandler, nullptr, true); initialized = true; } diff --git a/tools/opt/opt.cpp b/tools/opt/opt.cpp index a27ce735b53..ca3ab8a49ab 100644 --- a/tools/opt/opt.cpp +++ b/tools/opt/opt.cpp @@ -316,7 +316,7 @@ int main(int argc, char **argv) { EnableDebugBuffering = true; llvm_shutdown_obj Y; // Call llvm_shutdown() on exit. - LLVMContext &Context = getGlobalContext(); + LLVMContext Context; InitializeAllTargets(); InitializeAllTargetMCs(); diff --git a/tools/verify-uselistorder/verify-uselistorder.cpp b/tools/verify-uselistorder/verify-uselistorder.cpp index c3fec1326ac..a2f80996416 100644 --- a/tools/verify-uselistorder/verify-uselistorder.cpp +++ b/tools/verify-uselistorder/verify-uselistorder.cpp @@ -525,7 +525,7 @@ int main(int argc, char **argv) { 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"); diff --git a/unittests/Analysis/AliasAnalysisTest.cpp b/unittests/Analysis/AliasAnalysisTest.cpp index 3ef635cf3b0..40436ef99b8 100644 --- a/unittests/Analysis/AliasAnalysisTest.cpp +++ b/unittests/Analysis/AliasAnalysisTest.cpp @@ -207,14 +207,13 @@ TEST_F(AliasAnalysisTest, getModRefInfo) { 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" diff --git a/unittests/Analysis/BlockFrequencyInfoTest.cpp b/unittests/Analysis/BlockFrequencyInfoTest.cpp index 64516373e8e..b3b0fcfb049 100644 --- a/unittests/Analysis/BlockFrequencyInfoTest.cpp +++ b/unittests/Analysis/BlockFrequencyInfoTest.cpp @@ -30,6 +30,7 @@ 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)); @@ -50,7 +51,6 @@ protected: " %y2 = phi i32 [0, %bb1], [1, %bb2] \n" " ret i32 %y2\n" "}\n"; - LLVMContext &C = getGlobalContext(); SMDiagnostic Err; return parseAssemblyString(ModuleStrig, Err, C); } diff --git a/unittests/Analysis/CFGTest.cpp b/unittests/Analysis/CFGTest.cpp index 44f0fe681df..c60044fa52d 100644 --- a/unittests/Analysis/CFGTest.cpp +++ b/unittests/Analysis/CFGTest.cpp @@ -31,7 +31,7 @@ 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); @@ -112,6 +112,7 @@ protected: PM.run(*M); } + LLVMContext Context; std::unique_ptr<Module> M; Instruction *A, *B; }; diff --git a/unittests/Analysis/CGSCCPassManagerTest.cpp b/unittests/Analysis/CGSCCPassManagerTest.cpp index 857c84d5016..7f6e4d13ff8 100644 --- a/unittests/Analysis/CGSCCPassManagerTest.cpp +++ b/unittests/Analysis/CGSCCPassManagerTest.cpp @@ -209,51 +209,50 @@ struct 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" - "entry:\n" - " call void @g()\n" - " call void @h1()\n" - " ret void\n" - "}\n" - "define void @g() {\n" - "entry:\n" - " call void @g()\n" - " call void @x()\n" - " ret void\n" - "}\n" - "define void @h1() {\n" - "entry:\n" - " call void @h2()\n" - " ret void\n" - "}\n" - "define void @h2() {\n" - "entry:\n" - " call void @h3()\n" - " call void @x()\n" - " ret void\n" - "}\n" - "define void @h3() {\n" - "entry:\n" - " call void @h1()\n" - " ret void\n" - "}\n" - "define void @x() {\n" - "entry:\n" - " ret void\n" - "}\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" + " call void @x()\n" + " ret void\n" + "}\n" + "define void @h1() {\n" + "entry:\n" + " call void @h2()\n" + " ret void\n" + "}\n" + "define void @h2() {\n" + "entry:\n" + " call void @h3()\n" + " call void @x()\n" + " ret void\n" + "}\n" + "define void @h3() {\n" + "entry:\n" + " call void @h1()\n" + " ret void\n" + "}\n" + "define void @x() {\n" + "entry:\n" + " ret void\n" + "}\n")) {} }; TEST_F(CGSCCPassManagerTest, Basic) { diff --git a/unittests/Analysis/CallGraphTest.cpp b/unittests/Analysis/CallGraphTest.cpp index 777907a55b1..af46291074c 100644 --- a/unittests/Analysis/CallGraphTest.cpp +++ b/unittests/Analysis/CallGraphTest.cpp @@ -44,14 +44,16 @@ template <typename Ty> void canSpecializeGraphTraitsIterators(Ty *G) { } 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)); diff --git a/unittests/Analysis/LazyCallGraphTest.cpp b/unittests/Analysis/LazyCallGraphTest.cpp index 457c07dc308..224a9458cc8 100644 --- a/unittests/Analysis/LazyCallGraphTest.cpp +++ b/unittests/Analysis/LazyCallGraphTest.cpp @@ -21,10 +21,10 @@ 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()); + std::unique_ptr<Module> M = parseAssemblyString(Assembly, Error, Context); std::string ErrMsg; raw_string_ostream OS(ErrMsg); @@ -121,7 +121,8 @@ static const char DiamondOfTriangles[] = "}\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 @@ -280,21 +281,21 @@ static Function &lookupFunction(Module &M, StringRef Name) { } TEST(LazyCallGraphTest, BasicGraphMutation) { - std::unique_ptr<Module> M = parseAssembly( - "define void @a() {\n" - "entry:\n" - " call void @b()\n" - " call void @c()\n" - " ret void\n" - "}\n" - "define void @b() {\n" - "entry:\n" - " ret void\n" - "}\n" - "define void @c() {\n" - "entry:\n" - " ret void\n" - "}\n"); + 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" + " ret void\n" + "}\n" + "define void @c() {\n" + "entry:\n" + " ret void\n" + "}\n"); LazyCallGraph CG(*M); LazyCallGraph::Node &A = CG.get(lookupFunction(*M, "a")); @@ -328,7 +329,8 @@ TEST(LazyCallGraphTest, BasicGraphMutation) { } 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 @@ -391,37 +393,37 @@ TEST(LazyCallGraphTest, InnerSCCFormation) { } 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( - "define void @f1() {\n" - "entry:\n" - " call void @f2()\n" - " call void @f4()\n" - " ret void\n" - "}\n" - "define void @f2() {\n" - "entry:\n" - " call void @f3()\n" - " ret void\n" - "}\n" - "define void @f3() {\n" - "entry:\n" - " call void @f1()\n" - " ret void\n" - "}\n" - "define void @f4() {\n" - "entry:\n" - " call void @f5()\n" - " ret void\n" - "}\n" - "define void @f5() {\n" - "entry:\n" - " call void @f1()\n" - " ret void\n" - "}\n"); + 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" + " call void @f3()\n" + " ret void\n" + "}\n" + "define void @f3() {\n" + "entry:\n" + " call void @f1()\n" + " ret void\n" + "}\n" + "define void @f4() {\n" + "entry:\n" + " call void @f5()\n" + " ret void\n" + "}\n" + "define void @f5() {\n" + "entry:\n" + " call void @f1()\n" + " ret void\n" + "}\n"); LazyCallGraph CG(*M); // Force the graph to be fully expanded. @@ -451,27 +453,27 @@ TEST(LazyCallGraphTest, MultiArmSCC) { } TEST(LazyCallGraphTest, OutgoingEdgeMutation) { - std::unique_ptr<Module> M = parseAssembly( - "define void @a() {\n" - "entry:\n" - " call void @b()\n" - " call void @c()\n" - " ret void\n" - "}\n" - "define void @b() {\n" - "entry:\n" - " call void @d()\n" - " ret void\n" - "}\n" - "define void @c() {\n" - "entry:\n" - " call void @d()\n" - " ret void\n" - "}\n" - "define void @d() {\n" - "entry:\n" - " ret void\n" - "}\n"); + 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" + " call void @d()\n" + " ret void\n" + "}\n" + "define void @c() {\n" + "entry:\n" + " call void @d()\n" + " ret void\n" + "}\n" + "define void @d() {\n" + "entry:\n" + " ret void\n" + "}\n"); LazyCallGraph CG(*M); // Force the graph to be fully expanded. @@ -575,6 +577,7 @@ TEST(LazyCallGraphTest, OutgoingEdgeMutation) { } 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. @@ -591,7 +594,7 @@ TEST(LazyCallGraphTest, IncomingEdgeInsertion) { // / \ | // 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. @@ -668,9 +671,10 @@ TEST(LazyCallGraphTest, IncomingEdgeInsertion) { } 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'. @@ -744,22 +748,22 @@ TEST(LazyCallGraphTest, IncomingEdgeInsertionMidTraversal) { } TEST(LazyCallGraphTest, InternalEdgeMutation) { - std::unique_ptr<Module> M = parseAssembly( - "define void @a() {\n" - "entry:\n" - " call void @b()\n" - " ret void\n" - "}\n" - "define void @b() {\n" - "entry:\n" - " call void @c()\n" - " ret void\n" - "}\n" - "define void @c() {\n" - "entry:\n" - " call void @a()\n" - " ret void\n" - "}\n"); + 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" + " ret void\n" + "}\n" + "define void @c() {\n" + "entry:\n" + " call void @a()\n" + " ret void\n" + "}\n"); LazyCallGraph CG(*M); // Force the graph to be fully expanded. @@ -824,29 +828,30 @@ TEST(LazyCallGraphTest, InternalEdgeMutation) { } TEST(LazyCallGraphTest, InternalEdgeRemoval) { + LLVMContext Context; // A nice fully connected (including self-edges) RefSCC. std::unique_ptr<Module> M = parseAssembly( - "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" - "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 @c(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"); + 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" + "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 @c(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"); LazyCallGraph CG(*M); // Force the graph to be fully expanded. @@ -882,29 +887,29 @@ TEST(LazyCallGraphTest, InternalEdgeRemoval) { } TEST(LazyCallGraphTest, InternalCallEdgeToRef) { + LLVMContext Context; // A nice fully connected (including self-edges) SCC (and RefSCC) - std::unique_ptr<Module> M = parseAssembly( - "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" - "entry:\n" - " call void @a()\n" - " call void @b()\n" - " call void @c()\n" - " ret void\n" - "}\n" - "define void @c() {\n" - "entry:\n" - " call void @a()\n" - " call void @b()\n" - " call void @c()\n" - " ret void\n" - "}\n"); + 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" + "entry:\n" + " call void @a()\n" + " call void @b()\n" + " call void @c()\n" + " ret void\n" + "}\n" + "define void @c() {\n" + "entry:\n" + " call void @a()\n" + " call void @b()\n" + " call void @c()\n" + " ret void\n" + "}\n"); LazyCallGraph CG(*M); // Force the graph to be fully expanded. @@ -964,33 +969,34 @@ TEST(LazyCallGraphTest, InternalCallEdgeToRef) { } 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( - "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" - "entry:\n" - " store void()* @c, void()** undef\n" - " call void @d()\n" - " ret void\n" - "}\n" - "define void @c() {\n" - "entry:\n" - " store void()* @b, void()** undef\n" - " call void @d()\n" - " ret void\n" - "}\n" - "define void @d() {\n" - "entry:\n" - " store void()* @a, void()** undef\n" - " ret void\n" - "}\n"); + 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" + "entry:\n" + " store void()* @c, void()** undef\n" + " call void @d()\n" + " ret void\n" + "}\n" + "define void @c() {\n" + "entry:\n" + " store void()* @b, void()** undef\n" + " call void @d()\n" + " ret void\n" + "}\n" + "define void @d() {\n" + "entry:\n" + " store void()* @a, void()** undef\n" + " ret void\n" + "}\n"); LazyCallGraph CG(*M); // Force the graph to be fully expanded. @@ -1049,59 +1055,60 @@ TEST(LazyCallGraphTest, InternalRefEdgeToCall) { } 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( - "define void @a() {\n" - "entry:\n" - " call void @b1()\n" - " call void @c1()\n" - " ret void\n" - "}\n" - "define void @b1() {\n" - "entry:\n" - " call void @c1()\n" - " call void @b2()\n" - " ret void\n" - "}\n" - "define void @c1() {\n" - "entry:\n" - " call void @b2()\n" - " call void @c2()\n" - " ret void\n" - "}\n" - "define void @b2() {\n" - "entry:\n" - " call void @c2()\n" - " call void @b3()\n" - " ret void\n" - "}\n" - "define void @c2() {\n" - "entry:\n" - " call void @b3()\n" - " call void @c3()\n" - " ret void\n" - "}\n" - "define void @b3() {\n" - "entry:\n" - " call void @c3()\n" - " call void @d()\n" - " ret void\n" - "}\n" - "define void @c3() {\n" - "entry:\n" - " store void()* @b1, void()** undef\n" - " call void @d()\n" - " ret void\n" - "}\n" - "define void @d() {\n" - "entry:\n" - " store void()* @a, void()** undef\n" - " ret void\n" - "}\n"); + 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" + " call void @c1()\n" + " call void @b2()\n" + " ret void\n" + "}\n" + "define void @c1() {\n" + "entry:\n" + " call void @b2()\n" + " call void @c2()\n" + " ret void\n" + "}\n" + "define void @b2() {\n" + "entry:\n" + " call void @c2()\n" + " call void @b3()\n" + " ret void\n" + "}\n" + "define void @c2() {\n" + "entry:\n" + " call void @b3()\n" + " call void @c3()\n" + " ret void\n" + "}\n" + "define void @b3() {\n" + "entry:\n" + " call void @c3()\n" + " call void @d()\n" + " ret void\n" + "}\n" + "define void @c3() {\n" + "entry:\n" + " store void()* @b1, void()** undef\n" + " call void @d()\n" + " ret void\n" + "}\n" + "define void @d() {\n" + "entry:\n" + " store void()* @a, void()** undef\n" + " ret void\n" + "}\n"); LazyCallGraph CG(*M); // Force the graph to be fully expanded. @@ -1163,6 +1170,7 @@ TEST(LazyCallGraphTest, InternalRefEdgeToCallNoCycleInterleaved) { } 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 @@ -1190,47 +1198,47 @@ TEST(LazyCallGraphTest, InternalRefEdgeToCallBothPartitionAndMerge) { // G | G | // // And we form a cycle by connecting F to B. - std::unique_ptr<Module> M = parseAssembly( - "define void @a() {\n" - "entry:\n" - " call void @b()\n" - " call void @e()\n" - " ret void\n" - "}\n" - "define void @b() {\n" - "entry:\n" - " call void @c()\n" - " call void @d()\n" - " ret void\n" - "}\n" - "define void @c() {\n" - "entry:\n" - " call void @d()\n" - " call void @g()\n" - " ret void\n" - "}\n" - "define void @d() {\n" - "entry:\n" - " call void @e()\n" - " call void @f()\n" - " ret void\n" - "}\n" - "define void @e() {\n" - "entry:\n" - " call void @f()\n" - " ret void\n" - "}\n" - "define void @f() {\n" - "entry:\n" - " store void()* @b, void()** undef\n" - " call void @g()\n" - " ret void\n" - "}\n" - "define void @g() {\n" - "entry:\n" - " store void()* @a, void()** undef\n" - " ret void\n" - "}\n"); + 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" + " call void @c()\n" + " call void @d()\n" + " ret void\n" + "}\n" + "define void @c() {\n" + "entry:\n" + " call void @d()\n" + " call void @g()\n" + " ret void\n" + "}\n" + "define void @d() {\n" + "entry:\n" + " call void @e()\n" + " call void @f()\n" + " ret void\n" + "}\n" + "define void @e() {\n" + "entry:\n" + " call void @f()\n" + " ret void\n" + "}\n" + "define void @f() {\n" + "entry:\n" + " store void()* @b, void()** undef\n" + " call void @g()\n" + " ret void\n" + "}\n" + "define void @g() {\n" + "entry:\n" + " store void()* @a, void()** undef\n" + " ret void\n" + "}\n"); LazyCallGraph CG(*M); // Force the graph to be fully expanded. diff --git a/unittests/Analysis/LoopPassManagerTest.cpp b/unittests/Analysis/LoopPassManagerTest.cpp index 8a620499a3e..3cbe203e14d 100644 --- a/unittests/Analysis/LoopPassManagerTest.cpp +++ b/unittests/Analysis/LoopPassManagerTest.cpp @@ -99,39 +99,39 @@ public: 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" - "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" - "end:\n" - " ret void\n" - "}\n" - "\n" - "define void @g() {\n" - "entry:\n" - " br label %loop.g.0\n" - "loop.g.0:\n" - " br i1 undef, label %loop.g.0, label %end\n" - "end:\n" - " ret void\n" - "}\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" + "end:\n" + " ret void\n" + "}\n" + "\n" + "define void @g() {\n" + "entry:\n" + " br label %loop.g.0\n" + "loop.g.0:\n" + " br i1 undef, label %loop.g.0, label %end\n" + "end:\n" + " ret void\n" + "}\n")) {} }; #define EXPECT_N_ELEMENTS_EQ(N, EXPECTED, ACTUAL) \ diff --git a/unittests/Analysis/UnrollAnalyzer.cpp b/unittests/Analysis/UnrollAnalyzer.cpp index 15d500a30c8..83d57f52469 100644 --- a/unittests/Analysis/UnrollAnalyzer.cpp +++ b/unittests/Analysis/UnrollAnalyzer.cpp @@ -60,11 +60,11 @@ struct UnrollAnalyzerTest : public FunctionPass { 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) { @@ -86,7 +86,8 @@ TEST(UnrollAnalyzerTest, BasicSimplifications) { " 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); @@ -148,7 +149,8 @@ TEST(UnrollAnalyzerTest, OuterLoopSimplification) { "}\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); @@ -188,7 +190,8 @@ TEST(UnrollAnalyzerTest, CmpSimplifications) { " 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); @@ -234,7 +237,8 @@ TEST(UnrollAnalyzerTest, PtrCmpSimplifications) { " 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); @@ -279,7 +283,8 @@ TEST(UnrollAnalyzerTest, CastSimplifications) { "}\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); diff --git a/unittests/Analysis/ValueTrackingTest.cpp b/unittests/Analysis/ValueTrackingTest.cpp index 3af856ea203..f429c3b9914 100644 --- a/unittests/Analysis/ValueTrackingTest.cpp +++ b/unittests/Analysis/ValueTrackingTest.cpp @@ -25,7 +25,7 @@ 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); @@ -59,6 +59,7 @@ protected: EXPECT_EQ(P.Ordered, R.Ordered); } + LLVMContext Context; std::unique_ptr<Module> M; Instruction *A, *B; }; diff --git a/unittests/AsmParser/AsmParserTest.cpp b/unittests/AsmParser/AsmParserTest.cpp index 38810cd7c7a..ddbedd05c7b 100644 --- a/unittests/AsmParser/AsmParserTest.cpp +++ b/unittests/AsmParser/AsmParserTest.cpp @@ -21,7 +21,7 @@ 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); @@ -34,7 +34,7 @@ TEST(AsmParserTest, NullTerminatedInput) { #ifndef NDEBUG TEST(AsmParserTest, NonNullTerminatedInput) { - LLVMContext &Ctx = getGlobalContext(); + LLVMContext Ctx; StringRef Source = "; Empty module \n\1\2"; SMDiagnostic Error; std::unique_ptr<Module> Mod; @@ -47,7 +47,7 @@ TEST(AsmParserTest, NonNullTerminatedInput) { #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; @@ -66,7 +66,7 @@ TEST(AsmParserTest, SlotMappingTest) { } 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); @@ -117,7 +117,7 @@ TEST(AsmParserTest, TypeAndConstantValueParsing) { } TEST(AsmParserTest, TypeAndConstantValueWithSlotMappingParsing) { - LLVMContext &Ctx = getGlobalContext(); + LLVMContext Ctx; SMDiagnostic Error; StringRef Source = "%st = type { i32, i32 }\n" @@ -153,7 +153,7 @@ TEST(AsmParserTest, TypeAndConstantValueWithSlotMappingParsing) { } TEST(AsmParserTest, TypeWithSlotMappingParsing) { - LLVMContext &Ctx = getGlobalContext(); + LLVMContext Ctx; SMDiagnostic Error; StringRef Source = "%st = type { i32, i32 }\n" @@ -277,7 +277,7 @@ TEST(AsmParserTest, TypeWithSlotMappingParsing) { } TEST(AsmParserTest, TypeAtBeginningWithSlotMappingParsing) { - LLVMContext &Ctx = getGlobalContext(); + LLVMContext Ctx; SMDiagnostic Error; StringRef Source = "%st = type { i32, i32 }\n" diff --git a/unittests/Bitcode/BitReaderTest.cpp b/unittests/Bitcode/BitReaderTest.cpp index 420aca2443b..d0f33d12d5b 100644 --- a/unittests/Bitcode/BitReaderTest.cpp +++ b/unittests/Bitcode/BitReaderTest.cpp @@ -29,10 +29,10 @@ 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()); + std::unique_ptr<Module> M = parseAssemblyString(Assembly, Error, Context); std::string ErrMsg; raw_string_ostream OS(ErrMsg); @@ -54,7 +54,7 @@ static void writeModuleToBuffer(std::unique_ptr<Module> Mod, 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 = @@ -82,7 +82,7 @@ public: 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)); diff --git a/unittests/ExecutionEngine/ExecutionEngineTest.cpp b/unittests/ExecutionEngine/ExecutionEngineTest.cpp index 3ffa9cd9b8f..7cad8413069 100644 --- a/unittests/ExecutionEngine/ExecutionEngineTest.cpp +++ b/unittests/ExecutionEngine/ExecutionEngineTest.cpp @@ -28,7 +28,7 @@ private: 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()); } @@ -44,13 +44,13 @@ protected: } 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"); + GlobalVariable *G1 = NewExtGlobal(Type::getInt32Ty(Context), "Global1"); int32_t Mem1 = 3; Engine->addGlobalMapping(G1, &Mem1); EXPECT_EQ(&Mem1, Engine->getPointerToGlobalIfAvailable(G1)); @@ -63,8 +63,7 @@ TEST_F(ExecutionEngineTest, ForwardGlobalMapping) { Engine->updateGlobalMapping(G1, &Mem2); EXPECT_EQ(&Mem2, Engine->getPointerToGlobalIfAvailable(G1)); - GlobalVariable *G2 = - NewExtGlobal(Type::getInt32Ty(getGlobalContext()), "Global1"); + GlobalVariable *G2 = NewExtGlobal(Type::getInt32Ty(Context), "Global1"); EXPECT_EQ(nullptr, Engine->getPointerToGlobalIfAvailable(G2)) << "The NULL return shouldn't depend on having called" << " updateGlobalMapping(..., NULL)"; @@ -76,8 +75,7 @@ TEST_F(ExecutionEngineTest, ForwardGlobalMapping) { } TEST_F(ExecutionEngineTest, ReverseGlobalMapping) { - GlobalVariable *G1 = - NewExtGlobal(Type::getInt32Ty(getGlobalContext()), "Global1"); + GlobalVariable *G1 = NewExtGlobal(Type::getInt32Ty(Context), "Global1"); int32_t Mem1 = 3; Engine->addGlobalMapping(G1, &Mem1); @@ -87,8 +85,7 @@ TEST_F(ExecutionEngineTest, ReverseGlobalMapping) { EXPECT_EQ(nullptr, Engine->getGlobalValueAtAddress(&Mem1)); EXPECT_EQ(G1, Engine->getGlobalValueAtAddress(&Mem2)); - GlobalVariable *G2 = - NewExtGlobal(Type::getInt32Ty(getGlobalContext()), "Global2"); + GlobalVariable *G2 = NewExtGlobal(Type::getInt32Ty(Context), "Global2"); Engine->updateGlobalMapping(G2, &Mem1); EXPECT_EQ(G2, Engine->getGlobalValueAtAddress(&Mem1)); EXPECT_EQ(G1, Engine->getGlobalValueAtAddress(&Mem2)); @@ -104,8 +101,7 @@ TEST_F(ExecutionEngineTest, ReverseGlobalMapping) { } TEST_F(ExecutionEngineTest, ClearModuleMappings) { - GlobalVariable *G1 = - NewExtGlobal(Type::getInt32Ty(getGlobalContext()), "Global1"); + GlobalVariable *G1 = NewExtGlobal(Type::getInt32Ty(Context), "Global1"); int32_t Mem1 = 3; Engine->addGlobalMapping(G1, &Mem1); @@ -115,8 +111,7 @@ TEST_F(ExecutionEngineTest, ClearModuleMappings) { EXPECT_EQ(nullptr, Engine->getGlobalValueAtAddress(&Mem1)); - GlobalVariable *G2 = - NewExtGlobal(Type::getInt32Ty(getGlobalContext()), "Global2"); + GlobalVariable *G2 = NewExtGlobal(Type::getInt32Ty(Context), "Global2"); // After clearing the module mappings, we can assign a new GV to the // same address. Engine->addGlobalMapping(G2, &Mem1); @@ -124,8 +119,7 @@ TEST_F(ExecutionEngineTest, ClearModuleMappings) { } TEST_F(ExecutionEngineTest, DestructionRemovesGlobalMapping) { - GlobalVariable *G1 = - NewExtGlobal(Type::getInt32Ty(getGlobalContext()), "Global1"); + GlobalVariable *G1 = NewExtGlobal(Type::getInt32Ty(Context), "Global1"); int32_t Mem1 = 3; Engine->addGlobalMapping(G1, &Mem1); // Make sure the reverse mapping is enabled. diff --git a/unittests/ExecutionEngine/Orc/IndirectionUtilsTest.cpp b/unittests/ExecutionEngine/Orc/IndirectionUtilsTest.cpp index 38b60ea7fcd..ac847039d9f 100644 --- a/unittests/ExecutionEngine/Orc/IndirectionUtilsTest.cpp +++ b/unittests/ExecutionEngine/Orc/IndirectionUtilsTest.cpp @@ -17,7 +17,8 @@ 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( diff --git a/unittests/ExecutionEngine/Orc/ObjectLinkingLayerTest.cpp b/unittests/ExecutionEngine/Orc/ObjectLinkingLayerTest.cpp index a733bd558c8..89adb665f22 100644 --- a/unittests/ExecutionEngine/Orc/ObjectLinkingLayerTest.cpp +++ b/unittests/ExecutionEngine/Orc/ObjectLinkingLayerTest.cpp @@ -25,6 +25,7 @@ namespace { class ObjectLinkingLayerExecutionTest : public testing::Test, public OrcExecutionTest { + }; class SectionMemoryManagerWrapper : public SectionMemoryManager { @@ -64,9 +65,10 @@ TEST(ObjectLinkingLayerTest, TestSetProcessAllSections) { 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"); @@ -131,14 +133,13 @@ TEST_F(ObjectLinkingLayerExecutionTest, NoDuplicateFinalization) { // 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", - BarImpl); + 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); } @@ -147,13 +148,12 @@ TEST_F(ObjectLinkingLayerExecutionTest, NoDuplicateFinalization) { 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", - FooImpl); + BasicBlock *FooEntry = BasicBlock::Create(Context, "entry", FooImpl); IRBuilder<> Builder(FooEntry); Builder.CreateRet(Builder.CreateCall(BarDecl)); } @@ -203,14 +203,13 @@ TEST_F(ObjectLinkingLayerExecutionTest, NoPrematureAllocation) { // 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", - BarImpl); + 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); } @@ -219,14 +218,13 @@ TEST_F(ObjectLinkingLayerExecutionTest, NoPrematureAllocation) { 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", - BarImpl); + 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); } diff --git a/unittests/ExecutionEngine/Orc/OrcCAPITest.cpp b/unittests/ExecutionEngine/Orc/OrcCAPITest.cpp index 776d26970a3..305325b6c6e 100644 --- a/unittests/ExecutionEngine/Orc/OrcCAPITest.cpp +++ b/unittests/ExecutionEngine/Orc/OrcCAPITest.cpp @@ -25,11 +25,11 @@ 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); diff --git a/unittests/ExecutionEngine/Orc/OrcTestCommon.h b/unittests/ExecutionEngine/Orc/OrcTestCommon.h index e8fab561564..fe3da88dc9d 100644 --- a/unittests/ExecutionEngine/Orc/OrcTestCommon.h +++ b/unittests/ExecutionEngine/Orc/OrcTestCommon.h @@ -54,6 +54,7 @@ public: }; protected: + LLVMContext Context; std::unique_ptr<TargetMachine> TM; private: static bool NativeTargetInitialized; diff --git a/unittests/IR/ConstantsTest.cpp b/unittests/IR/ConstantsTest.cpp index 7471584097d..39ae18ca5e0 100644 --- a/unittests/IR/ConstantsTest.cpp +++ b/unittests/IR/ConstantsTest.cpp @@ -22,7 +22,8 @@ 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); @@ -103,7 +104,8 @@ TEST(ConstantsTest, Integer_i1) { } 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()); @@ -116,16 +118,17 @@ TEST(ConstantsTest, IntSigns) { } 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); @@ -165,14 +168,15 @@ TEST(ConstantsTest, PointerCast) { } 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)); @@ -189,8 +193,7 @@ TEST(ConstantsTest, AsInstructionsTest) { Constant *One = ConstantInt::get(Int32Ty, 1); Constant *Two = ConstantInt::get(Int64Ty, 2); - Constant *Big = ConstantInt::get(getGlobalContext(), - APInt{256, uint64_t(-1), true}); + 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); @@ -278,9 +281,10 @@ TEST(ConstantsTest, AsInstructionsTest) { #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 = diff --git a/unittests/IR/DominatorTreeTest.cpp b/unittests/IR/DominatorTreeTest.cpp index fcd6b9c65b4..6c49deb32d9 100644 --- a/unittests/IR/DominatorTreeTest.cpp +++ b/unittests/IR/DominatorTreeTest.cpp @@ -215,7 +215,7 @@ namespace llvm { }; 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" \ @@ -239,14 +239,14 @@ namespace llvm { " %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); diff --git a/unittests/IR/InstructionsTest.cpp b/unittests/IR/InstructionsTest.cpp index cfc55b05ab9..0dac7c1bcfb 100644 --- a/unittests/IR/InstructionsTest.cpp +++ b/unittests/IR/InstructionsTest.cpp @@ -27,7 +27,7 @@ namespace llvm { namespace { TEST(InstructionsTest, ReturnInst) { - LLVMContext &C(getGlobalContext()); + LLVMContext C; // test for PR6589 const ReturnInst* r0 = ReturnInst::Create(C); @@ -103,7 +103,7 @@ TEST_F(ModuleWithFunctionTest, InvokeInst) { } TEST(InstructionsTest, BranchInst) { - LLVMContext &C(getGlobalContext()); + LLVMContext C; // Make a BasicBlocks BasicBlock* bb0 = BasicBlock::Create(C); @@ -169,7 +169,7 @@ TEST(InstructionsTest, BranchInst) { } TEST(InstructionsTest, CastInst) { - LLVMContext &C(getGlobalContext()); + LLVMContext C; Type *Int8Ty = Type::getInt8Ty(C); Type *Int16Ty = Type::getInt16Ty(C); @@ -281,14 +281,18 @@ TEST(InstructionsTest, CastInst) { // 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); @@ -391,7 +395,7 @@ TEST(InstructionsTest, VectorGep) { } TEST(InstructionsTest, FPMathOperator) { - LLVMContext &Context = getGlobalContext(); + LLVMContext Context; IRBuilder<> Builder(Context); MDBuilder MDHelper(Context); Instruction *I = Builder.CreatePHI(Builder.getDoubleTy(), 0); @@ -406,7 +410,7 @@ TEST(InstructionsTest, FPMathOperator) { TEST(InstructionsTest, isEliminableCastPair) { - LLVMContext &C(getGlobalContext()); + LLVMContext C; Type* Int16Ty = Type::getInt16Ty(C); Type* Int32Ty = Type::getInt32Ty(C); @@ -486,7 +490,7 @@ TEST(InstructionsTest, isEliminableCastPair) { } 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); @@ -519,7 +523,7 @@ TEST(InstructionsTest, CloneCall) { } 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()); @@ -546,7 +550,7 @@ TEST(InstructionsTest, AlterCallBundles) { } 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()); diff --git a/unittests/IR/LegacyPassManagerTest.cpp b/unittests/IR/LegacyPassManagerTest.cpp index 1f88283dc0c..fe2bb2e2e57 100644 --- a/unittests/IR/LegacyPassManagerTest.cpp +++ b/unittests/IR/LegacyPassManagerTest.cpp @@ -288,7 +288,8 @@ namespace llvm { 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(); @@ -311,7 +312,8 @@ namespace llvm { } 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(); @@ -334,11 +336,12 @@ namespace llvm { 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); @@ -348,7 +351,8 @@ namespace llvm { 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); @@ -383,7 +387,8 @@ namespace llvm { } TEST(PassManager, MemoryOnTheFly) { - Module *M = makeLLVMModule(); + LLVMContext Context; + Module *M = makeLLVMModule(Context); { SCOPED_TRACE("Running OnTheFlyTest"); struct OnTheFlyTest *O = new OnTheFlyTest(); @@ -396,9 +401,9 @@ namespace llvm { 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"); @@ -406,18 +411,17 @@ namespace llvm { // Type Definitions std::vector<Type*>FuncTy_0_args; - FunctionType* FuncTy_0 = FunctionType::get( - /*Result=*/IntegerType::get(getGlobalContext(), 32), - /*Params=*/FuncTy_0_args, - /*isVarArg=*/false); + FunctionType *FuncTy_0 = FunctionType::get( + /*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)); - FunctionType* FuncTy_2 = FunctionType::get( - /*Result=*/Type::getVoidTy(getGlobalContext()), - /*Params=*/FuncTy_2_args, - /*isVarArg=*/false); - + FuncTy_2_args.push_back(IntegerType::get(Context, 1)); + FunctionType *FuncTy_2 = FunctionType::get( + /*Result=*/Type::getVoidTy(Context), + /*Params=*/FuncTy_2_args, + /*isVarArg=*/false); // Function Declarations @@ -465,7 +469,8 @@ namespace llvm { // 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); @@ -473,14 +478,14 @@ namespace llvm { 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); @@ -488,14 +493,14 @@ namespace llvm { 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); @@ -503,8 +508,7 @@ namespace llvm { 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) @@ -513,10 +517,14 @@ namespace llvm { 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); @@ -528,8 +536,7 @@ namespace llvm { 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; } diff --git a/unittests/IR/MetadataTest.cpp b/unittests/IR/MetadataTest.cpp index 40590445f70..ba603644dbb 100644 --- a/unittests/IR/MetadataTest.cpp +++ b/unittests/IR/MetadataTest.cpp @@ -174,8 +174,8 @@ TEST_F(MDNodeTest, Simple) { 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))); + ConstantAsMetadata *CI = + ConstantAsMetadata::get(ConstantInt::get(Context, APInt(8, 0))); std::vector<Metadata *> V; V.push_back(s1); @@ -206,8 +206,8 @@ TEST_F(MDNodeTest, Simple) { } 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); @@ -2062,8 +2062,8 @@ TEST_F(ValueAsMetadataTest, UpdatesOnRAUW) { TEST_F(ValueAsMetadataTest, TempTempReplacement) { // Create a constant. - ConstantAsMetadata *CI = ConstantAsMetadata::get( - ConstantInt::get(getGlobalContext(), APInt(8, 0))); + ConstantAsMetadata *CI = + ConstantAsMetadata::get(ConstantInt::get(Context, APInt(8, 0))); auto Temp1 = MDTuple::getTemporary(Context, None); auto Temp2 = MDTuple::getTemporary(Context, {CI}); @@ -2079,8 +2079,8 @@ TEST_F(ValueAsMetadataTest, TempTempReplacement) { TEST_F(ValueAsMetadataTest, CollidingDoubleUpdates) { // Create a constant. - ConstantAsMetadata *CI = ConstantAsMetadata::get( - ConstantInt::get(getGlobalContext(), APInt(8, 0))); + ConstantAsMetadata *CI = + ConstantAsMetadata::get(ConstantInt::get(Context, APInt(8, 0))); // Create a temporary to prevent nodes from resolving. auto Temp = MDTuple::getTemporary(Context, None); diff --git a/unittests/IR/PassManagerTest.cpp b/unittests/IR/PassManagerTest.cpp index 15b29d9b896..3bfe22cf646 100644 --- a/unittests/IR/PassManagerTest.cpp +++ b/unittests/IR/PassManagerTest.cpp @@ -153,30 +153,30 @@ struct TestInvalidationFunctionPass 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" - "entry:\n" - " call void @g()\n" - " call void @h()\n" - " ret void\n" - "}\n" - "define void @g() {\n" - " ret void\n" - "}\n" - "define void @h() {\n" - " ret void\n" - "}\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" + "define void @h() {\n" + " ret void\n" + "}\n")) {} }; TEST_F(PassManagerTest, BasicPreservedAnalyses) { diff --git a/unittests/IR/TypeBuilderTest.cpp b/unittests/IR/TypeBuilderTest.cpp index b7b3e45e35e..02a0ce027f6 100644 --- a/unittests/IR/TypeBuilderTest.cpp +++ b/unittests/IR/TypeBuilderTest.cpp @@ -17,141 +17,175 @@ 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()), - (TypeBuilder<const volatile void*, false>::get( - 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(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()))); - - EXPECT_EQ(Type::getInt8PtrTy(getGlobalContext()), - (TypeBuilder<const volatile int8_t*const volatile, false>::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(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), - (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), - (TypeBuilder<int8_t(int32_t*, void*, char, char, char), - false>::get(getGlobalContext()))); - EXPECT_EQ(FunctionType::get(Type::getInt8Ty(getGlobalContext()), params, true), - (TypeBuilder<int8_t(int32_t*, char*, char, char, char, ...), - false>::get(getGlobalContext()))); + 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( + 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( + Context))); + EXPECT_EQ(FunctionType::get(Type::getInt8Ty(Context), params, true), + (TypeBuilder<int8_t(int32_t *, char *, char, char, char, ...), + false>::get(Context))); } TEST(TypeBuilderTest, Context) { @@ -230,24 +264,24 @@ public: 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()), - (void*)nullptr)), - (TypeBuilder<MyType*, false>::get(getGlobalContext()))); - 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()), - (void*)nullptr)), - (TypeBuilder<MyPortableType*, false>::get(getGlobalContext()))); - 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()), - (void*)nullptr)), - (TypeBuilder<MyPortableType*, true>::get(getGlobalContext()))); + TypeBuilder<int, false>::get(Context), + TypeBuilder<int *, false>::get(Context), + TypeBuilder<void *[], false>::get(Context), (void *)nullptr)), + (TypeBuilder<MyType *, false>::get(Context))); + EXPECT_EQ( + PointerType::getUnqual(StructType::get( + 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(Context))); + EXPECT_EQ( + PointerType::getUnqual(StructType::get( + 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(Context))); } } // anonymous namespace diff --git a/unittests/IR/UserTest.cpp b/unittests/IR/UserTest.cpp index 8d488389448..7d875aa80d4 100644 --- a/unittests/IR/UserTest.cpp +++ b/unittests/IR/UserTest.cpp @@ -94,9 +94,9 @@ TEST(UserTest, ValueOpIteration) { } TEST(UserTest, PersonalityUser) { - Module M("", getGlobalContext()); - FunctionType *RetVoidTy = - FunctionType::get(Type::getVoidTy(getGlobalContext()), false); + LLVMContext Context; + Module M("", Context); + FunctionType *RetVoidTy = FunctionType::get(Type::getVoidTy(Context), false); Function *PersonalityF = Function::Create( RetVoidTy, GlobalValue::ExternalLinkage, "PersonalityFn", &M); Function *TestF = diff --git a/unittests/IR/ValueHandleTest.cpp b/unittests/IR/ValueHandleTest.cpp index e1d598bbc58..59cd9d7ba37 100644 --- a/unittests/IR/ValueHandleTest.cpp +++ b/unittests/IR/ValueHandleTest.cpp @@ -20,13 +20,13 @@ 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()))) { - } + ValueHandle() + : ConstantV(ConstantInt::get(Type::getInt32Ty(Context), 0)), + BitcastV(new BitCastInst(ConstantV, Type::getInt32Ty(Context))) {} }; class ConcreteCallbackVH final : public CallbackVH { @@ -42,8 +42,8 @@ TEST_F(ValueHandle, WeakVH_BasicOperation) { // 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) { @@ -197,8 +197,8 @@ TEST_F(ValueHandle, CallbackVH_BasicOperation) { // 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) { @@ -297,15 +297,17 @@ TEST_F(ValueHandle, CallbackVH_DeletionCanRAUW) { 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 { @@ -318,15 +320,15 @@ TEST_F(ValueHandle, CallbackVH_DeletionCanRAUW) { // 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(); - std::unique_ptr<BinaryOperator> BitcastUser( - BinaryOperator::CreateAdd(RVH, - Constant::getNullValue(Type::getInt32Ty(getGlobalContext())))); + RecoveringVH RVH(Context); + RVH = RecoveringVH(Context, BitcastV.get()); + std::unique_ptr<BinaryOperator> BitcastUser(BinaryOperator::CreateAdd( + RVH, 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)); } diff --git a/unittests/IR/ValueMapTest.cpp b/unittests/IR/ValueMapTest.cpp index 71a1fd1c748..28633b44b11 100644 --- a/unittests/IR/ValueMapTest.cpp +++ b/unittests/IR/ValueMapTest.cpp @@ -22,15 +22,15 @@ namespace { 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()))), - AddV(BinaryOperator::CreateAdd(ConstantV, ConstantV)) { - } + ValueMapTest() + : 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 diff --git a/unittests/IR/ValueTest.cpp b/unittests/IR/ValueTest.cpp index 9cf1306dae6..607b7a1bd2c 100644 --- a/unittests/IR/ValueTest.cpp +++ b/unittests/IR/ValueTest.cpp @@ -45,7 +45,7 @@ TEST(ValueTest, UsedInBasicBlock) { } 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); @@ -92,7 +92,7 @@ TEST(GlobalTest, CreateAddressSpace) { #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 = diff --git a/unittests/IR/VerifierTest.cpp b/unittests/IR/VerifierTest.cpp index 1acedf38fc8..8b951739e47 100644 --- a/unittests/IR/VerifierTest.cpp +++ b/unittests/IR/VerifierTest.cpp @@ -23,7 +23,7 @@ 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)); @@ -46,7 +46,7 @@ TEST(VerifierTest, Branch_i1) { } 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)); @@ -62,7 +62,7 @@ TEST(VerifierTest, InvalidRetAttribute) { } TEST(VerifierTest, CrossModuleRef) { - LLVMContext &C = getGlobalContext(); + LLVMContext C; Module M1("M1", C); Module M2("M2", C); Module M3("M3", C); @@ -121,7 +121,7 @@ TEST(VerifierTest, CrossModuleRef) { } TEST(VerifierTest, CrossModuleMetadataRef) { - LLVMContext &C = getGlobalContext(); + LLVMContext C; Module M1("M1", C); Module M2("M2", C); GlobalVariable *newGV = diff --git a/unittests/IR/WaymarkTest.cpp b/unittests/IR/WaymarkTest.cpp index a8924efed3f..4d2671c06c1 100644 --- a/unittests/IR/WaymarkTest.cpp +++ b/unittests/IR/WaymarkTest.cpp @@ -19,16 +19,14 @@ 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)); diff --git a/unittests/ProfileData/InstrProfTest.cpp b/unittests/ProfileData/InstrProfTest.cpp index 24e2a4ecc3a..a80be3d444a 100644 --- a/unittests/ProfileData/InstrProfTest.cpp +++ b/unittests/ProfileData/InstrProfTest.cpp @@ -180,7 +180,8 @@ TEST_F(InstrProfTest, get_profile_summary) { 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); @@ -190,7 +191,7 @@ TEST_F(InstrProfTest, get_profile_summary) { 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); diff --git a/unittests/ProfileData/SampleProfTest.cpp b/unittests/ProfileData/SampleProfTest.cpp index 12533fa6656..24ffee72d3c 100644 --- a/unittests/ProfileData/SampleProfTest.cpp +++ b/unittests/ProfileData/SampleProfTest.cpp @@ -29,6 +29,7 @@ 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; @@ -43,7 +44,7 @@ struct SampleProfTest : ::testing::Test { } 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()); } @@ -127,7 +128,7 @@ struct SampleProfTest : ::testing::Test { 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); @@ -137,7 +138,7 @@ struct SampleProfTest : ::testing::Test { 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); diff --git a/unittests/Transforms/Utils/IntegerDivision.cpp b/unittests/Transforms/Utils/IntegerDivision.cpp index 4cda2b4e589..b6b1b1665ab 100644 --- a/unittests/Transforms/Utils/IntegerDivision.cpp +++ b/unittests/Transforms/Utils/IntegerDivision.cpp @@ -21,7 +21,7 @@ namespace { TEST(IntegerDivision, SDiv) { - LLVMContext &C(getGlobalContext()); + LLVMContext C; Module M("test division", C); IRBuilder<> Builder(C); @@ -51,7 +51,7 @@ TEST(IntegerDivision, SDiv) { } TEST(IntegerDivision, UDiv) { - LLVMContext &C(getGlobalContext()); + LLVMContext C; Module M("test division", C); IRBuilder<> Builder(C); @@ -81,7 +81,7 @@ TEST(IntegerDivision, UDiv) { } TEST(IntegerDivision, SRem) { - LLVMContext &C(getGlobalContext()); + LLVMContext C; Module M("test remainder", C); IRBuilder<> Builder(C); @@ -111,7 +111,7 @@ TEST(IntegerDivision, SRem) { } TEST(IntegerDivision, URem) { - LLVMContext &C(getGlobalContext()); + LLVMContext C; Module M("test remainder", C); IRBuilder<> Builder(C); @@ -142,7 +142,7 @@ TEST(IntegerDivision, URem) { TEST(IntegerDivision, SDiv64) { - LLVMContext &C(getGlobalContext()); + LLVMContext C; Module M("test division", C); IRBuilder<> Builder(C); @@ -172,7 +172,7 @@ TEST(IntegerDivision, SDiv64) { } TEST(IntegerDivision, UDiv64) { - LLVMContext &C(getGlobalContext()); + LLVMContext C; Module M("test division", C); IRBuilder<> Builder(C); @@ -202,7 +202,7 @@ TEST(IntegerDivision, UDiv64) { } TEST(IntegerDivision, SRem64) { - LLVMContext &C(getGlobalContext()); + LLVMContext C; Module M("test remainder", C); IRBuilder<> Builder(C); @@ -232,7 +232,7 @@ TEST(IntegerDivision, SRem64) { } TEST(IntegerDivision, URem64) { - LLVMContext &C(getGlobalContext()); + LLVMContext C; Module M("test remainder", C); IRBuilder<> Builder(C); diff --git a/unittests/Transforms/Utils/Local.cpp b/unittests/Transforms/Utils/Local.cpp index 2ff56047555..5164bdbb2a4 100644 --- a/unittests/Transforms/Utils/Local.cpp +++ b/unittests/Transforms/Utils/Local.cpp @@ -17,7 +17,7 @@ using namespace llvm; TEST(Local, RecursivelyDeleteDeadPHINodes) { - LLVMContext &C(getGlobalContext()); + LLVMContext C; IRBuilder<> builder(C); @@ -60,7 +60,7 @@ TEST(Local, RecursivelyDeleteDeadPHINodes) { } TEST(Local, RemoveDuplicatePHINodes) { - LLVMContext &C(getGlobalContext()); + LLVMContext C; IRBuilder<> B(C); std::unique_ptr<Function> F( diff --git a/unittests/Transforms/Utils/MemorySSA.cpp b/unittests/Transforms/Utils/MemorySSA.cpp index 48bbe476a30..ceee21a70cf 100644 --- a/unittests/Transforms/Utils/MemorySSA.cpp +++ b/unittests/Transforms/Utils/MemorySSA.cpp @@ -20,7 +20,7 @@ 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"); |