Use std::make_shared in LLDB (NFC)

[JDevlieghere]

Summary

Unlike std::make_unique, which is only available since C++14,
std::make_shared is available since C++11. Not only is std::make_shared
a lot more readable compared to ::reset(new), it also performs a single
heap allocation for the object and control block.

[Eugene.Zelenko]

lldb/source/API/SBData.cpp

9 ↗

(On Diff #186086)

cinttypes should be used instead. See Clang-tidy modernize-deprecated-headers. Same in other places.

12 ↗

(On Diff #186086)

Spaces between include statements interfere with Clang-format. Same in other places.

[jingham]

lldb/source/API/SBData.cpp

12 ↗

(On Diff #186086)

How?

We always separate system header includes from lldb includes from llvm includes by putting a blank line. That's done all over the place in lldb. I haven't heard of this causing problems before now. If this does cause problems, that should be fixed in clang-format. It seems like a really unreasonable requirement.

[JDevlieghere]

lldb/source/API/SBData.cpp

12 ↗

(On Diff #186086)

Indeed, and as far as I know llvm does exactly the same thing. clang-format sorts headers within the same group, which is exactly what we want.

[Eugene.Zelenko]

lldb/source/API/SBData.cpp

12 ↗

(On Diff #186086)

Is there any good reason to be different from LLVM/Clang? Wasn't formatting style was changed in not so recent past to reduce differences?

Examples of problems visible in this patch:

lldb/source/API/SBInstruction.cpp
lldb/source/API/SBThread.cpp
lldb/source/Commands/CommandObjectMemory.cpp
lldb/source/Interpreter/CommandInterpreter.cpp

[JDevlieghere]

lldb/source/API/SBData.cpp

12 ↗

(On Diff #186086)

I'm saying it's exactly the same in LLDB as it is in LLVM. I'm afraid I don't understand what you mean here.

[Eugene.Zelenko]

lldb/source/API/SBData.cpp

12 ↗

(On Diff #186086)

I don't remember empty lines between headers groups in LLVM and Clang code base.

[jfb]

Do you ever use weak pointers? The single allocation is good until you start holding on to more things (because you can't just keep the block around, you need the entire allocation), so you should make sure you won’t be delaying memory being reclaimed.

[labath]

I agree with Eugene that the empty lines interfere with clang-format and that llvm does not use empty lines between system and own headers. However, our headers are already very inconsistent with that, so I don't think fixing that should be a part of this patch. It would be good if this patch did not make the problem worse though, which in some cases it does: e.g. in SBInstruction.cpp, <memory> is inserted into a middle of a SB include group together with an empty line, which prevents clang-format from fixing this up.

Apart from that, this lgtm. Lldb does use weak_ptrs in a bunch of places, but I'm not terribly worried about the memory impact of this change.

[tatyana-krasnukha]

A few modernizations which though don't directly relate to make_shared:

lldb/source/API/SBCommandInterpreter.cpp

560 ↗

(On Diff #186086)

Why not replace assignment with initialization here and below?

lldb/source/Target/Thread.cpp

1611 ↗

(On Diff #186086)

This 'if-else' block may be replaced with

if (!m_curr_frames_sp)
  m_curr_frames_sp =
      std::make_shared<StackFrameList>(*this, m_prev_frames_sp, true);
frame_list_sp = m_curr_frames_sp;

[tatyana-krasnukha]

These also don't relate directly but intersect with your changes:

lldb/source/API/SBTypeEnumMember.cpp

78 ↗

(On Diff #186086)

if (!m_opaque_sp)

lldb/source/Core/IOHandler.cpp

1012 ↗

(On Diff #186086)

Also may be simplified

auto get_window = [this, &bounds] () {
  return m_window ?
      ::subwin(m_window, bounds.size.height, bounds.size.width,
                   bounds.origin.y, bounds.origin.x) :
      ::newwin(bounds.size.height, bounds.size.width,
                   bounds.origin.y, bounds.origin.x);
};

subwindow_sp = std::make_shared<Window>(name, get_window(), true);
subwindow_sp->m_is_subwin = m_window.operator bool();

[Eugene.Zelenko]

lldb/source/API/SBTypeEnumMember.cpp

78 ↗

(On Diff #186086)

Will be good idea to run Clang-tidy readability-redundant-smartptr-get.

[JDevlieghere]

• Fix <memory> include.

[JDevlieghere]

@tatyana-krasnukha and @Eugene.Zelenko, are you okay with me addressing those thing in a follow-up?

lldb/source/API/SBData.cpp

12 ↗

(On Diff #186086)

I misunderstood, you're correct!

[tatyana-krasnukha]

Yes, of course!

[Eugene.Zelenko]

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

10 ↗

(On Diff #186279)

Spurious separator.

lldb/source/Plugins/Process/minidump/ThreadMinidump.cpp

10 ↗

(On Diff #186279)

Spurious separator.

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp

11 ↗

(On Diff #186279)

Wrong place.

lldb/tools/debugserver/source/debugserver.cpp

14 ↗

(On Diff #186279)

Wrong place.

source/API/SBCommandInterpreter.cpp

 #include "lldb/API/SBEvent.h"
 #include "lldb/API/SBExecutionContext.h"
 #include "lldb/API/SBListener.h"
 #include "lldb/API/SBProcess.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBStringList.h"
 #include "lldb/API/SBTarget.h"
 
+#include <memory>
+
 using namespace lldb;
 using namespace lldb_private;
 
 SBCommandInterpreterRunOptions::SBCommandInterpreterRunOptions() {
   m_opaque_up.reset(new CommandInterpreterRunOptions());
 }
 
 SBCommandInterpreterRunOptions::~SBCommandInterpreterRunOptions() = default;
if (new_command_sp &&
       m_opaque_ptr->AddUserCommand(name, new_command_sp, true))
     return lldb::SBCommand(new_command_sp);
   return lldb::SBCommand();
 }
 
 lldb::SBCommand SBCommandInterpreter::AddCommand(
     const char *name, lldb::SBCommandPluginInterface *impl, const char *help) {
   lldb::CommandObjectSP new_command_sp;
-  new_command_sp.reset(new CommandPluginInterfaceImplementation(
-      *m_opaque_ptr, name, impl, help));
+  new_command_sp = std::make_shared<CommandPluginInterfaceImplementation>(
+      *m_opaque_ptr, name, impl, help);
 
   if (new_command_sp &&
       m_opaque_ptr->AddUserCommand(name, new_command_sp, true))
     return lldb::SBCommand(new_command_sp);
   return lldb::SBCommand();
 }
 
 lldb::SBCommand
 SBCommandInterpreter::AddCommand(const char *name,
                                  lldb::SBCommandPluginInterface *impl,
                                  const char *help, const char *syntax) {
   lldb::CommandObjectSP new_command_sp;
-  new_command_sp.reset(new CommandPluginInterfaceImplementation(
-      *m_opaque_ptr, name, impl, help, syntax));
+  new_command_sp = std::make_shared<CommandPluginInterfaceImplementation>(
+      *m_opaque_ptr, name, impl, help, syntax);
 
   if (new_command_sp &&
       m_opaque_ptr->AddUserCommand(name, new_command_sp, true))
     return lldb::SBCommand(new_command_sp);
   return lldb::SBCommand();
 }
 
 SBCommand::SBCommand() = default;

 lldb::SBCommand SBCommand::AddCommand(const char *name,
                                       lldb::SBCommandPluginInterface *impl,
                                       const char *help) {
   if (!IsValid())
     return lldb::SBCommand();
   if (!m_opaque_sp->IsMultiwordObject())
     return lldb::SBCommand();
   lldb::CommandObjectSP new_command_sp;
-  new_command_sp.reset(new CommandPluginInterfaceImplementation(
-      m_opaque_sp->GetCommandInterpreter(), name, impl, help));
+  new_command_sp = std::make_shared<CommandPluginInterfaceImplementation>(
+      m_opaque_sp->GetCommandInterpreter(), name, impl, help);
   if (new_command_sp && m_opaque_sp->LoadSubCommand(name, new_command_sp))
     return lldb::SBCommand(new_command_sp);
   return lldb::SBCommand();
 }
 
 lldb::SBCommand SBCommand::AddCommand(const char *name,
                                       lldb::SBCommandPluginInterface *impl,
                                       const char *help, const char *syntax) {
   if (!IsValid())
     return lldb::SBCommand();
   if (!m_opaque_sp->IsMultiwordObject())
     return lldb::SBCommand();
   lldb::CommandObjectSP new_command_sp;
-  new_command_sp.reset(new CommandPluginInterfaceImplementation(
-      m_opaque_sp->GetCommandInterpreter(), name, impl, help, syntax));
+  new_command_sp = std::make_shared<CommandPluginInterfaceImplementation>(
+      m_opaque_sp->GetCommandInterpreter(), name, impl, help, syntax);
   if (new_command_sp && m_opaque_sp->LoadSubCommand(name, new_command_sp))
     return lldb::SBCommand(new_command_sp);
   return lldb::SBCommand();
 }
 
 uint32_t SBCommand::GetFlags() {
   return (IsValid() ? m_opaque_sp->GetFlags().Get() : 0);
 }
 
 void SBCommand::SetFlags(uint32_t flags) {
   if (IsValid())
     m_opaque_sp->GetFlags().Set(flags);
 }

source/API/SBData.cpp

 //===-- SBData.cpp ----------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#include <inttypes.h>
-
 #include "lldb/API/SBData.h"
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBStream.h"
 
 #include "lldb/Core/DumpDataExtractor.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Stream.h"
 
+#include <cinttypes>
+#include <memory>
+
 using namespace lldb;
 using namespace lldb_private;
 
 SBData::SBData() : m_opaque_sp(new DataExtractor()) {}
 
 SBData::SBData(const lldb::DataExtractorSP &data_sp) : m_opaque_sp(data_sp) {}
 
 SBData::SBData(const SBData &rhs) : m_opaque_sp(rhs.m_opaque_sp) {}
log->Printf("SBData::ReadRawData (error=%p,offset=%" PRIu64
                 static_cast<void *>(ok));
   return ok ? size : 0;
 }
 
 void SBData::SetData(lldb::SBError &error, const void *buf, size_t size,
                      lldb::ByteOrder endian, uint8_t addr_size) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (!m_opaque_sp.get())
-    m_opaque_sp.reset(new DataExtractor(buf, size, endian, addr_size));
+    m_opaque_sp = std::make_shared<DataExtractor>(buf, size, endian, addr_size);
   else
   {
     m_opaque_sp->SetData(buf, size, endian);
     m_opaque_sp->SetAddressByteSize(addr_size);
   }
 
   if (log)
     log->Printf("SBData::SetData (error=%p,buf=%p,size=%" PRIu64
if (!data) {
     return false;
   }
 
   size_t data_len = strlen(data);
 
   lldb::DataBufferSP buffer_sp(new DataBufferHeap(data, data_len));
 
   if (!m_opaque_sp.get())
-    m_opaque_sp.reset(
-        new DataExtractor(buffer_sp, GetByteOrder(), GetAddressByteSize()));
+    m_opaque_sp = std::make_shared<DataExtractor>(buffer_sp, GetByteOrder(),
+                                                  GetAddressByteSize());
   else
     m_opaque_sp->SetData(buffer_sp);
 
   if (log)
     log->Printf("SBData::SetDataFromCString (data=%p) => true",
                 static_cast<const void *>(data));
 
   return true;
if (!array || array_len == 0) {
     return false;
   }
 
   size_t data_len = array_len * sizeof(uint64_t);
 
   lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len));
 
   if (!m_opaque_sp.get())
-    m_opaque_sp.reset(
-        new DataExtractor(buffer_sp, GetByteOrder(), GetAddressByteSize()));
+    m_opaque_sp = std::make_shared<DataExtractor>(buffer_sp, GetByteOrder(),
+                                                  GetAddressByteSize());
   else
     m_opaque_sp->SetData(buffer_sp);
 
   if (log)
     log->Printf("SBData::SetDataFromUInt64Array (array=%p, array_len = %" PRIu64
                 ") => "
                 "true",
                 static_cast<void *>(array), static_cast<uint64_t>(array_len));
if (!array || array_len == 0) {
     return false;
   }
 
   size_t data_len = array_len * sizeof(uint32_t);
 
   lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len));
 
   if (!m_opaque_sp.get())
-    m_opaque_sp.reset(
-        new DataExtractor(buffer_sp, GetByteOrder(), GetAddressByteSize()));
+    m_opaque_sp = std::make_shared<DataExtractor>(buffer_sp, GetByteOrder(),
+                                                  GetAddressByteSize());
   else
     m_opaque_sp->SetData(buffer_sp);
 
   if (log)
     log->Printf("SBData::SetDataFromUInt32Array (array=%p, array_len = %" PRIu64
                 ") => "
                 "true",
                 static_cast<void *>(array), static_cast<uint64_t>(array_len));
if (!array || array_len == 0) {
     return false;
   }
 
   size_t data_len = array_len * sizeof(int64_t);
 
   lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len));
 
   if (!m_opaque_sp.get())
-    m_opaque_sp.reset(
-        new DataExtractor(buffer_sp, GetByteOrder(), GetAddressByteSize()));
+    m_opaque_sp = std::make_shared<DataExtractor>(buffer_sp, GetByteOrder(),
+                                                  GetAddressByteSize());
   else
     m_opaque_sp->SetData(buffer_sp);
 
   if (log)
     log->Printf("SBData::SetDataFromSInt64Array (array=%p, array_len = %" PRIu64
                 ") => "
                 "true",
                 static_cast<void *>(array), static_cast<uint64_t>(array_len));
if (!array || array_len == 0) {
     return false;
   }
 
   size_t data_len = array_len * sizeof(int32_t);
 
   lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len));
 
   if (!m_opaque_sp.get())
-    m_opaque_sp.reset(
-        new DataExtractor(buffer_sp, GetByteOrder(), GetAddressByteSize()));
+    m_opaque_sp = std::make_shared<DataExtractor>(buffer_sp, GetByteOrder(),
+                                                  GetAddressByteSize());
   else
     m_opaque_sp->SetData(buffer_sp);
 
   if (log)
     log->Printf("SBData::SetDataFromSInt32Array (array=%p, array_len = %" PRIu64
                 ") => "
                 "true",
                 static_cast<void *>(array), static_cast<uint64_t>(array_len));
if (!array || array_len == 0) {
     return false;
   }
 
   size_t data_len = array_len * sizeof(double);
 
   lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len));
 
   if (!m_opaque_sp.get())
-    m_opaque_sp.reset(
-        new DataExtractor(buffer_sp, GetByteOrder(), GetAddressByteSize()));
+    m_opaque_sp = std::make_shared<DataExtractor>(buffer_sp, GetByteOrder(),
+                                                  GetAddressByteSize());
   else
     m_opaque_sp->SetData(buffer_sp);
 
   if (log)
     log->Printf("SBData::SetDataFromDoubleArray (array=%p, array_len = %" PRIu64
                 ") => "
                 "true",
                 static_cast<void *>(array), static_cast<uint64_t>(array_len));
 
   return true;
 }

source/API/SBInstruction.cpp

 //===-- SBInstruction.cpp ---------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBInstruction.h"
 
 #include "lldb/API/SBAddress.h"
 #include "lldb/API/SBFrame.h"
+
 #include "lldb/API/SBInstruction.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBTarget.h"
 #include "lldb/Core/Disassembler.h"
 #include "lldb/Core/EmulateInstruction.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
 
+#include <memory>
+
 //----------------------------------------------------------------------
 // We recently fixed a leak in one of the Instruction subclasses where the
 // instruction will only hold a weak reference to the disassembler to avoid a
 // cycle that was keeping both objects alive (leak) and we need the
 // InstructionImpl class to make sure our public API behaves as users would
 // expect. Calls in our public API allow clients to do things like:
 //
 // 1  lldb::SBInstruction inst;
lldb::InstructionSP SBInstruction::GetOpaque() {
   if (m_opaque_sp)
     return m_opaque_sp->GetSP();
   else
     return lldb::InstructionSP();
 }
 
 void SBInstruction::SetOpaque(const lldb::DisassemblerSP &disasm_sp,
                               const lldb::InstructionSP &inst_sp) {
-  m_opaque_sp.reset(new InstructionImpl(disasm_sp, inst_sp));
+  m_opaque_sp = std::make_shared<InstructionImpl>(disasm_sp, inst_sp);
 }
 
 bool SBInstruction::GetDescription(lldb::SBStream &s) {
   lldb::InstructionSP inst_sp(GetOpaque());
   if (inst_sp) {
     SymbolContext sc;
     const Address &addr = inst_sp->GetAddress();
     ModuleSP module_sp(addr.GetModule());

source/API/SBThread.cpp

 #include "lldb/API/SBEvent.h"
 #include "lldb/API/SBFrame.h"
 #include "lldb/API/SBProcess.h"
 #include "lldb/API/SBThreadCollection.h"
 #include "lldb/API/SBThreadPlan.h"
 #include "lldb/API/SBValue.h"
 #include "lldb/lldb-enumerations.h"
 
+#include <memory>
+
 using namespace lldb;
 using namespace lldb_private;
 
 const char *SBThread::GetBroadcasterClassName() {
   return Thread::GetStaticBroadcasterClass().AsCString();
 }
 
 //----------------------------------------------------------------------
bool SBThread::GetStopReasonExtendedInfoAsJSON(lldb::SBStream &stream) {
   info->Dump(strm);
 
   return true;
 }
 
 SBThreadCollection
 SBThread::GetStopReasonExtendedBacktraces(InstrumentationRuntimeType type) {
   ThreadCollectionSP threads;
-  threads.reset(new ThreadCollection());
+  threads = std::make_shared<ThreadCollection>();
 
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   if (!exe_ctx.HasThreadScope())
     return threads;
 
   ProcessSP process_sp = exe_ctx.GetProcessSP();

source/API/SBThreadPlan.cpp

 #include "lldb/API/SBAddress.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBEvent.h"
 #include "lldb/API/SBFrame.h"
 #include "lldb/API/SBProcess.h"
 #include "lldb/API/SBThreadPlan.h"
 #include "lldb/API/SBValue.h"
 
+#include <memory>
+
 using namespace lldb;
 using namespace lldb_private;
 
 //----------------------------------------------------------------------
 // Constructors
 //----------------------------------------------------------------------
 SBThreadPlan::SBThreadPlan() {}
 
 SBThreadPlan::SBThreadPlan(const ThreadPlanSP &lldb_object_sp)
     : m_opaque_sp(lldb_object_sp) {}
 
 SBThreadPlan::SBThreadPlan(const SBThreadPlan &rhs)
     : m_opaque_sp(rhs.m_opaque_sp) {}
 
 SBThreadPlan::SBThreadPlan(lldb::SBThread &sb_thread, const char *class_name) {
   Thread *thread = sb_thread.get();
   if (thread)
-    m_opaque_sp.reset(new ThreadPlanPython(*thread, class_name));
+    m_opaque_sp = std::make_shared<ThreadPlanPython>(*thread, class_name);
 }
 
 //----------------------------------------------------------------------
 // Assignment operator
 //----------------------------------------------------------------------
 
 const lldb::SBThreadPlan &SBThreadPlan::operator=(const SBThreadPlan &rhs) {
   if (this != &rhs)

source/API/SBTrace.cpp

 //===-- SBTrace.cpp ---------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/Log.h"
 
 #include "lldb/API/SBTrace.h"
 #include "lldb/API/SBTraceOptions.h"
 
+#include <memory>
+
 using namespace lldb;
 using namespace lldb_private;
 
 class TraceImpl {
 public:
   lldb::user_id_t uid;
 };
 

 }
 
 void SBTrace::SetTraceUID(lldb::user_id_t uid) {
   if (m_trace_impl_sp)
     m_trace_impl_sp->uid = uid;
 }
 
 SBTrace::SBTrace() {
-  m_trace_impl_sp.reset(new TraceImpl);
+  m_trace_impl_sp = std::make_shared<TraceImpl>();
   if (m_trace_impl_sp)
     m_trace_impl_sp->uid = LLDB_INVALID_UID;
 }
 
 void SBTrace::SetSP(const ProcessSP &process_sp) { m_opaque_wp = process_sp; }
 
 bool SBTrace::IsValid() {
   if (!m_trace_impl_sp)
     return false;
   if (!GetSP())
     return false;
   return true;
 }

source/API/SBTraceOptions.cpp

 //===-- SBTraceOptions.cpp --------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBTraceOptions.h"
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBStructuredData.h"
 #include "lldb/Core/StructuredDataImpl.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/TraceOptions.h"
 
+#include <memory>
+
 using namespace lldb;
 using namespace lldb_private;
 
 SBTraceOptions::SBTraceOptions() {
-  m_traceoptions_sp.reset(new TraceOptions());
+  m_traceoptions_sp = std::make_shared<TraceOptions>();
 }
 
 lldb::TraceType SBTraceOptions::getType() const {
   if (m_traceoptions_sp)
     return m_traceoptions_sp->getType();
   return lldb::TraceType::eTraceTypeNone;
 }
 

source/API/SBType.cpp

 #include "lldb/Symbol/Type.h"
 #include "lldb/Symbol/TypeSystem.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Stream.h"
 
 #include "llvm/ADT/APSInt.h"
 
+#include <memory>
+
 using namespace lldb;
 using namespace lldb_private;
 
 SBType::SBType() : m_opaque_sp() {}
 
 SBType::SBType(const CompilerType &type)
     : m_opaque_sp(new TypeImpl(
           CompilerType(type.GetTypeSystem(), type.GetOpaqueQualType()))) {}
SBType &SBType::operator=(const SBType &rhs) {
   }
   return *this;
 }
 
 SBType::~SBType() {}
 
 TypeImpl &SBType::ref() {
   if (m_opaque_sp.get() == NULL)
-    m_opaque_sp.reset(new TypeImpl());
+    m_opaque_sp = std::make_shared<TypeImpl>();
   return *m_opaque_sp;
 }
 
 const TypeImpl &SBType::ref() const {
   // "const SBAddress &addr" should already have checked "addr.IsValid()" prior
   // to calling this function. In case you didn't we will assert and die to let
   // you know.
   assert(m_opaque_sp.get());

 }
 
 void SBTypeMemberFunction::reset(TypeMemberFunctionImpl *type_member_impl) {
   m_opaque_sp.reset(type_member_impl);
 }
 
 TypeMemberFunctionImpl &SBTypeMemberFunction::ref() {
   if (!m_opaque_sp)
-    m_opaque_sp.reset(new TypeMemberFunctionImpl());
+    m_opaque_sp = std::make_shared<TypeMemberFunctionImpl>();
   return *m_opaque_sp.get();
 }
 
 const TypeMemberFunctionImpl &SBTypeMemberFunction::ref() const {
   return *m_opaque_sp.get();
 }

source/API/SBTypeEnumMember.cpp

 //===-- SBTypeEnumMember.cpp ---------------------------------- -*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBTypeEnumMember.h"
 #include "lldb/API/SBDefines.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBType.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Utility/Stream.h"
 
+#include <memory>
+
 using namespace lldb;
 using namespace lldb_private;
 
 SBTypeEnumMember::SBTypeEnumMember() : m_opaque_sp() {}
 
 SBTypeEnumMember::~SBTypeEnumMember() {}
 SBTypeEnumMember::SBTypeEnumMember(
     const lldb::TypeEnumMemberImplSP &enum_member_sp)
     : m_opaque_sp(enum_member_sp) {}
 
 SBTypeEnumMember::SBTypeEnumMember(const SBTypeEnumMember &rhs)
     : m_opaque_sp() {
   if (this != &rhs) {
     if (rhs.IsValid())
-      m_opaque_sp.reset(new TypeEnumMemberImpl(rhs.ref()));
+      m_opaque_sp = std::make_shared<TypeEnumMemberImpl>(rhs.ref());
   }
 }
 
 SBTypeEnumMember &SBTypeEnumMember::operator=(const SBTypeEnumMember &rhs) {
   if (this != &rhs) {
     if (rhs.IsValid())
-      m_opaque_sp.reset(new TypeEnumMemberImpl(rhs.ref()));
+      m_opaque_sp = std::make_shared<TypeEnumMemberImpl>(rhs.ref());
   }
   return *this;
 }
 
 bool SBTypeEnumMember::IsValid() const { return m_opaque_sp.get(); }
 
 const char *SBTypeEnumMember::GetName() {
   if (m_opaque_sp.get())

 }
 
 void SBTypeEnumMember::reset(TypeEnumMemberImpl *type_member_impl) {
   m_opaque_sp.reset(type_member_impl);
 }
 
 TypeEnumMemberImpl &SBTypeEnumMember::ref() {
   if (m_opaque_sp.get() == NULL)
-    m_opaque_sp.reset(new TypeEnumMemberImpl());
+    m_opaque_sp = std::make_shared<TypeEnumMemberImpl>();
   return *m_opaque_sp.get();
 }
 
 const TypeEnumMemberImpl &SBTypeEnumMember::ref() const {
   return *m_opaque_sp.get();
 }
 
 SBTypeEnumMemberList::SBTypeEnumMemberList()

source/API/SBValue.cpp

 
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBExpressionOptions.h"
 #include "lldb/API/SBFrame.h"
 #include "lldb/API/SBProcess.h"
 #include "lldb/API/SBTarget.h"
 #include "lldb/API/SBThread.h"
 
+#include <memory>
+
 using namespace lldb;
 using namespace lldb_private;
 
 class ValueImpl {
 public:
   ValueImpl() {}
 
   ValueImpl(lldb::ValueObjectSP in_valobj_sp,

 
 SBType SBValue::GetType() {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   SBType sb_type;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   TypeImplSP type_sp;
   if (value_sp) {
-    type_sp.reset(new TypeImpl(value_sp->GetTypeImpl()));
+    type_sp = std::make_shared<TypeImpl>(value_sp->GetTypeImpl());
     sb_type.SetSP(type_sp);
   }
   if (log) {
     if (type_sp)
       log->Printf("SBValue(%p)::GetType => SBType(%p)",
                   static_cast<void *>(value_sp.get()),
                   static_cast<void *>(type_sp.get()));
     else

source/Breakpoint/Breakpoint.cpp

 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/ThreadSpec.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StreamString.h"
 
+#include <memory>
+
 using namespace lldb;
 using namespace lldb_private;
 using namespace llvm;
 
 const ConstString &Breakpoint::GetEventIdentifier() {
   static ConstString g_identifier("event-identifier.breakpoint.changed");
   return g_identifier;
 }
if (create_error.Fail()) {
     return result_sp;
   }
 
   StructuredData::Dictionary *filter_dict;
   success = breakpoint_dict->GetValueForKeyAsDictionary(
       SearchFilter::GetSerializationKey(), filter_dict);
   SearchFilterSP filter_sp;
   if (!success)
-    filter_sp.reset(
-        new SearchFilterForUnconstrainedSearches(target.shared_from_this()));
+    filter_sp = std::make_shared<SearchFilterForUnconstrainedSearches>(
+        target.shared_from_this());
   else {
     filter_sp = SearchFilter::CreateFromStructuredData(target, *filter_dict,
                                                        create_error);
     if (create_error.Fail()) {
       error.SetErrorStringWithFormat(
           "Error creating breakpoint filter from data: %s.",
           create_error.AsCString());
       return result_sp;

source/Commands/CommandObjectBreakpoint.cpp

 //===-- CommandObjectBreakpoint.cpp -----------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#include <vector>
-
 #include "CommandObjectBreakpoint.h"
 #include "CommandObjectBreakpointCommand.h"
 #include "lldb/Breakpoint/Breakpoint.h"
 #include "lldb/Breakpoint/BreakpointIDList.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Interpreter/CommandCompletions.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Interpreter/OptionValueBoolean.h"
 #include "lldb/Interpreter/OptionValueString.h"
 #include "lldb/Interpreter/OptionValueUInt64.h"
 #include "lldb/Interpreter/Options.h"
 #include "lldb/Target/Language.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadSpec.h"
 #include "lldb/Utility/RegularExpression.h"
 #include "lldb/Utility/StreamString.h"
 
+#include <memory>
+#include <vector>
+
 using namespace lldb;
 using namespace lldb_private;
 
 static void AddBreakpointDescription(Stream *s, Breakpoint *bp,
                                      lldb::DescriptionLevel level) {
   s->IndentMore();
   bp->GetDescription(s, level, true);
   s->IndentLess();
void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_language = lldb::eLanguageTypeUnknown;
       m_skip_prologue = eLazyBoolCalculate;
       m_breakpoint_names.clear();
       m_all_files = false;
       m_exception_extra_args.Clear();
       m_move_to_nearest_code = eLazyBoolCalculate;
       m_source_regex_func_names.clear();
       m_python_class.clear();
-      m_extra_args_sp.reset(new StructuredData::Dictionary());
+      m_extra_args_sp = std::make_shared<StructuredData::Dictionary>();
       m_current_key.clear();
     }
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_breakpoint_set_options);
     }
 
     // Instance variables to hold the values for command options.

source/Commands/CommandObjectFrame.cpp

 //===-- CommandObjectFrame.cpp ----------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
-
-#include <string>
-
 #include "CommandObjectFrame.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectVariable.h"
 #include "lldb/DataFormatters/DataVisualization.h"

 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/Args.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/Timer.h"
 
+#include <memory>
+#include <string>
+
 using namespace lldb;
 using namespace lldb_private;
 
 #pragma mark CommandObjectFrameDiagnose
 
 //-------------------------------------------------------------------------
 // CommandObjectFrameInfo
 //-------------------------------------------------------------------------
bool DoExecute(Args &command, CommandReturnObject &result) override {
     ValueObjectSP valobj_sp;
 
     TypeSummaryImplSP summary_format_sp;
     if (!m_option_variable.summary.IsCurrentValueEmpty())
       DataVisualization::NamedSummaryFormats::GetSummaryFormat(
           ConstString(m_option_variable.summary.GetCurrentValue()),
           summary_format_sp);
     else if (!m_option_variable.summary_string.IsCurrentValueEmpty())
-      summary_format_sp.reset(new StringSummaryFormat(
+      summary_format_sp = std::make_shared<StringSummaryFormat>(
           TypeSummaryImpl::Flags(),
-          m_option_variable.summary_string.GetCurrentValue()));
+          m_option_variable.summary_string.GetCurrentValue());
 
     DumpValueObjectOptions options(m_varobj_options.GetAsDumpOptions(
         eLanguageRuntimeDescriptionDisplayVerbosityFull, eFormatDefault,
         summary_format_sp));
 
     const SymbolContext &sym_ctx =
         frame->GetSymbolContext(eSymbolContextFunction);
     if (sym_ctx.function && sym_ctx.function->IsTopLevelFunction())

source/Commands/CommandObjectMemory.cpp

 //===-- CommandObjectMemory.cpp ---------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#include <inttypes.h>
-
 #include "clang/AST/Decl.h"
 
 #include "CommandObjectMemory.h"
 #include "Plugins/ExpressionParser/Clang/ClangPersistentVariables.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/DumpDataExtractor.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/Section.h"

 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/Args.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataBufferLLVM.h"
 #include "lldb/Utility/StreamString.h"
 
 #include "lldb/lldb-private.h"
 
+#include <cinttypes>
+#include <memory>
+
 using namespace lldb;
 using namespace lldb_private;
 
 static constexpr OptionDefinition g_read_memory_options[] = {
     // clang-format off
   {LLDB_OPT_SET_1, false, "num-per-line", 'l', OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeNumberPerLine, "The number of items per line to display." },
   {LLDB_OPT_SET_2, false, "binary",       'b', OptionParser::eNoArgument,       nullptr, {}, 0, eArgTypeNone,          "If true, memory will be saved as binary. If false, the memory is saved save as an ASCII dump that "
                                                                                                                             "uses the format, size, count and number per line settings." },
if (clang_ast_type.GetOpaqueQualType()) {
         return false;
       }
       bytes_read = *size * m_format_options.GetCountValue().GetCurrentValue();
 
       if (argc > 0)
         addr = addr + (*size * m_memory_options.m_offset.GetCurrentValue());
     } else if (m_format_options.GetFormatValue().GetCurrentValue() !=
                eFormatCString) {
-      data_sp.reset(new DataBufferHeap(total_byte_size, '\0'));
+      data_sp = std::make_shared<DataBufferHeap>(total_byte_size, '\0');
       if (data_sp->GetBytes() == nullptr) {
         result.AppendErrorWithFormat(
             "can't allocate 0x%" PRIx32
             " bytes for the memory read buffer, specify a smaller size to read",
             (uint32_t)total_byte_size);
         result.SetStatus(eReturnStatusFailed);
         return false;
       }
if (clang_ast_type.GetOpaqueQualType()) {
       // size
       if (m_format_options.GetByteSizeValue().OptionWasSet() &&
           !m_format_options.HasGDBFormat())
         item_byte_size = m_format_options.GetByteSizeValue().GetCurrentValue();
       else
         item_byte_size = target->GetMaximumSizeOfStringSummary();
       if (!m_format_options.GetCountValue().OptionWasSet())
         item_count = 1;
-      data_sp.reset(new DataBufferHeap((item_byte_size + 1) * item_count,
-                                       '\0')); // account for NULLs as necessary
+      data_sp = std::make_shared<DataBufferHeap>(
+          (item_byte_size + 1) * item_count,
+          '\0'); // account for NULLs as necessary
       if (data_sp->GetBytes() == nullptr) {
         result.AppendErrorWithFormat(
             "can't allocate 0x%" PRIx64
             " bytes for the memory read buffer, specify a smaller size to read",
             (uint64_t)((item_byte_size + 1) * item_count));
         result.SetStatus(eReturnStatusFailed);
         return false;
       }
if (clang_ast_type.GetOpaqueQualType()) {
         data_addr += read;
         bytes_read += read;
         item_count++; // if we break early we know we only read item_count
                       // strings
 
         if (break_on_no_NULL)
           break;
       }
-      data_sp.reset(new DataBufferHeap(data_sp->GetBytes(), bytes_read + 1));
+      data_sp =
+          std::make_shared<DataBufferHeap>(data_sp->GetBytes(), bytes_read + 1);
     }
 
     m_next_addr = addr + bytes_read;
     m_prev_byte_size = bytes_read;
     m_prev_format_options = m_format_options;
     m_prev_memory_options = m_memory_options;
     m_prev_outfile_options = m_outfile_options;
     m_prev_varobj_options = m_varobj_options;

source/Commands/CommandObjectType.cpp

 //===-- CommandObjectType.cpp -----------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "CommandObjectType.h"
 
-#include <algorithm>
-#include <cctype>
-#include <functional>
-
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/IOHandler.h"
 #include "lldb/DataFormatters/DataVisualization.h"
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandObject.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/OptionArgParser.h"

 #include "lldb/Target/ThreadList.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/RegularExpression.h"
 #include "lldb/Utility/State.h"
 #include "lldb/Utility/StringList.h"
 
 #include "llvm/ADT/STLExtras.h"
 
+#include <algorithm>
+#include <cctype>
+#include <functional>
+#include <memory>
+
 using namespace lldb;
 using namespace lldb_private;
 
 class ScriptAddOptions {
 public:
   TypeSummaryImpl::Flags m_flags;
   StringList m_target_types;
   bool m_regex;
if (interpreter) {
                 error_sp->Printf("unable to obtain a valid function name from "
                                  "the script interpreter.\n");
                 error_sp->Flush();
               } else {
                 // now I have a valid function name, let's add this as script
                 // for every type in the list
 
                 TypeSummaryImplSP script_format;
-                script_format.reset(new ScriptSummaryFormat(
+                script_format = std::make_shared<ScriptSummaryFormat>(
                     options->m_flags, funct_name_str.c_str(),
-                    lines.CopyList("    ").c_str()));
+                    lines.CopyList("    ").c_str());
 
                 Status error;
 
                 for (size_t i = 0; i < options->m_target_types.GetSize(); i++) {
                   const char *type_name =
                       options->m_target_types.GetStringAtIndex(i);
                   CommandObjectTypeSummaryAdd::AddSummary(
                       ConstString(type_name), script_format,
if (interpreter) {
                 error_sp->Printf(
                     "error: unable to obtain a proper name for the class.\n");
                 error_sp->Flush();
               } else {
                 // everything should be fine now, let's add the synth provider
                 // class
 
                 SyntheticChildrenSP synth_provider;
-                synth_provider.reset(new ScriptedSyntheticChildren(
+                synth_provider = std::make_shared<ScriptedSyntheticChildren>(
                     SyntheticChildren::Flags()
                         .SetCascades(options->m_cascade)
                         .SetSkipPointers(options->m_skip_pointers)
                         .SetSkipReferences(options->m_skip_references),
-                    class_name_str.c_str()));
+                    class_name_str.c_str());
 
                 lldb::TypeCategoryImplSP category;
                 DataVisualization::Categories::GetCategory(
                     ConstString(options->m_category.c_str()), category);
 
                 Status error;
 
                 for (size_t i = 0; i < options->m_target_types.GetSize(); i++) {
if (format == eFormatInvalid &&
                                    m_cmd_name.c_str());
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     TypeFormatImplSP entry;
 
     if (m_command_options.m_custom_type_name.empty())
-      entry.reset(new TypeFormatImpl_Format(
+      entry = std::make_shared<TypeFormatImpl_Format>(
           format, TypeFormatImpl::Flags()
                       .SetCascades(m_command_options.m_cascade)
                       .SetSkipPointers(m_command_options.m_skip_pointers)
-                      .SetSkipReferences(m_command_options.m_skip_references)));
+                      .SetSkipReferences(m_command_options.m_skip_references));
     else
-      entry.reset(new TypeFormatImpl_EnumType(
+      entry = std::make_shared<TypeFormatImpl_EnumType>(
           ConstString(m_command_options.m_custom_type_name.c_str()),
           TypeFormatImpl::Flags()
               .SetCascades(m_command_options.m_cascade)
               .SetSkipPointers(m_command_options.m_skip_pointers)
-              .SetSkipReferences(m_command_options.m_skip_references)));
+              .SetSkipReferences(m_command_options.m_skip_references));
 
     // now I have a valid format, let's add it to every type
 
     TypeCategoryImplSP category_sp;
     DataVisualization::Categories::GetCategory(
         ConstString(m_command_options.m_category), category_sp);
     if (!category_sp)
       return false;
if (!funct_name || !funct_name[0]) {
       result.AppendError("function name empty.\n");
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     std::string code =
         ("    " + m_options.m_python_function + "(valobj,internal_dict)");
 
-    script_format.reset(
-        new ScriptSummaryFormat(m_options.m_flags, funct_name, code.c_str()));
+    script_format = std::make_shared<ScriptSummaryFormat>(
+        m_options.m_flags, funct_name, code.c_str());
 
     ScriptInterpreter *interpreter = m_interpreter.GetScriptInterpreter();
 
     if (interpreter && !interpreter->CheckObjectExists(funct_name))
       result.AppendWarningWithFormat(
           "The provided function \"%s\" does not exist - "
           "please define it before attempting to use this summary.\n",
           funct_name);
if (funct_name_str.empty()) {
       result.AppendError(
           "script interpreter failed to generate a valid function name.\n");
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     std::string code = "    " + m_options.m_python_script;
 
-    script_format.reset(new ScriptSummaryFormat(
-        m_options.m_flags, funct_name_str.c_str(), code.c_str()));
+    script_format = std::make_shared<ScriptSummaryFormat>(
+        m_options.m_flags, funct_name_str.c_str(), code.c_str());
   } else {
     // Use an IOHandler to grab Python code from the user
     ScriptAddOptions *options =
         new ScriptAddOptions(m_options.m_flags, m_options.m_regex,
                              m_options.m_name, m_options.m_category);
 
     for (auto &entry : command.entries()) {
       if (entry.ref.empty()) {

source/Core/IOHandler.cpp

void Touch() {
     if (m_parent)
       m_parent->Touch();
   }
 
   WindowSP CreateSubWindow(const char *name, const Rect &bounds,
                            bool make_active) {
     WindowSP subwindow_sp;
     if (m_window) {
-      subwindow_sp.reset(new Window(
-          name, ::subwin(m_window, bounds.size.height, bounds.size.width,
+      subwindow_sp = std::make_shared<Window>(
+          name,
+          ::subwin(m_window, bounds.size.height, bounds.size.width,
                          bounds.origin.y, bounds.origin.x),
-          true));
+          true);
       subwindow_sp->m_is_subwin = true;
     } else {
-      subwindow_sp.reset(
-          new Window(name, ::newwin(bounds.size.height, bounds.size.width,
-                                    bounds.origin.y, bounds.origin.x),
-                     true));
+      subwindow_sp = std::make_shared<Window>(
+          name,
+          ::newwin(bounds.size.height, bounds.size.width, bounds.origin.y,
+                   bounds.origin.x),
+          true);
       subwindow_sp->m_is_subwin = false;
     }
     subwindow_sp->m_parent = this;
     if (make_active) {
       m_prev_active_window_idx = m_curr_active_window_idx;
       m_curr_active_window_idx = m_subwindows.size();
     }
     m_subwindows.push_back(subwindow_sp);
#endif
       }
     }
 
     debugger.CancelForwardEvents(listener_sp);
   }
 
   WindowSP &GetMainWindow() {
     if (!m_window_sp)
-      m_window_sp.reset(new Window("main", stdscr, false));
+      m_window_sp = std::make_shared<Window>("main", stdscr, false);
     return m_window_sp;
   }
 
   WindowDelegates &GetWindowDelegates() { return m_window_delegates; }
 
 protected:
   WindowSP m_window_sp;
   WindowDelegates m_window_delegates;
if (process_sp && process_sp->IsAlive()) {
       if (StateIsStoppedState(state, true)) {
         ThreadSP thread_sp = GetThread(item);
         if (thread_sp) {
           if (m_stop_id == process_sp->GetStopID() &&
               thread_sp->GetID() == m_tid)
             return; // Children are already up to date
           if (!m_frame_delegate_sp) {
             // Always expand the thread item the first time we show it
-            m_frame_delegate_sp.reset(new FrameTreeDelegate());
+            m_frame_delegate_sp = std::make_shared<FrameTreeDelegate>();
           }
 
           m_stop_id = process_sp->GetStopID();
           m_tid = thread_sp->GetID();
 
           TreeItem t(&item, *m_frame_delegate_sp, false);
           size_t num_frames = thread_sp->GetStackFrameCount();
           item.Resize(num_frames, t);
if (process_sp && process_sp->IsAlive()) {
         if (m_stop_id == stop_id)
           return; // Children are already up to date
 
         m_stop_id = stop_id;
 
         if (!m_thread_delegate_sp) {
           // Always expand the thread item the first time we show it
           // item.Expand();
-          m_thread_delegate_sp.reset(new ThreadTreeDelegate(m_debugger));
+          m_thread_delegate_sp =
+              std::make_shared<ThreadTreeDelegate>(m_debugger);
         }
 
         TreeItem t(&item, *m_thread_delegate_sp, false);
         ThreadList &threads = process_sp->GetThreadList();
         std::lock_guard<std::recursive_mutex> guard(threads.GetMutex());
         size_t num_threads = threads.GetSize();
         item.Resize(num_threads, t);
         for (size_t i = 0; i < num_threads; ++i) {

source/Core/ModuleList.cpp

static constexpr PropertyDefinition g_properties[] = {
      {},
      "The path to the clang modules cache directory (-fmodules-cache-path)."}};
 
 enum { ePropertyEnableExternalLookup, ePropertyClangModulesCachePath };
 
 } // namespace
 
 ModuleListProperties::ModuleListProperties() {
-  m_collection_sp.reset(new OptionValueProperties(ConstString("symbols")));
+  m_collection_sp =
+      std::make_shared<OptionValueProperties>(ConstString("symbols"));
   m_collection_sp->Initialize(g_properties);
 
   llvm::SmallString<128> path;
   clang::driver::Driver::getDefaultModuleCachePath(path);
   SetClangModulesCachePath(path);
 }
 
 bool ModuleListProperties::GetEnableExternalLookup() const {
if (num_matching_modules > 0) {
         }
       }
     }
   }
 
   if (module_sp)
     return error;
 
-  module_sp.reset(new Module(module_spec));
+  module_sp = std::make_shared<Module>(module_spec);
   // Make sure there are a module and an object file since we can specify a
   // valid file path with an architecture that might not be in that file. By
   // getting the object file we can guarantee that the architecture matches
   if (module_sp->GetObjectFile()) {
     // If we get in here we got the correct arch, now we just need to verify
     // the UUID if one was given
     if (uuid_ptr && *uuid_ptr != module_sp->GetUUID()) {
       module_sp.reset();
for (size_t idx = 0; idx < num_directories; ++idx) {
         continue;
       search_path_spec.AppendPathComponent(
           module_spec.GetFileSpec().GetFilename().AsCString());
       if (!FileSystem::Instance().Exists(search_path_spec))
         continue;
 
       auto resolved_module_spec(module_spec);
       resolved_module_spec.GetFileSpec() = search_path_spec;
-      module_sp.reset(new Module(resolved_module_spec));
+      module_sp = std::make_shared<Module>(resolved_module_spec);
       if (module_sp->GetObjectFile()) {
         // If we get in here we got the correct arch, now we just need to
         // verify the UUID if one was given
         if (uuid_ptr && *uuid_ptr != module_sp->GetUUID()) {
           module_sp.reset();
         } else {
           if (module_sp->GetObjectFile()->GetType() ==
               ObjectFile::eTypeStubLibrary) {
if (shared_module_list.FindModules(platform_module_spec,
             shared_module_list.Remove(module_sp);
             module_sp.reset();
           }
         }
       }
     }
 
     if (!module_sp) {
-      module_sp.reset(new Module(platform_module_spec));
+      module_sp = std::make_shared<Module>(platform_module_spec);
       // Make sure there are a module and an object file since we can specify a
       // valid file path with an architecture that might not be in that file.
       // By getting the object file we can guarantee that the architecture
       // matches
       if (module_sp && module_sp->GetObjectFile()) {
         if (module_sp->GetObjectFile()->GetType() ==
             ObjectFile::eTypeStubLibrary) {
           module_sp.reset();

source/Core/ValueObject.cpp

bool ValueObject::SetData(DataExtractor &data, Status &error) {
   // If we have reached this point, then we have successfully changed the
   // value.
   SetNeedsUpdate();
   return true;
 }
 
 static bool CopyStringDataToBufferSP(const StreamString &source,
                                      lldb::DataBufferSP &destination) {
-  destination.reset(new DataBufferHeap(source.GetSize() + 1, 0));
+  destination = std::make_shared<DataBufferHeap>(source.GetSize() + 1, 0);
   memcpy(destination->GetBytes(), source.GetString().data(), source.GetSize());
   return true;
 }
 
 std::pair<size_t, bool>
 ValueObject::ReadPointedString(lldb::DataBufferSP &buffer_sp, Status &error,
                                uint32_t max_length, bool honor_array,
                                Format item_format) {
if (cstr_address == 0 || cstr_address == LLDB_INVALID_ADDRESS) {
       if (cstr_address_type == eAddressTypeHost && is_array) {
         const char *cstr = GetDataExtractor().PeekCStr(0);
         if (cstr == nullptr) {
           s << "<invalid address>";
           error.SetErrorString("invalid address");
           CopyStringDataToBufferSP(s, buffer_sp);
           return {0, was_capped};
         }
-        buffer_sp.reset(new DataBufferHeap(cstr_len, 0));
+        buffer_sp = std::make_shared<DataBufferHeap>(cstr_len, 0);
         memcpy(buffer_sp->GetBytes(), cstr, cstr_len);
         return {cstr_len, was_capped};
       } else {
         s << "<invalid address>";
         error.SetErrorString("invalid address");
         CopyStringDataToBufferSP(s, buffer_sp);
         return {0, was_capped};
       }
if (my_format == lldb::eFormatDefault) {
             my_format = GetValue().GetCompilerType().GetFormat();
           }
         }
       }
     }
     if (my_format != m_last_format || m_value_str.empty()) {
       m_last_format = my_format;
       if (!format_sp)
-        format_sp.reset(new TypeFormatImpl_Format(my_format));
+        format_sp = std::make_shared<TypeFormatImpl_Format>(my_format);
       if (GetValueAsCString(*format_sp.get(), m_value_str)) {
         if (!m_value_did_change && m_old_value_valid) {
           // The value was gotten successfully, so we consider the value as
           // changed if the value string differs
           SetValueDidChange(m_old_value_str != m_value_str);
         }
       }
     }

source/DataFormatters/StringPrinter.cpp

 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/Status.h"
 
 #include "llvm/Support/ConvertUTF.h"
 
 #include <ctype.h>
 #include <locale>
+#include <memory>
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::formatters;
 
 // we define this for all values of type but only implement it for those we
 // care about that's good because we get linker errors for any unsupported type
 template <lldb_private::formatters::StringPrinter::StringElementType type>
if (zero_is_terminator) {
       data_ptr = (const SourceDataType *)data.GetDataStart();
     }
 
     lldb::DataBufferSP utf8_data_buffer_sp;
     llvm::UTF8 *utf8_data_ptr = nullptr;
     llvm::UTF8 *utf8_data_end_ptr = nullptr;
 
     if (ConvertFunction) {
-      utf8_data_buffer_sp.reset(new DataBufferHeap(4 * bufferSPSize, 0));
+      utf8_data_buffer_sp =
+          std::make_shared<DataBufferHeap>(4 * bufferSPSize, 0);
       utf8_data_ptr = (llvm::UTF8 *)utf8_data_buffer_sp->GetBytes();
       utf8_data_end_ptr = utf8_data_ptr + utf8_data_buffer_sp->GetByteSize();
       ConvertFunction(&data_ptr, data_end_ptr, &utf8_data_ptr,
                       utf8_data_end_ptr, llvm::lenientConversion);
       if (!zero_is_terminator)
         utf8_data_end_ptr = utf8_data_ptr;
       // needed because the ConvertFunction will change the value of the
       // data_ptr.

source/Expression/Materializer.cpp

 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/RegisterValue.h"
 
+#include <memory>
+
 using namespace lldb_private;
 
 uint32_t Materializer::AddStructMember(Entity &entity) {
   uint32_t size = entity.GetSize();
   uint32_t alignment = entity.GetAlignment();
 
   uint32_t ret;
 
if (m_is_reference) {
 
         m_temporary_allocation = map.Malloc(
             data.GetByteSize(), byte_align,
             lldb::ePermissionsReadable | lldb::ePermissionsWritable,
             IRMemoryMap::eAllocationPolicyMirror, zero_memory, alloc_error);
 
         m_temporary_allocation_size = data.GetByteSize();
 
-        m_original_data.reset(
-            new DataBufferHeap(data.GetDataStart(), data.GetByteSize()));
+        m_original_data = std::make_shared<DataBufferHeap>(data.GetDataStart(),
+                                                           data.GetByteSize());
 
         if (!alloc_error.Success()) {
           err.SetErrorStringWithFormat(
               "couldn't allocate a temporary region for %s: %s",
               m_variable_sp->GetName().AsCString(), alloc_error.AsCString());
           return;
         }
 
void Materialize(lldb::StackFrameSP &frame_sp, IRMemoryMap &map,
     if (register_data.GetByteSize() != m_register_info.byte_size) {
       err.SetErrorStringWithFormat(
           "data for register %s had size %llu but we expected %llu",
           m_register_info.name, (unsigned long long)register_data.GetByteSize(),
           (unsigned long long)m_register_info.byte_size);
       return;
     }
 
-    m_register_contents.reset(new DataBufferHeap(register_data.GetDataStart(),
-                                                 register_data.GetByteSize()));
+    m_register_contents = std::make_shared<DataBufferHeap>(
+        register_data.GetDataStart(), register_data.GetByteSize());
 
     Status write_error;
 
     map.WriteMemory(load_addr, register_data.GetDataStart(),
                     register_data.GetByteSize(), write_error);
 
     if (!write_error.Success()) {
       err.SetErrorStringWithFormat(

source/Expression/REPL.cpp

 #include "lldb/Expression/UserExpression.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/AnsiTerminal.h"
 
+#include <memory>
+
 using namespace lldb_private;
 
 REPL::REPL(LLVMCastKind kind, Target &target) : m_target(target), m_kind(kind) {
   // Make sure all option values have sane defaults
   Debugger &debugger = m_target.GetDebugger();
   auto exe_ctx = debugger.GetCommandInterpreter().GetExecutionContext();
   m_format_options.OptionParsingStarting(&exe_ctx);
   m_varobj_options.OptionParsingStarting(&exe_ctx);
std::string REPL::GetSourcePath() {
   }
 
   return tmpdir_file_spec.GetPath();
 }
 
 lldb::IOHandlerSP REPL::GetIOHandler() {
   if (!m_io_handler_sp) {
     Debugger &debugger = m_target.GetDebugger();
-    m_io_handler_sp.reset(
-        new IOHandlerEditline(debugger, IOHandler::Type::REPL,
+    m_io_handler_sp = std::make_shared<IOHandlerEditline>(
+        debugger, IOHandler::Type::REPL,
                               "lldb-repl", // Name of input reader for history
                               llvm::StringRef("> "), // prompt
                               llvm::StringRef(". "), // Continuation prompt
                               true,                  // Multi-line
                               true, // The REPL prompt is always colored
                               1,    // Line number
-                              *this));
+        *this);
 
     // Don't exit if CTRL+C is pressed
     static_cast<IOHandlerEditline *>(m_io_handler_sp.get())
         ->SetInterruptExits(false);
 
     if (m_io_handler_sp->GetIsInteractive() &&
         m_io_handler_sp->GetIsRealTerminal()) {
       m_indent_str.assign(debugger.GetTabSize(), ' ');

source/Host/posix/ConnectionFileDescriptorPosix.cpp

 #include <string.h>
 #include <sys/types.h>
 
 #ifndef LLDB_DISABLE_POSIX
 #include <termios.h>
 #include <unistd.h>
 #endif
 
+#include <memory>
 #include <sstream>
 
 #include "llvm/Support/Errno.h"
 #include "llvm/Support/ErrorHandling.h"
 #if defined(__APPLE__)
 #include "llvm/ADT/SmallVector.h"
 #endif
 #include "lldb/Host/Host.h"
ConnectionFileDescriptor::ConnectionFileDescriptor(bool child_processes_inherit)
   if (log)
     log->Printf("%p ConnectionFileDescriptor::ConnectionFileDescriptor ()",
                 static_cast<void *>(this));
 }
 
 ConnectionFileDescriptor::ConnectionFileDescriptor(int fd, bool owns_fd)
     : Connection(), m_pipe(), m_mutex(), m_shutting_down(false),
       m_waiting_for_accept(false), m_child_processes_inherit(false) {
-  m_write_sp.reset(new File(fd, owns_fd));
-  m_read_sp.reset(new File(fd, false));
+  m_write_sp = std::make_shared<File>(fd, owns_fd);
+  m_read_sp = std::make_shared<File>(fd, false);
 
   Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_CONNECTION |
                                                   LIBLLDB_LOG_OBJECT));
   if (log)
     log->Printf("%p ConnectionFileDescriptor::ConnectionFileDescriptor (fd = "
                 "%i, owns_fd = %i)",
                 static_cast<void *>(this), fd, owns_fd);
   OpenCommandPipe();
else if ((addr = GetURLAddress(path, FD_SCHEME))) {
           // this is a socket and set m_is_socket accordingly.
           int resuse;
           bool is_socket =
               !!tcp_socket->GetOption(SOL_SOCKET, SO_REUSEADDR, resuse);
           if (is_socket) {
             m_read_sp = std::move(tcp_socket);
             m_write_sp = m_read_sp;
           } else {
-            m_read_sp.reset(new File(fd, false));
-            m_write_sp.reset(new File(fd, false));
+            m_read_sp = std::make_shared<File>(fd, false);
+            m_write_sp = std::make_shared<File>(fd, false);
           }
           m_uri = *addr;
           return eConnectionStatusSuccess;
         }
       }
 
       if (error_ptr)
         error_ptr->SetErrorStringWithFormat("invalid file descriptor: \"%s\"",
else if ((addr = GetURLAddress(path, FD_SCHEME))) {
 
       int flags = ::fcntl(fd, F_GETFL, 0);
       if (flags >= 0) {
         if ((flags & O_NONBLOCK) == 0) {
           flags |= O_NONBLOCK;
           ::fcntl(fd, F_SETFL, flags);
         }
       }
-      m_read_sp.reset(new File(fd, true));
-      m_write_sp.reset(new File(fd, false));
+      m_read_sp = std::make_shared<File>(fd, true);
+      m_write_sp = std::make_shared<File>(fd, false);
       return eConnectionStatusSuccess;
     }
 #endif
     if (error_ptr)
       error_ptr->SetErrorStringWithFormat("unsupported connection URL: '%s'",
                                           path.str().c_str());
     return eConnectionStatusError;
   }

source/Interpreter/CommandInterpreter.cpp

 //===-- CommandInterpreter.cpp ----------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include <memory>
 #include <stdlib.h>
 #include <string>
 #include <vector>
 
 #include "CommandObjectScript.h"
 #include "lldb/Interpreter/CommandObjectRegexCommand.h"
 
 #include "Commands/CommandObjectApropos.h"
void CommandInterpreter::Initialize() {
   cmd_obj_sp = GetCommandSPExact("target create", false);
   if (cmd_obj_sp)
     AddAlias("file", cmd_obj_sp);
 
   cmd_obj_sp = GetCommandSPExact("target modules", false);
   if (cmd_obj_sp)
     AddAlias("image", cmd_obj_sp);
 
-  alias_arguments_vector_sp.reset(new OptionArgVector);
+  alias_arguments_vector_sp = std::make_shared<OptionArgVector>();
 
   cmd_obj_sp = GetCommandSPExact("expression", false);
   if (cmd_obj_sp) {
     AddAlias("p", cmd_obj_sp, "--")->SetHelpLong("");
     AddAlias("print", cmd_obj_sp, "--")->SetHelpLong("");
     AddAlias("call", cmd_obj_sp, "--")->SetHelpLong("");
     if (auto po = AddAlias("po", cmd_obj_sp, "-O --")) {
       po->SetHelp("Evaluate an expression on the current thread.  Displays any "
void CommandInterpreter::Initialize() {
 
   cmd_obj_sp = GetCommandSPExact("process kill", false);
   if (cmd_obj_sp) {
     AddAlias("kill", cmd_obj_sp);
   }
 
   cmd_obj_sp = GetCommandSPExact("process launch", false);
   if (cmd_obj_sp) {
-    alias_arguments_vector_sp.reset(new OptionArgVector);
+    alias_arguments_vector_sp = std::make_shared<OptionArgVector>();
 #if defined(__arm__) || defined(__arm64__) || defined(__aarch64__)
     AddAlias("r", cmd_obj_sp, "--");
     AddAlias("run", cmd_obj_sp, "--");
 #else
 #if defined(__APPLE__)
     std::string shell_option;
     shell_option.append("--shell-expand-args");
     shell_option.append(" true");
if (options) {
       if (options->m_echo_comment_commands != eLazyBoolNo)
         flags |= eHandleCommandFlagEchoCommentCommand;
       if (options->m_print_results != eLazyBoolNo)
         flags |= eHandleCommandFlagPrintResult;
     } else {
       flags = eHandleCommandFlagEchoCommand | eHandleCommandFlagPrintResult;
     }
 
-    m_command_io_handler_sp.reset(new IOHandlerEditline(
+    m_command_io_handler_sp = std::make_shared<IOHandlerEditline>(
         m_debugger, IOHandler::Type::CommandInterpreter,
         m_debugger.GetInputFile(), m_debugger.GetOutputFile(),
         m_debugger.GetErrorFile(), flags, "lldb", m_debugger.GetPrompt(),
         llvm::StringRef(), // Continuation prompt
         false, // Don't enable multiple line input, just single line commands
         m_debugger.GetUseColor(),
         0, // Don't show line numbers
-        *this));
+        *this);
   }
   return m_command_io_handler_sp;
 }
 
 void CommandInterpreter::RunCommandInterpreter(
     bool auto_handle_events, bool spawn_thread,
     CommandInterpreterRunOptions &options) {
   // Always re-create the command interpreter when we run it in case any file

source/Interpreter/Property.cpp

 
 #include "lldb/Core/UserSettingsController.h"
 #include "lldb/Host/StringConvert.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Interpreter/OptionValues.h"
 #include "lldb/Target/Language.h"
 
+#include <memory>
+
 using namespace lldb;
 using namespace lldb_private;
 
 Property::Property(const PropertyDefinition &definition)
     : m_name(definition.name), m_description(definition.description),
       m_value_sp(), m_is_global(definition.global) {
   switch (definition.type) {
   case OptionValue::eTypeInvalid:
   case OptionValue::eTypeProperties:
     break;
   case OptionValue::eTypeArch:
     // "definition.default_uint_value" is not used
     // "definition.default_cstr_value" as a string value that represents the
     // default string value for the architecture/triple
-    m_value_sp.reset(new OptionValueArch(definition.default_cstr_value));
+    m_value_sp =
+        std::make_shared<OptionValueArch>(definition.default_cstr_value);
     break;
 
   case OptionValue::eTypeArgs:
     // "definition.default_uint_value" is always a OptionValue::Type
-    m_value_sp.reset(new OptionValueArgs());
+    m_value_sp = std::make_shared<OptionValueArgs>();
     break;
 
   case OptionValue::eTypeArray:
     // "definition.default_uint_value" is always a OptionValue::Type
-    m_value_sp.reset(new OptionValueArray(OptionValue::ConvertTypeToMask(
-        (OptionValue::Type)definition.default_uint_value)));
+    m_value_sp =
+        std::make_shared<OptionValueArray>(OptionValue::ConvertTypeToMask(
+            (OptionValue::Type)definition.default_uint_value));
     break;
 
   case OptionValue::eTypeBoolean:
     // "definition.default_uint_value" is the default boolean value if
     // "definition.default_cstr_value" is NULL, otherwise interpret
     // "definition.default_cstr_value" as a string value that represents the
     // default value.
     if (definition.default_cstr_value)
-      m_value_sp.reset(new OptionValueBoolean(OptionArgParser::ToBoolean(
-          llvm::StringRef(definition.default_cstr_value), false, nullptr)));
+      m_value_sp =
+          std::make_shared<OptionValueBoolean>(OptionArgParser::ToBoolean(
+              llvm::StringRef(definition.default_cstr_value), false, nullptr));
     else
-      m_value_sp.reset(
-          new OptionValueBoolean(definition.default_uint_value != 0));
+      m_value_sp = std::make_shared<OptionValueBoolean>(
+          definition.default_uint_value != 0);
     break;
 
   case OptionValue::eTypeChar: {
     llvm::StringRef s(definition.default_cstr_value ? definition.default_cstr_value : "");
     m_value_sp = std::make_shared<OptionValueChar>(
         OptionArgParser::ToChar(s, '\0', nullptr));
     break;
   }
   case OptionValue::eTypeDictionary:
     // "definition.default_uint_value" is always a OptionValue::Type
-    m_value_sp.reset(new OptionValueDictionary(OptionValue::ConvertTypeToMask(
-        (OptionValue::Type)definition.default_uint_value)));
+    m_value_sp =
+        std::make_shared<OptionValueDictionary>(OptionValue::ConvertTypeToMask(
+            (OptionValue::Type)definition.default_uint_value));
     break;
 
   case OptionValue::eTypeEnum:
     // "definition.default_uint_value" is the default enumeration value if
     // "definition.default_cstr_value" is NULL, otherwise interpret
     // "definition.default_cstr_value" as a string value that represents the
     // default value.
     {
Property::Property(const PropertyDefinition &definition)
 
   case OptionValue::eTypeFileSpec: {
     // "definition.default_uint_value" represents if the
     // "definition.default_cstr_value" should be resolved or not
     const bool resolve = definition.default_uint_value != 0;
     FileSpec file_spec = FileSpec(definition.default_cstr_value);
     if (resolve)
       FileSystem::Instance().Resolve(file_spec);
-    m_value_sp.reset(new OptionValueFileSpec(file_spec, resolve));
+    m_value_sp = std::make_shared<OptionValueFileSpec>(file_spec, resolve);
     break;
   }
 
   case OptionValue::eTypeFileSpecList:
     // "definition.default_uint_value" is not used for a
     // OptionValue::eTypeFileSpecList
-    m_value_sp.reset(new OptionValueFileSpecList());
+    m_value_sp = std::make_shared<OptionValueFileSpecList>();
     break;
 
   case OptionValue::eTypeFormat:
     // "definition.default_uint_value" is the default format enumeration value
     // if "definition.default_cstr_value" is NULL, otherwise interpret
     // "definition.default_cstr_value" as a string value that represents the
     // default value.
     {
       Format new_format = eFormatInvalid;
       if (definition.default_cstr_value)
         OptionArgParser::ToFormat(definition.default_cstr_value, new_format,
                                   nullptr);
       else
         new_format = (Format)definition.default_uint_value;
-      m_value_sp.reset(new OptionValueFormat(new_format));
+      m_value_sp = std::make_shared<OptionValueFormat>(new_format);
     }
     break;
 
   case OptionValue::eTypeLanguage:
     // "definition.default_uint_value" is the default language enumeration
     // value if "definition.default_cstr_value" is NULL, otherwise interpret
     // "definition.default_cstr_value" as a string value that represents the
     // default value.
     {
       LanguageType new_lang = eLanguageTypeUnknown;
       if (definition.default_cstr_value)
         Language::GetLanguageTypeFromString(
             llvm::StringRef(definition.default_cstr_value));
       else
         new_lang = (LanguageType)definition.default_uint_value;
-      m_value_sp.reset(new OptionValueLanguage(new_lang));
+      m_value_sp = std::make_shared<OptionValueLanguage>(new_lang);
     }
     break;
 
   case OptionValue::eTypeFormatEntity:
     // "definition.default_cstr_value" as a string value that represents the
     // default
-    m_value_sp.reset(
-        new OptionValueFormatEntity(definition.default_cstr_value));
+    m_value_sp = std::make_shared<OptionValueFormatEntity>(
+        definition.default_cstr_value);
     break;
 
   case OptionValue::eTypePathMap:
     // "definition.default_uint_value" tells us if notifications should occur
     // for path mappings
-    m_value_sp.reset(
-        new OptionValuePathMappings(definition.default_uint_value != 0));
+    m_value_sp = std::make_shared<OptionValuePathMappings>(
+        definition.default_uint_value != 0);
     break;
 
   case OptionValue::eTypeRegex:
     // "definition.default_uint_value" is used to the regular expression flags
     // "definition.default_cstr_value" the default regular expression value
     // value.
-    m_value_sp.reset(new OptionValueRegex(definition.default_cstr_value));
+    m_value_sp =
+        std::make_shared<OptionValueRegex>(definition.default_cstr_value);
     break;
 
   case OptionValue::eTypeSInt64:
     // "definition.default_uint_value" is the default integer value if
     // "definition.default_cstr_value" is NULL, otherwise interpret
     // "definition.default_cstr_value" as a string value that represents the
     // default value.
-    m_value_sp.reset(new OptionValueSInt64(
+    m_value_sp = std::make_shared<OptionValueSInt64>(
         definition.default_cstr_value
             ? StringConvert::ToSInt64(definition.default_cstr_value)
-            : definition.default_uint_value));
+            : definition.default_uint_value);
     break;
 
   case OptionValue::eTypeUInt64:
     // "definition.default_uint_value" is the default unsigned integer value if
     // "definition.default_cstr_value" is NULL, otherwise interpret
     // "definition.default_cstr_value" as a string value that represents the
     // default value.
-    m_value_sp.reset(new OptionValueUInt64(
+    m_value_sp = std::make_shared<OptionValueUInt64>(
         definition.default_cstr_value
             ? StringConvert::ToUInt64(definition.default_cstr_value)
-            : definition.default_uint_value));
+            : definition.default_uint_value);
     break;
 
   case OptionValue::eTypeUUID:
     // "definition.default_uint_value" is not used for a OptionValue::eTypeUUID
     // "definition.default_cstr_value" can contain a default UUID value
     {
       UUID uuid;
       if (definition.default_cstr_value)
         uuid.SetFromStringRef(definition.default_cstr_value);
-      m_value_sp.reset(new OptionValueUUID(uuid));
+      m_value_sp = std::make_shared<OptionValueUUID>(uuid);
     }
     break;
 
   case OptionValue::eTypeString:
     // "definition.default_uint_value" can contain the string option flags
     // OR'ed together "definition.default_cstr_value" can contain a default
     // string value
     {

source/Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.cpp

 #include "lldb/Target/ThreadPlanRunToAddress.h"
 #include "lldb/Utility/DataBuffer.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/State.h"
 
 #include "DynamicLoaderDarwinKernel.h"
 
+#include <memory>
+
 //#define ENABLE_DEBUG_PRINTF // COMMENT THIS LINE OUT PRIOR TO CHECKIN
 #ifdef ENABLE_DEBUG_PRINTF
 #include <stdio.h>
 #define DEBUG_PRINTF(fmt, ...) printf(fmt, ##__VA_ARGS__)
 #else
 #define DEBUG_PRINTF(fmt, ...)
 #endif
 

 class DynamicLoaderDarwinKernelProperties : public Properties {
 public:
   static ConstString &GetSettingName() {
     static ConstString g_setting_name("darwin-kernel");
     return g_setting_name;
   }
 
   DynamicLoaderDarwinKernelProperties() : Properties() {
-    m_collection_sp.reset(new OptionValueProperties(GetSettingName()));
+    m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName());
     m_collection_sp->Initialize(g_properties);
   }
 
   virtual ~DynamicLoaderDarwinKernelProperties() {}
 
   bool GetLoadKexts() const {
     const uint32_t idx = ePropertyLoadKexts;
     return m_collection_sp->GetPropertyAtIndexAsBoolean(
         NULL, idx, g_properties[idx].default_uint_value != 0);
   }
 
   KASLRScanType GetScanType() const {
     const uint32_t idx = ePropertyScanType;
     return (KASLRScanType)m_collection_sp->GetPropertyAtIndexAsEnumeration(
         NULL, idx, g_properties[idx].default_uint_value);
   }
 };
 
 typedef std::shared_ptr<DynamicLoaderDarwinKernelProperties>
     DynamicLoaderDarwinKernelPropertiesSP;
 
 static const DynamicLoaderDarwinKernelPropertiesSP &GetGlobalProperties() {
   static DynamicLoaderDarwinKernelPropertiesSP g_settings_sp;
   if (!g_settings_sp)
-    g_settings_sp.reset(new DynamicLoaderDarwinKernelProperties());
+    g_settings_sp = std::make_shared<DynamicLoaderDarwinKernelProperties>();
   return g_settings_sp;
 }
 
 //----------------------------------------------------------------------
 // Create an instance of this class. This function is filled into the plugin
 // info class that gets handed out by the plugin factory and allows the lldb to
 // instantiate an instance of this class.
 //----------------------------------------------------------------------
if (!m_module_sp && uuid_is_valid) {
       module_spec.GetUUID() = m_uuid;
       module_spec.GetArchitecture() = target.GetArchitecture();
 
       // For the kernel, we really do need an on-disk file copy of the binary
       // to do anything useful. This will force a clal to
       if (IsKernel()) {
         if (Symbols::DownloadObjectAndSymbolFile(module_spec, true)) {
           if (FileSystem::Instance().Exists(module_spec.GetFileSpec())) {
-            m_module_sp.reset(new Module(module_spec.GetFileSpec(),
-                                         target.GetArchitecture()));
+            m_module_sp = std::make_shared<Module>(module_spec.GetFileSpec(),
+                                                   target.GetArchitecture());
             if (m_module_sp.get() &&
                 m_module_sp->MatchesModuleSpec(module_spec)) {
               ModuleList loaded_module_list;
               loaded_module_list.Append(m_module_sp);
               target.ModulesDidLoad(loaded_module_list);
             }
           }
         }

source/Plugins/DynamicLoader/Hexagon-DYLD/DynamicLoaderHexagonDYLD.cpp

 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlanRunToAddress.h"
 #include "lldb/Utility/Log.h"
 
 #include "DynamicLoaderHexagonDYLD.h"
 
+#include <memory>
+
 using namespace lldb;
 using namespace lldb_private;
 
 // Aidan 21/05/2014
 //
 // Notes about hexagon dynamic loading:
 //
 //      When we connect to a target we find the dyld breakpoint address.  We put
DynamicLoaderHexagonDYLD::GetStepThroughTrampolinePlan(Thread &thread,
   }
 
   if (addrs.size() > 0) {
     AddressVector::iterator start = addrs.begin();
     AddressVector::iterator end = addrs.end();
 
     llvm::sort(start, end);
     addrs.erase(std::unique(start, end), end);
-    thread_plan_sp.reset(new ThreadPlanRunToAddress(thread, addrs, stop));
+    thread_plan_sp =
+        std::make_shared<ThreadPlanRunToAddress>(thread, addrs, stop);
   }
 
   return thread_plan_sp;
 }
 
 /// Helper for the entry breakpoint callback.  Resolves the load addresses
 /// of all dependent modules.
 void DynamicLoaderHexagonDYLD::LoadAllCurrentModules() {

source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderDarwin.cpp

 #endif
 
 #ifndef __APPLE__
 #include "Utility/UuidCompatibility.h"
 #else
 #include <uuid/uuid.h>
 #endif
 
+#include <memory>
+
 using namespace lldb;
 using namespace lldb_private;
 
 //----------------------------------------------------------------------
 // Constructor
 //----------------------------------------------------------------------
 DynamicLoaderDarwin::DynamicLoaderDarwin(Process *process)
     : DynamicLoader(process), m_dyld_module_wp(), m_libpthread_module_wp(),
if (addresses.size() > 0) {
               log->Printf("ResolveIndirectFunction found resolved target for "
                           "%s at 0x%" PRIx64 ".",
                           symbol->GetName().GetCString(), resolved_addr);
           }
         } else {
           load_addrs.push_back(address.GetLoadAddress(target_sp.get()));
         }
       }
-      thread_plan_sp.reset(
-          new ThreadPlanRunToAddress(thread, load_addrs, stop_others));
+      thread_plan_sp = std::make_shared<ThreadPlanRunToAddress>(
+          thread, load_addrs, stop_others);
     }
   } else {
     if (log)
       log->Printf("Could not find symbol for step through.");
   }
 
   return thread_plan_sp;
 }

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

 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlanRunToAddress.h"
 #include "lldb/Utility/Log.h"
 
+#include <memory>
 
 using namespace lldb;
 using namespace lldb_private;
 
 void DynamicLoaderPOSIXDYLD::Initialize() {
   PluginManager::RegisterPlugin(GetPluginNameStatic(),
                                 GetPluginDescriptionStatic(), CreateInstance);
 }
DynamicLoaderPOSIXDYLD::GetStepThroughTrampolinePlan(Thread &thread,
   }
 
   if (addrs.size() > 0) {
     AddressVector::iterator start = addrs.begin();
     AddressVector::iterator end = addrs.end();
 
     llvm::sort(start, end);
     addrs.erase(std::unique(start, end), end);
-    thread_plan_sp.reset(new ThreadPlanRunToAddress(thread, addrs, stop));
+    thread_plan_sp =
+        std::make_shared<ThreadPlanRunToAddress>(thread, addrs, stop);
   }
 
   return thread_plan_sp;
 }
 
 void DynamicLoaderPOSIXDYLD::LoadVDSO() {
   if (m_vdso_base == LLDB_INVALID_ADDRESS)
     return;

source/Plugins/ExpressionParser/Clang/ClangASTSource.cpp

 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Symbol/TaggedASTType.h"
 #include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/Log.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/RecordLayout.h"
 
+#include <memory>
 #include <vector>
 
 using namespace clang;
 using namespace lldb_private;
 
 //------------------------------------------------------------------
 // Scoped class that will remove an active lexical decl from the set when it
 // goes out of scope.
dyn_cast<ObjCInterfaceDecl>(context.m_decl_context)) {
       }
     }
 
     GetMergerUnchecked().FindExternalVisibleDeclsByName(context.m_decl_context,
                                                 context.m_decl_name);
     return; // otherwise we may need to fall back
   }
 
-  context.m_namespace_map.reset(new ClangASTImporter::NamespaceMap);
+  context.m_namespace_map = std::make_shared<ClangASTImporter::NamespaceMap>();
 
   if (const NamespaceDecl *namespace_context =
           dyn_cast<NamespaceDecl>(context.m_decl_context)) {
     ClangASTImporter::NamespaceMapSP namespace_map =  m_ast_importer_sp ?
         m_ast_importer_sp->GetNamespaceMap(namespace_context) : nullptr;
 
     if (log && log->GetVerbose())
       log->Printf("  CAS::FEVD[%u] Inspecting namespace map %p (%d entries)",

source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp

 //===-- ClangExpressionParser.cpp -------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#include <cctype>
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTDiagnostic.h"
 #include "clang/AST/ExternalASTSource.h"
 #include "clang/AST/PrettyPrinter.h"
 #include "clang/Basic/DiagnosticIDs.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/TargetInfo.h"

 #include "lldb/Target/ThreadPlanCallFunction.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/StringList.h"
 
+#include <cctype>
+#include <memory>
+
 using namespace clang;
 using namespace llvm;
 using namespace lldb_private;
 
 //===----------------------------------------------------------------------===//
 // Utility Methods for Clang
 //===----------------------------------------------------------------------===//
 
if (custom_passes.EarlyPasses) {
     if (log)
       log->Printf("%s - Running Early IR Passes from LanguageRuntime on "
                   "expression module '%s'",
                   __FUNCTION__, m_expr.FunctionName());
 
     custom_passes.EarlyPasses->run(*llvm_module_ap);
   }
 
-  execution_unit_sp.reset(
-      new IRExecutionUnit(m_llvm_context, // handed off here
+  execution_unit_sp = std::make_shared<IRExecutionUnit>(
+      m_llvm_context, // handed off here
                           llvm_module_ap, // handed off here
                           function_name, exe_ctx.GetTargetSP(), sc,
-                          m_compiler->getTargetOpts().Features));
+      m_compiler->getTargetOpts().Features);
 
   ClangExpressionHelper *type_system_helper =
       dyn_cast<ClangExpressionHelper>(m_expr.GetTypeSystemHelper());
   ClangExpressionDeclMap *decl_map =
       type_system_helper->DeclMap(); // result can be NULL
 
   if (decl_map) {
     Stream *error_stream = NULL;

source/Plugins/InstrumentationRuntime/MainThreadChecker/MainThreadCheckerRuntime.cpp

 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/RegularExpression.h"
 #include "Plugins/Process/Utility/HistoryThread.h"
 
+#include <memory>
+
 using namespace lldb;
 using namespace lldb_private;
 
 MainThreadCheckerRuntime::~MainThreadCheckerRuntime() {
   Deactivate();
 }
 
 lldb::InstrumentationRuntimeSP
if (ProcessSP process_sp = GetProcessSP()) {
     SetBreakpointID(LLDB_INVALID_BREAK_ID);
   }
 }
 
 lldb::ThreadCollectionSP
 MainThreadCheckerRuntime::GetBacktracesFromExtendedStopInfo(
     StructuredData::ObjectSP info) {
   ThreadCollectionSP threads;
-  threads.reset(new ThreadCollection());
+  threads = std::make_shared<ThreadCollection>();
   
   ProcessSP process_sp = GetProcessSP();
   
   if (info->GetObjectForDotSeparatedPath("instrumentation_class")
       ->GetStringValue() != "MainThreadChecker")
     return threads;
   
   std::vector<lldb::addr_t> PCs;

source/Plugins/InstrumentationRuntime/TSan/TSanRuntime.cpp

 #include "lldb/Target/InstrumentationRuntimeStopInfo.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/RegularExpression.h"
 #include "lldb/Utility/Stream.h"
 
+#include <memory>
+
 using namespace lldb;
 using namespace lldb_private;
 
 lldb::InstrumentationRuntimeSP
 ThreadSanitizerRuntime::CreateInstance(const lldb::ProcessSP &process_sp) {
   return InstrumentationRuntimeSP(new ThreadSanitizerRuntime(process_sp));
 }
 
info->GetObjectForDotSeparatedPath(path)->GetAsArray()->ForEach(
         return true;
       });
 }
 
 lldb::ThreadCollectionSP
 ThreadSanitizerRuntime::GetBacktracesFromExtendedStopInfo(
     StructuredData::ObjectSP info) {
   ThreadCollectionSP threads;
-  threads.reset(new ThreadCollection());
+  threads = std::make_shared<ThreadCollection>();
 
   if (info->GetObjectForDotSeparatedPath("instrumentation_class")
           ->GetStringValue() != "ThreadSanitizer")
     return threads;
 
   ProcessSP process_sp = GetProcessSP();
 
   AddThreadsForPath("stacks", threads, process_sp, info);
   AddThreadsForPath("mops", threads, process_sp, info);
   AddThreadsForPath("locs", threads, process_sp, info);
   AddThreadsForPath("mutexes", threads, process_sp, info);
   AddThreadsForPath("threads", threads, process_sp, info);
 
   return threads;
 }

source/Plugins/InstrumentationRuntime/UBSan/UBSanRuntime.cpp

 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/RegularExpression.h"
 #include "lldb/Utility/Stream.h"
 #include <ctype.h>
 
+#include <memory>
+
 using namespace lldb;
 using namespace lldb_private;
 
 UndefinedBehaviorSanitizerRuntime::~UndefinedBehaviorSanitizerRuntime() {
   Deactivate();
 }
 
 lldb::InstrumentationRuntimeSP
if (ProcessSP process_sp = GetProcessSP()) {
     SetBreakpointID(LLDB_INVALID_BREAK_ID);
   }
 }
 
 lldb::ThreadCollectionSP
 UndefinedBehaviorSanitizerRuntime::GetBacktracesFromExtendedStopInfo(
     StructuredData::ObjectSP info) {
   ThreadCollectionSP threads;
-  threads.reset(new ThreadCollection());
+  threads = std::make_shared<ThreadCollection>();
 
   ProcessSP process_sp = GetProcessSP();
 
   if (info->GetObjectForDotSeparatedPath("instrumentation_class")
           ->GetStringValue() != "UndefinedBehaviorSanitizer")
     return threads;
 
   std::vector<lldb::addr_t> PCs;

source/Plugins/JITLoader/GDB/JITLoaderGDB.cpp

 #include "lldb/Target/Target.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.h"
 
 #include "JITLoaderGDB.h"
 
+#include <memory>
+
 using namespace lldb;
 using namespace lldb_private;
 
 //------------------------------------------------------------------
 // Debug Interface Structures
 //------------------------------------------------------------------
 typedef enum {
   JIT_NOACTION = 0,

 
 class PluginProperties : public Properties {
 public:
   static ConstString GetSettingName() {
     return JITLoaderGDB::GetPluginNameStatic();
   }
 
   PluginProperties() {
-    m_collection_sp.reset(new OptionValueProperties(GetSettingName()));
+    m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName());
     m_collection_sp->Initialize(g_properties);
   }
 
   bool GetEnableJITBreakpoint() const {
     return m_collection_sp->GetPropertyAtIndexAsBoolean(
         nullptr, ePropertyEnableJITBreakpoint,
         g_properties[ePropertyEnableJITBreakpoint].default_uint_value != 0);
   }
lldb_private::ConstString JITLoaderGDB::GetPluginNameStatic() {
   static ConstString g_name("gdb");
   return g_name;
 }
 
 JITLoaderSP JITLoaderGDB::CreateInstance(Process *process, bool force) {
   JITLoaderSP jit_loader_sp;
   ArchSpec arch(process->GetTarget().GetArchitecture());
   if (arch.GetTriple().getVendor() != llvm::Triple::Apple)
-    jit_loader_sp.reset(new JITLoaderGDB(process));
+    jit_loader_sp = std::make_shared<JITLoaderGDB>(process);
   return jit_loader_sp;
 }
 
 const char *JITLoaderGDB::GetPluginDescriptionStatic() {
   return "JIT loader plug-in that watches for JIT events using the GDB "
          "interface.";
 }
 

source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV1.cpp

 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Scalar.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 
+#include <memory>
 #include <vector>
 
 using namespace lldb;
 using namespace lldb_private;
 
 AppleObjCRuntimeV1::AppleObjCRuntimeV1(Process *process)
     : AppleObjCRuntime(process), m_hash_signature(),
       m_isa_hash_table_ptr(LLDB_INVALID_ADDRESS) {}

 uint32_t AppleObjCRuntimeV1::GetPluginVersion() { return 1; }
 
 BreakpointResolverSP
 AppleObjCRuntimeV1::CreateExceptionResolver(Breakpoint *bkpt, bool catch_bp,
                                             bool throw_bp) {
   BreakpointResolverSP resolver_sp;
 
   if (throw_bp)
-    resolver_sp.reset(new BreakpointResolverName(
+    resolver_sp = std::make_shared<BreakpointResolverName>(
         bkpt, std::get<1>(GetExceptionThrowLocation()).AsCString(),
         eFunctionNameTypeBase, eLanguageTypeUnknown, Breakpoint::Exact, 0,
-        eLazyBoolNo));
+        eLazyBoolNo);
   // FIXME: don't do catch yet.
   return resolver_sp;
 }
 
 struct BufStruct {
   char contents[2048];
 };
 

source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp

 //===-- AppleObjCRuntimeV2.cpp ----------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include <stdint.h>
 
+#include <memory>
 #include <string>
 #include <vector>
 
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/DeclObjC.h"
 
 #include "lldb/Core/ClangForward.h"
 #include "lldb/Host/OptionParser.h"

 uint32_t AppleObjCRuntimeV2::GetPluginVersion() { return 1; }
 
 BreakpointResolverSP
 AppleObjCRuntimeV2::CreateExceptionResolver(Breakpoint *bkpt, bool catch_bp,
                                             bool throw_bp) {
   BreakpointResolverSP resolver_sp;
 
   if (throw_bp)
-    resolver_sp.reset(new BreakpointResolverName(
+    resolver_sp = std::make_shared<BreakpointResolverName>(
         bkpt, std::get<1>(GetExceptionThrowLocation()).AsCString(),
         eFunctionNameTypeBase, eLanguageTypeUnknown, Breakpoint::Exact, 0,
-        eLazyBoolNo));
+        eLazyBoolNo);
   // FIXME: We don't do catch breakpoints for ObjC yet.
   // Should there be some way for the runtime to specify what it can do in this
   // regard?
   return resolver_sp;
 }
 
 UtilityFunction *AppleObjCRuntimeV2::CreateObjectChecker(const char *name) {
   char check_function_code[2048];
if ((isa & m_objc_debug_isa_magic_mask) == m_objc_debug_isa_magic_value) {
     ret_isa = isa & m_objc_debug_isa_class_mask;
     return (ret_isa != 0); // this is a pointer so 0 is not a valid value
   }
   return false;
 }
 
 ObjCLanguageRuntime::EncodingToTypeSP AppleObjCRuntimeV2::GetEncodingToType() {
   if (!m_encoding_to_type_sp)
-    m_encoding_to_type_sp.reset(new AppleObjCTypeEncodingParser(*this));
+    m_encoding_to_type_sp =
+        std::make_shared<AppleObjCTypeEncodingParser>(*this);
   return m_encoding_to_type_sp;
 }
 
 lldb_private::AppleObjCRuntime::ObjCISA
 AppleObjCRuntimeV2::GetPointerISA(ObjCISA isa) {
   ObjCISA ret = isa;
 
   if (m_non_pointer_isa_cache_ap)

source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTrampolineHandler.cpp

 //===-- AppleObjCTrampolineHandler.cpp ----------------------------*- C++
 //-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "AppleObjCTrampolineHandler.h"
-
 #include "AppleThreadPlanStepThroughObjCTrampoline.h"
 
 #include "lldb/Breakpoint/StoppointCallbackContext.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Expression/DiagnosticManager.h"

 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlanRunToAddress.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 
 #include "llvm/ADT/STLExtras.h"
 
+#include <memory>
+
 using namespace lldb;
 using namespace lldb_private;
 
 const char *AppleObjCTrampolineHandler::g_lookup_implementation_function_name =
     "__lldb_objc_find_implementation_for_selector";
 const char *AppleObjCTrampolineHandler::
     g_lookup_implementation_with_stret_function_code =
         "                               \n\
if (found_it) {
 
     if (impl_addr != LLDB_INVALID_ADDRESS) {
       // Yup, it was in the cache, so we can run to that address directly.
 
       if (log)
         log->Printf("Found implementation address in cache: 0x%" PRIx64,
                     impl_addr);
 
-      ret_plan_sp.reset(
-          new ThreadPlanRunToAddress(thread, impl_addr, stop_others));
+      ret_plan_sp = std::make_shared<ThreadPlanRunToAddress>(thread, impl_addr,
+                                                             stop_others);
     } else {
       // We haven't seen this class/selector pair yet.  Look it up.
       StreamString errors;
       Address impl_code_address;
 
       ValueList dispatch_values;
 
       // We've will inject a little function in the target that takes the
if (impl_addr != LLDB_INVALID_ADDRESS) {
       else
         flag_value.GetScalar() = 0; // FIXME - Set to 0 when debugging is done.
       dispatch_values.PushValue(flag_value);
 
       // The step through code might have to fill in the cache, so it
       // is not safe to run only one thread.  So we override the
       // stop_others value passed in to us here:
       const bool trampoline_stop_others = false;
-      ret_plan_sp.reset(new AppleThreadPlanStepThroughObjCTrampoline(
+      ret_plan_sp = std::make_shared<AppleThreadPlanStepThroughObjCTrampoline>(
           thread, this, dispatch_values, isa_addr, sel_addr,
-          trampoline_stop_others));
+          trampoline_stop_others);
       if (log) {
         StreamString s;
         ret_plan_sp->GetDescription(&s, eDescriptionLevelFull);
         log->Printf("Using ObjC step plan: %s.\n", s.GetData());
       }
     }
   }
 
   return ret_plan_sp;
 }
 
 FunctionCaller *
 AppleObjCTrampolineHandler::GetLookupImplementationFunctionCaller() {
   return m_impl_code->GetFunctionCaller();
 }

source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleThreadPlanStepThroughObjCTrampoline.cpp

 //===-- AppleThreadPlanStepThroughObjCTrampoline.cpp
 //--------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "AppleThreadPlanStepThroughObjCTrampoline.h"
+
 #include "AppleObjCTrampolineHandler.h"
 #include "lldb/Expression/DiagnosticManager.h"
 #include "lldb/Expression/FunctionCaller.h"
 #include "lldb/Expression/UtilityFunction.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlanRunToAddress.h"
 #include "lldb/Target/ThreadPlanStepOut.h"
 #include "lldb/Utility/Log.h"
 
+#include <memory>
+
 using namespace lldb;
 using namespace lldb_private;
 
 //----------------------------------------------------------------------
 // ThreadPlanStepThroughObjCTrampoline constructor
 //----------------------------------------------------------------------
 AppleThreadPlanStepThroughObjCTrampoline::
     AppleThreadPlanStepThroughObjCTrampoline(
if (!m_run_to_sp) {
     objc_runtime->AddToMethodCache(m_isa_addr, m_sel_addr, target_addr);
     if (log)
       log->Printf("Adding {isa-addr=0x%" PRIx64 ", sel-addr=0x%" PRIx64
                   "} = addr=0x%" PRIx64 " to cache.",
                   m_isa_addr, m_sel_addr, target_addr);
 
     // Extract the target address from the value:
 
-    m_run_to_sp.reset(
-        new ThreadPlanRunToAddress(m_thread, target_so_addr, m_stop_others));
+    m_run_to_sp = std::make_shared<ThreadPlanRunToAddress>(
+        m_thread, target_so_addr, m_stop_others);
     m_thread.QueueThreadPlan(m_run_to_sp, false);
     m_run_to_sp->SetPrivate(true);
     return false;
   } else if (m_thread.IsThreadPlanDone(m_run_to_sp.get())) {
     // Third stage, work the run to target plan.
     SetPlanComplete();
     return true;
   }

source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp

 //===-- RenderScriptRuntime.cpp ---------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/ADT/StringSwitch.h"
-
 #include "RenderScriptRuntime.h"
 #include "RenderScriptScriptGroup.h"
 
 #include "lldb/Breakpoint/StoppointCallbackContext.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/DumpDataExtractor.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/ValueObjectVariable.h"

 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/Args.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/RegularExpression.h"
 #include "lldb/Utility/Status.h"
 
+#include "llvm/ADT/StringSwitch.h"
+
+#include <memory>
+
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_renderscript;
 
 #define FMT_COORD "(%" PRIu32 ", %" PRIu32 ", %" PRIu32 ")"
 
 namespace {
 
RSScriptGroupDescriptorSP group;
     // search for existing script group
     for (auto sg : m_scriptGroups) {
       if (sg->m_name == group_name) {
         group = sg;
         break;
       }
     }
     if (!group) {
-      group.reset(new RSScriptGroupDescriptor);
+      group = std::make_shared<RSScriptGroupDescriptor>();
       group->m_name = group_name;
       m_scriptGroups.push_back(group);
     } else {
       // already have this script group
       if (log)
         log->Printf("Attempt to add duplicate script group %s",
                     group_name.AsCString());
       return;
for (const auto &rs_module : m_rsmodules) {
 
         return false;
       }
     }
     bool module_loaded = false;
     switch (GetModuleKind(module_sp)) {
     case eModuleKindKernelObj: {
       RSModuleDescriptorSP module_desc;
-      module_desc.reset(new RSModuleDescriptor(module_sp));
+      module_desc = std::make_shared<RSModuleDescriptor>(module_sp);
       if (module_desc->ParseRSInfo()) {
         m_rsmodules.push_back(module_desc);
         module_desc->WarnIfVersionMismatch(GetProcess()
                                                ->GetTarget()
                                                .GetDebugger()
                                                .GetAsyncOutputStream()
                                                .get());
         module_loaded = true;

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

 #endif
 
 #ifndef __APPLE__
 #include "Utility/UuidCompatibility.h"
 #else
 #include <uuid/uuid.h>
 #endif
 
+#include <memory>
+
 #define THUMB_ADDRESS_BIT_MASK 0xfffffffffffffffeull
 using namespace lldb;
 using namespace lldb_private;
 using namespace llvm::MachO;
 
 // Some structure definitions needed for parsing the dyld shared cache files
 // found on iOS devices.
 
void ObjectFileMachO::ProcessSegmentCommand(const load_command &load_cmd_,
   // Keep a list of mach segments around in case we need to get at data that
   // isn't stored in the abstracted Sections.
   m_mach_segments.push_back(load_cmd);
 
   // Use a segment ID of the segment index shifted left by 8 so they never
   // conflict with any of the sections.
   SectionSP segment_sp;
   if (add_section && (const_segname || is_core)) {
-    segment_sp.reset(new Section(
+    segment_sp = std::make_shared<Section>(
         module_sp, // Module to which this section belongs
         this,      // Object file to which this sections belongs
         ++context.NextSegmentIdx
             << 8, // Section ID is the 1 based segment index
         // shifted right by 8 bits as not to collide with any of the 256
         // section IDs that are possible
         const_segname,         // Name of this section
         eSectionTypeContainer, // This section is a container of other
         // sections.
         load_cmd.vmaddr, // File VM address == addresses as they are
         // found in the object file
         load_cmd.vmsize,  // VM size in bytes of this section
         load_cmd.fileoff, // Offset to the data for this section in
         // the file
         load_cmd.filesize, // Size in bytes of this section as found
         // in the file
         0,                // Segments have no alignment information
-        load_cmd.flags)); // Flags for this section
+        load_cmd.flags); // Flags for this section
 
     segment_sp->SetIsEncrypted(segment_is_encrypted);
     m_sections_ap->AddSection(segment_sp);
     segment_sp->SetPermissions(segment_permissions);
     if (add_to_unified)
       context.UnifiedList.AddSection(segment_sp);
   } else if (unified_section_sp) {
     if (is_dsym && unified_section_sp->GetFileAddress() != load_cmd.vmaddr) {
if (add_section) {
             const lldb::addr_t new_file_size =
                 std::max(section_max_file_offset, segment_max_file_offset) -
                 new_file_offset;
             segment->SetFileOffset(new_file_offset);
             segment->SetFileSize(new_file_size);
           }
         } else {
           // Create a fake section for the section's named segment
-          segment_sp.reset(new Section(
+          segment_sp = std::make_shared<Section>(
               segment_sp, // Parent section
               module_sp,  // Module to which this section belongs
               this,       // Object file to which this section belongs
               ++context.NextSegmentIdx
                   << 8, // Section ID is the 1 based segment index
               // shifted right by 8 bits as not to
               // collide with any of the 256 section IDs
               // that are possible
               const_segname,         // Name of this section
               eSectionTypeContainer, // This section is a container of
               // other sections.
               sect64.addr, // File VM address == addresses as they are
               // found in the object file
               sect64.size,   // VM size in bytes of this section
               sect64.offset, // Offset to the data for this section in
               // the file
               sect64.offset ? sect64.size : 0, // Size in bytes of
               // this section as
               // found in the file
               sect64.align,
-              load_cmd.flags)); // Flags for this section
+              load_cmd.flags); // Flags for this section
           segment_sp->SetIsFake(true);
           segment_sp->SetPermissions(segment_permissions);
           m_sections_ap->AddSection(segment_sp);
           if (add_to_unified)
             context.UnifiedList.AddSection(segment_sp);
           segment_sp->SetIsEncrypted(segment_is_encrypted);
         }
       }
const FileRangeArray::Entry *thread_context_file_range =
         m_thread_context_offsets.GetEntryAtIndex(idx);
     if (thread_context_file_range) {
 
       DataExtractor data(m_data, thread_context_file_range->GetRangeBase(),
                          thread_context_file_range->GetByteSize());
 
       switch (m_header.cputype) {
       case llvm::MachO::CPU_TYPE_ARM64:
-        reg_ctx_sp.reset(new RegisterContextDarwin_arm64_Mach(thread, data));
+        reg_ctx_sp =
+            std::make_shared<RegisterContextDarwin_arm64_Mach>(thread, data);
         break;
 
       case llvm::MachO::CPU_TYPE_ARM:
-        reg_ctx_sp.reset(new RegisterContextDarwin_arm_Mach(thread, data));
+        reg_ctx_sp =
+            std::make_shared<RegisterContextDarwin_arm_Mach>(thread, data);
         break;
 
       case llvm::MachO::CPU_TYPE_I386:
-        reg_ctx_sp.reset(new RegisterContextDarwin_i386_Mach(thread, data));
+        reg_ctx_sp =
+            std::make_shared<RegisterContextDarwin_i386_Mach>(thread, data);
         break;
 
       case llvm::MachO::CPU_TYPE_X86_64:
-        reg_ctx_sp.reset(new RegisterContextDarwin_x86_64_Mach(thread, data));
+        reg_ctx_sp =
+            std::make_shared<RegisterContextDarwin_x86_64_Mach>(thread, data);
         break;
       }
     }
   }
   return reg_ctx_sp;
 }
 
 ObjectFile::Type ObjectFileMachO::CalculateType() {

source/Plugins/OperatingSystem/Python/OperatingSystemPython.cpp

 //===-- OperatingSystemPython.cpp --------------------------------*- C++-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_DISABLE_PYTHON
 
 #include "OperatingSystemPython.h"
+
 #include "Plugins/Process/Utility/DynamicRegisterInfo.h"
 #include "Plugins/Process/Utility/RegisterContextDummy.h"
 #include "Plugins/Process/Utility/RegisterContextMemory.h"
 #include "Plugins/Process/Utility/ThreadMemory.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/ValueObjectVariable.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/ScriptInterpreter.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadList.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/StructuredData.h"
 
+#include <memory>
+
 using namespace lldb;
 using namespace lldb_private;
 
 void OperatingSystemPython::Initialize() {
   PluginManager::RegisterPlugin(GetPluginNameStatic(),
                                 GetPluginDescriptionStatic(), CreateInstance,
                                 nullptr);
 }
if (!IsOperatingSystemPluginThread(thread_sp)) {
       // system thread for this.
       thread_sp.reset();
     }
   }
 
   if (!thread_sp) {
     if (did_create_ptr)
       *did_create_ptr = true;
-    thread_sp.reset(
-        new ThreadMemory(*m_process, tid, name, queue, reg_data_addr));
+    thread_sp = std::make_shared<ThreadMemory>(*m_process, tid, name, queue,
+                                               reg_data_addr);
   }
 
   if (core_number < core_thread_list.GetSize(false)) {
     ThreadSP core_thread_sp(
         core_thread_list.GetThreadAtIndex(core_number, false));
     if (core_thread_sp) {
       // Keep track of which cores were set as the backing thread for memory
       // threads...
OperatingSystemPython::CreateRegisterContextForThread(Thread *thread,
   if (reg_data_addr != LLDB_INVALID_ADDRESS) {
     // The registers data is in contiguous memory, just create the register
     // context using the address provided
     if (log)
       log->Printf("OperatingSystemPython::CreateRegisterContextForThread (tid "
                   "= 0x%" PRIx64 ", 0x%" PRIx64 ", reg_data_addr = 0x%" PRIx64
                   ") creating memory register context",
                   thread->GetID(), thread->GetProtocolID(), reg_data_addr);
-    reg_ctx_sp.reset(new RegisterContextMemory(
-        *thread, 0, *GetDynamicRegisterInfo(), reg_data_addr));
+    reg_ctx_sp = std::make_shared<RegisterContextMemory>(
+        *thread, 0, *GetDynamicRegisterInfo(), reg_data_addr);
   } else {
     // No register data address is provided, query the python plug-in to let it
     // make up the data as it sees fit
     if (log)
       log->Printf("OperatingSystemPython::CreateRegisterContextForThread (tid "
                   "= 0x%" PRIx64 ", 0x%" PRIx64
                   ") fetching register data from python",
                   thread->GetID(), thread->GetProtocolID());
OperatingSystemPython::CreateRegisterContextForThread(Thread *thread,
   }
   // if we still have no register data, fallback on a dummy context to avoid
   // crashing
   if (!reg_ctx_sp) {
     if (log)
       log->Printf("OperatingSystemPython::CreateRegisterContextForThread (tid "
                   "= 0x%" PRIx64 ") forcing a dummy register context",
                   thread->GetID());
-    reg_ctx_sp.reset(new RegisterContextDummy(
-        *thread, 0, target.GetArchitecture().GetAddressByteSize()));
+    reg_ctx_sp = std::make_shared<RegisterContextDummy>(
+        *thread, 0, target.GetArchitecture().GetAddressByteSize());
   }
   return reg_ctx_sp;
 }
 
 StopInfoSP
 OperatingSystemPython::CreateThreadStopReason(lldb_private::Thread *thread) {
   // We should have gotten the thread stop info from the dictionary of data for
   // the thread in the initial call to get_thread_info(), this should have been

source/Plugins/Platform/MacOSX/PlatformDarwin.cpp

 //===-- PlatformDarwin.cpp --------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "PlatformDarwin.h"
 
 #include <string.h>
 
 #include <algorithm>
+#include <memory>
 #include <mutex>
 
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Breakpoint/BreakpointSite.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Host/Host.h"
if (!cache_path.empty()) {
           Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM));
           if (log)
             log->Printf("[%s] module %s/%s was rsynced and is now there",
                         (IsHost() ? "host" : "remote"),
                         module_spec.GetFileSpec().GetDirectory().AsCString(),
                         module_spec.GetFileSpec().GetFilename().AsCString());
           ModuleSpec local_spec(module_cache_spec,
                                 module_spec.GetArchitecture());
-          module_sp.reset(new Module(local_spec));
+          module_sp = std::make_shared<Module>(local_spec);
           module_sp->SetPlatformFileSpec(module_spec.GetFileSpec());
           return Status();
         }
       }
 
       // try to find the module in the cache
       if (FileSystem::Instance().Exists(module_cache_spec)) {
         // get the local and remote MD5 and compare
if (!cache_path.empty()) {
             Status err =
                 BringInRemoteFile(this, module_spec, module_cache_spec);
             if (err.Fail())
               return err;
           }
         }
 
         ModuleSpec local_spec(module_cache_spec, module_spec.GetArchitecture());
-        module_sp.reset(new Module(local_spec));
+        module_sp = std::make_shared<Module>(local_spec);
         module_sp->SetPlatformFileSpec(module_spec.GetFileSpec());
         Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM));
         if (log)
           log->Printf("[%s] module %s/%s was found in the cache",
                       (IsHost() ? "host" : "remote"),
                       module_spec.GetFileSpec().GetDirectory().AsCString(),
                       module_spec.GetFileSpec().GetFilename().AsCString());
         return Status();
if (!cache_path.empty()) {
       if (FileSystem::Instance().Exists(module_cache_spec)) {
         Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM));
         if (log)
           log->Printf("[%s] module %s/%s is now cached and fine",
                       (IsHost() ? "host" : "remote"),
                       module_spec.GetFileSpec().GetDirectory().AsCString(),
                       module_spec.GetFileSpec().GetFilename().AsCString());
         ModuleSpec local_spec(module_cache_spec, module_spec.GetArchitecture());
-        module_sp.reset(new Module(local_spec));
+        module_sp = std::make_shared<Module>(local_spec);
         module_sp->SetPlatformFileSpec(module_spec.GetFileSpec());
         return Status();
       } else
         return Status("unable to obtain valid module file");
     } else
       return Status("no cache path");
   } else
     return Status("unable to resolve module");

source/Plugins/Platform/MacOSX/PlatformDarwinKernel.cpp

 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 
 #include "llvm/Support/FileSystem.h"
 
 #include <CoreFoundation/CoreFoundation.h>
 
+#include <memory>
+
 #include "Host/macosx/cfcpp/CFCBundle.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 //------------------------------------------------------------------
 // Static Variables
 //------------------------------------------------------------------

 class PlatformDarwinKernelProperties : public Properties {
 public:
   static ConstString &GetSettingName() {
     static ConstString g_setting_name("darwin-kernel");
     return g_setting_name;
   }
 
   PlatformDarwinKernelProperties() : Properties() {
-    m_collection_sp.reset(new OptionValueProperties(GetSettingName()));
+    m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName());
     m_collection_sp->Initialize(g_properties);
   }
 
   virtual ~PlatformDarwinKernelProperties() {}
 
   bool GetSearchForKexts() const {
     const uint32_t idx = ePropertySearchForKexts;
     return m_collection_sp->GetPropertyAtIndexAsBoolean(

 };
 
 typedef std::shared_ptr<PlatformDarwinKernelProperties>
     PlatformDarwinKernelPropertiesSP;
 
 static const PlatformDarwinKernelPropertiesSP &GetGlobalProperties() {
   static PlatformDarwinKernelPropertiesSP g_settings_sp;
   if (!g_settings_sp)
-    g_settings_sp.reset(new PlatformDarwinKernelProperties());
+    g_settings_sp = std::make_shared<PlatformDarwinKernelProperties>();
   return g_settings_sp;
 }
 
 void PlatformDarwinKernel::DebuggerInitialize(
     lldb_private::Debugger &debugger) {
   if (!PluginManager::GetSettingForPlatformPlugin(
           debugger, PlatformDarwinKernelProperties::GetSettingName())) {
     const bool is_global_setting = true;

source/Plugins/Process/MacOSX-Kernel/ProcessKDP.cpp

 //===-- ProcessKDP.cpp ------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include <errno.h>
 #include <stdlib.h>
 
+#include <memory>
 #include <mutex>
 
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/Host.h"

 
 class PluginProperties : public Properties {
 public:
   static ConstString GetSettingName() {
     return ProcessKDP::GetPluginNameStatic();
   }
 
   PluginProperties() : Properties() {
-    m_collection_sp.reset(new OptionValueProperties(GetSettingName()));
+    m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName());
     m_collection_sp->Initialize(g_properties);
   }
 
   virtual ~PluginProperties() {}
 
   uint64_t GetPacketTimeout() {
     const uint32_t idx = ePropertyPacketTimeout;
     return m_collection_sp->GetPropertyAtIndexAsUInt64(
         NULL, idx, g_properties[idx].default_uint_value);
   }
 };
 
 typedef std::shared_ptr<PluginProperties> ProcessKDPPropertiesSP;
 
 static const ProcessKDPPropertiesSP &GetGlobalPluginProperties() {
   static ProcessKDPPropertiesSP g_settings_sp;
   if (!g_settings_sp)
-    g_settings_sp.reset(new PluginProperties());
+    g_settings_sp = std::make_shared<PluginProperties>();
   return g_settings_sp;
 }
 
 } // anonymous namespace end
 
 static const lldb::tid_t g_kernel_tid = 1;
 
 ConstString ProcessKDP::GetPluginNameStatic() {
void ProcessKDP::Terminate() {
   PluginManager::UnregisterPlugin(ProcessKDP::CreateInstance);
 }
 
 lldb::ProcessSP ProcessKDP::CreateInstance(TargetSP target_sp,
                                            ListenerSP listener_sp,
                                            const FileSpec *crash_file_path) {
   lldb::ProcessSP process_sp;
   if (crash_file_path == NULL)
-    process_sp.reset(new ProcessKDP(target_sp, listener_sp));
+    process_sp = std::make_shared<ProcessKDP>(target_sp, listener_sp);
   return process_sp;
 }
 
 bool ProcessKDP::CanDebug(TargetSP target_sp, bool plugin_specified_by_name) {
   if (plugin_specified_by_name)
     return true;
 
   // For now we are just making sure the file exists for a given module

 }
 
 lldb::ThreadSP ProcessKDP::GetKernelThread() {
   // KDP only tells us about one thread/core. Any other threads will usually
   // be the ones that are read from memory by the OS plug-ins.
 
   ThreadSP thread_sp(m_kernel_thread_wp.lock());
   if (!thread_sp) {
-    thread_sp.reset(new ThreadKDP(*this, g_kernel_tid));
+    thread_sp = std::make_shared<ThreadKDP>(*this, g_kernel_tid);
     m_kernel_thread_wp = thread_sp;
   }
   return thread_sp;
 }
 
 bool ProcessKDP::UpdateThreadList(ThreadList &old_thread_list,
                                   ThreadList &new_thread_list) {
   // locker will keep a mutex locked until it goes out of scope
LoadSubCommand("packet", CommandObjectSP(new CommandObjectProcessKDPPacket(
                                  interpreter)));
   }
 
   ~CommandObjectMultiwordProcessKDP() {}
 };
 
 CommandObject *ProcessKDP::GetPluginCommandObject() {
   if (!m_command_sp)
-    m_command_sp.reset(new CommandObjectMultiwordProcessKDP(
-        GetTarget().GetDebugger().GetCommandInterpreter()));
+    m_command_sp = std::make_shared<CommandObjectMultiwordProcessKDP>(
+        GetTarget().GetDebugger().GetCommandInterpreter());
   return m_command_sp.get();
 }

source/Plugins/Process/MacOSX-Kernel/ThreadKDP.cpp

 #include "Plugins/Process/Utility/StopInfoMachException.h"
 #include "ProcessKDP.h"
 #include "ProcessKDPLog.h"
 #include "RegisterContextKDP_arm.h"
 #include "RegisterContextKDP_arm64.h"
 #include "RegisterContextKDP_i386.h"
 #include "RegisterContextKDP_x86_64.h"
 
+#include <memory>
+
 using namespace lldb;
 using namespace lldb_private;
 
 //----------------------------------------------------------------------
 // Thread Registers
 //----------------------------------------------------------------------
 
 ThreadKDP::ThreadKDP(Process &process, lldb::tid_t tid)
ThreadKDP::CreateRegisterContextForFrame(StackFrame *frame) {
 
   if (concrete_frame_idx == 0) {
     ProcessSP process_sp(CalculateProcess());
     if (process_sp) {
       switch (static_cast<ProcessKDP *>(process_sp.get())
                   ->GetCommunication()
                   .GetCPUType()) {
       case llvm::MachO::CPU_TYPE_ARM:
-        reg_ctx_sp.reset(new RegisterContextKDP_arm(*this, concrete_frame_idx));
+        reg_ctx_sp =
+            std::make_shared<RegisterContextKDP_arm>(*this, concrete_frame_idx);
         break;
       case llvm::MachO::CPU_TYPE_ARM64:
-        reg_ctx_sp.reset(
-            new RegisterContextKDP_arm64(*this, concrete_frame_idx));
+        reg_ctx_sp = std::make_shared<RegisterContextKDP_arm64>(
+            *this, concrete_frame_idx);
         break;
       case llvm::MachO::CPU_TYPE_I386:
-        reg_ctx_sp.reset(
-            new RegisterContextKDP_i386(*this, concrete_frame_idx));
+        reg_ctx_sp = std::make_shared<RegisterContextKDP_i386>(
+            *this, concrete_frame_idx);
         break;
       case llvm::MachO::CPU_TYPE_X86_64:
-        reg_ctx_sp.reset(
-            new RegisterContextKDP_x86_64(*this, concrete_frame_idx));
+        reg_ctx_sp = std::make_shared<RegisterContextKDP_x86_64>(
+            *this, concrete_frame_idx);
         break;
       default:
         llvm_unreachable("Add CPU type support in KDP");
       }
     }
   } else {
     Unwind *unwinder = GetUnwinder();
     if (unwinder != nullptr)

source/Plugins/Process/Utility/HistoryThread.cpp

 //===-- HistoryThread.cpp ---------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/lldb-private.h"
 
 #include "Plugins/Process/Utility/HistoryThread.h"
+
 #include "Plugins/Process/Utility/HistoryUnwind.h"
 #include "Plugins/Process/Utility/RegisterContextHistory.h"
 
 #include "lldb/Target/Process.h"
 #include "lldb/Target/StackFrameList.h"
 #include "lldb/Utility/Log.h"
 
+#include <memory>
+
 using namespace lldb;
 using namespace lldb_private;
 
 //  Constructor
 
 HistoryThread::HistoryThread(lldb_private::Process &process, lldb::tid_t tid,
                              std::vector<lldb::addr_t> pcs, uint32_t stop_id,
                              bool stop_id_is_valid)
if (log)
     log->Printf("%p HistoryThread::~HistoryThread (tid=0x%" PRIx64 ")",
                 static_cast<void *>(this), GetID());
   DestroyThread();
 }
 
 lldb::RegisterContextSP HistoryThread::GetRegisterContext() {
   RegisterContextSP rctx;
   if (m_pcs.size() > 0) {
-    rctx.reset(new RegisterContextHistory(
-        *this, 0, GetProcess()->GetAddressByteSize(), m_pcs[0]));
+    rctx = std::make_shared<RegisterContextHistory>(
+        *this, 0, GetProcess()->GetAddressByteSize(), m_pcs[0]);
   }
   return rctx;
 }
 
 lldb::RegisterContextSP
 HistoryThread::CreateRegisterContextForFrame(StackFrame *frame) {
   return m_unwinder_ap->CreateRegisterContextForFrame(frame);
 }
 
 lldb::StackFrameListSP HistoryThread::GetStackFrameList() {
   // FIXME do not throw away the lock after we acquire it..
   std::unique_lock<std::mutex> lock(m_framelist_mutex);
   lock.unlock();
   if (m_framelist.get() == NULL) {
-    m_framelist.reset(new StackFrameList(*this, StackFrameListSP(), true));
+    m_framelist =
+        std::make_shared<StackFrameList>(*this, StackFrameListSP(), true);
   }
 
   return m_framelist;
 }
 
 uint32_t HistoryThread::GetExtendedBacktraceOriginatingIndexID() {
   if (m_originating_unique_thread_id != LLDB_INVALID_THREAD_ID) {
     if (GetProcess()->HasAssignedIndexIDToThread(
             m_originating_unique_thread_id)) {
       return GetProcess()->AssignIndexIDToThread(
           m_originating_unique_thread_id);
     }
   }
   return LLDB_INVALID_THREAD_ID;
 }

source/Plugins/Process/Utility/HistoryUnwind.cpp

 #include "Plugins/Process/Utility/HistoryUnwind.h"
 #include "Plugins/Process/Utility/RegisterContextHistory.h"
 
 #include "lldb/Target/Process.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 
+#include <memory>
+
 using namespace lldb;
 using namespace lldb_private;
 
 // Constructor
 
 HistoryUnwind::HistoryUnwind(Thread &thread, std::vector<lldb::addr_t> pcs,
                              bool stop_id_is_valid)
     : Unwind(thread), m_pcs(pcs), m_stop_id_is_valid(stop_id_is_valid) {}

 
 lldb::RegisterContextSP
 HistoryUnwind::DoCreateRegisterContextForFrame(StackFrame *frame) {
   RegisterContextSP rctx;
   if (frame) {
     addr_t pc = frame->GetFrameCodeAddress().GetLoadAddress(
         &frame->GetThread()->GetProcess()->GetTarget());
     if (pc != LLDB_INVALID_ADDRESS) {
-      rctx.reset(new RegisterContextHistory(
+      rctx = std::make_shared<RegisterContextHistory>(
           *frame->GetThread().get(), frame->GetConcreteFrameIndex(),
-          frame->GetThread()->GetProcess()->GetAddressByteSize(), pc));
+          frame->GetThread()->GetProcess()->GetAddressByteSize(), pc);
     }
   }
   return rctx;
 }
 
 bool HistoryUnwind::DoGetFrameInfoAtIndex(uint32_t frame_idx, lldb::addr_t &cfa,
                                           lldb::addr_t &pc) {
   // FIXME do not throw away the lock after we acquire it..

source/Plugins/Process/Utility/RegisterContextDarwin_arm.cpp

 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/Scalar.h"
 #include "llvm/Support/Compiler.h"
 
 #include "Plugins/Process/Utility/InstructionUtils.h"
 
+#include <memory>
+
 // Support building against older versions of LLVM, this macro was added
 // recently.
 #ifndef LLVM_EXTENSION
 #define LLVM_EXTENSION
 #endif
 
 #include "Utility/ARM_DWARF_Registers.h"
 #include "Utility/ARM_ehframe_Registers.h"
bool RegisterContextDarwin_arm::WriteRegister(const RegisterInfo *reg_info,
   default:
     return false;
   }
   return WriteRegisterSet(set) == KERN_SUCCESS;
 }
 
 bool RegisterContextDarwin_arm::ReadAllRegisterValues(
     lldb::DataBufferSP &data_sp) {
-  data_sp.reset(new DataBufferHeap(REG_CONTEXT_SIZE, 0));
+  data_sp = std::make_shared<DataBufferHeap>(REG_CONTEXT_SIZE, 0);
   if (data_sp && ReadGPR(false) == KERN_SUCCESS &&
       ReadFPU(false) == KERN_SUCCESS && ReadEXC(false) == KERN_SUCCESS) {
     uint8_t *dst = data_sp->GetBytes();
     ::memcpy(dst, &gpr, sizeof(gpr));
     dst += sizeof(gpr);
 
     ::memcpy(dst, &fpu, sizeof(fpu));
     dst += sizeof(gpr);

source/Plugins/Process/Utility/RegisterContextDarwin_arm64.cpp

 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/Scalar.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/Compiler.h"
 
 #include "Plugins/Process/Utility/InstructionUtils.h"
 
+#include <memory>
+
 // Support building against older versions of LLVM, this macro was added
 // recently.
 #ifndef LLVM_EXTENSION
 #define LLVM_EXTENSION
 #endif
 
 #include "Utility/ARM64_DWARF_Registers.h"
 
bool RegisterContextDarwin_arm64::WriteRegister(const RegisterInfo *reg_info,
   default:
     return false;
   }
   return WriteRegisterSet(set) == KERN_SUCCESS;
 }
 
 bool RegisterContextDarwin_arm64::ReadAllRegisterValues(
     lldb::DataBufferSP &data_sp) {
-  data_sp.reset(new DataBufferHeap(REG_CONTEXT_SIZE, 0));
+  data_sp = std::make_shared<DataBufferHeap>(REG_CONTEXT_SIZE, 0);
   if (data_sp && ReadGPR(false) == KERN_SUCCESS &&
       ReadFPU(false) == KERN_SUCCESS && ReadEXC(false) == KERN_SUCCESS) {
     uint8_t *dst = data_sp->GetBytes();
     ::memcpy(dst, &gpr, sizeof(gpr));
     dst += sizeof(gpr);
 
     ::memcpy(dst, &fpu, sizeof(fpu));
     dst += sizeof(gpr);

source/Plugins/Process/Utility/RegisterContextDarwin_i386.cpp

 //===-- RegisterContextDarwin_i386.cpp --------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#include <stddef.h>
-
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/Scalar.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/Compiler.h"
 
+#include <stddef.h>
+
+#include <memory>
+
 // Support building against older versions of LLVM, this macro was added
 // recently.
 #ifndef LLVM_EXTENSION
 #define LLVM_EXTENSION
 #endif
 
 #include "RegisterContextDarwin_i386.h"
 
bool RegisterContextDarwin_i386::WriteRegister(const RegisterInfo *reg_info,
   default:
     return false;
   }
   return WriteRegisterSet(set) == 0;
 }
 
 bool RegisterContextDarwin_i386::ReadAllRegisterValues(
     lldb::DataBufferSP &data_sp) {
-  data_sp.reset(new DataBufferHeap(REG_CONTEXT_SIZE, 0));
+  data_sp = std::make_shared<DataBufferHeap>(REG_CONTEXT_SIZE, 0);
   if (data_sp && ReadGPR(false) == 0 && ReadFPU(false) == 0 &&
       ReadEXC(false) == 0) {
     uint8_t *dst = data_sp->GetBytes();
     ::memcpy(dst, &gpr, sizeof(gpr));
     dst += sizeof(gpr);
 
     ::memcpy(dst, &fpu, sizeof(fpu));
     dst += sizeof(gpr);

source/Plugins/Process/Utility/RegisterContextDarwin_x86_64.cpp

 //===-- RegisterContextDarwin_x86_64.cpp ------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include <inttypes.h>
 #include <stdarg.h>
 #include <stddef.h>
 
+#include <memory>
+
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/Scalar.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/Compiler.h"
bool RegisterContextDarwin_x86_64::WriteRegister(const RegisterInfo *reg_info,
   default:
     return false;
   }
   return WriteRegisterSet(set) == 0;
 }
 
 bool RegisterContextDarwin_x86_64::ReadAllRegisterValues(
     lldb::DataBufferSP &data_sp) {
-  data_sp.reset(new DataBufferHeap(REG_CONTEXT_SIZE, 0));
+  data_sp = std::make_shared<DataBufferHeap>(REG_CONTEXT_SIZE, 0);
   if (data_sp && ReadGPR(false) == 0 && ReadFPU(false) == 0 &&
       ReadEXC(false) == 0) {
     uint8_t *dst = data_sp->GetBytes();
     ::memcpy(dst, &gpr, sizeof(gpr));
     dst += sizeof(gpr);
 
     ::memcpy(dst, &fpu, sizeof(fpu));
     dst += sizeof(gpr);

source/Plugins/Process/Utility/RegisterContextLLDB.cpp

 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/RegisterValue.h"
 #include "lldb/lldb-private.h"
 
 #include "RegisterContextLLDB.h"
 
+#include <memory>
+
 using namespace lldb;
 using namespace lldb_private;
 
 static ConstString GetSymbolOrFunctionName(const SymbolContext &sym_ctx) {
   if (sym_ctx.symbol)
     return sym_ctx.symbol->GetName();
   else if (sym_ctx.function)
     return sym_ctx.function->GetName();
if (process->GetLoadAddressPermissions(pc, permissions) &&
         UnwindLogMsg("pc is in a non-executable section of memory and this "
                      "isn't the 2nd frame in the stack walk.");
         return;
       }
     }
 
     if (abi) {
       m_fast_unwind_plan_sp.reset();
-      m_full_unwind_plan_sp.reset(new UnwindPlan(lldb::eRegisterKindGeneric));
+      m_full_unwind_plan_sp =
+          std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
       abi->CreateDefaultUnwindPlan(*m_full_unwind_plan_sp);
       if (m_frame_type != eSkipFrame) // don't override eSkipFrame
       {
         m_frame_type = eNormalFrame;
       }
       m_all_registers_available = false;
       m_current_offset = -1;
       m_current_offset_backed_up_one = -1;

 
 UnwindPlanSP RegisterContextLLDB::GetFullUnwindPlanForFrame() {
   UnwindPlanSP unwind_plan_sp;
   UnwindPlanSP arch_default_unwind_plan_sp;
   ExecutionContext exe_ctx(m_thread.shared_from_this());
   Process *process = exe_ctx.GetProcessPtr();
   ABI *abi = process ? process->GetABI().get() : NULL;
   if (abi) {
-    arch_default_unwind_plan_sp.reset(
-        new UnwindPlan(lldb::eRegisterKindGeneric));
+    arch_default_unwind_plan_sp =
+        std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
     abi->CreateDefaultUnwindPlan(*arch_default_unwind_plan_sp);
   } else {
     UnwindLogMsg(
         "unable to get architectural default UnwindPlan from ABI plugin");
   }
 
   bool behaves_like_zeroth_frame = false;
   if (IsFrameZero() || GetNextFrame()->m_frame_type == eTrapHandlerFrame ||
if ((!m_sym_ctx_valid ||
     uint32_t permissions;
     addr_t current_pc_addr =
         m_current_pc.GetLoadAddress(exe_ctx.GetTargetPtr());
     if (current_pc_addr == 0 ||
         (process &&
          process->GetLoadAddressPermissions(current_pc_addr, permissions) &&
          (permissions & ePermissionsExecutable) == 0)) {
       if (abi) {
-        unwind_plan_sp.reset(new UnwindPlan(lldb::eRegisterKindGeneric));
+        unwind_plan_sp =
+            std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
         abi->CreateFunctionEntryUnwindPlan(*unwind_plan_sp);
         m_frame_type = eNormalFrame;
         return unwind_plan_sp;
       }
     }
   }
 
   // No Module for the current pc, try using the architecture default unwind.
if (!pc_module_sp || !pc_module_sp->GetObjectFile() ||
         !m_current_pc.IsValid())
       return arch_default_unwind_plan_sp;
 
     // Even with -fomit-frame-pointer, we can try eh_frame to get back on
     // track.
     DWARFCallFrameInfo *eh_frame =
         pc_module_sp->GetObjectFile()->GetUnwindTable().GetEHFrameInfo();
     if (eh_frame) {
-      unwind_plan_sp.reset(new UnwindPlan(lldb::eRegisterKindGeneric));
+      unwind_plan_sp = std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
       if (eh_frame->GetUnwindPlan(m_current_pc, *unwind_plan_sp))
         return unwind_plan_sp;
       else
         unwind_plan_sp.reset();
     }
 
     ArmUnwindInfo *arm_exidx =
         pc_module_sp->GetObjectFile()->GetUnwindTable().GetArmUnwindInfo();
     if (arm_exidx) {
-      unwind_plan_sp.reset(new UnwindPlan(lldb::eRegisterKindGeneric));
+      unwind_plan_sp = std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
       if (arm_exidx->GetUnwindPlan(exe_ctx.GetTargetRef(), m_current_pc,
                                    *unwind_plan_sp))
         return unwind_plan_sp;
       else
         unwind_plan_sp.reset();
     }
 
     return arch_default_unwind_plan_sp;

source/Plugins/Process/Utility/ThreadMemory.cpp

 //===-- ThreadMemory.cpp ----------------------------------------------*- C++
 //-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "Plugins/Process/Utility/ThreadMemory.h"
+
 #include "Plugins/Process/Utility/RegisterContextThreadMemory.h"
 #include "lldb/Target/OperatingSystem.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/Unwind.h"
 
+#include <memory>
+
 using namespace lldb;
 using namespace lldb_private;
 
 ThreadMemory::ThreadMemory(Process &process, tid_t tid,
                            const ValueObjectSP &thread_info_valobj_sp)
     : Thread(process, tid), m_backing_thread_sp(),
       m_thread_info_valobj_sp(thread_info_valobj_sp), m_name(), m_queue() {}
 

 void ThreadMemory::ClearStackFrames() {
   if (m_backing_thread_sp)
     m_backing_thread_sp->ClearStackFrames();
   Thread::ClearStackFrames();
 }
 
 RegisterContextSP ThreadMemory::GetRegisterContext() {
   if (!m_reg_context_sp)
-    m_reg_context_sp.reset(
-        new RegisterContextThreadMemory(*this, m_register_data_addr));
+    m_reg_context_sp = std::make_shared<RegisterContextThreadMemory>(
+        *this, m_register_data_addr);
   return m_reg_context_sp;
 }
 
 RegisterContextSP
 ThreadMemory::CreateRegisterContextForFrame(StackFrame *frame) {
   RegisterContextSP reg_ctx_sp;
   uint32_t concrete_frame_idx = 0;
 

source/Plugins/Process/Utility/UnwindMacOSXFrameBackchain.cpp

 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/ArchSpec.h"
 
 #include "RegisterContextMacOSXFrameBackchain.h"
 
+#include <memory>
+
 using namespace lldb;
 using namespace lldb_private;
 
 UnwindMacOSXFrameBackchain::UnwindMacOSXFrameBackchain(Thread &thread)
     : Unwind(thread), m_cursors() {}
 
 uint32_t UnwindMacOSXFrameBackchain::DoGetFrameCount() {
   if (m_cursors.empty()) {

 }
 
 lldb::RegisterContextSP
 UnwindMacOSXFrameBackchain::DoCreateRegisterContextForFrame(StackFrame *frame) {
   lldb::RegisterContextSP reg_ctx_sp;
   uint32_t concrete_idx = frame->GetConcreteFrameIndex();
   const uint32_t frame_count = GetFrameCount();
   if (concrete_idx < frame_count)
-    reg_ctx_sp.reset(new RegisterContextMacOSXFrameBackchain(
-        m_thread, concrete_idx, m_cursors[concrete_idx]));
+    reg_ctx_sp = std::make_shared<RegisterContextMacOSXFrameBackchain>(
+        m_thread, concrete_idx, m_cursors[concrete_idx]);
   return reg_ctx_sp;
 }
 
 size_t UnwindMacOSXFrameBackchain::GetStackFrameData_i386(
     const ExecutionContext &exe_ctx) {
   m_cursors.clear();
 
   StackFrame *first_frame = exe_ctx.GetFramePtr();

source/Plugins/Process/elf-core/ProcessElfCore.cpp

 //===-- ProcessElfCore.cpp --------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include <stdlib.h>
 
+#include <memory>
 #include <mutex>
 
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Target/DynamicLoader.h"
 #include "lldb/Target/MemoryRegionInfo.h"
auto data_sp = FileSystem::Instance().CreateDataBuffer(
         crash_file->GetPath(), header_size, 0);
     if (data_sp && data_sp->GetByteSize() == header_size &&
         elf::ELFHeader::MagicBytesMatch(data_sp->GetBytes())) {
       elf::ELFHeader elf_header;
       DataExtractor data(data_sp, lldb::eByteOrderLittle, 4);
       lldb::offset_t data_offset = 0;
       if (elf_header.Parse(data, &data_offset)) {
         if (elf_header.e_type == llvm::ELF::ET_CORE)
-          process_sp.reset(
-              new ProcessElfCore(target_sp, listener_sp, *crash_file));
+          process_sp = std::make_shared<ProcessElfCore>(target_sp, listener_sp,
+                                                        *crash_file);
       }
     }
   }
   return process_sp;
 }
 
 bool ProcessElfCore::CanDebug(lldb::TargetSP target_sp,
                               bool plugin_specified_by_name) {

source/Plugins/Process/elf-core/RegisterContextPOSIXCore_arm.cpp

 //===-- RegisterContextPOSIXCore_arm.cpp ------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "RegisterContextPOSIXCore_arm.h"
 
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/RegisterValue.h"
 
+#include <memory>
+
 using namespace lldb_private;
 
 RegisterContextCorePOSIX_arm::RegisterContextCorePOSIX_arm(
     Thread &thread, RegisterInfoInterface *register_info,
     const DataExtractor &gpregset, llvm::ArrayRef<CoreNote> notes)
     : RegisterContextPOSIX_arm(thread, 0, register_info) {
-  m_gpr_buffer.reset(
-      new DataBufferHeap(gpregset.GetDataStart(), gpregset.GetByteSize()));
+  m_gpr_buffer = std::make_shared<DataBufferHeap>(gpregset.GetDataStart(),
+                                                  gpregset.GetByteSize());
   m_gpr.SetData(m_gpr_buffer);
   m_gpr.SetByteOrder(gpregset.GetByteOrder());
 }
 
 RegisterContextCorePOSIX_arm::~RegisterContextCorePOSIX_arm() {}
 
 bool RegisterContextCorePOSIX_arm::ReadGPR() { return true; }
 

source/Plugins/Process/elf-core/RegisterContextPOSIXCore_arm64.cpp

 //===-- RegisterContextPOSIXCore_arm64.cpp ----------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "RegisterContextPOSIXCore_arm64.h"
+
 #include "Plugins/Process/elf-core/RegisterUtilities.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/RegisterValue.h"
 
+#include <memory>
+
 using namespace lldb_private;
 
 RegisterContextCorePOSIX_arm64::RegisterContextCorePOSIX_arm64(
     Thread &thread, RegisterInfoInterface *register_info,
     const DataExtractor &gpregset, llvm::ArrayRef<CoreNote> notes)
     : RegisterContextPOSIX_arm64(thread, 0, register_info) {
-  m_gpr_buffer.reset(
-      new DataBufferHeap(gpregset.GetDataStart(), gpregset.GetByteSize()));
+  m_gpr_buffer = std::make_shared<DataBufferHeap>(gpregset.GetDataStart(),
+                                                  gpregset.GetByteSize());
   m_gpr.SetData(m_gpr_buffer);
   m_gpr.SetByteOrder(gpregset.GetByteOrder());
 }
 
 RegisterContextCorePOSIX_arm64::~RegisterContextCorePOSIX_arm64() {}
 
 bool RegisterContextCorePOSIX_arm64::ReadGPR() { return true; }
 

source/Plugins/Process/elf-core/RegisterContextPOSIXCore_mips64.cpp

 //===-- RegisterContextPOSIXCore_mips64.cpp ---------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "RegisterContextPOSIXCore_mips64.h"
 
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/RegisterValue.h"
 
+#include <memory>
+
 using namespace lldb_private;
 
 RegisterContextCorePOSIX_mips64::RegisterContextCorePOSIX_mips64(
     Thread &thread, RegisterInfoInterface *register_info,
     const DataExtractor &gpregset, llvm::ArrayRef<CoreNote> notes)
     : RegisterContextPOSIX_mips64(thread, 0, register_info) {
-  m_gpr_buffer.reset(
-      new DataBufferHeap(gpregset.GetDataStart(), gpregset.GetByteSize()));
+  m_gpr_buffer = std::make_shared<DataBufferHeap>(gpregset.GetDataStart(),
+                                                  gpregset.GetByteSize());
   m_gpr.SetData(m_gpr_buffer);
   m_gpr.SetByteOrder(gpregset.GetByteOrder());
 
   DataExtractor fpregset = getRegset(
       notes, register_info->GetTargetArchitecture().GetTriple(), FPR_Desc);
-  m_fpr_buffer.reset(
-      new DataBufferHeap(fpregset.GetDataStart(), fpregset.GetByteSize()));
+  m_fpr_buffer = std::make_shared<DataBufferHeap>(fpregset.GetDataStart(),
+                                                  fpregset.GetByteSize());
   m_fpr.SetData(m_fpr_buffer);
   m_fpr.SetByteOrder(fpregset.GetByteOrder());
 }
 
 RegisterContextCorePOSIX_mips64::~RegisterContextCorePOSIX_mips64() {}
 
 bool RegisterContextCorePOSIX_mips64::ReadGPR() { return true; }
 

source/Plugins/Process/elf-core/RegisterContextPOSIXCore_powerpc.cpp

 //===-- RegisterContextPOSIXCore_powerpc.cpp --------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "RegisterContextPOSIXCore_powerpc.h"
 
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/RegisterValue.h"
 
+#include <memory>
+
 using namespace lldb_private;
 
 RegisterContextCorePOSIX_powerpc::RegisterContextCorePOSIX_powerpc(
     Thread &thread, RegisterInfoInterface *register_info,
     const DataExtractor &gpregset, llvm::ArrayRef<CoreNote> notes)
     : RegisterContextPOSIX_powerpc(thread, 0, register_info) {
-  m_gpr_buffer.reset(
-      new DataBufferHeap(gpregset.GetDataStart(), gpregset.GetByteSize()));
+  m_gpr_buffer = std::make_shared<DataBufferHeap>(gpregset.GetDataStart(),
+                                                  gpregset.GetByteSize());
   m_gpr.SetData(m_gpr_buffer);
   m_gpr.SetByteOrder(gpregset.GetByteOrder());
 
   ArchSpec arch = register_info->GetTargetArchitecture();
   DataExtractor fpregset = getRegset(notes, arch.GetTriple(), FPR_Desc);
-  m_fpr_buffer.reset(
-      new DataBufferHeap(fpregset.GetDataStart(), fpregset.GetByteSize()));
+  m_fpr_buffer = std::make_shared<DataBufferHeap>(fpregset.GetDataStart(),
+                                                  fpregset.GetByteSize());
   m_fpr.SetData(m_fpr_buffer);
   m_fpr.SetByteOrder(fpregset.GetByteOrder());
 
   DataExtractor vregset = getRegset(notes, arch.GetTriple(), PPC_VMX_Desc);
-  m_vec_buffer.reset(
-      new DataBufferHeap(vregset.GetDataStart(), vregset.GetByteSize()));
+  m_vec_buffer = std::make_shared<DataBufferHeap>(vregset.GetDataStart(),
+                                                  vregset.GetByteSize());
   m_vec.SetData(m_vec_buffer);
   m_vec.SetByteOrder(vregset.GetByteOrder());
 }
 
 RegisterContextCorePOSIX_powerpc::~RegisterContextCorePOSIX_powerpc() {}
 
 bool RegisterContextCorePOSIX_powerpc::ReadGPR() { return true; }
 

source/Plugins/Process/elf-core/RegisterContextPOSIXCore_ppc64le.cpp

 
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/RegisterValue.h"
 
 #include "Plugins/Process/Utility/lldb-ppc64le-register-enums.h"
 #include "Plugins/Process/elf-core/RegisterUtilities.h"
 
+#include <memory>
+
 using namespace lldb_private;
 
 RegisterContextCorePOSIX_ppc64le::RegisterContextCorePOSIX_ppc64le(
     Thread &thread, RegisterInfoInterface *register_info,
     const DataExtractor &gpregset, llvm::ArrayRef<CoreNote> notes)
     : RegisterContextPOSIX_ppc64le(thread, 0, register_info) {
-  m_gpr_buffer.reset(
-      new DataBufferHeap(gpregset.GetDataStart(), gpregset.GetByteSize()));
+  m_gpr_buffer = std::make_shared<DataBufferHeap>(gpregset.GetDataStart(),
+                                                  gpregset.GetByteSize());
   m_gpr.SetData(m_gpr_buffer);
   m_gpr.SetByteOrder(gpregset.GetByteOrder());
 
   ArchSpec arch = register_info->GetTargetArchitecture();
   DataExtractor fpregset = getRegset(notes, arch.GetTriple(), FPR_Desc);
-  m_fpr_buffer.reset(
-      new DataBufferHeap(fpregset.GetDataStart(), fpregset.GetByteSize()));
+  m_fpr_buffer = std::make_shared<DataBufferHeap>(fpregset.GetDataStart(),
+                                                  fpregset.GetByteSize());
   m_fpr.SetData(m_fpr_buffer);
   m_fpr.SetByteOrder(fpregset.GetByteOrder());
 
   DataExtractor vmxregset = getRegset(notes, arch.GetTriple(), PPC_VMX_Desc);
-  m_vmx_buffer.reset(
-      new DataBufferHeap(vmxregset.GetDataStart(), vmxregset.GetByteSize()));
+  m_vmx_buffer = std::make_shared<DataBufferHeap>(vmxregset.GetDataStart(),
+                                                  vmxregset.GetByteSize());
   m_vmx.SetData(m_vmx_buffer);
   m_vmx.SetByteOrder(vmxregset.GetByteOrder());
 
   DataExtractor vsxregset = getRegset(notes, arch.GetTriple(), PPC_VSX_Desc);
-  m_vsx_buffer.reset(
-      new DataBufferHeap(vsxregset.GetDataStart(), vsxregset.GetByteSize()));
+  m_vsx_buffer = std::make_shared<DataBufferHeap>(vsxregset.GetDataStart(),
+                                                  vsxregset.GetByteSize());
   m_vsx.SetData(m_vsx_buffer);
   m_vsx.SetByteOrder(vsxregset.GetByteOrder());
 }
 
 size_t RegisterContextCorePOSIX_ppc64le::GetFPRSize() const {
   return k_num_fpr_registers_ppc64le * sizeof(uint64_t);
 }
 

source/Plugins/Process/elf-core/RegisterContextPOSIXCore_s390x.cpp

 //===-- RegisterContextPOSIXCore_s390x.cpp ----------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "RegisterContextPOSIXCore_s390x.h"
 
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/RegisterValue.h"
 
+#include <memory>
+
 using namespace lldb_private;
 
 RegisterContextCorePOSIX_s390x::RegisterContextCorePOSIX_s390x(
     Thread &thread, RegisterInfoInterface *register_info,
     const DataExtractor &gpregset, llvm::ArrayRef<CoreNote> notes)
     : RegisterContextPOSIX_s390x(thread, 0, register_info) {
-  m_gpr_buffer.reset(
-      new DataBufferHeap(gpregset.GetDataStart(), gpregset.GetByteSize()));
+  m_gpr_buffer = std::make_shared<DataBufferHeap>(gpregset.GetDataStart(),
+                                                  gpregset.GetByteSize());
   m_gpr.SetData(m_gpr_buffer);
   m_gpr.SetByteOrder(gpregset.GetByteOrder());
 
   DataExtractor fpregset = getRegset(
       notes, register_info->GetTargetArchitecture().GetTriple(), FPR_Desc);
-  m_fpr_buffer.reset(
-      new DataBufferHeap(fpregset.GetDataStart(), fpregset.GetByteSize()));
+  m_fpr_buffer = std::make_shared<DataBufferHeap>(fpregset.GetDataStart(),
+                                                  fpregset.GetByteSize());
   m_fpr.SetData(m_fpr_buffer);
   m_fpr.SetByteOrder(fpregset.GetByteOrder());
 }
 
 RegisterContextCorePOSIX_s390x::~RegisterContextCorePOSIX_s390x() {}
 
 bool RegisterContextCorePOSIX_s390x::ReadGPR() { return true; }
 

source/Plugins/Process/elf-core/ThreadElfCore.cpp

 #include "RegisterContextPOSIXCore_arm64.h"
 #include "RegisterContextPOSIXCore_mips64.h"
 #include "RegisterContextPOSIXCore_powerpc.h"
 #include "RegisterContextPOSIXCore_ppc64le.h"
 #include "RegisterContextPOSIXCore_s390x.h"
 #include "RegisterContextPOSIXCore_x86_64.h"
 #include "ThreadElfCore.h"
 
+#include <memory>
+
 using namespace lldb;
 using namespace lldb_private;
 
 //----------------------------------------------------------------------
 // Construct a Thread object with given data
 //----------------------------------------------------------------------
 ThreadElfCore::ThreadElfCore(Process &process, const ThreadData &td)
     : Thread(process, td.tid), m_thread_name(td.name), m_thread_reg_ctx_sp(),
if (!reg_interface) {
       if (log)
         log->Printf("elf-core::%s:: Architecture(%d) or OS(%d) not supported",
                     __FUNCTION__, arch.GetMachine(), arch.GetTriple().getOS());
       assert(false && "Architecture or OS not supported");
     }
 
     switch (arch.GetMachine()) {
     case llvm::Triple::aarch64:
-      m_thread_reg_ctx_sp.reset(new RegisterContextCorePOSIX_arm64(
-          *this, reg_interface, m_gpregset_data, m_notes));
+      m_thread_reg_ctx_sp = std::make_shared<RegisterContextCorePOSIX_arm64>(
+          *this, reg_interface, m_gpregset_data, m_notes);
       break;
     case llvm::Triple::arm:
-      m_thread_reg_ctx_sp.reset(new RegisterContextCorePOSIX_arm(
-          *this, reg_interface, m_gpregset_data, m_notes));
+      m_thread_reg_ctx_sp = std::make_shared<RegisterContextCorePOSIX_arm>(
+          *this, reg_interface, m_gpregset_data, m_notes);
       break;
     case llvm::Triple::mipsel:
     case llvm::Triple::mips:
-      m_thread_reg_ctx_sp.reset(new RegisterContextCorePOSIX_mips64(
-          *this, reg_interface, m_gpregset_data, m_notes));
+      m_thread_reg_ctx_sp = std::make_shared<RegisterContextCorePOSIX_mips64>(
+          *this, reg_interface, m_gpregset_data, m_notes);
       break;
     case llvm::Triple::mips64:
     case llvm::Triple::mips64el:
-      m_thread_reg_ctx_sp.reset(new RegisterContextCorePOSIX_mips64(
-          *this, reg_interface, m_gpregset_data, m_notes));
+      m_thread_reg_ctx_sp = std::make_shared<RegisterContextCorePOSIX_mips64>(
+          *this, reg_interface, m_gpregset_data, m_notes);
       break;
     case llvm::Triple::ppc:
     case llvm::Triple::ppc64:
-      m_thread_reg_ctx_sp.reset(new RegisterContextCorePOSIX_powerpc(
-          *this, reg_interface, m_gpregset_data, m_notes));
+      m_thread_reg_ctx_sp = std::make_shared<RegisterContextCorePOSIX_powerpc>(
+          *this, reg_interface, m_gpregset_data, m_notes);
       break;
     case llvm::Triple::ppc64le:
-      m_thread_reg_ctx_sp.reset(new RegisterContextCorePOSIX_ppc64le(
-          *this, reg_interface, m_gpregset_data, m_notes));
+      m_thread_reg_ctx_sp = std::make_shared<RegisterContextCorePOSIX_ppc64le>(
+          *this, reg_interface, m_gpregset_data, m_notes);
       break;
     case llvm::Triple::systemz:
-      m_thread_reg_ctx_sp.reset(new RegisterContextCorePOSIX_s390x(
-          *this, reg_interface, m_gpregset_data, m_notes));
+      m_thread_reg_ctx_sp = std::make_shared<RegisterContextCorePOSIX_s390x>(
+          *this, reg_interface, m_gpregset_data, m_notes);
       break;
     case llvm::Triple::x86:
     case llvm::Triple::x86_64:
-      m_thread_reg_ctx_sp.reset(new RegisterContextCorePOSIX_x86_64(
-          *this, reg_interface, m_gpregset_data, m_notes));
+      m_thread_reg_ctx_sp = std::make_shared<RegisterContextCorePOSIX_x86_64>(
+          *this, reg_interface, m_gpregset_data, m_notes);
       break;
     default:
       break;
     }
 
     reg_ctx_sp = m_thread_reg_ctx_sp;
   } else {
     Unwind *unwinder = GetUnwinder();

source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.cpp

 #include "lldb/Utility/StreamString.h"
 #include "ProcessGDBRemote.h"
 #include "ProcessGDBRemoteLog.h"
 #include "ThreadGDBRemote.h"
 #include "Utility/ARM_DWARF_Registers.h"
 #include "Utility/ARM_ehframe_Registers.h"
 #include "lldb/Utility/StringExtractorGDBRemote.h"
 
+#include <memory>
+
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::process_gdb_remote;
 
 //----------------------------------------------------------------------
 // GDBRemoteRegisterContext constructor
 //----------------------------------------------------------------------
 GDBRemoteRegisterContext::GDBRemoteRegisterContext(
if (lock) {
     for (uint32_t i = 0; (reg_info = GetRegisterInfoAtIndex(i)) != NULL; i++) {
       if (reg_info
               ->value_regs) // skip registers that are slices of real registers
         continue;
       ReadRegisterBytes(reg_info, m_reg_data);
       // ReadRegisterBytes saves the contents of the register in to the
       // m_reg_data buffer
     }
-    data_sp.reset(new DataBufferHeap(m_reg_data.GetDataStart(),
-                                     m_reg_info.GetRegisterDataByteSize()));
+    data_sp = std::make_shared<DataBufferHeap>(
+        m_reg_data.GetDataStart(), m_reg_info.GetRegisterDataByteSize());
     return true;
   } else {
 
     Log *log(ProcessGDBRemoteLog::GetLogIfAnyCategoryIsSet(GDBR_LOG_THREAD |
                                                            GDBR_LOG_PACKETS));
     if (log) {
       if (log->GetVerbose()) {
         StreamString strm;

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

 #endif
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <time.h>
 
 #include <algorithm>
 #include <csignal>
 #include <map>
+#include <memory>
 #include <mutex>
 #include <sstream>
 
 #include "lldb/Breakpoint/Watchpoint.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"

 
 class PluginProperties : public Properties {
 public:
   static ConstString GetSettingName() {
     return ProcessGDBRemote::GetPluginNameStatic();
   }
 
   PluginProperties() : Properties() {
-    m_collection_sp.reset(new OptionValueProperties(GetSettingName()));
+    m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName());
     m_collection_sp->Initialize(g_properties);
   }
 
   virtual ~PluginProperties() {}
 
   uint64_t GetPacketTimeout() {
     const uint32_t idx = ePropertyPacketTimeout;
     return m_collection_sp->GetPropertyAtIndexAsUInt64(
public:
   }
 };
 
 typedef std::shared_ptr<PluginProperties> ProcessKDPPropertiesSP;
 
 static const ProcessKDPPropertiesSP &GetGlobalPluginProperties() {
   static ProcessKDPPropertiesSP g_settings_sp;
   if (!g_settings_sp)
-    g_settings_sp.reset(new PluginProperties());
+    g_settings_sp = std::make_shared<PluginProperties>();
   return g_settings_sp;
 }
 
 struct ProcessGDBRemoteInfo {
   static const char *name;
   static const char *file;
 };
 

 }
 
 lldb::ProcessSP
 ProcessGDBRemote::CreateInstance(lldb::TargetSP target_sp,
                                  ListenerSP listener_sp,
                                  const FileSpec *crash_file_path) {
   lldb::ProcessSP process_sp;
   if (crash_file_path == NULL)
-    process_sp.reset(new ProcessGDBRemote(target_sp, listener_sp));
+    process_sp = std::make_shared<ProcessGDBRemote>(target_sp, listener_sp);
   return process_sp;
 }
 
 bool ProcessGDBRemote::CanDebug(lldb::TargetSP target_sp,
                                 bool plugin_specified_by_name) {
   if (plugin_specified_by_name)
     return true;
 
bool ProcessGDBRemote::UpdateThreadList(ThreadList &old_thread_list,
 
   ThreadList old_thread_list_copy(old_thread_list);
   if (num_thread_ids > 0) {
     for (size_t i = 0; i < num_thread_ids; ++i) {
       tid_t tid = m_thread_ids[i];
       ThreadSP thread_sp(
           old_thread_list_copy.RemoveThreadByProtocolID(tid, false));
       if (!thread_sp) {
-        thread_sp.reset(new ThreadGDBRemote(*this, tid));
+        thread_sp = std::make_shared<ThreadGDBRemote>(*this, tid);
         LLDB_LOGV(log, "Making new thread: {0} for thread ID: {1:x}.",
                   thread_sp.get(), thread_sp->GetID());
       } else {
         LLDB_LOGV(log, "Found old thread: {0} for thread ID: {1:x}.",
                   thread_sp.get(), thread_sp->GetID());
       }
 
       SetThreadPc(thread_sp, i);
// Scope for "locker" below
       // the mutex between the call to m_thread_list_real.FindThreadByID(...)
       // and the m_thread_list_real.AddThread(...) so it doesn't change on us
       std::lock_guard<std::recursive_mutex> guard(
           m_thread_list_real.GetMutex());
       thread_sp = m_thread_list_real.FindThreadByProtocolID(tid, false);
 
       if (!thread_sp) {
         // Create the thread if we need to
-        thread_sp.reset(new ThreadGDBRemote(*this, tid));
+        thread_sp = std::make_shared<ThreadGDBRemote>(*this, tid);
         m_thread_list_real.AddThread(thread_sp);
       }
     }
 
     if (thread_sp) {
       ThreadGDBRemote *gdb_thread =
           static_cast<ThreadGDBRemote *>(thread_sp.get());
       gdb_thread->GetRegisterContext()->InvalidateIfNeeded(true);

 
 const DataBufferSP ProcessGDBRemote::GetAuxvData() {
   DataBufferSP buf;
   if (m_gdb_comm.GetQXferAuxvReadSupported()) {
     std::string response_string;
     if (m_gdb_comm.SendPacketsAndConcatenateResponses("qXfer:auxv:read::",
                                                       response_string) ==
         GDBRemoteCommunication::PacketResult::Success)
-      buf.reset(new DataBufferHeap(response_string.c_str(),
-                                   response_string.length()));
+      buf = std::make_shared<DataBufferHeap>(response_string.c_str(),
+                                             response_string.length());
   }
   return buf;
 }
 
 StructuredData::ObjectSP
 ProcessGDBRemote::GetExtendedInfoForThread(lldb::tid_t tid) {
   StructuredData::ObjectSP object_sp;
 
LoadSubCommand(
         CommandObjectSP(new CommandObjectProcessGDBRemotePacket(interpreter)));
   }
 
   ~CommandObjectMultiwordProcessGDBRemote() {}
 };
 
 CommandObject *ProcessGDBRemote::GetPluginCommandObject() {
   if (!m_command_sp)
-    m_command_sp.reset(new CommandObjectMultiwordProcessGDBRemote(
-        GetTarget().GetDebugger().GetCommandInterpreter()));
+    m_command_sp = std::make_shared<CommandObjectMultiwordProcessGDBRemote>(
+        GetTarget().GetDebugger().GetCommandInterpreter());
   return m_command_sp.get();
 }

source/Plugins/Process/gdb-remote/ThreadGDBRemote.cpp

 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/SystemRuntime.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/UnixSignals.h"
 #include "lldb/Target/Unwind.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/State.h"
 #include "lldb/Utility/StreamString.h"
+#include "lldb/Utility/StringExtractorGDBRemote.h"
 
 #include "ProcessGDBRemote.h"
 #include "ProcessGDBRemoteLog.h"
-#include "lldb/Utility/StringExtractorGDBRemote.h"
+
+#include <memory>
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::process_gdb_remote;
 
 //----------------------------------------------------------------------
 // Thread Registers
 //----------------------------------------------------------------------
if (concrete_frame_idx == 0) {
     ProcessSP process_sp(GetProcess());
     if (process_sp) {
       ProcessGDBRemote *gdb_process =
           static_cast<ProcessGDBRemote *>(process_sp.get());
       // read_all_registers_at_once will be true if 'p' packet is not
       // supported.
       bool read_all_registers_at_once =
           !gdb_process->GetGDBRemote().GetpPacketSupported(GetID());
-      reg_ctx_sp.reset(new GDBRemoteRegisterContext(
+      reg_ctx_sp = std::make_shared<GDBRemoteRegisterContext>(
           *this, concrete_frame_idx, gdb_process->m_register_info,
-          read_all_registers_at_once));
+          read_all_registers_at_once);
     }
   } else {
     Unwind *unwinder = GetUnwinder();
     if (unwinder != nullptr)
       reg_ctx_sp = unwinder->CreateRegisterContextForFrame(frame);
   }
   return reg_ctx_sp;
 }

source/Plugins/Process/mach-core/ProcessMachCore.cpp

 //===-- ProcessMachCore.cpp ------------------------------------------*- C++
 //-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include <errno.h>
 #include <stdlib.h>
 
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/Threading.h"
-#include <mutex>
 
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Symbol/ObjectFile.h"

 
 // Needed for the plug-in names for the dynamic loaders.
 #include "lldb/Host/SafeMachO.h"
 
 #include "Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.h"
 #include "Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.h"
 #include "Plugins/ObjectFile/Mach-O/ObjectFileMachO.h"
 
+#include <memory>
+#include <mutex>
+
 using namespace lldb;
 using namespace lldb_private;
 
 ConstString ProcessMachCore::GetPluginNameStatic() {
   static ConstString g_name("mach-o-core");
   return g_name;
 }
 
auto data_sp = FileSystem::Instance().CreateDataBuffer(
         crash_file->GetPath(), header_size, 0);
     if (data_sp && data_sp->GetByteSize() == header_size) {
       DataExtractor data(data_sp, lldb::eByteOrderLittle, 4);
 
       lldb::offset_t data_offset = 0;
       llvm::MachO::mach_header mach_header;
       if (ObjectFileMachO::ParseHeader(data, &data_offset, mach_header)) {
         if (mach_header.filetype == llvm::MachO::MH_CORE)
-          process_sp.reset(
-              new ProcessMachCore(target_sp, listener_sp, *crash_file));
+          process_sp = std::make_shared<ProcessMachCore>(target_sp, listener_sp,
+                                                         *crash_file);
       }
     }
   }
   return process_sp;
 }
 
 bool ProcessMachCore::CanDebug(lldb::TargetSP target_sp,
                                bool plugin_specified_by_name) {

source/Plugins/Process/minidump/ProcessMinidump.cpp

 //===-- ProcessMinidump.cpp -------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "ProcessMinidump.h"
+
 #include "ThreadMinidump.h"
 
 #include "lldb/Core/DumpDataExtractor.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Interpreter/CommandInterpreter.h"

 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/State.h"
 
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Threading.h"
 
 #include "Plugins/Process/Utility/StopInfoMachException.h"
 
-// C includes
-// C++ includes
+#include <memory>
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace minidump;
 
 //------------------------------------------------------------------
 /// A placeholder module used for minidumps, where the original
 /// object files may not be available (so we can't parse the object
LoadSubCommand("dump",
         CommandObjectSP(new CommandObjectProcessMinidumpDump(interpreter)));
   }
 
   ~CommandObjectMultiwordProcessMinidump() {}
 };
 
 CommandObject *ProcessMinidump::GetPluginCommandObject() {
   if (!m_command_sp)
-    m_command_sp.reset(new CommandObjectMultiwordProcessMinidump(
-        GetTarget().GetDebugger().GetCommandInterpreter()));
+    m_command_sp = std::make_shared<CommandObjectMultiwordProcessMinidump>(
+        GetTarget().GetDebugger().GetCommandInterpreter());
   return m_command_sp.get();
 }

source/Plugins/Process/minidump/ThreadMinidump.cpp

 //===-- ThreadMinidump.cpp --------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "ThreadMinidump.h"
+
 #include "ProcessMinidump.h"
 
 #include "RegisterContextMinidump_ARM.h"
 #include "RegisterContextMinidump_ARM64.h"
 #include "RegisterContextMinidump_x86_32.h"
 #include "RegisterContextMinidump_x86_64.h"
 
 #include "Plugins/Process/Utility/RegisterContextLinux_i386.h"
 #include "Plugins/Process/Utility/RegisterContextLinux_x86_64.h"
 #include "Plugins/Process/elf-core/RegisterContextPOSIXCore_x86_64.h"
 #include "Plugins/Process/elf-core/RegisterUtilities.h"
 
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Unwind.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Log.h"
 
+#include <memory>
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace minidump;
 
 ThreadMinidump::ThreadMinidump(Process &process, const MinidumpThread &td,
                                llvm::ArrayRef<uint8_t> gpregset_data)
     : Thread(process, td.thread_id), m_thread_reg_ctx_sp(),
if (concrete_frame_idx == 0) {
 
     // TODO write other register contexts and add them here
     switch (arch.GetMachine()) {
     case llvm::Triple::x86: {
       reg_interface = new RegisterContextLinux_i386(arch);
       lldb::DataBufferSP buf =
           ConvertMinidumpContext_x86_32(m_gpregset_data, reg_interface);
       DataExtractor gpregset(buf, lldb::eByteOrderLittle, 4);
-      m_thread_reg_ctx_sp.reset(new RegisterContextCorePOSIX_x86_64(
-          *this, reg_interface, gpregset, {}));
+      m_thread_reg_ctx_sp = std::make_shared<RegisterContextCorePOSIX_x86_64>(
+          *this, reg_interface, gpregset,
+          llvm::ArrayRef<lldb_private::CoreNote>());
       break;
     }
     case llvm::Triple::x86_64: {
       reg_interface = new RegisterContextLinux_x86_64(arch);
       lldb::DataBufferSP buf =
           ConvertMinidumpContext_x86_64(m_gpregset_data, reg_interface);
       DataExtractor gpregset(buf, lldb::eByteOrderLittle, 8);
-      m_thread_reg_ctx_sp.reset(new RegisterContextCorePOSIX_x86_64(
-          *this, reg_interface, gpregset, {}));
+      m_thread_reg_ctx_sp = std::make_shared<RegisterContextCorePOSIX_x86_64>(
+          *this, reg_interface, gpregset,
+          llvm::ArrayRef<lldb_private::CoreNote>());
       break;
     }
     case llvm::Triple::aarch64: {
       DataExtractor data(m_gpregset_data.data(), m_gpregset_data.size(),
                          lldb::eByteOrderLittle, 8);
-      m_thread_reg_ctx_sp.reset(new RegisterContextMinidump_ARM64(*this, data));
+      m_thread_reg_ctx_sp =
+          std::make_shared<RegisterContextMinidump_ARM64>(*this, data);
       break;
     }
     case llvm::Triple::arm: {
       DataExtractor data(m_gpregset_data.data(), m_gpregset_data.size(),
                          lldb::eByteOrderLittle, 8);
       const bool apple = arch.GetTriple().getVendor() == llvm::Triple::Apple;
-      m_thread_reg_ctx_sp.reset(
-          new RegisterContextMinidump_ARM(*this, data, apple));
+      m_thread_reg_ctx_sp =
+          std::make_shared<RegisterContextMinidump_ARM>(*this, data, apple);
       break;
     }
     default:
       break;
     }
 
     reg_ctx_sp = m_thread_reg_ctx_sp;
   } else if (m_unwinder_ap) {
     reg_ctx_sp = m_unwinder_ap->CreateRegisterContextForFrame(frame);
   }
 
   return reg_ctx_sp;
 }
 
 bool ThreadMinidump::CalculateStopInfo() { return false; }

source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp

 
 #include "PythonDataObjects.h"
 #include "PythonExceptionState.h"
 #include "ScriptInterpreterPython.h"
 
 #include <stdio.h>
 #include <stdlib.h>
 
+#include <memory>
 #include <mutex>
 #include <string>
 
 #include "lldb/API/SBValue.h"
 #include "lldb/API/SBFrame.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Breakpoint/StoppointCallbackContext.h"
 #include "lldb/Breakpoint/WatchpointOptions.h"
#endif
           if (conn_ap->IsConnected()) {
             output_comm.SetConnection(conn_ap.release());
             output_comm.SetReadThreadBytesReceivedCallback(
                 ReadThreadBytesReceived, &result->GetOutputStream());
             output_comm.StartReadThread();
             join_read_thread = true;
             FILE *outfile_handle =
                 fdopen(pipe.ReleaseWriteFileDescriptor(), "w");
-            output_file_sp.reset(new StreamFile(outfile_handle, true));
+            output_file_sp = std::make_shared<StreamFile>(outfile_handle, true);
             error_file_sp = output_file_sp;
             if (outfile_handle)
               ::setbuf(outfile_handle, nullptr);
 
             result->SetImmediateOutputFile(
                 debugger.GetOutputFile()->GetFile().GetStream());
             result->SetImmediateErrorFile(
                 debugger.GetErrorFile()->GetFile().GetStream());
           }
         }
       }
       if (!input_file_sp || !output_file_sp || !error_file_sp)
         debugger.AdoptTopIOHandlerFilesIfInvalid(input_file_sp, output_file_sp,
                                                  error_file_sp);
     } else {
-      input_file_sp.reset(new StreamFile());
+      input_file_sp = std::make_shared<StreamFile>();
       FileSystem::Instance().Open(input_file_sp->GetFile(),
                                   FileSpec(FileSystem::DEV_NULL),
                                   File::eOpenOptionRead);
 
-      output_file_sp.reset(new StreamFile());
+      output_file_sp = std::make_shared<StreamFile>();
       FileSystem::Instance().Open(output_file_sp->GetFile(),
                                   FileSpec(FileSystem::DEV_NULL),
                                   File::eOpenOptionWrite);
 
       error_file_sp = output_file_sp;
     }
 
     FILE *in_file = input_file_sp->GetFile().GetStream();
if (python_function_name && *python_function_name) {
       }
     }
   } else {
     retval.assign("<no function name>");
     return false;
   }
 
   if (new_callee && old_callee != new_callee)
-    callee_wrapper_sp.reset(new StructuredPythonObject(new_callee));
+    callee_wrapper_sp = std::make_shared<StructuredPythonObject>(new_callee);
 
   return ret_val;
 }
 
 void ScriptInterpreterPython::Clear() {
   // Release any global variables that might have strong references to
   // LLDB objects when clearing the python script interpreter.
   Locker locker(this, ScriptInterpreterPython::Locker::AcquireLock,
if (module_sp) {
       command_stream.Clear();
       command_stream.Printf("%s", basename.c_str());
       void *module_pyobj = nullptr;
       if (ExecuteOneLineWithReturn(
               command_stream.GetData(),
               ScriptInterpreter::eScriptReturnTypeOpaqueObject,
               &module_pyobj) &&
           module_pyobj)
-        module_sp->reset(new StructuredPythonObject(module_pyobj));
+        *module_sp = std::make_shared<StructuredPythonObject>(module_pyobj);
     }
 
     return true;
   }
 }
 
 bool ScriptInterpreterPython::IsReservedWord(const char *word) {
   if (!word || !word[0])

source/Plugins/StructuredData/DarwinLog/StructuredDataDarwinLog.cpp

 //===-- StructuredDataDarwinLog.cpp -----------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "StructuredDataDarwinLog.h"
 
-// C includes
 #include <string.h>
 
-// C++ includes
+#include <memory>
 #include <sstream>
 
 #include "lldb/Breakpoint/StoppointCallbackContext.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Interpreter/CommandInterpreter.h"

 class StructuredDataDarwinLogProperties : public Properties {
 public:
   static ConstString &GetSettingName() {
     static ConstString g_setting_name("darwin-log");
     return g_setting_name;
   }
 
   StructuredDataDarwinLogProperties() : Properties() {
-    m_collection_sp.reset(new OptionValueProperties(GetSettingName()));
+    m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName());
     m_collection_sp->Initialize(g_properties);
   }
 
   virtual ~StructuredDataDarwinLogProperties() {}
 
   bool GetEnableOnStartup() const {
     const uint32_t idx = ePropertyEnableOnStartup;
     return m_collection_sp->GetPropertyAtIndexAsBoolean(

 };
 
 using StructuredDataDarwinLogPropertiesSP =
     std::shared_ptr<StructuredDataDarwinLogProperties>;
 
 static const StructuredDataDarwinLogPropertiesSP &GetGlobalProperties() {
   static StructuredDataDarwinLogPropertiesSP g_settings_sp;
   if (!g_settings_sp)
-    g_settings_sp.reset(new StructuredDataDarwinLogProperties());
+    g_settings_sp = std::make_shared<StructuredDataDarwinLogProperties>();
   return g_settings_sp;
 }
 
 const char *const s_filter_attributes[] = {
     "activity",       // current activity
     "activity-chain", // entire activity chain, each level separated by ':'
     "category",       // category of the log message
     "message",        // message contents, fully expanded

source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

 #include "lldb/Utility/StreamString.h"
 
 #include "clang/AST/CXXInheritance.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/DeclTemplate.h"
 
 #include <map>
+#include <memory>
 #include <vector>
 
 //#define ENABLE_DEBUG_PRINTF // COMMENT OUT THIS LINE PRIOR TO CHECKIN
 
 #ifdef ENABLE_DEBUG_PRINTF
 #include <stdio.h>
 #define DEBUG_PRINTF(fmt, ...) printf(fmt, __VA_ARGS__)
 #else
if (type_ptr == NULL) {
                     resolve_state = Type::eResolveStateFull;
                   }
                 }
               }
             }
           }
         }
 
-        type_sp.reset(
-            new Type(die.GetID(), dwarf, type_name_const_str, byte_size, NULL,
-                     DIERef(encoding_uid).GetUID(dwarf), encoding_data_type,
-                     &decl, clang_type, resolve_state));
+        type_sp = std::make_shared<Type>(
+            die.GetID(), dwarf, type_name_const_str, byte_size, nullptr,
+            DIERef(encoding_uid).GetUID(dwarf), encoding_data_type, &decl,
+            clang_type, resolve_state);
 
         dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
       } break;
 
       case DW_TAG_structure_type:
       case DW_TAG_union_type:
       case DW_TAG_class_type: {
         // Set a bit that lets us know that we are currently parsing this
if (type_ptr == NULL) {
                                                 class_language, &metadata);
           }
         }
         
         // Store a forward declaration to this class type in case any
         // parameters in any class methods need it for the clang types for
         // function prototypes.
         LinkDeclContextToDIE(m_ast.GetDeclContextForType(clang_type), die);
-        type_sp.reset(new Type(die.GetID(), dwarf, type_name_const_str,
-                               byte_size, NULL, LLDB_INVALID_UID,
-                               Type::eEncodingIsUID, &decl, clang_type,
-                               Type::eResolveStateForward));
+        type_sp = std::make_shared<Type>(
+            die.GetID(), dwarf, type_name_const_str, byte_size, nullptr,
+            LLDB_INVALID_UID, Type::eEncodingIsUID, &decl, clang_type,
+            Type::eResolveStateForward);
 
         type_sp->SetIsCompleteObjCClass(is_complete_objc_class);
 
         // Add our type to the unique type map so we don't end up creating many
         // copies of the same type over and over in the ASTContext for our
         // module
         unique_ast_entry_ap->m_type_sp = type_sp;
         unique_ast_entry_ap->m_die = die;
if (type_ptr == NULL) {
           } else {
             enumerator_clang_type =
                 m_ast.GetEnumerationIntegerType(clang_type.GetOpaqueQualType());
           }
 
           LinkDeclContextToDIE(
               ClangASTContext::GetDeclContextForType(clang_type), die);
 
-          type_sp.reset(new Type(
-              die.GetID(), dwarf, type_name_const_str, byte_size, NULL,
+          type_sp = std::make_shared<Type>(
+              die.GetID(), dwarf, type_name_const_str, byte_size, nullptr,
               DIERef(encoding_form).GetUID(dwarf), Type::eEncodingIsUID, &decl,
-              clang_type, Type::eResolveStateForward));
+              clang_type, Type::eResolveStateForward);
 
           if (ClangASTContext::StartTagDeclarationDefinition(clang_type)) {
             if (die.HasChildren()) {
               SymbolContext cu_sc(die.GetLLDBCompileUnit());
               bool is_signed = false;
               enumerator_clang_type.IsIntegerType(is_signed);
               ParseChildEnumerators(cu_sc, clang_type, is_signed,
                                     type_sp->GetByteSize().getValueOr(0), die);

                                 object_pointer_name.c_str(),
                                 static_cast<void *>(function_decl));
                 }
                 m_ast.SetMetadata(function_decl, metadata);
               }
             }
           }
         }
-        type_sp.reset(new Type(die.GetID(), dwarf, type_name_const_str,
-                               llvm::None, NULL, LLDB_INVALID_UID,
-                               Type::eEncodingIsUID, &decl, clang_type,
-                               Type::eResolveStateFull));
+        type_sp = std::make_shared<Type>(
+            die.GetID(), dwarf, type_name_const_str, llvm::None, nullptr,
+            LLDB_INVALID_UID, Type::eEncodingIsUID, &decl, clang_type,
+            Type::eResolveStateFull);
         assert(type_sp.get());
       } break;
 
       case DW_TAG_array_type: {
         // Set a bit that lets us know that we are currently parsing this
         dwarf->GetDIEToType()[die.GetDIE()] = DIE_IS_BEING_PARSED;
 
         DWARFFormValue type_die_form;

                     num_elements ? array_element_bit_stride * num_elements
                                  : array_element_bit_stride;
               }
             } else {
               clang_type =
                   m_ast.CreateArrayType(array_element_type, 0, is_vector);
             }
             ConstString empty_name;
-            type_sp.reset(new Type(
+            type_sp = std::make_shared<Type>(
                 die.GetID(), dwarf, empty_name, array_element_bit_stride / 8,
-                NULL, DIERef(type_die_form).GetUID(dwarf), Type::eEncodingIsUID,
-                &decl, clang_type, Type::eResolveStateFull));
+                nullptr, DIERef(type_die_form).GetUID(dwarf),
+                Type::eEncodingIsUID, &decl, clang_type,
+                Type::eResolveStateFull);
             type_sp->SetEncodingType(element_type);
             m_ast.SetMetadataAsUserID(clang_type.GetOpaqueQualType(),
                                       die.GetID());
           }
         }
       } break;
 
       case DW_TAG_ptr_to_member_type: {

           CompilerType class_clang_type = class_type->GetLayoutCompilerType();
 
           clang_type = ClangASTContext::CreateMemberPointerType(
               class_clang_type, pointee_clang_type);
 
           if (llvm::Optional<uint64_t> clang_type_size =
                   clang_type.GetByteSize(nullptr)) {
             byte_size = *clang_type_size;
-            type_sp.reset(new Type(die.GetID(), dwarf, type_name_const_str,
-                                   byte_size, NULL, LLDB_INVALID_UID,
-                                   Type::eEncodingIsUID, NULL, clang_type,
-                                   Type::eResolveStateForward));
+            type_sp = std::make_shared<Type>(
+                die.GetID(), dwarf, type_name_const_str, byte_size, nullptr,
+                LLDB_INVALID_UID, Type::eEncodingIsUID, nullptr, clang_type,
+                Type::eResolveStateForward);
           }
         }
 
         break;
       }
       default:
         dwarf->GetObjectFile()->GetModule()->ReportError(
             "{0x%8.8x}: unhandled type tag 0x%4.4x (%s), please file a bug and "
if (func_range.GetBaseAddress().IsValid()) {
       SymbolFileDWARF *dwarf = die.GetDWARF();
       // Supply the type _only_ if it has already been parsed
       Type *func_type = dwarf->GetDIEToType().lookup(die.GetDIE());
 
       assert(func_type == NULL || func_type != DIE_IS_BEING_PARSED);
 
       if (dwarf->FixupAddress(func_range.GetBaseAddress())) {
         const user_id_t func_user_id = die.GetID();
-        func_sp.reset(new Function(&comp_unit,
+        func_sp =
+            std::make_shared<Function>(&comp_unit,
                                    func_user_id, // UserID is the DIE offset
                                    func_user_id, func_name, func_type,
-                                   func_range)); // first address range
+                                       func_range); // first address range
 
         if (func_sp.get() != NULL) {
           if (frame_base.IsValid())
             func_sp->GetFrameBaseExpression() = frame_base;
           comp_unit.AddFunction(func_sp);
           return func_sp.get();
         }
       }

source/Plugins/SymbolFile/DWARF/DWARFDebugLine.cpp

 //===-- DWARFDebugLine.cpp --------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "DWARFDebugLine.h"
 
 //#define ENABLE_DEBUG_PRINTF   // DO NOT LEAVE THIS DEFINED: DEBUG ONLY!!!
 #include <assert.h>
 
+#include <memory>
+
 #include "lldb/Core/FileSpecList.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Timer.h"
 
 #include "DWARFUnit.h"
 #include "LogChannelDWARF.h"
while (debug_line_data.ValidOffset(offset)) {
 
     if (ParseStatementTable(debug_line_data, &offset, line_table_sp.get(), nullptr)) {
       // Make sure we don't don't loop infinitely
       if (offset <= debug_line_offset)
         break;
       // DEBUG_PRINTF("m_lineTableMap[0x%8.8x] = line_table_sp\n",
       // debug_line_offset);
       m_lineTableMap[debug_line_offset] = line_table_sp;
-      line_table_sp.reset(new LineTable);
+      line_table_sp = std::make_shared<LineTable>();
     } else
       ++offset; // Try next byte in line table
   }
 }
 
 void DWARFDebugLine::ParseIfNeeded(const DWARFDataExtractor &debug_line_data) {
   if (m_lineTableMap.empty())
     Parse(debug_line_data);

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

 #include "ManualDWARFIndex.h"
 #include "SymbolFileDWARFDebugMap.h"
 #include "SymbolFileDWARFDwo.h"
 #include "SymbolFileDWARFDwp.h"
 
 #include "llvm/Support/FileSystem.h"
 
 #include <map>
+#include <memory>
 
 #include <ctype.h>
 #include <string.h>
 
 //#define ENABLE_DEBUG_PRINTF // COMMENT OUT THIS LINE PRIOR TO CHECKIN
 
 #ifdef ENABLE_DEBUG_PRINTF
 #include <stdio.h>

 
 class PluginProperties : public Properties {
 public:
   static ConstString GetSettingName() {
     return SymbolFileDWARF::GetPluginNameStatic();
   }
 
   PluginProperties() {
-    m_collection_sp.reset(new OptionValueProperties(GetSettingName()));
+    m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName());
     m_collection_sp->Initialize(g_properties);
   }
 
   FileSpecList &GetSymLinkPaths() {
     OptionValueFileSpecList *option_value =
         m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpecList(
             nullptr, true, ePropertySymLinkPaths);
     assert(option_value);
if (comp_unit) {
                                              remapped_file))
                 cu_file_spec.SetFile(remapped_file, FileSpec::Style::native);
             }
 
             LanguageType cu_language = DWARFUnit::LanguageTypeFromDWARF(
                 cu_die.GetAttributeValueAsUnsigned(DW_AT_language, 0));
 
             bool is_optimized = dwarf_cu->GetIsOptimized();
-            cu_sp.reset(new CompileUnit(
+            cu_sp = std::make_shared<CompileUnit>(
                 module_sp, dwarf_cu, cu_file_spec, dwarf_cu->GetID(),
-                cu_language, is_optimized ? eLazyBoolYes : eLazyBoolNo));
+                cu_language, is_optimized ? eLazyBoolYes : eLazyBoolNo);
             if (cu_sp) {
               // If we just created a compile unit with an invalid file spec,
               // try and get the first entry in the supports files from the
               // line table as that should be the compile unit.
               if (!cu_file_spec) {
                 cu_file_spec = cu_sp->GetSupportFiles().GetFileSpecAtIndex(1);
                 if (cu_file_spec) {
                   (FileSpec &)(*cu_sp) = cu_file_spec;
if (sc.function) {
 
       if (dwarf_cu == NULL)
         return 0;
 
       uint32_t vars_added = 0;
       VariableListSP variables(sc.comp_unit->GetVariableList(false));
 
       if (variables.get() == NULL) {
-        variables.reset(new VariableList());
+        variables = std::make_shared<VariableList>();
         sc.comp_unit->SetVariableList(variables);
 
         DIEArray die_offsets;
         m_index->GetGlobalVariables(*dwarf_cu, die_offsets);
         const size_t num_matches = die_offsets.size();
         if (num_matches) {
           for (size_t i = 0; i < num_matches; ++i) {
             const DIERef &die_ref = die_offsets[i];
if (num_attributes > 0) {
             new SymbolFileType(*this, DIERef(type_die_form).GetUID(this)));
 
         if (const_value.Form() && type_sp && type_sp->GetType())
           location.CopyOpcodeData(
               const_value.Unsigned(),
               type_sp->GetType()->GetByteSize().getValueOr(0),
               die.GetCU()->GetAddressByteSize());
 
-        var_sp.reset(new Variable(die.GetID(), name, mangled, type_sp, scope,
-                                  symbol_context_scope, scope_ranges, &decl,
-                                  location, is_external, is_artificial,
-                                  is_static_member));
+        var_sp = std::make_shared<Variable>(
+            die.GetID(), name, mangled, type_sp, scope, symbol_context_scope,
+            scope_ranges, &decl, location, is_external, is_artificial,
+            is_static_member);
 
         var_sp->SetLocationIsConstantValueData(location_is_const_value_data);
       } else {
         // Not ready to parse this variable yet. It might be a global or static
         // variable that is in a function scope and the function in the symbol
         // context wasn't filled in yet
         return var_sp;
       }
if (var_sp) {
           DWARFDIE sc_parent_die = GetParentSymbolContextDIE(orig_die);
           dw_tag_t parent_tag = sc_parent_die.Tag();
           switch (parent_tag) {
           case DW_TAG_compile_unit:
           case DW_TAG_partial_unit:
             if (sc.comp_unit != NULL) {
               variable_list_sp = sc.comp_unit->GetVariableList(false);
               if (variable_list_sp.get() == NULL) {
-                variable_list_sp.reset(new VariableList());
+                variable_list_sp = std::make_shared<VariableList>();
               }
             } else {
               GetObjectFile()->GetModule()->ReportError(
                   "parent 0x%8.8" PRIx64 " %s with no valid compile unit in "
                                          "symbol context for 0x%8.8" PRIx64
                   " %s.\n",
                   sc_parent_die.GetID(), sc_parent_die.GetTagAsCString(),
                   orig_die.GetID(), orig_die.GetTagAsCString());
if (var_sp) {
                   block = sc.function->GetBlock(true).FindBlockByID(
                       concrete_block_die.GetID());
               }
 
               if (block != NULL) {
                 const bool can_create = false;
                 variable_list_sp = block->GetBlockVariableList(can_create);
                 if (variable_list_sp.get() == NULL) {
-                  variable_list_sp.reset(new VariableList());
+                  variable_list_sp = std::make_shared<VariableList>();
                   block->SetVariableList(variable_list_sp);
                 }
               }
             }
             break;
 
           default:
             GetObjectFile()->GetModule()->ReportError(

source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp

 //===-- SymbolFileDWARFDebugMap.cpp -----------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "SymbolFileDWARFDebugMap.h"
-
 #include "DWARFDebugAranges.h"
 
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/RangeMap.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Host/FileSystem.h"

 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Symbol/TypeMap.h"
 #include "lldb/Symbol/VariableList.h"
 #include "llvm/Support/ScopedPrinter.h"
 
 #include "LogChannelDWARF.h"
 #include "SymbolFileDWARF.h"
 
+#include <memory>
+
 using namespace lldb;
 using namespace lldb_private;
 
 // Subclass lldb_private::Module so we can intercept the
 // "Module::GetObjectFile()" (so we can fixup the object file sections) and
 // also for "Module::GetSymbolVendor()" (so we can fixup the symbol file id.
 
 const SymbolFileDWARFDebugMap::FileRangeMap &
Module *SymbolFileDWARFDebugMap::GetModuleByCompUnitInfo(
     CompileUnitInfo *comp_unit_info) {
   if (!comp_unit_info->oso_sp) {
     auto pos = m_oso_map.find(
         {comp_unit_info->oso_path, comp_unit_info->oso_mod_time});
     if (pos != m_oso_map.end()) {
       comp_unit_info->oso_sp = pos->second;
     } else {
       ObjectFile *obj_file = GetObjectFile();
-      comp_unit_info->oso_sp.reset(new OSOInfo());
+      comp_unit_info->oso_sp = std::make_shared<OSOInfo>();
       m_oso_map[{comp_unit_info->oso_path, comp_unit_info->oso_mod_time}] =
           comp_unit_info->oso_sp;
       const char *oso_path = comp_unit_info->oso_path.GetCString();
       FileSpec oso_file(oso_path);
       ConstString oso_object;
       if (FileSystem::Instance().Exists(oso_file)) {
         // The modification time returned by the FS can have a higher precision
         // than the one from the CU.
if (pos != m_oso_map.end()) {
       // -apple-macosx" due to the lack of a LC_VERSION_MIN_MACOSX or
       // LC_VERSION_MIN_IPHONEOS load command...
       oso_arch.SetTriple(m_obj_file->GetModule()
                              ->GetArchitecture()
                              .GetTriple()
                              .getArchName()
                              .str()
                              .c_str());
-      comp_unit_info->oso_sp->module_sp.reset(new DebugMapModule(
+      comp_unit_info->oso_sp->module_sp = std::make_shared<DebugMapModule>(
           obj_file->GetModule(), GetCompUnitInfoIndex(comp_unit_info), oso_file,
-          oso_arch, oso_object ? &oso_object : NULL, 0,
-          oso_object ? comp_unit_info->oso_mod_time
-                     : llvm::sys::TimePoint<>()));
+          oso_arch, oso_object ? &oso_object : nullptr, 0,
+          oso_object ? comp_unit_info->oso_mod_time : llvm::sys::TimePoint<>());
     }
   }
   if (comp_unit_info->oso_sp)
     return comp_unit_info->oso_sp->module_sp.get();
   return NULL;
 }
 
 bool SymbolFileDWARFDebugMap::GetFileSpecForSO(uint32_t oso_idx,
CompUnitSP SymbolFileDWARFDebugMap::ParseCompileUnitAtIndex(uint32_t cu_idx) {
   if (cu_idx < cu_count) {
     Module *oso_module = GetModuleByCompUnitInfo(&m_compile_unit_infos[cu_idx]);
     if (oso_module) {
       FileSpec so_file_spec;
       if (GetFileSpecForSO(cu_idx, so_file_spec)) {
         // User zero as the ID to match the compile unit at offset zero in each
         // .o file since each .o file can only have one compile unit for now.
         lldb::user_id_t cu_id = 0;
-        m_compile_unit_infos[cu_idx].compile_unit_sp.reset(
-            new CompileUnit(m_obj_file->GetModule(), NULL, so_file_spec, cu_id,
-                            eLanguageTypeUnknown, eLazyBoolCalculate));
+        m_compile_unit_infos[cu_idx].compile_unit_sp =
+            std::make_shared<CompileUnit>(
+                m_obj_file->GetModule(), nullptr, so_file_spec, cu_id,
+                eLanguageTypeUnknown, eLazyBoolCalculate);
 
         if (m_compile_unit_infos[cu_idx].compile_unit_sp) {
           // Let our symbol vendor know about this compile unit
           m_obj_file->GetModule()->GetSymbolVendor()->SetCompileUnitAtIndex(
               cu_idx, m_compile_unit_infos[cu_idx].compile_unit_sp);
         }
       }
     }

source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.cpp

 //===-- SymbolFileSymtab.cpp ------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "SymbolFileSymtab.h"
+
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/Symtab.h"
 #include "lldb/Symbol/TypeList.h"
 #include "lldb/Utility/RegularExpression.h"
 #include "lldb/Utility/Timer.h"
 
+#include <memory>
+
 using namespace lldb;
 using namespace lldb_private;
 
 void SymbolFileSymtab::Initialize() {
   PluginManager::RegisterPlugin(GetPluginNameStatic(),
                                 GetPluginDescriptionStatic(), CreateInstance);
 }
 
CompUnitSP SymbolFileSymtab::ParseCompileUnitAtIndex(uint32_t idx) {
   CompUnitSP cu_sp;
 
   // If we don't have any source file symbols we will just have one compile
   // unit for the entire object file
   if (idx < m_source_indexes.size()) {
     const Symbol *cu_symbol =
         m_obj_file->GetSymtab()->SymbolAtIndex(m_source_indexes[idx]);
     if (cu_symbol)
-      cu_sp.reset(new CompileUnit(m_obj_file->GetModule(), NULL,
+      cu_sp = std::make_shared<CompileUnit>(m_obj_file->GetModule(), nullptr,
                                   cu_symbol->GetName().AsCString(), 0,
-                                  eLanguageTypeUnknown, eLazyBoolNo));
+                                            eLanguageTypeUnknown, eLazyBoolNo);
   }
   return cu_sp;
 }
 
 lldb::LanguageType SymbolFileSymtab::ParseLanguage(CompileUnit &comp_unit) {
   return eLanguageTypeUnknown;
 }
 

source/Plugins/SystemRuntime/MacOSX/SystemRuntimeMacOSX.cpp

 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.h"
 
 #include "SystemRuntimeMacOSX.h"
 
+#include <memory>
+
 using namespace lldb;
 using namespace lldb_private;
 
 //----------------------------------------------------------------------
 // Create an instance of this class. This function is filled into the plugin
 // info class that gets handed out by the plugin factory and allows the lldb to
 // instantiate an instance of this class.
 //----------------------------------------------------------------------
if (real_thread->GetExtendedBacktraceToken() != LLDB_INVALID_ADDRESS) {
             error.Success()) {
           DataExtractor extractor(data.GetBytes(), data.GetByteSize(),
                                   m_process->GetByteOrder(),
                                   m_process->GetAddressByteSize());
           ItemInfo item = ExtractItemInfoFromBuffer(extractor);
           bool stop_id_is_valid = true;
           if (item.stop_id == 0)
             stop_id_is_valid = false;
-          originating_thread_sp.reset(new HistoryThread(
+          originating_thread_sp = std::make_shared<HistoryThread>(
               *m_process, item.enqueuing_thread_id, item.enqueuing_callstack,
-              item.stop_id, stop_id_is_valid));
+              item.stop_id, stop_id_is_valid);
           originating_thread_sp->SetExtendedBacktraceToken(
               item.item_that_enqueued_this);
           originating_thread_sp->SetQueueName(
               item.enqueuing_queue_label.c_str());
           originating_thread_sp->SetQueueID(item.enqueuing_queue_serialnum);
           //                    originating_thread_sp->SetThreadName
           //                    (item.enqueuing_thread_label.c_str());
         }
if (m_process->ReadMemory(ret.item_buffer_ptr, data.GetBytes(),
         error.Success()) {
       DataExtractor extractor(data.GetBytes(), data.GetByteSize(),
                               m_process->GetByteOrder(),
                               m_process->GetAddressByteSize());
       ItemInfo item = ExtractItemInfoFromBuffer(extractor);
       bool stop_id_is_valid = true;
       if (item.stop_id == 0)
         stop_id_is_valid = false;
-      return_thread_sp.reset(new HistoryThread(
+      return_thread_sp = std::make_shared<HistoryThread>(
           *m_process, item.enqueuing_thread_id, item.enqueuing_callstack,
-          item.stop_id, stop_id_is_valid));
+          item.stop_id, stop_id_is_valid);
       return_thread_sp->SetExtendedBacktraceToken(item.item_that_enqueued_this);
       return_thread_sp->SetQueueName(item.enqueuing_queue_label.c_str());
       return_thread_sp->SetQueueID(item.enqueuing_queue_serialnum);
       //            return_thread_sp->SetThreadName
       //            (item.enqueuing_thread_label.c_str());
 
       m_page_to_free = ret.item_buffer_ptr;
       m_page_to_free_size = ret.item_buffer_size;
     }
   }
   return return_thread_sp;
 }
 
 ThreadSP
 SystemRuntimeMacOSX::GetExtendedBacktraceForQueueItem(QueueItemSP queue_item_sp,
                                                       ConstString type) {
   ThreadSP extended_thread_sp;
   if (type != ConstString("libdispatch"))
     return extended_thread_sp;
 
   bool stop_id_is_valid = true;
   if (queue_item_sp->GetStopID() == 0)
     stop_id_is_valid = false;
 
-  extended_thread_sp.reset(
-      new HistoryThread(*m_process, queue_item_sp->GetEnqueueingThreadID(),
-                        queue_item_sp->GetEnqueueingBacktrace(),
-                        queue_item_sp->GetStopID(), stop_id_is_valid));
+  extended_thread_sp = std::make_shared<HistoryThread>(
+      *m_process, queue_item_sp->GetEnqueueingThreadID(),
+      queue_item_sp->GetEnqueueingBacktrace(), queue_item_sp->GetStopID(),
+      stop_id_is_valid);
   extended_thread_sp->SetExtendedBacktraceToken(
       queue_item_sp->GetItemThatEnqueuedThis());
   extended_thread_sp->SetQueueName(queue_item_sp->GetQueueLabel().c_str());
   extended_thread_sp->SetQueueID(queue_item_sp->GetEnqueueingQueueID());
   //    extended_thread_sp->SetThreadName
   //    (queue_item_sp->GetThreadLabel().c_str());
 
   return extended_thread_sp;

source/Plugins/UnwindAssembly/x86/x86AssemblyInspectionEngine.cpp

 //===-- x86AssemblyInspectionEngine.cpp -------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "x86AssemblyInspectionEngine.h"
 
+#include <memory>
+
 #include "llvm-c/Disassembler.h"
 
 #include "lldb/Core/Address.h"
 #include "lldb/Symbol/UnwindPlan.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/UnwindAssembly.h"
 
 using namespace lldb_private;
while (offset < size) {
     if (offset >= size) 
       continue;
 
     if (reinstate_unwind_state) {
       UnwindPlan::RowSP new_row(new UnwindPlan::Row());
       *new_row = *original_last_row;
       new_row->SetOffset(offset);
       unwind_plan.AppendRow(new_row);
-      row.reset(new UnwindPlan::Row());
+      row = std::make_shared<UnwindPlan::Row>();
       *row = *new_row;
       reinstate_unwind_state = false;
       unwind_plan_updated = true;
       continue;
     }
 
     // If we already have one row for this instruction, we can continue.
     while (row_id < unwind_plan.GetRowCount() &&

source/Symbol/Block.cpp

 #include "lldb/Core/Module.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Utility/Log.h"
 
+#include <memory>
+
 using namespace lldb;
 using namespace lldb_private;
 
 Block::Block(lldb::user_id_t uid)
     : UserID(uid), m_parent_scope(nullptr), m_children(), m_ranges(),
       m_inlineInfoSP(), m_variable_list_sp(), m_parsed_block_info(false),
       m_parsed_block_variables(false), m_parsed_child_blocks(false) {}
 
if (child_block_sp) {
     child_block_sp->SetParentScope(this);
     m_children.push_back(child_block_sp);
   }
 }
 
 void Block::SetInlinedFunctionInfo(const char *name, const char *mangled,
                                    const Declaration *decl_ptr,
                                    const Declaration *call_decl_ptr) {
-  m_inlineInfoSP.reset(
-      new InlineFunctionInfo(name, mangled, decl_ptr, call_decl_ptr));
+  m_inlineInfoSP = std::make_shared<InlineFunctionInfo>(name, mangled, decl_ptr,
+                                                        call_decl_ptr);
 }
 
 VariableListSP Block::GetBlockVariableList(bool can_create) {
   if (!m_parsed_block_variables) {
     if (m_variable_list_sp.get() == nullptr && can_create) {
       m_parsed_block_variables = true;
       SymbolContext sc;
       CalculateSymbolContext(&sc);

source/Symbol/ClangASTImporter.cpp

 #include "lldb/Symbol/ClangUtil.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/Log.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclObjC.h"
 #include "llvm/Support/raw_ostream.h"
 
+#include <memory>
+
 using namespace lldb_private;
 using namespace clang;
 
 ClangASTMetrics::Counters ClangASTMetrics::global_counters = {0, 0, 0, 0, 0, 0};
 ClangASTMetrics::Counters ClangASTMetrics::local_counters = {0, 0, 0, 0, 0, 0};
 
 void ClangASTMetrics::DumpCounters(Log *log,
                                    ClangASTMetrics::Counters &counters) {
const NamespaceDecl *parent_namespace =
       dyn_cast<NamespaceDecl>(parent_context);
   NamespaceMapSP parent_map;
 
   if (parent_namespace)
     parent_map = GetNamespaceMap(parent_namespace);
 
   NamespaceMapSP new_map;
 
-  new_map.reset(new NamespaceMap);
+  new_map = std::make_shared<NamespaceMap>();
 
   if (context_md->m_map_completer) {
     std::string namespace_string = decl->getDeclName().getAsString();
 
     context_md->m_map_completer->CompleteNamespaceMap(
         new_map, ConstString(namespace_string.c_str()), parent_map);
   }
 

source/Symbol/CompactUnwindInfo.cpp

 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/UnwindPlan.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.h"
-#include <algorithm>
 
 #include "llvm/Support/MathExtras.h"
 
+#include <algorithm>
+#include <memory>
+
 using namespace lldb;
 using namespace lldb_private;
 
 namespace lldb_private {
 
 // Constants from <mach-o/compact_unwind_encoding.h>
 
 FLAGS_ANONYMOUS_ENUM(){
m_objfile.GetModule()->LogMessage(
         log, "Reading compact unwind first-level indexes");
 
   if (!m_unwindinfo_data_computed) {
     if (m_section_sp->IsEncrypted()) {
       // Can't get section contents of a protected/encrypted section until we
       // have a live process and can read them out of memory.
       if (process_sp.get() == nullptr)
         return;
-      m_section_contents_if_encrypted.reset(
-          new DataBufferHeap(m_section_sp->GetByteSize(), 0));
+      m_section_contents_if_encrypted =
+          std::make_shared<DataBufferHeap>(m_section_sp->GetByteSize(), 0);
       Status error;
       if (process_sp->ReadMemory(
               m_section_sp->GetLoadBaseAddress(&process_sp->GetTarget()),
               m_section_contents_if_encrypted->GetBytes(),
               m_section_sp->GetByteSize(),
               error) == m_section_sp->GetByteSize() &&
           error.Success()) {
         m_unwindinfo_data.SetAddressByteSize(

source/Symbol/FuncUnwinders.cpp

 #include "lldb/Target/ABI.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterNumber.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/UnwindAssembly.h"
 
+#include <memory>
+
 using namespace lldb;
 using namespace lldb_private;
 
 //------------------------------------------------
 /// constructor
 //------------------------------------------------
 
 FuncUnwinders::FuncUnwinders(UnwindTable &unwind_table, AddressRange range)
UnwindPlanSP FuncUnwinders::GetEHFrameUnwindPlan(Target &target,
 
   m_tried_unwind_plan_eh_frame = true;
   if (m_range.GetBaseAddress().IsValid()) {
     Address current_pc(m_range.GetBaseAddress());
     if (current_offset != -1)
       current_pc.SetOffset(current_pc.GetOffset() + current_offset);
     DWARFCallFrameInfo *eh_frame = m_unwind_table.GetEHFrameInfo();
     if (eh_frame) {
-      m_unwind_plan_eh_frame_sp.reset(
-          new UnwindPlan(lldb::eRegisterKindGeneric));
+      m_unwind_plan_eh_frame_sp =
+          std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
       if (!eh_frame->GetUnwindPlan(current_pc, *m_unwind_plan_eh_frame_sp))
         m_unwind_plan_eh_frame_sp.reset();
     }
   }
   return m_unwind_plan_eh_frame_sp;
 }
 
 UnwindPlanSP FuncUnwinders::GetDebugFrameUnwindPlan(Target &target,
                                                     int current_offset) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   if (m_unwind_plan_debug_frame_sp || m_tried_unwind_plan_debug_frame)
     return m_unwind_plan_debug_frame_sp;
 
   m_tried_unwind_plan_debug_frame = true;
   if (m_range.GetBaseAddress().IsValid()) {
     Address current_pc(m_range.GetBaseAddress());
     if (current_offset != -1)
       current_pc.SetOffset(current_pc.GetOffset() + current_offset);
     DWARFCallFrameInfo *debug_frame = m_unwind_table.GetDebugFrameInfo();
     if (debug_frame) {
-      m_unwind_plan_debug_frame_sp.reset(
-          new UnwindPlan(lldb::eRegisterKindGeneric));
+      m_unwind_plan_debug_frame_sp =
+          std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
       if (!debug_frame->GetUnwindPlan(current_pc,
                                       *m_unwind_plan_debug_frame_sp))
         m_unwind_plan_debug_frame_sp.reset();
     }
   }
   return m_unwind_plan_debug_frame_sp;
 }
 
 UnwindPlanSP FuncUnwinders::GetArmUnwindUnwindPlan(Target &target,
                                                    int current_offset) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   if (m_unwind_plan_arm_unwind_sp.get() || m_tried_unwind_plan_arm_unwind)
     return m_unwind_plan_arm_unwind_sp;
 
   m_tried_unwind_plan_arm_unwind = true;
   if (m_range.GetBaseAddress().IsValid()) {
     Address current_pc(m_range.GetBaseAddress());
     if (current_offset != -1)
       current_pc.SetOffset(current_pc.GetOffset() + current_offset);
     ArmUnwindInfo *arm_unwind_info = m_unwind_table.GetArmUnwindInfo();
     if (arm_unwind_info) {
-      m_unwind_plan_arm_unwind_sp.reset(
-          new UnwindPlan(lldb::eRegisterKindGeneric));
+      m_unwind_plan_arm_unwind_sp =
+          std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
       if (!arm_unwind_info->GetUnwindPlan(target, current_pc,
                                           *m_unwind_plan_arm_unwind_sp))
         m_unwind_plan_arm_unwind_sp.reset();
     }
   }
   return m_unwind_plan_arm_unwind_sp;
 }
 
UnwindPlanSP FuncUnwinders::GetEHFrameAugmentedUnwindPlan(Target &target,
   }
 
   m_tried_unwind_plan_eh_frame_augmented = true;
 
   UnwindPlanSP eh_frame_plan = GetEHFrameUnwindPlan(target, current_offset);
   if (!eh_frame_plan)
     return m_unwind_plan_eh_frame_augmented_sp;
 
-  m_unwind_plan_eh_frame_augmented_sp.reset(new UnwindPlan(*eh_frame_plan));
+  m_unwind_plan_eh_frame_augmented_sp =
+      std::make_shared<UnwindPlan>(*eh_frame_plan);
 
   // Augment the eh_frame instructions with epilogue descriptions if necessary
   // so the UnwindPlan can be used at any instruction in the function.
 
   UnwindAssemblySP assembly_profiler_sp(GetUnwindAssemblyProfiler(target));
   if (assembly_profiler_sp) {
     if (!assembly_profiler_sp->AugmentUnwindPlanFromCallSite(
             m_range, thread, *m_unwind_plan_eh_frame_augmented_sp)) {
FuncUnwinders::GetDebugFrameAugmentedUnwindPlan(Target &target, Thread &thread,
 
   m_tried_unwind_plan_debug_frame_augmented = true;
 
   UnwindPlanSP debug_frame_plan =
       GetDebugFrameUnwindPlan(target, current_offset);
   if (!debug_frame_plan)
     return m_unwind_plan_debug_frame_augmented_sp;
 
-  m_unwind_plan_debug_frame_augmented_sp.reset(
-      new UnwindPlan(*debug_frame_plan));
+  m_unwind_plan_debug_frame_augmented_sp =
+      std::make_shared<UnwindPlan>(*debug_frame_plan);
 
   // Augment the debug_frame instructions with epilogue descriptions if
   // necessary so the UnwindPlan can be used at any instruction in the
   // function.
 
   UnwindAssemblySP assembly_profiler_sp(GetUnwindAssemblyProfiler(target));
   if (assembly_profiler_sp) {
     if (!assembly_profiler_sp->AugmentUnwindPlanFromCallSite(
if (m_unwind_plan_assembly_sp.get() || m_tried_unwind_plan_assembly ||
       !m_unwind_table.GetAllowAssemblyEmulationUnwindPlans()) {
     return m_unwind_plan_assembly_sp;
   }
 
   m_tried_unwind_plan_assembly = true;
 
   UnwindAssemblySP assembly_profiler_sp(GetUnwindAssemblyProfiler(target));
   if (assembly_profiler_sp) {
-    m_unwind_plan_assembly_sp.reset(new UnwindPlan(lldb::eRegisterKindGeneric));
+    m_unwind_plan_assembly_sp =
+        std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
     if (!assembly_profiler_sp->GetNonCallSiteUnwindPlanFromAssembly(
             m_range, thread, *m_unwind_plan_assembly_sp)) {
       m_unwind_plan_assembly_sp.reset();
     }
   }
   return m_unwind_plan_assembly_sp;
 }
 
UnwindPlanSP FuncUnwinders::GetUnwindPlanFastUnwind(Target &target,
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   if (m_unwind_plan_fast_sp.get() || m_tried_unwind_fast)
     return m_unwind_plan_fast_sp;
 
   m_tried_unwind_fast = true;
 
   UnwindAssemblySP assembly_profiler_sp(GetUnwindAssemblyProfiler(target));
   if (assembly_profiler_sp) {
-    m_unwind_plan_fast_sp.reset(new UnwindPlan(lldb::eRegisterKindGeneric));
+    m_unwind_plan_fast_sp =
+        std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
     if (!assembly_profiler_sp->GetFastUnwindPlan(m_range, thread,
                                                  *m_unwind_plan_fast_sp)) {
       m_unwind_plan_fast_sp.reset();
     }
   }
   return m_unwind_plan_fast_sp;
 }
 
 UnwindPlanSP FuncUnwinders::GetUnwindPlanArchitectureDefault(Thread &thread) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   if (m_unwind_plan_arch_default_sp.get() || m_tried_unwind_arch_default)
     return m_unwind_plan_arch_default_sp;
 
   m_tried_unwind_arch_default = true;
 
   Address current_pc;
   ProcessSP process_sp(thread.CalculateProcess());
   if (process_sp) {
     ABI *abi = process_sp->GetABI().get();
     if (abi) {
-      m_unwind_plan_arch_default_sp.reset(
-          new UnwindPlan(lldb::eRegisterKindGeneric));
+      m_unwind_plan_arch_default_sp =
+          std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
       if (!abi->CreateDefaultUnwindPlan(*m_unwind_plan_arch_default_sp)) {
         m_unwind_plan_arch_default_sp.reset();
       }
     }
   }
 
   return m_unwind_plan_arch_default_sp;
 }
 
 UnwindPlanSP
 FuncUnwinders::GetUnwindPlanArchitectureDefaultAtFunctionEntry(Thread &thread) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   if (m_unwind_plan_arch_default_at_func_entry_sp.get() ||
       m_tried_unwind_arch_default_at_func_entry)
     return m_unwind_plan_arch_default_at_func_entry_sp;
 
   m_tried_unwind_arch_default_at_func_entry = true;
 
   Address current_pc;
   ProcessSP process_sp(thread.CalculateProcess());
   if (process_sp) {
     ABI *abi = process_sp->GetABI().get();
     if (abi) {
-      m_unwind_plan_arch_default_at_func_entry_sp.reset(
-          new UnwindPlan(lldb::eRegisterKindGeneric));
+      m_unwind_plan_arch_default_at_func_entry_sp =
+          std::make_shared<UnwindPlan>(lldb::eRegisterKindGeneric);
       if (!abi->CreateFunctionEntryUnwindPlan(
               *m_unwind_plan_arch_default_at_func_entry_sp)) {
         m_unwind_plan_arch_default_at_func_entry_sp.reset();
       }
     }
   }
 
   return m_unwind_plan_arch_default_at_func_entry_sp;

source/Target/CPPLanguageRuntime.cpp

 //===-- CPPLanguageRuntime.cpp
 //-------------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Target/CPPLanguageRuntime.h"
 
 #include <string.h>
 
+#include <memory>
+
 #include "llvm/ADT/StringRef.h"
 
 #include "lldb/Symbol/Block.h"
 #include "lldb/Symbol/VariableList.h"
 
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/UniqueCStringMap.h"
 #include "lldb/Symbol/ClangASTContext.h"
if (frame) {
 
     CPPLanguageRuntime::LibCppStdFunctionCallableInfo callable_info =
         FindLibCppStdFunctionCallableInfo(value_sp);
 
     if (callable_info.callable_case != LibCppStdFunctionCallableCase::Invalid &&
         value_sp->GetValueIsValid()) {
       // We found the std::function wrapped callable and we have its address.
       // We now create a ThreadPlan to run to the callable.
-      ret_plan_sp.reset(new ThreadPlanRunToAddress(
-          thread, callable_info.callable_address, stop_others));
+      ret_plan_sp = std::make_shared<ThreadPlanRunToAddress>(
+          thread, callable_info.callable_address, stop_others);
       return ret_plan_sp;
     } else {
       // We are in std::function but we could not obtain the callable.
       // We create a ThreadPlan to keep stepping through using the address range
       // of the current function.
-      ret_plan_sp.reset(new ThreadPlanStepInRange(thread, range_of_curr_func,
-                                                  sc, eOnlyThisThread,
-                                                  eLazyBoolYes, eLazyBoolYes));
+      ret_plan_sp = std::make_shared<ThreadPlanStepInRange>(
+          thread, range_of_curr_func, sc, eOnlyThisThread, eLazyBoolYes,
+          eLazyBoolYes);
       return ret_plan_sp;
     }
   }
 
   return ret_plan_sp;
 }

source/Target/Memory.cpp

 //===-- Memory.cpp ----------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Target/Memory.h"
-#include <inttypes.h>
+
 #include "lldb/Core/RangeMap.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/State.h"
 
+#include <cinttypes>
+#include <memory>
+
 using namespace lldb;
 using namespace lldb_private;
 
 //----------------------------------------------------------------------
 // MemoryCache constructor
 //----------------------------------------------------------------------
 MemoryCache::MemoryCache(Process &process)
     : m_mutex(), m_L1_cache(), m_L2_cache(), m_invalid_ranges(),
AllocatedMemoryCache::AllocatePage(uint32_t byte_size, uint32_t permissions,
   if (log) {
     log->Printf("Process::DoAllocateMemory (byte_size = 0x%8.8" PRIx32
                 ", permissions = %s) => 0x%16.16" PRIx64,
                 (uint32_t)page_byte_size, GetPermissionsAsCString(permissions),
                 (uint64_t)addr);
   }
 
   if (addr != LLDB_INVALID_ADDRESS) {
-    block_sp.reset(
-        new AllocatedBlock(addr, page_byte_size, permissions, chunk_size));
+    block_sp = std::make_shared<AllocatedBlock>(addr, page_byte_size,
+                                                permissions, chunk_size);
     m_memory_map.insert(std::make_pair(permissions, block_sp));
   }
   return block_sp;
 }
 
 lldb::addr_t AllocatedMemoryCache::AllocateMemory(size_t byte_size,
                                                   uint32_t permissions,
                                                   Status &error) {

source/Target/Platform.cpp

 //===-- Platform.cpp --------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include <algorithm>
 #include <csignal>
 #include <fstream>
+#include <memory>
 #include <vector>
 
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 
 #include "lldb/Breakpoint/BreakpointIDList.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Debugger.h"

 } // namespace
 
 ConstString PlatformProperties::GetSettingName() {
   static ConstString g_setting_name("platform");
   return g_setting_name;
 }
 
 PlatformProperties::PlatformProperties() {
-  m_collection_sp.reset(new OptionValueProperties(GetSettingName()));
+  m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName());
   m_collection_sp->Initialize(g_properties);
 
   auto module_cache_dir = GetModuleCacheDirectory();
   if (module_cache_dir)
     return;
 
   llvm::SmallString<64> user_home_dir;
   if (!llvm::sys::path::home_directory(user_home_dir))

source/Target/Process.cpp

 //===-- Process.cpp ---------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include <atomic>
+#include <memory>
 #include <mutex>
 
 #include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/Threading.h"
 
 #include "Plugins/Process/Utility/InferiorCallPOSIX.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Breakpoint/StoppointCallbackContext.h"

 };
 
 ProcessProperties::ProcessProperties(lldb_private::Process *process)
     : Properties(),
       m_process(process) // Can be nullptr for global ProcessProperties
 {
   if (process == nullptr) {
     // Global process properties, set them up one time
-    m_collection_sp.reset(
-        new ProcessOptionValueProperties(ConstString("process")));
+    m_collection_sp =
+        std::make_shared<ProcessOptionValueProperties>(ConstString("process"));
     m_collection_sp->Initialize(g_properties);
     m_collection_sp->AppendProperty(
         ConstString("thread"), ConstString("Settings specific to threads."),
         true, Thread::GetGlobalProperties()->GetValueProperties());
   } else {
-    m_collection_sp.reset(
-        new ProcessOptionValueProperties(Process::GetGlobalProperties().get()));
+    m_collection_sp = std::make_shared<ProcessOptionValueProperties>(
+        Process::GetGlobalProperties().get());
     m_collection_sp->SetValueChangedCallback(
         ePropertyPythonOSPluginPath,
         ProcessProperties::OptionValueChangedCallback, this);
   }
 }
 
 ProcessProperties::~ProcessProperties() = default;
 
if (conn_ap) {
     if (m_stdio_communication.IsConnected()) {
       m_stdio_communication.SetReadThreadBytesReceivedCallback(
           STDIOReadThreadBytesReceived, this);
       m_stdio_communication.StartReadThread();
 
       // Now read thread is set up, set up input reader.
 
       if (!m_process_input_reader)
-        m_process_input_reader.reset(new IOHandlerProcessSTDIO(this, fd));
+        m_process_input_reader =
+            std::make_shared<IOHandlerProcessSTDIO>(this, fd);
     }
   }
 }
 
 bool Process::ProcessIOHandlerIsActive() {
   IOHandlerSP io_handler_sp(m_process_input_reader);
   if (io_handler_sp)
     return GetTarget().GetDebugger().IsTopIOHandler(io_handler_sp);
ThreadCollectionSP Process::GetHistoryThreads(lldb::addr_t addr) {
 
   const MemoryHistorySP &memory_history =
       MemoryHistory::FindPlugin(shared_from_this());
 
   if (!memory_history) {
     return threads;
   }
 
-  threads.reset(new ThreadCollection(memory_history->GetHistoryThreads(addr)));
+  threads = std::make_shared<ThreadCollection>(
+      memory_history->GetHistoryThreads(addr));
 
   return threads;
 }
 
 InstrumentationRuntimeSP
 Process::GetInstrumentationRuntime(lldb::InstrumentationRuntimeType type) {
   InstrumentationRuntimeCollection::iterator pos;
   pos = m_instrumentation_runtimes.find(type);

source/Target/StackFrame.cpp

 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StackFrameRecognizer.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/RegisterValue.h"
 
 #include "lldb/lldb-enumerations.h"
 
+#include <memory>
+
 using namespace lldb;
 using namespace lldb_private;
 
 // The first bits in the flags are reserved for the SymbolContext::Scope bits
 // so we know if we have tried to look up information in our internal symbol
 // context (m_sc) already.
 #define RESOLVED_FRAME_CODE_ADDR (uint32_t(eSymbolContextEverything + 1))
 #define RESOLVED_FRAME_ID_SYMBOL_SCOPE (RESOLVED_FRAME_CODE_ADDR << 1)
if (m_flags.IsClear(RESOLVED_VARIABLES)) {
     m_flags.Set(RESOLVED_VARIABLES);
 
     Block *frame_block = GetFrameBlock();
 
     if (frame_block) {
       const bool get_child_variables = true;
       const bool can_create = true;
       const bool stop_if_child_block_is_inlined_function = true;
-      m_variable_list_sp.reset(new VariableList());
+      m_variable_list_sp = std::make_shared<VariableList>();
       frame_block->AppendBlockVariables(can_create, get_child_variables,
                                         stop_if_child_block_is_inlined_function,
                                         [](Variable *v) { return true; },
                                         m_variable_list_sp.get());
     }
   }
 
   if (m_flags.IsClear(RESOLVED_GLOBAL_VARIABLES) && get_file_globals) {
ValueObjectSP StackFrame::TrackGlobalVariable(const VariableSP &variable_sp,
   // Check to make sure we aren't already tracking this variable?
   ValueObjectSP valobj_sp(
       GetValueObjectForFrameVariable(variable_sp, use_dynamic));
   if (!valobj_sp) {
     // We aren't already tracking this global
     VariableList *var_list = GetVariableList(true);
     // If this frame has no variables, create a new list
     if (var_list == nullptr)
-      m_variable_list_sp.reset(new VariableList());
+      m_variable_list_sp = std::make_shared<VariableList>();
 
     // Add the global/static variable to this frame
     m_variable_list_sp->AddVariable(variable_sp);
 
     // Now make a value object for it so we can track its changes
     valobj_sp = GetValueObjectForFrameVariable(variable_sp, use_dynamic);
   }
   return valobj_sp;

source/Target/StackFrameList.cpp

 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/Unwind.h"
 #include "lldb/Utility/Log.h"
 #include "llvm/ADT/SmallPtrSet.h"
 
+#include <memory>
+
 //#define DEBUG_STACK_FRAMES 1
 
 using namespace lldb;
 using namespace lldb_private;
 
 //----------------------------------------------------------------------
 // StackFrameList constructor
 //----------------------------------------------------------------------
if (idx == 0) {
           // There shouldn't be any way not to get the frame info for frame
           // 0. But if the unwinder can't make one, lets make one by hand
           // with the SP as the CFA and see if that gets any further.
           if (!success) {
             cfa = reg_ctx_sp->GetSP();
             pc = reg_ctx_sp->GetPC();
           }
 
-          unwind_frame_sp.reset(new StackFrame(m_thread.shared_from_this(),
-                                               m_frames.size(), idx, reg_ctx_sp,
-                                               cfa, pc, nullptr));
+          unwind_frame_sp = std::make_shared<StackFrame>(
+              m_thread.shared_from_this(), m_frames.size(), idx, reg_ctx_sp,
+              cfa, pc, nullptr);
           m_frames.push_back(unwind_frame_sp);
         }
       } else {
         unwind_frame_sp = m_frames.front();
         cfa = unwind_frame_sp->m_id.GetCallFrameAddress();
       }
     } else {
       const bool success =
           unwinder && unwinder->GetFrameInfoAtIndex(idx, cfa, pc);
       if (!success) {
         // We've gotten to the end of the stack.
         SetAllFramesFetched();
         break;
       }
       const bool cfa_is_valid = true;
-      unwind_frame_sp.reset(
-          new StackFrame(m_thread.shared_from_this(), m_frames.size(), idx, cfa,
-                         cfa_is_valid, pc, StackFrame::Kind::Regular, nullptr));
+      unwind_frame_sp = std::make_shared<StackFrame>(
+          m_thread.shared_from_this(), m_frames.size(), idx, cfa, cfa_is_valid,
+          pc, StackFrame::Kind::Regular, nullptr);
 
       // Create synthetic tail call frames between the previous frame and the
       // newly-found frame. The new frame's index may change after this call,
       // although its concrete index will stay the same.
       SynthesizeTailCallFrames(*unwind_frame_sp.get());
 
       m_frames.push_back(unwind_frame_sp);
     }
if (m_show_inlined_frames) {
       // GetFramesUpTo.
       frame_sp = m_frames[idx];
     } else {
       Unwind *unwinder = m_thread.GetUnwinder();
       if (unwinder) {
         addr_t pc, cfa;
         if (unwinder->GetFrameInfoAtIndex(idx, cfa, pc)) {
           const bool cfa_is_valid = true;
-          frame_sp.reset(new StackFrame(m_thread.shared_from_this(), idx, idx,
-                                        cfa, cfa_is_valid, pc,
-                                        StackFrame::Kind::Regular, nullptr));
+          frame_sp = std::make_shared<StackFrame>(
+              m_thread.shared_from_this(), idx, idx, cfa, cfa_is_valid, pc,
+              StackFrame::Kind::Regular, nullptr);
 
           Function *function =
               frame_sp->GetSymbolContext(eSymbolContextFunction).function;
           if (function) {
             // When we aren't showing inline functions we always use the top
             // most function block as the scope.
             frame_sp->SetSymbolContextScope(&function->GetBlock(false));
           } else {

source/Target/Target.cpp

 #include "lldb/Target/ThreadSpec.h"
 #include "lldb/Utility/Event.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/State.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/Timer.h"
+
+#include <memory>
 #include <mutex>
 
 using namespace lldb;
 using namespace lldb_private;
 
 constexpr std::chrono::milliseconds EvaluateExpressionOptions::default_timeout;
 
 Target::Arch::Arch(const ArchSpec &spec)

 }
 
 SearchFilterSP
 Target::GetSearchFilterForModule(const FileSpec *containingModule) {
   SearchFilterSP filter_sp;
   if (containingModule != nullptr) {
     // TODO: We should look into sharing module based search filters
     // across many breakpoints like we do for the simple target based one
-    filter_sp.reset(
-        new SearchFilterByModule(shared_from_this(), *containingModule));
+    filter_sp = std::make_shared<SearchFilterByModule>(shared_from_this(),
+                                                       *containingModule);
   } else {
     if (!m_search_filter_sp)
-      m_search_filter_sp.reset(
-          new SearchFilterForUnconstrainedSearches(shared_from_this()));
+      m_search_filter_sp =
+          std::make_shared<SearchFilterForUnconstrainedSearches>(
+              shared_from_this());
     filter_sp = m_search_filter_sp;
   }
   return filter_sp;
 }
 
 SearchFilterSP
 Target::GetSearchFilterForModuleList(const FileSpecList *containingModules) {
   SearchFilterSP filter_sp;
   if (containingModules && containingModules->GetSize() != 0) {
     // TODO: We should look into sharing module based search filters
     // across many breakpoints like we do for the simple target based one
-    filter_sp.reset(
-        new SearchFilterByModuleList(shared_from_this(), *containingModules));
+    filter_sp = std::make_shared<SearchFilterByModuleList>(shared_from_this(),
+                                                           *containingModules);
   } else {
     if (!m_search_filter_sp)
-      m_search_filter_sp.reset(
-          new SearchFilterForUnconstrainedSearches(shared_from_this()));
+      m_search_filter_sp =
+          std::make_shared<SearchFilterForUnconstrainedSearches>(
+              shared_from_this());
     filter_sp = m_search_filter_sp;
   }
   return filter_sp;
 }
 
 SearchFilterSP Target::GetSearchFilterForModuleAndCUList(
     const FileSpecList *containingModules,
     const FileSpecList *containingSourceFiles) {
   if (containingSourceFiles == nullptr || containingSourceFiles->GetSize() == 0)
     return GetSearchFilterForModuleList(containingModules);
 
   SearchFilterSP filter_sp;
   if (containingModules == nullptr) {
     // We could make a special "CU List only SearchFilter".  Better yet was if
     // these could be composable, but that will take a little reworking.
 
-    filter_sp.reset(new SearchFilterByModuleListAndCU(
-        shared_from_this(), FileSpecList(), *containingSourceFiles));
+    filter_sp = std::make_shared<SearchFilterByModuleListAndCU>(
+        shared_from_this(), FileSpecList(), *containingSourceFiles);
   } else {
-    filter_sp.reset(new SearchFilterByModuleListAndCU(
-        shared_from_this(), *containingModules, *containingSourceFiles));
+    filter_sp = std::make_shared<SearchFilterByModuleListAndCU>(
+        shared_from_this(), *containingModules, *containingSourceFiles);
   }
   return filter_sp;
 }
 
 BreakpointSP Target::CreateFuncRegexBreakpoint(
     const FileSpecList *containingModules,
     const FileSpecList *containingSourceFiles, RegularExpression &func_regex,
     lldb::LanguageType requested_language, LazyBool skip_prologue,
if (has_files && has_modules) {
     filter_sp = GetSearchFilterForModuleAndCUList(
       containingModules, containingSourceFiles);
   } else if (has_files) {
     filter_sp = GetSearchFilterForModuleAndCUList(
       nullptr, containingSourceFiles);
   } else if (has_modules) {
     filter_sp = GetSearchFilterForModuleList(containingModules);
   } else {
-    filter_sp.reset(new SearchFilterForUnconstrainedSearches(shared_from_this()));
+    filter_sp = std::make_shared<SearchFilterForUnconstrainedSearches>(
+        shared_from_this());
   }
   
   StructuredDataImpl *extra_args_impl = new StructuredDataImpl();
   if (extra_args_sp)
     extra_args_impl->SetObjectSP(extra_args_sp);
   
   BreakpointResolverSP resolver_sp(new 
                                    BreakpointResolverScripted(nullptr, class_name,
if (matched_sp) {
     } else {
       // Nil the matched watchpoint; we will be creating a new one.
       m_process_sp->DisableWatchpoint(matched_sp.get(), notify);
       m_watchpoint_list.Remove(matched_sp->GetID(), true);
     }
   }
 
   if (!wp_sp) {
-    wp_sp.reset(new Watchpoint(*this, addr, size, type));
+    wp_sp = std::make_shared<Watchpoint>(*this, addr, size, type);
     wp_sp->SetWatchpointType(kind, notify);
     m_watchpoint_list.Add(wp_sp, true);
   }
 
   error = m_process_sp->EnableWatchpoint(wp_sp.get(), notify);
   if (log)
     log->Printf("Target::%s (creation of watchpoint %s with id = %u)\n",
                 __FUNCTION__, error.Success() ? "succeeded" : "failed",
if (error.Success()) {
         error.SetErrorStringWithFormat(
             "Tried to append to invalid input file %s", path.c_str());
         return error;
       }
     }
   }
 
   if (!break_store_ptr) {
-    break_store_sp.reset(new StructuredData::Array());
+    break_store_sp = std::make_shared<StructuredData::Array>();
     break_store_ptr = break_store_sp.get();
   }
 
   StreamFile out_file(path.c_str(),
                       File::OpenOptions::eOpenOptionTruncate |
                           File::OpenOptions::eOpenOptionWrite |
                           File::OpenOptions::eOpenOptionCanCreate |
                           File::OpenOptions::eOpenOptionCloseOnExec,
if (TypeSystem *type_system = GetScratchTypeSystemForLanguage(
       return llvm::dyn_cast<ClangASTContext>(type_system);
   }
   return nullptr;
 }
 
 ClangASTImporterSP Target::GetClangASTImporter() {
   if (m_valid) {
     if (!m_ast_importer_sp) {
-      m_ast_importer_sp.reset(new ClangASTImporter());
+      m_ast_importer_sp = std::make_shared<ClangASTImporter>();
     }
     return m_ast_importer_sp;
   }
   return ClangASTImporterSP();
 }
 
 void Target::SettingsInitialize() { Process::SettingsInitialize(); }
 

 }
 
 //----------------------------------------------------------------------
 // TargetProperties
 //----------------------------------------------------------------------
 TargetProperties::TargetProperties(Target *target)
     : Properties(), m_launch_info() {
   if (target) {
-    m_collection_sp.reset(
-        new TargetOptionValueProperties(target, Target::GetGlobalProperties()));
+    m_collection_sp = std::make_shared<TargetOptionValueProperties>(
+        target, Target::GetGlobalProperties());
 
     // Set callbacks to update launch_info whenever "settins set" updated any
     // of these properties
     m_collection_sp->SetValueChangedCallback(
         ePropertyArg0, TargetProperties::Arg0ValueChangedCallback, this);
     m_collection_sp->SetValueChangedCallback(
         ePropertyRunArgs, TargetProperties::RunArgsValueChangedCallback, this);
     m_collection_sp->SetValueChangedCallback(
if (target) {
     // Target::GetPlatform()
     InputPathValueChangedCallback(this, nullptr);
     OutputPathValueChangedCallback(this, nullptr);
     ErrorPathValueChangedCallback(this, nullptr);
     DetachOnErrorValueChangedCallback(this, nullptr);
     DisableASLRValueChangedCallback(this, nullptr);
     DisableSTDIOValueChangedCallback(this, nullptr);
   } else {
-    m_collection_sp.reset(
-        new TargetOptionValueProperties(ConstString("target")));
+    m_collection_sp =
+        std::make_shared<TargetOptionValueProperties>(ConstString("target"));
     m_collection_sp->Initialize(g_properties);
     m_experimental_properties_up.reset(new TargetExperimentalProperties());
     m_collection_sp->AppendProperty(
         ConstString(Properties::GetExperimentalSettingsName()),
         ConstString("Experimental settings - setting these won't produce "
                     "errors if the setting is not present."),
         true, m_experimental_properties_up->GetValueProperties());
     m_collection_sp->AppendProperty(

source/Target/Thread.cpp

 #include "lldb/Target/Unwind.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/RegularExpression.h"
 #include "lldb/Utility/State.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/lldb-enumerations.h"
 
+#include <memory>
+
 using namespace lldb;
 using namespace lldb_private;
 
 const ThreadPropertiesSP &Thread::GetGlobalProperties() {
   // NOTE: intentional leak so we don't crash if global destructor chain gets
   // called as other threads still use the result of this function
   static ThreadPropertiesSP *g_settings_sp_ptr =
       new ThreadPropertiesSP(new ThreadProperties(true));
if (exe_ctx) {
       }
     }
     return ProtectedGetPropertyAtIndex(idx);
   }
 };
 
 ThreadProperties::ThreadProperties(bool is_global) : Properties() {
   if (is_global) {
-    m_collection_sp.reset(
-        new ThreadOptionValueProperties(ConstString("thread")));
+    m_collection_sp =
+        std::make_shared<ThreadOptionValueProperties>(ConstString("thread"));
     m_collection_sp->Initialize(g_properties);
   } else
-    m_collection_sp.reset(
-        new ThreadOptionValueProperties(Thread::GetGlobalProperties().get()));
+    m_collection_sp = std::make_shared<ThreadOptionValueProperties>(
+        Thread::GetGlobalProperties().get());
 }
 
 ThreadProperties::~ThreadProperties() = default;
 
 const RegularExpression *ThreadProperties::GetSymbolsToAvoidRegexp() {
   const uint32_t idx = ePropertyStepAvoidRegex;
   return m_collection_sp->GetPropertyAtIndexAsOptionValueRegex(nullptr, idx);
 }
ThreadPlanSP Thread::QueueThreadPlanForStepSingleInstruction(
   return thread_plan_sp;
 }
 
 ThreadPlanSP Thread::QueueThreadPlanForStepOverRange(
     bool abort_other_plans, const AddressRange &range,
     const SymbolContext &addr_context, lldb::RunMode stop_other_threads,
     Status &status, LazyBool step_out_avoids_code_withoug_debug_info) {
   ThreadPlanSP thread_plan_sp;
-  thread_plan_sp.reset(new ThreadPlanStepOverRange(
+  thread_plan_sp = std::make_shared<ThreadPlanStepOverRange>(
       *this, range, addr_context, stop_other_threads,
-      step_out_avoids_code_withoug_debug_info));
+      step_out_avoids_code_withoug_debug_info);
 
   status = QueueThreadPlan(thread_plan_sp, abort_other_plans);
   return thread_plan_sp;
 }
 
 // Call the QueueThreadPlanForStepOverRange method which takes an address
 // range.
 ThreadPlanSP Thread::QueueThreadPlanForStepOverRange(

 }
 
 StackFrameListSP Thread::GetStackFrameList() {
   StackFrameListSP frame_list_sp;
   std::lock_guard<std::recursive_mutex> guard(m_frame_mutex);
   if (m_curr_frames_sp) {
     frame_list_sp = m_curr_frames_sp;
   } else {
-    frame_list_sp.reset(new StackFrameList(*this, m_prev_frames_sp, true));
+    frame_list_sp =
+        std::make_shared<StackFrameList>(*this, m_prev_frames_sp, true);
     m_curr_frames_sp = frame_list_sp;
   }
   return frame_list_sp;
 }
 
 void Thread::ClearStackFrames() {
   std::lock_guard<std::recursive_mutex> guard(m_frame_mutex);
 

source/Target/ThreadPlanCallFunction.cpp

 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlanRunToAddress.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Stream.h"
 
+#include <memory>
+
 using namespace lldb;
 using namespace lldb_private;
 
 //----------------------------------------------------------------------
 // ThreadPlanCallFunction: Plan to call a single function
 //----------------------------------------------------------------------
 bool ThreadPlanCallFunction::ConstructorSetup(
     Thread &thread, ABI *&abi, lldb::addr_t &start_load_addr,
void ThreadPlanCallFunction::DidPush() {
 
   // Now set the thread state to "no reason" so we don't run with whatever
   // signal was outstanding... Wait till the plan is pushed so we aren't
   // changing the stop info till we're about to run.
 
   GetThread().SetStopInfoToNothing();
 
 #ifndef SINGLE_STEP_EXPRESSIONS
-  m_subplan_sp.reset(
-      new ThreadPlanRunToAddress(m_thread, m_start_addr, m_stop_other_threads));
+  m_subplan_sp = std::make_shared<ThreadPlanRunToAddress>(
+      m_thread, m_start_addr, m_stop_other_threads);
 
   m_thread.QueueThreadPlan(m_subplan_sp, false);
   m_subplan_sp->SetPrivate(true);
 #endif
 }
 
 bool ThreadPlanCallFunction::WillStop() { return true; }
 

source/Target/ThreadPlanStepOut.cpp

 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/ThreadPlanStepOverRange.h"
 #include "lldb/Target/ThreadPlanStepThrough.h"
 #include "lldb/Utility/Log.h"
 
+#include <memory>
+
 using namespace lldb;
 using namespace lldb_private;
 
 uint32_t ThreadPlanStepOut::s_default_flag_values = 0;
 
 //----------------------------------------------------------------------
 // ThreadPlanStepOut: Step out of the current frame
 //----------------------------------------------------------------------
ThreadPlanStepOut::ThreadPlanStepOut(
   // If the frame directly below the one we are returning to is inlined, we
   // have to be a little more careful.  It is non-trivial to determine the real
   // "return code address" for an inlined frame, so we have to work our way to
   // that frame and then step out.
   if (immediate_return_from_sp->IsInlined()) {
     if (frame_idx > 0) {
       // First queue a plan that gets us to this inlined frame, and when we get
       // there we'll queue a second plan that walks us out of this frame.
-      m_step_out_to_inline_plan_sp.reset(new ThreadPlanStepOut(
+      m_step_out_to_inline_plan_sp = std::make_shared<ThreadPlanStepOut>(
           m_thread, nullptr, false, stop_others, eVoteNoOpinion, eVoteNoOpinion,
-          frame_idx - 1, eLazyBoolNo, continue_to_next_branch));
+          frame_idx - 1, eLazyBoolNo, continue_to_next_branch);
       static_cast<ThreadPlanStepOut *>(m_step_out_to_inline_plan_sp.get())
           ->SetShouldStopHereCallbacks(nullptr, nullptr);
       m_step_out_to_inline_plan_sp->SetPrivate(true);
     } else {
       // If we're already at the inlined frame we're stepping through, then
       // just do that now.
       QueueInlinedStepPlan(false);
     }
if (inlined_block) {
       if (inlined_block->GetRangeAtIndex(0, inline_range)) {
         SymbolContext inlined_sc;
         inlined_block->CalculateSymbolContext(&inlined_sc);
         inlined_sc.target_sp = GetTarget().shared_from_this();
         RunMode run_mode =
             m_stop_others ? lldb::eOnlyThisThread : lldb::eAllThreads;
         const LazyBool avoid_no_debug = eLazyBoolNo;
 
-        m_step_through_inline_plan_sp.reset(new ThreadPlanStepOverRange(
-            m_thread, inline_range, inlined_sc, run_mode, avoid_no_debug));
+        m_step_through_inline_plan_sp =
+            std::make_shared<ThreadPlanStepOverRange>(
+                m_thread, inline_range, inlined_sc, run_mode, avoid_no_debug);
         ThreadPlanStepOverRange *step_through_inline_plan_ptr =
             static_cast<ThreadPlanStepOverRange *>(
                 m_step_through_inline_plan_sp.get());
         m_step_through_inline_plan_sp->SetPrivate(true);
 
         step_through_inline_plan_ptr->SetOkayToDiscard(true);
         StreamString errors;
         if (!step_through_inline_plan_ptr->ValidatePlan(&errors)) {

tools/debugserver/source/MacOSX/DarwinLog/DarwinLogCollector.cpp

 //===-- DarwinLogCollector.cpp ----------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "DarwinLogCollector.h"
 #include "ActivityStreamSPI.h"
 
 #include <dlfcn.h>
 
 #include <cinttypes>
+#include <memory>
 #include <mutex>
 #include <vector>
 
 #include "DNB.h"
 #include "DNBLog.h"
 #include "DarwinLogTypes.h"
 #include "LogFilterChain.h"
 #include "LogFilterExactMatch.h"
bool ParseFilterRules(const JSONObject &config) {
     // Retrieve the default rule.
     bool filter_default_accept = true;
     if (!config.GetObjectAsBool("filter-fall-through-accepts",
                                 filter_default_accept)) {
       DNBLogThreadedIf(LOG_DARWIN_LOG, "Setting 'filter-fall-through-accepts' "
                                        "missing from configuration.");
       return false;
     }
-    m_filter_chain_sp.reset(new LogFilterChain(filter_default_accept));
+    m_filter_chain_sp = std::make_shared<LogFilterChain>(filter_default_accept);
     DNBLogThreadedIf(LOG_DARWIN_LOG, "DarwinLog no-match rule: %s.",
                      filter_default_accept ? "accept" : "reject");
 
     // If we don't have the filter-rules array, we're done.
     auto filter_rules_sp = config.GetObject("filter-rules");
     if (!filter_rules_sp) {
       DNBLogThreadedIf(LOG_DARWIN_LOG,
                        "No 'filter-rules' config element, all log "
for (auto &rule_sp : rules_config.m_elements) {
         std::string exact_text;
         if (!rule_config.GetObjectAsString("exact_text", exact_text)) {
           DNBLogError("Exact match filter missing "
                       "'exact_text' element.");
           return false;
         }
 
         // Create the filter.
-        filter_sp.reset(
-            new LogFilterExactMatch(filter_accepts, target_enum, exact_text));
+        filter_sp = std::make_shared<LogFilterExactMatch>(
+            filter_accepts, target_enum, exact_text);
       }
 
       // Add the filter to the chain.
       m_filter_chain_sp->AppendFilter(filter_sp);
     }
     return true;
   }
 

tools/debugserver/source/MacOSX/MachThreadList.cpp

 //===-- MachThreadList.cpp --------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 //  Created by Greg Clayton on 6/19/07.
 //
 //===----------------------------------------------------------------------===//
 
 #include "MachThreadList.h"
 
-#include <inttypes.h>
-#include <sys/sysctl.h>
-
 #include "DNBLog.h"
 #include "DNBThreadResumeActions.h"
 #include "MachProcess.h"
 
+#include <inttypes.h>
+#include <sys/sysctl.h>
+
+#include <memory>
+
 MachThreadList::MachThreadList()
     : m_threads(), m_threads_mutex(PTHREAD_MUTEX_RECURSIVE),
       m_is_64_bit(false) {}
 
 MachThreadList::~MachThreadList() {}
 
 nub_state_t MachThreadList::GetState(nub_thread_t tid) {
   MachThreadSP thread_sp(GetThreadByID(tid));
if (err.Status() == KERN_SUCCESS && thread_list_count > 0) {
         uint64_t unique_thread_id =
             MachThread::GetGloballyUniqueThreadIDForMachPortID(mach_port_num);
         MachThreadSP thread_sp(GetThreadByID(unique_thread_id));
         if (thread_sp) {
           // Keep the existing thread class
           currThreads.push_back(thread_sp);
         } else {
           // We don't have this thread, lets add it.
-          thread_sp.reset(new MachThread(process, m_is_64_bit, unique_thread_id,
-                                         mach_port_num));
+          thread_sp = std::make_shared<MachThread>(
+              process, m_is_64_bit, unique_thread_id, mach_port_num);
 
           // Add the new thread regardless of its is user ready state...
           // Make sure the thread is ready to be displayed and shown to users
           // before we add this thread to our list...
           if (thread_sp->IsUserReady()) {
             if (new_threads)
               new_threads->push_back(thread_sp);
 

tools/debugserver/source/RNBRemote.cpp

 #include "RNBServices.h"
 #include "RNBSocket.h"
 #include "StdStringExtractor.h"
 
 #include <compression.h>
 
 #include <TargetConditionals.h>
 #include <iomanip>
+#include <memory>
 #include <sstream>
 #include <unordered_set>
 
 //----------------------------------------------------------------------
 // constants
 //----------------------------------------------------------------------
 
 static const std::string OS_LOG_EVENTS_KEY_NAME("events");
bool get_array_of_ints_value_for_key_name_from_json(
   }
   return false;
 }
 
 JSONGenerator::ObjectSP
 RNBRemote::GetJSONThreadsInfo(bool threads_with_valid_stop_info_only) {
   JSONGenerator::ArraySP threads_array_sp;
   if (m_ctx.HasValidProcessID()) {
-    threads_array_sp.reset(new JSONGenerator::Array());
+    threads_array_sp = std::make_shared<JSONGenerator::Array>();
 
     nub_process_t pid = m_ctx.ProcessID();
 
     nub_size_t numthreads = DNBProcessGetNumThreads(pid);
     for (nub_size_t i = 0; i < numthreads; ++i) {
       nub_thread_t tid = DNBProcessGetThreadAtIndex(pid, i);
 
       struct DNBThreadStopInfo tid_stop_info;

tools/debugserver/source/debugserver.cpp

 #include <netinet/in.h>
 #include <netinet/tcp.h>
 #include <string>
 #include <sys/select.h>
 #include <sys/socket.h>
 #include <sys/sysctl.h>
 #include <sys/types.h>
 #include <sys/un.h>
+
+#include <memory>
 #include <vector>
 
 #if defined(__APPLE__)
 #include <sched.h>
 extern "C" int proc_set_wakemon_params(pid_t, int,
                                        int); // <libproc_internal.h> SPI
 #endif
 
#endif
   // death,
   // we don't need no stinking SIGCHLD's...
 
   sigset_t sigset;
   sigemptyset(&sigset);
   sigaddset(&sigset, SIGCHLD);
   sigprocmask(SIG_BLOCK, &sigset, NULL);
 
-  g_remoteSP.reset(new RNBRemote());
+  g_remoteSP = std::make_shared<RNBRemote>();
 
   RNBRemote *remote = g_remoteSP.get();
   if (remote == NULL) {
     RNBLogSTDERR("error: failed to create a remote connection class\n");
     return -1;
   }
 
   RNBContext &ctx = remote->Context();

tools/debugserver/source/libdebugserver.cpp

 //===-- libdebugserver.cpp --------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include <errno.h>
 #include <getopt.h>
 #include <netinet/in.h>
 #include <sys/select.h>
 #include <sys/socket.h>
 #include <sys/sysctl.h>
 #include <sys/types.h>
 
+#include <memory>
+
 #include "DNB.h"
 #include "DNBLog.h"
 #include "DNBTimer.h"
 #include "PseudoTerminal.h"
 #include "RNBContext.h"
 #include "RNBRemote.h"
 #include "RNBServices.h"
 #include "RNBSocket.h"
#else
   DNBLogSetDebug(1);
   DNBLogSetVerbose(1);
   DNBLogSetLogMask(-1);
   DNBLogSetLogCallback(ASLLogCallback, NULL);
 #endif
 
   signal(SIGPIPE, signal_handler);
 
-  g_remoteSP.reset(new RNBRemote);
+  g_remoteSP = std::make_shared<RNBRemote>();
 
   RNBRemote *remote = g_remoteSP.get();
   if (remote == NULL) {
     RNBLogSTDERR("error: failed to create a remote connection class\n");
     return -1;
   }
 
   RNBRunLoopMode mode = eRNBRunLoopModeGetStartModeFromRemoteProtocol;

unittests/Editline/EditlineTest.cpp

void SetUp() {
     setenv("TERM", "vt100", 1);
 
     // Validate the editline adapter.
     EXPECT_TRUE(_el_adapter.IsValid());
     if (!_el_adapter.IsValid())
       return;
 
     // Dump output.
-    _sp_output_thread.reset(
-        new std::thread([&] { _el_adapter.ConsumeAllOutput(); }));
+    _sp_output_thread =
+        std::make_shared<std::thread>([&] { _el_adapter.ConsumeAllOutput(); });
   }
 
   void TearDown() {
     _el_adapter.CloseInput();
     if (_sp_output_thread)
       _sp_output_thread->join();
 
     FileSystem::Terminate();

unittests/UnwindAssembly/x86/Testx86AssemblyInspectionEngine.cpp

 //===-- Testx86AssemblyInspectionEngine.cpp ---------------------------*- C++
 //-*-===//
 
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "gtest/gtest.h"
 
+#include <memory>
 #include <vector>
 
 #include "Plugins/UnwindAssembly/x86/x86AssemblyInspectionEngine.h"
 #include "lldb/Core/Address.h"
 #include "lldb/Core/AddressRange.h"
 #include "lldb/Symbol/UnwindPlan.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/StreamString.h"
TEST_F(Testx86AssemblyInspectionEngine, TestSimplex86_64Augmented) {
   };
 
   sample_range = AddressRange(0x1000, sizeof(data));
 
   unwind_plan.SetSourceName("unit testing hand-created unwind plan");
   unwind_plan.SetPlanValidAddressRange(sample_range);
   unwind_plan.SetRegisterKind(eRegisterKindLLDB);
 
-  row_sp.reset(new UnwindPlan::Row);
+  row_sp = std::make_shared<UnwindPlan::Row>();
 
   // Describe offset 0
   row_sp->SetOffset(0);
   row_sp->GetCFAValue().SetIsRegisterPlusOffset(k_rsp, 8);
 
   regloc.SetAtCFAPlusOffset(-8);
   row_sp->SetRegisterInfo(k_rip, regloc);
 
TEST_F(Testx86AssemblyInspectionEngine, TestSimplei386ugmented) {
   };
 
   sample_range = AddressRange(0x1000, sizeof(data));
 
   unwind_plan.SetSourceName("unit testing hand-created unwind plan");
   unwind_plan.SetPlanValidAddressRange(sample_range);
   unwind_plan.SetRegisterKind(eRegisterKindLLDB);
 
-  row_sp.reset(new UnwindPlan::Row);
+  row_sp = std::make_shared<UnwindPlan::Row>();
 
   // Describe offset 0
   row_sp->SetOffset(0);
   row_sp->GetCFAValue().SetIsRegisterPlusOffset(k_esp, 4);
 
   regloc.SetAtCFAPlusOffset(-4);
   row_sp->SetRegisterInfo(k_eip, regloc);