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

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

12

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

[jingham]

lldb/source/API/SBData.cpp

12

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

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

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

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

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

Why not replace assignment with initialization here and below?

lldb/source/Target/Thread.cpp

1611

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

if (!m_opaque_sp)

lldb/source/Core/IOHandler.cpp

1012

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

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

I misunderstood, you're correct!

[tatyana-krasnukha]

Yes, of course!

[Eugene.Zelenko]

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

10

Spurious separator.

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

10

Spurious separator.

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

11

Wrong place.

lldb/tools/debugserver/source/debugserver.cpp

14

Wrong place.

lldb/source/API/SBCommandInterpreter.cpp

 //
 //===----------------------------------------------------------------------===//
 
+#include <memory>
+
 #include "lldb/lldb-types.h"
 
 #include "lldb/Interpreter/CommandInterpreter.h"

 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))

                                  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))

   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();

   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();

lldb/source/API/SBData.cpp

 
 #include <inttypes.h>
 
+#include <memory>
+
 #include "lldb/API/SBData.h"
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBStream.h"

                      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);

   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);
 

   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);
 

   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);
 

   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);
 

   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);
 

   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);
 

lldb/source/API/SBInstruction.cpp

 
 #include "lldb/API/SBAddress.h"
 #include "lldb/API/SBFrame.h"
+#include <memory>
+
 #include "lldb/API/SBInstruction.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBTarget.h"

 
 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/source/API/SBThread.cpp

 //
 //===----------------------------------------------------------------------===//
 
+#include <memory>
+
 #include "lldb/API/SBThread.h"
 
 #include "lldb/API/SBFileSpec.h"

 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);

lldb/source/API/SBThreadPlan.cpp

 //
 //===----------------------------------------------------------------------===//
 
+#include <memory>
+
 #include "lldb/API/SBThread.h"
 
 #include "lldb/API/SBFileSpec.h"

 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);
 }
 
 //----------------------------------------------------------------------

lldb/source/API/SBTrace.cpp

 //
 //===----------------------------------------------------------------------===//
 
+#include <memory>
+
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/Log.h"
 

 }
 
 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;
 }

lldb/source/API/SBTraceOptions.cpp

 //
 //===----------------------------------------------------------------------===//
 
+#include <memory>
+
 #include "lldb/API/SBTraceOptions.h"
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBStructuredData.h"

 using namespace lldb_private;
 
 SBTraceOptions::SBTraceOptions() {
-  m_traceoptions_sp.reset(new TraceOptions());
+  m_traceoptions_sp = std::make_shared<TraceOptions>();
 }
 
 lldb::TraceType SBTraceOptions::getType() const {

lldb/source/API/SBType.cpp

 //
 //===----------------------------------------------------------------------===//
 
+#include <memory>
+
 #include "lldb/API/SBType.h"
 #include "lldb/API/SBDefines.h"
 #include "lldb/API/SBStream.h"

 
 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;
 }
 

 
 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();
 }
 

lldb/source/API/SBTypeEnumMember.cpp

 //
 //===----------------------------------------------------------------------===//
 
+#include <memory>
+
 #include "lldb/API/SBTypeEnumMember.h"
 #include "lldb/API/SBDefines.h"
 #include "lldb/API/SBStream.h"

     : 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;
 }

 
 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();
 }
 

lldb/source/API/SBValue.cpp

 //
 //===----------------------------------------------------------------------===//
 
+#include <memory>
+
 #include "lldb/API/SBValue.h"
 
 #include "lldb/API/SBDeclaration.h"

   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) {

lldb/source/Breakpoint/Breakpoint.cpp

 //
 //===----------------------------------------------------------------------===//
 
+#include <memory>
+
 #include "llvm/Support/Casting.h"
 
 #include "lldb/Breakpoint/Breakpoint.h"

       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);

lldb/source/Commands/CommandObjectBreakpoint.cpp

 //
 //===----------------------------------------------------------------------===//
 
+#include <memory>
 #include <vector>
 
 #include "CommandObjectBreakpoint.h"

       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();
     }
 

lldb/source/Commands/CommandObjectFrame.cpp

 //
 //===----------------------------------------------------------------------===//
 
+#include <memory>
 #include <string>
 
 #include "CommandObjectFrame.h"

           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,

lldb/source/Commands/CommandObjectMemory.cpp

 
 #include <inttypes.h>
 
