Migrate llvm::make_unique to std::make_unique

[JDevlieghere]

Summary

Now that we've moved to C++14, we no longer need the llvm::make_unique implementation from STLExtras.h. This patch is a mechanical replacement of (hopefully) all the llvm::make_unique instances across the monorepo.

I've omitted context given the size of this diff.

[JDevlieghere]

Remove whitespace related changes.

[jfb]

llvm/include/llvm/ADT/STLExtras.h

1429 ↗

(On Diff #215256)

This is used in NativeRegisterContextLinux_x86_64.h

[JDevlieghere]

Don't remove FreeDeleter

[jfb]

Thanks!

[jfb]

BTW, if this breaks stuff maybe it's better to do it one project at a time, and remove the helper at the very end.

[JDevlieghere]

In D66259#1630454, @jfb wrote:

BTW, if this breaks stuff maybe it's better to do it one project at a time, and remove the helper at the very end.

Yep, that sounds like a good approach. Removing the helper was useful for finding cases my regex missed :-)

llvm/include/llvm/ADT/STLExtras.h

1429 ↗

(On Diff #215256)

Good catch!

[thakis]

It looks like this breaks building with gcc5.1:

/b/s/w/ir/cache/builder/src/third_party/llvm-build-tools/gcc510trusty/bin/g++  -DGTEST_HAS_RTTI=0 -D_DEBUG -D_GNU_SOURCE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -Itools/lld/ELF -I/b/s/w/ir/cache/builder/src/third_party/llvm/lld/ELF -I/b/s/w/ir/cache/builder/src/third_party/llvm/lld/include -Itools/lld/include -I/usr/include/libxml2 -Iinclude -I/b/s/w/ir/cache/builder/src/third_party/llvm/llvm/include -DLLVM_FORCE_HEAD_REVISION -fvisibility-inlines-hidden -Werror=date-time -std=c++14 -Wall -Wextra -Wno-unused-parameter -Wwrite-strings -Wcast-qual -Wno-missing-field-initializers -pedantic -Wno-long-long -Wno-maybe-uninitialized -Wdelete-non-virtual-dtor -Wno-comment -fdiagnostics-color -ffunction-sections -fdata-sections -O3    -UNDEBUG  -fno-exceptions -fno-unwind-tables -fno-asynchronous-unwind-tables -fno-rtti -MD -MT tools/lld/ELF/CMakeFiles/lldELF.dir/LinkerScript.cpp.o -MF tools/lld/ELF/CMakeFiles/lldELF.dir/LinkerScript.cpp.o.d -o tools/lld/ELF/CMakeFiles/lldELF.dir/LinkerScript.cpp.o -c /b/s/w/ir/cache/builder/src/third_party/llvm/lld/ELF/LinkerScript.cpp
In file included from /b/s/w/ir/cache/builder/src/third_party/llvm-build-tools/gcc510trusty/include/c++/5.1.0/bits/stl_algobase.h:71:0,
                 from /b/s/w/ir/cache/builder/src/third_party/llvm-build-tools/gcc510trusty/include/c++/5.1.0/memory:62,
                 from /b/s/w/ir/cache/builder/src/third_party/llvm/llvm/include/llvm/ADT/Optional.h:22,
                 from /b/s/w/ir/cache/builder/src/third_party/llvm/llvm/include/llvm/ADT/STLExtras.h:19,
                 from /b/s/w/ir/cache/builder/src/third_party/llvm/llvm/include/llvm/ADT/StringRef.h:12,
                 from /b/s/w/ir/cache/builder/src/third_party/llvm/llvm/include/llvm/ADT/StringMap.h:16,
                 from /b/s/w/ir/cache/builder/src/third_party/llvm/llvm/include/llvm/Support/Host.h:16,
                 from /b/s/w/ir/cache/builder/src/third_party/llvm/llvm/include/llvm/ADT/Hashing.h:48,
                 from /b/s/w/ir/cache/builder/src/third_party/llvm/lld/include/lld/Common/LLVM.h:19,
                 from /b/s/w/ir/cache/builder/src/third_party/llvm/lld/include/lld/Common/ErrorHandler.h:71,
                 from /b/s/w/ir/cache/builder/src/third_party/llvm/lld/ELF/Config.h:12,
                 from /b/s/w/ir/cache/builder/src/third_party/llvm/lld/ELF/LinkerScript.h:12,
                 from /b/s/w/ir/cache/builder/src/third_party/llvm/lld/ELF/LinkerScript.cpp:13:
/b/s/w/ir/cache/builder/src/third_party/llvm-build-tools/gcc510trusty/include/c++/5.1.0/bits/predefined_ops.h: In instantiation of ‘constexpr bool __gnu_cxx::__ops::_Iter_comp_iter<_Compare>::operator()(_Iterator1, _Iterator2) [with _Iterator1 = lld::elf::InputSectionBase*; _Iterator2 = lld::elf::InputSectionBase*; _Compare = std::function<bool(lld::elf::InputSectionBase*, lld::elf::InputSectionBase*)>]’:
/b/s/w/ir/cache/builder/src/third_party/llvm-build-tools/gcc510trusty/include/c++/5.1.0/functional:1982:6:   required by substitution of ‘template<class _Res, class ... _ArgTypes> template<class _Functor> using _Invoke = decltype (std::__callable_functor(declval<_Functor&>())((declval<_ArgTypes>)()...)) [with _Functor = __gnu_cxx::__ops::_Iter_comp_iter<std::function<bool(lld::elf::InputSectionBase*, lld::elf::InputSectionBase*)> >; _Res = bool; _ArgTypes = {lld::elf::InputSectionBase*, lld::elf::InputSectionBase*}]’
/b/s/w/ir/cache/builder/src/third_party/llvm-build-tools/gcc510trusty/include/c++/5.1.0/functional:1992:56:   required by substitution of ‘template<class _Res, class ... _ArgTypes> template<class _Functor> using _Callable = std::__and_<std::function<_Res(_ArgTypes ...)>::_NotSelf<_Functor>, std::__check_func_return_type<std::function<_Res(_ArgTypes ...)>::_Invoke<_Functor>, _Res> > [with _Functor = __gnu_cxx::__ops::_Iter_comp_iter<std::function<bool(lld::elf::InputSectionBase*, lld::elf::InputSectionBase*)> >; _Res = bool; _ArgTypes = {lld::elf::InputSectionBase*, lld::elf::InputSectionBase*}]’
/b/s/w/ir/cache/builder/src/third_party/llvm-build-tools/gcc510trusty/include/c++/5.1.0/functional:2057:9:   required by substitution of ‘template<class _Functor, class> std::function<_Res(_ArgTypes ...)>::function(_Functor) [with _Functor = __gnu_cxx::__ops::_Iter_comp_iter<std::function<bool(lld::elf::InputSectionBase*, lld::elf::InputSectionBase*)> >; <template-parameter-1-2> = <missing>]’
/b/s/w/ir/cache/builder/src/third_party/llvm-build-tools/gcc510trusty/include/c++/5.1.0/bits/predefined_ops.h:130:46:   required from ‘constexpr __gnu_cxx::__ops::_Iter_comp_iter<_Compare> __gnu_cxx::__ops::__iter_comp_iter(_Compare) [with _Compare = std::function<bool(lld::elf::InputSectionBase*, lld::elf::InputSectionBase*)>]’
/b/s/w/ir/cache/builder/src/third_party/llvm-build-tools/gcc510trusty/include/c++/5.1.0/bits/stl_algo.h:4933:43:   required from ‘void std::stable_sort(_RAIter, _RAIter, _Compare) [with _RAIter = lld::elf::InputSection**; _Compare = std::function<bool(lld::elf::InputSectionBase*, lld::elf::InputSectionBase*)>]’
/b/s/w/ir/cache/builder/src/third_party/llvm/llvm/include/llvm/ADT/STLExtras.h:1322:19:   required from ‘void llvm::stable_sort(R&&, Compare) [with R = llvm::MutableArrayRef<lld::elf::InputSection*>&; Compare = std::function<bool(lld::elf::InputSectionBase*, lld::elf::InputSectionBase*)>]’
/b/s/w/ir/cache/builder/src/third_party/llvm/lld/ELF/LinkerScript.cpp:347:44:   required from here
/b/s/w/ir/cache/builder/src/third_party/llvm-build-tools/gcc510trusty/include/c++/5.1.0/bits/predefined_ops.h:123:46: error: no match for call to ‘(std::function<bool(lld::elf::InputSectionBase*, lld::elf::InputSectionBase*)>) (lld::elf::InputSectionBase&, lld::elf::InputSectionBase&)’
         { return bool(_M_comp(*__it1, *__it2)); }
                                              ^
In file included from /b/s/w/ir/cache/builder/src/third_party/llvm-build-tools/gcc510trusty/include/c++/5.1.0/memory:79:0,
                 from /b/s/w/ir/cache/builder/src/third_party/llvm/llvm/include/llvm/ADT/Optional.h:22,
                 from /b/s/w/ir/cache/builder/src/third_party/llvm/llvm/include/llvm/ADT/STLExtras.h:19,
                 from /b/s/w/ir/cache/builder/src/third_party/llvm/llvm/include/llvm/ADT/StringRef.h:12,
                 from /b/s/w/ir/cache/builder/src/third_party/llvm/llvm/include/llvm/ADT/StringMap.h:16,
                 from /b/s/w/ir/cache/builder/src/third_party/llvm/llvm/include/llvm/Support/Host.h:16,
                 from /b/s/w/ir/cache/builder/src/third_party/llvm/llvm/include/llvm/ADT/Hashing.h:48,
                 from /b/s/w/ir/cache/builder/src/third_party/llvm/lld/include/lld/Common/LLVM.h:19,
                 from /b/s/w/ir/cache/builder/src/third_party/llvm/lld/include/lld/Common/ErrorHandler.h:71,
                 from /b/s/w/ir/cache/builder/src/third_party/llvm/lld/ELF/Config.h:12,
                 from /b/s/w/ir/cache/builder/src/third_party/llvm/lld/ELF/LinkerScript.h:12,
                 from /b/s/w/ir/cache/builder/src/third_party/llvm/lld/ELF/LinkerScript.cpp:13:
/b/s/w/ir/cache/builder/src/third_party/llvm-build-tools/gcc510trusty/include/c++/5.1.0/functional:2266:5: note: candidate: _Res std::function<_Res(_ArgTypes ...)>::operator()(_ArgTypes ...) const [with _Res = bool; _ArgTypes = {lld::elf::InputSectionBase*, lld::elf::InputSectionBase*}]
     function<_Res(_ArgTypes...)>::
     ^
/b/s/w/ir/cache/builder/src/third_party/llvm-build-tools/gcc510trusty/include/c++/5.1.0/functional:2266:5: note:   no known conversion for argument 1 from ‘lld::elf::InputSectionBase’ to ‘lld::elf::InputSectionBase*’

[thakis]

Sorry, wrong patch, looks like this is actually due to D66195

[jwakely]

In D66259#1631586, @thakis wrote:

It looks like this breaks building with gcc5.1:

Why are you using 5.1? That's dumb. There are tons of bugs in 5.1 that are fixed in later 5.x releases, especially if you're using C++14.

That's a really bad choice of minimum version to insist on supporting.

Source: me, because I broke lots of stuff in 5.1 and then fixed it.

[jfb]

In D66259#1631802, @jwakely wrote:

In D66259#1631586, @thakis wrote:

It looks like this breaks building with gcc5.1:

Why are you using 5.1? That's dumb. There are tons of bugs in 5.1 that are fixed in later 5.x releases, especially if you're using C++14.

That's a really bad choice of minimum version to insist on supporting.

Source: me, because I broke lots of stuff in 5.1 and then fixed it.

I'll bring this up on the list and suggest we move to 5.5 as you suggested privately.

[jwakely]

FWIW I think this particular bug was https://gcc.gnu.org/PR65942

[jfb]

In D66259#1632052, @jwakely wrote:

FWIW I think this particular bug was https://gcc.gnu.org/PR65942

Indeed, thanks for the reference!

lldb/trunk/include/lldb/Utility/Reproducer.h

public:
 
   /// Method to indicate we do not want to keep the reproducer. This is
   /// unaffected by whether or not generation reproduction is enabled, as we
   /// might need to clean up files already written to disk.
   void Discard();
 
   /// 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)));
   }
 
   /// Get an existing provider.
   template <typename T> T *Get() {
     auto it = m_providers.find(T::ClassID());
     if (it == m_providers.end())
       return nullptr;

lldb/trunk/include/lldb/Utility/ReproducerInstrumentation.h

public:
   Registry() = default;
   virtual ~Registry() = default;
 
   /// Register a default replayer for a function.
   template <typename Signature>
   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));
   }
 
   /// Register a replayer that invokes a custom function with the same
   /// signature as the replayed function.
   template <typename Signature>
   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));
   }
 
   /// Replay functions from a file.
   bool Replay(const FileSpec &file);
 
   /// Replay functions from a buffer.
   bool Replay(llvm::StringRef buffer);

