Replace OwningPtr<T> with std::unique_ptr<T>.

This compiles with no changes to clang/lld/lldb with MSVC and includes
overloads to various functions which are used by those projects and llvm
which have OwningPtr's as parameters. This should allow out of tree
projects some time to move. There are also no changes to libs/Target,
which should help out of tree targets have time to move, if necessary.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@203083 91177308-0d34-0410-b5e6-96231b3b80d8

29 files changed, 140 insertions, 149 deletions

diff --git a/unittests/Analysis/CFGTest.cpp b/unittests/Analysis/CFGTest.cpp
index bc029e3786..8d8c560d9e 100644
--- a/unittests/Analysis/CFGTest.cpp
+++ b/unittests/Analysis/CFGTest.cpp
@@ -8,7 +8,6 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Analysis/CFG.h"
-#include "llvm/ADT/OwningPtr.h"
 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/AsmParser/Parser.h"
 #include "llvm/IR/Dominators.h"
@@ -116,7 +115,7 @@ protected:
     PM.run(*M);
   }
 
-  OwningPtr<Module> M;
+  std::unique_ptr<Module> M;
   Instruction *A, *B;
 };
 
diff --git a/unittests/Bitcode/BitReaderTest.cpp b/unittests/Bitcode/BitReaderTest.cpp
index eca8845430..ba030230a2 100644
--- a/unittests/Bitcode/BitReaderTest.cpp
+++ b/unittests/Bitcode/BitReaderTest.cpp
@@ -45,7 +45,7 @@ static Module *makeLLVMModule() {
 }
 
 static void writeModuleToBuffer(SmallVectorImpl<char> &Buffer) {
-  OwningPtr<Module> Mod(makeLLVMModule());
+  std::unique_ptr<Module> Mod(makeLLVMModule());
   raw_svector_ostream OS(Buffer);
   WriteBitcodeToFile(Mod.get(), OS);
 }
@@ -56,7 +56,7 @@ TEST(BitReaderTest, MaterializeFunctionsForBlockAddr) { // PR11677
   MemoryBuffer *Buffer = MemoryBuffer::getMemBuffer(Mem.str(), "test", false);
   ErrorOr<Module *> ModuleOrErr =
       getLazyBitcodeModule(Buffer, getGlobalContext());
-  OwningPtr<Module> m(ModuleOrErr.get());
+  std::unique_ptr<Module> m(ModuleOrErr.get());
   PassManager passes;
   passes.add(createVerifierPass());
   passes.run(*m);
diff --git a/unittests/ExecutionEngine/ExecutionEngineTest.cpp b/unittests/ExecutionEngine/ExecutionEngineTest.cpp
index 3e304e7986..e6f07dce1e 100644
--- a/unittests/ExecutionEngine/ExecutionEngineTest.cpp
+++ b/unittests/ExecutionEngine/ExecutionEngineTest.cpp
@@ -8,7 +8,6 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ExecutionEngine/Interpreter.h"
-#include "llvm/ADT/OwningPtr.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/LLVMContext.h"
@@ -38,7 +37,7 @@ protected:
 
   Module *const M;
   std::string Error;
-  const OwningPtr<ExecutionEngine> Engine;
+  const std::unique_ptr<ExecutionEngine> Engine;
 };
 
 TEST_F(ExecutionEngineTest, ForwardGlobalMapping) {
diff --git a/unittests/ExecutionEngine/JIT/JITEventListenerTest.cpp b/unittests/ExecutionEngine/JIT/JITEventListenerTest.cpp
index 41b4f2f774..175b9fb107 100644
--- a/unittests/ExecutionEngine/JIT/JITEventListenerTest.cpp
+++ b/unittests/ExecutionEngine/JIT/JITEventListenerTest.cpp
@@ -8,7 +8,6 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ExecutionEngine/JITEventListener.h"
-#include "llvm/ADT/OwningPtr.h"
 #include "llvm/CodeGen/MachineCodeInfo.h"
 #include "llvm/ExecutionEngine/JIT.h"
 #include "llvm/IR/Instructions.h"
@@ -69,7 +68,7 @@ class JITEventListenerTest : public testing::Test {
   }
 
   Module *M;
-  const OwningPtr<ExecutionEngine> EE;
+  const std::unique_ptr<ExecutionEngine> EE;
 };
 
 // Tests on SystemZ disabled as we're running the old JIT