+#include <memory>
+
 #include "clang/AST/Decl.h"
 
 #include "CommandObjectMemory.h"

         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

         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

         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;

lldb/source/Commands/CommandObjectType.cpp

 #include <algorithm>
 #include <cctype>
 #include <functional>
+#include <memory>
 
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/IOHandler.h"

                 // 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;
 

                 // 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(

     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
 

     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();
 

 
     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 =

lldb/source/Core/IOHandler.cpp

 #if defined(__APPLE__)
 #include <deque>
 #endif
+#include <memory>
 #include <string>
 
 #include "lldb/Core/Debugger.h"

                            bool make_active) {
     WindowSP subwindow_sp;
     if (m_window) {
-      subwindow_sp.reset(new Window(
-          name, ::subwin(m_window, bounds.size.height, bounds.size.width,
-                         bounds.origin.y, bounds.origin.x),
-          true));
+      subwindow_sp = std::make_shared<Window>(
+          name,
+          ::subwin(m_window, bounds.size.height, bounds.size.width,
+                   bounds.origin.y, bounds.origin.x),
+          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;

 
   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;
   }
 

             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();

         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);

lldb/source/Core/ModuleList.cpp

 } // 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;

   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

 
       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 (!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

lldb/source/Core/ValueObject.cpp

 
 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;
 }

           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 {

     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

lldb/source/DataFormatters/StringPrinter.cpp

 
 #include <ctype.h>
 #include <locale>
+#include <memory>
 
 using namespace lldb;
 using namespace lldb_private;

     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,

lldb/source/Expression/Materializer.cpp

 //
 //===----------------------------------------------------------------------===//
 
+#include <memory>
+
 #include "lldb/Expression/Materializer.h"
 #include "lldb/Core/DumpDataExtractor.h"
 #include "lldb/Core/ValueObjectConstResult.h"

 
         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(

       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;
 

lldb/source/Expression/REPL.cpp

 //
 //===----------------------------------------------------------------------===//
 
+#include <memory>
+
 #include "lldb/Expression/REPL.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/PluginManager.h"

 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,
-                              "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));
+    m_io_handler_sp = std::make_shared<IOHandlerEditline>(
+        debugger, IOHandler::Type::REPL,
+        "lldb-repl",           // Name of input reader for history
+        true,                  // The REPL prompt is always colored
+        1,                     // Line number
+        *this);
 
     // Don't exit if CTRL+C is pressed
     static_cast<IOHandlerEditline *>(m_io_handler_sp.get())

lldb/source/Host/posix/ConnectionFileDescriptorPosix.cpp

 #include <unistd.h>
 #endif
 
+#include <memory>
 #include <sstream>
 
 #include "llvm/Support/Errno.h"

 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));

             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;

           ::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

lldb/source/Interpreter/CommandInterpreter.cpp

 //
 //===----------------------------------------------------------------------===//
 
+#include <memory>
 #include <stdlib.h>
 #include <string>
 #include <vector>

   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) {

 
   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, "--");

       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(),

         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;
 }

lldb/source/Interpreter/Property.cpp

 //
 //===----------------------------------------------------------------------===//
 
+#include <memory>
+
 #include "lldb/Interpreter/Property.h"
 
 #include "lldb/Core/UserSettingsController.h"

     // "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_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: {

   }
   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:

     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:

                                   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;
 

             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_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_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:

       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;
 

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

 
 #include "DynamicLoaderDarwinKernel.h"
 
+#include <memory>
+
 //#define ENABLE_DEBUG_PRINTF // COMMENT THIS LINE OUT PRIOR TO CHECKIN
 #ifdef ENABLE_DEBUG_PRINTF
 #include <stdio.h>

   }
 
   DynamicLoaderDarwinKernelProperties() : Properties() {
-    m_collection_sp.reset(new OptionValueProperties(GetSettingName()));
+    m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName());
     m_collection_sp->Initialize(g_properties);
   }
 

 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;
 }
 

       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;

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

 
 #include "DynamicLoaderHexagonDYLD.h"
 
+#include <memory>
+
 using namespace lldb;
 using namespace lldb_private;
 

 
     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;

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

 #include "Utility/UuidCompatibility.h"
 #else
 #include <uuid/uuid.h>
+
+#include <memory>
 #endif
 
 using namespace lldb;

           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)

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

 // Main header include
 #include "DynamicLoaderPOSIXDYLD.h"
 