lldb/trunk/source/API/SBAddress.cpp

 
 SBAddress::SBAddress() : m_opaque_up(new Address()) {
   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBAddress);
 }
 
 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()) {
   LLDB_RECORD_CONSTRUCTOR(SBAddress, (const lldb::SBAddress &), rhs);
 
   m_opaque_up = clone(rhs.m_opaque_up);
 }
 

lldb/trunk/source/API/SBBreakpointOptionCommon.cpp

 #include "llvm/ADT/STLExtras.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 SBBreakpointCallbackBaton::SBBreakpointCallbackBaton(SBBreakpointHitCallback 
                                                          callback,
                                                      void *baton)
-      : TypedBaton(llvm::make_unique<CallbackData>()) {
+      : TypedBaton(std::make_unique<CallbackData>()) {
     getItem()->callback = callback;
     getItem()->callback_baton = baton;
   }
 
  bool SBBreakpointCallbackBaton::PrivateBreakpointHitCallback(void *baton,
                                                   StoppointCallbackContext *ctx,
                                                   lldb::user_id_t break_id,
                                                   lldb::user_id_t break_loc_id)

lldb/trunk/source/API/SBDebugger.cpp

if (auto err = yin.error())
       return {};
 
     for (auto &file : files) {
       FileSpec absolute_path =
           loader->GetRoot().CopyByAppendingPathComponent(file);
       file = absolute_path.GetPath();
     }
 
-    return llvm::make_unique<CommandLoader>(std::move(files));
+    return std::make_unique<CommandLoader>(std::move(files));
   }
 
   FILE *GetNextFile() {
     if (m_index >= m_files.size())
       return nullptr;
     return FileSystem::Instance().Fopen(m_files[m_index++].c_str(), "r");
   }
 

 lldb::SBError SBDebugger::InitializeWithErrorHandling() {
   LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBError, SBDebugger,
                                     InitializeWithErrorHandling);
 
 
 
   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);
 }
 
 void SBDebugger::Terminate() {
   LLDB_RECORD_STATIC_METHOD_NO_ARGS(void, SBDebugger, Terminate);
 
LLDB_RECORD_STATIC_METHOD(const char *, SBDebugger, StateAsCString,
                             (lldb::StateType), state);
 
   return lldb_private::StateAsCString(state);
 }
 
 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));
 }
 
 SBStructuredData SBDebugger::GetBuildConfiguration() {
   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");
   AddLLVMTargets(*config_up);
 
   SBStructuredData data;
   data.m_impl_up->SetObjectSP(std::move(config_up));
   return LLDB_RECORD_RESULT(data);
uint32_t SBDebugger::GetNumAvailablePlatforms() {
   return idx + 1;
 }
 
 SBStructuredData SBDebugger::GetAvailablePlatformInfoAtIndex(uint32_t idx) {
   LLDB_RECORD_METHOD(lldb::SBStructuredData, SBDebugger,
                      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) {
     PlatformSP host_platform_sp(Platform::GetHostPlatform());
     platform_dict->AddStringItem(
         name_str, host_platform_sp->GetPluginName().GetStringRef());
     platform_dict->AddStringItem(
         desc_str, llvm::StringRef(host_platform_sp->GetDescription()));

lldb/trunk/source/API/SBDeclaration.cpp

SBDeclaration::SBDeclaration(const SBDeclaration &rhs) : m_opaque_up() {
   LLDB_RECORD_CONSTRUCTOR(SBDeclaration, (const lldb::SBDeclaration &), rhs);
 
   m_opaque_up = clone(rhs.m_opaque_up);
 }
 
 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) {
   LLDB_RECORD_METHOD(const lldb::SBDeclaration &,
                      SBDeclaration, operator=,(const lldb::SBDeclaration &),
                      rhs);
 
   if (this != &rhs)

lldb/trunk/source/API/SBFrame.cpp

if (target && process) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&process->GetRunLock())) {
       frame = exe_ctx.GetFramePtr();
       if (frame) {
         std::unique_ptr<llvm::PrettyStackTraceFormat> stack_trace;
         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(),
               frame_description.GetData());
         }
 
         target->EvaluateExpression(expr, frame, expr_value_sp, options.ref());
         expr_result.SetSP(expr_value_sp, options.GetFetchDynamicValue());

lldb/trunk/source/API/SBLineEntry.cpp

SBLineEntry::SBLineEntry(const SBLineEntry &rhs) : m_opaque_up() {
   LLDB_RECORD_CONSTRUCTOR(SBLineEntry, (const lldb::SBLineEntry &), rhs);
 
   m_opaque_up = clone(rhs.m_opaque_up);
 }
 
 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) {
   LLDB_RECORD_METHOD(const lldb::SBLineEntry &,
                      SBLineEntry, operator=,(const lldb::SBLineEntry &), rhs);
 
   if (this != &rhs)
     m_opaque_up = clone(rhs.m_opaque_up);
   return LLDB_RECORD_RESULT(*this);
 }
 
 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() {}
 
 SBAddress SBLineEntry::GetStartAddress() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBLineEntry,
                                    GetStartAddress);
 