diff --git a/unittests/ExecutionEngine/JIT/JITEventListenerTestCommon.h b/unittests/ExecutionEngine/JIT/JITEventListenerTestCommon.h
index 7f6dad63e5..61220f545f 100644
--- a/unittests/ExecutionEngine/JIT/JITEventListenerTestCommon.h
+++ b/unittests/ExecutionEngine/JIT/JITEventListenerTestCommon.h
@@ -53,8 +53,8 @@ inline const char* getFilename() {
 template<typename WrapperT>
 class JITEventListenerTestBase : public testing::Test {
 protected:
-  llvm::OwningPtr<WrapperT> MockWrapper;
-  llvm::OwningPtr<llvm::JITEventListener> Listener;
+  std::unique_ptr<WrapperT> MockWrapper;
+  std::unique_ptr<llvm::JITEventListener> Listener;
 
 public:
   llvm::Module* M;
diff --git a/unittests/ExecutionEngine/JIT/JITMemoryManagerTest.cpp b/unittests/ExecutionEngine/JIT/JITMemoryManagerTest.cpp
index 731f7807f5..ab308844f2 100644
--- a/unittests/ExecutionEngine/JIT/JITMemoryManagerTest.cpp
+++ b/unittests/ExecutionEngine/JIT/JITMemoryManagerTest.cpp
@@ -9,7 +9,6 @@
 
 #include "llvm/ExecutionEngine/JITMemoryManager.h"
 #include "llvm/ADT/ArrayRef.h"
-#include "llvm/ADT/OwningPtr.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GlobalValue.h"
@@ -31,27 +30,27 @@ Function *makeFakeFunction() {
 // the code in the case that we don't have to allocate more memory to store the
 // function bodies.
 TEST(JITMemoryManagerTest, NoAllocations) {
-  OwningPtr<JITMemoryManager> MemMgr(
+  std::unique_ptr<JITMemoryManager> MemMgr(
       JITMemoryManager::CreateDefaultMemManager());
   uintptr_t size;
   std::string Error;
 
   // Allocate the functions.
-  OwningPtr<Function> F1(makeFakeFunction());
+  std::unique_ptr<Function> F1(makeFakeFunction());
   size = 1024;
   uint8_t *FunctionBody1 = MemMgr->startFunctionBody(F1.get(), size);
   memset(FunctionBody1, 0xFF, 1024);
   MemMgr->endFunctionBody(F1.get(), FunctionBody1, FunctionBody1 + 1024);
   EXPECT_TRUE(MemMgr->CheckInvariants(Error)) << Error;
 
-  OwningPtr<Function> F2(makeFakeFunction());
+  std::unique_ptr<Function> F2(makeFakeFunction());
   size = 1024;
   uint8_t *FunctionBody2 = MemMgr->startFunctionBody(F2.get(), size);
   memset(FunctionBody2, 0xFF, 1024);
   MemMgr->endFunctionBody(F2.get(), FunctionBody2, FunctionBody2 + 1024);
   EXPECT_TRUE(MemMgr->CheckInvariants(Error)) << Error;
 
-  OwningPtr<Function> F3(makeFakeFunction());
+  std::unique_ptr<Function> F3(makeFakeFunction());
   size = 1024;
   uint8_t *FunctionBody3 = MemMgr->startFunctionBody(F3.get(), size);
   memset(FunctionBody3, 0xFF, 1024);
@@ -70,7 +69,7 @@ TEST(JITMemoryManagerTest, NoAllocations) {
 // Make three large functions that take up most of the space in the slab.  Then
 // try allocating three smaller functions that don't require additional slabs.
 TEST(JITMemoryManagerTest, TestCodeAllocation) {
-  OwningPtr<JITMemoryManager> MemMgr(
+  std::unique_ptr<JITMemoryManager> MemMgr(
       JITMemoryManager::CreateDefaultMemManager());
   uintptr_t size;
   std::string Error;
@@ -81,7 +80,7 @@ TEST(JITMemoryManagerTest, TestCodeAllocation) {
                                  smallFuncSize * 2);
 
   // Allocate big functions
-  OwningPtr<Function> F1(makeFakeFunction());
+  std::unique_ptr<Function> F1(makeFakeFunction());
   size = bigFuncSize;
   uint8_t *FunctionBody1 = MemMgr->startFunctionBody(F1.get(), size);
   ASSERT_LE(bigFuncSize, size);
@@ -89,7 +88,7 @@ TEST(JITMemoryManagerTest, TestCodeAllocation) {
   MemMgr->endFunctionBody(F1.get(), FunctionBody1, FunctionBody1 + bigFuncSize);
   EXPECT_TRUE(MemMgr->CheckInvariants(Error)) << Error;
 
-  OwningPtr<Function> F2(makeFakeFunction());
+  std::unique_ptr<Function> F2(makeFakeFunction());
   size = bigFuncSize;
   uint8_t *FunctionBody2 = MemMgr->startFunctionBody(F2.get(), size);
   ASSERT_LE(bigFuncSize, size);
@@ -97,7 +96,7 @@ TEST(JITMemoryManagerTest, TestCodeAllocation) {
   MemMgr->endFunctionBody(F2.get(), FunctionBody2, FunctionBody2 + bigFuncSize);
   EXPECT_TRUE(MemMgr->CheckInvariants(Error)) << Error;
 
-  OwningPtr<Function> F3(makeFakeFunction());
+  std::unique_ptr<Function> F3(makeFakeFunction());
   size = bigFuncSize;
   uint8_t *FunctionBody3 = MemMgr->startFunctionBody(F3.get(), size);
   ASSERT_LE(bigFuncSize, size);
@@ -109,7 +108,7 @@ TEST(JITMemoryManagerTest, TestCodeAllocation) {
   EXPECT_EQ(3U, MemMgr->GetNumCodeSlabs());
 
   // Allocate small functions
-  OwningPtr<Function> F4(makeFakeFunction());
+  std::unique_ptr<Function> F4(makeFakeFunction());
   size = smallFuncSize;
   uint8_t *FunctionBody4 = MemMgr->startFunctionBody(F4.get(), size);
   ASSERT_LE(smallFuncSize, size);
@@ -118,7 +117,7 @@ TEST(JITMemoryManagerTest, TestCodeAllocation) {
                           FunctionBody4 + smallFuncSize);
   EXPECT_TRUE(MemMgr->CheckInvariants(Error)) << Error;
 
-  OwningPtr<Function> F5(makeFakeFunction());
+  std::unique_ptr<Function> F5(makeFakeFunction());
   size = smallFuncSize;
   uint8_t *FunctionBody5 = MemMgr->startFunctionBody(F5.get(), size);
   ASSERT_LE(smallFuncSize, size);
@@ -127,7 +126,7 @@ TEST(JITMemoryManagerTest, TestCodeAllocation) {
                           FunctionBody5 + smallFuncSize);
   EXPECT_TRUE(MemMgr->CheckInvariants(Error)) << Error;
 
-  OwningPtr<Function> F6(makeFakeFunction());
+  std::unique_ptr<Function> F6(makeFakeFunction());
   size = smallFuncSize;
   uint8_t *FunctionBody6 = MemMgr->startFunctionBody(F6.get(), size);
   ASSERT_LE(smallFuncSize, size);
@@ -157,7 +156,7 @@ TEST(JITMemoryManagerTest, TestCodeAllocation) {
 // Allocate five global ints of varying widths and alignment, and check their
 // alignment and overlap.
 TEST(JITMemoryManagerTest, TestSmallGlobalInts) {
-  OwningPtr<JITMemoryManager> MemMgr(
+  std::unique_ptr<JITMemoryManager> MemMgr(
       JITMemoryManager::CreateDefaultMemManager());
   uint8_t  *a = (uint8_t *)MemMgr->allocateGlobal(8,  0);
   uint16_t *b = (uint16_t*)MemMgr->allocateGlobal(16, 2);
@@ -204,7 +203,7 @@ TEST(JITMemoryManagerTest, TestSmallGlobalInts) {
 // Allocate a small global, a big global, and a third global, and make sure we
 // only use two slabs for that.
 TEST(JITMemoryManagerTest, TestLargeGlobalArray) {
-  OwningPtr<JITMemoryManager> MemMgr(
+  std::unique_ptr<JITMemoryManager> MemMgr(
       JITMemoryManager::CreateDefaultMemManager());
   size_t Size = 4 * MemMgr->GetDefaultDataSlabSize();
   uint64_t *a = (uint64_t*)MemMgr->allocateGlobal(64, 8);
@@ -234,7 +233,7 @@ TEST(JITMemoryManagerTest, TestLargeGlobalArray) {
 // Allocate lots of medium globals so that we can test moving the bump allocator
 // to a new slab.
 TEST(JITMemoryManagerTest, TestManyGlobals) {
-  OwningPtr<JITMemoryManager> MemMgr(
+  std::unique_ptr<JITMemoryManager> MemMgr(
       JITMemoryManager::CreateDefaultMemManager());
   size_t SlabSize = MemMgr->GetDefaultDataSlabSize();
   size_t Size = 128;
@@ -257,7 +256,7 @@ TEST(JITMemoryManagerTest, TestManyGlobals) {
 // Allocate lots of function stubs so that we can test moving the stub bump
 // allocator to a new slab.
 TEST(JITMemoryManagerTest, TestManyStubs) {
-  OwningPtr<JITMemoryManager> MemMgr(
+  std::unique_ptr<JITMemoryManager> MemMgr(
       JITMemoryManager::CreateDefaultMemManager());
   size_t SlabSize = MemMgr->GetDefaultStubSlabSize();
   size_t Size = 128;
@@ -279,7 +278,7 @@ TEST(JITMemoryManagerTest, TestManyStubs) {
 
 // Check section allocation and alignment
 TEST(JITMemoryManagerTest, AllocateSection) {
-  OwningPtr<JITMemoryManager> MemMgr(
+  std::unique_ptr<JITMemoryManager> MemMgr(
       JITMemoryManager::CreateDefaultMemManager());
   uint8_t *code1 = MemMgr->allocateCodeSection(256, 0, 1, StringRef());
   uint8_t *data1 = MemMgr->allocateDataSection(256, 16, 2, StringRef(), true);
diff --git a/unittests/ExecutionEngine/JIT/JITTest.cpp b/unittests/ExecutionEngine/JIT/JITTest.cpp
index 4e1d6e7890..9e65fee4b1 100644
--- a/unittests/ExecutionEngine/JIT/JITTest.cpp
+++ b/unittests/ExecutionEngine/JIT/JITTest.cpp
@@ -8,7 +8,6 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ExecutionEngine/JIT.h"
-#include "llvm/ADT/OwningPtr.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/AsmParser/Parser.h"
 #include "llvm/Bitcode/ReaderWriter.h"
@@ -77,7 +76,8 @@ std::string DumpFunction(const Function *F) {
 }
 
 class RecordingJITMemoryManager : public JITMemoryManager {
-  const OwningPtr<JITMemoryManager> Base;
+  const std::unique_ptr<JITMemoryManager> Base;
+
 public:
   RecordingJITMemoryManager()
     : Base(JITMemoryManager::CreateDefaultMemManager()) {
@@ -203,7 +203,7 @@ class JITTest : public testing::Test {
   LLVMContext Context;
   Module *M;  // Owned by ExecutionEngine.
   RecordingJITMemoryManager *RJMM;
-  OwningPtr<ExecutionEngine> TheJIT;
+  std::unique_ptr<ExecutionEngine> TheJIT;
 };
 
 // Regression test for a bug.  The JIT used to allocate globals inside the same
@@ -220,13 +220,13 @@ TEST(JIT, GlobalInFunction) {
   // memory is more easily tested.
   MemMgr->setPoisonMemory(true);
   std::string Error;
-  OwningPtr<ExecutionEngine> JIT(EngineBuilder(M)
-                                 .setEngineKind(EngineKind::JIT)
-                                 .setErrorStr(&Error)
-                                 .setJITMemoryManager(MemMgr)
-                                 // The next line enables the fix:
-                                 .setAllocateGVsWithCode(false)
-                                 .create());
+  std::unique_ptr<ExecutionEngine> JIT(EngineBuilder(M)
+                                           .setEngineKind(EngineKind::JIT)
+                                           .setErrorStr(&Error)
+                                           .setJITMemoryManager(MemMgr)
+                                           // The next line enables the fix:
+                                           .setAllocateGVsWithCode(false)
+                                           .create());
   ASSERT_EQ(Error, "");
 
   // Create a global variable.
@@ -669,7 +669,8 @@ TEST(LazyLoadedJITTest, MaterializableAvailableExternallyFunctionIsntCompiled) {
                       "} ");
   ASSERT_FALSE(Bitcode.empty()) << "Assembling failed";
   Module *M;
-  OwningPtr<ExecutionEngine> TheJIT(getJITFromBitcode(Context, Bitcode, M));
+  std::unique_ptr<ExecutionEngine> TheJIT(
+      getJITFromBitcode(Context, Bitcode, M));
   ASSERT_TRUE(TheJIT.get()) << "Failed to create JIT.";
   TheJIT->DisableLazyCompilation(true);
 
@@ -708,7 +709,8 @@ TEST(LazyLoadedJITTest, EagerCompiledRecursionThroughGhost) {
                       "} ");
   ASSERT_FALSE(Bitcode.empty()) << "Assembling failed";
   Module *M;
-  OwningPtr<ExecutionEngine> TheJIT(getJITFromBitcode(Context, Bitcode, M));
+  std::unique_ptr<ExecutionEngine> TheJIT(
+      getJITFromBitcode(Context, Bitcode, M));
   ASSERT_TRUE(TheJIT.get()) << "Failed to create JIT.";
   TheJIT->DisableLazyCompilation(true);
 
diff --git a/unittests/ExecutionEngine/JIT/MultiJITTest.cpp b/unittests/ExecutionEngine/JIT/MultiJITTest.cpp
index 92b7a92acb..48aa955769 100644
--- a/unittests/ExecutionEngine/JIT/MultiJITTest.cpp
+++ b/unittests/ExecutionEngine/JIT/MultiJITTest.cpp
@@ -81,9 +81,9 @@ TEST(MultiJitTest, EagerMode) {
   createModule2(Context2, M2, FooF2);
 
   // Now we create the JIT in eager mode
-  OwningPtr<ExecutionEngine> EE1(EngineBuilder(M1).create());
+  std::unique_ptr<ExecutionEngine> EE1(EngineBuilder(M1).create());
   EE1->DisableLazyCompilation(true);
-  OwningPtr<ExecutionEngine> EE2(EngineBuilder(M2).create());
+  std::unique_ptr<ExecutionEngine> EE2(EngineBuilder(M2).create());
   EE2->DisableLazyCompilation(true);
 
   // Call the `foo' function with no arguments:
@@ -111,9 +111,9 @@ TEST(MultiJitTest, LazyMode) {
   createModule2(Context2, M2, FooF2);
 
   // Now we create the JIT in lazy mode
-  OwningPtr<ExecutionEngine> EE1(EngineBuilder(M1).create());
+  std::unique_ptr<ExecutionEngine> EE1(EngineBuilder(M1).create());
   EE1->DisableLazyCompilation(false);
-  OwningPtr<ExecutionEngine> EE2(EngineBuilder(M2).create());
+  std::unique_ptr<ExecutionEngine> EE2(EngineBuilder(M2).create());
   EE2->DisableLazyCompilation(false);
 
   // Call the `foo' function with no arguments:
@@ -145,8 +145,8 @@ TEST(MultiJitTest, JitPool) {
   createModule2(Context2, M2, FooF2);
 
   // Now we create two JITs
-  OwningPtr<ExecutionEngine> EE1(EngineBuilder(M1).create());
-  OwningPtr<ExecutionEngine> EE2(EngineBuilder(M2).create());
+  std::unique_ptr<ExecutionEngine> EE1(EngineBuilder(M1).create());
+  std::unique_ptr<ExecutionEngine> EE2(EngineBuilder(M2).create());
 
   Function *F1 = EE1->FindFunctionNamed("foo1");
   void *foo1 = EE1->getPointerToFunction(F1);
diff --git a/unittests/ExecutionEngine/MCJIT/MCJITMemoryManagerTest.cpp b/unittests/ExecutionEngine/MCJIT/MCJITMemoryManagerTest.cpp
index c24346de84..f862999da8 100644
--- a/unittests/ExecutionEngine/MCJIT/MCJITMemoryManagerTest.cpp
+++ b/unittests/ExecutionEngine/MCJIT/MCJITMemoryManagerTest.cpp
@@ -8,7 +8,6 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ExecutionEngine/SectionMemoryManager.h"
-#include "llvm/ADT/OwningPtr.h"
 #include "llvm/ExecutionEngine/JIT.h"
 #include "gtest/gtest.h"
 
@@ -17,7 +16,7 @@ using namespace llvm;
 namespace {
 
 TEST(MCJITMemoryManagerTest, BasicAllocations) {
-  OwningPtr<SectionMemoryManager> MemMgr(new SectionMemoryManager());
+  std::unique_ptr<SectionMemoryManager> MemMgr(new SectionMemoryManager());
 
   uint8_t *code1 = MemMgr->allocateCodeSection(256, 0, 1, "");
   uint8_t *data1 = MemMgr->allocateDataSection(256, 0, 2, "", true);
@@ -50,7 +49,7 @@ TEST(MCJITMemoryManagerTest, BasicAllocations) {
 }
 
 TEST(MCJITMemoryManagerTest, LargeAllocations) {
-  OwningPtr<SectionMemoryManager> MemMgr(new SectionMemoryManager());
+  std::unique_ptr<SectionMemoryManager> MemMgr(new SectionMemoryManager());
 
   uint8_t *code1 = MemMgr->allocateCodeSection(0x100000, 0, 1, "");
   uint8_t *data1 = MemMgr->allocateDataSection(0x100000, 0, 2, "", true);
@@ -83,7 +82,7 @@ TEST(MCJITMemoryManagerTest, LargeAllocations) {
 }
 
 TEST(MCJITMemoryManagerTest, ManyAllocations) {
-  OwningPtr<SectionMemoryManager> MemMgr(new SectionMemoryManager());
+  std::unique_ptr<SectionMemoryManager> MemMgr(new SectionMemoryManager());
 
   uint8_t* code[10000];
   uint8_t* data[10000];
@@ -118,7 +117,7 @@ TEST(MCJITMemoryManagerTest, ManyAllocations) {
 }
 
 TEST(MCJITMemoryManagerTest, ManyVariedAllocations) {
-  OwningPtr<SectionMemoryManager> MemMgr(new SectionMemoryManager());
+  std::unique_ptr<SectionMemoryManager> MemMgr(new SectionMemoryManager());
 
   uint8_t* code[10000];
   uint8_t* data[10000];
diff --git a/unittests/ExecutionEngine/MCJIT/MCJITMultipleModuleTest.cpp b/unittests/ExecutionEngine/MCJIT/MCJITMultipleModuleTest.cpp
index 62ed0a8cb1..c5ca36e417 100644
--- a/unittests/ExecutionEngine/MCJIT/MCJITMultipleModuleTest.cpp
+++ b/unittests/ExecutionEngine/MCJIT/MCJITMultipleModuleTest.cpp
@@ -90,7 +90,7 @@ TEST_F(MCJITMultipleModuleTest, multiple_empty_modules) {
 TEST_F(MCJITMultipleModuleTest, two_module_case) {
   SKIP_UNSUPPORTED_PLATFORM;
 
-  OwningPtr<Module> A, B;
+  std::unique_ptr<Module> A, B;
   Function *FA, *FB;
   createTwoModuleCase(A, FA, B, FB);
 
@@ -110,7 +110,7 @@ TEST_F(MCJITMultipleModuleTest, two_module_case) {
 TEST_F(MCJITMultipleModuleTest, two_module_reverse_case) {
   SKIP_UNSUPPORTED_PLATFORM;
 
-  OwningPtr<Module> A, B;
+  std::unique_ptr<Module> A, B;
   Function *FA, *FB;
   createTwoModuleCase(A, FA, B, FB);
 
@@ -131,7 +131,7 @@ TEST_F(MCJITMultipleModuleTest, two_module_reverse_case) {
 TEST_F(MCJITMultipleModuleTest, two_module_extern_reverse_case) {
   SKIP_UNSUPPORTED_PLATFORM;
 
-  OwningPtr<Module> A, B;
+  std::unique_ptr<Module> A, B;
   Function *FA, *FB;
   createTwoModuleExternCase(A, FA, B, FB);
 
@@ -152,7 +152,7 @@ TEST_F(MCJITMultipleModuleTest, two_module_extern_reverse_case) {
 TEST_F(MCJITMultipleModuleTest, two_module_extern_case) {
   SKIP_UNSUPPORTED_PLATFORM;
 
-  OwningPtr<Module> A, B;
+  std::unique_ptr<Module> A, B;
   Function *FA, *FB;
   createTwoModuleExternCase(A, FA, B, FB);
 
@@ -172,7 +172,7 @@ TEST_F(MCJITMultipleModuleTest, two_module_extern_case) {
 TEST_F(MCJITMultipleModuleTest, two_module_consecutive_call_case) {
   SKIP_UNSUPPORTED_PLATFORM;
 
-  OwningPtr<Module> A, B;
+  std::unique_ptr<Module> A, B;
   Function *FA1, *FA2, *FB;
   createTwoModuleExternCase(A, FA1, B, FB);
   FA2 = insertSimpleCallFunction<int32_t(int32_t, int32_t)>(A.get(), FA1);
@@ -199,7 +199,7 @@ TEST_F(MCJITMultipleModuleTest, two_module_consecutive_call_case) {
 TEST_F(MCJITMultipleModuleTest, two_module_global_variables_case) {
   SKIP_UNSUPPORTED_PLATFORM;
 
-  OwningPtr<Module> A, B;
+  std::unique_ptr<Module> A, B;
   Function *FA, *FB;
   GlobalVariable *GVA, *GVB;
   A.reset(createEmptyModule("A"));
@@ -237,7 +237,7 @@ TEST_F(MCJITMultipleModuleTest, two_module_global_variables_case) {
 TEST_F(MCJITMultipleModuleTest, three_module_case) {
   SKIP_UNSUPPORTED_PLATFORM;
 
-  OwningPtr<Module> A, B, C;
+  std::unique_ptr<Module> A, B, C;
   Function *FA, *FB, *FC;
   createThreeModuleCase(A, FA, B, FB, C, FC);
 
@@ -262,7 +262,7 @@ TEST_F(MCJITMultipleModuleTest, three_module_case) {
 TEST_F(MCJITMultipleModuleTest, three_module_case_reverse_order) {
   SKIP_UNSUPPORTED_PLATFORM;
 
-  OwningPtr<Module> A, B, C;
+  std::unique_ptr<Module> A, B, C;
   Function *FA, *FB, *FC;
   createThreeModuleCase(A, FA, B, FB, C, FC);
 
@@ -287,7 +287,7 @@ TEST_F(MCJITMultipleModuleTest, three_module_case_reverse_order) {
 TEST_F(MCJITMultipleModuleTest, three_module_chain_case) {
   SKIP_UNSUPPORTED_PLATFORM;
 
-  OwningPtr<Module> A, B, C;
+  std::unique_ptr<Module> A, B, C;
   Function *FA, *FB, *FC;
   createThreeModuleChainedCallsCase(A, FA, B, FB, C, FC);
 
@@ -312,7 +312,7 @@ TEST_F(MCJITMultipleModuleTest, three_module_chain_case) {
 TEST_F(MCJITMultipleModuleTest, three_modules_chain_case_reverse_order) {
   SKIP_UNSUPPORTED_PLATFORM;
 
-  OwningPtr<Module> A, B, C;
+  std::unique_ptr<Module> A, B, C;
   Function *FA, *FB, *FC;
   createThreeModuleChainedCallsCase(A, FA, B, FB, C, FC);
 
@@ -337,7 +337,7 @@ TEST_F(MCJITMultipleModuleTest, three_modules_chain_case_reverse_order) {
 TEST_F(MCJITMultipleModuleTest, cross_module_dependency_case) {
   SKIP_UNSUPPORTED_PLATFORM;
 
-  OwningPtr<Module> A, B;
+  std::unique_ptr<Module> A, B;
   Function *FA, *FB1, *FB2;
   createCrossModuleRecursiveCase(A, FA, B, FB1, FB2);
 
@@ -358,7 +358,7 @@ TEST_F(MCJITMultipleModuleTest, cross_module_dependency_case) {
 TEST_F(MCJITMultipleModuleTest, cross_module_dependency_case_reverse_order) {
   SKIP_UNSUPPORTED_PLATFORM;
 
-  OwningPtr<Module> A, B;
+  std::unique_ptr<Module> A, B;
   Function *FA, *FB1, *FB2;
   createCrossModuleRecursiveCase(A, FA, B, FB1, FB2);
 
@@ -379,7 +379,7 @@ TEST_F(MCJITMultipleModuleTest, cross_module_dependency_case_reverse_order) {
 TEST_F(MCJITMultipleModuleTest, cross_module_dependency_case3) {
   SKIP_UNSUPPORTED_PLATFORM;
 
-  OwningPtr<Module> A, B;
+  std::unique_ptr<Module> A, B;
   Function *FA, *FB1, *FB2;
   createCrossModuleRecursiveCase(A, FA, B, FB1, FB2);
 
diff --git a/unittests/ExecutionEngine/MCJIT/MCJITObjectCacheTest.cpp b/unittests/ExecutionEngine/MCJIT/MCJITObjectCacheTest.cpp
index f16928b7a9..46847d3e51 100644
--- a/unittests/ExecutionEngine/MCJIT/MCJITObjectCacheTest.cpp
+++ b/unittests/ExecutionEngine/MCJIT/MCJITObjectCacheTest.cpp
@@ -7,7 +7,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/ADT/OwningPtr.h"
 #include "MCJITTestBase.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
@@ -101,7 +100,7 @@ protected:
 
   void compileAndRun(int ExpectedRC = OriginalRC) {
     // This function shouldn't be called until after SetUp.
-    ASSERT_TRUE(TheJIT.isValid());
+    ASSERT_TRUE(bool(TheJIT));
     ASSERT_TRUE(0 != Main);
 
     // We may be using a null cache, so ensure compilation is valid.
@@ -133,7 +132,7 @@ TEST_F(MCJITObjectCacheTest, SetNullObjectCache) {
 TEST_F(MCJITObjectCacheTest, VerifyBasicObjectCaching) {
   SKIP_UNSUPPORTED_PLATFORM;
 
-  OwningPtr<TestObjectCache>  Cache(new TestObjectCache);
+  std::unique_ptr<TestObjectCache> Cache(new TestObjectCache);
 
   // Save a copy of the module pointer before handing it off to MCJIT.
   const Module * SavedModulePointer = M.get();
@@ -162,7 +161,7 @@ TEST_F(MCJITObjectCacheTest, VerifyBasicObjectCaching) {
 TEST_F(MCJITObjectCacheTest, VerifyLoadFromCache) {
   SKIP_UNSUPPORTED_PLATFORM;
 
-  OwningPtr<TestObjectCache>  Cache(new TestObjectCache);
+  std::unique_ptr<TestObjectCache> Cache(new TestObjectCache);
 
   // Compile this module with an MCJIT engine
   createJIT(M.release());
@@ -196,7 +195,7 @@ TEST_F(MCJITObjectCacheTest, VerifyLoadFromCache) {
 TEST_F(MCJITObjectCacheTest, VerifyNonLoadFromCache) {
   SKIP_UNSUPPORTED_PLATFORM;
 
-  OwningPtr<TestObjectCache>  Cache(new TestObjectCache);
+  std::unique_ptr<TestObjectCache> Cache(new TestObjectCache);
 
   // Compile this module with an MCJIT engine
   createJIT(M.release());
diff --git a/unittests/ExecutionEngine/MCJIT/MCJITTestBase.h b/unittests/ExecutionEngine/MCJIT/MCJITTestBase.h
index a8f6b2b1b8..b2cb3bbef6 100644
--- a/unittests/ExecutionEngine/MCJIT/MCJITTestBase.h
+++ b/unittests/ExecutionEngine/MCJIT/MCJITTestBase.h
@@ -185,11 +185,9 @@ protected:
   // Populates Modules A and B:
   // Module A { Extern FB1, Function FA which calls FB1 },
   // Module B { Extern FA, Function FB1, Function FB2 which calls FA },
-  void createCrossModuleRecursiveCase(OwningPtr<Module> &A,
-                                      Function *&FA,
-                                      OwningPtr<Module> &B,
-                                      Function *&FB1,
-                                      Function *&FB2) {
+  void createCrossModuleRecursiveCase(std::unique_ptr<Module> &A, Function *&FA,
+                                      std::unique_ptr<Module> &B,
+                                      Function *&FB1, Function *&FB2) {
     // Define FB1 in B.
     B.reset(createEmptyModule("B"));
     FB1 = insertAccumulateFunction(B.get(), 0, "FB1");
@@ -211,12 +209,10 @@ protected:
   // Module A { Function FA },
   // Module B { Extern FA, Function FB which calls FA },
   // Module C { Extern FB, Function FC which calls FB },
-  void createThreeModuleChainedCallsCase(OwningPtr<Module> &A,
-                             Function *&FA,
-                             OwningPtr<Module> &B,
-                             Function *&FB,
-                             OwningPtr<Module> &C,
-                             Function *&FC) {
+  void
+  createThreeModuleChainedCallsCase(std::unique_ptr<Module> &A, Function *&FA,
+                                    std::unique_ptr<Module> &B, Function *&FB,
+                                    std::unique_ptr<Module> &C, Function *&FC) {
     A.reset(createEmptyModule("A"));
     FA = insertAddFunction(A.get());
 
@@ -233,8 +229,8 @@ protected:
   // Module A { Function FA },
   // Populates Modules A and B:
   // Module B { Function FB }
-  void createTwoModuleCase(OwningPtr<Module> &A, Function *&FA,
-                           OwningPtr<Module> &B, Function *&FB) {
+  void createTwoModuleCase(std::unique_ptr<Module> &A, Function *&FA,
+                           std::unique_ptr<Module> &B, Function *&FB) {
     A.reset(createEmptyModule("A"));
     FA = insertAddFunction(A.get());
 
@@ -244,8 +240,8 @@ protected:
 
   // Module A { Function FA },
   // Module B { Extern FA, Function FB which calls FA }
-  void createTwoModuleExternCase(OwningPtr<Module> &A, Function *&FA,
-                                 OwningPtr<Module> &B, Function *&FB) {
+  void createTwoModuleExternCase(std::unique_ptr<Module> &A, Function *&FA,
+                                 std::unique_ptr<Module> &B, Function *&FB) {
     A.reset(createEmptyModule("A"));
     FA = insertAddFunction(A.get());
 
@@ -258,12 +254,9 @@ protected:
   // Module A { Function FA },
   // Module B { Extern FA, Function FB which calls FA },
   // Module C { Extern FB, Function FC which calls FA },
-  void createThreeModuleCase(OwningPtr<Module> &A,
-                             Function *&FA,
-                             OwningPtr<Module> &B,
-                             Function *&FB,
-                             OwningPtr<Module> &C,
-                             Function *&FC) {
+  void createThreeModuleCase(std::unique_ptr<Module> &A, Function *&FA,
+                             std::unique_ptr<Module> &B, Function *&FB,
+                             std::unique_ptr<Module> &C, Function *&FC) {
     A.reset(createEmptyModule("A"));
     FA = insertAddFunction(A.get());
 
@@ -342,10 +335,10 @@ protected:
   CodeModel::Model CodeModel;
   StringRef MArch;
   SmallVector<std::string, 1> MAttrs;
-  OwningPtr<ExecutionEngine> TheJIT;
+  std::unique_ptr<ExecutionEngine> TheJIT;
   RTDyldMemoryManager *MM;
 
-  OwningPtr<Module> M;
+  std::unique_ptr<Module> M;
 };
 
 } // namespace llvm
diff --git a/unittests/IR/ConstantsTest.cpp b/unittests/IR/ConstantsTest.cpp
index fee38b891d..b3aa8102b6 100644
--- a/unittests/IR/ConstantsTest.cpp
+++ b/unittests/IR/ConstantsTest.cpp
@@ -162,7 +162,7 @@ TEST(ConstantsTest, PointerCast) {
   }
 
 TEST(ConstantsTest, AsInstructionsTest) {
-  OwningPtr<Module> M(new Module("MyModule", getGlobalContext()));
+  std::unique_ptr<Module> M(new Module("MyModule", getGlobalContext()));
 
   Type *Int64Ty = Type::getInt64Ty(getGlobalContext());
   Type *Int32Ty = Type::getInt32Ty(getGlobalContext());
diff --git a/unittests/IR/DominatorTreeTest.cpp b/unittests/IR/DominatorTreeTest.cpp
index d10031cb41..98c2317f2c 100644
--- a/unittests/IR/DominatorTreeTest.cpp
+++ b/unittests/IR/DominatorTreeTest.cpp
@@ -218,7 +218,7 @@ namespace llvm {
 
     TEST(DominatorTree, Unreachable) {
       DPass *P = new DPass();
-      OwningPtr<Module> M(makeLLVMModule(P));
+      std::unique_ptr<Module> M(makeLLVMModule(P));
       PassManager Passes;
       Passes.add(P);
       Passes.run(*M);
diff --git a/unittests/IR/IRBuilderTest.cpp b/unittests/IR/IRBuilderTest.cpp
index 5d67e700a9..9796e44599 100644
--- a/unittests/IR/IRBuilderTest.cpp
+++ b/unittests/IR/IRBuilderTest.cpp
@@ -8,7 +8,6 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/IR/IRBuilder.h"
-#include "llvm/ADT/OwningPtr.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/Function.h"
@@ -41,7 +40,7 @@ protected:
   }
 
   LLVMContext Ctx;
-  OwningPtr<Module> M;
+  std::unique_ptr<Module> M;
   Function *F;
   BasicBlock *BB;
   GlobalVariable *GV;
@@ -109,7 +108,7 @@ TEST_F(IRBuilderTest, LandingPadName) {
 }
 
 TEST_F(IRBuilderTest, DataLayout) {
-  OwningPtr<Module> M(new Module("test", Ctx));
+  std::unique_ptr<Module> M(new Module("test", Ctx));
   M->setDataLayout("e-n32");
   EXPECT_TRUE(M->getDataLayout()->isLegalInteger(32));
   M->setDataLayout("e");
diff --git a/unittests/IR/LegacyPassManagerTest.cpp b/unittests/IR/LegacyPassManagerTest.cpp
index 284a513b52..df6f460df9 100644
--- a/unittests/IR/LegacyPassManagerTest.cpp
+++ b/unittests/IR/LegacyPassManagerTest.cpp
@@ -346,7 +346,7 @@ namespace llvm {
 
     template<typename T>
     void MemoryTestHelper(int run) {
-      OwningPtr<Module> M(makeLLVMModule());
+      std::unique_ptr<Module> M(makeLLVMModule());
       T *P = new T();
       PassManager Passes;
       Passes.add(new DataLayoutPass(M.get()));
diff --git a/unittests/IR/PassManagerTest.cpp b/unittests/IR/PassManagerTest.cpp
index ee1deff8df..75ba02b3a4 100644
--- a/unittests/IR/PassManagerTest.cpp
+++ b/unittests/IR/PassManagerTest.cpp
@@ -175,7 +175,7 @@ Module *parseIR(const char *IR) {
 
 class PassManagerTest : public ::testing::Test {
 protected:
-  OwningPtr<Module> M;
+  std::unique_ptr<Module> M;
 
 public:
   PassManagerTest()
diff --git a/unittests/IR/PatternMatch.cpp b/unittests/IR/PatternMatch.cpp
index da1638163f..bebee15366 100644
--- a/unittests/IR/PatternMatch.cpp
+++ b/unittests/IR/PatternMatch.cpp
@@ -32,7 +32,7 @@ namespace {
 
 struct PatternMatchTest : ::testing::Test {
   LLVMContext Ctx;
-  OwningPtr<Module> M;
+  std::unique_ptr<Module> M;
   Function *F;
   BasicBlock *BB;
   IRBuilder<true, NoFolder> IRB;
diff --git a/unittests/IR/ValueHandleTest.cpp b/unittests/IR/ValueHandleTest.cpp
index bbca701776..15a0c226f7 100644
--- a/unittests/IR/ValueHandleTest.cpp
+++ b/unittests/IR/ValueHandleTest.cpp
@@ -8,7 +8,6 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/IR/ValueHandle.h"
-#include "llvm/ADT/OwningPtr.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/LLVMContext.h"
@@ -336,7 +335,7 @@ TEST_F(ValueHandle, DestroyingOtherVHOnSameValueDoesntBreakIteration) {
 
   class DestroyingVH : public CallbackVH {
   public:
-    OwningPtr<WeakVH> ToClear[2];
+    std::unique_ptr<WeakVH> ToClear[2];
     DestroyingVH(Value *V) {
       ToClear[0].reset(new WeakVH(V));
       setValPtr(V);
diff --git a/unittests/IR/ValueMapTest.cpp b/unittests/IR/ValueMapTest.cpp
index 2e7e5dc493..176b56cfbe 100644
--- a/unittests/IR/ValueMapTest.cpp
+++ b/unittests/IR/ValueMapTest.cpp
@@ -8,7 +8,6 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/IR/ValueMap.h"
-#include "llvm/ADT/OwningPtr.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/Instructions.h"
@@ -24,8 +23,8 @@ template<typename T>
 class ValueMapTest : public testing::Test {
 protected:
   Constant *ConstantV;
-  OwningPtr<BitCastInst> BitcastV;
-  OwningPtr<BinaryOperator> AddV;
+  std::unique_ptr<BitCastInst> BitcastV;
+  std::unique_ptr<BinaryOperator> AddV;
 
   ValueMapTest() :
     ConstantV(ConstantInt::get(Type::getInt32Ty(getGlobalContext()), 0)),
diff --git a/unittests/IR/ValueTest.cpp b/unittests/IR/ValueTest.cpp
index f10e58922e..d92bc82768 100644
--- a/unittests/IR/ValueTest.cpp
+++ b/unittests/IR/ValueTest.cpp
@@ -45,7 +45,7 @@ TEST(ValueTest, UsedInBasicBlock) {
 
 TEST(GlobalTest, CreateAddressSpace) {
   LLVMContext &Ctx = getGlobalContext();
-  OwningPtr<Module> M(new Module("TestModule", Ctx));
+  std::unique_ptr<Module> M(new Module("TestModule", Ctx));
   Type *Int8Ty = Type::getInt8Ty(Ctx);
   Type *Int32Ty = Type::getInt32Ty(Ctx);
 
diff --git a/unittests/IR/VerifierTest.cpp b/unittests/IR/VerifierTest.cpp
index a5ce5fc9d3..0a660a6b91 100644
--- a/unittests/IR/VerifierTest.cpp
+++ b/unittests/IR/VerifierTest.cpp
@@ -8,7 +8,6 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/IR/Verifier.h"
-#include "llvm/ADT/OwningPtr.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Function.h"
diff --git a/unittests/Linker/LinkModulesTest.cpp b/unittests/Linker/LinkModulesTest.cpp
index ef3772d3a7..7b40b9f672 100644
--- a/unittests/Linker/LinkModulesTest.cpp
+++ b/unittests/Linker/LinkModulesTest.cpp
@@ -62,7 +62,7 @@ protected:
     M.reset();
   }
 
-  OwningPtr<Module> M;
+  std::unique_ptr<Module> M;
   Function *F;
   GlobalVariable *GV;
   BasicBlock *EntryBB;
diff --git a/unittests/Option/OptionParsingTest.cpp b/unittests/Option/OptionParsingTest.cpp
index 11d6d1e87e..6beb286cab 100644
--- a/unittests/Option/OptionParsingTest.cpp
+++ b/unittests/Option/OptionParsingTest.cpp
@@ -7,7 +7,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/ADT/OwningPtr.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
@@ -68,7 +67,8 @@ const char *Args[] = {
 TEST(Option, OptionParsing) {
   TestOptTable T;
   unsigned MAI, MAC;
-  OwningPtr<InputArgList> AL(T.ParseArgs(Args, array_endof(Args), MAI, MAC));
+  std::unique_ptr<InputArgList> AL(
+      T.ParseArgs(Args, array_endof(Args), MAI, MAC));
 
   // Check they all exist.
   EXPECT_TRUE(AL->hasArg(OPT_A));
@@ -111,7 +111,7 @@ TEST(Option, OptionParsing) {
 TEST(Option, ParseWithFlagExclusions) {
   TestOptTable T;
   unsigned MAI, MAC;
-  OwningPtr<InputArgList> AL;
+  std::unique_ptr<InputArgList> AL;
 
   // Exclude flag3 to avoid parsing as OPT_SLASH_C.
   AL.reset(T.ParseArgs(Args, array_endof(Args), MAI, MAC,
@@ -142,7 +142,8 @@ TEST(Option, ParseAliasInGroup) {
   unsigned MAI, MAC;
 
   const char *MyArgs[] = { "-I" };
-  OwningPtr<InputArgList> AL(T.ParseArgs(MyArgs, array_endof(MyArgs), MAI, MAC));
+  std::unique_ptr<InputArgList> AL(
+      T.ParseArgs(MyArgs, array_endof(MyArgs), MAI, MAC));
   EXPECT_TRUE(AL->hasArg(OPT_H));
 }
 
@@ -151,7 +152,8 @@ TEST(Option, AliasArgs) {
   unsigned MAI, MAC;
 
   const char *MyArgs[] = { "-J", "-Joo" };
-  OwningPtr<InputArgList> AL(T.ParseArgs(MyArgs, array_endof(MyArgs), MAI, MAC));
+  std::unique_ptr<InputArgList> AL(
+      T.ParseArgs(MyArgs, array_endof(MyArgs), MAI, MAC));
   EXPECT_TRUE(AL->hasArg(OPT_B));
   EXPECT_EQ(AL->getAllArgValues(OPT_B)[0], "foo");
   EXPECT_EQ(AL->getAllArgValues(OPT_B)[1], "bar");
@@ -162,7 +164,8 @@ TEST(Option, IgnoreCase) {
   unsigned MAI, MAC;
 
   const char *MyArgs[] = { "-a", "-joo" };
-  OwningPtr<InputArgList> AL(T.ParseArgs(MyArgs, array_endof(MyArgs), MAI, MAC));
+  std::unique_ptr<InputArgList> AL(
+      T.ParseArgs(MyArgs, array_endof(MyArgs), MAI, MAC));
   EXPECT_TRUE(AL->hasArg(OPT_A));
   EXPECT_TRUE(AL->hasArg(OPT_B));
 }
@@ -172,7 +175,8 @@ TEST(Option, DoNotIgnoreCase) {
   unsigned MAI, MAC;
 
   const char *MyArgs[] = { "-a", "-joo" };
-  OwningPtr<InputArgList> AL(T.ParseArgs(MyArgs, array_endof(MyArgs), MAI, MAC));
+  std::unique_ptr<InputArgList> AL(
+      T.ParseArgs(MyArgs, array_endof(MyArgs), MAI, MAC));
   EXPECT_FALSE(AL->hasArg(OPT_A));
   EXPECT_FALSE(AL->hasArg(OPT_B));
 }
@@ -182,7 +186,8 @@ TEST(Option, SlurpEmpty) {
   unsigned MAI, MAC;
 
   const char *MyArgs[] = { "-A", "-slurp" };
-  OwningPtr<InputArgList> AL(T.ParseArgs(MyArgs, array_endof(MyArgs), MAI, MAC));
+  std::unique_ptr<InputArgList> AL(
+      T.ParseArgs(MyArgs, array_endof(MyArgs), MAI, MAC));
   EXPECT_TRUE(AL->hasArg(OPT_A));
   EXPECT_TRUE(AL->hasArg(OPT_Slurp));
   EXPECT_EQ(AL->getAllArgValues(OPT_Slurp).size(), 0U);
@@ -193,7 +198,8 @@ TEST(Option, Slurp) {
   unsigned MAI, MAC;
 
   const char *MyArgs[] = { "-A", "-slurp", "-B", "--", "foo" };
-  OwningPtr<InputArgList> AL(T.ParseArgs(MyArgs, array_endof(MyArgs), MAI, MAC));
+  std::unique_ptr<InputArgList> AL(
+      T.ParseArgs(MyArgs, array_endof(MyArgs), MAI, MAC));
   EXPECT_EQ(AL->size(), 2U);
   EXPECT_TRUE(AL->hasArg(OPT_A));
   EXPECT_FALSE(AL->hasArg(OPT_B));
diff --git a/unittests/Support/CompressionTest.cpp b/unittests/Support/CompressionTest.cpp
index c0a9adadb7..db6a8bb146 100644
--- a/unittests/Support/CompressionTest.cpp
+++ b/unittests/Support/CompressionTest.cpp
@@ -12,7 +12,6 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/Compression.h"
-#include "llvm/ADT/OwningPtr.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Config/config.h"
 #include "llvm/Support/MemoryBuffer.h"
@@ -25,8 +24,8 @@ namespace {
 #if LLVM_ENABLE_ZLIB == 1 && HAVE_LIBZ
 
 void TestZlibCompression(StringRef Input, zlib::CompressionLevel Level) {
-  OwningPtr<MemoryBuffer> Compressed;
-  OwningPtr<MemoryBuffer> Uncompressed;
+  std::unique_ptr<MemoryBuffer> Compressed;
+  std::unique_ptr<MemoryBuffer> Uncompressed;
   EXPECT_EQ(zlib::StatusOK, zlib::compress(Input, Compressed, Level));
   // Check that uncompressed buffer is the same as original.
   EXPECT_EQ(zlib::StatusOK, zlib::uncompress(Compressed->getBuffer(),
diff --git a/unittests/Support/LineIteratorTest.cpp b/unittests/Support/LineIteratorTest.cpp
index d684e25df5..18f3fa99bc 100644
--- a/unittests/Support/LineIteratorTest.cpp
+++ b/unittests/Support/LineIteratorTest.cpp
@@ -8,7 +8,6 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/LineIterator.h"
-#include "llvm/ADT/OwningPtr.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "gtest/gtest.h"
 
@@ -18,9 +17,9 @@ using namespace llvm::sys;
 namespace {
 
 TEST(LineIteratorTest, Basic) {
-  OwningPtr<MemoryBuffer> Buffer(MemoryBuffer::getMemBuffer("line 1\n"
-                                                            "line 2\n"
-                                                            "line 3"));
+  std::unique_ptr<MemoryBuffer> Buffer(MemoryBuffer::getMemBuffer("line 1\n"
+                                                                  "line 2\n"
+                                                                  "line 3"));
 
   line_iterator I = line_iterator(*Buffer), E;
 
@@ -42,11 +41,12 @@ TEST(LineIteratorTest, Basic) {
 }
 
 TEST(LineIteratorTest, CommentSkipping) {
-  OwningPtr<MemoryBuffer> Buffer(MemoryBuffer::getMemBuffer("line 1\n"
-                                                            "line 2\n"
-                                                            "# Comment 1\n"
-                                                            "line 4\n"
-                                                            "# Comment 2"));
+  std::unique_ptr<MemoryBuffer> Buffer(
+      MemoryBuffer::getMemBuffer("line 1\n"
+                                 "line 2\n"
+                                 "# Comment 1\n"
+                                 "line 4\n"
+                                 "# Comment 2"));
 
   line_iterator I = line_iterator(*Buffer, '#'), E;
 
@@ -68,11 +68,11 @@ TEST(LineIteratorTest, CommentSkipping) {
 }
 
 TEST(LineIteratorTest, BlankSkipping) {
-  OwningPtr<MemoryBuffer> Buffer(MemoryBuffer::getMemBuffer("\n\n\n"
-                                                            "line 1\n"
-                                                            "\n\n\n"
-                                                            "line 2\n"
-                                                            "\n\n\n"));
+  std::unique_ptr<MemoryBuffer> Buffer(MemoryBuffer::getMemBuffer("\n\n\n"
+                                                                  "line 1\n"
+                                                                  "\n\n\n"
+                                                                  "line 2\n"
+                                                                  "\n\n\n"));
 
   line_iterator I = line_iterator(*Buffer), E;
 
@@ -91,7 +91,7 @@ TEST(LineIteratorTest, BlankSkipping) {
 }
 
 TEST(LineIteratorTest, EmptyBuffers) {
-  OwningPtr<MemoryBuffer> Buffer(MemoryBuffer::getMemBuffer(""));
+  std::unique_ptr<MemoryBuffer> Buffer(MemoryBuffer::getMemBuffer(""));
   EXPECT_TRUE(line_iterator(*Buffer).is_at_eof());
   EXPECT_EQ(line_iterator(), line_iterator(*Buffer));
 
diff --git a/unittests/Support/Path.cpp b/unittests/Support/Path.cpp
index 29a77f3780..d5bee7ae5d 100644
--- a/unittests/Support/Path.cpp
+++ b/unittests/Support/Path.cpp
@@ -555,7 +555,7 @@ TEST_F(FileSystemTest, CarriageReturn) {
     File << '\n';
   }
   {
-    OwningPtr<MemoryBuffer> Buf;
+    std::unique_ptr<MemoryBuffer> Buf;
     MemoryBuffer::getFile(FilePathname.c_str(), Buf);
     EXPECT_EQ(Buf->getBuffer(), "\r\n");
   }
@@ -566,7 +566,7 @@ TEST_F(FileSystemTest, CarriageReturn) {
     File << '\n';
   }
   {
-    OwningPtr<MemoryBuffer> Buf;
+    std::unique_ptr<MemoryBuffer> Buf;
     MemoryBuffer::getFile(FilePathname.c_str(), Buf);
     EXPECT_EQ(Buf->getBuffer(), "\n");
   }
diff --git a/unittests/Transforms/DebugIR/DebugIR.cpp b/unittests/Transforms/DebugIR/DebugIR.cpp
index 590fa8eac6..497dae30cb 100644
--- a/unittests/Transforms/DebugIR/DebugIR.cpp
+++ b/unittests/Transforms/DebugIR/DebugIR.cpp
@@ -90,8 +90,8 @@ protected:
 
   LLVMContext Context;
   char *cwd;
-  OwningPtr<Module> M;
-  OwningPtr<DebugIR> D;
+  std::unique_ptr<Module> M;
+  std::unique_ptr<DebugIR> D;
 };
 
 // Test empty named Module that is not supposed to be output to disk.
diff --git a/unittests/Transforms/Utils/SpecialCaseList.cpp b/unittests/Transforms/Utils/SpecialCaseList.cpp
index 07ac908caa..748834f85e 100644
--- a/unittests/Transforms/Utils/SpecialCaseList.cpp
+++ b/unittests/Transforms/Utils/SpecialCaseList.cpp
@@ -40,7 +40,7 @@ protected:
   }
 
   SpecialCaseList *makeSpecialCaseList(StringRef List, std::string &Error) {
-    OwningPtr<MemoryBuffer> MB(MemoryBuffer::getMemBuffer(List));
+    std::unique_ptr<MemoryBuffer> MB(MemoryBuffer::getMemBuffer(List));
     return SpecialCaseList::create(MB.get(), Error);
   }
 
@@ -60,9 +60,10 @@ TEST_F(SpecialCaseListTest, ModuleIsIn) {
   Function *F = makeFunction("foo", M);
   GlobalVariable *GV = makeGlobal("bar", "t", M);
 
-  OwningPtr<SpecialCaseList> SCL(makeSpecialCaseList("# This is a comment.\n"
-                                                     "\n"
-                                                     "src:hello\n"));
+  std::unique_ptr<SpecialCaseList> SCL(
+      makeSpecialCaseList("# This is a comment.\n"
+                          "\n"
+                          "src:hello\n"));
   EXPECT_TRUE(SCL->isIn(M));
   EXPECT_TRUE(SCL->isIn(*F));
   EXPECT_TRUE(SCL->isIn(*GV));
@@ -83,7 +84,7 @@ TEST_F(SpecialCaseListTest, FunctionIsIn) {
   Function *Foo = makeFunction("foo", M);
   Function *Bar = makeFunction("bar", M);
 
-  OwningPtr<SpecialCaseList> SCL(makeSpecialCaseList("fun:foo\n"));
+  std::unique_ptr<SpecialCaseList> SCL(makeSpecialCaseList("fun:foo\n"));
   EXPECT_TRUE(SCL->isIn(*Foo));
   EXPECT_FALSE(SCL->isIn(*Bar));
 
@@ -107,7 +108,7 @@ TEST_F(SpecialCaseListTest, GlobalIsIn) {
   GlobalVariable *Foo = makeGlobal("foo", "t1", M);
   GlobalVariable *Bar = makeGlobal("bar", "t2", M);
 
-  OwningPtr<SpecialCaseList> SCL(makeSpecialCaseList("global:foo\n"));
+  std::unique_ptr<SpecialCaseList> SCL(makeSpecialCaseList("global:foo\n"));
   EXPECT_TRUE(SCL->isIn(*Foo));
   EXPECT_FALSE(SCL->isIn(*Bar));
   EXPECT_FALSE(SCL->isIn(*Foo, "init"));
@@ -157,7 +158,7 @@ TEST_F(SpecialCaseListTest, AliasIsIn) {
   GlobalAlias *FooAlias = makeAlias("fooalias", Foo);
   GlobalAlias *BarAlias = makeAlias("baralias", Bar);
 
-  OwningPtr<SpecialCaseList> SCL(makeSpecialCaseList("fun:foo\n"));
+  std::unique_ptr<SpecialCaseList> SCL(makeSpecialCaseList("fun:foo\n"));
   EXPECT_FALSE(SCL->isIn(*FooAlias));
   EXPECT_FALSE(SCL->isIn(*BarAlias));
 
@@ -193,9 +194,9 @@ TEST_F(SpecialCaseListTest, Substring) {
   GlobalAlias *GA1 = makeAlias("buffoonery", F);
   GlobalAlias *GA2 = makeAlias("foobar", GV);
 
-  OwningPtr<SpecialCaseList> SCL(makeSpecialCaseList("src:hello\n"
-                                                     "fun:foo\n"
-                                                     "global:bar\n"));
+  std::unique_ptr<SpecialCaseList> SCL(makeSpecialCaseList("src:hello\n"
+                                                           "fun:foo\n"
+                                                           "global:bar\n"));
   EXPECT_FALSE(SCL->isIn(M));
   EXPECT_FALSE(SCL->isIn(*F));
   EXPECT_FALSE(SCL->isIn(*GV));
@@ -224,7 +225,7 @@ TEST_F(SpecialCaseListTest, InvalidSpecialCaseList) {
 }
 
 TEST_F(SpecialCaseListTest, EmptySpecialCaseList) {
-  OwningPtr<SpecialCaseList> SCL(makeSpecialCaseList(""));
+  std::unique_ptr<SpecialCaseList> SCL(makeSpecialCaseList(""));
   Module M("foo", Ctx);
   EXPECT_FALSE(SCL->isIn(M));
 }