+#include <memory>
+
 #include "AuxVector.h"
 
 #include "lldb/Breakpoint/BreakpointLocation.h"

 
     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;

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

 #include "clang/AST/ASTContext.h"
 #include "clang/AST/RecordLayout.h"
 
+#include <memory>
 #include <vector>
 
 using namespace clang;

     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)) {

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp

 //
 //===----------------------------------------------------------------------===//
 
-#include <cctype>
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTDiagnostic.h"
 #include "clang/AST/ExternalASTSource.h"

 #include "clang/Sema/CodeCompleteConsumer.h"
 #include "clang/Sema/Sema.h"
 #include "clang/Sema/SemaConsumer.h"
+#include <cctype>
+#include <memory>
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ExecutionEngine/ExecutionEngine.h"

     custom_passes.EarlyPasses->run(*llvm_module_ap);
   }
 
-  execution_unit_sp.reset(
-      new IRExecutionUnit(m_llvm_context, // handed off here
-                          llvm_module_ap, // handed off here
-                          function_name, exe_ctx.GetTargetSP(), sc,
-                          m_compiler->getTargetOpts().Features));
+  execution_unit_sp = std::make_shared<IRExecutionUnit>(
+      m_llvm_context, // handed off here
+      m_compiler->getTargetOpts().Features);
 
   ClangExpressionHelper *type_system_helper =
       dyn_cast<ClangExpressionHelper>(m_expr.GetTypeSystemHelper());

lldb/source/Plugins/InstrumentationRuntime/MainThreadChecker/MainThreadCheckerRuntime.cpp

 
 #include "MainThreadCheckerRuntime.h"
 
+#include <memory>
+
 #include "lldb/Breakpoint/StoppointCallbackContext.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"

 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")

lldb/source/Plugins/InstrumentationRuntime/TSan/TSanRuntime.cpp

 
 #include "TSanRuntime.h"
 
+#include <memory>
+
 #include "Plugins/Process/Utility/HistoryThread.h"
 #include "lldb/Breakpoint/StoppointCallbackContext.h"
 #include "lldb/Core/Debugger.h"

 ThreadSanitizerRuntime::GetBacktracesFromExtendedStopInfo(
     StructuredData::ObjectSP info) {
   ThreadCollectionSP threads;
-  threads.reset(new ThreadCollection());
+  threads = std::make_shared<ThreadCollection>();
 
   if (info->GetObjectForDotSeparatedPath("instrumentation_class")
           ->GetStringValue() != "ThreadSanitizer")

lldb/source/Plugins/InstrumentationRuntime/UBSan/UBSanRuntime.cpp

 #include "lldb/Utility/Stream.h"
 #include <ctype.h>
 
+#include <memory>
+
 using namespace lldb;
 using namespace lldb_private;
 

 UndefinedBehaviorSanitizerRuntime::GetBacktracesFromExtendedStopInfo(
     StructuredData::ObjectSP info) {
   ThreadCollectionSP threads;
-  threads.reset(new ThreadCollection());
+  threads = std::make_shared<ThreadCollection>();
 
   ProcessSP process_sp = GetProcessSP();
 

lldb/source/Plugins/JITLoader/GDB/JITLoaderGDB.cpp

 
 #include "JITLoaderGDB.h"
 
+#include <memory>
+
 using namespace lldb;
 using namespace lldb_private;
 

   }
 
   PluginProperties() {
-    m_collection_sp.reset(new OptionValueProperties(GetSettingName()));
+    m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName());
     m_collection_sp->Initialize(g_properties);
   }
 

   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;
 }
 

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

 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 
+#include <memory>
 #include <vector>
 
 using namespace lldb;

   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;
 }

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

 
 #include <stdint.h>
 
+#include <memory>
 #include <string>
 #include <vector>
 

   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?

 
 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/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTrampolineHandler.cpp

 
 #include "AppleObjCTrampolineHandler.h"
 
+#include <memory>
+
 #include "AppleThreadPlanStepThroughObjCTrampoline.h"
 
 #include "lldb/Breakpoint/StoppointCallbackContext.h"

         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;

       // 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);

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

 //===----------------------------------------------------------------------===//
 
 #include "AppleThreadPlanStepThroughObjCTrampoline.h"