lldb/trunk/source/API/SBStringList.cpp

 
 SBStringList::SBStringList() : m_opaque_up() {
   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBStringList);
 }
 
 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() {
   LLDB_RECORD_CONSTRUCTOR(SBStringList, (const lldb::SBStringList &), rhs);
 
   m_opaque_up = clone(rhs.m_opaque_up);
 }
 

lldb/trunk/source/API/SBSymbolContext.cpp

SBSymbolContext::SBSymbolContext() : m_opaque_up() {
   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBSymbolContext);
 }
 
 SBSymbolContext::SBSymbolContext(const SymbolContext *sc_ptr) : m_opaque_up() {
   LLDB_RECORD_CONSTRUCTOR(SBSymbolContext,
                           (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() {
   LLDB_RECORD_CONSTRUCTOR(SBSymbolContext, (const lldb::SBSymbolContext &),
                           rhs);
 
   m_opaque_up = clone(rhs.m_opaque_up);
 }
 
 SBSymbolContext::~SBSymbolContext() {}
 
 const SBSymbolContext &SBSymbolContext::operator=(const SBSymbolContext &rhs) {
   LLDB_RECORD_METHOD(const lldb::SBSymbolContext &,
                      SBSymbolContext, operator=,(const lldb::SBSymbolContext &),
                      rhs);
 
   if (this != &rhs)
     m_opaque_up = clone(rhs.m_opaque_up);
   return LLDB_RECORD_RESULT(*this);
 }
 
 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);
 }
 
 bool SBSymbolContext::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbolContext, IsValid);
   return this->operator bool();
 }

lldb/trunk/source/API/SBTarget.cpp

 SBStructuredData SBTarget::GetStatistics() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBStructuredData, SBTarget, GetStatistics);
 
   SBStructuredData data;
   TargetSP target_sp(GetSP());
   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(
         static_cast<lldb_private::StatisticKind>(i));
     stats_up->AddIntegerItem(Desc, Entry);
     i += 1;
   }
 

lldb/trunk/source/API/Utils.h

 
 #include "llvm/ADT/STLExtras.h"
 #include <memory>
 
 namespace lldb_private {
 
 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;
 }
 
 template <typename T> std::shared_ptr<T> clone(const std::shared_ptr<T> &src) {
   if (src)
     return std::make_shared<T>(*src);
   return nullptr;
 }
 
 } // namespace lldb_private
 #endif

lldb/trunk/source/Breakpoint/BreakpointOptions.cpp

if (success && cmds_dict) {
     if (cmds_error.Fail()) {
       error.SetErrorStringWithFormat(
           "Failed to deserialize breakpoint command options: %s.",
           cmds_error.AsCString());
       return nullptr;
     }
   }
 
-  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) {
     if (cmd_data_up->interpreter == eScriptLanguageNone)
       bp_options->SetCommandDataCallback(cmd_data_up);
     else {
       ScriptInterpreter *interp = target.GetDebugger().GetScriptInterpreter();
       if (!interp) {

lldb/trunk/source/Commands/CommandObjectBreakpoint.cpp

void OptionParsingStarting(ExecutionContext *execution_context) override {
     m_commands.clear();
   }
   
   Status OptionParsingFinished(ExecutionContext *execution_context) override {
     if (!m_commands.empty())
     {
       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); 
 
           cmd_data->stop_on_error = true;
           m_bp_opts.SetCommandDataCallback(cmd_data);
       }
     }

lldb/trunk/source/Commands/CommandObjectBreakpointCommand.cpp

void IOHandlerInputComplete(IOHandler &io_handler,
     io_handler.SetIsDone(true);
 
     std::vector<BreakpointOptions *> *bp_options_vec =
         (std::vector<BreakpointOptions *> *)io_handler.GetUserData();
     for (BreakpointOptions *bp_options : *bp_options_vec) {
       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);
     }
   }
 
   void CollectDataForBreakpointCommandCallback(
       std::vector<BreakpointOptions *> &bp_options_vec,
       CommandReturnObject &result) {
     m_interpreter.GetLLDBCommandsFromIOHandler(
         "> ",             // Prompt
         *this,            // IOHandlerDelegate
         true,             // Run IOHandler in async mode
         &bp_options_vec); // Baton for the "io_handler" that will be passed back
                           // into our IOHandlerDelegate functions
   }
 
   /// Set a one-liner as the callback for the breakpoint.
   void
   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;
 
       bp_options->SetCommandDataCallback(cmd_data);
     }
   }
 

