Index: lldb/trunk/include/lldb/Utility/Reproducer.h
===================================================================
--- lldb/trunk/include/lldb/Utility/Reproducer.h
+++ lldb/trunk/include/lldb/Utility/Reproducer.h
@@ -203,7 +203,7 @@
 
   /// Create and register a new provider.
   template <typename T> T *Create() {
-    std::unique_ptr<ProviderBase> provider = llvm::make_unique<T>(m_root);
+    std::unique_ptr<ProviderBase> provider = std::make_unique<T>(m_root);
     return static_cast<T *>(Register(std::move(provider)));
   }
 
Index: lldb/trunk/include/lldb/Utility/ReproducerInstrumentation.h
===================================================================
--- lldb/trunk/include/lldb/Utility/ReproducerInstrumentation.h
+++ lldb/trunk/include/lldb/Utility/ReproducerInstrumentation.h
@@ -442,7 +442,7 @@
   void Register(Signature *f, llvm::StringRef result = {},
                 llvm::StringRef scope = {}, llvm::StringRef name = {},
                 llvm::StringRef args = {}) {
-    DoRegister(uintptr_t(f), llvm::make_unique<DefaultReplayer<Signature>>(f),
+    DoRegister(uintptr_t(f), std::make_unique<DefaultReplayer<Signature>>(f),
                SignatureStr(result, scope, name, args));
   }
 
@@ -452,7 +452,7 @@
   void Register(Signature *f, Signature *g, llvm::StringRef result = {},
                 llvm::StringRef scope = {}, llvm::StringRef name = {},
                 llvm::StringRef args = {}) {
-    DoRegister(uintptr_t(f), llvm::make_unique<DefaultReplayer<Signature>>(g),
+    DoRegister(uintptr_t(f), std::make_unique<DefaultReplayer<Signature>>(g),
                SignatureStr(result, scope, name, args));
   }
 
Index: lldb/trunk/source/API/SBAddress.cpp
===================================================================
--- lldb/trunk/source/API/SBAddress.cpp
+++ lldb/trunk/source/API/SBAddress.cpp
@@ -28,7 +28,7 @@
 SBAddress::SBAddress(const Address *lldb_object_ptr)
     : m_opaque_up(new Address()) {
   if (lldb_object_ptr)
-    m_opaque_up = llvm::make_unique<Address>(*lldb_object_ptr);
+    m_opaque_up = std::make_unique<Address>(*lldb_object_ptr);
 }
 
 SBAddress::SBAddress(const SBAddress &rhs) : m_opaque_up(new Address()) {
Index: lldb/trunk/source/API/SBBreakpointOptionCommon.cpp
===================================================================
--- lldb/trunk/source/API/SBBreakpointOptionCommon.cpp
+++ lldb/trunk/source/API/SBBreakpointOptionCommon.cpp
@@ -41,7 +41,7 @@
 SBBreakpointCallbackBaton::SBBreakpointCallbackBaton(SBBreakpointHitCallback 
                                                          callback,
                                                      void *baton)
-      : TypedBaton(llvm::make_unique<CallbackData>()) {
+      : TypedBaton(std::make_unique<CallbackData>()) {
     getItem()->callback = callback;
     getItem()->callback_baton = baton;
   }
Index: lldb/trunk/source/API/SBDebugger.cpp
===================================================================
--- lldb/trunk/source/API/SBDebugger.cpp
+++ lldb/trunk/source/API/SBDebugger.cpp
@@ -88,7 +88,7 @@
       file = absolute_path.GetPath();
     }
 
-    return llvm::make_unique<CommandLoader>(std::move(files));
+    return std::make_unique<CommandLoader>(std::move(files));
   }
 
   FILE *GetNextFile() {
@@ -204,7 +204,7 @@
 
   SBError error;
   if (auto e = g_debugger_lifetime->Initialize(
-          llvm::make_unique<SystemInitializerFull>(), LoadPlugin)) {
+          std::make_unique<SystemInitializerFull>(), LoadPlugin)) {
     error.SetError(Status(std::move(e)));
   }
   return LLDB_RECORD_RESULT(error);
@@ -599,18 +599,18 @@
 static void AddBoolConfigEntry(StructuredData::Dictionary &dict,
                                llvm::StringRef name, bool value,
                                llvm::StringRef description) {
-  auto entry_up = llvm::make_unique<StructuredData::Dictionary>();
+  auto entry_up = std::make_unique<StructuredData::Dictionary>();
   entry_up->AddBooleanItem("value", value);
   entry_up->AddStringItem("description", description);
   dict.AddItem(name, std::move(entry_up));
 }
 
 static void AddLLVMTargets(StructuredData::Dictionary &dict) {
-  auto array_up = llvm::make_unique<StructuredData::Array>();
+  auto array_up = std::make_unique<StructuredData::Array>();
 #define LLVM_TARGET(target)                                                    \
-  array_up->AddItem(llvm::make_unique<StructuredData::String>(#target));
+  array_up->AddItem(std::make_unique<StructuredData::String>(#target));
 #include "llvm/Config/Targets.def"
-  auto entry_up = llvm::make_unique<StructuredData::Dictionary>();
+  auto entry_up = std::make_unique<StructuredData::Dictionary>();
   entry_up->AddItem("value", std::move(array_up));
   entry_up->AddStringItem("description", "A list of configured LLVM targets.");
   dict.AddItem("targets", std::move(entry_up));
@@ -620,7 +620,7 @@
   LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBStructuredData, SBDebugger,
                                     GetBuildConfiguration);
 
-  auto config_up = llvm::make_unique<StructuredData::Dictionary>();
+  auto config_up = std::make_unique<StructuredData::Dictionary>();
   AddBoolConfigEntry(
       *config_up, "xml", XMLDocument::XMLEnabled(),
       "A boolean value that indicates if XML support is enabled in LLDB");
@@ -1012,7 +1012,7 @@
                      GetAvailablePlatformInfoAtIndex, (uint32_t), idx);
 
   SBStructuredData data;
-  auto platform_dict = llvm::make_unique<StructuredData::Dictionary>();
+  auto platform_dict = std::make_unique<StructuredData::Dictionary>();
   llvm::StringRef name_str("name"), desc_str("description");
 
   if (idx == 0) {
Index: lldb/trunk/source/API/SBDeclaration.cpp
===================================================================
--- lldb/trunk/source/API/SBDeclaration.cpp
+++ lldb/trunk/source/API/SBDeclaration.cpp
@@ -32,7 +32,7 @@
 SBDeclaration::SBDeclaration(const lldb_private::Declaration *lldb_object_ptr)
     : m_opaque_up() {
   if (lldb_object_ptr)
-    m_opaque_up = llvm::make_unique<Declaration>(*lldb_object_ptr);
+    m_opaque_up = std::make_unique<Declaration>(*lldb_object_ptr);
 }
 
 const SBDeclaration &SBDeclaration::operator=(const SBDeclaration &rhs) {
Index: lldb/trunk/source/API/SBFrame.cpp
===================================================================
--- lldb/trunk/source/API/SBFrame.cpp
+++ lldb/trunk/source/API/SBFrame.cpp
@@ -1107,7 +1107,7 @@
         if (target->GetDisplayExpressionsInCrashlogs()) {
           StreamString frame_description;
           frame->DumpUsingSettingsFormat(&frame_description);
-          stack_trace = llvm::make_unique<llvm::PrettyStackTraceFormat>(
+          stack_trace = std::make_unique<llvm::PrettyStackTraceFormat>(
               "SBFrame::EvaluateExpression (expr = \"%s\", fetch_dynamic_value "
               "= %u) %s",
               expr, options.GetFetchDynamicValue(),
Index: lldb/trunk/source/API/SBLineEntry.cpp
===================================================================
--- lldb/trunk/source/API/SBLineEntry.cpp
+++ lldb/trunk/source/API/SBLineEntry.cpp
@@ -32,7 +32,7 @@
 SBLineEntry::SBLineEntry(const lldb_private::LineEntry *lldb_object_ptr)
     : m_opaque_up() {
   if (lldb_object_ptr)
-    m_opaque_up = llvm::make_unique<LineEntry>(*lldb_object_ptr);
+    m_opaque_up = std::make_unique<LineEntry>(*lldb_object_ptr);
 }
 
 const SBLineEntry &SBLineEntry::operator=(const SBLineEntry &rhs) {
@@ -45,7 +45,7 @@
 }
 
 void SBLineEntry::SetLineEntry(const lldb_private::LineEntry &lldb_object_ref) {
-  m_opaque_up = llvm::make_unique<LineEntry>(lldb_object_ref);
+  m_opaque_up = std::make_unique<LineEntry>(lldb_object_ref);
 }
 
 SBLineEntry::~SBLineEntry() {}
Index: lldb/trunk/source/API/SBStringList.cpp
===================================================================
--- lldb/trunk/source/API/SBStringList.cpp
+++ lldb/trunk/source/API/SBStringList.cpp
@@ -21,7 +21,7 @@
 SBStringList::SBStringList(const lldb_private::StringList *lldb_strings_ptr)
     : m_opaque_up() {
   if (lldb_strings_ptr)
-    m_opaque_up = llvm::make_unique<StringList>(*lldb_strings_ptr);
+    m_opaque_up = std::make_unique<StringList>(*lldb_strings_ptr);
 }
 
 SBStringList::SBStringList(const SBStringList &rhs) : m_opaque_up() {
Index: lldb/trunk/source/API/SBSymbolContext.cpp
===================================================================
--- lldb/trunk/source/API/SBSymbolContext.cpp
+++ lldb/trunk/source/API/SBSymbolContext.cpp
@@ -27,7 +27,7 @@
                           (const lldb_private::SymbolContext *), sc_ptr);
 
   if (sc_ptr)
-    m_opaque_up = llvm::make_unique<SymbolContext>(*sc_ptr);
+    m_opaque_up = std::make_unique<SymbolContext>(*sc_ptr);
 }
 
 SBSymbolContext::SBSymbolContext(const SBSymbolContext &rhs) : m_opaque_up() {
@@ -51,7 +51,7 @@
 
 void SBSymbolContext::SetSymbolContext(const SymbolContext *sc_ptr) {
   if (sc_ptr)
-    m_opaque_up = llvm::make_unique<SymbolContext>(*sc_ptr);
+    m_opaque_up = std::make_unique<SymbolContext>(*sc_ptr);
   else
     m_opaque_up->Clear(true);
 }
Index: lldb/trunk/source/API/SBTarget.cpp
===================================================================
--- lldb/trunk/source/API/SBTarget.cpp
+++ lldb/trunk/source/API/SBTarget.cpp
@@ -218,7 +218,7 @@
   if (!target_sp)
     return LLDB_RECORD_RESULT(data);
 
-  auto stats_up = llvm::make_unique<StructuredData::Dictionary>();
+  auto stats_up = std::make_unique<StructuredData::Dictionary>();
   int i = 0;
   for (auto &Entry : target_sp->GetStatistics()) {
     std::string Desc = lldb_private::GetStatDescription(
Index: lldb/trunk/source/API/Utils.h
===================================================================
--- lldb/trunk/source/API/Utils.h
+++ lldb/trunk/source/API/Utils.h
@@ -16,7 +16,7 @@
 
 template <typename T> std::unique_ptr<T> clone(const std::unique_ptr<T> &src) {
   if (src)
-    return llvm::make_unique<T>(*src);
+    return std::make_unique<T>(*src);
   return nullptr;
 }
 
Index: lldb/trunk/source/Breakpoint/BreakpointOptions.cpp
===================================================================
--- lldb/trunk/source/Breakpoint/BreakpointOptions.cpp
+++ lldb/trunk/source/Breakpoint/BreakpointOptions.cpp
@@ -309,7 +309,7 @@
     }
   }
 
-  auto bp_options = llvm::make_unique<BreakpointOptions>(
+  auto bp_options = std::make_unique<BreakpointOptions>(
       condition_ref.str().c_str(), enabled, 
       ignore_count, one_shot, auto_continue);
   if (cmd_data_up) {
Index: lldb/trunk/source/Commands/CommandObjectBreakpoint.cpp
===================================================================
--- lldb/trunk/source/Commands/CommandObjectBreakpoint.cpp
+++ lldb/trunk/source/Commands/CommandObjectBreakpoint.cpp
@@ -159,7 +159,7 @@
     {
       if (!m_commands.empty())
       {
-          auto cmd_data = llvm::make_unique<BreakpointOptions::CommandData>();
+          auto cmd_data = std::make_unique<BreakpointOptions::CommandData>();
         
           for (std::string &str : m_commands)
             cmd_data->user_source.AppendString(str); 
Index: lldb/trunk/source/Commands/CommandObjectBreakpointCommand.cpp
===================================================================
--- lldb/trunk/source/Commands/CommandObjectBreakpointCommand.cpp
+++ lldb/trunk/source/Commands/CommandObjectBreakpointCommand.cpp
@@ -238,7 +238,7 @@
       if (!bp_options)
         continue;
 
-      auto cmd_data = llvm::make_unique<BreakpointOptions::CommandData>();
+      auto cmd_data = std::make_unique<BreakpointOptions::CommandData>();
       cmd_data->user_source.SplitIntoLines(line.c_str(), line.size());
       bp_options->SetCommandDataCallback(cmd_data);
     }
@@ -260,7 +260,7 @@
   SetBreakpointCommandCallback(std::vector<BreakpointOptions *> &bp_options_vec,
                                const char *oneliner) {
     for (auto bp_options : bp_options_vec) {
-      auto cmd_data = llvm::make_unique<BreakpointOptions::CommandData>();
+      auto cmd_data = std::make_unique<BreakpointOptions::CommandData>();
 
       cmd_data->user_source.AppendString(oneliner);
       cmd_data->stop_on_error = m_options.m_stop_on_error;
Index: lldb/trunk/source/Commands/CommandObjectCommands.cpp
===================================================================
--- lldb/trunk/source/Commands/CommandObjectCommands.cpp
+++ lldb/trunk/source/Commands/CommandObjectCommands.cpp
@@ -997,7 +997,7 @@
 
     Status error;
     auto name = command[0].ref;
-    m_regex_cmd_up = llvm::make_unique<CommandObjectRegexCommand>(
+    m_regex_cmd_up = std::make_unique<CommandObjectRegexCommand>(
         m_interpreter, name, m_options.GetHelp(), m_options.GetSyntax(), 10, 0,
         true);
 
Index: lldb/trunk/source/Core/Debugger.cpp
===================================================================
--- lldb/trunk/source/Core/Debugger.cpp
+++ lldb/trunk/source/Core/Debugger.cpp
@@ -275,7 +275,7 @@
       if (str.length())
         new_prompt = str;
       GetCommandInterpreter().UpdatePrompt(new_prompt);
-      auto bytes = llvm::make_unique<EventDataBytes>(new_prompt);
+      auto bytes = std::make_unique<EventDataBytes>(new_prompt);
       auto prompt_change_event_sp = std::make_shared<Event>(
           CommandInterpreter::eBroadcastBitResetPrompt, bytes.release());
       GetCommandInterpreter().BroadcastEvent(prompt_change_event_sp);
@@ -704,7 +704,7 @@
       m_listener_sp(Listener::MakeListener("lldb.Debugger")),
       m_source_manager_up(), m_source_file_cache(),
       m_command_interpreter_up(
-          llvm::make_unique<CommandInterpreter>(*this, false)),
+          std::make_unique<CommandInterpreter>(*this, false)),
       m_script_interpreter_sp(), m_input_reader_stack(), m_instance_name(),
       m_loaded_plugins(), m_event_handler_thread(), m_io_handler_thread(),
       m_sync_broadcaster(nullptr, "lldb.debugger.sync"),
@@ -1239,7 +1239,7 @@
 
 SourceManager &Debugger::GetSourceManager() {
   if (!m_source_manager_up)
-    m_source_manager_up = llvm::make_unique<SourceManager>(shared_from_this());
+    m_source_manager_up = std::make_unique<SourceManager>(shared_from_this());
   return *m_source_manager_up;
 }
 
Index: lldb/trunk/source/Core/Module.cpp
===================================================================
--- lldb/trunk/source/Core/Module.cpp
+++ lldb/trunk/source/Core/Module.cpp
@@ -292,7 +292,7 @@
     std::lock_guard<std::recursive_mutex> guard(m_mutex);
     if (process_sp) {
       m_did_load_objfile = true;
-      auto data_up = llvm::make_unique<DataBufferHeap>(size_to_read, 0);
+      auto data_up = std::make_unique<DataBufferHeap>(size_to_read, 0);
       Status readmem_error;
       const size_t bytes_read =
           process_sp->ReadMemory(header_addr, data_up->GetBytes(),
@@ -1297,7 +1297,7 @@
 
 SectionList *Module::GetUnifiedSectionList() {
   if (!m_sections_up)
-    m_sections_up = llvm::make_unique<SectionList>();
+    m_sections_up = std::make_unique<SectionList>();
   return m_sections_up.get();
 }
 
Index: lldb/trunk/source/Core/ValueObjectSyntheticFilter.cpp
===================================================================
--- lldb/trunk/source/Core/ValueObjectSyntheticFilter.cpp
+++ lldb/trunk/source/Core/ValueObjectSyntheticFilter.cpp
@@ -140,7 +140,7 @@
   }
   m_synth_filter_up = (m_synth_sp->GetFrontEnd(*valobj_for_frontend));
   if (!m_synth_filter_up)
-    m_synth_filter_up = llvm::make_unique<DummySyntheticFrontEnd>(*m_parent);
+    m_synth_filter_up = std::make_unique<DummySyntheticFrontEnd>(*m_parent);
 }
 
 bool ValueObjectSynthetic::UpdateValue() {
Index: lldb/trunk/source/Expression/IRExecutionUnit.cpp
===================================================================
--- lldb/trunk/source/Expression/IRExecutionUnit.cpp
+++ lldb/trunk/source/Expression/IRExecutionUnit.cpp
@@ -316,7 +316,7 @@
   };
 
   if (process_sp->GetTarget().GetEnableSaveObjects()) {
-    m_object_cache_up = llvm::make_unique<ObjectDumper>();
+    m_object_cache_up = std::make_unique<ObjectDumper>();
     m_execution_engine_up->setObjectCache(m_object_cache_up.get());
   }
 
Index: lldb/trunk/source/Host/common/Socket.cpp
===================================================================
--- lldb/trunk/source/Host/common/Socket.cpp
+++ lldb/trunk/source/Host/common/Socket.cpp
@@ -114,16 +114,16 @@
   switch (protocol) {
   case ProtocolTcp:
     socket_up =
-        llvm::make_unique<TCPSocket>(true, child_processes_inherit);
+        std::make_unique<TCPSocket>(true, child_processes_inherit);
     break;
   case ProtocolUdp:
     socket_up =
-        llvm::make_unique<UDPSocket>(true, child_processes_inherit);
+        std::make_unique<UDPSocket>(true, child_processes_inherit);
     break;
   case ProtocolUnixDomain:
 #ifndef LLDB_DISABLE_POSIX
     socket_up =
-        llvm::make_unique<DomainSocket>(true, child_processes_inherit);
+        std::make_unique<DomainSocket>(true, child_processes_inherit);
 #else
     error.SetErrorString(
         "Unix domain sockets are not supported on this platform.");
@@ -132,7 +132,7 @@
   case ProtocolUnixAbstract:
 #ifdef __linux__
     socket_up =
-        llvm::make_unique<AbstractSocket>(child_processes_inherit);
+        std::make_unique<AbstractSocket>(child_processes_inherit);
 #else
     error.SetErrorString(
         "Abstract domain sockets are not supported on this platform.");
Index: lldb/trunk/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp
===================================================================
--- lldb/trunk/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp
+++ lldb/trunk/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp
@@ -87,7 +87,7 @@
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
   LLDB_LOGF(log, "DynamicLoaderPOSIXDYLD::%s() pid %" PRIu64, __FUNCTION__,
             m_process ? m_process->GetID() : LLDB_INVALID_PROCESS_ID);
-  m_auxv = llvm::make_unique<AuxVector>(m_process->GetAuxvData());
+  m_auxv = std::make_unique<AuxVector>(m_process->GetAuxvData());
 
   LLDB_LOGF(
       log, "DynamicLoaderPOSIXDYLD::%s pid %" PRIu64 " reloaded auxv data",
@@ -179,7 +179,7 @@
   ModuleSP executable;
   addr_t load_offset;
 
-  m_auxv = llvm::make_unique<AuxVector>(m_process->GetAuxvData());
+  m_auxv = std::make_unique<AuxVector>(m_process->GetAuxvData());
 
   executable = GetTargetExecutable();
   load_offset = ComputeLoadOffset();
Index: lldb/trunk/source/Plugins/ExpressionParser/Clang/ClangASTSource.cpp
===================================================================
--- lldb/trunk/source/Plugins/ExpressionParser/Clang/ClangASTSource.cpp
+++ lldb/trunk/source/Plugins/ExpressionParser/Clang/ClangASTSource.cpp
@@ -135,7 +135,7 @@
       ;
 
     m_merger_up =
-        llvm::make_unique<clang::ExternalASTMerger>(target, sources);
+        std::make_unique<clang::ExternalASTMerger>(target, sources);
   } else {
     m_ast_importer_sp->InstallMapCompleter(&ast_context, *this);
   }
Index: lldb/trunk/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.h
===================================================================
--- lldb/trunk/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.h
+++ lldb/trunk/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.h
@@ -356,7 +356,7 @@
   /// Activate parser-specific variables
   void EnableParserVars() {
     if (!m_parser_vars.get())
-      m_parser_vars = llvm::make_unique<ParserVars>();
+      m_parser_vars = std::make_unique<ParserVars>();
   }
 
   /// Deallocate parser-specific variables
Index: lldb/trunk/source/Plugins/Language/ObjC/NSDictionary.h
===================================================================
--- lldb/trunk/source/Plugins/Language/ObjC/NSDictionary.h
+++ lldb/trunk/source/Plugins/Language/ObjC/NSDictionary.h
@@ -68,10 +68,10 @@
     };
     typedef Matcher::UP MatcherUP;
 
-    MatcherUP GetFullMatch(ConstString n) { return llvm::make_unique<Full>(n); }
+    MatcherUP GetFullMatch(ConstString n) { return std::make_unique<Full>(n); }
 
     MatcherUP GetPrefixMatch(ConstString p) {
-      return llvm::make_unique<Prefix>(p);
+      return std::make_unique<Prefix>(p);
     }
   };
 
Index: lldb/trunk/source/Plugins/ObjectFile/Breakpad/ObjectFileBreakpad.cpp
===================================================================
--- lldb/trunk/source/Plugins/ObjectFile/Breakpad/ObjectFileBreakpad.cpp
+++ lldb/trunk/source/Plugins/ObjectFile/Breakpad/ObjectFileBreakpad.cpp
@@ -127,7 +127,7 @@
 void ObjectFileBreakpad::CreateSections(SectionList &unified_section_list) {
   if (m_sections_up)
     return;
-  m_sections_up = llvm::make_unique<SectionList>();
+  m_sections_up = std::make_unique<SectionList>();
 
   llvm::Optional<Record::Kind> current_section;
   offset_t section_start;
Index: lldb/trunk/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp
===================================================================
--- lldb/trunk/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp
+++ lldb/trunk/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp
@@ -1762,7 +1762,7 @@
   if (m_sections_up)
     return;
 
-  m_sections_up = llvm::make_unique<SectionList>();
+  m_sections_up = std::make_unique<SectionList>();
   VMAddressProvider regular_provider(GetType(), "PT_LOAD");
   VMAddressProvider tls_provider(GetType(), "PT_TLS");
 
Index: lldb/trunk/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp
===================================================================
--- lldb/trunk/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp
+++ lldb/trunk/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp
@@ -874,7 +874,7 @@
       return nullptr;
     data_offset = 0;
   }
-  auto objfile_up = llvm::make_unique<ObjectFileMachO>(
+  auto objfile_up = std::make_unique<ObjectFileMachO>(
       module_sp, data_sp, data_offset, file, file_offset, length);
   if (!objfile_up || !objfile_up->ParseHeader())
     return nullptr;
Index: lldb/trunk/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp
===================================================================
--- lldb/trunk/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp
+++ lldb/trunk/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp
@@ -133,7 +133,7 @@
       return nullptr;
   }
 
-  auto objfile_up = llvm::make_unique<ObjectFilePECOFF>(
+  auto objfile_up = std::make_unique<ObjectFilePECOFF>(
       module_sp, data_sp, data_offset, file, file_offset, length);
   if (!objfile_up || !objfile_up->ParseHeader())
     return nullptr;
@@ -150,7 +150,7 @@
     const lldb::ProcessSP &process_sp, lldb::addr_t header_addr) {
   if (!data_sp || !ObjectFilePECOFF::MagicBytesMatch(data_sp))
     return nullptr;
-  auto objfile_up = llvm::make_unique<ObjectFilePECOFF>(
+  auto objfile_up = std::make_unique<ObjectFilePECOFF>(
       module_sp, data_sp, process_sp, header_addr);
   if (objfile_up.get() && objfile_up->ParseHeader()) {
     return objfile_up.release();
@@ -524,7 +524,7 @@
   ProcessSP process_sp(m_process_wp.lock());
   DataExtractor data;
   if (process_sp) {
-    auto data_up = llvm::make_unique<DataBufferHeap>(size, 0);
+    auto data_up = std::make_unique<DataBufferHeap>(size, 0);
     Status readmem_error;
     size_t bytes_read =
         process_sp->ReadMemory(m_image_base + offset, data_up->GetBytes(),
Index: lldb/trunk/source/Plugins/Process/Linux/NativeProcessLinux.cpp
===================================================================
--- lldb/trunk/source/Plugins/Process/Linux/NativeProcessLinux.cpp
+++ lldb/trunk/source/Plugins/Process/Linux/NativeProcessLinux.cpp
@@ -1591,7 +1591,7 @@
   if (m_threads.empty())
     SetCurrentThreadID(thread_id);
 
-  m_threads.push_back(llvm::make_unique<NativeThreadLinux>(*this, thread_id));
+  m_threads.push_back(std::make_unique<NativeThreadLinux>(*this, thread_id));
 
   if (m_pt_proces_trace_id != LLDB_INVALID_UID) {
     auto traceMonitor = ProcessorTraceMonitor::Create(
Index: lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_arm.cpp
===================================================================
--- lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_arm.cpp
+++ lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_arm.cpp
@@ -97,7 +97,7 @@
 std::unique_ptr<NativeRegisterContextLinux>
 NativeRegisterContextLinux::CreateHostNativeRegisterContextLinux(
     const ArchSpec &target_arch, NativeThreadProtocol &native_thread) {
-  return llvm::make_unique<NativeRegisterContextLinux_arm>(target_arch,
+  return std::make_unique<NativeRegisterContextLinux_arm>(target_arch,
                                                            native_thread);
 }
 
Index: lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_arm64.cpp
===================================================================
--- lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_arm64.cpp
+++ lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_arm64.cpp
@@ -112,10 +112,10 @@
     const ArchSpec &target_arch, NativeThreadProtocol &native_thread) {
   switch (target_arch.GetMachine()) {
   case llvm::Triple::arm:
-    return llvm::make_unique<NativeRegisterContextLinux_arm>(target_arch,
+    return std::make_unique<NativeRegisterContextLinux_arm>(target_arch,
                                                              native_thread);
   case llvm::Triple::aarch64:
-    return llvm::make_unique<NativeRegisterContextLinux_arm64>(target_arch,
+    return std::make_unique<NativeRegisterContextLinux_arm64>(target_arch,
                                                                native_thread);
   default:
     llvm_unreachable("have no register context for architecture");
Index: lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.cpp
===================================================================
--- lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.cpp
+++ lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.cpp
@@ -79,7 +79,7 @@
 std::unique_ptr<NativeRegisterContextLinux>
 NativeRegisterContextLinux::CreateHostNativeRegisterContextLinux(
     const ArchSpec &target_arch, NativeThreadProtocol &native_thread) {
-  return llvm::make_unique<NativeRegisterContextLinux_mips64>(target_arch,
+  return std::make_unique<NativeRegisterContextLinux_mips64>(target_arch,
                                                               native_thread);
 }
 
Index: lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_ppc64le.cpp
===================================================================
--- lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_ppc64le.cpp
+++ lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_ppc64le.cpp
@@ -118,7 +118,7 @@
     const ArchSpec &target_arch, NativeThreadProtocol &native_thread) {
   switch (target_arch.GetMachine()) {
   case llvm::Triple::ppc64le:
-    return llvm::make_unique<NativeRegisterContextLinux_ppc64le>(target_arch,
+    return std::make_unique<NativeRegisterContextLinux_ppc64le>(target_arch,
                                                                  native_thread);
   default:
     llvm_unreachable("have no register context for architecture");
Index: lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_s390x.cpp
===================================================================
--- lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_s390x.cpp
+++ lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_s390x.cpp
@@ -95,7 +95,7 @@
 std::unique_ptr<NativeRegisterContextLinux>
 NativeRegisterContextLinux::CreateHostNativeRegisterContextLinux(
     const ArchSpec &target_arch, NativeThreadProtocol &native_thread) {
-  return llvm::make_unique<NativeRegisterContextLinux_s390x>(target_arch,
+  return std::make_unique<NativeRegisterContextLinux_s390x>(target_arch,
                                                              native_thread);
 }
 
Index: lldb/trunk/source/Plugins/Process/Linux/SingleStepCheck.cpp
===================================================================
--- lldb/trunk/source/Plugins/Process/Linux/SingleStepCheck.cpp
+++ lldb/trunk/source/Plugins/Process/Linux/SingleStepCheck.cpp
@@ -172,7 +172,7 @@
   }
 
   LLDB_LOG(log, "workaround for thread {0} prepared", tid);
-  return llvm::make_unique<SingleStepWorkaround>(tid, original_set);
+  return std::make_unique<SingleStepWorkaround>(tid, original_set);
 }
 
 SingleStepWorkaround::~SingleStepWorkaround() {
Index: lldb/trunk/source/Plugins/Process/NetBSD/NativeProcessNetBSD.cpp
===================================================================
--- lldb/trunk/source/Plugins/Process/NetBSD/NativeProcessNetBSD.cpp
+++ lldb/trunk/source/Plugins/Process/NetBSD/NativeProcessNetBSD.cpp
@@ -659,7 +659,7 @@
   if (m_threads.empty())
     SetCurrentThreadID(thread_id);
 
-  m_threads.push_back(llvm::make_unique<NativeThreadNetBSD>(*this, thread_id));
+  m_threads.push_back(std::make_unique<NativeThreadNetBSD>(*this, thread_id));
   return static_cast<NativeThreadNetBSD &>(*m_threads.back());
 }
 
Index: lldb/trunk/source/Plugins/Process/POSIX/NativeProcessELF.cpp
===================================================================
--- lldb/trunk/source/Plugins/Process/POSIX/NativeProcessELF.cpp
+++ lldb/trunk/source/Plugins/Process/POSIX/NativeProcessELF.cpp
@@ -21,7 +21,7 @@
     DataExtractor auxv_data(buffer_or_error.get()->getBufferStart(),
                             buffer_or_error.get()->getBufferSize(),
                             GetByteOrder(), GetAddressByteSize());
-    m_aux_vector = llvm::make_unique<AuxVector>(auxv_data);
+    m_aux_vector = std::make_unique<AuxVector>(auxv_data);
   }
 
   return m_aux_vector->GetAuxValue(type);
Index: lldb/trunk/source/Plugins/Process/Windows/Common/NativeProcessWindows.cpp
===================================================================
--- lldb/trunk/source/Plugins/Process/Windows/Common/NativeProcessWindows.cpp
+++ lldb/trunk/source/Plugins/Process/Windows/Common/NativeProcessWindows.cpp
@@ -410,7 +410,7 @@
 
   // The very first one shall always be the main thread.
   assert(m_threads.empty());
-  m_threads.push_back(llvm::make_unique<NativeThreadWindows>(
+  m_threads.push_back(std::make_unique<NativeThreadWindows>(
       *this, m_session_data->m_debugger->GetMainThread()));
 }
 
@@ -514,7 +514,7 @@
 void NativeProcessWindows::OnCreateThread(const HostThread &new_thread) {
   llvm::sys::ScopedLock lock(m_mutex);
   m_threads.push_back(
-      llvm::make_unique<NativeThreadWindows>(*this, new_thread));
+      std::make_unique<NativeThreadWindows>(*this, new_thread));
 }
 
 void NativeProcessWindows::OnExitThread(lldb::tid_t thread_id,
Index: lldb/trunk/source/Plugins/Process/Windows/Common/NativeRegisterContextWindows_i386.cpp
===================================================================
--- lldb/trunk/source/Plugins/Process/Windows/Common/NativeRegisterContextWindows_i386.cpp
+++ lldb/trunk/source/Plugins/Process/Windows/Common/NativeRegisterContextWindows_i386.cpp
@@ -86,7 +86,7 @@
 std::unique_ptr<NativeRegisterContextWindows>
 NativeRegisterContextWindows::CreateHostNativeRegisterContextWindows(
     const ArchSpec &target_arch, NativeThreadProtocol &native_thread) {
-  return llvm::make_unique<NativeRegisterContextWindows_i386>(target_arch,
+  return std::make_unique<NativeRegisterContextWindows_i386>(target_arch,
                                                               native_thread);
 }
 
Index: lldb/trunk/source/Plugins/Process/Windows/Common/NativeRegisterContextWindows_x86_64.cpp
===================================================================
--- lldb/trunk/source/Plugins/Process/Windows/Common/NativeRegisterContextWindows_x86_64.cpp
+++ lldb/trunk/source/Plugins/Process/Windows/Common/NativeRegisterContextWindows_x86_64.cpp
@@ -100,11 +100,11 @@
     const ArchSpec &target_arch, NativeThreadProtocol &native_thread) {
   // Register context for a WoW64 application.
   if (target_arch.GetAddressByteSize() == 4)
-    return llvm::make_unique<NativeRegisterContextWindows_WoW64>(target_arch,
+    return std::make_unique<NativeRegisterContextWindows_WoW64>(target_arch,
                                                                  native_thread);
 
   // Register context for a native 64-bit application.
-  return llvm::make_unique<NativeRegisterContextWindows_x86_64>(target_arch,
+  return std::make_unique<NativeRegisterContextWindows_x86_64>(target_arch,
                                                                 native_thread);
 }
 
Index: lldb/trunk/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
===================================================================
--- lldb/trunk/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
+++ lldb/trunk/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
@@ -179,7 +179,7 @@
     FileSpec history_file = GetRoot().CopyByAppendingPathComponent(Info::file);
 
     std::error_code EC;
-    m_stream_up = llvm::make_unique<raw_fd_ostream>(
+    m_stream_up = std::make_unique<raw_fd_ostream>(
         history_file.GetPath(), EC, sys::fs::OpenFlags::OF_Text);
     return m_stream_up.get();
   }
Index: lldb/trunk/source/Plugins/Process/minidump/ProcessMinidump.cpp
===================================================================
--- lldb/trunk/source/Plugins/Process/minidump/ProcessMinidump.cpp
+++ lldb/trunk/source/Plugins/Process/minidump/ProcessMinidump.cpp
@@ -55,7 +55,7 @@
                    /*length*/ 0, /*data_sp*/ nullptr, /*data_offset*/ 0),
         m_arch(module_spec.GetArchitecture()), m_uuid(module_spec.GetUUID()),
         m_base(base), m_size(size) {
-    m_symtab_up = llvm::make_unique<Symtab>(this);
+    m_symtab_up = std::make_unique<Symtab>(this);
   }
 
   ConstString GetPluginName() override { return ConstString("placeholder"); }
@@ -80,7 +80,7 @@
   }
 
   void CreateSections(SectionList &unified_section_list) override {
-    m_sections_up = llvm::make_unique<SectionList>();
+    m_sections_up = std::make_unique<SectionList>();
     auto section_sp = std::make_shared<Section>(
         GetModule(), this, /*sect_id*/ 0, ConstString(".module_image"),
         eSectionTypeOther, m_base, m_size, /*file_offset*/ 0, /*file_size*/ 0,
@@ -444,7 +444,7 @@
 // debug information than needed.
 JITLoaderList &ProcessMinidump::GetJITLoaders() {
   if (!m_jit_loaders_up) {
-    m_jit_loaders_up = llvm::make_unique<JITLoaderList>();
+    m_jit_loaders_up = std::make_unique<JITLoaderList>();
   }
   return *m_jit_loaders_up;
 }
Index: lldb/trunk/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp
===================================================================
--- lldb/trunk/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp
+++ lldb/trunk/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp
@@ -558,7 +558,7 @@
       if (!bp_options)
         continue;
 
-      auto data_up = llvm::make_unique<CommandDataPython>();
+      auto data_up = std::make_unique<CommandDataPython>();
       if (!data_up)
         break;
       data_up->user_source.SplitIntoLines(data);
@@ -583,7 +583,7 @@
   case eIOHandlerWatchpoint: {
     WatchpointOptions *wp_options =
         (WatchpointOptions *)io_handler.GetUserData();
-    auto data_up = llvm::make_unique<WatchpointOptions::CommandData>();
+    auto data_up = std::make_unique<WatchpointOptions::CommandData>();
     data_up->user_source.SplitIntoLines(data);
 
     if (GenerateWatchpointCommandCallbackData(data_up->user_source,
@@ -1290,7 +1290,7 @@
 // Set a Python one-liner as the callback for the breakpoint.
 Status ScriptInterpreterPythonImpl::SetBreakpointCommandCallback(
     BreakpointOptions *bp_options, const char *command_body_text) {
-  auto data_up = llvm::make_unique<CommandDataPython>();
+  auto data_up = std::make_unique<CommandDataPython>();
 
   // Split the command_body_text into lines, and pass that to
   // GenerateBreakpointCommandCallbackData.  That will wrap the body in an
@@ -1313,7 +1313,7 @@
 // Set a Python one-liner as the callback for the watchpoint.
 void ScriptInterpreterPythonImpl::SetWatchpointCommandCallback(
     WatchpointOptions *wp_options, const char *oneliner) {
-  auto data_up = llvm::make_unique<WatchpointOptions::CommandData>();
+  auto data_up = std::make_unique<WatchpointOptions::CommandData>();
 
   // It's necessary to set both user_source and script_source to the oneliner.
   // The former is used to generate callback description (as in watchpoint
Index: lldb/trunk/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.cpp
===================================================================
--- lldb/trunk/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.cpp
+++ lldb/trunk/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.cpp
@@ -590,7 +590,7 @@
          "How did we create compile units without a base address?");
 
   SupportFileMap map;
-  data.line_table_up = llvm::make_unique<LineTable>(&cu);
+  data.line_table_up = std::make_unique<LineTable>(&cu);
   std::unique_ptr<LineSequence> line_seq_up(
       data.line_table_up->CreateLineSequenceContainer());
   llvm::Optional<addr_t> next_addr;
Index: lldb/trunk/source/Plugins/SymbolFile/DWARF/AppleDWARFIndex.cpp
===================================================================
--- lldb/trunk/source/Plugins/SymbolFile/DWARF/AppleDWARFIndex.cpp
+++ lldb/trunk/source/Plugins/SymbolFile/DWARF/AppleDWARFIndex.cpp
@@ -21,30 +21,30 @@
     Module &module, DWARFDataExtractor apple_names,
     DWARFDataExtractor apple_namespaces, DWARFDataExtractor apple_types,
     DWARFDataExtractor apple_objc, DWARFDataExtractor debug_str) {
-  auto apple_names_table_up = llvm::make_unique<DWARFMappedHash::MemoryTable>(
+  auto apple_names_table_up = std::make_unique<DWARFMappedHash::MemoryTable>(
       apple_names, debug_str, ".apple_names");
   if (!apple_names_table_up->IsValid())
     apple_names_table_up.reset();
 
   auto apple_namespaces_table_up =
-      llvm::make_unique<DWARFMappedHash::MemoryTable>(
+      std::make_unique<DWARFMappedHash::MemoryTable>(
           apple_namespaces, debug_str, ".apple_namespaces");
   if (!apple_namespaces_table_up->IsValid())
     apple_namespaces_table_up.reset();
 
-  auto apple_types_table_up = llvm::make_unique<DWARFMappedHash::MemoryTable>(
+  auto apple_types_table_up = std::make_unique<DWARFMappedHash::MemoryTable>(
       apple_types, debug_str, ".apple_types");
   if (!apple_types_table_up->IsValid())
     apple_types_table_up.reset();
 
-  auto apple_objc_table_up = llvm::make_unique<DWARFMappedHash::MemoryTable>(
+  auto apple_objc_table_up = std::make_unique<DWARFMappedHash::MemoryTable>(
       apple_objc, debug_str, ".apple_objc");
   if (!apple_objc_table_up->IsValid())
     apple_objc_table_up.reset();
 
   if (apple_names_table_up || apple_names_table_up || apple_types_table_up ||
       apple_objc_table_up)
-    return llvm::make_unique<AppleDWARFIndex>(
+    return std::make_unique<AppleDWARFIndex>(
         module, std::move(apple_names_table_up),
         std::move(apple_namespaces_table_up), std::move(apple_types_table_up),
         std::move(apple_objc_table_up));
Index: lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.cpp
===================================================================
--- lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.cpp
+++ lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.cpp
@@ -38,7 +38,7 @@
   if (m_cu_aranges_up)
     return *m_cu_aranges_up;
 
-  m_cu_aranges_up = llvm::make_unique<DWARFDebugAranges>();
+  m_cu_aranges_up = std::make_unique<DWARFDebugAranges>();
   const DWARFDataExtractor &debug_aranges_data =
       m_context.getOrLoadArangesData();
   if (llvm::Error error = m_cu_aranges_up->extract(debug_aranges_data))
Index: lldb/trunk/source/Plugins/SymbolFile/DWARF/DebugNamesDWARFIndex.cpp
===================================================================
--- lldb/trunk/source/Plugins/SymbolFile/DWARF/DebugNamesDWARFIndex.cpp
+++ lldb/trunk/source/Plugins/SymbolFile/DWARF/DebugNamesDWARFIndex.cpp
@@ -24,7 +24,7 @@
     return llvm::make_error<llvm::StringError>("debug info null",
                                                llvm::inconvertibleErrorCode());
   }
-  auto index_up = llvm::make_unique<DebugNames>(debug_names.GetAsLLVM(),
+  auto index_up = std::make_unique<DebugNames>(debug_names.GetAsLLVM(),
                                                 debug_str.GetAsLLVM());
   if (llvm::Error E = index_up->extract())
     return std::move(E);
Index: lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp
===================================================================
--- lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp
+++ lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp
@@ -474,7 +474,7 @@
     }
   }
 
-  m_index = llvm::make_unique<ManualDWARFIndex>(*GetObjectFile()->GetModule(),
+  m_index = std::make_unique<ManualDWARFIndex>(*GetObjectFile()->GetModule(),
                                                 DebugInfo());
 }
 
@@ -612,7 +612,7 @@
   if (debug_abbrev_data.GetByteSize() == 0)
     return nullptr;
 
-  auto abbr = llvm::make_unique<DWARFDebugAbbrev>();
+  auto abbr = std::make_unique<DWARFDebugAbbrev>();
   llvm::Error error = abbr->parse(debug_abbrev_data);
   if (error) {
     Log *log = LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO);
@@ -635,7 +635,7 @@
     Timer scoped_timer(func_cat, "%s this = %p", LLVM_PRETTY_FUNCTION,
                        static_cast<void *>(this));
     if (m_context.getOrLoadDebugInfoData().GetByteSize() > 0)
-      m_info = llvm::make_unique<DWARFDebugInfo>(*this, m_context);
+      m_info = std::make_unique<DWARFDebugInfo>(*this, m_context);
   }
   return m_info.get();
 }
@@ -989,7 +989,7 @@
   // into LLDB, we should explore using a callback to populate the line table
   // while we parse to reduce memory usage.
   std::unique_ptr<LineTable> line_table_up =
-      llvm::make_unique<LineTable>(&comp_unit);
+      std::make_unique<LineTable>(&comp_unit);
   LineSequence *sequence = line_table_up->CreateLineSequenceContainer();
   for (auto &row : line_table->Rows) {
     line_table_up->AppendLineEntryToSequence(
@@ -1585,7 +1585,7 @@
   if (dwo_obj_file == nullptr)
     return nullptr;
 
-  return llvm::make_unique<SymbolFileDWARFDwo>(dwo_obj_file, *dwarf_cu);
+  return std::make_unique<SymbolFileDWARFDwo>(dwo_obj_file, *dwarf_cu);
 }
 
 void SymbolFileDWARF::UpdateExternalModuleListIfNeeded() {
Index: lldb/trunk/source/Plugins/SymbolFile/NativePDB/CompileUnitIndex.cpp
===================================================================
--- lldb/trunk/source/Plugins/SymbolFile/NativePDB/CompileUnitIndex.cpp
+++ lldb/trunk/source/Plugins/SymbolFile/NativePDB/CompileUnitIndex.cpp
@@ -130,7 +130,7 @@
 
   if (!stream_data) {
     llvm::pdb::ModuleDebugStreamRef debug_stream(descriptor, nullptr);
-    cci = llvm::make_unique<CompilandIndexItem>(PdbCompilandId{ modi }, debug_stream, std::move(descriptor));
+    cci = std::make_unique<CompilandIndexItem>(PdbCompilandId{ modi }, debug_stream, std::move(descriptor));
     return *cci;
   }
 
@@ -139,7 +139,7 @@
 
   cantFail(debug_stream.reload());
 
-  cci = llvm::make_unique<CompilandIndexItem>(
+  cci = std::make_unique<CompilandIndexItem>(
       PdbCompilandId{modi}, std::move(debug_stream), std::move(descriptor));
   ParseExtendedInfo(m_index, *cci);
 
Index: lldb/trunk/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp
===================================================================
--- lldb/trunk/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp
+++ lldb/trunk/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp
@@ -91,10 +91,10 @@
   std::unique_ptr<llvm::MemoryBuffer> Buffer = std::move(*ErrorOrBuffer);
 
   llvm::StringRef Path = Buffer->getBufferIdentifier();
-  auto Stream = llvm::make_unique<llvm::MemoryBufferByteStream>(
+  auto Stream = std::make_unique<llvm::MemoryBufferByteStream>(
       std::move(Buffer), llvm::support::little);
 
-  auto File = llvm::make_unique<PDBFile>(Path, std::move(Stream), Allocator);
+  auto File = std::make_unique<PDBFile>(Path, std::move(Stream), Allocator);
   if (auto EC = File->parseFileHeaders()) {
     llvm::consumeError(std::move(EC));
     return nullptr;
@@ -333,7 +333,7 @@
     ts_or_err->SetSymbolFile(this);
     auto *clang = llvm::cast_or_null<ClangASTContext>(&ts_or_err.get());
     lldbassert(clang);
-    m_ast = llvm::make_unique<PdbAstBuilder>(*m_objfile_sp, *m_index, *clang);
+    m_ast = std::make_unique<PdbAstBuilder>(*m_objfile_sp, *m_index, *clang);
   }
 }
 
@@ -1068,7 +1068,7 @@
   CompilandIndexItem *cci =
       m_index->compilands().GetCompiland(cu_id.asCompiland().modi);
   lldbassert(cci);
-  auto line_table = llvm::make_unique<LineTable>(&comp_unit);
+  auto line_table = std::make_unique<LineTable>(&comp_unit);
 
   // This is basically a copy of the .debug$S subsections from all original COFF
   // object files merged together with address relocations applied.  We are
Index: lldb/trunk/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp
===================================================================
--- lldb/trunk/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp
+++ lldb/trunk/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp
@@ -1800,7 +1800,7 @@
   // to do a mapping so that we can hand out indices.
   llvm::DenseMap<uint32_t, uint32_t> index_map;
   BuildSupportFileIdToSupportFileIndexMap(*compiland_up, index_map);
-  auto line_table = llvm::make_unique<LineTable>(&comp_unit);
+  auto line_table = std::make_unique<LineTable>(&comp_unit);
 
   // Find contributions to `compiland` from all source and header files.
   std::string path = comp_unit.GetPath();
Index: lldb/trunk/source/Symbol/ClangASTContext.cpp
===================================================================
--- lldb/trunk/source/Symbol/ClangASTContext.cpp
+++ lldb/trunk/source/Symbol/ClangASTContext.cpp
@@ -8444,7 +8444,7 @@
   if (!type)
     return nullptr;
 
-  return llvm::make_unique<clang::CXXBaseSpecifier>(
+  return std::make_unique<clang::CXXBaseSpecifier>(
       clang::SourceRange(), is_virtual, base_of_class,
       ClangASTContext::ConvertAccessTypeToAccessSpecifier(access),
       getASTContext()->getTrivialTypeSourceInfo(GetQualType(type)),
Index: lldb/trunk/source/Target/Platform.cpp
===================================================================
--- lldb/trunk/source/Target/Platform.cpp
+++ lldb/trunk/source/Target/Platform.cpp
@@ -384,7 +384,7 @@
       m_rsync_opts(), m_rsync_prefix(), m_supports_ssh(false), m_ssh_opts(),
       m_ignores_remote_hostname(false), m_trap_handlers(),
       m_calculated_trap_handlers(false),
-      m_module_cache(llvm::make_unique<ModuleCache>()) {
+      m_module_cache(std::make_unique<ModuleCache>()) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
   LLDB_LOGF(log, "%p Platform::Platform()", static_cast<void *>(this));
 }
Index: lldb/trunk/source/Utility/Reproducer.cpp
===================================================================
--- lldb/trunk/source/Utility/Reproducer.cpp
+++ lldb/trunk/source/Utility/Reproducer.cpp
@@ -175,7 +175,7 @@
   index.AppendPathComponent("index.yaml");
 
   std::error_code EC;
-  auto strm = llvm::make_unique<raw_fd_ostream>(index.GetPath(), EC,
+  auto strm = std::make_unique<raw_fd_ostream>(index.GetPath(), EC,
                                                 sys::fs::OpenFlags::OF_None);
   yaml::Output yout(*strm);
 
@@ -223,7 +223,7 @@
 llvm::Expected<std::unique_ptr<DataRecorder>>
 DataRecorder::Create(const FileSpec &filename) {
   std::error_code ec;
-  auto recorder = llvm::make_unique<DataRecorder>(std::move(filename), ec);
+  auto recorder = std::make_unique<DataRecorder>(std::move(filename), ec);
   if (ec)
     return llvm::errorCodeToError(ec);
   return std::move(recorder);
Index: lldb/trunk/source/Utility/StructuredData.cpp
===================================================================
--- lldb/trunk/source/Utility/StructuredData.cpp
+++ lldb/trunk/source/Utility/StructuredData.cpp
@@ -47,7 +47,7 @@
 static StructuredData::ObjectSP ParseJSONObject(JSONParser &json_parser) {
   // The "JSONParser::Token::ObjectStart" token should have already been
   // consumed by the time this function is called
-  auto dict_up = llvm::make_unique<StructuredData::Dictionary>();
+  auto dict_up = std::make_unique<StructuredData::Dictionary>();
 
   std::string value;
   std::string key;
@@ -78,7 +78,7 @@
 static StructuredData::ObjectSP ParseJSONArray(JSONParser &json_parser) {
   // The "JSONParser::Token::ObjectStart" token should have already been
   // consumed by the time this function is called
-  auto array_up = llvm::make_unique<StructuredData::Array>();
+  auto array_up = std::make_unique<StructuredData::Array>();
 
   std::string value;
   std::string key;
Index: lldb/trunk/tools/lldb-instr/Instrument.cpp
===================================================================
--- lldb/trunk/tools/lldb-instr/Instrument.cpp
+++ lldb/trunk/tools/lldb-instr/Instrument.cpp
@@ -335,7 +335,7 @@
   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
                                                  StringRef File) override {
     MyRewriter.setSourceMgr(CI.getSourceManager(), CI.getLangOpts());
-    return llvm::make_unique<SBConsumer>(MyRewriter, CI.getASTContext());
+    return std::make_unique<SBConsumer>(MyRewriter, CI.getASTContext());
   }
 
 private:
@@ -348,8 +348,8 @@
                          "instrumentation framework.");
 
   auto PCHOpts = std::make_shared<PCHContainerOperations>();
-  PCHOpts->registerWriter(llvm::make_unique<ObjectFilePCHContainerWriter>());
-  PCHOpts->registerReader(llvm::make_unique<ObjectFilePCHContainerReader>());
+  PCHOpts->registerWriter(std::make_unique<ObjectFilePCHContainerWriter>());
+  PCHOpts->registerReader(std::make_unique<ObjectFilePCHContainerReader>());
 
   ClangTool T(OP.getCompilations(), OP.getSourcePathList(), PCHOpts);
   return T.run(newFrontendActionFactory<SBAction>().get());
Index: lldb/trunk/tools/lldb-server/lldb-server.cpp
===================================================================
--- lldb/trunk/tools/lldb-server/lldb-server.cpp
+++ lldb/trunk/tools/lldb-server/lldb-server.cpp
@@ -39,7 +39,7 @@
 namespace llgs {
 static void initialize() {
   if (auto e = g_debugger_lifetime->Initialize(
-          llvm::make_unique<SystemInitializerLLGS>(), nullptr))
+          std::make_unique<SystemInitializerLLGS>(), nullptr))
     llvm::consumeError(std::move(e));
 }
 
Index: lldb/trunk/tools/lldb-test/lldb-test.cpp
===================================================================
--- lldb/trunk/tools/lldb-test/lldb-test.cpp
+++ lldb/trunk/tools/lldb-test/lldb-test.cpp
@@ -969,7 +969,7 @@
 
   SystemLifetimeManager DebuggerLifetime;
   if (auto e = DebuggerLifetime.Initialize(
-          llvm::make_unique<SystemInitializerTest>(), nullptr)) {
+          std::make_unique<SystemInitializerTest>(), nullptr)) {
     WithColor::error() << "initialization failed: " << toString(std::move(e))
                        << '\n';
     return 1;
Index: lldb/trunk/unittests/Host/MainLoopTest.cpp
===================================================================
--- lldb/trunk/unittests/Host/MainLoopTest.cpp
+++ lldb/trunk/unittests/Host/MainLoopTest.cpp
@@ -110,7 +110,7 @@
   PseudoTerminal term;
   ASSERT_TRUE(term.OpenFirstAvailableMaster(O_RDWR, nullptr, 0));
   ASSERT_TRUE(term.OpenSlave(O_RDWR | O_NOCTTY, nullptr, 0));
-  auto conn = llvm::make_unique<ConnectionFileDescriptor>(
+  auto conn = std::make_unique<ConnectionFileDescriptor>(
       term.ReleaseMasterFileDescriptor(), true);
 
   Status error;
Index: lldb/trunk/unittests/Process/minidump/RegisterContextMinidumpTest.cpp
===================================================================
--- lldb/trunk/unittests/Process/minidump/RegisterContextMinidumpTest.cpp
+++ lldb/trunk/unittests/Process/minidump/RegisterContextMinidumpTest.cpp
@@ -51,7 +51,7 @@
                                      sizeof(Context));
 
   ArchSpec arch("i386-pc-linux");
-  auto RegInterface = llvm::make_unique<RegisterContextLinux_i386>(arch);
+  auto RegInterface = std::make_unique<RegisterContextLinux_i386>(arch);
   lldb::DataBufferSP Buf =
       ConvertMinidumpContext_x86_32(ContextRef, RegInterface.get());
   ASSERT_EQ(RegInterface->GetGPRSize(), Buf->GetByteSize());
@@ -112,7 +112,7 @@
                                      sizeof(Context));
 
   ArchSpec arch("x86_64-pc-linux");
-  auto RegInterface = llvm::make_unique<RegisterContextLinux_x86_64>(arch);
+  auto RegInterface = std::make_unique<RegisterContextLinux_x86_64>(arch);
   lldb::DataBufferSP Buf =
       ConvertMinidumpContext_x86_64(ContextRef, RegInterface.get());
   ASSERT_EQ(RegInterface->GetGPRSize(), Buf->GetByteSize());
Index: lldb/trunk/unittests/tools/lldb-server/tests/MessageObjects.cpp
===================================================================
--- lldb/trunk/unittests/tools/lldb-server/tests/MessageObjects.cpp
+++ lldb/trunk/unittests/tools/lldb-server/tests/MessageObjects.cpp
@@ -319,7 +319,7 @@
   if (!RegistersOr)
     return RegistersOr.takeError();
 
-  return llvm::make_unique<StopReplyStop>(Signal, Thread, Name,
+  return std::make_unique<StopReplyStop>(Signal, Thread, Name,
                                           std::move(ThreadPcs),
                                           std::move(*RegistersOr), Reason);
 }
@@ -329,7 +329,7 @@
   uint8_t Status;
   if (!to_integer(Response, Status, 16))
     return make_parsing_error("StopReply: exit status");
-  return llvm::make_unique<StopReplyExit>(Status);
+  return std::make_unique<StopReplyExit>(Status);
 }
 
 //====== Globals ===============================================================
Index: lldb/trunk/unittests/tools/lldb-server/tests/TestClient.cpp
===================================================================
--- lldb/trunk/unittests/tools/lldb-server/tests/TestClient.cpp
+++ lldb/trunk/unittests/tools/lldb-server/tests/TestClient.cpp
@@ -111,7 +111,7 @@
 
   Socket *accept_socket;
   listen_socket.Accept(accept_socket);
-  auto Conn = llvm::make_unique<ConnectionFileDescriptor>(accept_socket);
+  auto Conn = std::make_unique<ConnectionFileDescriptor>(accept_socket);
   auto Client = std::unique_ptr<TestClient>(new TestClient(std::move(Conn)));
 
   if (Error E = Client->initializeConnection())