+
 #include "AppleObjCTrampolineHandler.h"
 #include "lldb/Expression/DiagnosticManager.h"
 #include "lldb/Expression/FunctionCaller.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;

 
     // 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;

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

 #include "llvm/ADT/StringSwitch.h"
 
 #include "RenderScriptRuntime.h"
+
 #include "RenderScriptScriptGroup.h"
+#include <memory>
 
 #include "lldb/Breakpoint/StoppointCallbackContext.h"
 #include "lldb/Core/Debugger.h"

       }
     }
     if (!group) {
-      group.reset(new RSScriptGroupDescriptor);
+      group = std::make_shared<RSScriptGroupDescriptor>();
       group->m_name = group_name;
       m_scriptGroups.push_back(group);
     } else {

     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()

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

 #include "Utility/UuidCompatibility.h"
 #else
 #include <uuid/uuid.h>
+
+#include <memory>
 #endif
 
 #define THUMB_ADDRESS_BIT_MASK 0xfffffffffffffffeull

   // 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

         // 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
+        0,               // Segments have no alignment information
+        load_cmd.flags); // Flags for this section
 
     segment_sp->SetIsEncrypted(segment_is_encrypted);
     m_sections_ap->AddSection(segment_sp);

           }
         } 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

               // 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);

 
       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;
       }
     }

lldb/source/Plugins/OperatingSystem/Python/OperatingSystemPython.cpp

 #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 "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/StructuredData.h"
+#include <memory>
 
 using namespace lldb;
 using namespace lldb_private;

   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)) {

                   "= 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

       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;
 }

lldb/source/Plugins/Platform/MacOSX/PlatformDarwin.cpp

 #include <string.h>
 
 #include <algorithm>
+#include <memory>
 #include <mutex>
 
 #include "lldb/Breakpoint/BreakpointLocation.h"

                         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();
         }

         }
 
         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)

                       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

lldb/source/Plugins/Platform/MacOSX/PlatformDarwinKernel.cpp

 
 #include <CoreFoundation/CoreFoundation.h>
 
+#include <memory>
+
 #include "Host/macosx/cfcpp/CFCBundle.h"
 
 using namespace lldb;

   }
 
   PlatformDarwinKernelProperties() : Properties() {
-    m_collection_sp.reset(new OptionValueProperties(GetSettingName()));
+    m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName());
     m_collection_sp->Initialize(g_properties);
   }
 

 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;
 }
 

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

 #include <errno.h>
 #include <stdlib.h>
 
+#include <memory>
 #include <mutex>
 
 #include "lldb/Core/Debugger.h"

   }
 
   PluginProperties() : Properties() {
-    m_collection_sp.reset(new OptionValueProperties(GetSettingName()));
+    m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName());
     m_collection_sp->Initialize(g_properties);
   }
 

 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;
 }
 

                                            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;
 }
 

 
   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;

 
 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();
 }

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

 
 #include "ThreadKDP.h"
 
+#include <memory>
+
 #include "lldb/Host/SafeMachO.h"
 
 #include "lldb/Breakpoint/Watchpoint.h"

                   ->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");

lldb/source/Plugins/Process/Utility/HistoryThread.cpp

 #include "lldb/lldb-private.h"
 
 #include "Plugins/Process/Utility/HistoryThread.h"
+
 #include "Plugins/Process/Utility/HistoryUnwind.h"
 #include "Plugins/Process/Utility/RegisterContextHistory.h"
+#include <memory>
 
 #include "lldb/Target/Process.h"
 #include "lldb/Target/StackFrameList.h"

 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;
 }

   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;

lldb/source/Plugins/Process/Utility/HistoryUnwind.cpp

 #include "lldb/lldb-private.h"
 
 #include "Plugins/Process/Utility/HistoryUnwind.h"
+
 #include "Plugins/Process/Utility/RegisterContextHistory.h"
+#include <memory>
 
 #include "lldb/Target/Process.h"
 #include "lldb/Target/StackFrame.h"

     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;

lldb/source/Plugins/Process/Utility/RegisterContextDarwin_arm.cpp

 //===----------------------------------------------------------------------===//
 
 #include "RegisterContextDarwin_arm.h"
+
 #include "RegisterContextDarwinConstants.h"
+#include <memory>
 
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"

 
 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();

lldb/source/Plugins/Process/Utility/RegisterContextDarwin_arm64.cpp

 //===----------------------------------------------------------------------===//
 
 #include "RegisterContextDarwin_arm64.h"
+
 #include "RegisterContextDarwinConstants.h"