lldb/trunk/source/Commands/CommandObjectCommands.cpp

if (argc == 0) {
       result.AppendError("usage: 'command regex <command-name> "
                          "[s/<regex1>/<subst1>/ s/<regex2>/<subst2>/ ...]'\n");
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     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);
 
     if (argc == 1) {
       Debugger &debugger = GetDebugger();
       bool color_prompt = debugger.GetUseColor();
       const bool multiple_lines = true; // Get multiple lines
       IOHandlerSP io_handler_sp(new IOHandlerEditline(

lldb/trunk/source/Core/Debugger.cpp

if (error.Success()) {
     // FIXME it would be nice to have "on-change" callbacks for properties
     if (property_path == g_debugger_properties[ePropertyPrompt].name) {
       llvm::StringRef new_prompt = GetPrompt();
       std::string str = lldb_utility::ansi::FormatAnsiTerminalCodes(
           new_prompt, GetUseColor());
       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);
     } else if (property_path == g_debugger_properties[ePropertyUseColor].name) {
       // use-color changed. Ping the prompt so it can reset the ansi terminal
       // codes.
       SetPrompt(GetPrompt());
     } else if (is_load_script && target_sp &&
: UserID(g_unique_id++),
       m_output_file_sp(std::make_shared<StreamFile>(stdout, false)),
       m_error_file_sp(std::make_shared<StreamFile>(stderr, false)),
       m_input_recorder(nullptr),
       m_broadcaster_manager_sp(BroadcasterManager::MakeBroadcasterManager()),
       m_terminal_state(), m_target_list(*this), m_platform_list(),
       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"),
       m_forward_listener_sp(), m_clear_once() {
   char instance_cstr[256];
   snprintf(instance_cstr, sizeof(instance_cstr), "debugger_%d", (int)GetID());
   m_instance_name.SetCString(instance_cstr);
   if (log_callback)
m_script_interpreter_sp = PluginManager::GetScriptInterpreterForLanguage(
         GetScriptLanguage(), *this);
   }
 
   return m_script_interpreter_sp.get();
 }
 
 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;
 }
 
 // This function handles events that were broadcast by the process.
 void Debugger::HandleBreakpointEvent(const EventSP &event_sp) {
   using namespace lldb;
   const uint32_t event_type =
       Breakpoint::BreakpointEventData::GetBreakpointEventTypeFromEvent(

lldb/trunk/source/Core/Module.cpp

ObjectFile *Module::GetMemoryObjectFile(const lldb::ProcessSP &process_sp,
                                         lldb::addr_t header_addr, Status &error,
                                         size_t size_to_read) {
   if (m_objfile_sp) {
     error.SetErrorString("object file already exists");
   } else {
     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(),
                                  data_up->GetByteSize(), readmem_error);
       if (bytes_read == size_to_read) {
         DataBufferSP data_sp(data_up.release());
         m_objfile_sp = ObjectFile::FindPlugin(shared_from_this(), process_sp,
                                               header_addr, data_sp);

 UnwindTable &Module::GetUnwindTable() {
   if (!m_unwind_table)
     m_unwind_table.emplace(*this);
   return *m_unwind_table;
 }
 
 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();
 }
 
 const Symbol *Module::FindFirstSymbolWithNameAndType(ConstString name,
                                                      SymbolType symbol_type) {
   static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(
       func_cat, "Module::FindFirstSymbolWithNameAndType (name = %s, type = %i)",

lldb/trunk/source/Core/ValueObjectSyntheticFilter.cpp

if (type.IsValid() && type.IsPointerOrReferenceType())
       Status error;
       lldb::ValueObjectSP deref_sp = m_parent->Dereference(error);
       if (error.Success())
         valobj_for_frontend = deref_sp.get();
     }
   }
   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() {
   Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_DATAFORMATTERS);
 
   SetValueIsValid(false);
   m_error.Clear();
 

lldb/trunk/source/Expression/IRExecutionUnit.cpp

public:
     getObject(const llvm::Module *module) override {
       // Return nothing - we're just abusing the object-cache mechanism to dump
       // objects.
       return nullptr;
     }
   };
 
   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());
   }
 
   // Make sure we see all sections, including ones that don't have
   // relocations...
   m_execution_engine_up->setProcessAllSections(true);
 
   m_execution_engine_up->DisableLazyCompilation();

lldb/trunk/source/Host/common/Socket.cpp

std::unique_ptr<Socket> Socket::Create(const SocketProtocol protocol,
                                        bool child_processes_inherit,
                                        Status &error) {
   error.Clear();
 
   std::unique_ptr<Socket> socket_up;
   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.");
 #endif
     break;
   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.");
 #endif
     break;
   }
 
   if (error.Fail())

lldb/trunk/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp

if (m_dyld_bid != LLDB_INVALID_BREAK_ID) {
     m_dyld_bid = LLDB_INVALID_BREAK_ID;
   }
 }
 
 void DynamicLoaderPOSIXDYLD::DidAttach() {
   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",
       __FUNCTION__, m_process ? m_process->GetID() : LLDB_INVALID_PROCESS_ID);
 
   // ask the process if it can load any of its own modules
   auto error = m_process->LoadModules();
   LLDB_LOG_ERROR(log, std::move(error), "Couldn't load modules: {0}");

 
 void DynamicLoaderPOSIXDYLD::DidLaunch() {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
   LLDB_LOGF(log, "DynamicLoaderPOSIXDYLD::%s()", __FUNCTION__);
 
   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();
   EvalSpecialModulesStatus();
 
   if (executable.get() && load_offset != LLDB_INVALID_ADDRESS) {
     ModuleList module_list;
     module_list.Append(executable);

lldb/trunk/source/Plugins/ExpressionParser/Clang/ClangASTSource.cpp

if (!is_shared_context) {
       sources.push_back({*scratch_ast_context->getASTContext(),
                          *scratch_ast_context->getFileManager(),
                          scratch_ast_context->GetOriginMap()});
     }
     while (false)
       ;
 
     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);
   }
 }
 
 ClangASTSource::~ClangASTSource() {
   if (m_ast_importer_sp)
     m_ast_importer_sp->ForgetDestination(m_ast_context);

lldb/trunk/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.h

private:
     DISALLOW_COPY_AND_ASSIGN(ParserVars);
   };
 
   std::unique_ptr<ParserVars> m_parser_vars;
 
   /// 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
   void DisableParserVars() { m_parser_vars.reset(); }
 
   /// The following values contain layout information for the materialized
   /// struct, but are not specific to a single materialization
   struct StructVars {

lldb/trunk/source/Plugins/Language/ObjC/NSDictionary.h

public:
       ~Full() override = default;
       bool Match(ConstString class_name) override;
 
     private:
       ConstString m_name;
     };
     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);
     }
   };
 
   template <typename FormatterType>
   using AdditionalFormatter =
       std::pair<AdditionalFormatterMatching::MatcherUP, FormatterType>;
 
   template <typename FormatterType>

