diff --git a/clang/unittests/CodeGen/BufferSourceTest.cpp b/clang/unittests/CodeGen/BufferSourceTest.cpp
--- a/clang/unittests/CodeGen/BufferSourceTest.cpp
+++ b/clang/unittests/CodeGen/BufferSourceTest.cpp
@@ -6,7 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "clang/AST/ASTConsumer.h"
+#include "TestCompiler.h"
+
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/Basic/TargetInfo.h"
@@ -26,10 +27,11 @@
 
 namespace {
 
-// 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[] =
+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:                        "
@@ -37,43 +39,13 @@
     "};                             "
     "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
diff --git a/clang/unittests/CodeGen/CodeGenExternalTest.cpp b/clang/unittests/CodeGen/CodeGenExternalTest.cpp
--- a/clang/unittests/CodeGen/CodeGenExternalTest.cpp
+++ b/clang/unittests/CodeGen/CodeGenExternalTest.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "TestCompiler.h"
+
 #include "clang/AST/ASTConsumer.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/GlobalDecl.h"
@@ -50,11 +52,11 @@
 // 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)
   {
   }
 
@@ -257,45 +259,17 @@
 }
 
 TEST(CodeGenExternalTest, CodeGenExternalTest) {
-    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>(
-          new MyASTConsumer(std::unique_ptr<CodeGenerator>(
-             CreateLLVMCodeGen(compiler.getDiagnostics(),
-                               "MemoryTypesTest",
-                               compiler.getHeaderSearchOpts(),
-                               compiler.getPreprocessorOpts(),
-                               compiler.getCodeGenOpts(),
-                               Context)))));
-
-    compiler.createSema(clang::TU_Prefix, nullptr);
+  clang::LangOptions LO;
+  LO.CPlusPlus = 1;
+  LO.CPlusPlus11 = 1;
+  TestCompiler Compiler(LO);
+  auto CustomASTConsumer = std::make_unique<MyASTConsumer>(Compiler.CG);
 
-    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);
+  ASSERT_TRUE(test_codegen_fns_ran);
 }
 
 } // end anonymous namespace
diff --git a/clang/unittests/CodeGen/IncrementalProcessingTest.cpp b/clang/unittests/CodeGen/IncrementalProcessingTest.cpp
--- a/clang/unittests/CodeGen/IncrementalProcessingTest.cpp
+++ b/clang/unittests/CodeGen/IncrementalProcessingTest.cpp
@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "TestCompiler.h"
+
 #include "clang/AST/ASTConsumer.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/RecursiveASTVisitor.h"
@@ -108,52 +110,30 @@
 }
 
 TEST(IncrementalProcessing, 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.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();
+    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);
+
+    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:
diff --git a/clang/unittests/CodeGen/TBAAMetadataTest.cpp b/clang/unittests/CodeGen/TBAAMetadataTest.cpp
--- a/clang/unittests/CodeGen/TBAAMetadataTest.cpp
+++ b/clang/unittests/CodeGen/TBAAMetadataTest.cpp
@@ -7,18 +7,12 @@
 //===----------------------------------------------------------------------===//
 
 #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>
@@ -27,82 +21,17 @@
 
 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(
@@ -132,8 +61,8 @@
     }
   )**";
 
-  TestCompiler Compiler;
-  Compiler.compiler.getLangOpts().C11 = 1;
+  clang::LangOptions LO;
+  TBAATestCompiler Compiler(LO, TBAATestCompiler::getCommonCodeGenOpts());
   Compiler.init(TestProgram);
   const BasicBlock *BB = Compiler.compile();
 
@@ -228,8 +157,9 @@
     }
   )**";
 
-  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();
 
@@ -349,8 +279,9 @@
     }
   )**";
 
-  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();
 
@@ -441,8 +372,9 @@
     }
   )**";
 
-  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();
 
@@ -534,8 +466,9 @@
     }
   )**";
 
-  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();
 
@@ -635,9 +568,10 @@
     }
   )**";
 
-  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();
 
@@ -757,9 +691,10 @@
     }
   )**";
 
-  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();
 
@@ -857,9 +792,10 @@
     }
   )**";
 
-  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();
 
@@ -938,9 +874,10 @@
     }
   )**";
 
-  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();
 
@@ -1016,9 +953,10 @@
     }
   )**";
 
-  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();
 
@@ -1094,9 +1032,10 @@
     }
   )**";
 
-  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();
 
@@ -1170,9 +1109,10 @@
     }
   )**";
 
-  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();
 
@@ -1255,9 +1195,10 @@
     }
   )**";
 
-  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();