+#include <memory>
 
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Thread.h"

 
 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();

lldb/source/Plugins/Process/Utility/RegisterContextDarwin_i386.cpp

 
 #include <stddef.h>
 
+#include <memory>
+
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Endian.h"

 
 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();

lldb/source/Plugins/Process/Utility/RegisterContextDarwin_x86_64.cpp

 #include <stdarg.h>
 #include <stddef.h>
 
+#include <memory>
+
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Endian.h"

 
 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();

lldb/source/Plugins/Process/Utility/RegisterContextLLDB.cpp

 
 #include "RegisterContextLLDB.h"
 
+#include <memory>
+
 using namespace lldb;
 using namespace lldb_private;
 

 
     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
       {

   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(

          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;

     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

     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;

lldb/source/Plugins/Process/Utility/ThreadMemory.cpp

 //===----------------------------------------------------------------------===//
 
 #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;

 
 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;
 }
 

lldb/source/Plugins/Process/Utility/UnwindMacOSXFrameBackchain.cpp

 //
 //===----------------------------------------------------------------------===//
 
+#include <memory>
+
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/Symbol.h"

   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;
 }
 

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

 
 #include <stdlib.h>
 
+#include <memory>
 #include <mutex>
 
 #include "lldb/Core/Module.h"

       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);
       }
     }
   }

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

 
 #include "RegisterContextPOSIXCore_arm.h"
 
+#include <memory>
+
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/RegisterValue.h"
 

     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());
 }

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

 //===----------------------------------------------------------------------===//
 
 #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;
 

     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());
 }

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

 
 #include "RegisterContextPOSIXCore_mips64.h"
 
+#include <memory>
+
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/RegisterValue.h"
 

     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());
 }

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

 
 #include "RegisterContextPOSIXCore_powerpc.h"
 
+#include <memory>
+
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/RegisterValue.h"

     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());
 }

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

 
 #include "RegisterContextPOSIXCore_ppc64le.h"
 
+#include <memory>
+
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/RegisterValue.h"

     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());
 }

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

 
 #include "RegisterContextPOSIXCore_s390x.h"
 
+#include <memory>
+
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/RegisterValue.h"

     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());
 }

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

 #include "RegisterContextPOSIXCore_x86_64.h"
 #include "ThreadElfCore.h"
 
+#include <memory>
+
 using namespace lldb;
 using namespace lldb_private;
 

 
     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;

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

 
 #include "GDBRemoteRegisterContext.h"
 
+#include <memory>
+
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/DataBufferHeap.h"

       // 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 {
 

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

 #include <algorithm>
 #include <csignal>
 #include <map>
+#include <memory>
 #include <mutex>
 #include <sstream>
 

   }
 
   PluginProperties() : Properties() {
-    m_collection_sp.reset(new OptionValueProperties(GetSettingName()));
+    m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName());
     m_collection_sp->Initialize(g_properties);
   }
 

 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;
 }
 

                                  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;
 }
 

       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 {

 
       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 (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;
 }

 
 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();
 }

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

 
 #include "ThreadGDBRemote.h"
 
+#include <memory>
+
 #include "lldb/Breakpoint/Watchpoint.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"

       // 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();

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

 
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/Threading.h"
+#include <memory>
 #include <mutex>
 
 #include "lldb/Core/Debugger.h"

       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);
       }
     }
   }

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

 //===----------------------------------------------------------------------===//
 
 #include "ProcessMinidump.h"
+
 #include "ThreadMinidump.h"
+#include <memory>
 
 #include "lldb/Core/DumpDataExtractor.h"
 #include "lldb/Core/Module.h"

 
 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();
 }

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

 //===----------------------------------------------------------------------===//
 
 #include "ThreadMinidump.h"
+
 #include "ProcessMinidump.h"
+#include <memory>
 
 #include "RegisterContextMinidump_ARM.h"
 #include "RegisterContextMinidump_ARM64.h"

       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: {

       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:

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

 #include <stdio.h>
 #include <stdlib.h>
 
+#include <memory>
 #include <mutex>
 #include <string>
 

             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);

         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);

   }
 
   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;
 }

               ScriptInterpreter::eScriptReturnTypeOpaqueObject,
               &module_pyobj) &&
           module_pyobj)
-        module_sp->reset(new StructuredPythonObject(module_pyobj));
+        *module_sp = std::make_shared<StructuredPythonObject>(module_pyobj);
     }
 
     return true;