lldb/trunk/source/Plugins/ObjectFile/Breakpad/ObjectFileBreakpad.cpp

 Symtab *ObjectFileBreakpad::GetSymtab() {
   // TODO
   return nullptr;
 }
 
 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;
   llvm::StringRef text = toStringRef(m_data.GetData());
   uint32_t next_section_id = 1;
   auto maybe_add_section = [&](const uint8_t *end_ptr) {
     if (!current_section)
       return; // We have been called before parsing the first line.

lldb/trunk/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

public:
   }
 };
 }
 
 void ObjectFileELF::CreateSections(SectionList &unified_section_list) {
   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");
 
   for (const auto &EnumPHdr : llvm::enumerate(ProgramHeaders())) {
     const ELFProgramHeader &PHdr = EnumPHdr.value();
     if (PHdr.p_type != PT_LOAD && PHdr.p_type != PT_TLS)
       continue;
 

lldb/trunk/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp

ObjectFile *ObjectFileMachO::CreateInstance(const lldb::ModuleSP &module_sp,
 
   // Update the data to contain the entire file if it doesn't already
   if (data_sp->GetByteSize() < length) {
     data_sp = MapFileData(*file, length, file_offset);
     if (!data_sp)
       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;
 
   return objfile_up.release();
 }
 
 ObjectFile *ObjectFileMachO::CreateMemoryInstance(

lldb/trunk/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp

ObjectFile *ObjectFilePECOFF::CreateInstance(const lldb::ModuleSP &module_sp,
 
   // Update the data to contain the entire file if it doesn't already
   if (data_sp->GetByteSize() < length) {
     data_sp = MapFileData(file, length, file_offset);
     if (!data_sp)
       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;
 
   // Cache coff binary.
   if (!objfile_up->CreateBinary())
     return nullptr;
 
   return objfile_up.release();
 }
 
 ObjectFile *ObjectFilePECOFF::CreateMemoryInstance(
     const lldb::ModuleSP &module_sp, lldb::DataBufferSP &data_sp,
     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();
   }
   return nullptr;
 }
 
 size_t ObjectFilePECOFF::GetModuleSpecifications(
if (m_file) {
     // A bit of a hack, but we intend to write to this buffer, so we can't
     // mmap it.
     auto buffer_sp = MapFileData(m_file, size, offset);
     return DataExtractor(buffer_sp, GetByteOrder(), GetAddressByteSize());
   }
   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(),
                                data_up->GetByteSize(), readmem_error);
     if (bytes_read == size) {
       DataBufferSP buffer_sp(data_up.release());
       data.SetData(buffer_sp, 0, buffer_sp->GetByteSize());
     }

lldb/trunk/source/Plugins/Process/Linux/NativeProcessLinux.cpp

NativeThreadLinux &NativeProcessLinux::AddThread(lldb::tid_t thread_id) {
 
   assert(!HasThreadNoLock(thread_id) &&
          "attempted to add a thread by id that already exists");
 
   // If this is the first thread, save it as the current thread
   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(
         GetID(), thread_id, m_pt_process_trace_config, true);
     if (traceMonitor) {
       m_pt_traced_thread_group.insert(thread_id);
       m_processor_trace_monitor.insert(
           std::make_pair(thread_id, std::move(*traceMonitor)));

lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_arm.cpp

static const RegisterSet g_reg_sets_arm[k_num_register_sets] = {
     {"Floating Point Registers", "fpu", k_num_fpr_registers_arm,
      g_fpu_regnums_arm}};
 
 #if defined(__arm__)
 
 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);
 }
 
 #endif // defined(__arm__)
 
 NativeRegisterContextLinux_arm::NativeRegisterContextLinux_arm(
     const ArchSpec &target_arch, NativeThreadProtocol &native_thread)
     : NativeRegisterContextLinux(native_thread,

lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_arm64.cpp

static const RegisterSet g_reg_sets_arm64[k_num_register_sets] = {
     {"Floating Point Registers", "fpu", k_num_fpr_registers_arm64,
      g_fpu_regnums_arm64}};
 
 std::unique_ptr<NativeRegisterContextLinux>
 NativeRegisterContextLinux::CreateHostNativeRegisterContextLinux(
     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");
   }
 }
 
 NativeRegisterContextLinux_arm64::NativeRegisterContextLinux_arm64(
     const ArchSpec &target_arch, NativeThreadProtocol &native_thread)

lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.cpp

 struct pt_watch_regs default_watch_regs;
 
 using namespace lldb_private;
 using namespace lldb_private::process_linux;
 
 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);
 }
 
 #define REG_CONTEXT_SIZE                                                       \
   (GetRegisterInfoInterface().GetGPRSize() + sizeof(FPR_linux_mips) +          \
    sizeof(MSA_linux_mips))
 
 // NativeRegisterContextLinux_mips64 members.

lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_ppc64le.cpp

static const RegisterSet g_reg_sets_ppc64le[k_num_register_sets] = {
      g_vsx_regnums_ppc64le},
 };
 
 std::unique_ptr<NativeRegisterContextLinux>
 NativeRegisterContextLinux::CreateHostNativeRegisterContextLinux(
     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");
   }
 }
 
 NativeRegisterContextLinux_ppc64le::NativeRegisterContextLinux_ppc64le(
     const ArchSpec &target_arch, NativeThreadProtocol &native_thread)

lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_s390x.cpp

 // Required ptrace defines.
 
 #define NT_S390_LAST_BREAK 0x306  /* s390 breaking event address */
 #define NT_S390_SYSTEM_CALL 0x307 /* s390 system call restart data */
 
 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);
 }
 
 // NativeRegisterContextLinux_s390x members.
 
 static RegisterInfoInterface *
 CreateRegisterInfoInterface(const ArchSpec &target_arch) {
   assert((HostInfo::GetArchitecture().GetAddressByteSize() == 8) &&

lldb/trunk/source/Plugins/Process/Linux/SingleStepCheck.cpp

if (sched_setaffinity(tid, sizeof set, &set) != 0) {
     // This may fail in very locked down systems, if the thread is not allowed
     // to run on cpu 0. If that happens, only thing we can do is it log it and
     // continue...
     LLDB_LOG(log, "Unable to set cpu affinity for thread {0}: {1}", tid,
              Status(errno, eErrorTypePOSIX));
   }
 
   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() {
   Log *log = ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_THREAD);
   LLDB_LOG(log, "Removing workaround");
   if (sched_setaffinity(m_tid, sizeof m_original_set, &m_original_set) != 0) {
     LLDB_LOG(log, "Unable to reset cpu affinity for thread {0}: {1}", m_tid,
              Status(errno, eErrorTypePOSIX));
   }
 }
 #endif

lldb/trunk/source/Plugins/Process/NetBSD/NativeProcessNetBSD.cpp

NativeThreadNetBSD &NativeProcessNetBSD::AddThread(lldb::tid_t thread_id) {
 
   assert(!HasThreadNoLock(thread_id) &&
          "attempted to add a thread by id that already exists");
 
   // If this is the first thread, save it as the current thread
   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());
 }
 
 Status NativeProcessNetBSD::Attach() {
   // Attach to the requested process.
   // An attach will cause the thread to stop with a SIGSTOP.
   Status status = PtraceWrapper(PT_ATTACH, m_pid);
   if (status.Fail())

lldb/trunk/source/Plugins/Process/POSIX/NativeProcessELF.cpp

 NativeProcessELF::GetAuxValue(enum AuxVector::EntryType type) {
   if (m_aux_vector == nullptr) {
     auto buffer_or_error = GetAuxvData();
     if (!buffer_or_error)
       return llvm::None;
     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);
 }
 
 lldb::addr_t NativeProcessELF::GetSharedLibraryInfoAddress() {
   if (!m_shared_library_info_addr.hasValue()) {
     if (GetAddressByteSize() == 8)

lldb/trunk/source/Plugins/Process/Windows/Common/NativeProcessWindows.cpp

if (!Host::GetProcessInfo(GetDebuggedProcessId(), process_info)) {
                     "to process");
       return;
     }
     SetArchitecture(process_info.GetArchitecture());
   }
 
   // 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()));
 }
 
 ExceptionResult
 NativeProcessWindows::OnDebugException(bool first_chance,
                                        const ExceptionRecord &record) {
   Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_EXCEPTION);
   llvm::sys::ScopedLock lock(m_mutex);
