[lldb] NFC remove DISALLOW_COPY_AND_ASSIGN

[kwk]

Summary

This is how I applied my clang-tidy check (see
https://reviews.llvm.org/D80531) in order to remove
DISALLOW_COPY_AND_ASSIGN and have deleted copy ctors and deleted
assignment operators instead.

grep DISALLOW_COPY_AND_ASSIGN /opt/notnfs/kkleine/llvm/lldb -r -l | sort | uniq > files

for i in $(cat files);
do
  clang-tidy \
    --checks="-*,modernize-replace-disallow-copy-and-assign-macro" \
    --format-style=LLVM \
    --header-filter=.* \
    --fix \
    -fix-errors \
    $i;
done

[kwk]

Sorry, wrong revisions uploaded

[kwk]

[lldb] Manual remove of DISALLOW_COPY_AND_ASSIGN def and one expansion

[labath]

I am all for this, because makes lldb code more consistent with llvm (llvm used to have a LLVM_DELETED_FUNCTION macro, but it was removed as soon as c++11 came into being).

But please don't commit this straight away -- let's wait a couple of days to give people a chance to comment on things.

[aprantl]

I am all for this, because makes lldb code more consistent with llvm (llvm used to have a LLVM_DELETED_FUNCTION macro, but it was removed as soon as c++11 came into being).

That argument makes sense to me.

[teemperor]

In D80543#2054405, @labath wrote:

I am all for this, because makes lldb code more consistent with llvm (llvm used to have a LLVM_DELETED_FUNCTION macro, but it was removed as soon as c++11 came into being).

But please don't commit this straight away -- let's wait a couple of days to give people a chance to comment on things.

Wasn't LLVM_DELETED_FUNCTION not just a compatibility thing with certain MSVC versions that didn't handle = delete correctly? DISALLOW_COPY_AND_ASSIGN seems to be more about preventing copy-pasted declarations.

I'm not sure if I see the motivation for this change, but I also don't really see a problem if we remove this to get rid of another LLDB_* macro. So IMHO this is change is fine.

[labath]

In D80543#2055448, @teemperor wrote:

In D80543#2054405, @labath wrote:

I am all for this, because makes lldb code more consistent with llvm (llvm used to have a LLVM_DELETED_FUNCTION macro, but it was removed as soon as c++11 came into being).

But please don't commit this straight away -- let's wait a couple of days to give people a chance to comment on things.

Wasn't LLVM_DELETED_FUNCTION not just a compatibility thing with certain MSVC versions that didn't handle = delete correctly?

Well, it was "compatibility" for the fact that MSVC did not support c++11, added back when c++11 was hot off the press. Before that llvm used /* DO NOT IMPLEMENT */ comments (that was way before my time, but that's what git history says).

DISALLOW_COPY_AND_ASSIGN seems to be more about preventing copy-pasted declarations.

Yes, that's kinda true. I was probably too harsh on it. I actually do see some appeal in that, but I don't think it's worth diverging from the llvm style because of it.

[kwk]

Rebased

lldb/examples/interposing/darwin/fd_interposing/FDInterposing.cpp

 #include <sys/mman.h>
 #include <sys/socket.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <tr1/memory>
 #include <unistd.h>
 #include <vector>
 
-/// \def DISALLOW_COPY_AND_ASSIGN(TypeName)
-///     Macro definition for easily disallowing copy constructor and
-///     assignment operators in C++ classes.
-#define DISALLOW_COPY_AND_ASSIGN(TypeName)                                     \
-  TypeName(const TypeName &);                                                  \
-  const TypeName &operator=(const TypeName &)
-
 extern "C" {
 int accept$NOCANCEL(int, struct sockaddr *__restrict, socklen_t *__restrict);
 int close$NOCANCEL(int);
 int open$NOCANCEL(const char *, int, ...);
 int __open_extended(const char *, int, uid_t, gid_t, int,
                     struct kauth_filesec *);
 }
 
if (m_str && log_fd >= 0) {
       }
     }
   }
 
 protected:
   char *m_str;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(String);
+  String(const String &) = delete;
+  const String &operator=(const String &) = delete;
 };
 
 // Type definitions
 typedef std::vector<void *> Frames;
 class FDEvent;
 typedef std::vector<void *> Frames;
 typedef std::tr1::shared_ptr<FDEvent> FDEventSP;
 typedef std::tr1::shared_ptr<String> StringSP;

lldb/include/lldb/API/SBCommunication.h

public:
   bool ReadThreadStop();
 
   bool ReadThreadIsRunning();
 
   bool SetReadThreadBytesReceivedCallback(ReadThreadBytesReceived callback,
                                           void *callback_baton);
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(SBCommunication);
+  SBCommunication(const SBCommunication &) = delete;
+  const SBCommunication &operator=(const SBCommunication &) = delete;
 
   lldb_private::Communication *m_opaque;
   bool m_opaque_owned;
 };
 
 } // namespace lldb
 
 #endif // LLDB_API_SBCOMMUNICATION_H

lldb/include/lldb/API/SBStream.h

protected:
 
   lldb_private::Stream *operator->();
 
   lldb_private::Stream *get();
 
   lldb_private::Stream &ref();
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(SBStream);
+  SBStream(const SBStream &) = delete;
+  const SBStream &operator=(const SBStream &) = delete;
   std::unique_ptr<lldb_private::Stream> m_opaque_up;
   bool m_is_file;
 };
 
 } // namespace lldb
 
 #endif // LLDB_API_SBSTREAM_H

lldb/include/lldb/Breakpoint/Breakpoint.h

public:
     static const BreakpointEventData *
     GetEventDataFromEvent(const Event *event_sp);
 
   private:
     lldb::BreakpointEventType m_breakpoint_event;
     lldb::BreakpointSP m_new_breakpoint_sp;
     BreakpointLocationCollection m_locations;
 
-    DISALLOW_COPY_AND_ASSIGN(BreakpointEventData);
+    BreakpointEventData(const BreakpointEventData &) = delete;
+    const BreakpointEventData &operator=(const BreakpointEventData &) = delete;
   };
 
   // Saving & restoring breakpoints:
   static lldb::BreakpointSP CreateFromStructuredData(
       lldb::TargetSP target_sp, StructuredData::ObjectSP &data_object_sp,
       Status &error);
 
   static bool
private:
   // separately from the locations hit counts, since locations can go away when
   // their backing library gets unloaded, and we would lose hit counts.
   BreakpointName::Permissions m_permissions;
 
   void SendBreakpointChangedEvent(lldb::BreakpointEventType eventKind);
 
   void SendBreakpointChangedEvent(BreakpointEventData *data);
 