lldb/source/Plugins/StructuredData/DarwinLog/StructuredDataDarwinLog.cpp

 #include <string.h>
 
 // C++ includes
+#include <memory>
 #include <sstream>
 
 #include "lldb/Breakpoint/StoppointCallbackContext.h"

   }
 
   StructuredDataDarwinLogProperties() : Properties() {
-    m_collection_sp.reset(new OptionValueProperties(GetSettingName()));
+    m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName());
     m_collection_sp->Initialize(g_properties);
   }
 

 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;
 }
 

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

 #include "clang/AST/DeclTemplate.h"
 
 #include <map>
+#include <memory>
 #include <vector>
 
 //#define ENABLE_DEBUG_PRINTF // COMMENT OUT THIS LINE PRIOR TO CHECKIN

           }
         }
 
-        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;

         // 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);
 

           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()) {

             }
           }
         }
-        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;
 

                   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());

           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);
           }
         }
 

 
       if (dwarf->FixupAddress(func_range.GetBaseAddress())) {
         const user_id_t func_user_id = die.GetID();
-        func_sp.reset(new Function(&comp_unit,
-                                   func_user_id, // UserID is the DIE offset
-                                   func_user_id, func_name, func_type,
-                                   func_range)); // first address range
+        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
 
         if (func_sp.get() != NULL) {
           if (frame_base.IsValid())

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

 //#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"

       // 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
   }

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

 #include "llvm/Support/FileSystem.h"
 
 #include <map>
+#include <memory>
 
 #include <ctype.h>
 #include <string.h>

   }
 
   PluginProperties() {
-    m_collection_sp.reset(new OptionValueProperties(GetSettingName()));
+    m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName());
     m_collection_sp->Initialize(g_properties);
   }
 

                 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

       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;

               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 {

             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(

                 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);
                 }
               }

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

 
 #include "SymbolFileDWARFDebugMap.h"
 
+#include <memory>
+
 #include "DWARFDebugAranges.h"
 
 #include "lldb/Core/Module.h"

       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();

                              .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)

         // 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

lldb/source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.cpp

 //===----------------------------------------------------------------------===//
 
 #include "SymbolFileSymtab.h"
+
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Symbol/CompileUnit.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;

     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/source/Plugins/SystemRuntime/MacOSX/SystemRuntimeMacOSX.cpp

 
 #include "SystemRuntimeMacOSX.h"
 
+#include <memory>
+
 using namespace lldb;
 using namespace lldb_private;
 

           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(

       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);

   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());

lldb/source/Plugins/UnwindAssembly/x86/x86AssemblyInspectionEngine.cpp

 
 #include "x86AssemblyInspectionEngine.h"
 
+#include <memory>
+
 #include "llvm-c/Disassembler.h"
 
 #include "lldb/Core/Address.h"

       *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;

lldb/source/Symbol/Block.cpp

 //
 //===----------------------------------------------------------------------===//
 
+#include <memory>
+
 #include "lldb/Symbol/Block.h"
 
 #include "lldb/Core/Module.h"

 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) {

lldb/source/Symbol/ClangASTImporter.cpp

 //
 //===----------------------------------------------------------------------===//
 
+#include <memory>
+
 #include "lldb/Symbol/ClangASTImporter.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Symbol/ClangASTContext.h"

 
   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();

lldb/source/Symbol/CompactUnwindInfo.cpp

 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.h"
 #include <algorithm>
+#include <memory>
 
 #include "llvm/Support/MathExtras.h"
 

       // 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()),

lldb/source/Symbol/FuncUnwinders.cpp

 //
 //===----------------------------------------------------------------------===//
 
+#include <memory>
+
 #include "lldb/Symbol/FuncUnwinders.h"
 #include "lldb/Core/Address.h"
 #include "lldb/Core/AddressRange.h"

       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();
     }

       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();

       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();

   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.

   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

 
   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();

 
   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();

   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();
       }

   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();

lldb/source/Target/CPPLanguageRuntime.cpp

 
 #include <string.h>
 
+#include <memory>
+
 #include "llvm/ADT/StringRef.h"
 
 #include "lldb/Symbol/Block.h"

         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;
     }
   }

lldb/source/Target/Memory.cpp

 
 #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 <memory>
 
 using namespace lldb;
 using namespace lldb_private;

   }
 
   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/source/Target/Platform.cpp

 #include <algorithm>
 #include <csignal>
 #include <fstream>