NativeProcessWindows::OnDebugException(bool first_chance,
   }
 
   return result;
 }
 
 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,
                                         uint32_t exit_code) {
   llvm::sys::ScopedLock lock(m_mutex);
   NativeThreadWindows *thread = GetThreadByID(thread_id);
   if (!thread)
     return;

lldb/trunk/source/Plugins/Process/Windows/Common/NativeRegisterContextWindows_i386.cpp

if (!::SetThreadContext(thread_handle, context_ptr)) {
     return error;
   }
   return Status();
 }
 
 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);
 }
 
 NativeRegisterContextWindows_i386::NativeRegisterContextWindows_i386(
     const ArchSpec &target_arch, NativeThreadProtocol &native_thread)
     : NativeRegisterContextWindows(native_thread,
                                    CreateRegisterInfoInterface(target_arch)) {}
 

lldb/trunk/source/Plugins/Process/Windows/Common/NativeRegisterContextWindows_x86_64.cpp

static Status SetThreadContextHelper(lldb::thread_t thread_handle,
   return Status();
 }
 
 std::unique_ptr<NativeRegisterContextWindows>
 NativeRegisterContextWindows::CreateHostNativeRegisterContextWindows(
     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);
 }
 
 NativeRegisterContextWindows_x86_64::NativeRegisterContextWindows_x86_64(
     const ArchSpec &target_arch, NativeThreadProtocol &native_thread)
     : NativeRegisterContextWindows(native_thread,
                                    CreateRegisterInfoInterface(target_arch)) {}
 

lldb/trunk/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

public:
 
   ProcessGDBRemoteProvider(const FileSpec &directory) : Provider(directory) {
   }
 
   raw_ostream *GetHistoryStream() {
     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();
   }
 
   void SetCallback(std::function<void()> callback) {
     m_callback = std::move(callback);
   }
 

lldb/trunk/source/Plugins/Process/minidump/ProcessMinidump.cpp

 public:
   PlaceholderObjectFile(const lldb::ModuleSP &module_sp,
                         const ModuleSpec &module_spec, lldb::offset_t base,
                         lldb::offset_t size)
       : ObjectFile(module_sp, &module_spec.GetFileSpec(), /*file_offset*/ 0,
                    /*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"); }
   uint32_t GetPluginVersion() override { return 1; }
   bool ParseHeader() override { return true; }
   Type CalculateType() override { return eTypeUnknown; }
   Strata CalculateStrata() override { return eStrataUnknown; }
   uint32_t GetDependentModules(FileSpecList &file_list) override { return 0; }
   bool IsExecutable() const override { return false; }
   ArchSpec GetArchitecture() override { return m_arch; }
   UUID GetUUID() override { return m_uuid; }
   Symtab *GetSymtab() override { return m_symtab_up.get(); }
   bool IsStripped() override { return true; }
   ByteOrder GetByteOrder() const override { return m_arch.GetByteOrder(); }
 
   uint32_t GetAddressByteSize() const override {
     return m_arch.GetAddressByteSize();
   }
 
   Address GetBaseAddress() override {
     return Address(m_sections_up->GetSectionAtIndex(0), 0);
   }
 
   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,
         /*log2align*/ 0, /*flags*/ 0);
     section_sp->SetPermissions(ePermissionsReadable | ePermissionsExecutable);
     m_sections_up->AddSection(section_sp);
     unified_section_list.AddSection(std::move(section_sp));
   }

 }
 
 // For minidumps there's no runtime generated code so we don't need JITLoader(s)
 // Avoiding them will also speed up minidump loading since JITLoaders normally
 // try to set up symbolic breakpoints, which in turn may force loading more
 // 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;
 }
 
 #define INIT_BOOL(VAR, LONG, SHORT, DESC) \
     VAR(LLDB_OPT_SET_1, false, LONG, SHORT, DESC, false, true)
 #define APPEND_OPT(VAR) \
     m_option_group.Append(&VAR, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1)

lldb/trunk/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp

case eIOHandlerNone:
     break;
   case eIOHandlerBreakpoint: {
     std::vector<BreakpointOptions *> *bp_options_vec =
         (std::vector<BreakpointOptions *> *)io_handler.GetUserData();
     for (auto bp_options : *bp_options_vec) {
       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);
 
       if (GenerateBreakpointCommandCallbackData(data_up->user_source,
                                                 data_up->script_source)
               .Success()) {
         auto baton_sp = std::make_shared<BreakpointOptions::CommandBaton>(
             std::move(data_up));
         bp_options->SetCallback(
             ScriptInterpreterPythonImpl::BreakpointCallbackFunction, baton_sp);
       } else if (!batch_mode) {
         StreamFileSP error_sp = io_handler.GetErrorStreamFile();
         if (error_sp) {
           error_sp->Printf("Warning: No command attached to breakpoint.\n");
           error_sp->Flush();
         }
       }
     }
     m_active_io_handler = eIOHandlerNone;
   } break;
   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,
                                               data_up->script_source)) {
       auto baton_sp =
           std::make_shared<WatchpointOptions::CommandBaton>(std::move(data_up));
       wp_options->SetCallback(
           ScriptInterpreterPythonImpl::WatchpointCallbackFunction, baton_sp);
Status ScriptInterpreterPythonImpl::SetBreakpointCommandCallback(
   bp_options->SetCallback(
       ScriptInterpreterPythonImpl::BreakpointCallbackFunction, baton_sp);
   return error;
 }
 
 // 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
   // auto-generated function, and return the function name in script_source.
   // That is what the callback will actually invoke.
 
   data_up->user_source.SplitIntoLines(command_body_text);
   Status error = GenerateBreakpointCommandCallbackData(data_up->user_source,
                                                        data_up->script_source);
   if (error.Success()) {
     auto baton_sp =
         std::make_shared<BreakpointOptions::CommandBaton>(std::move(data_up));
     bp_options->SetCallback(
         ScriptInterpreterPythonImpl::BreakpointCallbackFunction, baton_sp);
     return error;
   } else
     return error;
 }
 
 // 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
   // command list) while the latter is used for Python to interpret during the
   // actual callback.
 
   data_up->user_source.AppendString(oneliner);
   data_up->script_source.assign(oneliner);