-  DISALLOW_COPY_AND_ASSIGN(Breakpoint);
+  Breakpoint(const Breakpoint &) = delete;
+  const Breakpoint &operator=(const Breakpoint &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_BREAKPOINT_BREAKPOINT_H

lldb/include/lldb/Breakpoint/BreakpointIDList.h

static void FindAndReplaceIDRanges(Args &old_args, Target *target,
                                        ::PermissionKinds purpose,
                                      CommandReturnObject &result,
                                      Args &new_args);
 
 private:
   BreakpointIDArray m_breakpoint_ids;
   BreakpointID m_invalid_id;
 
-  DISALLOW_COPY_AND_ASSIGN(BreakpointIDList);
+  BreakpointIDList(const BreakpointIDList &) = delete;
+  const BreakpointIDList &operator=(const BreakpointIDList &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_BREAKPOINT_BREAKPOINTIDLIST_H

lldb/include/lldb/Breakpoint/BreakpointList.h

public:
   typedef LockingAdaptedIterable<bp_collection, lldb::BreakpointSP,
                                  list_adapter, std::recursive_mutex>
       BreakpointIterable;
   BreakpointIterable Breakpoints() {
     return BreakpointIterable(m_breakpoints, GetMutex());
   }
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(BreakpointList);
+  BreakpointList(const BreakpointList &) = delete;
+  const BreakpointList &operator=(const BreakpointList &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_BREAKPOINT_BREAKPOINTLIST_H

lldb/include/lldb/Breakpoint/BreakpointLocation.h

size_t m_condition_hash; ///< For testing whether the condition source code
                            ///changed.
 
   void SetShouldResolveIndirectFunctions(bool do_resolve) {
     m_should_resolve_indirect_functions = do_resolve;
   }
 
   void SendBreakpointLocationChangedEvent(lldb::BreakpointEventType eventKind);
 
-  DISALLOW_COPY_AND_ASSIGN(BreakpointLocation);
+  BreakpointLocation(const BreakpointLocation &) = delete;
+  const BreakpointLocation &operator=(const BreakpointLocation &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_BREAKPOINT_BREAKPOINTLOCATION_H

lldb/include/lldb/Breakpoint/BreakpointResolver.h

void AddLocation(SearchFilter &filter, const SymbolContext &sc,
                    bool skip_prologue, llvm::StringRef log_ident);
 
   lldb::BreakpointWP m_breakpoint; // This is the breakpoint we add locations to.
   lldb::addr_t m_offset;    // A random offset the user asked us to add to any
                             // breakpoints we set.
 
   // Subclass identifier (for llvm isa/dyn_cast)
   const unsigned char SubclassID;
-  DISALLOW_COPY_AND_ASSIGN(BreakpointResolver);
+  BreakpointResolver(const BreakpointResolver &) = delete;
+  const BreakpointResolver &operator=(const BreakpointResolver &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_BREAKPOINT_BREAKPOINTRESOLVER_H

lldb/include/lldb/Breakpoint/BreakpointResolverAddress.h

Address m_addr;               // The address - may be Section Offset or
                                 // may be just an offset
   lldb::addr_t m_resolved_addr; // The current value of the resolved load
                                 // address for this breakpoint,
   FileSpec m_module_filespec;   // If this filespec is Valid, and m_addr is an
                                 // offset, then it will be converted
   // to a Section+Offset address in this module, whenever that module gets
   // around to being loaded.
 private:
-  DISALLOW_COPY_AND_ASSIGN(BreakpointResolverAddress);
+  BreakpointResolverAddress(const BreakpointResolverAddress &) = delete;
+  const BreakpointResolverAddress &
+  operator=(const BreakpointResolverAddress &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_BREAKPOINT_BREAKPOINTRESOLVERADDRESS_H

lldb/include/lldb/Breakpoint/BreakpointResolverFileLine.h

protected:
   uint32_t m_line_number; ///< This is the line number that we are looking for.
   uint32_t m_column;      ///< This is the column that we are looking for.
   bool m_inlines; ///< This determines whether the resolver looks for inlined
                   ///< functions or not.
   bool m_skip_prologue;
   bool m_exact_match;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(BreakpointResolverFileLine);
+  BreakpointResolverFileLine(const BreakpointResolverFileLine &) = delete;
+  const BreakpointResolverFileLine &
+  operator=(const BreakpointResolverFileLine &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_BREAKPOINT_BREAKPOINTRESOLVERFILELINE_H

lldb/include/lldb/Breakpoint/BreakpointResolverFileRegex.h

RegularExpression
       m_regex;        // This is the line expression that we are looking for.
   bool m_exact_match; // If true, then if the source we match is in a comment,
                       // we won't set a location there.
   std::unordered_set<std::string> m_function_names; // Limit the search to
                                                     // functions in the
                                                     // comp_unit passed in.
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(BreakpointResolverFileRegex);
+  BreakpointResolverFileRegex(const BreakpointResolverFileRegex &) = delete;
+  const BreakpointResolverFileRegex &
+  operator=(const BreakpointResolverFileRegex &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_BREAKPOINT_BREAKPOINTRESOLVERFILEREGEX_H

lldb/include/lldb/Breakpoint/BreakpointResolverScripted.h

private:
   std::string m_class_name;
   lldb::SearchDepth m_depth;
   StructuredDataImpl *m_args_ptr; // We own this, but the implementation
                                   // has to manage the UP (since that is
                                   // how it gets stored in the
                                   // SBStructuredData).
   StructuredData::GenericSP m_implementation_sp;
 
-  DISALLOW_COPY_AND_ASSIGN(BreakpointResolverScripted);
+  BreakpointResolverScripted(const BreakpointResolverScripted &) = delete;
+  const BreakpointResolverScripted &
+  operator=(const BreakpointResolverScripted &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_BREAKPOINT_BREAKPOINTRESOLVERSCRIPTED_H

lldb/include/lldb/Breakpoint/BreakpointSite.h

private:
   static lldb::break_id_t GetNextID();
 
   // Only the Process can create breakpoint sites in
   // Process::CreateBreakpointSite (lldb::BreakpointLocationSP &, bool).
   BreakpointSite(BreakpointSiteList *list,
                  const lldb::BreakpointLocationSP &owner, lldb::addr_t m_addr,
                  bool use_hardware);
 
-  DISALLOW_COPY_AND_ASSIGN(BreakpointSite);
+  BreakpointSite(const BreakpointSite &) = delete;
+  const BreakpointSite &operator=(const BreakpointSite &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_BREAKPOINT_BREAKPOINTSITE_H

lldb/include/lldb/Breakpoint/Stoppoint.h

public:
 
   void SetID(lldb::break_id_t bid);
 
 protected:
   lldb::break_id_t m_bid;
 
 private:
   // For Stoppoint only
-  DISALLOW_COPY_AND_ASSIGN(Stoppoint);
+  Stoppoint(const Stoppoint &) = delete;
+  const Stoppoint &operator=(const Stoppoint &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_BREAKPOINT_STOPPOINT_H

lldb/include/lldb/Breakpoint/StoppointLocation.h

protected:
   // If you override this, be sure to call the base class to increment the
   // internal counter.
   void IncrementHitCount() { ++m_hit_count; }
 
   void DecrementHitCount();
 
 private:
   // For StoppointLocation only
-  DISALLOW_COPY_AND_ASSIGN(StoppointLocation);
+  StoppointLocation(const StoppointLocation &) = delete;
+  const StoppointLocation &operator=(const StoppointLocation &) = delete;
   StoppointLocation() = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_BREAKPOINT_STOPPOINTLOCATION_H

lldb/include/lldb/Breakpoint/Watchpoint.h

public:
 
     static const WatchpointEventData *
     GetEventDataFromEvent(const Event *event_sp);
 
   private:
     lldb::WatchpointEventType m_watchpoint_event;
     lldb::WatchpointSP m_new_watchpoint_sp;
 
-    DISALLOW_COPY_AND_ASSIGN(WatchpointEventData);
+    WatchpointEventData(const WatchpointEventData &) = delete;
+    const WatchpointEventData &operator=(const WatchpointEventData &) = delete;
   };
 
   Watchpoint(Target &target, lldb::addr_t addr, uint32_t size,
              const CompilerType *type, bool hardware = true);
 
   ~Watchpoint() override;
 
   void IncrementFalseAlarmsAndReviseHitCount();
private:
   std::unique_ptr<UserExpression> m_condition_up; // The condition to test.
 
   void SetID(lldb::watch_id_t id) { m_loc_id = id; }
 
   void SendWatchpointChangedEvent(lldb::WatchpointEventType eventKind);
 
   void SendWatchpointChangedEvent(WatchpointEventData *data);
 
-  DISALLOW_COPY_AND_ASSIGN(Watchpoint);
+  Watchpoint(const Watchpoint &) = delete;
+  const Watchpoint &operator=(const Watchpoint &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_BREAKPOINT_WATCHPOINT_H

lldb/include/lldb/Core/AddressResolver.h

public:
   size_t GetNumberOfAddresses();
 
   AddressRange &GetAddressRangeAtIndex(size_t idx);
 
 protected:
   std::vector<AddressRange> m_address_ranges;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(AddressResolver);
+  AddressResolver(const AddressResolver &) = delete;
+  const AddressResolver &operator=(const AddressResolver &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_CORE_ADDRESSRESOLVER_H

lldb/include/lldb/Core/AddressResolverFileLine.h

 
 protected:
   FileSpec m_file_spec;   // This is the file spec we are looking for.
   uint32_t m_line_number; // This is the line number that we are looking for.
   bool m_inlines; // This determines whether the resolver looks for inlined
                   // functions or not.
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(AddressResolverFileLine);
+  AddressResolverFileLine(const AddressResolverFileLine &) = delete;
+  const AddressResolverFileLine &
+  operator=(const AddressResolverFileLine &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_CORE_ADDRESSRESOLVERFILELINE_H

lldb/include/lldb/Core/AddressResolverName.h

 protected:
   ConstString m_func_name;
   ConstString m_class_name; // FIXME: Not used yet.  The idea would be to stop
                             // on methods of this class.
   RegularExpression m_regex;
   AddressResolver::MatchType m_match_type;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(AddressResolverName);
+  AddressResolverName(const AddressResolverName &) = delete;
+  const AddressResolverName &operator=(const AddressResolverName &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_CORE_ADDRESSRESOLVERNAME_H

lldb/include/lldb/Core/Communication.h

protected:
   ///     and also the max number of bytes that can be placed into
   ///     \a dst.
   ///
   /// \return
   ///     The number of bytes extracted from the data cache.
   size_t GetCachedBytes(void *dst, size_t dst_len);
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(Communication);
+  Communication(const Communication &) = delete;
+  const Communication &operator=(const Communication &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_CORE_COMMUNICATION_H

lldb/include/lldb/Core/Debugger.h

enum {
     eBroadcastBitEventThreadIsListening = (1 << 0),
   };
 
 private:
   // Use Debugger::CreateInstance() to get a shared pointer to a new debugger
   // object
   Debugger(lldb::LogOutputCallback m_log_callback, void *baton);
 
-  DISALLOW_COPY_AND_ASSIGN(Debugger);
+  Debugger(const Debugger &) = delete;
+  const Debugger &operator=(const Debugger &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_CORE_DEBUGGER_H

lldb/include/lldb/Core/Disassembler.h

public:
 
   void SetOpcode(size_t opcode_size, void *opcode_data);
 
   void SetDescription(llvm::StringRef description) override;
 
 protected:
   std::string m_description;
 
-  DISALLOW_COPY_AND_ASSIGN(PseudoInstruction);
+  PseudoInstruction(const PseudoInstruction &) = delete;
+  const PseudoInstruction &operator=(const PseudoInstruction &) = delete;
 };
 
 class Disassembler : public std::enable_shared_from_this<Disassembler>,
                      public PluginInterface {
 public:
   enum {
     eOptionNone = 0u,
     eOptionShowBytes = (1u << 0),
protected:
   // Classes that inherit from Disassembler can see and modify these
   ArchSpec m_arch;
   InstructionList m_instruction_list;
   lldb::addr_t m_base_addr;
   std::string m_flavor;
 
 private:
   // For Disassembler only
-  DISALLOW_COPY_AND_ASSIGN(Disassembler);
+  Disassembler(const Disassembler &) = delete;
+  const Disassembler &operator=(const Disassembler &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_CORE_DISASSEMBLER_H

lldb/include/lldb/Core/EmulateInstruction.h

protected:
   WriteMemoryCallback m_write_mem_callback = &WriteMemoryDefault;
   ReadRegisterCallback m_read_reg_callback = &ReadRegisterDefault;
   WriteRegisterCallback m_write_reg_callback = &WriteRegisterDefault;
   lldb::addr_t m_addr = LLDB_INVALID_ADDRESS;
   Opcode m_opcode;
 
 private:
   // For EmulateInstruction only
-  DISALLOW_COPY_AND_ASSIGN(EmulateInstruction);
+  EmulateInstruction(const EmulateInstruction &) = delete;
+  const EmulateInstruction &operator=(const EmulateInstruction &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_CORE_EMULATEINSTRUCTION_H

lldb/include/lldb/Core/FileLineResolver.h

 protected:
   FileSpec m_file_spec;   // This is the file spec we are looking for.
   uint32_t m_line_number; // This is the line number that we are looking for.
   SymbolContextList m_sc_list;
   bool m_inlines; // This determines whether the resolver looks for inlined
                   // functions or not.
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(FileLineResolver);
+  FileLineResolver(const FileLineResolver &) = delete;
+  const FileLineResolver &operator=(const FileLineResolver &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_CORE_FILELINERESOLVER_H

lldb/include/lldb/Core/Highlighter.h

struct HighlightStyle {
   static HighlightStyle MakeVimStyle();
 };
 
 /// Annotates source code with color attributes.
 class Highlighter {
 public:
   Highlighter() = default;
   virtual ~Highlighter() = default;
-  DISALLOW_COPY_AND_ASSIGN(Highlighter);
+  Highlighter(const Highlighter &) = delete;
+  const Highlighter &operator=(const Highlighter &) = delete;
 
   /// Returns a human readable name for the selected highlighter.
   virtual llvm::StringRef GetName() const = 0;
 
   /// Highlights the given line
   /// \param options
   ///     The highlight options.
   /// \param line

lldb/include/lldb/Core/IOHandler.h

protected:
   Predicate<bool> m_popped;
   Flags m_flags;
   Type m_type;
   void *m_user_data;
   bool m_done;
   bool m_active;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(IOHandler);
+  IOHandler(const IOHandler &) = delete;
+  const IOHandler &operator=(const IOHandler &) = delete;
 };
 
 /// A delegate class for use with IOHandler subclasses.
 ///
 /// The IOHandler delegate is designed to be mixed into classes so
 /// they can use an IOHandler subclass to fetch input and notify the
 /// object that inherits from this delegate class when a token is
 /// received.

 
 protected:
   typedef std::vector<lldb::IOHandlerSP> collection;
   collection m_stack;
   mutable std::recursive_mutex m_mutex;
   IOHandler *m_top = nullptr;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(IOHandlerStack);
+  IOHandlerStack(const IOHandlerStack &) = delete;
+  const IOHandlerStack &operator=(const IOHandlerStack &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_CORE_IOHANDLER_H

lldb/include/lldb/Core/Module.h

private:
   Module(); // Only used internally by CreateJITModule ()
 
   void FindTypes_Impl(
       ConstString name, const CompilerDeclContext &parent_decl_ctx,
       size_t max_matches,
       llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
       TypeMap &types);
 
-  DISALLOW_COPY_AND_ASSIGN(Module);
+  Module(const Module &) = delete;
+  const Module &operator=(const Module &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_CORE_MODULE_H

lldb/include/lldb/Core/Section.h

bool m_fake : 1, // If true, then this section only can contain the address if
       m_readable : 1,          // If this section has read permissions
       m_writable : 1,          // If this section has write permissions
       m_executable : 1,        // If this section has executable permissions
       m_relocated : 1;         // If this section has had relocations applied
   uint32_t m_target_byte_size; // Some architectures have non-8-bit byte size.
                                // This is specified as
                                // as a multiple number of a host bytes
 private:
-  DISALLOW_COPY_AND_ASSIGN(Section);
+  Section(const Section &) = delete;
+  const Section &operator=(const Section &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_CORE_SECTION_H

lldb/include/lldb/Core/SourceManager.h

protected:
   FileSpec m_last_file_spec;
   uint32_t m_last_line;
   uint32_t m_last_count;
   bool m_default_set;
   lldb::TargetWP m_target_wp;
   lldb::DebuggerWP m_debugger_wp;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(SourceManager);
+  SourceManager(const SourceManager &) = delete;
+  const SourceManager &operator=(const SourceManager &) = delete;
 };
 
 bool operator==(const SourceManager::File &lhs, const SourceManager::File &rhs);
 
 } // namespace lldb_private
 
 #endif // LLDB_CORE_SOURCEMANAGER_H

lldb/include/lldb/Core/StreamFile.h

public:
   void Flush() override;
 
 protected:
   // Classes that inherit from StreamFile can see and modify these
   std::shared_ptr<File> m_file_sp; // never NULL
   size_t WriteImpl(const void *s, size_t length) override;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(StreamFile);
+  StreamFile(const StreamFile &) = delete;
+  const StreamFile &operator=(const StreamFile &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_CORE_STREAMFILE_H

lldb/include/lldb/Core/ThreadSafeValue.h

public:
 
   std::recursive_mutex &GetMutex() { return m_mutex; }
 
 private:
   T m_value;
   mutable std::recursive_mutex m_mutex;
 
   // For ThreadSafeValue only
-  DISALLOW_COPY_AND_ASSIGN(ThreadSafeValue);
+  ThreadSafeValue(const ThreadSafeValue &) = delete;
+  const ThreadSafeValue &operator=(const ThreadSafeValue &) = delete;
 };
 
 } // namespace lldb_private
 #endif // LLDB_CORE_THREADSAFEVALUE_H

lldb/include/lldb/Core/ValueObject.h

private:
 
   lldb::ValueObjectSP GetValueForExpressionPath_Impl(
       llvm::StringRef expression_cstr,
       ExpressionPathScanEndReason *reason_to_stop,
       ExpressionPathEndResultType *final_value_type,
       const GetValueForExpressionPathOptions &options,
       ExpressionPathAftermath *final_task_on_target);
 
-  DISALLOW_COPY_AND_ASSIGN(ValueObject);
+  ValueObject(const ValueObject &) = delete;
+  const ValueObject &operator=(const ValueObject &) = delete;
 };
 
 // A value object manager class that is seeded with the static variable value
 // and it vends the user facing value object. If the type is dynamic it can
 // vend the dynamic type. If this user type also has a synthetic type
 // associated with it, it will vend the synthetic type. The class watches the
 // process' stop
 // ID and will update the user type when needed.

lldb/include/lldb/Core/ValueObjectCast.h

protected:
 
   bool UpdateValue() override;
 
   CompilerType GetCompilerTypeImpl() override;
 
   CompilerType m_cast_type;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(ValueObjectCast);
+  ValueObjectCast(const ValueObjectCast &) = delete;
+  const ValueObjectCast &operator=(const ValueObjectCast &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_CORE_VALUEOBJECTCAST_H

lldb/include/lldb/Core/ValueObjectChild.h

protected:
   ValueObjectChild(ValueObject &parent, const CompilerType &compiler_type,
                    ConstString name, uint64_t byte_size,
                    int32_t byte_offset, uint32_t bitfield_bit_size,
                    uint32_t bitfield_bit_offset, bool is_base_class,
                    bool is_deref_of_parent,
                    AddressType child_ptr_or_ref_addr_type,
                    uint64_t language_flags);
 
-  DISALLOW_COPY_AND_ASSIGN(ValueObjectChild);
+  ValueObjectChild(const ValueObjectChild &) = delete;
+  const ValueObjectChild &operator=(const ValueObjectChild &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_CORE_VALUEOBJECTCHILD_H

lldb/include/lldb/Core/ValueObjectConstResult.h

private:
 
   ValueObjectConstResult(ExecutionContextScope *exe_scope,
                          ValueObjectManager &manager, const Value &value,
                          ConstString name, Module *module = nullptr);
 
   ValueObjectConstResult(ExecutionContextScope *exe_scope,
                          ValueObjectManager &manager, const Status &error);
 
-  DISALLOW_COPY_AND_ASSIGN(ValueObjectConstResult);
+  ValueObjectConstResult(const ValueObjectConstResult &) = delete;
+  const ValueObjectConstResult &
+  operator=(const ValueObjectConstResult &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_CORE_VALUEOBJECTCONSTRESULT_H

lldb/include/lldb/Core/ValueObjectConstResultCast.h

 protected:
   ValueObjectConstResultImpl m_impl;
 
 private:
   friend class ValueObject;
   friend class ValueObjectConstResult;
   friend class ValueObjectConstResultImpl;
 
-  DISALLOW_COPY_AND_ASSIGN(ValueObjectConstResultCast);
+  ValueObjectConstResultCast(const ValueObjectConstResultCast &) = delete;
+  const ValueObjectConstResultCast &
+  operator=(const ValueObjectConstResultCast &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_CORE_VALUEOBJECTCONSTRESULTCAST_H

lldb/include/lldb/Core/ValueObjectConstResultChild.h

 protected:
   ValueObjectConstResultImpl m_impl;
 
 private:
   friend class ValueObject;
   friend class ValueObjectConstResult;
   friend class ValueObjectConstResultImpl;
 
-  DISALLOW_COPY_AND_ASSIGN(ValueObjectConstResultChild);
+  ValueObjectConstResultChild(const ValueObjectConstResultChild &) = delete;
+  const ValueObjectConstResultChild &
+  operator=(const ValueObjectConstResultChild &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_CORE_VALUEOBJECTCONSTRESULTCHILD_H

lldb/include/lldb/Core/ValueObjectConstResultImpl.h

 
 private:
   ValueObject *m_impl_backend;
   lldb::addr_t m_live_address;
   AddressType m_live_address_type;
   lldb::ValueObjectSP m_load_addr_backend;
   lldb::ValueObjectSP m_address_of_backend;
 
-  DISALLOW_COPY_AND_ASSIGN(ValueObjectConstResultImpl);
+  ValueObjectConstResultImpl(const ValueObjectConstResultImpl &) = delete;
+  const ValueObjectConstResultImpl &
+  operator=(const ValueObjectConstResultImpl &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_CORE_VALUEOBJECTCONSTRESULTIMPL_H

lldb/include/lldb/Core/ValueObjectDynamicValue.h

protected:
   TypeImpl m_type_impl;
 
 private:
   friend class ValueObject;
   friend class ValueObjectConstResult;
   ValueObjectDynamicValue(ValueObject &parent,
                           lldb::DynamicValueType use_dynamic);
 
-  DISALLOW_COPY_AND_ASSIGN(ValueObjectDynamicValue);
+  ValueObjectDynamicValue(const ValueObjectDynamicValue &) = delete;
+  const ValueObjectDynamicValue &
+  operator=(const ValueObjectDynamicValue &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_CORE_VALUEOBJECTDYNAMICVALUE_H

lldb/include/lldb/Core/ValueObjectMemory.h

private:
   ValueObjectMemory(ExecutionContextScope *exe_scope,
                     ValueObjectManager &manager, llvm::StringRef name,
                     const Address &address, lldb::TypeSP &type_sp);
 
   ValueObjectMemory(ExecutionContextScope *exe_scope,
                     ValueObjectManager &manager, llvm::StringRef name,
                     const Address &address, const CompilerType &ast_type);
   // For ValueObject only
-  DISALLOW_COPY_AND_ASSIGN(ValueObjectMemory);
+  ValueObjectMemory(const ValueObjectMemory &) = delete;
+  const ValueObjectMemory &operator=(const ValueObjectMemory &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_CORE_VALUEOBJECTMEMORY_H

lldb/include/lldb/Core/ValueObjectRegister.h

 private:
   friend class ValueObjectRegisterContext;
 
   ValueObjectRegisterSet(ExecutionContextScope *exe_scope,
                          ValueObjectManager &manager,
                          lldb::RegisterContextSP &reg_ctx_sp, uint32_t set_idx);
 
   // For ValueObject only
-  DISALLOW_COPY_AND_ASSIGN(ValueObjectRegisterSet);
+  ValueObjectRegisterSet(const ValueObjectRegisterSet &) = delete;
+  const ValueObjectRegisterSet &
+  operator=(const ValueObjectRegisterSet &) = delete;
 };
 
 class ValueObjectRegister : public ValueObject {
 public:
   ~ValueObjectRegister() override;
 
   static lldb::ValueObjectSP Create(ExecutionContextScope *exe_scope,
                                     lldb::RegisterContextSP &reg_ctx_sp,
private:
 
   ValueObjectRegister(ValueObject &parent, lldb::RegisterContextSP &reg_ctx_sp,
                       uint32_t reg_num);
   ValueObjectRegister(ExecutionContextScope *exe_scope,
                       ValueObjectManager &manager,
                       lldb::RegisterContextSP &reg_ctx_sp, uint32_t reg_num);
 
   // For ValueObject only
-  DISALLOW_COPY_AND_ASSIGN(ValueObjectRegister);
+  ValueObjectRegister(const ValueObjectRegister &) = delete;
+  const ValueObjectRegister &operator=(const ValueObjectRegister &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_CORE_VALUEOBJECTREGISTER_H

lldb/include/lldb/Core/ValueObjectSyntheticFilter.h

protected:
   LazyBool m_provides_value;
 
 private:
   friend class ValueObject;
   ValueObjectSynthetic(ValueObject &parent, lldb::SyntheticChildrenSP filter);
 
   void CopyValueData(ValueObject *source);
 
-  DISALLOW_COPY_AND_ASSIGN(ValueObjectSynthetic);
+  ValueObjectSynthetic(const ValueObjectSynthetic &) = delete;
+  const ValueObjectSynthetic &operator=(const ValueObjectSynthetic &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_CORE_VALUEOBJECTSYNTHETICFILTER_H

lldb/include/lldb/Core/ValueObjectVariable.h

protected:
   Value m_resolved_value; ///< The value that DWARFExpression resolves this
                           ///variable to before we patch it up
 
 private:
   ValueObjectVariable(ExecutionContextScope *exe_scope,
                       ValueObjectManager &manager,
                       const lldb::VariableSP &var_sp);
   // For ValueObject only
-  DISALLOW_COPY_AND_ASSIGN(ValueObjectVariable);
+  ValueObjectVariable(const ValueObjectVariable &) = delete;
+  const ValueObjectVariable &operator=(const ValueObjectVariable &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_CORE_VALUEOBJECTVARIABLE_H

lldb/include/lldb/DataFormatters/FormatClasses.h

private:
   // TODO: Replace this with TypeAndOrName.
   struct TypeOrName {
     std::string m_type_name;
     CompilerType m_compiler_type;
   };
   TypeOrName m_type;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(TypeNameSpecifierImpl);
+  TypeNameSpecifierImpl(const TypeNameSpecifierImpl &) = delete;
+  const TypeNameSpecifierImpl &
+  operator=(const TypeNameSpecifierImpl &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_DATAFORMATTERS_FORMATCLASSES_H

lldb/include/lldb/DataFormatters/FormattersContainer.h

public:
   void ForEach(ForEachCallback callback) { m_format_map.ForEach(callback); }
 
   uint32_t GetCount() { return m_format_map.GetCount(); }
 
 protected:
   BackEndType m_format_map;
   std::string m_name;
 
-  DISALLOW_COPY_AND_ASSIGN(FormattersContainer);
+  FormattersContainer(const FormattersContainer &) = delete;
+  const FormattersContainer &operator=(const FormattersContainer &) = delete;
 
   void Add_Impl(MapKeyType type, const MapValueType &entry,
                 RegularExpression *dummy) {
     m_format_map.Add(std::move(type), entry);
   }
 
   void Add_Impl(ConstString type, const MapValueType &entry,
                 ConstString *dummy) {

lldb/include/lldb/DataFormatters/TypeFormat.h

public:
 
   virtual std::string GetDescription() = 0;
 
 protected:
   Flags m_flags;
   uint32_t m_my_revision;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(TypeFormatImpl);
+  TypeFormatImpl(const TypeFormatImpl &) = delete;
+  const TypeFormatImpl &operator=(const TypeFormatImpl &) = delete;
 };
 
 class TypeFormatImpl_Format : public TypeFormatImpl {
 public:
   TypeFormatImpl_Format(lldb::Format f = lldb::eFormatInvalid,
                         const TypeFormatImpl::Flags &flags = Flags());
 
   typedef std::shared_ptr<TypeFormatImpl_Format> SharedPointer;
public:
   bool FormatObject(ValueObject *valobj, std::string &dest) const override;
 
   std::string GetDescription() override;
 
 protected:
   lldb::Format m_format;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(TypeFormatImpl_Format);
+  TypeFormatImpl_Format(const TypeFormatImpl_Format &) = delete;
+  const TypeFormatImpl_Format &
+  operator=(const TypeFormatImpl_Format &) = delete;
 };
 
 class TypeFormatImpl_EnumType : public TypeFormatImpl {
 public:
   TypeFormatImpl_EnumType(ConstString type_name = ConstString(""),
                           const TypeFormatImpl::Flags &flags = Flags());
 
   typedef std::shared_ptr<TypeFormatImpl_EnumType> SharedPointer;
public:
 
   std::string GetDescription() override;
 
 protected:
   ConstString m_enum_type;
   mutable std::unordered_map<void *, CompilerType> m_types;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(TypeFormatImpl_EnumType);
+  TypeFormatImpl_EnumType(const TypeFormatImpl_EnumType &) = delete;
+  const TypeFormatImpl_EnumType &
+  operator=(const TypeFormatImpl_EnumType &) = delete;
 };
 } // namespace lldb_private
 
 #endif // LLDB_DATAFORMATTERS_TYPEFORMAT_H

lldb/include/lldb/DataFormatters/TypeSummary.h

 protected:
   uint32_t m_my_revision;
   Flags m_flags;
 
   TypeSummaryImpl(Kind kind, const TypeSummaryImpl::Flags &flags);
 
 private:
   Kind m_kind;
-  DISALLOW_COPY_AND_ASSIGN(TypeSummaryImpl);
+  TypeSummaryImpl(const TypeSummaryImpl &) = delete;
+  const TypeSummaryImpl &operator=(const TypeSummaryImpl &) = delete;
 };
 
 // simple string-based summaries, using ${var to show data
 struct StringSummaryFormat : public TypeSummaryImpl {
   std::string m_format_str;
   FormatEntity::Entry m_format;
   Status m_error;
 
struct StringSummaryFormat : public TypeSummaryImpl {
 
   std::string GetDescription() override;
 
   static bool classof(const TypeSummaryImpl *S) {
     return S->GetKind() == Kind::eSummaryString;
   }
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(StringSummaryFormat);
+  StringSummaryFormat(const StringSummaryFormat &) = delete;
+  const StringSummaryFormat &operator=(const StringSummaryFormat &) = delete;
 };
 
 // summaries implemented via a C++ function
 struct CXXFunctionSummaryFormat : public TypeSummaryImpl {
   // we should convert these to SBValue and SBStream if we ever cross the
   // boundary towards the external world
   typedef std::function<bool(ValueObject &, Stream &,
                              const TypeSummaryOptions &)>
struct CXXFunctionSummaryFormat : public TypeSummaryImpl {
 
   static bool classof(const TypeSummaryImpl *S) {
     return S->GetKind() == Kind::eCallback;
   }
 
   typedef std::shared_ptr<CXXFunctionSummaryFormat> SharedPointer;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(CXXFunctionSummaryFormat);
+  CXXFunctionSummaryFormat(const CXXFunctionSummaryFormat &) = delete;
+  const CXXFunctionSummaryFormat &
+  operator=(const CXXFunctionSummaryFormat &) = delete;
 };
 
 // Python-based summaries, running script code to show data
 struct ScriptSummaryFormat : public TypeSummaryImpl {
   std::string m_function_name;
   std::string m_python_script;
   StructuredData::ObjectSP m_script_function_sp;
 
struct ScriptSummaryFormat : public TypeSummaryImpl {
 
   static bool classof(const TypeSummaryImpl *S) {
     return S->GetKind() == Kind::eScript;
   }
 
   typedef std::shared_ptr<ScriptSummaryFormat> SharedPointer;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(ScriptSummaryFormat);
+  ScriptSummaryFormat(const ScriptSummaryFormat &) = delete;
+  const ScriptSummaryFormat &operator=(const ScriptSummaryFormat &) = delete;
 };
 } // namespace lldb_private
 
 #endif // LLDB_DATAFORMATTERS_TYPESUMMARY_H

lldb/include/lldb/DataFormatters/TypeSynthetic.h

protected:
 
   lldb::ValueObjectSP CreateValueObjectFromData(llvm::StringRef name,
                                                 const DataExtractor &data,
                                                 const ExecutionContext &exe_ctx,
                                                 CompilerType type);
 
 private:
   bool m_valid;
-  DISALLOW_COPY_AND_ASSIGN(SyntheticChildrenFrontEnd);
+  SyntheticChildrenFrontEnd(const SyntheticChildrenFrontEnd &) = delete;
+  const SyntheticChildrenFrontEnd &
+  operator=(const SyntheticChildrenFrontEnd &) = delete;
 };
 
 class SyntheticValueProviderFrontEnd : public SyntheticChildrenFrontEnd {
 public:
   SyntheticValueProviderFrontEnd(ValueObject &backend)
       : SyntheticChildrenFrontEnd(backend) {}
 
   ~SyntheticValueProviderFrontEnd() override = default;
 
   size_t CalculateNumChildren() override { return 0; }
 
   lldb::ValueObjectSP GetChildAtIndex(size_t idx) override { return nullptr; }
 
   size_t GetIndexOfChildWithName(ConstString name) override {
     return UINT32_MAX;
   }
 
   bool Update() override { return false; }
 
   bool MightHaveChildren() override { return false; }
 
   lldb::ValueObjectSP GetSyntheticValue() override = 0;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(SyntheticValueProviderFrontEnd);
+  SyntheticValueProviderFrontEnd(const SyntheticValueProviderFrontEnd &) =
+      delete;
+  const SyntheticValueProviderFrontEnd &
+  operator=(const SyntheticValueProviderFrontEnd &) = delete;
 };
 
 class SyntheticChildren {
 public:
   class Flags {
   public:
     Flags() : m_flags(lldb::eTypeOptionCascade) {}
 
public:
 
   uint32_t &GetRevision() { return m_my_revision; }
 
 protected:
   uint32_t m_my_revision;
   Flags m_flags;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(SyntheticChildren);
+  SyntheticChildren(const SyntheticChildren &) = delete;
+  const SyntheticChildren &operator=(const SyntheticChildren &) = delete;
 };
 
 class TypeFilterImpl : public SyntheticChildren {
   std::vector<std::string> m_expression_paths;
 
 public:
   TypeFilterImpl(const SyntheticChildren::Flags &flags)
       : SyntheticChildren(flags), m_expression_paths() {}
public:
 
     size_t GetIndexOfChildWithName(ConstString name) override;
 
     typedef std::shared_ptr<SyntheticChildrenFrontEnd> SharedPointer;
 
   private:
     TypeFilterImpl *filter;
 
-    DISALLOW_COPY_AND_ASSIGN(FrontEnd);
+    FrontEnd(const FrontEnd &) = delete;
+    const FrontEnd &operator=(const FrontEnd &) = delete;
   };
 
   SyntheticChildrenFrontEnd::AutoPointer
   GetFrontEnd(ValueObject &backend) override {
     return SyntheticChildrenFrontEnd::AutoPointer(new FrontEnd(this, backend));
   }
 
   typedef std::shared_ptr<TypeFilterImpl> SharedPointer;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(TypeFilterImpl);
+  TypeFilterImpl(const TypeFilterImpl &) = delete;
+  const TypeFilterImpl &operator=(const TypeFilterImpl &) = delete;
 };
 
 class CXXSyntheticChildren : public SyntheticChildren {
 public:
   typedef std::function<SyntheticChildrenFrontEnd *(CXXSyntheticChildren *,
                                                     lldb::ValueObjectSP)>
       CreateFrontEndCallback;
   CXXSyntheticChildren(const SyntheticChildren::Flags &flags,
return SyntheticChildrenFrontEnd::AutoPointer(
         m_create_callback(this, backend.GetSP()));
   }
 
 protected:
   CreateFrontEndCallback m_create_callback;
   std::string m_description;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(CXXSyntheticChildren);
+  CXXSyntheticChildren(const CXXSyntheticChildren &) = delete;
+  const CXXSyntheticChildren &operator=(const CXXSyntheticChildren &) = delete;
 };
 
 class ScriptedSyntheticChildren : public SyntheticChildren {
   std::string m_python_class;
   std::string m_python_code;
 
 public:
   ScriptedSyntheticChildren(const SyntheticChildren::Flags &flags,
public:
 
     typedef std::shared_ptr<SyntheticChildrenFrontEnd> SharedPointer;
 
   private:
     std::string m_python_class;
     StructuredData::ObjectSP m_wrapper_sp;
     ScriptInterpreter *m_interpreter;
 
-    DISALLOW_COPY_AND_ASSIGN(FrontEnd);
+    FrontEnd(const FrontEnd &) = delete;
+    const FrontEnd &operator=(const FrontEnd &) = delete;
   };
 
   SyntheticChildrenFrontEnd::AutoPointer
   GetFrontEnd(ValueObject &backend) override {
     auto synth_ptr = SyntheticChildrenFrontEnd::AutoPointer(
         new FrontEnd(m_python_class, backend));
     if (synth_ptr && ((FrontEnd *)synth_ptr.get())->IsValid())
       return synth_ptr;
     return nullptr;
   }
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(ScriptedSyntheticChildren);
+  ScriptedSyntheticChildren(const ScriptedSyntheticChildren &) = delete;
+  const ScriptedSyntheticChildren &
+  operator=(const ScriptedSyntheticChildren &) = delete;
 };
 } // namespace lldb_private
 
 #endif // LLDB_DATAFORMATTERS_TYPESYNTHETIC_H

lldb/include/lldb/DataFormatters/ValueObjectPrinter.h

private:
   std::pair<TypeSummaryImpl *, bool> m_summary_formatter;
   std::string m_value;
   std::string m_summary;
   std::string m_error;
   bool m_val_summary_ok;
 
   friend struct StringSummaryFormat;
 
-  DISALLOW_COPY_AND_ASSIGN(ValueObjectPrinter);
+  ValueObjectPrinter(const ValueObjectPrinter &) = delete;
+  const ValueObjectPrinter &operator=(const ValueObjectPrinter &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_DATAFORMATTERS_VALUEOBJECTPRINTER_H

lldb/include/lldb/Expression/IRMemoryMap.h

uint8_t m_permissions; ///< The access permissions on the memory in the
                            /// read/write.
     uint8_t m_alignment;   ///< The alignment of the requested allocation.
 
   public:
     Allocation(lldb::addr_t process_alloc, lldb::addr_t process_start,
                size_t size, uint32_t permissions, uint8_t alignment,
                AllocationPolicy m_policy);
 
-    DISALLOW_COPY_AND_ASSIGN(Allocation);
+    Allocation(const Allocation &) = delete;
+    const Allocation &operator=(const Allocation &) = delete;
   };
 
   static_assert(sizeof(Allocation) <=
                     (4 * sizeof(lldb::addr_t)) + sizeof(DataBufferHeap),
                 "IRMemoryMap::Allocation is larger than expected");
 
   lldb::ProcessWP m_process_wp;
   lldb::TargetWP m_target_wp;

lldb/include/lldb/Host/File.h

 protected:
   LazyBool m_is_interactive;
   LazyBool m_is_real_terminal;
   LazyBool m_supports_colors;
 
   void CalculateInteractiveAndTerminal();
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(File);
+  File(const File &) = delete;
+  const File &operator=(const File &) = delete;
 };
 
 class NativeFile : public File {
 public:
   NativeFile()
       : m_descriptor(kInvalidDescriptor), m_own_descriptor(false),
         m_stream(kInvalidStream), m_options(), m_own_stream(false) {}
 
protected:
   int m_descriptor;
   bool m_own_descriptor;
   FILE *m_stream;
   OpenOptions m_options;
   bool m_own_stream;
   std::mutex offset_access_mutex;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(NativeFile);
+  NativeFile(const NativeFile &) = delete;
+  const NativeFile &operator=(const NativeFile &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_HOST_FILE_H

lldb/include/lldb/Host/HostNativeProcessBase.h

 #include "lldb/lldb-defines.h"
 #include "lldb/lldb-types.h"
 
 namespace lldb_private {
 
 class HostThread;
 
 class HostNativeProcessBase {
-  DISALLOW_COPY_AND_ASSIGN(HostNativeProcessBase);
+  HostNativeProcessBase(const HostNativeProcessBase &) = delete;
+  const HostNativeProcessBase &
+  operator=(const HostNativeProcessBase &) = delete;
 
 public:
   HostNativeProcessBase() : m_process(LLDB_INVALID_PROCESS) {}
   explicit HostNativeProcessBase(lldb::process_t process)
       : m_process(process) {}
   virtual ~HostNativeProcessBase() {}
 
   virtual Status Terminate() = 0;

lldb/include/lldb/Host/HostNativeThreadBase.h

 #if defined(_WIN32)
 #define THREAD_ROUTINE __stdcall
 #else
 #define THREAD_ROUTINE
 #endif
 
 class HostNativeThreadBase {
   friend class ThreadLauncher;
-  DISALLOW_COPY_AND_ASSIGN(HostNativeThreadBase);
+  HostNativeThreadBase(const HostNativeThreadBase &) = delete;
+  const HostNativeThreadBase &operator=(const HostNativeThreadBase &) = delete;
 
 public:
   HostNativeThreadBase();
   explicit HostNativeThreadBase(lldb::thread_t thread);
   virtual ~HostNativeThreadBase() {}
 
   virtual Status Join(lldb::thread_result_t *result) = 0;
   virtual Status Cancel() = 0;

lldb/include/lldb/Host/MainLoop.h

private:
   private:
     SignalHandle(MainLoop &mainloop, int signo)
         : m_mainloop(mainloop), m_signo(signo) {}
 
     MainLoop &m_mainloop;
     int m_signo;
 
     friend class MainLoop;
-    DISALLOW_COPY_AND_ASSIGN(SignalHandle);
+    SignalHandle(const SignalHandle &) = delete;
+    const SignalHandle &operator=(const SignalHandle &) = delete;
   };
 
   struct SignalInfo {
     Callback callback;
 #if HAVE_SIGACTION
     struct sigaction old_action;
 #endif
     bool was_blocked : 1;

lldb/include/lldb/Host/MainLoopBase.h

private:
   private:
     ReadHandle(MainLoopBase &mainloop, IOObject::WaitableHandle handle)
         : m_mainloop(mainloop), m_handle(handle) {}
 
     MainLoopBase &m_mainloop;
     IOObject::WaitableHandle m_handle;
 
     friend class MainLoopBase;
-    DISALLOW_COPY_AND_ASSIGN(ReadHandle);
+    ReadHandle(const ReadHandle &) = delete;
+    const ReadHandle &operator=(const ReadHandle &) = delete;
   };
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(MainLoopBase);
+  MainLoopBase(const MainLoopBase &) = delete;
+  const MainLoopBase &operator=(const MainLoopBase &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_HOST_MAINLOOPBASE_H

lldb/include/lldb/Host/ProcessRunLock.h

void Unlock() {
         m_lock->ReadUnlock();
         m_lock = nullptr;
       }
     }
 
     ProcessRunLock *m_lock;
 
   private:
-    DISALLOW_COPY_AND_ASSIGN(ProcessRunLocker);
+    ProcessRunLocker(const ProcessRunLocker &) = delete;
+    const ProcessRunLocker &operator=(const ProcessRunLocker &) = delete;
   };
 
 protected:
   lldb::rwlock_t m_rwlock;
   bool m_running;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(ProcessRunLock);
+  ProcessRunLock(const ProcessRunLock &) = delete;
+  const ProcessRunLock &operator=(const ProcessRunLock &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_HOST_PROCESSRUNLOCK_H

lldb/include/lldb/Host/PseudoTerminal.h

public:
   int ReleaseSlaveFileDescriptor();
 
 protected:
   // Member variables
   int m_master_fd; ///< The file descriptor for the master.
   int m_slave_fd;  ///< The file descriptor for the slave.
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(PseudoTerminal);
+  PseudoTerminal(const PseudoTerminal &) = delete;
+  const PseudoTerminal &operator=(const PseudoTerminal &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_HOST_PSEUDOTERMINAL_H

lldb/include/lldb/Host/common/NativeRegisterContext.h

protected:
   // Classes that inherit from RegisterContext can see and modify these
   NativeThreadProtocol
       &m_thread; // The thread that this register context belongs to.
   // uint32_t m_stop_id;             // The stop ID that any data in this
   // context is valid for
 
 private:
   // For RegisterContext only
-  DISALLOW_COPY_AND_ASSIGN(NativeRegisterContext);
+  NativeRegisterContext(const NativeRegisterContext &) = delete;
+  const NativeRegisterContext &
+  operator=(const NativeRegisterContext &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_HOST_COMMON_NATIVEREGISTERCONTEXT_H

lldb/include/lldb/Host/posix/ConnectionFileDescriptorPosix.h

protected:
   bool m_waiting_for_accept;
   bool m_child_processes_inherit;
 
   std::string m_uri;
 
 private:
   void InitializeSocket(Socket *socket);
 
-  DISALLOW_COPY_AND_ASSIGN(ConnectionFileDescriptor);
+  ConnectionFileDescriptor(const ConnectionFileDescriptor &) = delete;
+  const ConnectionFileDescriptor &
+  operator=(const ConnectionFileDescriptor &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_HOST_POSIX_CONNECTIONFILEDESCRIPTORPOSIX_H

lldb/include/lldb/Host/posix/HostThreadPosix.h

 //===-- HostThreadPosix.h -------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_HOST_POSIX_HOSTTHREADPOSIX_H
 #define LLDB_HOST_POSIX_HOSTTHREADPOSIX_H
 
 #include "lldb/Host/HostNativeThreadBase.h"
 
 namespace lldb_private {
 
 class HostThreadPosix : public HostNativeThreadBase {
-  DISALLOW_COPY_AND_ASSIGN(HostThreadPosix);
+  HostThreadPosix(const HostThreadPosix &) = delete;
+  const HostThreadPosix &operator=(const HostThreadPosix &) = delete;
 
 public:
   HostThreadPosix();
   HostThreadPosix(lldb::thread_t thread);
   ~HostThreadPosix() override;
 
   Status Join(lldb::thread_result_t *result) override;
   Status Cancel() override;
 
   Status Detach();
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_HOST_POSIX_HOSTTHREADPOSIX_H

lldb/include/lldb/Host/windows/ConnectionGenericFileWindows.h

protected:
   enum { kBytesAvailableEvent, kInterruptEvent };
 
 private:
   void InitializeEventHandles();
   void IncrementFilePointer(DWORD amount);
 
   std::string m_uri;
 
-  DISALLOW_COPY_AND_ASSIGN(ConnectionGenericFile);
+  ConnectionGenericFile(const ConnectionGenericFile &) = delete;
+  const ConnectionGenericFile &
+  operator=(const ConnectionGenericFile &) = delete;
 };
 }
 
 #endif

lldb/include/lldb/Host/windows/HostThreadWindows.h

 
 #include "lldb/Host/HostNativeThreadBase.h"
 
 #include "llvm/ADT/SmallString.h"
 
 namespace lldb_private {
 
 class HostThreadWindows : public HostNativeThreadBase {
-  DISALLOW_COPY_AND_ASSIGN(HostThreadWindows);
+  HostThreadWindows(const HostThreadWindows &) = delete;
+  const HostThreadWindows &operator=(const HostThreadWindows &) = delete;
 
 public:
   HostThreadWindows();
   HostThreadWindows(lldb::thread_t thread);
   virtual ~HostThreadWindows();
 
   void SetOwnsHandle(bool owns);
 

lldb/include/lldb/Interpreter/CommandHistory.h

public:
   void Clear();
 
   void Dump(Stream &stream, size_t start_idx = 0,
             size_t stop_idx = SIZE_MAX) const;
 
   static const char g_repeat_char = '!';
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(CommandHistory);
+  CommandHistory(const CommandHistory &) = delete;
+  const CommandHistory &operator=(const CommandHistory &) = delete;
 
   typedef std::vector<std::string> History;
   mutable std::recursive_mutex m_mutex;
   History m_history;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_INTERPRETER_COMMANDHISTORY_H

lldb/include/lldb/Interpreter/CommandObjectRegexCommand.h

protected:
 
   typedef std::list<Entry> EntryCollection;
   const uint32_t m_max_matches;
   const uint32_t m_completion_type_mask;
   EntryCollection m_entries;
   bool m_is_removable;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(CommandObjectRegexCommand);
+  CommandObjectRegexCommand(const CommandObjectRegexCommand &) = delete;
+  const CommandObjectRegexCommand &
+  operator=(const CommandObjectRegexCommand &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_INTERPRETER_COMMANDOBJECTREGEXCOMMAND_H

lldb/include/lldb/Interpreter/OptionGroupVariable.h

bool include_frame_options : 1,
                                  // true)
       show_locals : 1,  // Frame option only (include_frame_options == true)
       show_globals : 1, // Frame option only (include_frame_options == true)
       use_regex : 1, show_scope : 1, show_decl : 1;
   OptionValueString summary;        // the name of a named summary
   OptionValueString summary_string; // a summary string
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(OptionGroupVariable);
+  OptionGroupVariable(const OptionGroupVariable &) = delete;
+  const OptionGroupVariable &operator=(const OptionGroupVariable &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_INTERPRETER_OPTIONGROUPVARIABLE_H

lldb/include/lldb/Interpreter/OptionGroupWatchpoint.h

enum WatchType {
     eWatchReadWrite
   };
 
   WatchType watch_type;
   uint32_t watch_size;
   bool watch_type_specified;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(OptionGroupWatchpoint);
+  OptionGroupWatchpoint(const OptionGroupWatchpoint &) = delete;
+  const OptionGroupWatchpoint &
+  operator=(const OptionGroupWatchpoint &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_INTERPRETER_OPTIONGROUPWATCHPOINT_H

lldb/include/lldb/Interpreter/ScriptInterpreter.h

 
 class ScriptInterpreterLocker {
 public:
   ScriptInterpreterLocker() = default;
 
   virtual ~ScriptInterpreterLocker() = default;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(ScriptInterpreterLocker);
+  ScriptInterpreterLocker(const ScriptInterpreterLocker &) = delete;
+  const ScriptInterpreterLocker &
+  operator=(const ScriptInterpreterLocker &) = delete;
 };
 
 class ScriptInterpreter : public PluginInterface {
 public:
   enum ScriptReturnType {
     eScriptReturnTypeCharPtr,
     eScriptReturnTypeBool,
     eScriptReturnTypeShortInt,

lldb/include/lldb/Symbol/Block.h

bool m_parsed_block_info : 1, ///< Set to true if this block and it's children
                                 ///have all been parsed
       m_parsed_block_variables : 1, m_parsed_child_blocks : 1;
 
   // A parent of child blocks can be asked to find a sibling block given
   // one of its child blocks
   Block *GetSiblingForChild(const Block *child_block) const;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(Block);
+  Block(const Block &) = delete;
+  const Block &operator=(const Block &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SYMBOL_BLOCK_H

lldb/include/lldb/Symbol/CompileUnit.h

flagsParsedLineTable =
         (1u << 3),                   ///< Have we parsed the line table already?
     flagsParsedLanguage = (1u << 4), ///< Have we parsed the language already?
     flagsParsedImportedModules =
         (1u << 5), ///< Have we parsed the imported modules already?
     flagsParsedDebugMacros =
         (1u << 6) ///< Have we parsed the debug macros already?
   };
 
-  DISALLOW_COPY_AND_ASSIGN(CompileUnit);
+  CompileUnit(const CompileUnit &) = delete;
+  const CompileUnit &operator=(const CompileUnit &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SYMBOL_COMPILEUNIT_H

lldb/include/lldb/Symbol/DebugMacros.h

public:
   DebugMacroEntry GetMacroEntryAtIndex(const size_t index) const {
     if (index < m_macro_entries.size())
       return m_macro_entries[index];
     else
       return DebugMacroEntry();
   }
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(DebugMacros);
+  DebugMacros(const DebugMacros &) = delete;
+  const DebugMacros &operator=(const DebugMacros &) = delete;
 
   std::vector<DebugMacroEntry> m_macro_entries;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SYMBOL_DEBUGMACROS_H

lldb/include/lldb/Symbol/DeclVendor.h

public:
   //      The maximum number of matches. UINT32_MAX means "as many as possible".
   ///
   /// \return
   ///     The vector of CompilerTypes that was found.
   std::vector<CompilerType> FindTypes(ConstString name, uint32_t max_matches);
 
 private:
   // For DeclVendor only
-  DISALLOW_COPY_AND_ASSIGN(DeclVendor);
+  DeclVendor(const DeclVendor &) = delete;
+  const DeclVendor &operator=(const DeclVendor &) = delete;
 
   const DeclVendorKind m_kind;
 };
 
 } // namespace lldb_private
 
 #endif

lldb/include/lldb/Symbol/FuncUnwinders.h

bool m_tried_unwind_plan_assembly : 1, m_tried_unwind_plan_eh_frame : 1,
       m_tried_unwind_plan_debug_frame_augmented : 1,
       m_tried_unwind_plan_compact_unwind : 1,
       m_tried_unwind_plan_arm_unwind : 1, m_tried_unwind_plan_symbol_file : 1,
       m_tried_unwind_fast : 1, m_tried_unwind_arch_default : 1,
       m_tried_unwind_arch_default_at_func_entry : 1;
 
   Address m_first_non_prologue_insn;
 
-  DISALLOW_COPY_AND_ASSIGN(FuncUnwinders);
+  FuncUnwinders(const FuncUnwinders &) = delete;
+  const FuncUnwinders &operator=(const FuncUnwinders &) = delete;
 
 }; // class FuncUnwinders
 
 } // namespace lldb_private
 
 #endif // LLDB_SYMBOL_FUNCUNWINDERS_H

lldb/include/lldb/Symbol/Function.h

protected:
   Flags m_flags;
   uint32_t
       m_prologue_byte_size; ///< Compute the prologue size once and cache it
 
   bool m_call_edges_resolved = false; ///< Whether call site info has been
                                       ///  parsed.
   std::vector<std::unique_ptr<CallEdge>> m_call_edges; ///< Outgoing call edges.
 private:
-  DISALLOW_COPY_AND_ASSIGN(Function);
+  Function(const Function &) = delete;
+  const Function &operator=(const Function &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SYMBOL_FUNCTION_H

lldb/include/lldb/Symbol/LineTable.h

 public:
   LineSequence();
 
   virtual ~LineSequence() = default;
 
   virtual void Clear() = 0;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(LineSequence);
+  LineSequence(const LineSequence &) = delete;
+  const LineSequence &operator=(const LineSequence &) = delete;
 };
 
 /// \class LineTable LineTable.h "lldb/Symbol/LineTable.h"
 /// A line table class.
 class LineTable {
 public:
   /// Construct with compile unit.
   ///
public:
 
     entry_collection
         m_entries; ///< The collection of line entries in this sequence.
   };
 
   bool ConvertEntryAtIndexToLineEntry(uint32_t idx, LineEntry &line_entry);
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(LineTable);
+  LineTable(const LineTable &) = delete;
+  const LineTable &operator=(const LineTable &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SYMBOL_LINETABLE_H

lldb/include/lldb/Symbol/ObjectContainer.h

FileSpec m_file; ///< The file that represents this container objects (which
                    ///can be different from the module's file).
   lldb::addr_t
       m_offset; ///< The offset in bytes into the file, or the address in memory
   lldb::addr_t m_length; ///< The size in bytes if known (can be zero).
   DataExtractor
       m_data; ///< The data for this object file so things can be parsed lazily.
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(ObjectContainer);
+  ObjectContainer(const ObjectContainer &) = delete;
+  const ObjectContainer &operator=(const ObjectContainer &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SYMBOL_OBJECTCONTAINER_H

lldb/include/lldb/Symbol/ObjectFile.h

protected:
   bool SetModulesArchitecture(const ArchSpec &new_arch);
 
   ConstString GetNextSyntheticSymbolName();
 
   static lldb::DataBufferSP MapFileData(const FileSpec &file, uint64_t Size,
                                         uint64_t Offset);
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(ObjectFile);
+  ObjectFile(const ObjectFile &) = delete;
+  const ObjectFile &operator=(const ObjectFile &) = delete;
 };
 
 } // namespace lldb_private
 
 namespace llvm {
 template <> struct format_provider<lldb_private::ObjectFile::Type> {
   static void format(const lldb_private::ObjectFile::Type &type,
                      raw_ostream &OS, StringRef Style);

lldb/include/lldb/Symbol/SymbolFile.h

lldb::ObjectFileSP m_objfile_sp; // Keep a reference to the object file in
                                    // file)
   llvm::Optional<std::vector<lldb::CompUnitSP>> m_compile_units;
   TypeList m_type_list;
   Symtab *m_symtab = nullptr;
   uint32_t m_abilities;
   bool m_calculated_abilities;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(SymbolFile);
+  SymbolFile(const SymbolFile &) = delete;
+  const SymbolFile &operator=(const SymbolFile &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SYMBOL_SYMBOLFILE_H

lldb/include/lldb/Symbol/SymbolVendor.h

public:
   uint32_t GetPluginVersion() override;
 
 protected:
   std::unique_ptr<SymbolFile> m_sym_file_up; // A single symbol file. Subclasses
                                              // can add more of these if needed.
 
 private:
   // For SymbolVendor only
-  DISALLOW_COPY_AND_ASSIGN(SymbolVendor);
+  SymbolVendor(const SymbolVendor &) = delete;
+  const SymbolVendor &operator=(const SymbolVendor &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SYMBOL_SYMBOLVENDOR_H

lldb/include/lldb/Symbol/Symtab.h

void RegisterMangledNameEntry(
       uint32_t value, std::set<const char *> &class_contexts,
       std::vector<std::pair<NameToIndexMap::Entry, const char *>> &backlog,
       RichManglingContext &rmc);
 
   void RegisterBacklogEntry(const NameToIndexMap::Entry &entry,
                             const char *decl_context,
                             const std::set<const char *> &class_contexts);
 
-  DISALLOW_COPY_AND_ASSIGN(Symtab);
+  Symtab(const Symtab &) = delete;
+  const Symtab &operator=(const Symtab &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SYMBOL_SYMTAB_H

lldb/include/lldb/Symbol/TypeList.h

public:
   void RemoveMismatchedTypes(lldb::TypeClass type_class);
 
 private:
   typedef collection::iterator iterator;
   typedef collection::const_iterator const_iterator;
 
   collection m_types;
 
-  DISALLOW_COPY_AND_ASSIGN(TypeList);
+  TypeList(const TypeList &) = delete;
+  const TypeList &operator=(const TypeList &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SYMBOL_TYPELIST_H

lldb/include/lldb/Symbol/TypeMap.h

public:
   void RemoveMismatchedTypes(lldb::TypeClass type_class);
 
 private:
   typedef collection::iterator iterator;
   typedef collection::const_iterator const_iterator;
 
   collection m_types;
 
-  DISALLOW_COPY_AND_ASSIGN(TypeMap);
+  TypeMap(const TypeMap &) = delete;
+  const TypeMap &operator=(const TypeMap &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SYMBOL_TYPEMAP_H

lldb/include/lldb/Symbol/UnwindTable.h

private:
   std::mutex m_mutex;
 
   std::unique_ptr<CallFrameInfo> m_object_file_unwind_up;
   std::unique_ptr<DWARFCallFrameInfo> m_eh_frame_up;
   std::unique_ptr<DWARFCallFrameInfo> m_debug_frame_up;
   std::unique_ptr<CompactUnwindInfo> m_compact_unwind_up;
   std::unique_ptr<ArmUnwindInfo> m_arm_unwind_up;
 
-  DISALLOW_COPY_AND_ASSIGN(UnwindTable);
+  UnwindTable(const UnwindTable &) = delete;
+  const UnwindTable &operator=(const UnwindTable &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SYMBOL_UNWINDTABLE_H

lldb/include/lldb/Symbol/VariableList.h

public:
   const_iterator begin() const { return m_variables.begin(); }
   const_iterator end() const { return m_variables.end(); }
 
 protected:
   collection m_variables;
 
 private:
   // For VariableList only
-  DISALLOW_COPY_AND_ASSIGN(VariableList);
+  VariableList(const VariableList &) = delete;
+  const VariableList &operator=(const VariableList &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SYMBOL_VARIABLELIST_H

lldb/include/lldb/Target/ABI.h

protected:
   /// MCRegisterInfo themselves.
   static std::unique_ptr<llvm::MCRegisterInfo>
   MakeMCRegisterInfo(const ArchSpec &arch);
 
   lldb::ProcessWP m_process_wp;
   std::unique_ptr<llvm::MCRegisterInfo> m_mc_register_info_up;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(ABI);
+  ABI(const ABI &) = delete;
+  const ABI &operator=(const ABI &) = delete;
 };
 
 class RegInfoBasedABI : public ABI {
 public:
   void AugmentRegisterInfo(RegisterInfo &info) override;
 
 protected:
   using ABI::ABI;

lldb/include/lldb/Target/DynamicLoader.h

protected:
   void LoadOperatingSystemPlugin(bool flush);
 
 
   // Member variables.
   Process
       *m_process; ///< The process that this dynamic loader plug-in is tracking.
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(DynamicLoader);
+  DynamicLoader(const DynamicLoader &) = delete;
+  const DynamicLoader &operator=(const DynamicLoader &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_DYNAMICLOADER_H

lldb/include/lldb/Target/Language.h

public:
   static LanguageSet GetLanguagesSupportingREPLs();
 
 protected:
   // Classes that inherit from Language can see and modify these
 
   Language();
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(Language);
+  Language(const Language &) = delete;
+  const Language &operator=(const Language &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_LANGUAGE_H

lldb/include/lldb/Target/LanguageRuntime.h

 
 protected:
   // Classes that inherit from LanguageRuntime can see and modify these
 
   LanguageRuntime(Process *process);
   Process *m_process;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(LanguageRuntime);
+  LanguageRuntime(const LanguageRuntime &) = delete;
+  const LanguageRuntime &operator=(const LanguageRuntime &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_LANGUAGERUNTIME_H

lldb/include/lldb/Target/Memory.h

BlockMap m_L1_cache; // A first level memory cache whose chunk sizes vary that
                        // a chunk
   BlockMap m_L2_cache; // A memory cache of fixed size chinks
                        // (m_L2_cache_line_byte_size bytes in size each)
   InvalidRanges m_invalid_ranges;
   Process &m_process;
   uint32_t m_L2_cache_line_byte_size;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(MemoryCache);
+  MemoryCache(const MemoryCache &) = delete;
+  const MemoryCache &operator=(const MemoryCache &) = delete;
 };
 
     
 
 class AllocatedBlock {
 public:
   AllocatedBlock(lldb::addr_t addr, uint32_t byte_size, uint32_t permissions,
                  uint32_t chunk_size);
protected:
 
   // Classes that inherit from MemoryCache can see and modify these
   Process &m_process;
   std::recursive_mutex m_mutex;
   typedef std::multimap<uint32_t, AllocatedBlockSP> PermissionsToBlockMap;
   PermissionsToBlockMap m_memory_map;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(AllocatedMemoryCache);
+  AllocatedMemoryCache(const AllocatedMemoryCache &) = delete;
+  const AllocatedMemoryCache &operator=(const AllocatedMemoryCache &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_MEMORY_H

lldb/include/lldb/Target/OperatingSystem.h

public:
 
   virtual bool IsOperatingSystemPluginThread(const lldb::ThreadSP &thread_sp);
 
 protected:
   // Member variables.
   Process
       *m_process; ///< The process that this dynamic loader plug-in is tracking.
 private:
-  DISALLOW_COPY_AND_ASSIGN(OperatingSystem);
+  OperatingSystem(const OperatingSystem &) = delete;
+  const OperatingSystem &operator=(const OperatingSystem &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_OPERATINGSYSTEM_H

lldb/include/lldb/Target/Platform.h

private:
 
   Status LoadCachedExecutable(const ModuleSpec &module_spec,
                               lldb::ModuleSP &module_sp,
                               const FileSpecList *module_search_paths_ptr,
                               Platform &remote_platform);
 
   FileSpec GetModuleCacheRoot();
 
-  DISALLOW_COPY_AND_ASSIGN(Platform);
+  Platform(const Platform &) = delete;
+  const Platform &operator=(const Platform &) = delete;
 };
 
 class PlatformList {
 public:
   PlatformList() : m_mutex(), m_platforms(), m_selected_platform_sp() {}
 
   ~PlatformList() = default;
 

 
 protected:
   typedef std::vector<lldb::PlatformSP> collection;
   mutable std::recursive_mutex m_mutex;
   collection m_platforms;
   lldb::PlatformSP m_selected_platform_sp;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(PlatformList);
+  PlatformList(const PlatformList &) = delete;
+  const PlatformList &operator=(const PlatformList &) = delete;
 };
 
 class OptionGroupPlatformRSync : public lldb_private::OptionGroup {
 public:
   OptionGroupPlatformRSync() = default;
 
   ~OptionGroupPlatformRSync() override = default;
 
   lldb_private::Status
   SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
                  ExecutionContext *execution_context) override;
 
   void OptionParsingStarting(ExecutionContext *execution_context) override;
 
   llvm::ArrayRef<OptionDefinition> GetDefinitions() override;
 
   // Instance variables to hold the values for command options.
 
   bool m_rsync;
   std::string m_rsync_opts;
   std::string m_rsync_prefix;
   bool m_ignores_remote_hostname;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(OptionGroupPlatformRSync);
+  OptionGroupPlatformRSync(const OptionGroupPlatformRSync &) = delete;
+  const OptionGroupPlatformRSync &
+  operator=(const OptionGroupPlatformRSync &) = delete;
 };
 
 class OptionGroupPlatformSSH : public lldb_private::OptionGroup {
 public:
   OptionGroupPlatformSSH() = default;
 
   ~OptionGroupPlatformSSH() override = default;
 
   lldb_private::Status
   SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
                  ExecutionContext *execution_context) override;
 
   void OptionParsingStarting(ExecutionContext *execution_context) override;
 
   llvm::ArrayRef<OptionDefinition> GetDefinitions() override;
 
   // Instance variables to hold the values for command options.
 
   bool m_ssh;
   std::string m_ssh_opts;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(OptionGroupPlatformSSH);
+  OptionGroupPlatformSSH(const OptionGroupPlatformSSH &) = delete;
+  const OptionGroupPlatformSSH &
+  operator=(const OptionGroupPlatformSSH &) = delete;
 };
 
 class OptionGroupPlatformCaching : public lldb_private::OptionGroup {
 public:
   OptionGroupPlatformCaching() = default;
 
   ~OptionGroupPlatformCaching() override = default;
 
   lldb_private::Status
   SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
                  ExecutionContext *execution_context) override;
 
   void OptionParsingStarting(ExecutionContext *execution_context) override;
 
   llvm::ArrayRef<OptionDefinition> GetDefinitions() override;
 
   // Instance variables to hold the values for command options.
 
   std::string m_cache_dir;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(OptionGroupPlatformCaching);
+  OptionGroupPlatformCaching(const OptionGroupPlatformCaching &) = delete;
+  const OptionGroupPlatformCaching &
+  operator=(const OptionGroupPlatformCaching &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_PLATFORM_H

lldb/include/lldb/Target/Process.h

private:
     lldb::ProcessWP m_process_wp;
     lldb::StateType m_state;
     std::vector<std::string> m_restarted_reasons;
     bool m_restarted; // For "eStateStopped" events, this is true if the target
                       // was automatically restarted.
     int m_update_state;
     bool m_interrupted;
 
-    DISALLOW_COPY_AND_ASSIGN(ProcessEventData);
+    ProcessEventData(const ProcessEventData &) = delete;
+    const ProcessEventData &operator=(const ProcessEventData &) = delete;
   };
 
   /// Construct with a shared pointer to a target, and the Process listener.
   /// Uses the Host UnixSignalsSP by default.
   Process(lldb::TargetSP target_sp, lldb::ListenerSP listener_sp);
 
   /// Construct with a shared pointer to a target, the Process listener, and
   /// the appropriate UnixSignalsSP for the process.
private:
   ///
   /// \return
   ///     Returns \b true if the event should be reported to the
   ///     user, \b false otherwise.
   bool ShouldBroadcastEvent(Event *event_ptr);
 
   void ControlPrivateStateThread(uint32_t signal);
 
-  DISALLOW_COPY_AND_ASSIGN(Process);
+  Process(const Process &) = delete;
+  const Process &operator=(const Process &) = delete;
 };
 
 /// RAII guard that should be acquired when an utility function is called within
 /// a given process.
 class UtilityFunctionScope {
   Process *m_process;
 
 public:

lldb/include/lldb/Target/Queue.h

private:
   std::string m_queue_name;
   uint32_t m_running_work_items_count;
   uint32_t m_pending_work_items_count;
   std::vector<lldb::QueueItemSP> m_pending_items;
   lldb::addr_t m_dispatch_queue_t_addr; // address of libdispatch
                                         // dispatch_queue_t for this Queue
   lldb::QueueKind m_kind;
 
-  DISALLOW_COPY_AND_ASSIGN(Queue);
+  Queue(const Queue &) = delete;
+  const Queue &operator=(const Queue &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_QUEUE_H

lldb/include/lldb/Target/QueueItem.h

protected:
   lldb::queue_id_t m_target_queue_id;
   uint32_t m_stop_id; // indicates when this backtrace was recorded in time
   std::vector<lldb::addr_t> m_backtrace;
   std::string m_thread_label;
   std::string m_queue_label;
   std::string m_target_queue_label;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(QueueItem);
+  QueueItem(const QueueItem &) = delete;
+  const QueueItem &operator=(const QueueItem &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_QUEUEITEM_H

lldb/include/lldb/Target/RegisterCheckpoint.h

public:
 
   const lldb::DataBufferSP &GetData() const { return m_data_sp; }
 
 protected:
   lldb::DataBufferSP m_data_sp;
   Reason m_reason;
 
   // Make RegisterCheckpointSP if you wish to share the data in this class.
-  DISALLOW_COPY_AND_ASSIGN(RegisterCheckpoint);
+  RegisterCheckpoint(const RegisterCheckpoint &) = delete;
+  const RegisterCheckpoint &operator=(const RegisterCheckpoint &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_REGISTERCHECKPOINT_H

lldb/include/lldb/Target/RegisterContext.h

 protected:
   // Classes that inherit from RegisterContext can see and modify these
   Thread &m_thread; // The thread that this register context belongs to.
   uint32_t m_concrete_frame_idx; // The concrete frame index for this register
                                  // context
   uint32_t m_stop_id; // The stop ID that any data in this context is valid for
 private:
   // For RegisterContext only
-  DISALLOW_COPY_AND_ASSIGN(RegisterContext);
+  RegisterContext(const RegisterContext &) = delete;
+  const RegisterContext &operator=(const RegisterContext &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_REGISTERCONTEXT_H

lldb/include/lldb/Target/RegisterContextUnwind.h

private:
   uint32_t m_frame_number; // What stack frame this RegisterContext is
 
   std::map<uint32_t, lldb_private::UnwindLLDB::RegisterLocation>
       m_registers; // where to find reg values for this frame
 
   lldb_private::UnwindLLDB &m_parent_unwind; // The UnwindLLDB that is creating
                                              // this RegisterContextUnwind
 
-  DISALLOW_COPY_AND_ASSIGN(RegisterContextUnwind);
+  RegisterContextUnwind(const RegisterContextUnwind &) = delete;
+  const RegisterContextUnwind &
+  operator=(const RegisterContextUnwind &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_REGISTERCONTEXTUNWIND_H

lldb/include/lldb/Target/SectionLoadHistory.h

protected:
   SectionLoadList *GetSectionLoadListForStopID(uint32_t stop_id,
                                                bool read_only);
 
   typedef std::map<uint32_t, lldb::SectionLoadListSP> StopIDToSectionLoadList;
   StopIDToSectionLoadList m_stop_id_to_section_load_list;
   mutable std::recursive_mutex m_mutex;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(SectionLoadHistory);
+  SectionLoadHistory(const SectionLoadHistory &) = delete;
+  const SectionLoadHistory &operator=(const SectionLoadHistory &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_SECTIONLOADHISTORY_H

lldb/include/lldb/Target/StackFrame.h

private:
   lldb::VariableListSP m_variable_list_sp;
   ValueObjectList m_variable_list_value_objects; // Value objects for each
                                                  // variable in
                                                  // m_variable_list_sp
   lldb::RecognizedStackFrameSP m_recognized_frame_sp;
   StreamString m_disassembly;
   std::recursive_mutex m_mutex;
 
-  DISALLOW_COPY_AND_ASSIGN(StackFrame);
+  StackFrame(const StackFrame &) = delete;
+  const StackFrame &operator=(const StackFrame &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_STACKFRAME_H

lldb/include/lldb/Target/StackFrameList.h

protected:
   /// This is only valid if m_current_inlined_depth is valid.
   // TODO: Use an optional instead of UINT32_MAX to denote invalid values.
   lldb::addr_t m_current_inlined_pc;
 
   /// Whether or not to show synthetic (inline) frames. Immutable.
   const bool m_show_inlined_frames;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(StackFrameList);
+  StackFrameList(const StackFrameList &) = delete;
+  const StackFrameList &operator=(const StackFrameList &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_STACKFRAMELIST_H

lldb/include/lldb/Target/StackFrameRecognizer.h

public:
   }
 
   const char *GetPythonClassName() { return m_python_class.c_str(); }
 
   lldb::RecognizedStackFrameSP RecognizeFrame(
       lldb::StackFrameSP frame) override;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(ScriptedStackFrameRecognizer);
+  ScriptedStackFrameRecognizer(const ScriptedStackFrameRecognizer &) = delete;
+  const ScriptedStackFrameRecognizer &
+  operator=(const ScriptedStackFrameRecognizer &) = delete;
 };
 
 /// \class StackFrameRecognizerManager
 ///
 /// Static class that provides a registry of known stack frame recognizers.
 /// Has static methods to add, enumerate, remove, query and invoke recognizers.
 
 class StackFrameRecognizerManager {

lldb/include/lldb/Target/StopInfo.h

protected:
   // themselves as valid. It should only be used by
   // Thread::RestoreThreadStateFromCheckpoint and to make sure the one-step
   // needed for before-the-fact watchpoints does not prevent us from stopping
   void MakeStopInfoValid();
 
 private:
   friend class Thread;
 
-  DISALLOW_COPY_AND_ASSIGN(StopInfo);
+  StopInfo(const StopInfo &) = delete;
+  const StopInfo &operator=(const StopInfo &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_STOPINFO_H

lldb/include/lldb/Target/StructuredDataPlugin.h

protected:
   /// \param[in] debugger
   ///     The Debugger instance for which we're creating the required shared
   ///     components for the StructuredDataPlugin derived classes.
   static void InitializeBasePluginForDebugger(Debugger &debugger);
 
 private:
   lldb::ProcessWP m_process_wp;
 
-  DISALLOW_COPY_AND_ASSIGN(StructuredDataPlugin);
+  StructuredDataPlugin(const StructuredDataPlugin &) = delete;
+  const StructuredDataPlugin &operator=(const StructuredDataPlugin &) = delete;
 };
 }
 
 #endif

lldb/include/lldb/Target/SystemRuntime.h

 
 protected:
   // Member variables.
   Process *m_process;
 
   std::vector<ConstString> m_types;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(SystemRuntime);
+  SystemRuntime(const SystemRuntime &) = delete;
+  const SystemRuntime &operator=(const SystemRuntime &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_SYSTEMRUNTIME_H

lldb/include/lldb/Target/Target.h

public:
     const lldb::TargetSP &GetTarget() const { return m_target_sp; }
 
     const ModuleList &GetModuleList() const { return m_module_list; }
 
   private:
     lldb::TargetSP m_target_sp;
     ModuleList m_module_list;
 
-    DISALLOW_COPY_AND_ASSIGN(TargetEventData);
+    TargetEventData(const TargetEventData &) = delete;
+    const TargetEventData &operator=(const TargetEventData &) = delete;
   };
 
   ~Target() override;
 
   static void SettingsInitialize();
 
   static void SettingsTerminate();
 
private:
 
   // Copy breakpoints, stop hooks and so forth from the dummy target:
   void PrimeFromDummyTarget(Target *dummy_target);
 
   void AddBreakpoint(lldb::BreakpointSP breakpoint_sp, bool internal);
 
   void FinalizeFileActions(ProcessLaunchInfo &info);
 
-  DISALLOW_COPY_AND_ASSIGN(Target);
+  Target(const Target &) = delete;
+  const Target &operator=(const Target &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_TARGET_H

lldb/include/lldb/Target/TargetList.h

Status CreateTargetInternal(Debugger &debugger, llvm::StringRef user_exe_path,
                               lldb::TargetSP &target_sp, bool is_dummy_target);
 
   Status CreateTargetInternal(Debugger &debugger, llvm::StringRef user_exe_path,
                               const ArchSpec &arch,
                               LoadDependentFiles get_dependent_modules,
                               lldb::PlatformSP &platform_sp,
                               lldb::TargetSP &target_sp, bool is_dummy_target);
 
-  DISALLOW_COPY_AND_ASSIGN(TargetList);
+  TargetList(const TargetList &) = delete;
+  const TargetList &operator=(const TargetList &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_TARGETLIST_H

lldb/include/lldb/Target/Thread.h

public:
     lldb::ThreadSP GetThread() const { return m_thread_sp; }
 
     StackID GetStackID() const { return m_stack_id; }
 
   private:
     lldb::ThreadSP m_thread_sp;
     StackID m_stack_id;
 
-    DISALLOW_COPY_AND_ASSIGN(ThreadEventData);
+    ThreadEventData(const ThreadEventData &) = delete;
+    const ThreadEventData &operator=(const ThreadEventData &) = delete;
   };
 
   struct ThreadStateCheckpoint {
     uint32_t orig_stop_id; // Dunno if I need this yet but it is an interesting
                            // bit of data.
     lldb::StopInfoSP stop_info_sp; // You have to restore the stop info or you
                                    // might continue with the wrong signals.
     size_t m_completed_plan_checkpoint;

 private:
   bool m_extended_info_fetched; // Have we tried to retrieve the m_extended_info
                                 // for this thread?
   StructuredData::ObjectSP m_extended_info; // The extended info for this thread
 
 private:
   void BroadcastSelectedFrameChange(StackID &new_frame_id);
 
-  DISALLOW_COPY_AND_ASSIGN(Thread);
+  Thread(const Thread &) = delete;
+  const Thread &operator=(const Thread &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_THREAD_H

lldb/include/lldb/Target/ThreadPlan.h

private:
   bool m_plan_private;
   bool m_okay_to_discard;
   bool m_is_master_plan;
   bool m_plan_succeeded;
 
   lldb::ThreadPlanTracerSP m_tracer_sp;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(ThreadPlan);
+  ThreadPlan(const ThreadPlan &) = delete;
+  const ThreadPlan &operator=(const ThreadPlan &) = delete;
 };
 
 // ThreadPlanNull:
 // Threads are assumed to always have at least one plan on the plan stack. This
 // is put on the plan stack when a thread is destroyed so that if you
 // accidentally access a thread after it is destroyed you won't crash. But
 // asking questions of the ThreadPlanNull is definitely an error.
 
public:
 
   const Status &GetStatus() { return m_status; }
 
 protected:
   bool DoPlanExplainsStop(Event *event_ptr) override;
 
   lldb::StateType GetPlanRunState() override;
 
-  DISALLOW_COPY_AND_ASSIGN(ThreadPlanNull);
+  ThreadPlanNull(const ThreadPlanNull &) = delete;
+  const ThreadPlanNull &operator=(const ThreadPlanNull &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_THREADPLAN_H

lldb/include/lldb/Target/ThreadPlanBase.h

protected:
   bool DoWillResume(lldb::StateType resume_state, bool current_plan) override;
   bool DoPlanExplainsStop(Event *event_ptr) override;
   ThreadPlanBase(Thread &thread);
 
 private:
   friend lldb::ThreadPlanSP
   Thread::QueueFundamentalPlan(bool abort_other_plans);
 
-  DISALLOW_COPY_AND_ASSIGN(ThreadPlanBase);
+  ThreadPlanBase(const ThreadPlanBase &) = delete;
+  const ThreadPlanBase &operator=(const ThreadPlanBase &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_THREADPLANBASE_H

lldb/include/lldb/Target/ThreadPlanCallFunction.h

bool m_takedown_done; // We want to ensure we only do the takedown once.  This
                         // ensures that.
   bool m_should_clear_objc_exception_bp;
   bool m_should_clear_cxx_exception_bp;
   lldb::addr_t m_stop_address; // This is the address we stopped at.  Also set
                                // in DoTakedown;
 
 private:
   CompilerType m_return_type;
-  DISALLOW_COPY_AND_ASSIGN(ThreadPlanCallFunction);
+  ThreadPlanCallFunction(const ThreadPlanCallFunction &) = delete;
+  const ThreadPlanCallFunction &
+  operator=(const ThreadPlanCallFunction &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_THREADPLANCALLFUNCTION_H

lldb/include/lldb/Target/ThreadPlanCallFunctionUsingABI.h

public:
 
   void GetDescription(Stream *s, lldb::DescriptionLevel level) override;
 
 protected:
   void SetReturnValue() override;
 
 private:
   llvm::Type &m_return_type;
-  DISALLOW_COPY_AND_ASSIGN(ThreadPlanCallFunctionUsingABI);
+  ThreadPlanCallFunctionUsingABI(const ThreadPlanCallFunctionUsingABI &) =
+      delete;
+  const ThreadPlanCallFunctionUsingABI &
+  operator=(const ThreadPlanCallFunctionUsingABI &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_THREADPLANCALLFUNCTIONUSINGABI_H

lldb/include/lldb/Target/ThreadPlanCallUserExpression.h

lldb::UserExpressionSP
       m_user_expression_sp; // This is currently just used to ensure the
                             // User expression the initiated this ThreadPlan
                             // lives as long as the thread plan does.
   bool m_manage_materialization = false;
   lldb::ExpressionVariableSP
       m_result_var_sp; // If we are left to manage the materialization,
                        // then stuff the result expression variable here.
 
-  DISALLOW_COPY_AND_ASSIGN(ThreadPlanCallUserExpression);
+  ThreadPlanCallUserExpression(const ThreadPlanCallUserExpression &) = delete;
+  const ThreadPlanCallUserExpression &
+  operator=(const ThreadPlanCallUserExpression &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_THREADPLANCALLUSEREXPRESSION_H

lldb/include/lldb/Target/ThreadPlanPython.h

private:
   StructuredDataImpl *m_args_data; // We own this, but the implementation
                                    // has to manage the UP (since that is
                                    // how it gets stored in the
                                    // SBStructuredData).
   std::string m_error_str;
   StructuredData::ObjectSP m_implementation_sp;
   bool m_did_push;
 
-  DISALLOW_COPY_AND_ASSIGN(ThreadPlanPython);
+  ThreadPlanPython(const ThreadPlanPython &) = delete;
+  const ThreadPlanPython &operator=(const ThreadPlanPython &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_THREADPLANPYTHON_H

lldb/include/lldb/Target/ThreadPlanRunToAddress.h

 private:
   bool m_stop_others;
   std::vector<lldb::addr_t>
       m_addresses; // This is the address we are going to run to.
                    // TODO: Would it be useful to have multiple addresses?
   std::vector<lldb::break_id_t> m_break_ids; // This is the breakpoint we are
                                              // using to stop us at m_address.
 
-  DISALLOW_COPY_AND_ASSIGN(ThreadPlanRunToAddress);
+  ThreadPlanRunToAddress(const ThreadPlanRunToAddress &) = delete;
+  const ThreadPlanRunToAddress &
+  operator=(const ThreadPlanRunToAddress &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_THREADPLANRUNTOADDRESS_H

lldb/include/lldb/Target/ThreadPlanShouldStopHere.h

protected:
   virtual void SetFlagsToDefault() = 0;
 
   ThreadPlanShouldStopHereCallbacks m_callbacks;
   void *m_baton;
   ThreadPlan *m_owner;
   lldb_private::Flags m_flags;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(ThreadPlanShouldStopHere);
+  ThreadPlanShouldStopHere(const ThreadPlanShouldStopHere &) = delete;
+  const ThreadPlanShouldStopHere &
+  operator=(const ThreadPlanShouldStopHere &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_THREADPLANSHOULDSTOPHERE_H

lldb/include/lldb/Target/ThreadPlanStepInRange.h

lldb::ThreadPlanSP m_sub_plan_sp;      // Keep track of the last plan we were
                                     // running.  If it fails, we should stop.
   std::unique_ptr<RegularExpression> m_avoid_regexp_up;
   bool m_step_past_prologue; // FIXME: For now hard-coded to true, we could put
                              // a switch in for this if there's
                              // demand for that.
   bool m_virtual_step; // true if we've just done a "virtual step", i.e. just
                        // moved the inline stack depth.
   ConstString m_step_into_target;
-  DISALLOW_COPY_AND_ASSIGN(ThreadPlanStepInRange);
+  ThreadPlanStepInRange(const ThreadPlanStepInRange &) = delete;
+  const ThreadPlanStepInRange &
+  operator=(const ThreadPlanStepInRange &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_THREADPLANSTEPINRANGE_H

lldb/include/lldb/Target/ThreadPlanStepInstruction.h

private:
   lldb::addr_t m_instruction_addr;
   bool m_stop_other_threads;
   bool m_step_over;
   // These two are used only for the step over case.
   bool m_start_has_symbol;
   StackID m_stack_id;
   StackID m_parent_frame_id;
 
-  DISALLOW_COPY_AND_ASSIGN(ThreadPlanStepInstruction);
+  ThreadPlanStepInstruction(const ThreadPlanStepInstruction &) = delete;
+  const ThreadPlanStepInstruction &
+  operator=(const ThreadPlanStepInstruction &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_THREADPLANSTEPINSTRUCTION_H

lldb/include/lldb/Target/ThreadPlanStepOut.h

friend lldb::ThreadPlanSP Thread::QueueThreadPlanForStepOut(
       Status &status, LazyBool step_out_avoids_code_without_debug_info);
 
   void SetupAvoidNoDebug(LazyBool step_out_avoids_code_without_debug_info);
   // Need an appropriate marker for the current stack so we can tell step out
   // from step in.
 
   void CalculateReturnValue();
 
-  DISALLOW_COPY_AND_ASSIGN(ThreadPlanStepOut);
+  ThreadPlanStepOut(const ThreadPlanStepOut &) = delete;
+  const ThreadPlanStepOut &operator=(const ThreadPlanStepOut &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_THREADPLANSTEPOUT_H

lldb/include/lldb/Target/ThreadPlanStepOverBreakpoint.h

protected:
   void ReenableBreakpointSite();
 
 private:
   lldb::addr_t m_breakpoint_addr;
   lldb::user_id_t m_breakpoint_site_id;
   bool m_auto_continue;
   bool m_reenabled_breakpoint_site;
 
-  DISALLOW_COPY_AND_ASSIGN(ThreadPlanStepOverBreakpoint);
+  ThreadPlanStepOverBreakpoint(const ThreadPlanStepOverBreakpoint &) = delete;
+  const ThreadPlanStepOverBreakpoint &
+  operator=(const ThreadPlanStepOverBreakpoint &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_THREADPLANSTEPOVERBREAKPOINT_H

lldb/include/lldb/Target/ThreadPlanStepOverRange.h

 private:
   static uint32_t s_default_flag_values;
 
   void SetupAvoidNoDebug(LazyBool step_out_avoids_code_without_debug_info);
   bool IsEquivalentContext(const SymbolContext &context);
 
   bool m_first_resume;
 
-  DISALLOW_COPY_AND_ASSIGN(ThreadPlanStepOverRange);
+  ThreadPlanStepOverRange(const ThreadPlanStepOverRange &) = delete;
+  const ThreadPlanStepOverRange &
+  operator=(const ThreadPlanStepOverRange &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_THREADPLANSTEPOVERRANGE_H

lldb/include/lldb/Target/ThreadPlanStepRange.h

bool m_found_calls = false; // When we set the next branch breakpoint for
                               // that directly return.  But if we do that we
                               // need to run all threads, or we might cause
                               // deadlocks.  This tells us whether we found
                               // any calls in setting the next branch breakpoint.
 
 private:
   std::vector<lldb::DisassemblerSP> m_instruction_ranges;
 
-  DISALLOW_COPY_AND_ASSIGN(ThreadPlanStepRange);
+  ThreadPlanStepRange(const ThreadPlanStepRange &) = delete;
+  const ThreadPlanStepRange &operator=(const ThreadPlanStepRange &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_THREADPLANSTEPRANGE_H

lldb/include/lldb/Target/ThreadPlanStepThrough.h

private:
 
   lldb::ThreadPlanSP m_sub_plan_sp;
   lldb::addr_t m_start_address;
   lldb::break_id_t m_backstop_bkpt_id;
   lldb::addr_t m_backstop_addr;
   StackID m_return_stack_id;
   bool m_stop_others;
 
-  DISALLOW_COPY_AND_ASSIGN(ThreadPlanStepThrough);
+  ThreadPlanStepThrough(const ThreadPlanStepThrough &) = delete;
+  const ThreadPlanStepThrough &
+  operator=(const ThreadPlanStepThrough &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_THREADPLANSTEPTHROUGH_H

lldb/include/lldb/Target/ThreadPlanStepUntil.h

private:
 
   friend lldb::ThreadPlanSP Thread::QueueThreadPlanForStepUntil(
       bool abort_other_plans, lldb::addr_t *address_list, size_t num_addresses,
       bool stop_others, uint32_t frame_idx, Status &status);
 
   // Need an appropriate marker for the current stack so we can tell step out
   // from step in.
 
-  DISALLOW_COPY_AND_ASSIGN(ThreadPlanStepUntil);
+  ThreadPlanStepUntil(const ThreadPlanStepUntil &) = delete;
+  const ThreadPlanStepUntil &operator=(const ThreadPlanStepUntil &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_THREADPLANSTEPUNTIL_H

lldb/include/lldb/Target/Unwind.h

protected:
 
   virtual lldb::RegisterContextSP
   DoCreateRegisterContextForFrame(StackFrame *frame) = 0;
 
   Thread &m_thread;
   std::recursive_mutex m_unwind_mutex;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(Unwind);
+  Unwind(const Unwind &) = delete;
+  const Unwind &operator=(const Unwind &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_UNWIND_H

lldb/include/lldb/Target/UnwindAssembly.h

FirstNonPrologueInsn(AddressRange &func,
                        Address &first_non_prologue_insn) = 0;
 
 protected:
   UnwindAssembly(const ArchSpec &arch);
   ArchSpec m_arch;
 
 private:
   UnwindAssembly() = delete;
-  DISALLOW_COPY_AND_ASSIGN(UnwindAssembly);
+  UnwindAssembly(const UnwindAssembly &) = delete;
+  const UnwindAssembly &operator=(const UnwindAssembly &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_UNWINDASSEMBLY_H

lldb/include/lldb/Target/UnwindLLDB.h

struct Cursor {
     RegisterContextLLDBSP
         reg_ctx_lldb_sp; // These are all RegisterContextUnwind's
 
     Cursor()
         : start_pc(LLDB_INVALID_ADDRESS), cfa(LLDB_INVALID_ADDRESS), sctx(),
           reg_ctx_lldb_sp() {}
 
   private:
-    DISALLOW_COPY_AND_ASSIGN(Cursor);
+    Cursor(const Cursor &) = delete;
+    const Cursor &operator=(const Cursor &) = delete;
   };
 
   typedef std::shared_ptr<Cursor> CursorSP;
   std::vector<CursorSP> m_frames;
   CursorSP m_candidate_frame;
   bool m_unwind_complete; // If this is true, we've enumerated all the frames in
                           // the stack, and m_frames.size() is the
   // number of frames, etc.  Otherwise we've only gone as far as directly asked,
private:
 
   CursorSP GetOneMoreFrame(ABI *abi);
 
   bool AddOneMoreFrame(ABI *abi);
 
   bool AddFirstFrame();
 
   // For UnwindLLDB only
-  DISALLOW_COPY_AND_ASSIGN(UnwindLLDB);
+  UnwindLLDB(const UnwindLLDB &) = delete;
+  const UnwindLLDB &operator=(const UnwindLLDB &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_UNWINDLLDB_H

lldb/include/lldb/Utility/Broadcaster.h

protected:
     /// A simple mechanism to intercept events from a broadcaster
     std::vector<lldb::ListenerSP> m_hijacking_listeners;
 
     /// At some point we may want to have a stack or Listener collections, but
     /// for now this is just for private hijacking.
     std::vector<uint32_t> m_hijacking_masks;
 
   private:
-    DISALLOW_COPY_AND_ASSIGN(BroadcasterImpl);
+    BroadcasterImpl(const BroadcasterImpl &) = delete;
+    const BroadcasterImpl &operator=(const BroadcasterImpl &) = delete;
   };
 
   typedef std::shared_ptr<BroadcasterImpl> BroadcasterImplSP;
   typedef std::weak_ptr<BroadcasterImpl> BroadcasterImplWP;
 
   BroadcasterImplSP GetBroadcasterImpl() { return m_broadcaster_sp; }
 
   const char *GetHijackingListenerName() {
     return m_broadcaster_sp->GetHijackingListenerName();
   }
 
 private:
   BroadcasterImplSP m_broadcaster_sp;
   lldb::BroadcasterManagerSP m_manager_sp;
 
   /// The name of this broadcaster object.
   const ConstString m_broadcaster_name;
 
-  DISALLOW_COPY_AND_ASSIGN(Broadcaster);
+  Broadcaster(const Broadcaster &) = delete;
+  const Broadcaster &operator=(const Broadcaster &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_UTILITY_BROADCASTER_H

lldb/include/lldb/Utility/Connection.h

public:
   /// support waiting) this function should return a null pointer.
   ///
   /// \return
   ///     The underlying IOObject used for reading.
   virtual lldb::IOObjectSP GetReadObject() { return lldb::IOObjectSP(); };
 
 private:
   // For Connection only
-  DISALLOW_COPY_AND_ASSIGN(Connection);
+  Connection(const Connection &) = delete;
+  const Connection &operator=(const Connection &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_UTILITY_CONNECTION_H

lldb/include/lldb/Utility/DataEncoder.h

private:
   /// The address size to use when extracting pointers or
   /// addresses
   uint8_t m_addr_size;
 
   /// The shared pointer to data that can
   /// be shared among multiple instances
   mutable lldb::DataBufferSP m_data_sp;
 
-  DISALLOW_COPY_AND_ASSIGN(DataEncoder);
+  DataEncoder(const DataEncoder &) = delete;
+  const DataEncoder &operator=(const DataEncoder &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // #if defined (__cplusplus)
 #endif // LLDB_UTILITY_DATAENCODER_H

lldb/include/lldb/Utility/Event.h

public:
 
   virtual ConstString GetFlavor() const = 0;
 
   virtual void Dump(Stream *s) const;
 
 private:
   virtual void DoOnRemoval(Event *event_ptr) {}
 
-  DISALLOW_COPY_AND_ASSIGN(EventData);
+  EventData(const EventData &) = delete;
+  const EventData &operator=(const EventData &) = delete;
 };
 
 // lldb::EventDataBytes
 class EventDataBytes : public EventData {
 public:
   // Constructors
   EventDataBytes();
 
public:
 
   static size_t GetByteSizeFromEvent(const Event *event_ptr);
 
   static ConstString GetFlavorString();
 
 private:
   std::string m_bytes;
 
-  DISALLOW_COPY_AND_ASSIGN(EventDataBytes);
+  EventDataBytes(const EventDataBytes &) = delete;
+  const EventDataBytes &operator=(const EventDataBytes &) = delete;
 };
 
 class EventDataReceipt : public EventData {
 public:
   EventDataReceipt() : EventData(), m_predicate(false) {}
 
   ~EventDataReceipt() override {}
 
public:
 
   static ConstString GetFlavorString();
 
 private:
   lldb::ProcessSP m_process_sp;
   StructuredData::ObjectSP m_object_sp;
   lldb::StructuredDataPluginSP m_plugin_sp;
 
-  DISALLOW_COPY_AND_ASSIGN(EventDataStructuredData);
+  EventDataStructuredData(const EventDataStructuredData &) = delete;
+  const EventDataStructuredData &
+  operator=(const EventDataStructuredData &) = delete;
 };
 
 // lldb::Event
 class Event {
   friend class Listener;
   friend class EventData;
   friend class Broadcaster::BroadcasterImpl;
 
void SetBroadcaster(Broadcaster *broadcaster) {
     m_broadcaster_wp = broadcaster->GetBroadcasterImpl();
   }
 
   Broadcaster::BroadcasterImplWP
       m_broadcaster_wp;        // The broadcaster that sent this event
   uint32_t m_type;             // The bit describing this event
   lldb::EventDataSP m_data_sp; // User specific data for this event
 
-  DISALLOW_COPY_AND_ASSIGN(Event);
+  Event(const Event &) = delete;
+  const Event &operator=(const Event &) = delete;
   Event() = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_UTILITY_EVENT_H

lldb/include/lldb/Utility/IOObject.h

public:
   FDType GetFdType() const { return m_fd_type; }
 
   virtual WaitableHandle GetWaitableHandle() = 0;
 
 protected:
   FDType m_fd_type;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(IOObject);
+  IOObject(const IOObject &) = delete;
+  const IOObject &operator=(const IOObject &) = delete;
 };
 } // namespace lldb_private
 
 #endif

lldb/include/lldb/Utility/Listener.h

private:
   void BroadcasterManagerWillDestruct(lldb::BroadcasterManagerSP manager_sp);
 
   //    broadcaster_collection::iterator
   //    FindBroadcasterWithMask (Broadcaster *broadcaster,
   //                             uint32_t event_mask,
   //                             bool exact);
 
   // For Listener only
-  DISALLOW_COPY_AND_ASSIGN(Listener);
+  Listener(const Listener &) = delete;
+  const Listener &operator=(const Listener &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_UTILITY_LISTENER_H

lldb/include/lldb/Utility/Predicate.h

#ifdef DB_PTHREAD_LOG_EVENTS
     printf("%s (old_value = 0x%8.8x, broadcast_type = %i) m_value = 0x%8.8x, "
            "broadcast = %u\n",
            __FUNCTION__, old_value, broadcast_type, m_value, broadcast);
 #endif
     if (broadcast)
       m_condition.notify_all();
   }
 
-  DISALLOW_COPY_AND_ASSIGN(Predicate);
+  Predicate(const Predicate &) = delete;
+  const Predicate &operator=(const Predicate &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_UTILITY_PREDICATE_H

lldb/include/lldb/Utility/Timer.h

public:
   private:
     friend class Timer;
     const char *m_name;
     std::atomic<uint64_t> m_nanos;
     std::atomic<uint64_t> m_nanos_total;
     std::atomic<uint64_t> m_count;
     std::atomic<Category *> m_next;
 
-    DISALLOW_COPY_AND_ASSIGN(Category);
+    Category(const Category &) = delete;
+    const Category &operator=(const Category &) = delete;
   };
 
   /// Default constructor.
   Timer(Category &category, const char *format, ...)
       __attribute__((format(printf, 3, 4)));
 
   /// Destructor
   ~Timer();
protected:
   Category &m_category;
   TimePoint m_total_start;
   TimePoint::duration m_child_duration{0};
 
   static std::atomic<bool> g_quiet;
   static std::atomic<unsigned> g_display_depth;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(Timer);
+  Timer(const Timer &) = delete;
+  const Timer &operator=(const Timer &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_UTILITY_TIMER_H

lldb/include/lldb/lldb-defines.h

 
 // ignore GCC function attributes
 #if defined(_MSC_VER) && !defined(__clang__)
 #define __attribute__(X)
 #endif
 
 #define UNUSED_IF_ASSERT_DISABLED(x) ((void)(x))
 
-#if defined(__cplusplus)
-
-/// \def DISALLOW_COPY_AND_ASSIGN(TypeName)
-///     Macro definition for easily disallowing copy constructor and
-///     assignment operators in C++ classes.
-#define DISALLOW_COPY_AND_ASSIGN(TypeName)                                     \
-  TypeName(const TypeName &) = delete;                                         \
-  const TypeName &operator=(const TypeName &) = delete
-
-#endif // #if defined(__cplusplus)
-
 #endif // LLDB_LLDB_DEFINES_H

lldb/source/Commands/CommandCompletions.cpp

public:
 
   virtual void DoCompletion(SearchFilter *filter) = 0;
 
 protected:
   CommandInterpreter &m_interpreter;
   CompletionRequest &m_request;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(Completer);
+  Completer(const Completer &) = delete;
+  const Completer &operator=(const Completer &) = delete;
 };
 } // namespace
 
 // SourceFileCompleter implements the source file completer
 namespace {
 class SourceFileCompleter : public Completer {
 public:
   SourceFileCompleter(CommandInterpreter &interpreter,
void DoCompletion(SearchFilter *filter) override {
     }
   }
 
 private:
   FileSpecList m_matching_files;
   const char *m_file_name;
   const char *m_dir_name;
 
-  DISALLOW_COPY_AND_ASSIGN(SourceFileCompleter);
+  SourceFileCompleter(const SourceFileCompleter &) = delete;
+  const SourceFileCompleter &operator=(const SourceFileCompleter &) = delete;
 };
 } // namespace
 
 static bool regex_chars(const char comp) {
   return llvm::StringRef("[](){}+.*|^$\\?").contains(comp);
 }
 
 namespace {
for (pos = m_match_set.begin(); pos != end; pos++)
       m_request.AddCompletion((*pos).GetCString());
   }
 
 private:
   RegularExpression m_regex;
   typedef std::set<ConstString> collection;
   collection m_match_set;
 
-  DISALLOW_COPY_AND_ASSIGN(SymbolCompleter);
+  SymbolCompleter(const SymbolCompleter &) = delete;
+  const SymbolCompleter &operator=(const SymbolCompleter &) = delete;
 };
 } // namespace
 
 namespace {
 class ModuleCompleter : public Completer {
 public:
   ModuleCompleter(CommandInterpreter &interpreter, CompletionRequest &request)
       : Completer(interpreter, request) {
public:
   }
 
   void DoCompletion(SearchFilter *filter) override { filter->Search(*this); }
 
 private:
   const char *m_file_name;
   const char *m_dir_name;
 
-  DISALLOW_COPY_AND_ASSIGN(ModuleCompleter);
+  ModuleCompleter(const ModuleCompleter &) = delete;
+  const ModuleCompleter &operator=(const ModuleCompleter &) = delete;
 };
 } // namespace
 
 void CommandCompletions::SourceFiles(CommandInterpreter &interpreter,
                                      CompletionRequest &request,
                                      SearchFilter *searcher) {
   SourceFileCompleter completer(interpreter, request);
 

 }
 
 void CommandCompletions::ProcessPluginNames(CommandInterpreter &interpreter,
                                             CompletionRequest &request,
                                             SearchFilter *searcher) {
   PluginManager::AutoCompleteProcessName(request.GetCursorArgumentPrefix(),
                                          request);
 }
 No newline at end of file

lldb/source/Commands/CommandObjectLog.h

 public:
   // Constructors and Destructors
   CommandObjectLog(CommandInterpreter &interpreter);
 
   ~CommandObjectLog() override;
 
 private:
   // For CommandObjectLog only
-  DISALLOW_COPY_AND_ASSIGN(CommandObjectLog);
+  CommandObjectLog(const CommandObjectLog &) = delete;
+  const CommandObjectLog &operator=(const CommandObjectLog &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_COMMANDS_COMMANDOBJECTLOG_H

lldb/source/Commands/CommandObjectPlatform.h

 
 class CommandObjectPlatform : public CommandObjectMultiword {
 public:
   CommandObjectPlatform(CommandInterpreter &interpreter);
 
   ~CommandObjectPlatform() override;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(CommandObjectPlatform);
+  CommandObjectPlatform(const CommandObjectPlatform &) = delete;
+  const CommandObjectPlatform &
+  operator=(const CommandObjectPlatform &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_COMMANDS_COMMANDOBJECTPLATFORM_H

lldb/source/Commands/CommandObjectPlatform.cpp

llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
     return llvm::makeArrayRef(g_permissions_options);
   }
 
   // Instance variables to hold the values for command options.
 
   uint32_t m_permissions;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(OptionPermissions);
+  OptionPermissions(const OptionPermissions &) = delete;
+  const OptionPermissions &operator=(const OptionPermissions &) = delete;
 };
 
 // "platform select <platform-name>"
 class CommandObjectPlatformSelect : public CommandObjectParsed {
 public:
   CommandObjectPlatformSelect(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "platform select",
                             "Create a platform if needed and select it as the "
CommandObjectPlatformFile(CommandInterpreter &interpreter)
     LoadSubCommand(
         "write", CommandObjectSP(new CommandObjectPlatformFWrite(interpreter)));
   }
 
   ~CommandObjectPlatformFile() override = default;
 
 private:
   // For CommandObjectPlatform only
-  DISALLOW_COPY_AND_ASSIGN(CommandObjectPlatformFile);
+  CommandObjectPlatformFile(const CommandObjectPlatformFile &) = delete;
+  const CommandObjectPlatformFile &
+  operator=(const CommandObjectPlatformFile &) = delete;
 };
 
 // "platform get-file remote-file-path host-file-path"
 class CommandObjectPlatformGetFile : public CommandObjectParsed {
 public:
   CommandObjectPlatformGetFile(CommandInterpreter &interpreter)
       : CommandObjectParsed(
             interpreter, "platform get-file",
CommandObjectPlatformProcess(CommandInterpreter &interpreter)
     LoadSubCommand("list", CommandObjectSP(new CommandObjectPlatformProcessList(
                                interpreter)));
   }
 
   ~CommandObjectPlatformProcess() override = default;
 
 private:
   // For CommandObjectPlatform only
-  DISALLOW_COPY_AND_ASSIGN(CommandObjectPlatformProcess);
+  CommandObjectPlatformProcess(const CommandObjectPlatformProcess &) = delete;
+  const CommandObjectPlatformProcess &
+  operator=(const CommandObjectPlatformProcess &) = delete;
 };
 
 // "platform shell"
 #define LLDB_OPTIONS_platform_shell
 #include "CommandOptions.inc"
 
 class CommandObjectPlatformShell : public CommandObjectRaw {
 public:

lldb/source/Commands/CommandObjectRegister.h

 public:
   // Constructors and Destructors
   CommandObjectRegister(CommandInterpreter &interpreter);
 
   ~CommandObjectRegister() override;
 
 private:
   // For CommandObjectRegister only
-  DISALLOW_COPY_AND_ASSIGN(CommandObjectRegister);
+  CommandObjectRegister(const CommandObjectRegister &) = delete;
+  const CommandObjectRegister &
+  operator=(const CommandObjectRegister &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_COMMANDS_COMMANDOBJECTREGISTER_H

lldb/source/Commands/CommandObjectTarget.cpp

public:
 
   void OptionParsingStarting(ExecutionContext *execution_context) override {
     m_load_dependent_files = eLoadDependentsDefault;
   }
 
   LoadDependentFiles m_load_dependent_files;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(OptionGroupDependents);
+  OptionGroupDependents(const OptionGroupDependents &) = delete;
+  const OptionGroupDependents &
+  operator=(const OptionGroupDependents &) = delete;
 };
 
 #pragma mark CommandObjectTargetCreate
 
 // "target create"
 
 class CommandObjectTargetCreate : public CommandObjectParsed {
 public:
LoadSubCommand(
         "show-unwind",
         CommandObjectSP(new CommandObjectTargetModulesShowUnwind(interpreter)));
   }
 
   ~CommandObjectTargetModules() override = default;
 
 private:
   // For CommandObjectTargetModules only
-  DISALLOW_COPY_AND_ASSIGN(CommandObjectTargetModules);
+  CommandObjectTargetModules(const CommandObjectTargetModules &) = delete;
+  const CommandObjectTargetModules &
+  operator=(const CommandObjectTargetModules &) = delete;
 };
 
 class CommandObjectTargetSymbolsAdd : public CommandObjectParsed {
 public:
   CommandObjectTargetSymbolsAdd(CommandInterpreter &interpreter)
       : CommandObjectParsed(
             interpreter, "target symbols add",
             "Add a debug symbol file to one of the target's current modules by "
CommandObjectTargetSymbols(CommandInterpreter &interpreter)
     LoadSubCommand(
         "add", CommandObjectSP(new CommandObjectTargetSymbolsAdd(interpreter)));
   }
 
   ~CommandObjectTargetSymbols() override = default;
 
 private:
   // For CommandObjectTargetModules only
-  DISALLOW_COPY_AND_ASSIGN(CommandObjectTargetSymbols);
+  CommandObjectTargetSymbols(const CommandObjectTargetSymbols &) = delete;
+  const CommandObjectTargetSymbols &
+  operator=(const CommandObjectTargetSymbols &) = delete;
 };
 
 #pragma mark CommandObjectTargetStopHookAdd
 
 // CommandObjectTargetStopHookAdd
 #define LLDB_OPTIONS_target_stop_hook_add
 #include "CommandOptions.inc"
 

lldb/source/Core/IOHandlerCursesGUI.cpp

protected:
   uint32_t m_curr_active_window_idx;
   uint32_t m_prev_active_window_idx;
   bool m_delete;
   bool m_needs_update;
   bool m_can_activate;
   bool m_is_subwin;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(Window);
+  Window(const Window &) = delete;
+  const Window &operator=(const Window &) = delete;
 };
 
 class MenuDelegate {
 public:
   virtual ~MenuDelegate() = default;
 
   virtual MenuActionResult MenuDelegateAction(Menu &menu) = 0;
 };

lldb/source/Host/macosx/objcxx/HostThreadMacOSX.mm

if (v)
       delete static_cast<MacOSXDarwinThread *>(v);
     ::pthread_setspecific(g_thread_create_key, NULL);
   }
 
 protected:
   NSAutoreleasePool *m_pool;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(MacOSXDarwinThread);
+  MacOSXDarwinThread(const MacOSXDarwinThread &) = delete;
+  const MacOSXDarwinThread &operator=(const MacOSXDarwinThread &) = delete;
 };
 
 void InitThreadCreated() {
   ::pthread_key_create(&g_thread_create_key,
                        MacOSXDarwinThread::PThreadDestructor);
 }
 } // namespace
 

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

protected:
   lldb_private::Address m_kext_summary_header_ptr_addr;
   lldb_private::Address m_kext_summary_header_addr;
   OSKextLoadedKextSummaryHeader m_kext_summary_header;
   KextImageInfo::collection m_known_kexts;
   mutable std::recursive_mutex m_mutex;
   lldb::user_id_t m_break_id;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(DynamicLoaderDarwinKernel);
+  DynamicLoaderDarwinKernel(const DynamicLoaderDarwinKernel &) = delete;
+  const DynamicLoaderDarwinKernel &
+  operator=(const DynamicLoaderDarwinKernel &) = delete;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_DYNAMICLOADER_DARWIN_KERNEL_DYNAMICLOADERDARWINKERNEL_H

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

protected:
 
   /// return the address of the Rendezvous breakpoint
   lldb::addr_t FindRendezvousBreakpointAddress();
 
 private:
   const lldb_private::SectionList *
   GetSectionListFromModule(const lldb::ModuleSP module) const;
 
-  DISALLOW_COPY_AND_ASSIGN(DynamicLoaderHexagonDYLD);
+  DynamicLoaderHexagonDYLD(const DynamicLoaderHexagonDYLD &) = delete;
+  const DynamicLoaderHexagonDYLD &
+  operator=(const DynamicLoaderHexagonDYLD &) = delete;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_DYNAMICLOADER_HEXAGON_DYLD_DYNAMICLOADERHEXAGONDYLD_H

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

protected:
   ImageInfo::collection
       m_dyld_image_infos;              // Current shared libraries information
   uint32_t m_dyld_image_infos_stop_id; // The process stop ID that
                                        // "m_dyld_image_infos" is valid for
   ImageInfo m_dyld;
   mutable std::recursive_mutex m_mutex;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(DynamicLoaderDarwin);
+  DynamicLoaderDarwin(const DynamicLoaderDarwin &) = delete;
+  const DynamicLoaderDarwin &operator=(const DynamicLoaderDarwin &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_DYNAMICLOADER_MACOSX_DYLD_DYNAMICLOADERDARWIN_H

lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOS.h

protected:
   lldb::addr_t m_maybe_image_infos_address; // If dyld is still maintaining the
                                             // all_image_infos address, store it
                                             // here so we can use it to detect
                                             // exec's when talking to
                                             // debugservers that don't support
                                             // the "reason:exec" annotation.
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(DynamicLoaderMacOS);
+  DynamicLoaderMacOS(const DynamicLoaderMacOS &) = delete;
+  const DynamicLoaderMacOS &operator=(const DynamicLoaderMacOS &) = delete;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_DYNAMICLOADER_MACOSX_DYLD_DYNAMICLOADERMACOS_H

lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.h

protected:
   lldb::addr_t m_dyld_all_image_infos_addr;
   DYLDAllImageInfos m_dyld_all_image_infos;
   uint32_t m_dyld_all_image_infos_stop_id;
   lldb::user_id_t m_break_id;
   mutable std::recursive_mutex m_mutex;
   bool m_process_image_addr_is_all_images_infos;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(DynamicLoaderMacOSXDYLD);
+  DynamicLoaderMacOSXDYLD(const DynamicLoaderMacOSXDYLD &) = delete;
+  const DynamicLoaderMacOSXDYLD &
+  operator=(const DynamicLoaderMacOSXDYLD &) = delete;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_DYNAMICLOADER_MACOSX_DYLD_DYNAMICLOADERMACOSXDYLD_H

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

protected:
   void EvalSpecialModulesStatus();
 
   /// Loads Module from inferior process.
   void ResolveExecutableModule(lldb::ModuleSP &module_sp);
 
   bool AlwaysRelyOnEHUnwindInfo(lldb_private::SymbolContext &sym_ctx) override;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(DynamicLoaderPOSIXDYLD);
+  DynamicLoaderPOSIXDYLD(const DynamicLoaderPOSIXDYLD &) = delete;
+  const DynamicLoaderPOSIXDYLD &
+  operator=(const DynamicLoaderPOSIXDYLD &) = delete;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_DYNAMICLOADER_POSIX_DYLD_DYNAMICLOADERPOSIXDYLD_H

lldb/source/Plugins/DynamicLoader/Static/DynamicLoaderStatic.h

public:
   // PluginInterface protocol
   lldb_private::ConstString GetPluginName() override;
 
   uint32_t GetPluginVersion() override;
 
 private:
   void LoadAllImagesAtFileAddresses();
 
-  DISALLOW_COPY_AND_ASSIGN(DynamicLoaderStatic);
+  DynamicLoaderStatic(const DynamicLoaderStatic &) = delete;
+  const DynamicLoaderStatic &operator=(const DynamicLoaderStatic &) = delete;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_DYNAMICLOADER_STATIC_DYNAMICLOADERSTATIC_H

lldb/source/Plugins/ExpressionParser/Clang/ClangDeclVendor.h

uint32_t FindDecls(ConstString name, bool append, uint32_t max_matches,
                      std::vector<clang::NamedDecl *> &decls);
 
   static bool classof(const DeclVendor *vendor) {
     return vendor->GetKind() >= eClangDeclVendor &&
            vendor->GetKind() < eLastClangDeclVendor;
   }
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(ClangDeclVendor);
+  ClangDeclVendor(const ClangDeclVendor &) = delete;
+  const ClangDeclVendor &operator=(const ClangDeclVendor &) = delete;
 };
 } // namespace lldb_private
 
 #endif

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

public:
     TargetInfo m_target_info;      ///< Basic information about the target.
     Materializer *m_materializer = nullptr;   ///< If non-NULL, the materializer
                                               ///to use when reporting used
                                               ///variables.
     clang::ASTConsumer *m_code_gen = nullptr; ///< If non-NULL, a code generator
                                               ///that receives new top-level
                                               ///functions.
   private:
-    DISALLOW_COPY_AND_ASSIGN(ParserVars);
+    ParserVars(const ParserVars &) = delete;
+    const ParserVars &operator=(const ParserVars &) = delete;
   };
 
   std::unique_ptr<ParserVars> m_parser_vars;
 
   /// Activate parser-specific variables
   void EnableParserVars() {
     if (!m_parser_vars.get())
       m_parser_vars = std::make_unique<ParserVars>();

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionVariable.h

public:
   TypeFromUser GetTypeFromUser();
 
   // llvm casting support
   static bool classof(const ExpressionVariable *ev) {
     return ev->getKind() == ExpressionVariable::eKindClang;
   }
 
   /// Members
-  DISALLOW_COPY_AND_ASSIGN(ClangExpressionVariable);
+  ClangExpressionVariable(const ClangExpressionVariable &) = delete;
+  const ClangExpressionVariable &
+  operator=(const ClangExpressionVariable &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_CLANGEXPRESSIONVARIABLE_H

lldb/source/Plugins/Instruction/ARM/EmulationStateARM.h

struct _sd_regs {
     uint64_t d_regs[16]; // dregs 16-31
 
   } m_vfp_regs;
 
   std::map<lldb::addr_t, uint32_t> m_memory; // Eventually will want to change
                                              // uint32_t to a data buffer heap
                                              // type.
 
-  DISALLOW_COPY_AND_ASSIGN(EmulationStateARM);
+  EmulationStateARM(const EmulationStateARM &) = delete;
+  const EmulationStateARM &operator=(const EmulationStateARM &) = delete;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_INSTRUCTION_ARM_EMULATIONSTATEARM_H

lldb/source/Plugins/LanguageRuntime/CPlusPlus/CPPLanguageRuntime.h

protected:
   CPPLanguageRuntime(Process *process);
 
 private:
   using OperatorStringToCallableInfoMap =
     llvm::StringMap<CPPLanguageRuntime::LibCppStdFunctionCallableInfo>;
 
   OperatorStringToCallableInfoMap CallableLookupCache;
 
-  DISALLOW_COPY_AND_ASSIGN(CPPLanguageRuntime);
+  CPPLanguageRuntime(const CPPLanguageRuntime &) = delete;
+  const CPPLanguageRuntime &operator=(const CPPLanguageRuntime &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_LANGUAGERUNTIME_CPLUSPLUS_CPPLANGUAGERUNTIME_H

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

private:
     uint64_t m_objc_debug_indexed_isa_index_mask;
     uint64_t m_objc_debug_indexed_isa_index_shift;
     lldb::addr_t m_objc_indexed_classes;
 
     std::vector<lldb::addr_t> m_indexed_isa_cache;
 
     friend class AppleObjCRuntimeV2;
 
-    DISALLOW_COPY_AND_ASSIGN(NonPointerISACache);
+    NonPointerISACache(const NonPointerISACache &) = delete;
+    const NonPointerISACache &operator=(const NonPointerISACache &) = delete;
   };
 
   class TaggedPointerVendorV2
       : public ObjCLanguageRuntime::TaggedPointerVendor {
   public:
     ~TaggedPointerVendorV2() override = default;
 
     static TaggedPointerVendorV2 *
     CreateInstance(AppleObjCRuntimeV2 &runtime,
                    const lldb::ModuleSP &objc_module_sp);
 
   protected:
     AppleObjCRuntimeV2 &m_runtime;
 
     TaggedPointerVendorV2(AppleObjCRuntimeV2 &runtime)
         : TaggedPointerVendor(), m_runtime(runtime) {}
 
   private:
-    DISALLOW_COPY_AND_ASSIGN(TaggedPointerVendorV2);
+    TaggedPointerVendorV2(const TaggedPointerVendorV2 &) = delete;
+    const TaggedPointerVendorV2 &
+    operator=(const TaggedPointerVendorV2 &) = delete;
   };
 
   class TaggedPointerVendorRuntimeAssisted : public TaggedPointerVendorV2 {
   public:
     bool IsPossibleTaggedPointer(lldb::addr_t ptr) override;
 
     ObjCLanguageRuntime::ClassDescriptorSP
     GetClassDescriptor(lldb::addr_t ptr) override;
protected:
     uint32_t m_objc_debug_taggedpointer_slot_shift;
     uint32_t m_objc_debug_taggedpointer_slot_mask;
     uint32_t m_objc_debug_taggedpointer_payload_lshift;
     uint32_t m_objc_debug_taggedpointer_payload_rshift;
     lldb::addr_t m_objc_debug_taggedpointer_classes;
 
     friend class AppleObjCRuntimeV2::TaggedPointerVendorV2;
 
-    DISALLOW_COPY_AND_ASSIGN(TaggedPointerVendorRuntimeAssisted);
+    TaggedPointerVendorRuntimeAssisted(
+        const TaggedPointerVendorRuntimeAssisted &) = delete;
+    const TaggedPointerVendorRuntimeAssisted &
+    operator=(const TaggedPointerVendorRuntimeAssisted &) = delete;
   };
 
   class TaggedPointerVendorExtended
       : public TaggedPointerVendorRuntimeAssisted {
   public:
     ObjCLanguageRuntime::ClassDescriptorSP
     GetClassDescriptor(lldb::addr_t ptr) override;
 
protected:
     uint32_t m_objc_debug_taggedpointer_ext_slot_shift;
     uint32_t m_objc_debug_taggedpointer_ext_slot_mask;
     uint32_t m_objc_debug_taggedpointer_ext_payload_lshift;
     uint32_t m_objc_debug_taggedpointer_ext_payload_rshift;
     lldb::addr_t m_objc_debug_taggedpointer_ext_classes;
 
     friend class AppleObjCRuntimeV2::TaggedPointerVendorV2;
 
-    DISALLOW_COPY_AND_ASSIGN(TaggedPointerVendorExtended);
+    TaggedPointerVendorExtended(const TaggedPointerVendorExtended &) = delete;
+    const TaggedPointerVendorExtended &
+    operator=(const TaggedPointerVendorExtended &) = delete;
   };
 
   class TaggedPointerVendorLegacy : public TaggedPointerVendorV2 {
   public:
     bool IsPossibleTaggedPointer(lldb::addr_t ptr) override;
 
     ObjCLanguageRuntime::ClassDescriptorSP
     GetClassDescriptor(lldb::addr_t ptr) override;
 
   protected:
     TaggedPointerVendorLegacy(AppleObjCRuntimeV2 &runtime)
         : TaggedPointerVendorV2(runtime) {}
 
     friend class AppleObjCRuntimeV2::TaggedPointerVendorV2;
 
-    DISALLOW_COPY_AND_ASSIGN(TaggedPointerVendorLegacy);
+    TaggedPointerVendorLegacy(const TaggedPointerVendorLegacy &) = delete;
+    const TaggedPointerVendorLegacy &
+    operator=(const TaggedPointerVendorLegacy &) = delete;
   };
 
   struct DescriptorMapUpdateResult {
     bool m_update_ran;
     uint32_t m_num_found;
 
     DescriptorMapUpdateResult(bool ran, uint32_t found) {
       m_update_ran = ran;

lldb/source/Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h

public:
 
     virtual ObjCLanguageRuntime::ClassDescriptorSP
     GetClassDescriptor(lldb::addr_t ptr) = 0;
 
   protected:
     TaggedPointerVendor() = default;
 
   private:
-    DISALLOW_COPY_AND_ASSIGN(TaggedPointerVendor);
+    TaggedPointerVendor(const TaggedPointerVendor &) = delete;
+    const TaggedPointerVendor &operator=(const TaggedPointerVendor &) = delete;
   };
 
   ~ObjCLanguageRuntime() override;
 
   static char ID;
 
   bool isA(const void *ClassID) const override {
     return ClassID == &ID || LanguageRuntime::isA(ClassID);
protected:
 
   friend class ::CommandObjectObjC_ClassTable_Dump;
 
   std::pair<ISAToDescriptorIterator, ISAToDescriptorIterator>
   GetDescriptorIteratorPair(bool update_if_needed = true);
 
   void ReadObjCLibraryIfNeeded(const ModuleList &module_list);
 
-  DISALLOW_COPY_AND_ASSIGN(ObjCLanguageRuntime);
+  ObjCLanguageRuntime(const ObjCLanguageRuntime &) = delete;
+  const ObjCLanguageRuntime &operator=(const ObjCLanguageRuntime &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_LANGUAGERUNTIME_OBJC_OBJCLANGUAGERUNTIME_H

lldb/source/Plugins/Platform/Android/PlatformAndroid.h

 
 private:
   AdbClient::SyncService *GetSyncService(Status &error);
 
   std::unique_ptr<AdbClient::SyncService> m_adb_sync_svc;
   std::string m_device_id;
   uint32_t m_sdk_version;
 
-  DISALLOW_COPY_AND_ASSIGN(PlatformAndroid);
+  PlatformAndroid(const PlatformAndroid &) = delete;
+  const PlatformAndroid &operator=(const PlatformAndroid &) = delete;
 };
 
 } // namespace platofor_android
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_PLATFORM_ANDROID_PLATFORMANDROID_H

lldb/source/Plugins/Platform/Android/PlatformAndroidRemoteGDBServer.h

protected:
 
   void DeleteForwardPort(lldb::pid_t pid);
 
   Status MakeConnectURL(const lldb::pid_t pid, const uint16_t remote_port,
                         llvm::StringRef remote_socket_name,
                         std::string &connect_url);
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(PlatformAndroidRemoteGDBServer);
+  PlatformAndroidRemoteGDBServer(const PlatformAndroidRemoteGDBServer &) =
+      delete;
+  const PlatformAndroidRemoteGDBServer &
+  operator=(const PlatformAndroidRemoteGDBServer &) = delete;
 };
 
 } // namespace platform_android
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_PLATFORM_ANDROID_PLATFORMANDROIDREMOTEGDBSERVER_H

lldb/source/Plugins/Platform/FreeBSD/PlatformFreeBSD.h

public:
   void CalculateTrapHandlerSymbolNames() override;
 
   MmapArgList GetMmapArgumentList(const ArchSpec &arch, lldb::addr_t addr,
                                   lldb::addr_t length, unsigned prot,
                                   unsigned flags, lldb::addr_t fd,
                                   lldb::addr_t offset) override;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(PlatformFreeBSD);
+  PlatformFreeBSD(const PlatformFreeBSD &) = delete;
+  const PlatformFreeBSD &operator=(const PlatformFreeBSD &) = delete;
 };
 
 } // namespace platform_freebsd
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_PLATFORM_FREEBSD_PLATFORMFREEBSD_H

lldb/source/Plugins/Platform/Linux/PlatformLinux.h

public:
   void CalculateTrapHandlerSymbolNames() override;
 
   MmapArgList GetMmapArgumentList(const ArchSpec &arch, lldb::addr_t addr,
                                   lldb::addr_t length, unsigned prot,
                                   unsigned flags, lldb::addr_t fd,
                                   lldb::addr_t offset) override;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(PlatformLinux);
+  PlatformLinux(const PlatformLinux &) = delete;
+  const PlatformLinux &operator=(const PlatformLinux &) = delete;
 };
 
 } // namespace platform_linux
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_PLATFORM_LINUX_PLATFORMLINUX_H

lldb/source/Plugins/Platform/MacOSX/PlatformAppleSimulator.h

protected:
 
   void LoadCoreSimulator();
 
 #if defined(__APPLE__)
   CoreSimulatorSupport::Device GetSimulatorDevice();
 #endif
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(PlatformAppleSimulator);
+  PlatformAppleSimulator(const PlatformAppleSimulator &) = delete;
+  const PlatformAppleSimulator &
+  operator=(const PlatformAppleSimulator &) = delete;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_PLATFORM_MACOSX_PLATFORMAPPLESIMULATOR_H

lldb/source/Plugins/Platform/MacOSX/PlatformAppleTVSimulator.h

 protected:
   std::mutex m_sdk_dir_mutex;
   std::string m_sdk_directory;
   std::string m_build_update;
 
   const char *GetSDKDirectoryAsCString();
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(PlatformAppleTVSimulator);
+  PlatformAppleTVSimulator(const PlatformAppleTVSimulator &) = delete;
+  const PlatformAppleTVSimulator &
+  operator=(const PlatformAppleTVSimulator &) = delete;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_PLATFORM_MACOSX_PLATFORMAPPLETVSIMULATOR_H

lldb/source/Plugins/Platform/MacOSX/PlatformAppleWatchSimulator.h

 protected:
   std::mutex m_sdk_dir_mutex;
   std::string m_sdk_directory;
   std::string m_build_update;
 
   const char *GetSDKDirectoryAsCString();
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(PlatformAppleWatchSimulator);
+  PlatformAppleWatchSimulator(const PlatformAppleWatchSimulator &) = delete;
+  const PlatformAppleWatchSimulator &
+  operator=(const PlatformAppleWatchSimulator &) = delete;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_PLATFORM_MACOSX_PLATFORMAPPLEWATCHSIMULATOR_H

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

static std::string FindComponentInPath(llvm::StringRef path,
                                          llvm::StringRef component);
   static std::string FindXcodeContentsDirectoryInPath(llvm::StringRef path);
 
   std::string m_developer_directory;
   llvm::StringMap<std::string> m_sdk_path;
   std::mutex m_sdk_path_mutex;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(PlatformDarwin);
+  PlatformDarwin(const PlatformDarwin &) = delete;
+  const PlatformDarwin &operator=(const PlatformDarwin &) = delete;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_PLATFORM_MACOSX_PLATFORMDARWIN_H

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

KernelBinaryCollection m_kernel_binaries_with_dsyms; // list of kernel
                                                        // them
   KernelBinaryCollection m_kernel_binaries_without_dsyms; // list of kernel
                                                           // binaries we found
                                                           // on local
                                                           // filesystem, with
                                                           // dSYMs next to them
   lldb_private::LazyBool m_ios_debug_session;
 
-  DISALLOW_COPY_AND_ASSIGN(PlatformDarwinKernel);
+  PlatformDarwinKernel(const PlatformDarwinKernel &) = delete;
+  const PlatformDarwinKernel &operator=(const PlatformDarwinKernel &) = delete;
 };
 
 #else // __APPLE__
 
 // Since DynamicLoaderDarwinKernel is compiled in for all systems, and relies on
 // PlatformDarwinKernel for the plug-in name, we compile just the plug-in name
 // in
 // here to avoid issues. We are tracking an internal bug to resolve this issue

lldb/source/Plugins/Platform/MacOSX/PlatformMacOSX.h

public:
   void
   AddClangModuleCompilationOptions(lldb_private::Target *target,
                                    std::vector<std::string> &options) override {
     return PlatformDarwin::AddClangModuleCompilationOptionsForSDKType(
         target, options, lldb_private::XcodeSDK::Type::MacOSX);
   }
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(PlatformMacOSX);
+  PlatformMacOSX(const PlatformMacOSX &) = delete;
+  const PlatformMacOSX &operator=(const PlatformMacOSX &) = delete;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_PLATFORM_MACOSX_PLATFORMMACOSX_H

lldb/source/Plugins/Platform/MacOSX/PlatformRemoteAppleBridge.h

protected:
 
   // lldb_private::PlatformRemoteDarwinDevice functions
 
   void GetDeviceSupportDirectoryNames (std::vector<std::string> &dirnames) override;
 
   std::string GetPlatformName () override;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(PlatformRemoteAppleBridge);
+  PlatformRemoteAppleBridge(const PlatformRemoteAppleBridge &) = delete;
+  const PlatformRemoteAppleBridge &
+  operator=(const PlatformRemoteAppleBridge &) = delete;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_PLATFORM_MACOSX_PLATFORMREMOTEAPPLEBRIDGE_H

lldb/source/Plugins/Platform/MacOSX/PlatformRemoteAppleTV.h

protected:
 
   // lldb_private::PlatformRemoteDarwinDevice functions
 
   void GetDeviceSupportDirectoryNames (std::vector<std::string> &dirnames) override;
 
   std::string GetPlatformName () override;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(PlatformRemoteAppleTV);
+  PlatformRemoteAppleTV(const PlatformRemoteAppleTV &) = delete;
+  const PlatformRemoteAppleTV &
+  operator=(const PlatformRemoteAppleTV &) = delete;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_PLATFORM_MACOSX_PLATFORMREMOTEAPPLETV_H

lldb/source/Plugins/Platform/MacOSX/PlatformRemoteAppleWatch.h

protected:
 
   // lldb_private::PlatformRemoteDarwinDevice functions
 
   void GetDeviceSupportDirectoryNames (std::vector<std::string> &dirnames) override;
 
   std::string GetPlatformName () override;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(PlatformRemoteAppleWatch);
+  PlatformRemoteAppleWatch(const PlatformRemoteAppleWatch &) = delete;
+  const PlatformRemoteAppleWatch &
+  operator=(const PlatformRemoteAppleWatch &) = delete;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_PLATFORM_MACOSX_PLATFORMREMOTEAPPLEWATCH_H

lldb/source/Plugins/Platform/MacOSX/PlatformRemoteDarwinDevice.h

protected:
   uint32_t GetSDKIndexBySDKDirectoryInfo(const SDKDirectoryInfo *sdk_info);
 
 
   virtual void GetDeviceSupportDirectoryNames (std::vector<std::string> &dirnames) = 0;
 
   virtual std::string GetPlatformName () = 0;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(PlatformRemoteDarwinDevice);
+  PlatformRemoteDarwinDevice(const PlatformRemoteDarwinDevice &) = delete;
+  const PlatformRemoteDarwinDevice &
+  operator=(const PlatformRemoteDarwinDevice &) = delete;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_PLATFORM_MACOSX_PLATFORMREMOTEDARWINDEVICE_H

lldb/source/Plugins/Platform/MacOSX/PlatformRemoteiOS.h

protected:
 
   // lldb_private::PlatformRemoteDarwinDevice functions
 
   void GetDeviceSupportDirectoryNames (std::vector<std::string> &dirnames) override;
 
   std::string GetPlatformName () override;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(PlatformRemoteiOS);
+  PlatformRemoteiOS(const PlatformRemoteiOS &) = delete;
+  const PlatformRemoteiOS &operator=(const PlatformRemoteiOS &) = delete;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_PLATFORM_MACOSX_PLATFORMREMOTEIOS_H

lldb/source/Plugins/Platform/MacOSX/PlatformiOSSimulator.h

 protected:
   std::mutex m_sdk_dir_mutex;
   std::string m_sdk_directory;
   std::string m_build_update;
 
   const char *GetSDKDirectoryAsCString();
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(PlatformiOSSimulator);
+  PlatformiOSSimulator(const PlatformiOSSimulator &) = delete;
+  const PlatformiOSSimulator &operator=(const PlatformiOSSimulator &) = delete;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_PLATFORM_MACOSX_PLATFORMIOSSIMULATOR_H

lldb/source/Plugins/Platform/NetBSD/PlatformNetBSD.h

public:
   void CalculateTrapHandlerSymbolNames() override;
 
   MmapArgList GetMmapArgumentList(const ArchSpec &arch, lldb::addr_t addr,
                                   lldb::addr_t length, unsigned prot,
                                   unsigned flags, lldb::addr_t fd,
                                   lldb::addr_t offset) override;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(PlatformNetBSD);
+  PlatformNetBSD(const PlatformNetBSD &) = delete;
+  const PlatformNetBSD &operator=(const PlatformNetBSD &) = delete;
 };
 
 } // namespace platform_netbsd
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_PLATFORM_NETBSD_PLATFORMNETBSD_H

lldb/source/Plugins/Platform/OpenBSD/PlatformOpenBSD.h

public:
   void CalculateTrapHandlerSymbolNames() override;
 
   MmapArgList GetMmapArgumentList(const ArchSpec &arch, lldb::addr_t addr,
                                   lldb::addr_t length, unsigned prot,
                                   unsigned flags, lldb::addr_t fd,
                                   lldb::addr_t offset) override;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(PlatformOpenBSD);
+  PlatformOpenBSD(const PlatformOpenBSD &) = delete;
+  const PlatformOpenBSD &operator=(const PlatformOpenBSD &) = delete;
 };
 
 } // namespace platform_openbsd
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_PLATFORM_OPENBSD_PLATFORMOPENBSD_H

lldb/source/Plugins/Platform/POSIX/PlatformPOSIX.h

protected:
   std::unique_ptr<lldb_private::UtilityFunction>
   MakeLoadImageUtilityFunction(lldb_private::ExecutionContext &exe_ctx,
                                lldb_private::Status &error);
 
   virtual
   llvm::StringRef GetLibdlFunctionDeclarations(lldb_private::Process *process);
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(PlatformPOSIX);
+  PlatformPOSIX(const PlatformPOSIX &) = delete;
+  const PlatformPOSIX &operator=(const PlatformPOSIX &) = delete;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_PLATFORM_POSIX_PLATFORMPOSIX_H

lldb/source/Plugins/Platform/Windows/PlatformWindows.h

public:
   bool CanDebugProcess() override;
 
   // FIXME not sure what the _sigtramp equivalent would be on this platform
   void CalculateTrapHandlerSymbolNames() override {}
 
   ConstString GetFullNameForDylib(ConstString basename) override;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(PlatformWindows);
+  PlatformWindows(const PlatformWindows &) = delete;
+  const PlatformWindows &operator=(const PlatformWindows &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_PLATFORM_WINDOWS_PLATFORMWINDOWS_H

lldb/source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.h

 private:
   std::string MakeGdbServerUrl(const std::string &platform_scheme,
                                const std::string &platform_hostname,
                                uint16_t port, const char *socket_name);
 
   llvm::Optional<std::string> DoGetUserName(UserIDResolver::id_t uid) override;
   llvm::Optional<std::string> DoGetGroupName(UserIDResolver::id_t uid) override;
 
-  DISALLOW_COPY_AND_ASSIGN(PlatformRemoteGDBServer);
+  PlatformRemoteGDBServer(const PlatformRemoteGDBServer &) = delete;
+  const PlatformRemoteGDBServer &
+  operator=(const PlatformRemoteGDBServer &) = delete;
 };
 
 } // namespace platform_gdb_server
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_PLATFORM_GDB_SERVER_PLATFORMREMOTEGDBSERVER_H

lldb/source/Plugins/Process/MacOSX-Kernel/CommunicationKDP.h

protected:
   uint32_t m_kdp_hostinfo_cpu_type;
   uint32_t m_kdp_hostinfo_cpu_subtype;
   std::string m_kernel_version;
   // std::string m_image_path; // Disable KDP_IMAGEPATH for now, it seems to
   // hang the KDP connection...
   lldb::addr_t m_last_read_memory_addr; // Last memory read address for logging
 private:
   // For CommunicationKDP only
-  DISALLOW_COPY_AND_ASSIGN(CommunicationKDP);
+  CommunicationKDP(const CommunicationKDP &) = delete;
+  const CommunicationKDP &operator=(const CommunicationKDP &) = delete;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_PROCESS_MACOSX_KERNEL_COMMUNICATIONKDP_H

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

protected:
 
   void StopAsyncThread();
 
   static void *AsyncThread(void *arg);
 
 private:
   // For ProcessKDP only
 
-  DISALLOW_COPY_AND_ASSIGN(ProcessKDP);
+  ProcessKDP(const ProcessKDP &) = delete;
+  const ProcessKDP &operator=(const ProcessKDP &) = delete;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_PROCESS_MACOSX_KERNEL_PROCESSKDP_H

lldb/source/Plugins/Process/Utility/RegisterContextDummy.h

uint32_t ConvertRegisterKindToRegisterNumber(lldb::RegisterKind kind,
                                                uint32_t num) override;
 
 private:
   // For RegisterContextLLDB only
 
   lldb_private::RegisterSet m_reg_set0; // register set 0 (PC only)
   lldb_private::RegisterInfo m_pc_reg_info;
 
-  DISALLOW_COPY_AND_ASSIGN(RegisterContextDummy);
+  RegisterContextDummy(const RegisterContextDummy &) = delete;
+  const RegisterContextDummy &operator=(const RegisterContextDummy &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_REGISTERCONTEXTDUMMY_H

lldb/source/Plugins/Process/Utility/RegisterContextHistory.h

 private:
   // For RegisterContextLLDB only
 
   lldb_private::RegisterSet m_reg_set0; // register set 0 (PC only)
   lldb_private::RegisterInfo m_pc_reg_info;
 
   lldb::addr_t m_pc_value;
 
-  DISALLOW_COPY_AND_ASSIGN(RegisterContextHistory);
+  RegisterContextHistory(const RegisterContextHistory &) = delete;
+  const RegisterContextHistory &
+  operator=(const RegisterContextHistory &) = delete;
 };
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_REGISTERCONTEXTHISTORY_H

lldb/source/Plugins/Process/Utility/RegisterContextMemory.h

protected:
 
   DynamicRegisterInfo &m_reg_infos;
   std::vector<bool> m_reg_valid;
   lldb_private::DataExtractor m_reg_data;
   lldb::addr_t m_reg_data_addr; // If this is valid, then we have a register
                                 // context that is stored in memmory
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(RegisterContextMemory);
+  RegisterContextMemory(const RegisterContextMemory &) = delete;
+  const RegisterContextMemory &
+  operator=(const RegisterContextMemory &) = delete;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_REGISTERCONTEXTMEMORY_H

lldb/source/Plugins/Process/Utility/RegisterContextThreadMemory.h

protected:
   void UpdateRegisterContext();
 
   lldb::ThreadWP m_thread_wp;
   lldb::RegisterContextSP m_reg_ctx_sp;
   lldb::addr_t m_register_data_addr;
   uint32_t m_stop_id;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(RegisterContextThreadMemory);
+  RegisterContextThreadMemory(const RegisterContextThreadMemory &) = delete;
+  const RegisterContextThreadMemory &
+  operator=(const RegisterContextThreadMemory &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_REGISTERCONTEXTTHREADMEMORY_H

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

protected:
   // through the process plug-in.
   lldb::ThreadSP m_backing_thread_sp;
   lldb::ValueObjectSP m_thread_info_valobj_sp;
   std::string m_name;
   std::string m_queue;
   lldb::addr_t m_register_data_addr;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(ThreadMemory);
+  ThreadMemory(const ThreadMemory &) = delete;
+  const ThreadMemory &operator=(const ThreadMemory &) = delete;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_THREADMEMORY_H

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

private:
   typedef lldb_private::RangeDataVector<lldb::addr_t, lldb::addr_t, FileRange>
       VMRangeToFileOffset;
   typedef lldb_private::RangeDataVector<lldb::addr_t, lldb::addr_t, uint32_t>
       VMRangeToPermissions;
 
   lldb::ModuleSP m_core_module_sp;
   lldb_private::FileSpec m_core_file;
   std::string m_dyld_plugin_name;
-  DISALLOW_COPY_AND_ASSIGN(ProcessElfCore);
+  ProcessElfCore(const ProcessElfCore &) = delete;
+  const ProcessElfCore &operator=(const ProcessElfCore &) = delete;
 
   // True if m_thread_contexts contains valid entries
   bool m_thread_data_valid = false;
 
   // Contain thread data read from NOTE segments
   std::vector<ThreadData> m_thread_data;
 
   // AUXV structure found from the NOTE segment

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.h

private:
   HostThread m_listen_thread;
   std::string m_listen_url;
 
 #if defined(HAVE_LIBCOMPRESSION)
   CompressionType m_decompression_scratch_type = CompressionType::None;
   void *m_decompression_scratch = nullptr;
 #endif
 
-  DISALLOW_COPY_AND_ASSIGN(GDBRemoteCommunication);
+  GDBRemoteCommunication(const GDBRemoteCommunication &) = delete;
+  const GDBRemoteCommunication &
+  operator=(const GDBRemoteCommunication &) = delete;
 };
 
 } // namespace process_gdb_remote
 } // namespace lldb_private
 
 namespace llvm {
 template <>
 struct format_provider<
     lldb_private::process_gdb_remote::GDBRemoteCommunication::PacketResult> {
   static void format(const lldb_private::process_gdb_remote::
                          GDBRemoteCommunication::PacketResult &state,
                      raw_ostream &Stream, StringRef Style);
 };
 } // namespace llvm
 
 #endif // LLDB_SOURCE_PLUGINS_PROCESS_GDB_REMOTE_GDBREMOTECOMMUNICATION_H

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h

protected:
   Status LoadQXferMemoryMap();
 
   Status GetQXferMemoryMapRegionInfo(lldb::addr_t addr,
                                      MemoryRegionInfo &region);
 
   LazyBool GetThreadPacketSupported(lldb::tid_t tid, llvm::StringRef packetStr);
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(GDBRemoteCommunicationClient);
+  GDBRemoteCommunicationClient(const GDBRemoteCommunicationClient &) = delete;
+  const GDBRemoteCommunicationClient &
+  operator=(const GDBRemoteCommunicationClient &) = delete;
 };
 
 } // namespace process_gdb_remote
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_PROCESS_GDB_REMOTE_GDBREMOTECOMMUNICATIONCLIENT_H

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationReplayServer.h

protected:
   Broadcaster m_async_broadcaster;
   lldb::ListenerSP m_async_listener_sp;
   HostThread m_async_thread;
   std::recursive_mutex m_async_thread_state_mutex;
 
   bool m_skip_acks;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(GDBRemoteCommunicationReplayServer);
+  GDBRemoteCommunicationReplayServer(
+      const GDBRemoteCommunicationReplayServer &) = delete;
+  const GDBRemoteCommunicationReplayServer &
+  operator=(const GDBRemoteCommunicationReplayServer &) = delete;
 };
 
 } // namespace process_gdb_remote
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_PROCESS_GDB_REMOTE_GDBREMOTECOMMUNICATIONREPLAYSERVER_H

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServer.h

protected:
   PacketResult SendErrorResponse(uint8_t error);
 
   PacketResult SendIllFormedResponse(const StringExtractorGDBRemote &packet,
                                      const char *error_message);
 
   PacketResult SendOKResponse();
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(GDBRemoteCommunicationServer);
+  GDBRemoteCommunicationServer(const GDBRemoteCommunicationServer &) = delete;
+  const GDBRemoteCommunicationServer &
+  operator=(const GDBRemoteCommunicationServer &) = delete;
 };
 
 class PacketUnimplementedError
     : public llvm::ErrorInfo<PacketUnimplementedError, llvm::StringError> {
 public:
   static char ID;
   using llvm::ErrorInfo<PacketUnimplementedError,
                         llvm::StringError>::ErrorInfo; // inherit constructors

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.h

private:
 
   void SendProcessOutput();
 
   void StartSTDIOForwarding();
 
   void StopSTDIOForwarding();
 
   // For GDBRemoteCommunicationServerLLGS only
-  DISALLOW_COPY_AND_ASSIGN(GDBRemoteCommunicationServerLLGS);
+  GDBRemoteCommunicationServerLLGS(const GDBRemoteCommunicationServerLLGS &) =
+      delete;
+  const GDBRemoteCommunicationServerLLGS &
+  operator=(const GDBRemoteCommunicationServerLLGS &) = delete;
 };
 
 } // namespace process_gdb_remote
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_PROCESS_GDB_REMOTE_GDBREMOTECOMMUNICATIONSERVERLLGS_H

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.h

private:
   bool KillSpawnedProcess(lldb::pid_t pid);
 
   bool DebugserverProcessReaped(lldb::pid_t pid);
 
   static const FileSpec &GetDomainSocketDir();
 
   static FileSpec GetDomainSocketPath(const char *prefix);
 
-  DISALLOW_COPY_AND_ASSIGN(GDBRemoteCommunicationServerPlatform);
+  GDBRemoteCommunicationServerPlatform(
+      const GDBRemoteCommunicationServerPlatform &) = delete;
+  const GDBRemoteCommunicationServerPlatform &
+  operator=(const GDBRemoteCommunicationServerPlatform &) = delete;
 };
 
 } // namespace process_gdb_remote
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_PROCESS_GDB_REMOTE_GDBREMOTECOMMUNICATIONSERVERPLATFORM_H

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

 private:
   // Helper function for ReadRegisterBytes().
   bool GetPrimordialRegister(const RegisterInfo *reg_info,
                              GDBRemoteCommunicationClient &gdb_comm);
   // Helper function for WriteRegisterBytes().
   bool SetPrimordialRegister(const RegisterInfo *reg_info,
                              GDBRemoteCommunicationClient &gdb_comm);
 
-  DISALLOW_COPY_AND_ASSIGN(GDBRemoteRegisterContext);
+  GDBRemoteRegisterContext(const GDBRemoteRegisterContext &) = delete;
+  const GDBRemoteRegisterContext &
+  operator=(const GDBRemoteRegisterContext &) = delete;
 };
 
 } // namespace process_gdb_remote
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_PROCESS_GDB_REMOTE_GDBREMOTEREGISTERCONTEXT_H

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

struct ModuleCacheInfo {
     static bool isEqual(const ModuleCacheKey &LHS, const ModuleCacheKey &RHS) {
       return LHS == RHS;
     }
   };
 
   llvm::DenseMap<ModuleCacheKey, ModuleSpec, ModuleCacheInfo>
       m_cached_module_specs;
 
-  DISALLOW_COPY_AND_ASSIGN(ProcessGDBRemote);
+  ProcessGDBRemote(const ProcessGDBRemote &) = delete;
+  const ProcessGDBRemote &operator=(const ProcessGDBRemote &) = delete;
 };
 
 } // namespace process_gdb_remote
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_PROCESS_GDB_REMOTE_PROCESSGDBREMOTE_H

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

private:
   VMRangeToFileOffset m_core_aranges;
   VMRangeToPermissions m_core_range_infos;
   lldb::ModuleSP m_core_module_sp;
   lldb_private::FileSpec m_core_file;
   lldb::addr_t m_dyld_addr;
   lldb::addr_t m_mach_kernel_addr;
   lldb_private::ConstString m_dyld_plugin_name;
 
-  DISALLOW_COPY_AND_ASSIGN(ProcessMachCore);
+  ProcessMachCore(const ProcessMachCore &) = delete;
+  const ProcessMachCore &operator=(const ProcessMachCore &) = delete;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_PROCESS_MACH_CORE_PROCESSMACHCORE_H

lldb/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.h

~StructuredPythonObject() override {
     SetValue(nullptr);
   }
 
   bool IsValid() const override { return GetValue() && GetValue() != Py_None; }
 
   void Serialize(llvm::json::OStream &s) const override;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(StructuredPythonObject);
+  StructuredPythonObject(const StructuredPythonObject &) = delete;
+  const StructuredPythonObject &
+  operator=(const StructuredPythonObject &) = delete;
 };
 
 enum class PyObjectType {
   Unknown,
   None,
   Boolean,
   Integer,
   Dictionary,

lldb/source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.h

 
 private:
   DWARFCompileUnit(SymbolFileDWARF &dwarf, lldb::user_id_t uid,
                    const DWARFUnitHeader &header,
                    const DWARFAbbreviationDeclarationSet &abbrevs,
                    DIERef::Section section, bool is_dwo)
       : DWARFUnit(dwarf, uid, header, abbrevs, section, is_dwo) {}
 
-  DISALLOW_COPY_AND_ASSIGN(DWARFCompileUnit);
+  DWARFCompileUnit(const DWARFCompileUnit &) = delete;
+  const DWARFCompileUnit &operator=(const DWARFCompileUnit &) = delete;
 
   friend class DWARFUnit;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFCOMPILEUNIT_H

lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.h

private:
   // All parsing needs to be done partially any managed by this class as
   // accessors are called.
   void ParseUnitHeadersIfNeeded();
 
   void ParseUnitsFor(DIERef::Section section);
 
   uint32_t FindUnitIndex(DIERef::Section section, dw_offset_t offset);
 
-  DISALLOW_COPY_AND_ASSIGN(DWARFDebugInfo);
+  DWARFDebugInfo(const DWARFDebugInfo &) = delete;
+  const DWARFDebugInfo &operator=(const DWARFDebugInfo &) = delete;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFDEBUGINFO_H

lldb/source/Plugins/SymbolFile/DWARF/DWARFUnit.h

public:
   void ExtractDIEsIfNeeded();
 
   class ScopedExtractDIEs {
     DWARFUnit *m_cu;
   public:
     bool m_clear_dies = false;
     ScopedExtractDIEs(DWARFUnit &cu);
     ~ScopedExtractDIEs();
-    DISALLOW_COPY_AND_ASSIGN(ScopedExtractDIEs);
+    ScopedExtractDIEs(const ScopedExtractDIEs &) = delete;
+    const ScopedExtractDIEs &operator=(const ScopedExtractDIEs &) = delete;
     ScopedExtractDIEs(ScopedExtractDIEs &&rhs);
     ScopedExtractDIEs &operator=(ScopedExtractDIEs &&rhs);
   };
   ScopedExtractDIEs ExtractDIEsScoped();
 
   DWARFDIE LookupAddress(const dw_addr_t address);
   bool Verify(lldb_private::Stream *s) const;
   virtual void Dump(lldb_private::Stream *s) const = 0;
private:
   void ClearDIEsRWLocked();
 
   void AddUnitDIE(const DWARFDebugInfoEntry &cu_die);
   void SetDwoStrOffsetsBase();
 
   void ComputeCompDirAndGuessPathStyle();
   void ComputeAbsolutePath();
 
-  DISALLOW_COPY_AND_ASSIGN(DWARFUnit);
+  DWARFUnit(const DWARFUnit &) = delete;
+  const DWARFUnit &operator=(const DWARFUnit &) = delete;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFUNIT_H

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

typedef llvm::DenseMap<const DWARFDebugInfoEntry *, lldb_private::Type *>
       DIEToTypePtr;
   typedef llvm::DenseMap<const DWARFDebugInfoEntry *, lldb::VariableSP>
       DIEToVariableSP;
   typedef llvm::DenseMap<const DWARFDebugInfoEntry *,
                          lldb::opaque_compiler_type_t>
       DIEToClangType;
   typedef llvm::DenseMap<lldb::opaque_compiler_type_t, DIERef> ClangTypeToDIE;
 
-  DISALLOW_COPY_AND_ASSIGN(SymbolFileDWARF);
+  SymbolFileDWARF(const SymbolFileDWARF &) = delete;
+  const SymbolFileDWARF &operator=(const SymbolFileDWARF &) = delete;
 
   virtual void LoadSectionData(lldb::SectionType sect_type,
                                lldb_private::DWARFDataExtractor &data);
 
   bool DeclContextMatchesThisSymbolFile(
       const lldb_private::CompilerDeclContext &decl_ctx);
 
   uint32_t CalculateNumCompileUnits() override;

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

protected:
   lldb_private::Symtab::IndexCollection m_source_indexes;
   lldb_private::Symtab::IndexCollection m_func_indexes;
   lldb_private::Symtab::IndexCollection m_code_indexes;
   lldb_private::Symtab::IndexCollection m_data_indexes;
   lldb_private::Symtab::NameToIndexMap m_objc_class_name_to_index;
   TypeMap m_objc_class_types;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(SymbolFileSymtab);
+  SymbolFileSymtab(const SymbolFileSymtab &) = delete;
+  const SymbolFileSymtab &operator=(const SymbolFileSymtab &) = delete;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_SYMTAB_SYMBOLFILESYMTAB_H

lldb/source/Plugins/SymbolVendor/ELF/SymbolVendorELF.h

CreateInstance(const lldb::ModuleSP &module_sp,
                  lldb_private::Stream *feedback_strm);
 
   // PluginInterface protocol
   lldb_private::ConstString GetPluginName() override;
 
   uint32_t GetPluginVersion() override;
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(SymbolVendorELF);
+  SymbolVendorELF(const SymbolVendorELF &) = delete;
+  const SymbolVendorELF &operator=(const SymbolVendorELF &) = delete;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLVENDOR_ELF_SYMBOLVENDORELF_H

lldb/source/Plugins/SymbolVendor/MacOSX/SymbolVendorMacOSX.h

public:
   virtual ~SymbolVendorMacOSX();
 
   // PluginInterface protocol
   virtual lldb_private::ConstString GetPluginName();
 
   virtual uint32_t GetPluginVersion();
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(SymbolVendorMacOSX);
+  SymbolVendorMacOSX(const SymbolVendorMacOSX &) = delete;
+  const SymbolVendorMacOSX &operator=(const SymbolVendorMacOSX &) = delete;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLVENDOR_MACOSX_SYMBOLVENDORMACOSX_H

lldb/source/Plugins/SymbolVendor/wasm/SymbolVendorWasm.h

public:
 
   /// PluginInterface protocol.
   /// \{
   lldb_private::ConstString GetPluginName() override;
   uint32_t GetPluginVersion() override;
   /// \}
 
 private:
-  DISALLOW_COPY_AND_ASSIGN(SymbolVendorWasm);
+  SymbolVendorWasm(const SymbolVendorWasm &) = delete;
+  const SymbolVendorWasm &operator=(const SymbolVendorWasm &) = delete;
 };
 
 } // namespace wasm
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLVENDOR_WASM_SYMBOLVENDORWASM_H

lldb/source/Plugins/SystemRuntime/MacOSX/SystemRuntimeMacOSX.h

private:
   struct LibpthreadOffsets m_libpthread_offsets;
 
   lldb::addr_t m_dispatch_tsd_indexes_addr;
   struct LibdispatchTSDIndexes m_libdispatch_tsd_indexes;
 
   lldb::addr_t m_dispatch_voucher_offsets_addr;
   struct LibdispatchVoucherOffsets m_libdispatch_voucher_offsets;
 
-  DISALLOW_COPY_AND_ASSIGN(SystemRuntimeMacOSX);
+  SystemRuntimeMacOSX(const SystemRuntimeMacOSX &) = delete;
+  const SystemRuntimeMacOSX &operator=(const SystemRuntimeMacOSX &) = delete;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_SYSTEMRUNTIME_MACOSX_SYSTEMRUNTIMEMACOSX_H

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

private:
   lldb_private::ArchSpec m_arch;
   CPU m_cpu;
   int m_wordsize;
 
   bool m_register_map_initialized;
 
   ::LLVMDisasmContextRef m_disasm_context;
 
-  DISALLOW_COPY_AND_ASSIGN(x86AssemblyInspectionEngine);
+  x86AssemblyInspectionEngine(const x86AssemblyInspectionEngine &) = delete;
+  const x86AssemblyInspectionEngine &
+  operator=(const x86AssemblyInspectionEngine &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_UNWINDASSEMBLY_X86_X86ASSEMBLYINSPECTIONENGINE_H