+#include <memory>
 #include <vector>
 
 #include "llvm/Support/FileSystem.h"

 }
 
 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();

lldb/source/Target/Process.cpp

 //===----------------------------------------------------------------------===//
 
 #include <atomic>
+#include <memory>
 #include <mutex>
 
 #include "llvm/Support/ScopedPrinter.h"

 {
   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);

       // 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);
     }
   }
 }

     return threads;
   }
 
-  threads.reset(new ThreadCollection(memory_history->GetHistoryThreads(addr)));
+  threads = std::make_shared<ThreadCollection>(
+      memory_history->GetHistoryThreads(addr));
 
   return threads;
 }

lldb/source/Target/StackFrame.cpp

 //
 //===----------------------------------------------------------------------===//
 
+#include <memory>
+
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Disassembler.h"

       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; },

     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);

lldb/source/Target/StackFrameList.cpp

 //
 //===----------------------------------------------------------------------===//
 
+#include <memory>
+
 #include "lldb/Target/StackFrameList.h"
 #include "lldb/Breakpoint/Breakpoint.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"

             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 {

         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,

         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;

lldb/source/Target/Target.cpp

 #include "lldb/Utility/State.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/Timer.h"
+#include <memory>
 #include <mutex>
 
 using namespace lldb;

   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;

   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;

     // 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;
 }

   } 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 (!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);
   }

   }
 
   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();
   }
 

 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;
   }

 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

     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(

lldb/source/Target/Thread.cpp

 //
 //===----------------------------------------------------------------------===//
 
+#include <memory>
+
 #include "lldb/Target/Thread.h"
 #include "Plugins/Process/Utility/UnwindLLDB.h"
 #include "Plugins/Process/Utility/UnwindMacOSXFrameBackchain.h"

 
 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 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;

   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;

lldb/source/Target/ThreadPlanCallFunction.cpp

 //
 //===----------------------------------------------------------------------===//
 
+#include <memory>
+
 #include "lldb/Target/ThreadPlanCallFunction.h"
 #include "lldb/Breakpoint/Breakpoint.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"

   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);

lldb/source/Target/ThreadPlanStepOut.cpp

 //
 //===----------------------------------------------------------------------===//
 
+#include <memory>
+
 #include "lldb/Target/ThreadPlanStepOut.h"
 #include "lldb/Breakpoint/Breakpoint.h"
 #include "lldb/Core/Value.h"

     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);

             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());

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

 #include <dlfcn.h>
 
 #include <cinttypes>
+#include <memory>
 #include <mutex>
 #include <vector>
 

                                        "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");
 

         }
 
         // 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.

lldb/tools/debugserver/source/MacOSX/MachThreadList.cpp

 #include <inttypes.h>
 #include <sys/sysctl.h>
 
+#include <memory>
+
 #include "DNBLog.h"
 #include "DNBThreadResumeActions.h"
 #include "MachProcess.h"

           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

lldb/tools/debugserver/source/RNBRemote.cpp

 
 #include <TargetConditionals.h>
 #include <iomanip>
+#include <memory>
 #include <sstream>
 #include <unordered_set>
 

 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();
 

lldb/tools/debugserver/source/debugserver.cpp

 #include <crt_externs.h>
 #include <errno.h>
 #include <getopt.h>
+#include <memory>
 #include <netdb.h>
 #include <netinet/in.h>
 #include <netinet/tcp.h>

   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) {

lldb/tools/debugserver/source/libdebugserver.cpp

 #include <sys/sysctl.h>
 #include <sys/types.h>
 
+#include <memory>
+
 #include "DNB.h"
 #include "DNBLog.h"
 #include "DNBTimer.h"

 
   signal(SIGPIPE, signal_handler);
 
-  g_remoteSP.reset(new RNBRemote);
+  g_remoteSP = std::make_shared<RNBRemote>();
 
   RNBRemote *remote = g_remoteSP.get();
   if (remote == NULL) {

lldb/unittests/Editline/EditlineTest.cpp

       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() {

lldb/unittests/UnwindAssembly/x86/Testx86AssemblyInspectionEngine.cpp

 
 #include "gtest/gtest.h"
 
+#include <memory>
 #include <vector>
 
 #include "Plugins/UnwindAssembly/x86/x86AssemblyInspectionEngine.h"

   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);

   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);