lldb/trunk/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.cpp

 // compile unit.
 void SymbolFileBreakpad::ParseLineTableAndSupportFiles(CompileUnit &cu,
                                                        CompUnitData &data) {
   addr_t base = GetBaseFileAddress();
   assert(base != LLDB_INVALID_ADDRESS &&
          "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;
   auto finish_sequence = [&]() {
     data.line_table_up->AppendLineEntryToSequence(
         line_seq_up.get(), *next_addr, /*line*/ 0, /*column*/ 0,
         /*file_idx*/ 0, /*is_start_of_statement*/ false,
         /*is_start_of_basic_block*/ false, /*is_prologue_end*/ false,

lldb/trunk/source/Plugins/SymbolFile/DWARF/AppleDWARFIndex.cpp

 
 using namespace lldb_private;
 using namespace lldb;
 
 std::unique_ptr<AppleDWARFIndex> AppleDWARFIndex::Create(
     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));
 
   return nullptr;
 }
 
 void AppleDWARFIndex::GetGlobalVariables(ConstString basename, DIEArray &offsets) {

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.cpp

 DWARFDebugInfo::DWARFDebugInfo(SymbolFileDWARF &dwarf,
                                lldb_private::DWARFContext &context)
     : m_dwarf(dwarf), m_context(context), m_units(), m_cu_aranges_up() {}
 
 llvm::Expected<DWARFDebugAranges &> DWARFDebugInfo::GetCompileUnitAranges() {
   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))
     return std::move(error);
 
   // Make a list of all CUs represented by the arange data in the file.
   std::set<dw_offset_t> cus_with_data;
   for (size_t n = 0; n < m_cu_aranges_up->GetNumRanges(); n++) {

lldb/trunk/source/Plugins/SymbolFile/DWARF/DebugNamesDWARFIndex.cpp

 llvm::Expected<std::unique_ptr<DebugNamesDWARFIndex>>
 DebugNamesDWARFIndex::Create(Module &module, DWARFDataExtractor debug_names,
                              DWARFDataExtractor debug_str,
                              DWARFDebugInfo *debug_info) {
   if (!debug_info) {
     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);
 
   return std::unique_ptr<DebugNamesDWARFIndex>(new DebugNamesDWARFIndex(
       module, std::move(index_up), debug_names, debug_str, *debug_info));
 }
 

lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

if (debug_names.GetByteSize() > 0) {
         m_index = std::move(*index_or);
         return;
       }
       LLDB_LOG_ERROR(log, index_or.takeError(),
                      "Unable to read .debug_names data: {0}");
     }
   }
 
-  m_index = llvm::make_unique<ManualDWARFIndex>(*GetObjectFile()->GetModule(),
+  m_index = std::make_unique<ManualDWARFIndex>(*GetObjectFile()->GetModule(),
                                                 DebugInfo());
 }
 
 bool SymbolFileDWARF::SupportedVersion(uint16_t version) {
   return version >= 2 && version <= 5;
 }
 
 uint32_t SymbolFileDWARF::CalculateAbilities() {

 DWARFDebugAbbrev *SymbolFileDWARF::DebugAbbrev() {
   if (m_abbr)
     return m_abbr.get();
 
   const DWARFDataExtractor &debug_abbrev_data = m_context.getOrLoadAbbrevData();
   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);
     LLDB_LOG_ERROR(log, std::move(error),
                    "Unable to read .debug_abbrev section: {0}");
     return nullptr;
   }
 
   m_abbr = std::move(abbr);
   return m_abbr.get();
 }
 
 const DWARFDebugAbbrev *SymbolFileDWARF::DebugAbbrev() const {
   return m_abbr.get();
 }
 
 DWARFDebugInfo *SymbolFileDWARF::DebugInfo() {
   if (m_info == nullptr) {
     static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
     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();
 }
 
 const DWARFDebugInfo *SymbolFileDWARF::DebugInfo() const {
   return m_info.get();
 }
 
bool SymbolFileDWARF::ParseLineTable(CompileUnit &comp_unit) {
 
   if (!line_table)
     return false;
 
   // FIXME: Rather than parsing the whole line table and then copying it over
   // 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(
         sequence, row.Address.Address, row.Line, row.Column, row.File,
         row.IsStmt, row.BasicBlock, row.PrologueEnd, row.EpilogueBegin,
         row.EndSequence);
     if (row.EndSequence) {
       line_table_up->InsertSequence(sequence);
SymbolFileDWARF::GetDwoSymbolFileForCompileUnit(
   lldb::offset_t dwo_file_data_offset = 0;
   ObjectFileSP dwo_obj_file = ObjectFile::FindPlugin(
       GetObjectFile()->GetModule(), &dwo_file, file_offset,
       FileSystem::Instance().GetByteSize(dwo_file), dwo_file_data_sp,
       dwo_file_data_offset);
   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() {
   if (m_fetched_external_modules)
     return;
   m_fetched_external_modules = true;
 
   DWARFDebugInfo *debug_info = DebugInfo();

lldb/trunk/source/Plugins/SymbolFile/NativePDB/CompileUnitIndex.cpp

CompilandIndexItem &CompileUnitIndex::GetOrCreateCompiland(uint16_t modi) {
   std::unique_ptr<llvm::msf::MappedBlockStream> stream_data =
       m_index.pdb().createIndexedStream(stream);
 
 
   std::unique_ptr<CompilandIndexItem>& cci = result.first->second;
 
   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;
   }
 
   llvm::pdb::ModuleDebugStreamRef debug_stream(descriptor,
                                                std::move(stream_data));
 
   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);
 
   cci->m_strings.initialize(debug_stream.getSubsectionsArray());
   PDBStringTable &strings = cantFail(m_index.pdb().getStringTable());
   cci->m_strings.setStrings(strings.getStringTable());
 
   // We want the main source file to always comes first.  Note that we can't

lldb/trunk/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

static std::unique_ptr<PDBFile> loadPDBFile(std::string PdbPath,
   llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> ErrorOrBuffer =
       llvm::MemoryBuffer::getFile(PdbPath, /*FileSize=*/-1,
                                   /*RequiresNullTerminator=*/false);
   if (!ErrorOrBuffer)
     return nullptr;
   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;
   }
   if (auto EC = File->parseStreamData()) {
     llvm::consumeError(std::move(EC));
     return nullptr;
   }
auto ts_or_err = m_objfile_sp->GetModule()->GetTypeSystemForLanguage(
       lldb::eLanguageTypeC_plus_plus);
   if (auto err = ts_or_err.takeError()) {
     LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
                    std::move(err), "Failed to initialize");
   } else {
     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);
   }
 }
 
 uint32_t SymbolFileNativePDB::CalculateNumCompileUnits() {
   const DbiModuleList &modules = m_index->dbi().modules();
   uint32_t count = modules.getModuleCount();
   if (count == 0)
     return count;
bool SymbolFileNativePDB::ParseLineTable(CompileUnit &comp_unit) {
   // function.  In the future it would be nice if it could set the sc.m_function
   // member, and we could only get the line info for the function in question.
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   PdbSymUid cu_id(comp_unit.GetID());
   lldbassert(cu_id.kind() == PdbSymUidKind::Compiland);
   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
   // looking for all DEBUG_S_LINES subsections.
   for (const DebugSubsectionRecord &dssr :
        cci->m_debug_stream.getSubsectionsArray()) {
     if (dssr.kind() != DebugSubsectionKind::Lines)
       continue;

lldb/trunk/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp

if (!compiland_up)
     return false;
 
   // LineEntry needs the *index* of the file into the list of support files
   // returned by ParseCompileUnitSupportFiles.  But the underlying SDK gives us
   // a globally unique idenfitifier in the namespace of the PDB.  So, we have
   // 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();
   auto files = m_session_up->getSourceFilesForCompiland(*compiland_up);
   if (!files)
     return false;
 
   // For each source and header file, create a LineSequence for contributions

lldb/trunk/source/Symbol/ClangASTContext.cpp

 
 std::unique_ptr<clang::CXXBaseSpecifier>
 ClangASTContext::CreateBaseClassSpecifier(lldb::opaque_compiler_type_t type,
                                           AccessType access, bool is_virtual,
                                           bool base_of_class) {
   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)),
       clang::SourceLocation());
 }
 
 bool ClangASTContext::TransferBaseClasses(
     lldb::opaque_compiler_type_t type,

lldb/trunk/source/Target/Platform.cpp

 Platform::Platform(bool is_host)
     : m_is_host(is_host), m_os_version_set_while_connected(false),
       m_system_arch_set_while_connected(false), m_sdk_sysroot(), m_sdk_build(),
       m_working_dir(), m_remote_url(), m_name(), m_system_arch(), m_mutex(),
       m_max_uid_name_len(0), m_max_gid_name_len(0), m_supports_rsync(false),
       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));
 }
 
 /// Destructor.
 ///
 /// The destructor is virtual since this class is designed to be
 /// inherited from by the plug-in instance.

