Move the test compiler setup in a common place. NFCI

[v.g.vassilev]

Summary

This patch reduces the copy paste in the unittest/CodeGen folder by moving the common compiler setup phase in a header file.

[v.g.vassilev]

Add forgotten file.

[vitalybuka]

Reverted because of memory leaks: http://lab.llvm.org:8011/#/builders/5/builds/1262

clang/unittests/CodeGen/BufferSourceTest.cpp

 //===- unittests/CodeGen/BufferSourceTest.cpp - MemoryBuffer source tests -===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#include "clang/AST/ASTConsumer.h"
+#include "TestCompiler.h"
+
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/CodeGen/ModuleBuilder.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Parse/ParseAST.h"
 #include "clang/Sema/Sema.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 using namespace clang;
 
 namespace {
 
+TEST(BufferSourceTest, EmitCXXGlobalInitFunc) {
   // Emitting constructors for global objects involves looking
   // at the source file name. This makes sure that we don't crash
   // if the source file is a memory buffer.
   const char TestProgram[] =
     "class EmitCXXGlobalInitFunc    "
     "{                              "
     "public:                        "
     "   EmitCXXGlobalInitFunc() {}  "
     "};                             "
     "EmitCXXGlobalInitFunc test;    ";
 
-TEST(BufferSourceTest, EmitCXXGlobalInitFunc) {
-    LLVMContext Context;
-    CompilerInstance compiler;
-
-    compiler.createDiagnostics();
-    compiler.getLangOpts().CPlusPlus = 1;
-    compiler.getLangOpts().CPlusPlus11 = 1;
-
-    compiler.getTargetOpts().Triple = llvm::Triple::normalize(
-        llvm::sys::getProcessTriple());
-    compiler.setTarget(clang::TargetInfo::CreateTargetInfo(
-      compiler.getDiagnostics(),
-      std::make_shared<clang::TargetOptions>(
-        compiler.getTargetOpts())));
-
-    compiler.createFileManager();
-    compiler.createSourceManager(compiler.getFileManager());
-    compiler.createPreprocessor(clang::TU_Prefix);
-
-    compiler.createASTContext();
-
-    compiler.setASTConsumer(std::unique_ptr<ASTConsumer>(
-        CreateLLVMCodeGen(
-            compiler.getDiagnostics(),
-            "EmitCXXGlobalInitFuncTest",
-            compiler.getHeaderSearchOpts(),
-            compiler.getPreprocessorOpts(),
-            compiler.getCodeGenOpts(),
-            Context)));
-
-    compiler.createSema(clang::TU_Prefix, nullptr);
-
-    clang::SourceManager &sm = compiler.getSourceManager();
-    sm.setMainFileID(sm.createFileID(
-        llvm::MemoryBuffer::getMemBuffer(TestProgram), clang::SrcMgr::C_User));
+  clang::LangOptions LO;
+  LO.CPlusPlus = 1;
+  LO.CPlusPlus11 = 1;
+  TestCompiler Compiler(LO);
+  Compiler.init(TestProgram);
 
-    clang::ParseAST(compiler.getSema(), false, false);
+  clang::ParseAST(Compiler.compiler.getSema(), false, false);
 }
 
 } // end anonymous namespace

clang/unittests/CodeGen/CodeGenExternalTest.cpp

 //===- unittests/CodeGen/CodeGenExternalTest.cpp - test external CodeGen -===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "TestCompiler.h"
+
 #include "clang/AST/ASTConsumer.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/GlobalDecl.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/CodeGen/CodeGenABITypes.h"
 #include "clang/CodeGen/ModuleBuilder.h"
 #include "clang/Frontend/CompilerInstance.h"

 
 // This forwards the calls to the Clang CodeGenerator
 // so that we can test CodeGen functions while it is open.
 // It accumulates toplevel decls in HandleTopLevelDecl and
 // calls test_codegen_fns() in HandleTranslationUnit
 // before forwarding that function to the CodeGenerator.
 
 struct MyASTConsumer : public ASTConsumer {
-  std::unique_ptr<CodeGenerator> Builder;
+  CodeGenerator* Builder;
   std::vector<Decl*> toplevel_decls;
 
-  MyASTConsumer(std::unique_ptr<CodeGenerator> Builder_in)
-    : ASTConsumer(), Builder(std::move(Builder_in))
+  MyASTConsumer(CodeGenerator* Builder_in)
+    : ASTConsumer(), Builder(Builder_in)
   {
   }
 
   ~MyASTConsumer() { }
 
   void Initialize(ASTContext &Context) override;
   void HandleCXXStaticMemberVarInstantiation(VarDecl *VD) override;
   bool HandleTopLevelDecl(DeclGroupRef D) override;
static void test_codegen_fns(MyASTConsumer *my) {
 
   ASSERT_TRUE(mytest_fn_ok);
   ASSERT_TRUE(mytest_struct_ok);
 
   test_codegen_fns_ran = true;
 }
 
 TEST(CodeGenExternalTest, CodeGenExternalTest) {
-    LLVMContext Context;
-    CompilerInstance compiler;
+  clang::LangOptions LO;
+  LO.CPlusPlus = 1;
+  LO.CPlusPlus11 = 1;
+  TestCompiler Compiler(LO);
+  auto CustomASTConsumer = std::make_unique<MyASTConsumer>(Compiler.CG);
 
-    compiler.createDiagnostics();
-    compiler.getLangOpts().CPlusPlus = 1;
-    compiler.getLangOpts().CPlusPlus11 = 1;
-
-    compiler.getTargetOpts().Triple = llvm::Triple::normalize(
-        llvm::sys::getProcessTriple());
-    compiler.setTarget(clang::TargetInfo::CreateTargetInfo(
-      compiler.getDiagnostics(),
-      std::make_shared<clang::TargetOptions>(
-        compiler.getTargetOpts())));
-
-    compiler.createFileManager();
-    compiler.createSourceManager(compiler.getFileManager());
-    compiler.createPreprocessor(clang::TU_Prefix);
-
-    compiler.createASTContext();
-
-
-    compiler.setASTConsumer(std::unique_ptr<ASTConsumer>(
-          new MyASTConsumer(std::unique_ptr<CodeGenerator>(
-             CreateLLVMCodeGen(compiler.getDiagnostics(),
-                               "MemoryTypesTest",
-                               compiler.getHeaderSearchOpts(),
-                               compiler.getPreprocessorOpts(),
-                               compiler.getCodeGenOpts(),
-                               Context)))));
-
-    compiler.createSema(clang::TU_Prefix, nullptr);
-
-    clang::SourceManager &sm = compiler.getSourceManager();
-    sm.setMainFileID(sm.createFileID(
-        llvm::MemoryBuffer::getMemBuffer(TestProgram), clang::SrcMgr::C_User));
+  Compiler.init(TestProgram, std::move(CustomASTConsumer));
 
-    clang::ParseAST(compiler.getSema(), false, false);
+  clang::ParseAST(Compiler.compiler.getSema(), false, false);
 
-    ASSERT_TRUE(test_codegen_fns_ran);
 }
 
 } // end anonymous namespace

clang/unittests/CodeGen/IncrementalProcessingTest.cpp

 //=== unittests/CodeGen/IncrementalProcessingTest.cpp - IncrementalCodeGen ===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "TestCompiler.h"
+
 #include "clang/AST/ASTConsumer.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/CodeGen/ModuleBuilder.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Parse/Parser.h"
const Function* getGlobalInit(llvm::Module& M) {
   for (const auto& Func: M)
     if (Func.hasName() && Func.getName().startswith("_GLOBAL__sub_I_"))
       return &Func;
 
   return nullptr;
 }
 
 TEST(IncrementalProcessing, EmitCXXGlobalInitFunc) {
-    LLVMContext Context;
-    CompilerInstance compiler;
+    clang::LangOptions LO;
+    LO.CPlusPlus = 1;
+    LO.CPlusPlus11 = 1;
+    TestCompiler Compiler(LO);
+    clang::CompilerInstance &CI = Compiler.compiler;
+    CI.getPreprocessor().enableIncrementalProcessing();
+    CI.setASTConsumer(std::unique_ptr<ASTConsumer>(Compiler.CG));
+    CI.createSema(clang::TU_Prefix, nullptr);
 
-    compiler.createDiagnostics();
-    compiler.getLangOpts().CPlusPlus = 1;
-    compiler.getLangOpts().CPlusPlus11 = 1;
-
-    compiler.getTargetOpts().Triple = llvm::Triple::normalize(
-        llvm::sys::getProcessTriple());
-    compiler.setTarget(clang::TargetInfo::CreateTargetInfo(
-      compiler.getDiagnostics(),
-      std::make_shared<clang::TargetOptions>(
-        compiler.getTargetOpts())));
-
-    compiler.createFileManager();
-    compiler.createSourceManager(compiler.getFileManager());
-    compiler.createPreprocessor(clang::TU_Prefix);
-    compiler.getPreprocessor().enableIncrementalProcessing();
-
-    compiler.createASTContext();
-
-    CodeGenerator* CG =
-        CreateLLVMCodeGen(
-            compiler.getDiagnostics(),
-            "main-module",
-            compiler.getHeaderSearchOpts(),
-            compiler.getPreprocessorOpts(),
-            compiler.getCodeGenOpts(),
-            Context);
-    compiler.setASTConsumer(std::unique_ptr<ASTConsumer>(CG));
-    compiler.createSema(clang::TU_Prefix, nullptr);
-    Sema& S = compiler.getSema();
+    Sema& S = CI.getSema();
 
     std::unique_ptr<Parser> ParseOP(new Parser(S.getPreprocessor(), S,
                                                /*SkipFunctionBodies*/ false));
     Parser &P = *ParseOP.get();
 
     std::array<std::unique_ptr<llvm::Module>, 3> M;
-    M[0] = IncrementalParseAST(compiler, P, *CG, nullptr);
+    M[0] = IncrementalParseAST(CI, P, *Compiler.CG, nullptr);
     ASSERT_TRUE(M[0]);
 
-    M[1] = IncrementalParseAST(compiler, P, *CG, TestProgram1);
+    M[1] = IncrementalParseAST(CI, P, *Compiler.CG, TestProgram1);
     ASSERT_TRUE(M[1]);
     ASSERT_TRUE(M[1]->getFunction("funcForProg1"));
 
-    M[2] = IncrementalParseAST(compiler, P, *CG, TestProgram2);
+    M[2] = IncrementalParseAST(CI, P, *Compiler.CG, TestProgram2);
     ASSERT_TRUE(M[2]);
     ASSERT_TRUE(M[2]->getFunction("funcForProg2"));
     // First code should not end up in second module:
     ASSERT_FALSE(M[2]->getFunction("funcForProg1"));
 
     // Make sure global inits exist and are unique:
     const Function* GlobalInit1 = getGlobalInit(*M[1]);
     ASSERT_TRUE(GlobalInit1);

clang/unittests/CodeGen/TBAAMetadataTest.cpp

 //=== unittests/CodeGen/TBAAMetadataTest.cpp - Checks metadata generation -===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "IRMatchers.h"
+#include "TestCompiler.h"
 #include "clang/AST/ASTConsumer.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/TargetInfo.h"
-#include "clang/CodeGen/ModuleBuilder.h"
-#include "clang/Frontend/CompilerInstance.h"
-#include "clang/Parse/ParseAST.h"
-#include "llvm/ADT/Triple.h"
 #include "llvm/IR/Constants.h"
-#include "llvm/IR/LLVMContext.h"
-#include "llvm/IR/Module.h"
-#include "llvm/Support/Host.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "gtest/gtest.h"
 #include <memory>
 
 using namespace llvm;
 
 namespace {
 
-struct TestCompiler {
-  LLVMContext Context;
-  clang::CompilerInstance compiler;
-  clang::CodeGenerator *CG = nullptr;
-  llvm::Module *M = nullptr;
-  unsigned PtrSize = 0;
-
-  void init(const char *TestProgram) {
-    compiler.createDiagnostics();
-    compiler.getCodeGenOpts().StructPathTBAA = 1;
-    compiler.getCodeGenOpts().OptimizationLevel = 1;
-
-    std::string TrStr = llvm::Triple::normalize(llvm::sys::getProcessTriple());
-    llvm::Triple Tr(TrStr);
-    Tr.setOS(Triple::Linux);
-    Tr.setVendor(Triple::VendorType::UnknownVendor);
-    Tr.setEnvironment(Triple::EnvironmentType::UnknownEnvironment);
-    compiler.getTargetOpts().Triple = Tr.getTriple();
-    compiler.setTarget(clang::TargetInfo::CreateTargetInfo(
-        compiler.getDiagnostics(),
-        std::make_shared<clang::TargetOptions>(compiler.getTargetOpts())));
-
-    const clang::TargetInfo &TInfo = compiler.getTarget();
-    PtrSize = TInfo.getPointerWidth(0) / 8;
-
-    compiler.createFileManager();
-    compiler.createSourceManager(compiler.getFileManager());
-    compiler.createPreprocessor(clang::TU_Prefix);
-
-    compiler.createASTContext();
-
-    CG = CreateLLVMCodeGen(
-        compiler.getDiagnostics(),
-        "main-module",
-        compiler.getHeaderSearchOpts(),
-        compiler.getPreprocessorOpts(),
-        compiler.getCodeGenOpts(),
-        Context);
-    compiler.setASTConsumer(std::unique_ptr<clang::ASTConsumer>(CG));
-
-    compiler.createSema(clang::TU_Prefix, nullptr);
-
-    clang::SourceManager &sm = compiler.getSourceManager();
-    sm.setMainFileID(sm.createFileID(
-        llvm::MemoryBuffer::getMemBuffer(TestProgram), clang::SrcMgr::C_User));
-  }
-
-  const BasicBlock *compile() {
-    clang::ParseAST(compiler.getSema(), false, false);
-    M = CG->GetModule();
-
-    // Do not expect more than one function definition.
-    auto FuncPtr = M->begin();
-    for (; FuncPtr != M->end(); ++FuncPtr)
-      if (!FuncPtr->isDeclaration())
-        break;
-    assert(FuncPtr != M->end());
-    const llvm::Function &Func = *FuncPtr;
-    ++FuncPtr;
-    for (; FuncPtr != M->end(); ++FuncPtr)
-      if (!FuncPtr->isDeclaration())
-        break;
-    assert(FuncPtr == M->end());
-
-    // The function must consist of single basic block.
-    auto BBPtr = Func.begin();
-    assert(Func.begin() != Func.end());
-    const BasicBlock &BB = *BBPtr;
-    ++BBPtr;
-    assert(BBPtr == Func.end());
-
-    return &BB;
+struct TBAATestCompiler : public TestCompiler {
+  TBAATestCompiler(clang::LangOptions LO, clang::CodeGenOptions CGO)
+    : TestCompiler(LO, CGO) {}
+  static clang::CodeGenOptions getCommonCodeGenOpts() {
+    clang::CodeGenOptions CGOpts;
+    CGOpts.StructPathTBAA = 1;
+    CGOpts.OptimizationLevel = 1;
+    return CGOpts;
   }
 };
 
-
 auto OmnipotentCharC = MMTuple(
   MMString("omnipotent char"),
   MMTuple(
     MMString("Simple C/C++ TBAA")),
   MConstInt(0, 64)
 );
 
 
void func(char *CP, short *SP, int *IP, long long *LP, void **VPP,
       *SP = 11;
       *IP = 601;
       *LP = 604;
       *VPP = CP;
       *IPP = IP;
     }
   )**";
 
-  TestCompiler Compiler;
-  Compiler.compiler.getLangOpts().C11 = 1;
+  clang::LangOptions LO;
+  TBAATestCompiler Compiler(LO, TBAATestCompiler::getCommonCodeGenOpts());
   Compiler.init(TestProgram);
   const BasicBlock *BB = Compiler.compile();
 
   const Instruction *I = match(BB,
       MInstruction(Instruction::Store,
         MConstInt(4, 8),
         MMTuple(
           OmnipotentCharC,
void func(struct ABC *A) {
       A->f16 = 11;
       A->f64 = 601;
       A->f16_2 = 22;
       A->f32_2 = 77;
       A->f64_2 = 604;
     }
   )**";
 
-  TestCompiler Compiler;
-  Compiler.compiler.getLangOpts().C11 = 1;
+  clang::LangOptions LO;
+  LO.C11 = 1;
+  TBAATestCompiler Compiler(LO, TBAATestCompiler::getCommonCodeGenOpts());
   Compiler.init(TestProgram);
   const BasicBlock *BB = Compiler.compile();
 
   auto StructABC = MMTuple(
     MMString("ABC"),
     MMTuple(
       MMString("short"),
       OmnipotentCharC,
const char TestProgram[] = R"**(
     void func(ABC *A, CDE *B) {
       A->f32 = 4;
       A->f16 = 11;
       B->value_f32 = 44;
       B->value_f16 = 111;
     }
   )**";
 
-  TestCompiler Compiler;
-  Compiler.compiler.getLangOpts().C11 = 1;
+  clang::LangOptions LO;
+  LO.C11 = 1;
+  TBAATestCompiler Compiler(LO, TBAATestCompiler::getCommonCodeGenOpts());
   Compiler.init(TestProgram);
   const BasicBlock *BB = Compiler.compile();
 
   auto NamelessStruct = MMTuple(
     MMString(""),
     MMTuple(
       MMString("short"),
       OmnipotentCharC,
const char TestProgram[] = R"**(
     void func(ABC *A, CDE *B) {
       A->f32 = 4;
       A->f16 = 11;
       B->f32 = 44;
       B->f16 = 111;
     }
   )**";
 
-  TestCompiler Compiler;
-  Compiler.compiler.getLangOpts().C11 = 1;
+  clang::LangOptions LO;
+  LO.C11 = 1;
+  TBAATestCompiler Compiler(LO, TBAATestCompiler::getCommonCodeGenOpts());
   Compiler.init(TestProgram);
   const BasicBlock *BB = Compiler.compile();
 
   auto NamelessStruct = MMTuple(
     MMString(""),
     MMTuple(
       MMString("short"),
       OmnipotentCharC,
const char TestProgram[] = R"**(
     void func(ABC *A, CDE *B) {
       A->f32 = 4;
       A->f16 = 11;
       B->f32 = 44;
       B->f16 = 111;
     }
   )**";
 
-  TestCompiler Compiler;
-  Compiler.compiler.getLangOpts().C11 = 1;
+  clang::LangOptions LO;
+  LO.C11 = 1;
+  TBAATestCompiler Compiler(LO, TBAATestCompiler::getCommonCodeGenOpts());
   Compiler.init(TestProgram);
   const BasicBlock *BB = Compiler.compile();
 
   auto NamelessStruct1 = MMTuple(
     MMString(""),
     MMTuple(
       MMString("short"),
       OmnipotentCharC,
void func(struct ABC *A) {
       A->f16 = 11;
       A->f64 = 601;
       A->f16_2 = 22;
       A->f32_2 = 77;
       A->f64_2 = 604;
     }
   )**";
 
-  TestCompiler Compiler;
-  Compiler.compiler.getLangOpts().CPlusPlus = 1;
-  Compiler.compiler.getLangOpts().CPlusPlus11 = 1;
+  clang::LangOptions LO;
+  LO.CPlusPlus = 1;
+  LO.CPlusPlus11 = 1;
+  TBAATestCompiler Compiler(LO, TBAATestCompiler::getCommonCodeGenOpts());
   Compiler.init(TestProgram);
   const BasicBlock *BB = Compiler.compile();
 
   auto StructABC = MMTuple(
     MMString("_ZTS3ABC"),
     MMTuple(
       MMString("short"),
       OmnipotentCharCXX,
const char TestProgram[] = R"**(
     void func(ABC *A, CDE *B) {
       A->f32 = 4;
       A->f16 = 11;
       B->value_f32 = 44;
       B->value_f16 = 111;
     }
   )**";
 
-  TestCompiler Compiler;
-  Compiler.compiler.getLangOpts().CPlusPlus = 1;
-  Compiler.compiler.getLangOpts().CPlusPlus11 = 1;
+  clang::LangOptions LO;
+  LO.CPlusPlus = 1;
+  LO.CPlusPlus11 = 1;
+  TBAATestCompiler Compiler(LO, TBAATestCompiler::getCommonCodeGenOpts());
   Compiler.init(TestProgram);
   const BasicBlock *BB = Compiler.compile();
 
   auto StructABC = MMTuple(
     MMString("_ZTS3ABC"),
     MMTuple(
       MMString("short"),
       OmnipotentCharCXX,
const char TestProgram[] = R"**(
 
     void func(Outer *S) {
       S->f16 = 14;
       S->b1.f32 = 35;
       S->b2.f32 = 77;
     }
   )**";
 
-  TestCompiler Compiler;
-  Compiler.compiler.getLangOpts().CPlusPlus = 1;
-  Compiler.compiler.getLangOpts().CPlusPlus11 = 1;
+  clang::LangOptions LO;
+  LO.CPlusPlus = 1;
+  LO.CPlusPlus11 = 1;
+  TBAATestCompiler Compiler(LO, TBAATestCompiler::getCommonCodeGenOpts());
   Compiler.init(TestProgram);
   const BasicBlock *BB = Compiler.compile();
 
   auto StructInner = MMTuple(
     MMString("_ZTS5Inner"),
     MMTuple(
       MMString("int"),
       OmnipotentCharCXX,
const char TestProgram[] = R"**(
 
     void func(Outer *S) {
       S->f16 = 14;
       S->b1[0].f32 = 35;
       S->b1[1].f32 = 77;
     }
   )**";
 
-  TestCompiler Compiler;
-  Compiler.compiler.getLangOpts().CPlusPlus = 1;
-  Compiler.compiler.getLangOpts().CPlusPlus11 = 1;
+  clang::LangOptions LO;
+  LO.CPlusPlus = 1;
+  LO.CPlusPlus11 = 1;
+  TBAATestCompiler Compiler(LO, TBAATestCompiler::getCommonCodeGenOpts());
   Compiler.init(TestProgram);
   const BasicBlock *BB = Compiler.compile();
 
   auto StructInner = MMTuple(
     MMString("_ZTS5Inner"),
     MMTuple(
       MMString("int"),
       OmnipotentCharCXX,
const char TestProgram[] = R"**(
 
     void func(Base *B, Derived *D) {
       B->f32 = 14;
       D->f16 = 35;
       D->f32 = 77;
     }
   )**";
 
-  TestCompiler Compiler;
-  Compiler.compiler.getLangOpts().CPlusPlus = 1;
-  Compiler.compiler.getLangOpts().CPlusPlus11 = 1;
+  clang::LangOptions LO;
+  LO.CPlusPlus = 1;
+  LO.CPlusPlus11 = 1;
+  TBAATestCompiler Compiler(LO, TBAATestCompiler::getCommonCodeGenOpts());
   Compiler.init(TestProgram);
   const BasicBlock *BB = Compiler.compile();
 
   auto ClassBase = MMTuple(
     MMString("_ZTS4Base"),
     MMTuple(
       MMString("int"),
       OmnipotentCharCXX,
const char TestProgram[] = R"**(
 
     void func(Base *B, Derived *D) {
       B->f32 = 14;
       D->f16 = 35;
       D->f32 = 77;
     }
   )**";
 
-  TestCompiler Compiler;
-  Compiler.compiler.getLangOpts().CPlusPlus = 1;
-  Compiler.compiler.getLangOpts().CPlusPlus11 = 1;
+  clang::LangOptions LO;
+  LO.CPlusPlus = 1;
+  LO.CPlusPlus11 = 1;
+  TBAATestCompiler Compiler(LO, TBAATestCompiler::getCommonCodeGenOpts());
   Compiler.init(TestProgram);
   const BasicBlock *BB = Compiler.compile();
 
   auto ClassBase = MMTuple(
     MMString("_ZTS4Base"),
     MMTuple(
       MMString("int"),
       OmnipotentCharCXX,
const char TestProgram[] = R"**(
 
     void func(Base *B, Derived *D) {
       B->f32 = 14;
       D->f16 = 35;
       D->f32 = 77;
     }
   )**";
 
-  TestCompiler Compiler;
-  Compiler.compiler.getLangOpts().CPlusPlus = 1;
-  Compiler.compiler.getLangOpts().CPlusPlus11 = 1;
+  clang::LangOptions LO;
+  LO.CPlusPlus = 1;
+  LO.CPlusPlus11 = 1;
+  TBAATestCompiler Compiler(LO, TBAATestCompiler::getCommonCodeGenOpts());
   Compiler.init(TestProgram);
   const BasicBlock *BB = Compiler.compile();
 
   auto ClassBase = MMTuple(
     MMString("_ZTS4Base"),
     MMTuple(
       MMString("int"),
       OmnipotentCharCXX,
const char TestProgram[] = R"**(
     };
 
     void func(ABC<double, int> *p) {
       p->f1 = 12.1;
       p->f2 = 44;
     }
   )**";
 
-  TestCompiler Compiler;
-  Compiler.compiler.getLangOpts().CPlusPlus = 1;
-  Compiler.compiler.getLangOpts().CPlusPlus11 = 1;
+  clang::LangOptions LO;
+  LO.CPlusPlus = 1;
+  LO.CPlusPlus11 = 1;
+  TBAATestCompiler Compiler(LO, TBAATestCompiler::getCommonCodeGenOpts());
   Compiler.init(TestProgram);
   const BasicBlock *BB = Compiler.compile();
 
   auto SpecABC = MMTuple(
     MMString("_ZTS3ABCIdiE"),
     MMTuple(
       MMString("double"),
       OmnipotentCharCXX,