lldb/trunk/source/Utility/Reproducer.cpp

 
 const FileSpec &Generator::GetRoot() const { return m_root; }
 
 void Generator::AddProvidersToIndex() {
   FileSpec index = m_root;
   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);
 
   std::vector<std::string> files;
   files.reserve(m_providers.size());
   for (auto &provider : m_providers) {
     files.emplace_back(provider.second->GetFile());
   }
bool Loader::HasFile(StringRef file) {
   assert(m_loaded);
   auto it = std::lower_bound(m_files.begin(), m_files.end(), file.str());
   return (it != m_files.end()) && (*it == file);
 }
 
 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);
 }
 
 DataRecorder *CommandProvider::GetNewDataRecorder() {
   std::size_t i = m_data_recorders.size() + 1;
   std::string filename = (llvm::Twine(Info::name) + llvm::Twine("-") +

lldb/trunk/source/Utility/StructuredData.cpp

StructuredData::ParseJSONFromFile(const FileSpec &input_spec, Status &error) {
   JSONParser json_parser(buffer_or_error.get()->getBuffer());
   return_sp = ParseJSONValue(json_parser);
   return return_sp;
 }
 
 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;
   while (true) {
     JSONParser::Token token = json_parser.GetToken(value);
 
     if (token == JSONParser::Token::String) {
       key.swap(value);
while (true) {
     }
   }
   return StructuredData::ObjectSP();
 }
 
 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;
   while (true) {
     StructuredData::ObjectSP value_sp = ParseJSONValue(json_parser);
     if (value_sp)
       array_up->AddItem(value_sp);
     else

lldb/trunk/tools/lldb-instr/Instrument.cpp

public:
   void EndSourceFileAction() override {
     llvm::outs() << "}\n";
     MyRewriter.overwriteChangedFiles();
   }
 
   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:
   Rewriter MyRewriter;
 };
 
 int main(int argc, const char **argv) {
   CommonOptionsParser OP(argc, argv, InstrCategory,
                          "Utility for generating the macros for LLDB's "
                          "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());
 }

lldb/trunk/tools/lldb-server/lldb-server.cpp

 
 // Forward declarations of subcommand main methods.
 int main_gdbserver(int argc, char *argv[]);
 int main_platform(int argc, char *argv[]);
 
 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));
 }
 
 static void terminate_debugger() { g_debugger_lifetime->Terminate(); }
 } // namespace llgs
 
 // main
 int main(int argc, char *argv[]) {

lldb/trunk/tools/lldb-test/lldb-test.cpp

int main(int argc, const char *argv[]) {
   sys::PrintStackTraceOnErrorSignal(ToolName);
   PrettyStackTraceProgram X(argc, argv);
   llvm_shutdown_obj Y;
 
   cl::ParseCommandLineOptions(argc, argv, "LLDB Testing Utility\n");
 
   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;
   }
 
   CleanUp TerminateDebugger([&] { DebuggerLifetime.Terminate(); });
 
   auto Dbg = lldb_private::Debugger::CreateInstance();

lldb/trunk/unittests/Host/MainLoopTest.cpp

 // NetBSD currently does not report slave pty EOF via kevent
 // causing this test to hang forever.
 #ifndef __NetBSD__
 TEST_F(MainLoopTest, DetectsEOF) {
 
   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;
   MainLoop loop;
   auto handle =
       loop.RegisterReadObject(conn->GetReadObject(), make_callback(), error);
   ASSERT_TRUE(error.Success());
   term.CloseSlaveFileDescriptor();

lldb/trunk/unittests/Process/minidump/RegisterContextMinidumpTest.cpp

TEST(RegisterContextMinidump, ConvertMinidumpContext_x86_32) {
   Context.gs = 0x2c2d;
   Context.ss = 0x2e2f;
   Context.ds = 0x3031;
   Context.es = 0x3233;
   llvm::ArrayRef<uint8_t> ContextRef(reinterpret_cast<uint8_t *>(&Context),
                                      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());
 
   const RegisterInfo *Info = RegInterface->GetRegisterInfo();
   ASSERT_NE(nullptr, Info);
 
   EXPECT_EQ(Context.eax, reg32(*Buf, Info[lldb_eax_i386]));
TEST(RegisterContextMinidump, ConvertMinidumpContext_x86_64) {
   Context.gs = 0x9091;
   Context.ss = 0x9293;
   Context.ds = 0x9495;
   Context.ss = 0x9697;
   llvm::ArrayRef<uint8_t> ContextRef(reinterpret_cast<uint8_t *>(&Context),
                                      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());
 
   const RegisterInfo *Info = RegInterface->GetRegisterInfo();
   EXPECT_EQ(Context.rax, reg64(*Buf, Info[lldb_rax_x86_64]));
   EXPECT_EQ(Context.rbx, reg64(*Buf, Info[lldb_rbx_x86_64]));
   EXPECT_EQ(Context.rcx, reg64(*Buf, Info[lldb_rcx_x86_64]));

lldb/trunk/unittests/tools/lldb-server/tests/MessageObjects.cpp

if (!PcOr)
       return PcOr.takeError();
     ThreadPcs[Id] = std::move(*PcOr);
   }
 
   auto RegistersOr = parseRegisters(Elements, Endian, RegInfos);
   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);
 }
 
 Expected<std::unique_ptr<StopReplyExit>>
 StopReplyExit::create(StringRef Response) {
   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 ===============================================================
 Expected<StringMap<StringRef>> SplitUniquePairList(StringRef caller,
                                                    StringRef str) {
   SmallVector<StringRef, 20> elements;
   str.split(elements, ';');
 

lldb/trunk/unittests/tools/lldb-server/tests/TestClient.cpp

Info.SetMonitorProcessCallback(&ProcessLaunchInfo::NoOpMonitorCallback,
                                  false);
 
   status = Host::LaunchProcess(Info);
   if (status.Fail())
     return status.ToError();
 
   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())
     return std::move(E);
 
   if (!InferiorArgs.empty()) {
     if (Error E = Client->queryProcess())
       return std::move(E);