[lldb] Replace default bodies of special member functions with = default;

[JDevlieghere]

Summary

Replace default bodies of special member functions with = default;

$ run-clang-tidy.py -header-filter='lldb' -checks='-*,modernize-use-equals-default' -fix ,

https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-equals-default.html

[JDevlieghere]

lldb/include/lldb/Interpreter/CommandInterpreter.h

102–103

Interesting, I would've expected clang-format to get this.

[teemperor]

LGTM beside some minor formatting bugs that got exacerbated by the clang-tidy run. I got bored of writing 'format' everywhere so I translated every comment into a different language via Google translate. I'll already accept this as this is easy to fix.

lldb/include/lldb/Expression/ExpressionParser.h

45

Please drop that when you land it.

lldb/include/lldb/Target/Process.h

227

format

lldb/include/lldb/Target/StackFrameRecognizer.h

41

please remove that pointy boy

67

and that one too

lldb/source/Interpreter/OptionValueFileColonLine.cpp

24

formaat

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

219

formato

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

111

formatione

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

50

goodbye

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

58

フォーマット

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

55

хэлбэр хэмжээ

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

193

formoup

215

isimo

[JDevlieghere]

Mi traktis la komentojn

lldb/include/lldb/Expression/ExpressionParser.h

45

Dropped.

lldb/include/lldb/Target/Process.h

227

formatted

lldb/include/lldb/Target/StackFrameRecognizer.h

41

pointy boy gone

67

gone too

lldb/source/Interpreter/OptionValueFileColonLine.cpp

24

doone

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

219

hecho

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

111

factum

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

50

ciao

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

58

完了

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

55

хэлбэртэй, хэмжээтэй

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

193

doune

215

isimo sixazululiwe

[teemperor]

Not sure what happened to my accept, but I'll LGTM this again. Thanks!

[shafik]

I am sure I could find a bunch of other ends and odds but perhaps you have other checks that will cover these coming up.

lldb/include/lldb/Core/ThreadSafeValue.h

21

We can also default this as well, we can use member initializers for these values.

lldb/include/lldb/Core/UserSettingsController.h

35

I believe this should be defaultable as well.

lldb/include/lldb/DataFormatters/DumpValueObjectOptions.h

137

It looks like these members somehow got missed in the last PR that changed to use in class member initializers.

lldb/include/lldb/Host/HostNativeProcessBase.h

27

This looks like another case that got missed in the last PR to change to use in class member init.

lldb/include/lldb/Host/HostNativeThreadBase.h

30

I think we can switch this to =default as well.

48

lldb::thread_t m_thread = LLDB_INVALID_HOST_THREAD

lldb/.clang-tidy

-Checks: '-readability-identifier-naming,modernize-use-default-member-init'
+Checks: '-readability-identifier-naming,modernize-use-default-member-init,modernize-use-equals-default'
 InheritParentConfig: true
 CheckOptions:
   - key:             modernize-use-default-member-init.IgnoreMacros
     value:           '1'
   - key:             modernize-use-default-member-init.UseAssignment
     value:           '1'

lldb/include/lldb/Core/EmulateInstruction.h

       struct ISAAndImmediateSigned {
         uint32_t isa;
         int32_t signed_data32; // signed immediate data
       } ISAAndImmediateSigned;
 
       uint32_t isa;
     } info;
 
-    Context() {}
+    Context() = default;
 
     void SetRegisterPlusOffset(RegisterInfo base_reg, int64_t signed_offset) {
       info_type = eInfoTypeRegisterPlusOffset;
       info.RegisterPlusOffset.reg = base_reg;
       info.RegisterPlusOffset.signed_offset = signed_offset;
     }
 
     void SetRegisterPlusIndirectOffset(RegisterInfo base_reg,

lldb/include/lldb/Core/Opcode.h

 //===-- Opcode.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_CORE_OPCODE_H
 #define LLDB_CORE_OPCODE_H
 
 #include "lldb/Utility/Endian.h"
 #include "lldb/lldb-enumerations.h"
 
 #include "llvm/Support/SwapByteOrder.h"
 
 #include <cassert>
 #include <cstdint>
 #include <cstring>
 
enum Type {
     eType8,
     eType16,
     eType16_2, // a 32-bit Thumb instruction, made up of two words
     eType32,
     eType64,
     eTypeBytes
   };
 
-  Opcode() {}
+  Opcode() = default;
 
   Opcode(uint8_t inst, lldb::ByteOrder order)
       : m_byte_order(order), m_type(eType8) {
     m_data.inst8 = inst;
   }
 
   Opcode(uint16_t inst, lldb::ByteOrder order)
       : m_byte_order(order), m_type(eType16) {

lldb/include/lldb/Core/StreamBuffer.h

 //===-- StreamBuffer.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_CORE_STREAMBUFFER_H
 #define LLDB_CORE_STREAMBUFFER_H
 
 #include "lldb/Utility/Stream.h"
 #include "llvm/ADT/SmallVector.h"
 #include <cstdio>
 #include <string>
 
 namespace lldb_private {
 
 template <unsigned N> class StreamBuffer : public Stream {
 public:
   StreamBuffer() : Stream(0, 4, lldb::eByteOrderBig), m_packet() {}
 
   StreamBuffer(uint32_t flags, uint32_t addr_size, lldb::ByteOrder byte_order)
       : Stream(flags, addr_size, byte_order), m_packet() {}
 
-  ~StreamBuffer() override {}
+  ~StreamBuffer() override = default;
 
   void Flush() override {
     // Nothing to do when flushing a buffer based stream...
   }
 
   void Clear() { m_packet.clear(); }
 
   // Beware, this might not be NULL terminated as you can expect from

lldb/include/lldb/Core/ThreadSafeValue.h

 //===-- ThreadSafeValue.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_CORE_THREADSAFEVALUE_H
 #define LLDB_CORE_THREADSAFEVALUE_H
 
 #include <mutex>
 
 #include "lldb/lldb-defines.h"
 
 namespace lldb_private {
 
 template <class T> class ThreadSafeValue {
 public:
   // Constructors and Destructors
   ThreadSafeValue() : m_value(), m_mutex() {}
 
   ThreadSafeValue(const T &value) : m_value(value), m_mutex() {}
 
-  ~ThreadSafeValue() {}
+  ~ThreadSafeValue() = default;
 
   T GetValue() const {
     T value;
     {
       std::lock_guard<std::recursive_mutex> guard(m_mutex);
       value = m_value;
     }
     return value;

lldb/include/lldb/Core/UserSettingsController.h

 //====-- UserSettingsController.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_CORE_USERSETTINGSCONTROLLER_H
 #define LLDB_CORE_USERSETTINGSCONTROLLER_H
 
 #include "lldb/Utility/Status.h"
 #include "lldb/lldb-forward.h"
 #include "lldb/lldb-private-enumerations.h"
 
 #include "llvm/ADT/StringRef.h"
 
 #include <vector>
 
 #include <cstddef>
 #include <cstdint>
 
 namespace lldb_private {
 class CommandInterpreter;
 class ConstString;
 class ExecutionContext;
 class Property;
 class Stream;
 }
 
 namespace lldb_private {
 
 class Properties {
 public:
   Properties() : m_collection_sp() {}
 
   Properties(const lldb::OptionValuePropertiesSP &collection_sp)
       : m_collection_sp(collection_sp) {}
 
-  virtual ~Properties() {}
+  virtual ~Properties() = default;
 
   virtual lldb::OptionValuePropertiesSP GetValueProperties() const {
     // This function is virtual in case subclasses want to lazily implement
     // creating the properties.
     return m_collection_sp;
   }
 
   virtual lldb::OptionValueSP GetPropertyValue(const ExecutionContext *exe_ctx,

lldb/include/lldb/DataFormatters/DumpValueObjectOptions.h

 //===-- DumpValueObjectOptions.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_DATAFORMATTERS_DUMPVALUEOBJECTOPTIONS_H
 #define LLDB_DATAFORMATTERS_DUMPVALUEOBJECTOPTIONS_H
 
 #include <string>
 
 #include "lldb/lldb-private.h"
 #include "lldb/lldb-public.h"
 
 #include <functional>
 #include <string>
 
 namespace lldb_private {
 
 class DumpValueObjectOptions {
struct PointerDepth {
     bool CanAllowExpansion() const;
   };
 
   struct PointerAsArraySettings {
     size_t m_element_count = 0;
     size_t m_base_element = 0;
     size_t m_stride = 0;
 
-    PointerAsArraySettings() {}
+    PointerAsArraySettings() = default;
 
     PointerAsArraySettings(size_t elem_count, size_t base_elem = 0,
                            size_t stride = 1)
         : m_element_count(elem_count), m_base_element(base_elem),
           m_stride(stride) {}
 
     operator bool() { return m_element_count > 0; }
   };
public:
   uint32_t m_omit_summary_depth = 0;
   lldb::Format m_format = lldb::eFormatDefault;
   lldb::TypeSummaryImplSP m_summary_sp;
   std::string m_root_valobj_name;
   lldb::LanguageType m_varformat_language = lldb::eLanguageTypeUnknown;
   PointerDepth m_max_ptr_depth;
   DeclPrintingHelper m_decl_printing_helper;
   PointerAsArraySettings m_pointer_as_array;
   bool m_use_synthetic : 1;
   bool m_scope_already_checked : 1;
   bool m_flat_output : 1;
   bool m_ignore_cap : 1;
   bool m_show_types : 1;

lldb/include/lldb/DataFormatters/TypeFormat.h

 #ifndef LLDB_DATAFORMATTERS_TYPEFORMAT_H
 #define LLDB_DATAFORMATTERS_TYPEFORMAT_H
 
 #include <functional>
 #include <string>
 #include <unordered_map>
 
 
 #include "lldb/lldb-enumerations.h"
 #include "lldb/lldb-public.h"
 
 #include "lldb/Core/ValueObject.h"
 
 namespace lldb_private {
 class TypeFormatImpl {
 public:
   class Flags {
   public:
-    Flags() {}
+    Flags() = default;
 
     Flags(const Flags &other) : m_flags(other.m_flags) {}
 
     Flags(uint32_t value) : m_flags(value) {}
 
     Flags &operator=(const Flags &rhs) {
       if (&rhs != this)
         m_flags = rhs.m_flags;

lldb/include/lldb/DataFormatters/TypeSummary.h

 #define LLDB_DATAFORMATTERS_TYPESUMMARY_H
 
 #include <cstdint>
 
 #include <functional>
 #include <memory>
 #include <string>
 
 #include "lldb/lldb-enumerations.h"
 #include "lldb/lldb-public.h"
 
 #include "lldb/Core/FormatEntity.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StructuredData.h"
 
 namespace lldb_private {
 class TypeSummaryOptions {
public:
   enum class Kind { eSummaryString, eScript, eCallback, eInternal };
 
   virtual ~TypeSummaryImpl() = default;
 
   Kind GetKind() const { return m_kind; }
 
   class Flags {
   public:
-    Flags() {}
+    Flags() = default;
 
     Flags(const Flags &other) : m_flags(other.m_flags) {}
 
     Flags(uint32_t value) : m_flags(value) {}
 
     Flags &operator=(const Flags &rhs) {
       if (&rhs != this)
         m_flags = rhs.m_flags;

lldb/include/lldb/DataFormatters/TypeSynthetic.h

   const SyntheticValueProviderFrontEnd &
   operator=(const SyntheticValueProviderFrontEnd &) = delete;
 };
 
 class SyntheticChildren {
 public:
   class Flags {
   public:
-    Flags() {}
+    Flags() = default;
 
     Flags(const Flags &other) : m_flags(other.m_flags) {}
 
     Flags(uint32_t value) : m_flags(value) {}
 
     Flags &operator=(const Flags &rhs) {
       if (&rhs != this)
         m_flags = rhs.m_flags;

lldb/include/lldb/DataFormatters/ValueObjectPrinter.h

 //===-- ValueObjectPrinter.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_DATAFORMATTERS_VALUEOBJECTPRINTER_H
 #define LLDB_DATAFORMATTERS_VALUEOBJECTPRINTER_H
 
 #include "lldb/lldb-private.h"
 #include "lldb/lldb-public.h"
 
 #include "lldb/Utility/Flags.h"
 
 #include "lldb/DataFormatters/DumpValueObjectOptions.h"
 #include "lldb/Symbol/CompilerType.h"
 
 namespace lldb_private {
 
 class ValueObjectPrinter {
 public:
   ValueObjectPrinter(ValueObject *valobj, Stream *s);
 
   ValueObjectPrinter(ValueObject *valobj, Stream *s,
                      const DumpValueObjectOptions &options);
 
-  ~ValueObjectPrinter() {}
+  ~ValueObjectPrinter() = default;
 
   bool PrintValueObject();
 
 protected:
   typedef std::set<uint64_t> InstancePointersSet;
   typedef std::shared_ptr<InstancePointersSet> InstancePointersSetSP;
 
   InstancePointersSetSP m_printed_instance_pointers;

lldb/include/lldb/Expression/Expression.h

 //===-- Expression.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_EXPRESSION_EXPRESSION_H
 #define LLDB_EXPRESSION_EXPRESSION_H
 
 #include <map>
 #include <string>
 #include <vector>
 
 
 #include "lldb/Expression/ExpressionTypeSystemHelper.h"
 #include "lldb/lldb-forward.h"
 #include "lldb/lldb-private.h"
 
 namespace lldb_private {
 
 class RecordingMemoryManager;
 
 /// \class Expression Expression.h "lldb/Expression/Expression.h" Encapsulates
 /// a single expression for use in lldb
 ///
 /// LLDB uses expressions for various purposes, notably to call functions
 /// and as a backend for the expr command.  Expression encapsulates the
 /// objects needed to parse and interpret or JIT an expression.  It uses the
 /// expression parser appropriate to the language of the expression to produce
 /// LLVM IR from the expression.
 class Expression {
 public:
   enum ResultType { eResultTypeAny, eResultTypeId };
 
   Expression(Target &target);
 
   Expression(ExecutionContextScope &exe_scope);
 
   /// Destructor
-  virtual ~Expression() {}
+  virtual ~Expression() = default;
 
   /// Return the string that the parser should parse.  Must be a full
   /// translation unit.
   virtual const char *Text() = 0;
 
   /// Return the function name that should be used for executing the
   /// expression.  Text() should contain the definition of this function.
   virtual const char *FunctionName() = 0;

lldb/include/lldb/Expression/ExpressionParser.h

 //===-- ExpressionParser.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_EXPRESSION_EXPRESSIONPARSER_H
 #define LLDB_EXPRESSION_EXPRESSIONPARSER_H
 
 #include "lldb/Utility/CompletionRequest.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/lldb-private-enumerations.h"
 #include "lldb/lldb-public.h"
 
 namespace lldb_private {
 
 class IRExecutionUnit;
 
public:
   ///
   /// \param[in] expr
   ///     The expression to be parsed.
   ExpressionParser(ExecutionContextScope *exe_scope, Expression &expr,
                    bool generate_debug_info)
       : m_expr(expr), m_generate_debug_info(generate_debug_info) {}
 
   /// Destructor
-  virtual ~ExpressionParser(){};
+  virtual ~ExpressionParser() = default;
 
   /// Attempts to find possible command line completions for the given
   /// expression.
   ///
   /// \param[out] request
   ///     The completion request to fill out. The completion should be a string
   ///     that would complete the current token at the cursor position.
   ///     Note that the string in the list replaces the current token
   ///     in the command line.

lldb/include/lldb/Expression/ExpressionTypeSystemHelper.h

enum LLVMCastKind {
     eKindGoHelper,
     kNumKinds
   };
 
   LLVMCastKind getKind() const { return m_kind; }
 
   ExpressionTypeSystemHelper(LLVMCastKind kind) : m_kind(kind) {}
 
-  ~ExpressionTypeSystemHelper() {}
+  ~ExpressionTypeSystemHelper() = default;
 
 protected:
   LLVMCastKind m_kind;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_EXPRESSION_EXPRESSIONTYPESYSTEMHELPER_H

lldb/include/lldb/Expression/Materializer.h

 //===-- Materializer.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_EXPRESSION_MATERIALIZER_H
 #define LLDB_EXPRESSION_MATERIALIZER_H
 
 #include <memory>
 #include <vector>
 
 #include "lldb/Expression/IRMemoryMap.h"
 #include "lldb/Symbol/TaggedASTType.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/lldb-private-types.h"
 
 namespace lldb_private {
 
 class Materializer {
public:
   uint32_t AddRegister(const RegisterInfo &register_info, Status &err);
 
   uint32_t GetStructAlignment() { return m_struct_alignment; }
 
   uint32_t GetStructByteSize() { return m_current_offset; }
 
   class Entity {
   public:
-    Entity() {}
+    Entity() = default;
 
     virtual ~Entity() = default;
 
     virtual void Materialize(lldb::StackFrameSP &frame_sp, IRMemoryMap &map,
                              lldb::addr_t process_address, Status &err) = 0;
     virtual void Dematerialize(lldb::StackFrameSP &frame_sp, IRMemoryMap &map,
                                lldb::addr_t process_address,
                                lldb::addr_t frame_top,

lldb/include/lldb/Host/FileCache.h

 //===-- FileCache.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_FILECACHE_H
 #define LLDB_HOST_FILECACHE_H
 
 #include <cstdint>
 #include <map>
 
 #include "lldb/lldb-forward.h"
 #include "lldb/lldb-types.h"
 
 #include "lldb/Host/File.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Status.h"
 
 namespace lldb_private {
 class FileCache {
 private:
-  FileCache() {}
+  FileCache() = default;
 
   typedef std::map<lldb::user_id_t, lldb::FileUP> FDToFileMap;
 
 public:
   static FileCache &GetInstance();
 
   lldb::user_id_t OpenFile(const FileSpec &file_spec, File::OpenOptions flags,
                            uint32_t mode, Status &error);

lldb/include/lldb/Host/HostInfoBase.h

 //===-- HostInfoBase.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_HOSTINFOBASE_H
 #define LLDB_HOST_HOSTINFOBASE_H
 
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/UUID.h"
 #include "lldb/Utility/UserIDResolver.h"
 #include "lldb/Utility/XcodeSDK.h"
 #include "lldb/lldb-enumerations.h"
 #include "llvm/ADT/StringRef.h"
 
 #include <cstdint>
 
 #include <string>
 
 namespace lldb_private {
 
 class FileSpec;
 
 struct SharedCacheImageInfo {
   UUID uuid;
   lldb::DataBufferSP data_sp;
 };
 
 class HostInfoBase {
 private:
   // Static class, unconstructable.
-  HostInfoBase() {}
-  ~HostInfoBase() {}
+  HostInfoBase() = default;
+  ~HostInfoBase() = default;
 
 public:
   /// A helper function for determining the liblldb location. It receives a
   /// FileSpec with the location of file containing _this_ code. It can
   /// (optionally) replace it with a file spec pointing to a more canonical
   /// copy.
   using SharedLibraryDirectoryHelper = void(FileSpec &this_file);
 

lldb/include/lldb/Host/HostNativeProcessBase.h

 //===-- HostNativeProcessBase.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_HOSTNATIVEPROCESSBASE_H
 #define LLDB_HOST_HOSTNATIVEPROCESSBASE_H
 
 #include "lldb/Host/HostProcess.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/lldb-defines.h"
 #include "lldb/lldb-types.h"
 
 namespace lldb_private {
 
 class HostThread;
 
 class 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 ~HostNativeProcessBase() = default;
 
   virtual Status Terminate() = 0;
   virtual Status GetMainModule(FileSpec &file_spec) const = 0;
 
   virtual lldb::pid_t GetProcessId() const = 0;
   virtual bool IsRunning() const = 0;
 
   lldb::process_t GetSystemHandle() const { return m_process; }

lldb/include/lldb/Host/HostNativeThreadBase.h

 //===-- HostNativeThreadBase.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_HOSTNATIVETHREADBASE_H
 #define LLDB_HOST_HOSTNATIVETHREADBASE_H
 
 #include "lldb/Utility/Status.h"
 #include "lldb/lldb-defines.h"
 #include "lldb/lldb-types.h"
 
 namespace lldb_private {
 
 #if defined(_WIN32)
 #define THREAD_ROUTINE __stdcall
 #else
 #define THREAD_ROUTINE
 #endif
 
 class HostNativeThreadBase {
   friend class ThreadLauncher;
   HostNativeThreadBase(const HostNativeThreadBase &) = delete;
   const HostNativeThreadBase &operator=(const HostNativeThreadBase &) = delete;
 
 public:
   HostNativeThreadBase();
   explicit HostNativeThreadBase(lldb::thread_t thread);
-  virtual ~HostNativeThreadBase() {}
+  virtual ~HostNativeThreadBase() = default;
 
   virtual Status Join(lldb::thread_result_t *result) = 0;
   virtual Status Cancel() = 0;
   virtual bool IsJoinable() const;
   virtual void Reset();
   virtual bool EqualsThread(lldb::thread_t thread) const;
   lldb::thread_t Release();
 
   lldb::thread_t GetSystemHandle() const;
   lldb::thread_result_t GetResult() const;
 
 protected:
   static lldb::thread_result_t THREAD_ROUTINE
   ThreadCreateTrampoline(lldb::thread_arg_t arg);
 
   lldb::thread_t m_thread;
   lldb::thread_result_t m_result = 0;
 };
 }
 
 #endif

lldb/include/lldb/Host/MainLoopBase.h

 //===-- MainLoopBase.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_MAINLOOPBASE_H
 #define LLDB_HOST_MAINLOOPBASE_H
 
 #include "lldb/Utility/IOObject.h"
 #include "lldb/Utility/Status.h"
 #include "llvm/Support/ErrorHandling.h"
 #include <functional>
 
 namespace lldb_private {
 
 // The purpose of this class is to enable multiplexed processing of data from
 // different sources without resorting to multi-threading. Clients can register
 // IOObjects, which will be monitored for readability, and when they become
 // ready, the specified callback will be invoked. Monitoring for writability is
 // not supported, but can be easily added if needed.
 //
 // The RegisterReadObject function return a handle, which controls the duration
 // of the monitoring. When this handle is destroyed, the callback is
 // deregistered.
 //
 // This class simply defines the interface common for all platforms, actual
 // implementations are platform-specific.
 class MainLoopBase {
 private:
   class ReadHandle;
 
 public:
-  MainLoopBase() {}
-  virtual ~MainLoopBase() {}
+  MainLoopBase() = default;
+  virtual ~MainLoopBase() = default;
 
   typedef std::unique_ptr<ReadHandle> ReadHandleUP;
 
   typedef std::function<void(MainLoopBase &)> Callback;
 
   virtual ReadHandleUP RegisterReadObject(const lldb::IOObjectSP &object_sp,
                                           const Callback &callback,
                                           Status &error) {

lldb/include/lldb/Host/ProcessLauncher.h

 namespace lldb_private {
 
 class ProcessLaunchInfo;
 class Status;
 class HostProcess;
 
 class ProcessLauncher {
 public:
-  virtual ~ProcessLauncher() {}
+  virtual ~ProcessLauncher() = default;
   virtual HostProcess LaunchProcess(const ProcessLaunchInfo &launch_info,
                                     Status &error) = 0;
 };
 }
 
 #endif

lldb/include/lldb/Host/ProcessRunLock.h

 //===-- ProcessRunLock.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_PROCESSRUNLOCK_H
 #define LLDB_HOST_PROCESSRUNLOCK_H
 
 #include <cstdint>
 #include <ctime>
 
 #include "lldb/lldb-defines.h"
 
 /// Enumerations for broadcasting.
 namespace lldb_private {
 
 /// \class ProcessRunLock ProcessRunLock.h "lldb/Host/ProcessRunLock.h"
 /// A class used to prevent the process from starting while other
 /// threads are accessing its data, and prevent access to its data while it is
 /// running.
 
 class ProcessRunLock {
 public:
   ProcessRunLock();
   ~ProcessRunLock();
 
   bool ReadTryLock();
   bool ReadUnlock();
   bool SetRunning();
   bool TrySetRunning();
   bool SetStopped();
 
   class ProcessRunLocker {
   public:
-    ProcessRunLocker() {}
+    ProcessRunLocker() = default;
 
     ~ProcessRunLocker() { Unlock(); }
 
     // Try to lock the read lock, but only do so if there are no writers.
     bool TryLock(ProcessRunLock *lock) {
       if (m_lock) {
         if (m_lock == lock)
           return true; // We already have this lock locked

lldb/include/lldb/Host/Terminal.h

 //===-- Terminal.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_TERMINAL_H
 #define LLDB_HOST_TERMINAL_H
 #if defined(__cplusplus)
 
 #include "lldb/Host/Config.h"
 #include "lldb/lldb-private.h"
 
 struct termios;
 
 namespace lldb_private {
 
 class Terminal {
 public:
   Terminal(int fd = -1) : m_fd(fd) {}
 
-  ~Terminal() {}
+  ~Terminal() = default;
 
   bool IsATerminal() const;
 
   int GetFileDescriptor() const { return m_fd; }
 
   void SetFileDescriptor(int fd) { m_fd = fd; }
 
   bool FileDescriptorIsValid() const { return m_fd != -1; }

lldb/include/lldb/Host/common/NativeProcessProtocol.h

struct SVR4LibraryInfo {
   lldb::addr_t base_addr;
   lldb::addr_t ld_addr;
   lldb::addr_t next;
 };
 
 // NativeProcessProtocol
 class NativeProcessProtocol {
 public:
-  virtual ~NativeProcessProtocol() {}
+  virtual ~NativeProcessProtocol() = default;
 
   virtual Status Resume(const ResumeActionList &resume_actions) = 0;
 
   virtual Status Halt() = 0;
 
   virtual Status Detach() = 0;
 
   /// Sends a process a UNIX signal \a signal.
public:
 
   // Stop id interface
 
   uint32_t GetStopID() const;
 
   // Callbacks for low-level process state changes
   class NativeDelegate {
   public:
-    virtual ~NativeDelegate() {}
+    virtual ~NativeDelegate() = default;
 
     virtual void InitializeDelegate(NativeProcessProtocol *process) = 0;
 
     virtual void ProcessStateChanged(NativeProcessProtocol *process,
                                      lldb::StateType state) = 0;
 
     virtual void DidExec(NativeProcessProtocol *process) = 0;
 

lldb/include/lldb/Host/common/NativeThreadProtocol.h

 //===-- NativeThreadProtocol.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_COMMON_NATIVETHREADPROTOCOL_H
 #define LLDB_HOST_COMMON_NATIVETHREADPROTOCOL_H
 
 #include <memory>
 
 #include "lldb/Host/Debug.h"
 #include "lldb/lldb-private-forward.h"
 #include "lldb/lldb-types.h"
 
 namespace lldb_private {
 // NativeThreadProtocol
 class NativeThreadProtocol {
 public:
   NativeThreadProtocol(NativeProcessProtocol &process, lldb::tid_t tid);
 
-  virtual ~NativeThreadProtocol() {}
+  virtual ~NativeThreadProtocol() = default;
 
   virtual std::string GetName() = 0;
 
   virtual lldb::StateType GetState() = 0;
 
   virtual NativeRegisterContext &GetRegisterContext() = 0;
 
   virtual bool GetStopReason(ThreadStopInfo &stop_info,

lldb/include/lldb/Interpreter/CommandInterpreter.h

 //===-- CommandInterpreter.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_INTERPRETER_COMMANDINTERPRETER_H
 #define LLDB_INTERPRETER_COMMANDINTERPRETER_H
 
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/IOHandler.h"
 #include "lldb/Interpreter/CommandAlias.h"
 #include "lldb/Interpreter/CommandHistory.h"
 #include "lldb/Interpreter/CommandObject.h"
 #include "lldb/Interpreter/ScriptInterpreter.h"
 #include "lldb/Utility/Args.h"
 #include "lldb/Utility/Broadcaster.h"
 #include "lldb/Utility/CompletionRequest.h"
 #include "lldb/Utility/Event.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/StringList.h"
 #include "lldb/lldb-forward.h"
 #include "lldb/lldb-private.h"
 
 #include <mutex>
 #include <stack>
 
 namespace lldb_private {
 class CommandInterpreter;
 
 class CommandInterpreterRunResult {
 public:
-  CommandInterpreterRunResult() {}
+  CommandInterpreterRunResult() = default;
 
   uint32_t GetNumErrors() const { return m_num_errors; }
 
   lldb::CommandInterpreterResult GetResult() const { return m_result; }
 
   bool IsResult(lldb::CommandInterpreterResult result) {
     return m_result == result;
   }
CommandInterpreterRunOptions(LazyBool stop_on_continue,
                                LazyBool stop_on_error, LazyBool stop_on_crash,
                                LazyBool echo_commands, LazyBool echo_comments,
                                LazyBool print_results, LazyBool print_errors,
                                LazyBool add_to_history)
       : m_stop_on_continue(stop_on_continue), m_stop_on_error(stop_on_error),
         m_stop_on_crash(stop_on_crash), m_echo_commands(echo_commands),
         m_echo_comment_commands(echo_comments), m_print_results(print_results),
         m_print_errors(print_errors), m_add_to_history(add_to_history) {}
 
-  CommandInterpreterRunOptions()
-
-  {}
+  CommandInterpreterRunOptions() = default;
 
   void SetSilent(bool silent) {
     LazyBool value = silent ? eLazyBoolNo : eLazyBoolYes;
 
     m_print_results = value;
     m_print_errors = value;
     m_echo_commands = value;
     m_echo_comment_commands = value;

lldb/include/lldb/Interpreter/OptionValue.h

 //===-- OptionValue.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_INTERPRETER_OPTIONVALUE_H
 #define LLDB_INTERPRETER_OPTIONVALUE_H
 
 #include "lldb/Core/FormatEntity.h"
 #include "lldb/Utility/Cloneable.h"
 #include "lldb/Utility/CompletionRequest.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/lldb-defines.h"
 #include "lldb/lldb-private-enumerations.h"
 #include "lldb/lldb-private-interfaces.h"
 
enum {
     eDumpOptionRaw = (1u << 4),
     eDumpOptionCommand = (1u << 5),
     eDumpGroupValue = (eDumpOptionName | eDumpOptionType | eDumpOptionValue),
     eDumpGroupHelp =
         (eDumpOptionName | eDumpOptionType | eDumpOptionDescription),
     eDumpGroupExport = (eDumpOptionCommand | eDumpOptionName | eDumpOptionValue)
   };
 
-  OptionValue() {}
+  OptionValue() = default;
 
   virtual ~OptionValue() = default;
 
   // Subclasses should override these functions
   virtual Type GetType() const = 0;
 
   // If this value is always hidden, the avoid showing any info on this value,
   // just show the info for the child values.

lldb/include/lldb/Interpreter/Options.h

     // can implement this function to do extra checking
     Status error;
     return error;
   }
 };
 
 class OptionGroupOptions : public Options {
 public:
-  OptionGroupOptions() {}
+  OptionGroupOptions() = default;
 
   ~OptionGroupOptions() override = default;
 
   /// Append options from a OptionGroup class.
   ///
   /// Append all options from \a group using the exact same option groups that
   /// each option is defined with.
   ///

lldb/include/lldb/Interpreter/ScriptInterpreter.h

 //===-- ScriptInterpreter.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_INTERPRETER_SCRIPTINTERPRETER_H
 #define LLDB_INTERPRETER_SCRIPTINTERPRETER_H
 
 #include "lldb/API/SBData.h"
 #include "lldb/API/SBError.h"
 #include "lldb/Breakpoint/BreakpointOptions.h"
 #include "lldb/Core/Communication.h"
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Core/SearchFilter.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Host/PseudoTerminal.h"
 #include "lldb/Interpreter/ScriptedProcessInterface.h"
public:
   ScriptInterpreter(
       Debugger &debugger, lldb::ScriptLanguage script_lang,
       lldb::ScriptedProcessInterfaceUP scripted_process_interface_up = {});
 
   ~ScriptInterpreter() override = default;
 
   struct ExecuteScriptOptions {
   public:
-    ExecuteScriptOptions() {}
+    ExecuteScriptOptions() = default;
 
     bool GetEnableIO() const { return m_enable_io; }
 
     bool GetSetLLDBGlobals() const { return m_set_lldb_globals; }
 
     // If this is true then any exceptions raised by the script will be
     // cleared with PyErr_Clear().   If false then they will be left for
     // the caller to clean up

lldb/include/lldb/Symbol/CompactUnwindInfo.h

 //===-- CompactUnwindInfo.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_SYMBOL_COMPACTUNWINDINFO_H
 #define LLDB_SYMBOL_COMPACTUNWINDINFO_H
 
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/UnwindPlan.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/RangeMap.h"
 #include "lldb/lldb-private.h"
 #include <mutex>
 #include <vector>
 
 namespace lldb_private {
struct UnwindIndex {
     uint32_t lsda_array_start = 0; // The offset (inside unwind_info sect) LSDA
                                    // array for this index
     uint32_t lsda_array_end =
         0; // The offset to the LSDA array for the NEXT index
     bool sentinal_entry = false; // There is an empty index at the end which
                                  // provides the upper bound of
     // function addresses that are described
 
-    UnwindIndex() {}
+    UnwindIndex() = default;
 
     bool operator<(const CompactUnwindInfo::UnwindIndex &rhs) const {
       return function_offset < rhs.function_offset;
     }
 
     bool operator==(const CompactUnwindInfo::UnwindIndex &rhs) const {
       return function_offset == rhs.function_offset;
     }
private:
 
   struct UnwindHeader {
     uint32_t version;
     uint32_t common_encodings_array_offset = 0;
     uint32_t common_encodings_array_count = 0;
     uint32_t personality_array_offset = 0;
     uint32_t personality_array_count = 0;
 
-    UnwindHeader() {}
+    UnwindHeader() = default;
   };
 
   void ScanIndex(const lldb::ProcessSP &process_sp);
 
   bool GetCompactUnwindInfoForFunction(Target &target, Address address,
                                        FunctionInfo &unwind_info);
 
   lldb::offset_t

lldb/include/lldb/Symbol/DeclVendor.h

 //===-- DeclVendor.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_SYMBOL_DECLVENDOR_H
 #define LLDB_SYMBOL_DECLVENDOR_H
 
 #include "lldb/lldb-defines.h"
 
 #include <vector>
 
 namespace lldb_private {
 
 // The Decl vendor class is intended as a generic interface to search for named
 // declarations that are not necessarily backed by a specific symbol file.
 class DeclVendor {
 public:
   enum DeclVendorKind {
     eClangDeclVendor,
     eClangModuleDeclVendor,
     eAppleObjCDeclVendor,
     eLastClangDeclVendor,
   };
   // Constructors and Destructors
   DeclVendor(DeclVendorKind kind) : m_kind(kind) {}
 
-  virtual ~DeclVendor() {}
+  virtual ~DeclVendor() = default;
 
   DeclVendorKind GetKind() const { return m_kind; }
 
   /// Look up the set of Decls that the DeclVendor currently knows about
   /// matching a given name.
   ///
   /// \param[in] name
   ///     The name to look for.

lldb/include/lldb/Symbol/Function.h

 
 /// \class CallEdge Function.h "lldb/Symbol/Function.h"
 ///
 /// Represent a call made within a Function. This can be used to find a path
 /// in the call graph between two functions, or to evaluate DW_OP_entry_value.
 class CallEdge {
 public:
   enum class AddrType : uint8_t { Call, AfterCall };
-  virtual ~CallEdge() {}
+  virtual ~CallEdge() = default;
 
   /// Get the callee's definition.
   ///
   /// Note that this might lazily invoke the DWARF parser. A register context
   /// from the caller's activation is needed to find indirect call targets.
   virtual Function *GetCallee(ModuleList &images,
                               ExecutionContext &exe_ctx) = 0;
 

lldb/include/lldb/Symbol/ObjectFile.h

 //===-- ObjectFile.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_SYMBOL_OBJECTFILE_H
 #define LLDB_SYMBOL_OBJECTFILE_H
 
 #include "lldb/Core/FileSpecList.h"
 #include "lldb/Core/ModuleChild.h"
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Symbol/Symtab.h"
 #include "lldb/Symbol/UnwindTable.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/UUID.h"
 #include "lldb/lldb-private.h"
 #include "llvm/Support/VersionTuple.h"
 
 namespace lldb_private {
 
 class ObjectFileJITDelegate {
 public:
-  ObjectFileJITDelegate() {}
+  ObjectFileJITDelegate() = default;
 
-  virtual ~ObjectFileJITDelegate() {}
+  virtual ~ObjectFileJITDelegate() = default;
 
   virtual lldb::ByteOrder GetByteOrder() const = 0;
 
   virtual uint32_t GetAddressByteSize() const = 0;
 
   virtual void PopulateSymtab(lldb_private::ObjectFile *obj_file,
                               lldb_private::Symtab &symtab) = 0;
 

lldb/include/lldb/Symbol/SymbolFile.h

 //===-- SymbolFile.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_SYMBOL_SYMBOLFILE_H
 #define LLDB_SYMBOL_SYMBOLFILE_H
 
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Core/SourceLocationSpec.h"
 #include "lldb/Symbol/CompilerDecl.h"
 #include "lldb/Symbol/CompilerDeclContext.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/SourceModule.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Symbol/TypeList.h"
public:
 
   static SymbolFile *FindPlugin(lldb::ObjectFileSP objfile_sp);
 
   // Constructors and Destructors
   SymbolFile(lldb::ObjectFileSP objfile_sp)
       : m_objfile_sp(std::move(objfile_sp)), m_abilities(0),
         m_calculated_abilities(false) {}
 
-  ~SymbolFile() override {}
+  ~SymbolFile() override = default;
 
   /// Get a mask of what this symbol file supports for the object file
   /// that it was constructed with.
   ///
   /// Each symbol file gets to respond with a mask of abilities that
   /// it supports for each object file. This happens when we are
   /// trying to figure out which symbol file plug-in will get used
   /// for a given object file. The plug-in that responds with the

lldb/include/lldb/Symbol/TaggedASTType.h

 //===-- TaggedASTType.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_SYMBOL_TAGGEDASTTYPE_H
 #define LLDB_SYMBOL_TAGGEDASTTYPE_H
 
 #include "lldb/Symbol/CompilerType.h"
 
 namespace lldb_private {
 
 // For cases in which there are multiple classes of types that are not
 // interchangeable, to allow static type checking.
 template <unsigned int C> class TaggedASTType : public CompilerType {
 public:
   TaggedASTType(const CompilerType &compiler_type)
       : CompilerType(compiler_type) {}
 
   TaggedASTType(lldb::opaque_compiler_type_t type, TypeSystem *type_system)
       : CompilerType(type_system, type) {}
 
   TaggedASTType(const TaggedASTType<C> &tw) : CompilerType(tw) {}
 
   TaggedASTType() : CompilerType() {}
 
-  virtual ~TaggedASTType() {}
+  virtual ~TaggedASTType() = default;
 
   TaggedASTType<C> &operator=(const TaggedASTType<C> &tw) {
     CompilerType::operator=(tw);
     return *this;
   }
 };
 
 // Commonly-used tagged types, so code using them is interoperable
 typedef TaggedASTType<0> TypeFromParser;
 typedef TaggedASTType<1> TypeFromUser;
 }
 
 #endif

lldb/include/lldb/Symbol/Type.h

 //===-- Type.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_SYMBOL_TYPE_H
 #define LLDB_SYMBOL_TYPE_H
 
 #include "lldb/Core/Declaration.h"
 #include "lldb/Symbol/CompilerDecl.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/UserID.h"
 #include "lldb/lldb-private.h"
 
 #include "llvm/ADT/APSInt.h"
 

 class SymbolFileType : public std::enable_shared_from_this<SymbolFileType>,
                        public UserID {
 public:
   SymbolFileType(SymbolFile &symbol_file, lldb::user_id_t uid)
       : UserID(uid), m_symbol_file(symbol_file) {}
 
   SymbolFileType(SymbolFile &symbol_file, const lldb::TypeSP &type_sp);
 
-  ~SymbolFileType() {}
+  ~SymbolFileType() = default;
 
   Type *operator->() { return GetType(); }
 
   Type *GetType();
   SymbolFile &GetSymbolFile() const { return m_symbol_file; }
 
 protected:
   SymbolFile &m_symbol_file;

 
 // the two classes here are used by the public API as a backend to the SBType
 // and SBTypeList classes
 
 class TypeImpl {
 public:
   TypeImpl() = default;
 
-  ~TypeImpl() {}
+  ~TypeImpl() = default;
 
   TypeImpl(const lldb::TypeSP &type_sp);
 
   TypeImpl(const CompilerType &compiler_type);
 
   TypeImpl(const lldb::TypeSP &type_sp, const CompilerType &dynamic);
 
   TypeImpl(const CompilerType &compiler_type, const CompilerType &dynamic);

lldb/include/lldb/Target/ExecutionContextScope.h

 //===-- ExecutionContextScope.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_TARGET_EXECUTIONCONTEXTSCOPE_H
 #define LLDB_TARGET_EXECUTIONCONTEXTSCOPE_H
 
 #include "lldb/lldb-private.h"
 
 namespace lldb_private {
 
 /// @class ExecutionContextScope ExecutionContextScope.h
 /// "lldb/Target/ExecutionContextScope.h" Inherit from this if your object can
 /// reconstruct its
 ///        execution context.
 ///
 /// Many objects that have pointers back to parent execution context objects
 /// can inherit from this pure virtual class can reconstruct their execution
 /// context without having to keep a complete ExecutionContext object in the
 /// object state. Examples of these objects include: Process, Thread,
 /// RegisterContext and StackFrame.
 ///
 /// Objects can contain a valid pointer to an instance of this so they can
 /// reconstruct the execution context.
 ///
 /// Objects that adhere to this protocol can reconstruct enough of a execution
 /// context to allow functions that take a execution contexts to be called.
 class ExecutionContextScope {
 public:
-  virtual ~ExecutionContextScope() {}
+  virtual ~ExecutionContextScope() = default;
 
   virtual lldb::TargetSP CalculateTarget() = 0;
 
   virtual lldb::ProcessSP CalculateProcess() = 0;
 
   virtual lldb::ThreadSP CalculateThread() = 0;
 
   virtual lldb::StackFrameSP CalculateStackFrame() = 0;

lldb/include/lldb/Target/InstrumentationRuntimeStopInfo.h

 //===-- InstrumentationRuntimeStopInfo.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_TARGET_INSTRUMENTATIONRUNTIMESTOPINFO_H
 #define LLDB_TARGET_INSTRUMENTATIONRUNTIMESTOPINFO_H
 
 #include <string>
 
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Utility/StructuredData.h"
 
 namespace lldb_private {
 
 class InstrumentationRuntimeStopInfo : public StopInfo {
 public:
-  ~InstrumentationRuntimeStopInfo() override {}
+  ~InstrumentationRuntimeStopInfo() override = default;
 
   lldb::StopReason GetStopReason() const override {
     return lldb::eStopReasonInstrumentation;
   }
 
   const char *GetDescription() override;
 
   bool DoShouldNotify(Event *event_ptr) override { return true; }

lldb/include/lldb/Target/Process.h

 // currently modify the program are running the program (which will up the
 // StopID) and writing memory (which will up the MemoryID.)
 // FIXME: Should we also include modification of register states?
 
 class ProcessModID {
   friend bool operator==(const ProcessModID &lhs, const ProcessModID &rhs);
 
 public:
-  ProcessModID()
-
-  {}
+  ProcessModID() = default;
 
   ProcessModID(const ProcessModID &rhs)
       : m_stop_id(rhs.m_stop_id), m_memory_id(rhs.m_memory_id) {}
 
   const ProcessModID &operator=(const ProcessModID &rhs) {
     if (this != &rhs) {
       m_stop_id = rhs.m_stop_id;
       m_memory_id = rhs.m_memory_id;
     }
     return *this;

lldb/include/lldb/Target/RegisterCheckpoint.h

 //===-- RegisterCheckpoint.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_TARGET_REGISTERCHECKPOINT_H
 #define LLDB_TARGET_REGISTERCHECKPOINT_H
 
 #include "lldb/Target/StackID.h"
 #include "lldb/Utility/UserID.h"
 #include "lldb/lldb-private.h"
 
 namespace lldb_private {
 
 // Inherit from UserID in case pushing/popping all register values can be done
 // using a 64 bit integer that holds a baton/cookie instead of actually having
 // to read all register values into a buffer
 class RegisterCheckpoint : public UserID {
 public:
   enum class Reason {
     // An expression is about to be run on the thread if the protocol that
     // talks to the debuggee supports checkpointing the registers using a
     // push/pop then the UserID base class in the RegisterCheckpoint can be
     // used to store the baton/cookie that refers to the remote saved state.
     eExpression,
     // The register checkpoint wants the raw register bytes, so they must be
     // read into m_data_sp, or the save/restore checkpoint should fail.
     eDataBackup
   };
 
   RegisterCheckpoint(Reason reason)
       : UserID(0), m_data_sp(), m_reason(reason) {}
 
-  ~RegisterCheckpoint() {}
+  ~RegisterCheckpoint() = default;
 
   lldb::DataBufferSP &GetData() { return m_data_sp; }
 
   const lldb::DataBufferSP &GetData() const { return m_data_sp; }
 
 protected:
   lldb::DataBufferSP m_data_sp;
   Reason m_reason;

lldb/include/lldb/Target/StackFrameRecognizer.h

 //===-- StackFrameRecognizer.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_TARGET_STACKFRAMERECOGNIZER_H
 #define LLDB_TARGET_STACKFRAMERECOGNIZER_H
 
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectList.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Utility/StructuredData.h"
 #include "lldb/lldb-private-forward.h"
 #include "lldb/lldb-public.h"
 
 #include <vector>

 public:
   virtual lldb::ValueObjectListSP GetRecognizedArguments() {
     return m_arguments;
   }
   virtual lldb::ValueObjectSP GetExceptionObject() {
     return lldb::ValueObjectSP();
   }
   virtual lldb::StackFrameSP GetMostRelevantFrame() { return nullptr; };
-  virtual ~RecognizedStackFrame(){};
+  virtual ~RecognizedStackFrame() = default;
 
   std::string GetStopDescription() { return m_stop_desc; }
 
 protected:
   lldb::ValueObjectListSP m_arguments;
   std::string m_stop_desc;
 };
 
 /// \class StackFrameRecognizer
 ///
 /// A base class for frame recognizers. Subclasses (actual frame recognizers)
 /// should implement RecognizeFrame to provide a RecognizedStackFrame for a
 /// given stack frame.
 
 class StackFrameRecognizer
     : public std::enable_shared_from_this<StackFrameRecognizer> {
 public:
   virtual lldb::RecognizedStackFrameSP RecognizeFrame(
       lldb::StackFrameSP frame) {
     return lldb::RecognizedStackFrameSP();
   };
   virtual std::string GetName() {
     return "";
   }
 
-  virtual ~StackFrameRecognizer(){};
+  virtual ~StackFrameRecognizer() = default;
 };
 
 /// \class ScriptedStackFrameRecognizer
 ///
 /// Python implementation for frame recognizers. An instance of this class
 /// tracks a particular Python classobject, which will be asked to recognize
 /// stack frames.
 
 class ScriptedStackFrameRecognizer : public StackFrameRecognizer {
   lldb_private::ScriptInterpreter *m_interpreter;
   lldb_private::StructuredData::ObjectSP m_python_object_sp;
   std::string m_python_class;
 
 public:
   ScriptedStackFrameRecognizer(lldb_private::ScriptInterpreter *interpreter,
                                const char *pclass);
-  ~ScriptedStackFrameRecognizer() override {}
+  ~ScriptedStackFrameRecognizer() override = default;
 
   std::string GetName() override {
     return GetPythonClassName();
   }
 
   const char *GetPythonClassName() { return m_python_class.c_str(); }
 
   lldb::RecognizedStackFrameSP RecognizeFrame(

lldb/include/lldb/Target/StopInfo.h

 //===-- StopInfo.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_TARGET_STOPINFO_H
 #define LLDB_TARGET_STOPINFO_H
 
 #include <string>
 
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/StructuredData.h"
 #include "lldb/lldb-public.h"
 
 namespace lldb_private {
 
 class StopInfo {
   friend class Process::ProcessEventData;
   friend class ThreadPlanBase;
 
 public:
   // Constructors and Destructors
   StopInfo(Thread &thread, uint64_t value);
 
-  virtual ~StopInfo() {}
+  virtual ~StopInfo() = default;
 
   bool IsValid() const;
 
   void SetThread(const lldb::ThreadSP &thread_sp) { m_thread_wp = thread_sp; }
 
   lldb::ThreadSP GetThread() const { return m_thread_wp.lock(); }
 
   // The value of the StopInfo depends on the StopReason.

lldb/include/lldb/Target/ThreadCollection.h

 //===-- ThreadCollection.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_TARGET_THREADCOLLECTION_H
 #define LLDB_TARGET_THREADCOLLECTION_H
 
 #include <mutex>
 #include <vector>
 
 #include "lldb/Utility/Iterable.h"
 #include "lldb/lldb-private.h"
 
 namespace lldb_private {
 
 class ThreadCollection {
 public:
   typedef std::vector<lldb::ThreadSP> collection;
   typedef LockingAdaptedIterable<collection, lldb::ThreadSP, vector_adapter,
                                  std::recursive_mutex>
       ThreadIterable;
 
   ThreadCollection();
 
   ThreadCollection(collection threads);
 
-  virtual ~ThreadCollection() {}
+  virtual ~ThreadCollection() = default;
 
   uint32_t GetSize();
 
   void AddThread(const lldb::ThreadSP &thread_sp);
 
   void AddThreadSortedByIndexID(const lldb::ThreadSP &thread_sp);
 
   void InsertThread(const lldb::ThreadSP &thread_sp, uint32_t idx);

lldb/include/lldb/Target/ThreadPlanStack.h

 //===-- ThreadPlanStack.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_TARGET_THREADPLANSTACK_H
 #define LLDB_TARGET_THREADPLANSTACK_H
 
 #include <mutex>
 #include <string>
 #include <unordered_map>
 #include <vector>
 
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/lldb-private-forward.h"
 #include "lldb/lldb-private.h"
 
 namespace lldb_private {
 
 // The ThreadPlans have a thread for use when they are asked all the ThreadPlan
 // state machine questions, but they should never cache any pointers from their
 // owning lldb_private::Thread.  That's because we want to be able to detach
 // them from an owning thread, then reattach them by TID.
 // The ThreadPlanStack holds the ThreadPlans for a given TID.  All its methods
 // are private, and it should only be accessed through the owning thread.  When
 // it is detached from a thread, all you can do is reattach it or delete it.
 class ThreadPlanStack {
   friend class lldb_private::Thread;
 
 public:
   ThreadPlanStack(const Thread &thread, bool make_empty = false);
-  ~ThreadPlanStack() {}
+  ~ThreadPlanStack() = default;
 
   using PlanStack = std::vector<lldb::ThreadPlanSP>;
 
   void DumpThreadPlans(Stream &s, lldb::DescriptionLevel desc_level,
                        bool include_internal) const;
 
   size_t CheckpointCompletedPlans();
 
private:
   size_t m_completed_plan_checkpoint = 0; // Monotonically increasing token for
                                           // completed plan checkpoints.
   std::unordered_map<size_t, PlanStack> m_completed_plan_store;
 };
 
 class ThreadPlanStackMap {
 public:
   ThreadPlanStackMap(Process &process) : m_process(process) {}
-  ~ThreadPlanStackMap() {}
+  ~ThreadPlanStackMap() = default;
 
   // Prune the map using the current_threads list.
   void Update(ThreadList &current_threads, bool delete_missing,
               bool check_for_new = true);
 
   void AddThread(Thread &thread) {
     lldb::tid_t tid = thread.GetID();
     m_plans_list.emplace(tid, thread);

lldb/include/lldb/Target/UnixSignals.h

 
 #ifndef LLDB_TARGET_UNIXSIGNALS_H
 #define LLDB_TARGET_UNIXSIGNALS_H
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "lldb/Utility/ConstString.h"
 #include "lldb/lldb-private.h"
 #include "llvm/ADT/Optional.h"
 
 namespace lldb_private {
 
 class UnixSignals {
 public:
   static lldb::UnixSignalsSP Create(const ArchSpec &arch);

     ConstString m_name;
     ConstString m_alias;
     std::string m_description;
     bool m_suppress : 1, m_stop : 1, m_notify : 1;
 
     Signal(const char *name, bool default_suppress, bool default_stop,
            bool default_notify, const char *description, const char *alias);
 
-    ~Signal() {}
+    ~Signal() = default;
   };
 
   virtual void Reset();
 
   typedef std::map<int32_t, Signal> collection;
 
   collection m_signals;
 

lldb/include/lldb/Target/Unwind.h

 //===-- Unwind.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_TARGET_UNWIND_H
 #define LLDB_TARGET_UNWIND_H
 
 #include <mutex>
 
 #include "lldb/lldb-private.h"
 
 namespace lldb_private {
 
 class Unwind {
 protected:
   // Classes that inherit from Unwind can see and modify these
   Unwind(Thread &thread) : m_thread(thread), m_unwind_mutex() {}
 
 public:
-  virtual ~Unwind() {}
+  virtual ~Unwind() = default;
 
   void Clear() {
     std::lock_guard<std::recursive_mutex> guard(m_unwind_mutex);
     DoClear();
   }
 
   uint32_t GetFrameCount() {
     std::lock_guard<std::recursive_mutex> guard(m_unwind_mutex);

lldb/include/lldb/Utility/Baton.h

 //===-- Baton.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_UTILITY_BATON_H
 #define LLDB_UTILITY_BATON_H
 
 #include "lldb/lldb-enumerations.h"
 #include "lldb/lldb-public.h"
 
 #include "llvm/Support/raw_ostream.h"
 
 #include <memory>
 
 namespace lldb_private {
 class Stream;
 }
 
 namespace lldb_private {
 
 /// \class Baton Baton.h "lldb/Core/Baton.h"
 /// A class designed to wrap callback batons so they can cleanup
 ///        any acquired resources
 ///
 /// This class is designed to be used by any objects that have a callback
 /// function that takes a baton where the baton might need to
 /// free/delete/close itself.
 ///
 /// The default behavior is to not free anything. Subclasses can free any
 /// needed resources in their destructors.
 class Baton {
 public:
-  Baton() {}
-  virtual ~Baton() {}
+  Baton() = default;
+  virtual ~Baton() = default;
 
   virtual void *data() = 0;
 
   virtual void GetDescription(llvm::raw_ostream &s,
                               lldb::DescriptionLevel level,
                               unsigned indentation) const = 0;
 };
 

lldb/include/lldb/Utility/DataBuffer.h

 //===-- DataBuffer.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_UTILITY_DATABUFFER_H
 #define LLDB_UTILITY_DATABUFFER_H
 #if defined(__cplusplus)
 
 #include <cstdint>
 #include <cstring>
 
 #include "lldb/lldb-types.h"
 
 #include "llvm/ADT/ArrayRef.h"
 
 namespace lldb_private {
 
 /// \class DataBuffer DataBuffer.h "lldb/Core/DataBuffer.h"
 /// A pure virtual protocol class for abstracted data buffers.
 ///

 class DataBuffer {
 public:
   /// Destructor
   ///
   /// The destructor is virtual as other classes will inherit from this class
   /// and be downcast to the DataBuffer pure virtual interface. The virtual
   /// destructor ensures that destructing the base class will destruct the
   /// class that inherited from it correctly.
-  virtual ~DataBuffer() {}
+  virtual ~DataBuffer() = default;
 
   /// Get a pointer to the data.
   ///
   /// \return
   ///     A pointer to the bytes owned by this object, or NULL if the
   ///     object contains no bytes.
   virtual uint8_t *GetBytes() = 0;
 

lldb/include/lldb/Utility/Event.h

 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_UTILITY_EVENT_H
 #define LLDB_UTILITY_EVENT_H
 
 #include "lldb/Utility/Broadcaster.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Predicate.h"
 #include "lldb/Utility/StructuredData.h"
 #include "lldb/lldb-defines.h"
 #include "lldb/lldb-forward.h"
 
 #include "llvm/ADT/StringRef.h"
 

   EventDataBytes(const EventDataBytes &) = delete;
   const EventDataBytes &operator=(const EventDataBytes &) = delete;
 };
 
 class EventDataReceipt : public EventData {
 public:
   EventDataReceipt() : EventData(), m_predicate(false) {}
 
-  ~EventDataReceipt() override {}
+  ~EventDataReceipt() override = default;
 
   static ConstString GetFlavorString() {
     static ConstString g_flavor("Process::ProcessEventData");
     return g_flavor;
   }
 
   ConstString GetFlavor() const override { return GetFlavorString(); }
 

lldb/include/lldb/Utility/ReproducerInstrumentation.h

                        Deserialized... d) {
       return f(d...);
     }
   };
 };
 
 /// The replayer interface.
 struct Replayer {
-  virtual ~Replayer() {}
+  virtual ~Replayer() = default;
   virtual void operator()(Deserializer &deserializer) const = 0;
 };
 
 /// The default replayer deserializes the arguments and calls the function.
 template <typename Signature> struct DefaultReplayer;
 template <typename Result, typename... Args>
 struct DefaultReplayer<Result(Args...)> : public Replayer {
   DefaultReplayer(Result (*f)(Args...)) : Replayer(), f(f) {}

   static void Initialize(Serializer &serializer, Registry &registry);
   static void Initialize(Deserializer &serializer, Registry &registry);
   static InstrumentationData &Instance();
 
 protected:
   friend llvm::optional_detail::OptionalStorage<InstrumentationData, true>;
   friend llvm::Optional<InstrumentationData>;
 
-  InstrumentationData() {}
+  InstrumentationData() = default;
   InstrumentationData(Serializer &serializer, Registry &registry)
       : m_serializer(&serializer), m_deserializer(nullptr),
         m_registry(&registry) {}
   InstrumentationData(Deserializer &deserializer, Registry &registry)
       : m_serializer(nullptr), m_deserializer(&deserializer),
         m_registry(&registry) {}
 
 private:

lldb/include/lldb/Utility/StreamTee.h

 //===-- StreamTee.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_UTILITY_STREAMTEE_H
 #define LLDB_UTILITY_STREAMTEE_H
 
 #include <climits>
 
 #include <mutex>
 
 #include "lldb/Utility/Stream.h"
 
 namespace lldb_private {
 
 class StreamTee : public Stream {
 public:
   StreamTee(bool colors = false)
       : Stream(colors), m_streams_mutex(), m_streams() {}
 
public:
 
   StreamTee(const StreamTee &rhs)
       : Stream(rhs), m_streams_mutex(), m_streams() {
     // Don't copy until we lock down "rhs"
     std::lock_guard<std::recursive_mutex> guard(rhs.m_streams_mutex);
     m_streams = rhs.m_streams;
   }
 
-  ~StreamTee() override {}
+  ~StreamTee() override = default;
 
   StreamTee &operator=(const StreamTee &rhs) {
     if (this != &rhs) {
       Stream::operator=(rhs);
       std::lock(m_streams_mutex, rhs.m_streams_mutex);
       std::lock_guard<std::recursive_mutex> lhs_locker(m_streams_mutex,
                                                        std::adopt_lock);
       std::lock_guard<std::recursive_mutex> rhs_locker(rhs.m_streams_mutex,

lldb/include/lldb/Utility/TraceGDBRemotePackets.h

 //===-- TraceGDBRemotePackets.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_UTILITY_TRACEGDBREMOTEPACKETS_H
 #define LLDB_UTILITY_TRACEGDBREMOTEPACKETS_H
 
 #include "llvm/Support/JSON.h"
 
 #include "lldb/lldb-defines.h"
 #include "lldb/lldb-enumerations.h"
 
 /// See docs/lldb-gdb-remote.txt for more information.
 namespace lldb_private {
 
 /// jLLDBTraceSupported gdb-remote packet
 /// \{
 struct TraceSupportedResponse {
bool fromJSON(const llvm::json::Value &value, TraceStartRequest &packet,
               llvm::json::Path path);
 
 llvm::json::Value toJSON(const TraceStartRequest &packet);
 /// \}
 
 /// jLLDBTraceStop gdb-remote packet
 /// \{
 struct TraceStopRequest {
-  TraceStopRequest() {}
+  TraceStopRequest() = default;
 
   TraceStopRequest(llvm::StringRef type, const std::vector<lldb::tid_t> &tids);
 
   TraceStopRequest(llvm::StringRef type) : type(type){};
 
   bool IsProcessTracing() const;
 
   /// Tracing technology name, e.g. intel-pt, arm-coresight.

lldb/include/lldb/Utility/UserID.h

 //===-- UserID.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_UTILITY_USERID_H
 #define LLDB_UTILITY_USERID_H
 
 #include "lldb/lldb-defines.h"
 #include "lldb/lldb-types.h"
 
 namespace lldb_private {
 class Stream;
 
 /// \class UserID UserID.h "lldb/Core/UserID.h"
 /// A mix in class that contains a generic user ID.
 ///
 /// UserID is designed as a mix in class that can contain an integer based
 /// unique identifier for a variety of objects in lldb.
 ///
 /// The value for this identifier is chosen by each parser plug-in. A value
 /// should be chosen that makes sense for each kind of object and should allow
 /// quick access to further and more in depth parsing.
 ///
 /// Symbol table entries can use this to store the original symbol table
 /// index, functions can use it to store the symbol table index or the
 /// DWARF offset.
 struct UserID {
   /// Construct with optional user ID.
   UserID(lldb::user_id_t uid = LLDB_INVALID_UID) : m_uid(uid) {}
 
   /// Destructor.
-  ~UserID() {}
+  ~UserID() = default;
 
   /// Clears the object state.
   ///
   /// Clears the object contents back to a default invalid state.
   void Clear() { m_uid = LLDB_INVALID_UID; }
 
   /// Get accessor for the user ID.
   ///

lldb/include/lldb/Utility/VMRange.h

 //===-- VMRange.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_UTILITY_VMRANGE_H
 #define LLDB_UTILITY_VMRANGE_H
 
 #include "lldb/lldb-types.h"
 #include "llvm/Support/raw_ostream.h"
 
 #include <cstddef>
 #include <cstdint>
 #include <vector>
 
 namespace lldb_private {
 
 // A vm address range. These can represent offsets ranges or actual
 // addresses.
 class VMRange {
 public:
   typedef std::vector<VMRange> collection;
   typedef collection::iterator iterator;
   typedef collection::const_iterator const_iterator;
 
-  VMRange() {}
+  VMRange() = default;
 
   VMRange(lldb::addr_t start_addr, lldb::addr_t end_addr)
       : m_base_addr(start_addr),
         m_byte_size(end_addr > start_addr ? end_addr - start_addr : 0) {}
 
-  ~VMRange() {}
+  ~VMRange() = default;
 
   void Clear() {
     m_base_addr = 0;
     m_byte_size = 0;
   }
 
   // Set the start and end values
   void Reset(lldb::addr_t start_addr, lldb::addr_t end_addr) {

lldb/include/lldb/lldb-private-types.h

 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_LLDB_PRIVATE_TYPES_H
 #define LLDB_LLDB_PRIVATE_TYPES_H
 
 #if defined(__cplusplus)
 
 #include "lldb/lldb-private.h"
 
 #include "llvm/ADT/ArrayRef.h"
 
 namespace llvm {
 namespace sys {
 class DynamicLibrary;
 }
 }

   int64_t value;
   const char *string_value;
   const char *usage;
 };
 
 using OptionEnumValues = llvm::ArrayRef<OptionEnumValueElement>;
 
 struct OptionValidator {
-  virtual ~OptionValidator() {}
+  virtual ~OptionValidator() = default;
   virtual bool IsValid(Platform &platform,
                        const ExecutionContext &target) const = 0;
   virtual const char *ShortConditionString() const = 0;
   virtual const char *LongConditionString() const = 0;
 };
 
 typedef struct type128 { uint64_t x[2]; } type128;
 typedef struct type256 { uint64_t x[4]; } type256;
 
 } // namespace lldb_private
 
 #endif // #if defined(__cplusplus)
 
 #endif // LLDB_LLDB_PRIVATE_TYPES_H

lldb/source/Breakpoint/BreakpointList.cpp

 //===-- BreakpointList.cpp ------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Breakpoint/BreakpointList.h"
 
 #include "lldb/Target/Target.h"
 
 #include "llvm/Support/Errc.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 static void NotifyChange(const BreakpointSP &bp, BreakpointEventType event) {
   Target &target = bp->GetTarget();
   if (target.EventTypeHasListeners(Target::eBroadcastBitBreakpointChanged))
     target.BroadcastEvent(Target::eBroadcastBitBreakpointChanged,
                           new Breakpoint::BreakpointEventData(event, bp));
 }
 
 BreakpointList::BreakpointList(bool is_internal)
     : m_mutex(), m_breakpoints(), m_next_break_id(0),
       m_is_internal(is_internal) {}
 
-BreakpointList::~BreakpointList() {}
+BreakpointList::~BreakpointList() = default;
 
 break_id_t BreakpointList::Add(BreakpointSP &bp_sp, bool notify) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
   // Internal breakpoint IDs are negative, normal ones are positive
   bp_sp->SetID(m_is_internal ? --m_next_break_id : ++m_next_break_id);
 
   m_breakpoints.push_back(bp_sp);

lldb/source/Breakpoint/BreakpointLocationCollection.cpp

 //===-- BreakpointLocationCollection.cpp ----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Breakpoint/BreakpointLocationCollection.h"
 #include "lldb/Breakpoint/Breakpoint.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadSpec.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 // BreakpointLocationCollection constructor
 BreakpointLocationCollection::BreakpointLocationCollection()
     : m_break_loc_collection(), m_collection_mutex() {}
 
 // Destructor
-BreakpointLocationCollection::~BreakpointLocationCollection() {}
+BreakpointLocationCollection::~BreakpointLocationCollection() = default;
 
 void BreakpointLocationCollection::Add(const BreakpointLocationSP &bp_loc) {
   std::lock_guard<std::mutex> guard(m_collection_mutex);
   BreakpointLocationSP old_bp_loc =
       FindByIDPair(bp_loc->GetBreakpoint().GetID(), bp_loc->GetID());
   if (!old_bp_loc.get())
     m_break_loc_collection.push_back(bp_loc);
 }

lldb/source/Breakpoint/BreakpointResolver.cpp

 //===-- BreakpointResolver.cpp --------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Breakpoint/BreakpointResolver.h"
 
 #include "lldb/Breakpoint/Breakpoint.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"
 // Have to include the other breakpoint resolver types here so the static
 // create from StructuredData can call them.
 #include "lldb/Breakpoint/BreakpointResolverAddress.h"
 #include "lldb/Breakpoint/BreakpointResolverFileLine.h"
 #include "lldb/Breakpoint/BreakpointResolverFileRegex.h"
BreakpointResolver::NameToResolverTy(llvm::StringRef name) {
   return UnknownResolver;
 }
 
 BreakpointResolver::BreakpointResolver(const BreakpointSP &bkpt,
                                        const unsigned char resolverTy,
                                        lldb::addr_t offset)
     : m_breakpoint(bkpt), m_offset(offset), SubclassID(resolverTy) {}
 
-BreakpointResolver::~BreakpointResolver() {}
+BreakpointResolver::~BreakpointResolver() = default;
 
 BreakpointResolverSP BreakpointResolver::CreateFromStructuredData(
     const StructuredData::Dictionary &resolver_dict, Status &error) {
   BreakpointResolverSP result_sp;
   if (!resolver_dict.IsValid()) {
     error.SetErrorString("Can't deserialize from an invalid data object.");
     return result_sp;
   }

lldb/source/Breakpoint/BreakpointSiteList.cpp

 //===-- BreakpointSiteList.cpp --------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Breakpoint/BreakpointSiteList.h"
 
 #include "lldb/Utility/Stream.h"
 #include <algorithm>
 
 using namespace lldb;
 using namespace lldb_private;
 
 BreakpointSiteList::BreakpointSiteList() : m_mutex(), m_bp_site_list() {}
 
-BreakpointSiteList::~BreakpointSiteList() {}
+BreakpointSiteList::~BreakpointSiteList() = default;
 
 // Add breakpoint site to the list.  However, if the element already exists in
 // the list, then we don't add it, and return LLDB_INVALID_BREAK_ID.
 
 lldb::break_id_t BreakpointSiteList::Add(const BreakpointSiteSP &bp) {
   lldb::addr_t bp_site_load_addr = bp->GetLoadAddress();
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   collection::iterator iter = m_bp_site_list.find(bp_site_load_addr);

lldb/source/Breakpoint/Stoppoint.cpp

 //===-- Stoppoint.cpp -----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Breakpoint/Stoppoint.h"
 #include "lldb/lldb-private.h"
 
 
 using namespace lldb;
 using namespace lldb_private;
 
 // Stoppoint constructor
-Stoppoint::Stoppoint() {}
+Stoppoint::Stoppoint() = default;
 
 // Destructor
-Stoppoint::~Stoppoint() {}
+Stoppoint::~Stoppoint() = default;
 
 break_id_t Stoppoint::GetID() const { return m_bid; }
 
 void Stoppoint::SetID(break_id_t bid) { m_bid = bid; }

lldb/source/Breakpoint/WatchpointList.cpp

 //===-- WatchpointList.cpp ------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Breakpoint/WatchpointList.h"
 #include "lldb/Breakpoint/Watchpoint.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 WatchpointList::WatchpointList() : m_watchpoints(), m_mutex() {}
 
-WatchpointList::~WatchpointList() {}
+WatchpointList::~WatchpointList() = default;
 
 // Add a watchpoint to the list.
 lldb::watch_id_t WatchpointList::Add(const WatchpointSP &wp_sp, bool notify) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   wp_sp->SetID(++m_next_wp_id);
   m_watchpoints.push_back(wp_sp);
   if (notify) {
     if (wp_sp->GetTarget().EventTypeHasListeners(

lldb/source/Commands/CommandObjectGUI.cpp

 using namespace lldb_private;
 
 // CommandObjectGUI
 
 CommandObjectGUI::CommandObjectGUI(CommandInterpreter &interpreter)
     : CommandObjectParsed(interpreter, "gui",
                           "Switch into the curses based GUI mode.", "gui") {}
 
-CommandObjectGUI::~CommandObjectGUI() {}
+CommandObjectGUI::~CommandObjectGUI() = default;
 
 bool CommandObjectGUI::DoExecute(Args &args, CommandReturnObject &result) {
 #if LLDB_ENABLE_CURSES
   if (args.GetArgumentCount() == 0) {
     Debugger &debugger = GetDebugger();
 
     File &input = debugger.GetInputFile();
     File &output = debugger.GetOutputFile();

lldb/source/Commands/CommandObjectHelp.h

 //===-- CommandObjectHelp.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_SOURCE_COMMANDS_COMMANDOBJECTHELP_H
 #define LLDB_SOURCE_COMMANDS_COMMANDOBJECTHELP_H
 
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Interpreter/CommandObject.h"
 #include "lldb/Interpreter/Options.h"
 
 namespace lldb_private {
 
 // CommandObjectHelp
 
 class CommandObjectHelp : public CommandObjectParsed {
 public:
   CommandObjectHelp(CommandInterpreter &interpreter);
 
   ~CommandObjectHelp() override;
 
   void HandleCompletion(CompletionRequest &request) override;
 
   static void GenerateAdditionalHelpAvenuesMessage(
       Stream *s, llvm::StringRef command, llvm::StringRef prefix,
       llvm::StringRef subcommand, bool include_upropos = true,
       bool include_type_lookup = true);
 
   class CommandOptions : public Options {
   public:
     CommandOptions() : Options() {}
 
-    ~CommandOptions() override {}
+    ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
       const int short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
       case 'a':

lldb/source/Commands/CommandObjectLanguage.cpp

 CommandObjectLanguage::CommandObjectLanguage(CommandInterpreter &interpreter)
     : CommandObjectMultiword(
           interpreter, "language", "Commands specific to a source language.",
           "language <language-name> <subcommand> [<subcommand-options>]") {
   // Let the LanguageRuntime populates this command with subcommands
   LanguageRuntime::InitializeCommands(this);
 }
 
-CommandObjectLanguage::~CommandObjectLanguage() {}
+CommandObjectLanguage::~CommandObjectLanguage() = default;

lldb/source/Commands/CommandObjectPlatform.cpp

static mode_t ParsePermissionString(llvm::StringRef permissions) {
   return user | group | world;
 }
 
 #define LLDB_OPTIONS_permissions
 #include "CommandOptions.inc"
 
 class OptionPermissions : public OptionGroup {
 public:
-  OptionPermissions() {}
+  OptionPermissions() = default;
 
   ~OptionPermissions() override = default;
 
   lldb_private::Status
   SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                  ExecutionContext *execution_context) override {
     Status error;
     char short_option = (char)GetDefinitions()[option_idx].short_option;

lldb/source/Commands/CommandObjectQuit.cpp

 using namespace lldb_private;
 
 // CommandObjectQuit
 
 CommandObjectQuit::CommandObjectQuit(CommandInterpreter &interpreter)
     : CommandObjectParsed(interpreter, "quit", "Quit the LLDB debugger.",
                           "quit [exit-code]") {}
 
-CommandObjectQuit::~CommandObjectQuit() {}
+CommandObjectQuit::~CommandObjectQuit() = default;
 
 // returns true if there is at least one alive process is_a_detach will be true
 // if all alive processes will be detached when you quit and false if at least
 // one process will be killed instead
 bool CommandObjectQuit::ShouldAskForConfirmation(bool &is_a_detach) {
   if (!m_interpreter.GetPromptOnQuit())
     return false;
   bool should_prompt = false;

lldb/source/Commands/CommandObjectRegexCommand.cpp

CommandObjectRegexCommand::CommandObjectRegexCommand(
     CommandInterpreter &interpreter, llvm::StringRef name, llvm::StringRef help,
     llvm::StringRef syntax, uint32_t max_matches, uint32_t completion_type_mask,
     bool is_removable)
     : CommandObjectRaw(interpreter, name, help, syntax),
       m_max_matches(max_matches), m_completion_type_mask(completion_type_mask),
       m_entries(), m_is_removable(is_removable) {}
 
 // Destructor
-CommandObjectRegexCommand::~CommandObjectRegexCommand() {}
+CommandObjectRegexCommand::~CommandObjectRegexCommand() = default;
 
 bool CommandObjectRegexCommand::DoExecute(llvm::StringRef command,
                                           CommandReturnObject &result) {
   EntryCollection::const_iterator pos, end = m_entries.end();
   for (pos = m_entries.begin(); pos != end; ++pos) {
     llvm::SmallVector<llvm::StringRef, 4> matches;
     if (pos->regex.Execute(command, &matches)) {
       std::string new_command(pos->command);

lldb/source/Commands/CommandObjectScript.cpp

 
 CommandObjectScript::CommandObjectScript(CommandInterpreter &interpreter)
     : CommandObjectRaw(
           interpreter, "script",
           "Invoke the script interpreter with provided code and display any "
           "results.  Start the interactive interpreter if no code is supplied.",
           "script [--language <scripting-language> --] [<script-code>]") {}
 
-CommandObjectScript::~CommandObjectScript() {}
+CommandObjectScript::~CommandObjectScript() = default;
 
 bool CommandObjectScript::DoExecute(llvm::StringRef command,
                                     CommandReturnObject &result) {
   // Try parsing the language option but when the command contains a raw part
   // separated by the -- delimiter.
   OptionsWithRaw raw_args(command);
   if (raw_args.HasArgs()) {
     if (!ParseOptions(raw_args.GetArgs(), result))

lldb/source/Commands/CommandObjectTarget.cpp

     },
 };
 
 #define LLDB_OPTIONS_target_dependents
 #include "CommandOptions.inc"
 
 class OptionGroupDependents : public OptionGroup {
 public:
-  OptionGroupDependents() {}
+  OptionGroupDependents() = default;
 
-  ~OptionGroupDependents() override {}
+  ~OptionGroupDependents() override = default;
 
   llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
     return llvm::makeArrayRef(g_target_dependents_options);
   }
 
   Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
                         ExecutionContext *execution_context) override {
     Status error;

lldb/source/Commands/CommandObjectVersion.cpp

 using namespace lldb_private;
 
 // CommandObjectVersion
 
 CommandObjectVersion::CommandObjectVersion(CommandInterpreter &interpreter)
     : CommandObjectParsed(interpreter, "version",
                           "Show the LLDB debugger version.", "version") {}
 
-CommandObjectVersion::~CommandObjectVersion() {}
+CommandObjectVersion::~CommandObjectVersion() = default;
 
 bool CommandObjectVersion::DoExecute(Args &args, CommandReturnObject &result) {
   if (args.GetArgumentCount() == 0) {
     result.AppendMessageWithFormat("%s\n", lldb_private::GetVersion());
     result.SetStatus(eReturnStatusSuccessFinishResult);
   } else {
     result.AppendError("the version command takes no arguments.");
     result.SetStatus(eReturnStatusFailed);
   }
   return true;
 }

lldb/source/Core/AddressRange.cpp

 //===-- AddressRange.cpp --------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/AddressRange.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/lldb-defines.h"
 

 
 AddressRange::AddressRange(const lldb::SectionSP &section, addr_t offset,
                            addr_t byte_size)
     : m_base_addr(section, offset), m_byte_size(byte_size) {}
 
 AddressRange::AddressRange(const Address &so_addr, addr_t byte_size)
     : m_base_addr(so_addr), m_byte_size(byte_size) {}
 
-AddressRange::~AddressRange() {}
+AddressRange::~AddressRange() = default;
 
 bool AddressRange::Contains(const Address &addr) const {
   SectionSP range_sect_sp = GetBaseAddress().GetSection();
   SectionSP addr_sect_sp = addr.GetSection();
   if (range_sect_sp) {
     if (!addr_sect_sp ||
         range_sect_sp->GetModule() != addr_sect_sp->GetModule())
       return false; // Modules do not match.

lldb/source/Core/AddressResolver.cpp

 //===-- AddressResolver.cpp -----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/AddressResolver.h"
 
 #include "lldb/Core/SearchFilter.h"
 
 namespace lldb_private {
 class ModuleList;
 }
 
 using namespace lldb_private;
 
 // AddressResolver:
-AddressResolver::AddressResolver() {}
+AddressResolver::AddressResolver() = default;
 
-AddressResolver::~AddressResolver() {}
+AddressResolver::~AddressResolver() = default;
 
 void AddressResolver::ResolveAddressInModules(SearchFilter &filter,
                                               ModuleList &modules) {
   filter.SearchInModuleList(*this, modules);
 }
 
 void AddressResolver::ResolveAddress(SearchFilter &filter) {
   filter.Search(*this);

lldb/source/Core/AddressResolverFileLine.cpp

 //===-- AddressResolverFileLine.cpp ---------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/AddressResolverFileLine.h"
 
 #include "lldb/Core/Address.h"
 #include "lldb/Core/AddressRange.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/LineEntry.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Log.h"

 using namespace lldb;
 using namespace lldb_private;
 
 // AddressResolverFileLine:
 AddressResolverFileLine::AddressResolverFileLine(
     SourceLocationSpec location_spec)
     : AddressResolver(), m_src_location_spec(location_spec) {}
 
-AddressResolverFileLine::~AddressResolverFileLine() {}
+AddressResolverFileLine::~AddressResolverFileLine() = default;
 
 Searcher::CallbackReturn
 AddressResolverFileLine::SearchCallback(SearchFilter &filter,
                                         SymbolContext &context, Address *addr) {
   SymbolContextList sc_list;
   CompileUnit *cu = context.comp_unit;
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));

lldb/source/Core/FileLineResolver.cpp

 //===-- FileLineResolver.cpp ----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/FileLineResolver.h"
 
 #include "lldb/Core/FileSpecList.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Stream.h"
 
 #include <string>
 
 namespace lldb_private {
 class Address;
 }
 
 using namespace lldb;
 using namespace lldb_private;
 
 // FileLineResolver:
 FileLineResolver::FileLineResolver(const FileSpec &file_spec, uint32_t line_no,
                                    bool check_inlines)
     : Searcher(), m_file_spec(file_spec), m_line_number(line_no),
       m_inlines(check_inlines) {}
 
-FileLineResolver::~FileLineResolver() {}
+FileLineResolver::~FileLineResolver() = default;
 
 Searcher::CallbackReturn
 FileLineResolver::SearchCallback(SearchFilter &filter, SymbolContext &context,
                                  Address *addr) {
   CompileUnit *cu = context.comp_unit;
 
   if (m_inlines || m_file_spec.Compare(cu->GetPrimaryFile(), m_file_spec,
                                        (bool)m_file_spec.GetDirectory())) {

lldb/source/Core/ModuleChild.cpp

 //===-- ModuleChild.cpp ---------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/ModuleChild.h"
 
 using namespace lldb_private;
 
 ModuleChild::ModuleChild(const lldb::ModuleSP &module_sp)
     : m_module_wp(module_sp) {}
 
-ModuleChild::~ModuleChild() {}
+ModuleChild::~ModuleChild() = default;
 
 const ModuleChild &ModuleChild::operator=(const ModuleChild &rhs) {
   if (this != &rhs)
     m_module_wp = rhs.m_module_wp;
   return *this;
 }
 
 lldb::ModuleSP ModuleChild::GetModule() const { return m_module_wp.lock(); }
 
 void ModuleChild::SetModule(const lldb::ModuleSP &module_sp) {
   m_module_wp = module_sp;
 }

lldb/source/Core/PluginManager.cpp

 //===-- PluginManager.cpp -------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/PluginManager.h"
 
 #include "lldb/Core/Debugger.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Interpreter/OptionValueProperties.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Status.h"

 
 using namespace lldb;
 using namespace lldb_private;
 
 typedef bool (*PluginInitCallback)();
 typedef void (*PluginTermCallback)();
 
 struct PluginInfo {
-  PluginInfo() {}
+  PluginInfo() = default;
 
   llvm::sys::DynamicLibrary library;
   PluginInitCallback plugin_init_callback = nullptr;
   PluginTermCallback plugin_term_callback = nullptr;
 };
 
 typedef std::map<FileSpec, PluginInfo> PluginTerminateMap;
 

lldb/source/Core/SourceManager.cpp

 //===-- SourceManager.cpp -------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/SourceManager.h"
 
 #include "lldb/Core/Address.h"
 #include "lldb/Core/AddressRange.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/FormatEntity.h"
 #include "lldb/Core/Highlighter.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
: m_last_line(0), m_last_count(0), m_default_set(false),
       m_target_wp(target_sp),
       m_debugger_wp(target_sp->GetDebugger().shared_from_this()) {}
 
 SourceManager::SourceManager(const DebuggerSP &debugger_sp)
     : m_last_line(0), m_last_count(0), m_default_set(false), m_target_wp(),
       m_debugger_wp(debugger_sp) {}
 
 // Destructor
-SourceManager::~SourceManager() {}
+SourceManager::~SourceManager() = default;
 
 SourceManager::FileSP SourceManager::GetFile(const FileSpec &file_spec) {
   if (!file_spec)
     return nullptr;
 
   DebuggerSP debugger_sp(m_debugger_wp.lock());
   FileSP file_sp;
   if (debugger_sp && debugger_sp->GetUseSourceCache())

lldb/source/Core/StreamFile.cpp

 //===-- StreamFile.cpp ----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Utility/Log.h"
 
 #include <cstdio>
 
 using namespace lldb;
 using namespace lldb_private;
 
StreamFile::StreamFile(const char *path, File::OpenOptions options,
   else {
     // TODO refactor this so the error gets popagated up instead of logged here.
     LLDB_LOG_ERROR(GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST), file.takeError(),
                    "Cannot open {1}: {0}", path);
     m_file_sp = std::make_shared<File>();
   }
 }
 
-StreamFile::~StreamFile() {}
+StreamFile::~StreamFile() = default;
 
 void StreamFile::Flush() { m_file_sp->Flush(); }
 
 size_t StreamFile::WriteImpl(const void *s, size_t length) {
   m_file_sp->Write(s, length);
   return length;
 }

lldb/source/Core/ValueObject.cpp

       m_data.SetByteOrder(arch.GetByteOrder());
       m_data.SetAddressByteSize(arch.GetAddressByteSize());
     }
   }
   m_manager->ManageObject(this);
 }
 
 // Destructor
-ValueObject::~ValueObject() {}
+ValueObject::~ValueObject() = default;
 
 bool ValueObject::UpdateValueIfNeeded(bool update_format) {
 
   bool did_change_formats = false;
 
   if (update_format)
     did_change_formats = UpdateFormatsIfNeeded();
 

     }
   }
 }
 
 ValueObject::EvaluationPoint::EvaluationPoint(
     const ValueObject::EvaluationPoint &rhs)
     : m_mod_id(), m_exe_ctx_ref(rhs.m_exe_ctx_ref), m_needs_update(true) {}
 
-ValueObject::EvaluationPoint::~EvaluationPoint() {}
+ValueObject::EvaluationPoint::~EvaluationPoint() = default;
 
 // This function checks the EvaluationPoint against the current process state.
 // If the current state matches the evaluation point, or the evaluation point
 // is already invalid, then we return false, meaning "no change".  If the
 // current state is different, we update our state, and return true meaning
 // "yes, change".  If we did see a change, we also set m_needs_update to true,
 // so future calls to NeedsUpdate will return true. exe_scope will be set to
 // the current execution context scope.

lldb/source/Core/ValueObjectCast.cpp

 //===-- ValueObjectCast.cpp -----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/ValueObjectCast.h"
 
 #include "lldb/Core/Value.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Utility/Scalar.h"
 #include "lldb/Utility/Status.h"
 

 
 ValueObjectCast::ValueObjectCast(ValueObject &parent, ConstString name,
                                  const CompilerType &cast_type)
     : ValueObject(parent), m_cast_type(cast_type) {
   SetName(name);
   m_value.SetCompilerType(cast_type);
 }
 
-ValueObjectCast::~ValueObjectCast() {}
+ValueObjectCast::~ValueObjectCast() = default;
 
 CompilerType ValueObjectCast::GetCompilerTypeImpl() { return m_cast_type; }
 
 size_t ValueObjectCast::CalculateNumChildren(uint32_t max) {
   ExecutionContext exe_ctx(GetExecutionContextRef());
   auto children_count = GetCompilerType().GetNumChildren(
       true, &exe_ctx);
   return children_count <= max ? children_count : max;

lldb/source/Core/ValueObjectChild.cpp

 //===-- ValueObjectChild.cpp ----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/ValueObjectChild.h"
 
 #include "lldb/Core/Value.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/Flags.h"
 #include "lldb/Utility/Scalar.h"
 #include "lldb/Utility/Status.h"
: ValueObject(parent), m_compiler_type(compiler_type),
       m_bitfield_bit_offset(bitfield_bit_offset),
       m_is_base_class(is_base_class), m_is_deref_of_parent(is_deref_of_parent),
       m_can_update_with_invalid_exe_ctx() {
   m_name = name;
   SetAddressTypeOfChildren(child_ptr_or_ref_addr_type);
   SetLanguageFlags(language_flags);
 }
 
-ValueObjectChild::~ValueObjectChild() {}
+ValueObjectChild::~ValueObjectChild() = default;
 
 lldb::ValueType ValueObjectChild::GetValueType() const {
   return m_parent->GetValueType();
 }
 
 size_t ValueObjectChild::CalculateNumChildren(uint32_t max) {
   ExecutionContext exe_ctx(GetExecutionContextRef());
   auto children_count = GetCompilerType().GetNumChildren(true, &exe_ctx);

lldb/source/Core/ValueObjectConstResult.cpp

     : ValueObject(exe_scope, manager), m_impl(this) {
   m_value = value;
   m_name = name;
   ExecutionContext exe_ctx;
   exe_scope->CalculateExecutionContext(exe_ctx);
   m_error = m_value.GetValueAsData(&exe_ctx, m_data, module);
 }
 
-ValueObjectConstResult::~ValueObjectConstResult() {}
+ValueObjectConstResult::~ValueObjectConstResult() = default;
 
 CompilerType ValueObjectConstResult::GetCompilerTypeImpl() {
   return m_value.GetCompilerType();
 }
 
 lldb::ValueType ValueObjectConstResult::GetValueType() const {
   return eValueTypeConstResult;
 }

lldb/source/Core/ValueObjectConstResultCast.cpp

 //===-- ValueObjectConstResultCast.cpp ------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/ValueObjectConstResultCast.h"
 
 namespace lldb_private {
 class DataExtractor;
 }
 namespace lldb_private {
 class Status;
 }
 namespace lldb_private {
 class ValueObject;
 }
 
 using namespace lldb_private;
 
 ValueObjectConstResultCast::ValueObjectConstResultCast(
     ValueObject &parent, ConstString name, const CompilerType &cast_type,
     lldb::addr_t live_address)
     : ValueObjectCast(parent, name, cast_type), m_impl(this, live_address) {
   m_name = name;
 }
 
-ValueObjectConstResultCast::~ValueObjectConstResultCast() {}
+ValueObjectConstResultCast::~ValueObjectConstResultCast() = default;
 
 lldb::ValueObjectSP ValueObjectConstResultCast::Dereference(Status &error) {
   return m_impl.Dereference(error);
 }
 
 lldb::ValueObjectSP ValueObjectConstResultCast::GetSyntheticChildAtOffset(
     uint32_t offset, const CompilerType &type, bool can_create,
     ConstString name_const_str) {

lldb/source/Core/ValueObjectConstResultChild.cpp

 //===-- ValueObjectConstResultChild.cpp -----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/ValueObjectConstResultChild.h"
 
 #include "lldb/lldb-private-enumerations.h"
 namespace lldb_private {
 class DataExtractor;
 }
 namespace lldb_private {
 class Status;
 }
ValueObjectConstResultChild::ValueObjectConstResultChild(
     uint64_t language_flags)
     : ValueObjectChild(parent, compiler_type, name, byte_size, byte_offset,
                        bitfield_bit_size, bitfield_bit_offset, is_base_class,
                        is_deref_of_parent, eAddressTypeLoad, language_flags),
       m_impl(this, live_address) {
   m_name = name;
 }
 
-ValueObjectConstResultChild::~ValueObjectConstResultChild() {}
+ValueObjectConstResultChild::~ValueObjectConstResultChild() = default;
 
 lldb::ValueObjectSP ValueObjectConstResultChild::Dereference(Status &error) {
   return m_impl.Dereference(error);
 }
 
 lldb::ValueObjectSP ValueObjectConstResultChild::GetSyntheticChildAtOffset(
     uint32_t offset, const CompilerType &type, bool can_create,
     ConstString name_const_str) {

lldb/source/Core/ValueObjectMemory.cpp

       m_value.GetScalar() = file_address;
     } else {
       m_value.GetScalar() = m_address.GetOffset();
       m_value.SetValueType(Value::ValueType::Scalar);
     }
   }
 }
 
-ValueObjectMemory::~ValueObjectMemory() {}
+ValueObjectMemory::~ValueObjectMemory() = default;
 
 CompilerType ValueObjectMemory::GetCompilerTypeImpl() {
   if (m_type_sp)
     return m_type_sp->GetForwardCompilerType();
   return m_compiler_type;
 }
 
 ConstString ValueObjectMemory::GetTypeName() {

lldb/source/Core/ValueObjectRegister.cpp

 //===-- ValueObjectRegister.cpp -------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/ValueObjectRegister.h"
 
 #include "lldb/Core/Module.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/TypeSystem.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
: ValueObject(exe_scope, manager), m_reg_ctx_sp(reg_ctx),
       m_reg_set(nullptr), m_reg_set_idx(reg_set_idx) {
   assert(reg_ctx);
   m_reg_set = reg_ctx->GetRegisterSet(m_reg_set_idx);
   if (m_reg_set) {
     m_name.SetCString(m_reg_set->name);
   }
 }
 
-ValueObjectRegisterSet::~ValueObjectRegisterSet() {}
+ValueObjectRegisterSet::~ValueObjectRegisterSet() = default;
 
 CompilerType ValueObjectRegisterSet::GetCompilerTypeImpl() {
   return CompilerType();
 }
 
 ConstString ValueObjectRegisterSet::GetTypeName() { return ConstString(); }
 
 ConstString ValueObjectRegisterSet::GetQualifiedTypeName() {
ValueObjectRegister::ValueObjectRegister(ExecutionContextScope *exe_scope,
                                          lldb::RegisterContextSP &reg_ctx,
                                          uint32_t reg_num)
     : ValueObject(exe_scope, manager), m_reg_ctx_sp(reg_ctx), m_reg_info(),
       m_reg_value(), m_type_name(), m_compiler_type() {
   assert(reg_ctx);
   ConstructObject(reg_num);
 }
 
-ValueObjectRegister::~ValueObjectRegister() {}
+ValueObjectRegister::~ValueObjectRegister() = default;
 
 CompilerType ValueObjectRegister::GetCompilerTypeImpl() {
   if (!m_compiler_type.IsValid()) {
     ExecutionContext exe_ctx(GetExecutionContextRef());
     if (auto *target = exe_ctx.GetTargetPtr()) {
       if (auto *exe_module = target->GetExecutableModulePointer()) {
         auto type_system_or_err =
             exe_module->GetTypeSystemForLanguage(eLanguageTypeC);

lldb/source/Core/ValueObjectVariable.cpp

 //===-- ValueObjectVariable.cpp -------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/ValueObjectVariable.h"
 
 #include "lldb/Core/Address.h"
 #include "lldb/Core/AddressRange.h"
 #include "lldb/Core/Declaration.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Expression/DWARFExpression.h"
 #include "lldb/Symbol/Function.h"
ValueObjectVariable::ValueObjectVariable(ExecutionContextScope *exe_scope,
                                          ValueObjectManager &manager,
                                          const lldb::VariableSP &var_sp)
     : ValueObject(exe_scope, manager), m_variable_sp(var_sp) {
   // Do not attempt to construct one of these objects with no variable!
   assert(m_variable_sp.get() != nullptr);
   m_name = var_sp->GetName();
 }
 
-ValueObjectVariable::~ValueObjectVariable() {}
+ValueObjectVariable::~ValueObjectVariable() = default;
 
 CompilerType ValueObjectVariable::GetCompilerTypeImpl() {
   Type *var_type = m_variable_sp->GetType();
   if (var_type)
     return var_type->GetForwardCompilerType();
   return CompilerType();
 }
 

lldb/source/DataFormatters/TypeFormat.cpp

 //===-- TypeFormat.cpp ----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/DataFormatters/TypeFormat.h"
 
 
 
 
 #include "lldb/lldb-enumerations.h"
 #include "lldb/lldb-public.h"
 
 #include "lldb/Core/DumpDataExtractor.h"
 #include "lldb/DataFormatters/FormatManager.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/TypeList.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/StreamString.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 TypeFormatImpl::TypeFormatImpl(const Flags &flags) : m_flags(flags) {}
 
-TypeFormatImpl::~TypeFormatImpl() {}
+TypeFormatImpl::~TypeFormatImpl() = default;
 
 TypeFormatImpl_Format::TypeFormatImpl_Format(lldb::Format f,
                                              const TypeFormatImpl::Flags &flags)
     : TypeFormatImpl(flags), m_format(f) {}
 
-TypeFormatImpl_Format::~TypeFormatImpl_Format() {}
+TypeFormatImpl_Format::~TypeFormatImpl_Format() = default;
 
 bool TypeFormatImpl_Format::FormatObject(ValueObject *valobj,
                                          std::string &dest) const {
   if (!valobj)
     return false;
   if (valobj->CanProvideValue()) {
     Value &value(valobj->GetValue());
     const Value::ContextType context_type = value.GetContextType();
sstr.Printf("%s%s%s%s", FormatManager::GetFormatAsCString(GetFormat()),
               SkipsReferences() ? " (skip references)" : "");
   return std::string(sstr.GetString());
 }
 
 TypeFormatImpl_EnumType::TypeFormatImpl_EnumType(
     ConstString type_name, const TypeFormatImpl::Flags &flags)
     : TypeFormatImpl(flags), m_enum_type(type_name), m_types() {}
 
-TypeFormatImpl_EnumType::~TypeFormatImpl_EnumType() {}
+TypeFormatImpl_EnumType::~TypeFormatImpl_EnumType() = default;
 
 bool TypeFormatImpl_EnumType::FormatObject(ValueObject *valobj,
                                            std::string &dest) const {
   dest.clear();
   if (!valobj)
     return false;
   if (!valobj->CanProvideValue())
     return false;

lldb/source/DataFormatters/TypeSummary.cpp

 //===-- TypeSummary.cpp ---------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/DataFormatters/TypeSummary.h"
 
 
 
 
 #include "lldb/lldb-enumerations.h"
 #include "lldb/lldb-public.h"
 
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/DataFormatters/ValueObjectPrinter.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/StreamString.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-TypeSummaryOptions::TypeSummaryOptions() {}
+TypeSummaryOptions::TypeSummaryOptions() = default;
 
 lldb::LanguageType TypeSummaryOptions::GetLanguage() const { return m_lang; }
 
 lldb::TypeSummaryCapping TypeSummaryOptions::GetCapping() const {
   return m_capping;
 }
 
 TypeSummaryOptions &TypeSummaryOptions::SetLanguage(lldb::LanguageType lang) {

lldb/source/DataFormatters/TypeSynthetic.cpp

 
   m_interpreter = target_sp->GetDebugger().GetScriptInterpreter();
 
   if (m_interpreter != nullptr)
     m_wrapper_sp = m_interpreter->CreateSyntheticScriptedProvider(
         m_python_class.c_str(), backend.GetSP());
 }
 
-ScriptedSyntheticChildren::FrontEnd::~FrontEnd() {}
+ScriptedSyntheticChildren::FrontEnd::~FrontEnd() = default;
 
 lldb::ValueObjectSP
 ScriptedSyntheticChildren::FrontEnd::GetChildAtIndex(size_t idx) {
   if (!m_wrapper_sp || !m_interpreter)
     return lldb::ValueObjectSP();
 
   return m_interpreter->GetChildAtIndex(m_wrapper_sp, idx);
 }

lldb/source/Expression/DWARFExpression.cpp

 //===-- DWARFExpression.cpp -----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Expression/DWARFExpression.h"
 
 #include <cinttypes>
 
 #include <vector>
 
 #include "lldb/Core/Module.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Core/dwarf.h"
DWARFExpression::DWARFExpression(lldb::ModuleSP module_sp,
                                  const DWARFUnit *dwarf_cu)
     : m_module_wp(), m_data(data), m_dwarf_cu(dwarf_cu),
       m_reg_kind(eRegisterKindDWARF) {
   if (module_sp)
     m_module_wp = module_sp;
 }
 
 // Destructor
-DWARFExpression::~DWARFExpression() {}
+DWARFExpression::~DWARFExpression() = default;
 
 bool DWARFExpression::IsValid() const { return m_data.GetByteSize() > 0; }
 
 void DWARFExpression::UpdateValue(uint64_t const_value,
                                   lldb::offset_t const_value_byte_size,
                                   uint8_t addr_byte_size) {
   if (!const_value_byte_size)
     return;

lldb/source/Expression/ExpressionVariable.cpp

 //===-- ExpressionVariable.cpp --------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Expression/ExpressionVariable.h"
 #include "lldb/Expression/IRExecutionUnit.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/Log.h"
 
 using namespace lldb_private;
 
-ExpressionVariable::~ExpressionVariable() {}
+ExpressionVariable::~ExpressionVariable() = default;
 
 uint8_t *ExpressionVariable::GetValueBytes() {
   llvm::Optional<uint64_t> byte_size = m_frozen_sp->GetByteSize();
   if (byte_size && *byte_size) {
     if (m_frozen_sp->GetDataExtractor().GetByteSize() < *byte_size) {
       m_frozen_sp->GetValue().ResizeData(*byte_size);
       m_frozen_sp->GetValue().GetData(m_frozen_sp->GetDataExtractor());
     }
     return const_cast<uint8_t *>(
         m_frozen_sp->GetDataExtractor().GetDataStart());
   }
   return nullptr;
 }
 
-PersistentExpressionState::~PersistentExpressionState() {}
+PersistentExpressionState::~PersistentExpressionState() = default;
 
 lldb::addr_t PersistentExpressionState::LookupSymbol(ConstString name) {
   SymbolMap::iterator si = m_symbol_map.find(name.GetCString());
 
   if (si != m_symbol_map.end())
     return si->second;
   else
     return LLDB_INVALID_ADDRESS;

lldb/source/Expression/IRExecutionUnit.cpp

   m_module_up.reset();
   m_execution_engine_up.reset();
   m_context_up.reset();
 }
 
 IRExecutionUnit::MemoryManager::MemoryManager(IRExecutionUnit &parent)
     : m_default_mm_up(new llvm::SectionMemoryManager()), m_parent(parent) {}
 
-IRExecutionUnit::MemoryManager::~MemoryManager() {}
+IRExecutionUnit::MemoryManager::~MemoryManager() = default;
 
 lldb::SectionType IRExecutionUnit::GetSectionTypeFromSectionName(
     const llvm::StringRef &name, IRExecutionUnit::AllocationKind alloc_kind) {
   lldb::SectionType sect_type = lldb::eSectionTypeCode;
   switch (alloc_kind) {
   case AllocationKind::Stub:
     sect_type = lldb::eSectionTypeCode;
     break;

lldb/source/Expression/IRInterpreter.cpp

                                                  : lldb::eByteOrderBig);
     m_addr_byte_size = (target_data.getPointerSize(0));
 
     m_frame_process_address = stack_frame_bottom;
     m_frame_size = stack_frame_top - stack_frame_bottom;
     m_stack_pointer = stack_frame_top;
   }
 
-  ~InterpreterStackFrame() {}
+  ~InterpreterStackFrame() = default;
 
   void Jump(const BasicBlock *bb) {
     m_prev_bb = m_bb;
     m_bb = bb;
     m_ii = m_bb->begin();
     m_ie = m_bb->end();
   }
 

lldb/source/Expression/UserExpression.cpp

 //===-- UserExpression.cpp ------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Host/Config.h"
 
 #include <cstdio>
 #if HAVE_SYS_TYPES_H
 #include <sys/types.h>
 #endif
 
 #include <cstdlib>
 #include <map>
UserExpression::UserExpression(ExecutionContextScope &exe_scope,
                                llvm::StringRef expr, llvm::StringRef prefix,
                                lldb::LanguageType language,
                                ResultType desired_type,
                                const EvaluateExpressionOptions &options)
     : Expression(exe_scope), m_expr_text(std::string(expr)),
       m_expr_prefix(std::string(prefix)), m_language(language),
       m_desired_type(desired_type), m_options(options) {}
 
-UserExpression::~UserExpression() {}
+UserExpression::~UserExpression() = default;
 
 void UserExpression::InstallContext(ExecutionContext &exe_ctx) {
   m_jit_process_wp = exe_ctx.GetProcessSP();
 
   lldb::StackFrameSP frame_sp = exe_ctx.GetFrameSP();
 
   if (frame_sp)
     m_address = frame_sp->GetFrameCodeAddress();

lldb/source/Host/common/HostProcess.cpp

 //===-- HostProcess.cpp ---------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Host/HostProcess.h"
 #include "lldb/Host/HostNativeProcess.h"
 #include "lldb/Host/HostThread.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 HostProcess::HostProcess() : m_native_process(new HostNativeProcess) {}
 
 HostProcess::HostProcess(lldb::process_t process)
     : m_native_process(new HostNativeProcess(process)) {}
 
-HostProcess::~HostProcess() {}
+HostProcess::~HostProcess() = default;
 
 Status HostProcess::Terminate() { return m_native_process->Terminate(); }
 
 Status HostProcess::GetMainModule(FileSpec &file_spec) const {
   return m_native_process->GetMainModule(file_spec);
 }
 
 lldb::pid_t HostProcess::GetProcessId() const {

lldb/source/Host/common/NativeRegisterContext.cpp

 //===-- NativeRegisterContext.cpp -----------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Host/common/NativeRegisterContext.h"
 
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/RegisterValue.h"
 
 #include "lldb/Host/PosixApi.h"
 #include "lldb/Host/common/NativeProcessProtocol.h"
 #include "lldb/Host/common/NativeThreadProtocol.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 NativeRegisterContext::NativeRegisterContext(NativeThreadProtocol &thread)
     : m_thread(thread) {}
 
 // Destructor
-NativeRegisterContext::~NativeRegisterContext() {}
+NativeRegisterContext::~NativeRegisterContext() = default;
 
 // FIXME revisit invalidation, process stop ids, etc.  Right now we don't
 // support caching in NativeRegisterContext.  We can do this later by utilizing
 // NativeProcessProtocol::GetStopID () and adding a stop id to
 // NativeRegisterContext.
 
 // void
 // NativeRegisterContext::InvalidateIfNeeded (bool force) {

lldb/source/Host/common/PseudoTerminal.cpp

 //===-- PseudoTerminal.cpp ------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Host/PseudoTerminal.h"
 #include "lldb/Host/Config.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/Errno.h"
 #include <cassert>
 #include <climits>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <mutex>
 #if defined(TIOCSCTTY)
 #include <sys/ioctl.h>
 #endif
 
 #include "lldb/Host/PosixApi.h"
 
 #if defined(__ANDROID__)
 int posix_openpt(int flags);
 #endif
 
 using namespace lldb_private;
 
 // PseudoTerminal constructor
-PseudoTerminal::PseudoTerminal() {}
+PseudoTerminal::PseudoTerminal() = default;
 
 // Destructor
 //
 // The destructor will close the primary and secondary file descriptors if they
 // are valid and ownership has not been released using the
 // ReleasePrimaryFileDescriptor() or the ReleaseSaveFileDescriptor() member
 // functions.
 PseudoTerminal::~PseudoTerminal() {

lldb/source/Host/common/SocketAddress.cpp

 //       there is compelling reason.
 //
 //===----------------------------------------------------------------------===//
 
 #if defined(_MSC_VER)
 #define _WINSOCK_DEPRECATED_NO_WARNINGS
 #endif
 
 #include "lldb/Host/SocketAddress.h"
 #include <cstddef>
 #include <cstdio>
 
 #if !defined(_WIN32)
 #include <arpa/inet.h>
 #endif
 
 #include <cassert>
SocketAddress::SocketAddress(const struct sockaddr_storage &s) {
   m_socket_addr.sa_storage = s;
 }
 
 SocketAddress::SocketAddress(const struct addrinfo *addr_info) {
   *this = addr_info;
 }
 
 // Destructor
-SocketAddress::~SocketAddress() {}
+SocketAddress::~SocketAddress() = default;
 
 void SocketAddress::Clear() {
   memset(&m_socket_addr, 0, sizeof(m_socket_addr));
 }
 
 bool SocketAddress::IsValid() const { return GetLength() != 0; }
 
 static socklen_t GetFamilyLength(sa_family_t family) {

lldb/source/Host/common/Terminal.cpp

 //===-- Terminal.cpp ------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Host/Terminal.h"
 
 #include "lldb/Host/Config.h"
 #include "lldb/Host/PosixApi.h"
 #include "llvm/ADT/STLExtras.h"
 
 #include <csignal>
 #include <fcntl.h>
 

 #if LLDB_ENABLE_TERMIOS
       ,
       m_termios_up()
 #endif
 {
 }
 
 // Destructor
-TerminalState::~TerminalState() {}
+TerminalState::~TerminalState() = default;
 
 void TerminalState::Clear() {
   m_tty.Clear();
   m_tflags = -1;
 #if LLDB_ENABLE_TERMIOS
   m_termios_up.reset();
 #endif
   m_process_group = -1;

 }
 
 // Returns true if m_process_group is valid
 bool TerminalState::ProcessGroupIsValid() const {
   return static_cast<int32_t>(m_process_group) != -1;
 }
 
 // Constructor
-TerminalStateSwitcher::TerminalStateSwitcher() {}
+TerminalStateSwitcher::TerminalStateSwitcher() = default;
 
 // Destructor
-TerminalStateSwitcher::~TerminalStateSwitcher() {}
+TerminalStateSwitcher::~TerminalStateSwitcher() = default;
 
 // Returns the number of states that this switcher contains
 uint32_t TerminalStateSwitcher::GetNumberOfStates() const {
   return llvm::array_lengthof(m_ttystates);
 }
 
 // Restore the state at index "idx".
 //

lldb/source/Host/common/XML.cpp

 //===-- XML.cpp -----------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include <stdlib.h> /* atof */
 
 #include "lldb/Host/Config.h"
 #include "lldb/Host/StringConvert.h"
 #include "lldb/Host/XML.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 #pragma mark-- XMLDocument
 
-XMLDocument::XMLDocument() {}
+XMLDocument::XMLDocument() = default;
 
 XMLDocument::~XMLDocument() { Clear(); }
 
 void XMLDocument::Clear() {
 #if LLDB_ENABLE_LIBXML2
   if (m_document) {
     xmlDocPtr doc = m_document;
     m_document = nullptr;

   return true;
 #else
   return false;
 #endif
 }
 
 #pragma mark-- XMLNode
 
-XMLNode::XMLNode() {}
+XMLNode::XMLNode() = default;
 
 XMLNode::XMLNode(XMLNodeImpl node) : m_node(node) {}
 
-XMLNode::~XMLNode() {}
+XMLNode::~XMLNode() = default;
 
 void XMLNode::Clear() { m_node = nullptr; }
 
 XMLNode XMLNode::GetParent() const {
 #if LLDB_ENABLE_LIBXML2
   if (IsValid())
     return XMLNode(m_node->parent);
   else

 
 ApplePropertyList::ApplePropertyList() : m_xml_doc(), m_dict_node() {}
 
 ApplePropertyList::ApplePropertyList(const char *path)
     : m_xml_doc(), m_dict_node() {
   ParseFile(path);
 }
 
-ApplePropertyList::~ApplePropertyList() {}
+ApplePropertyList::~ApplePropertyList() = default;
 
 llvm::StringRef ApplePropertyList::GetErrors() const {
   return m_xml_doc.GetErrors();
 }
 
 bool ApplePropertyList::ParseFile(const char *path) {
   if (m_xml_doc.ParseFile(path)) {
     XMLNode plist = m_xml_doc.GetRootElement("plist");

lldb/source/Host/macosx/cfcpp/CFCBundle.cpp

CFCBundle::CFCBundle(const char *path) : CFCReleaser<CFBundleRef>() {
   if (path && path[0])
     SetPath(path);
 }
 
 CFCBundle::CFCBundle(CFURLRef url)
     : CFCReleaser<CFBundleRef>(url ? CFBundleCreate(NULL, url) : NULL) {}
 
 // Destructor
-CFCBundle::~CFCBundle() {}
+CFCBundle::~CFCBundle() = default;
 
 // Set the path for a bundle by supplying a
 bool CFCBundle::SetPath(const char *path) {
   CFAllocatorRef alloc = kCFAllocatorDefault;
   // Release our old bundle and URL
   reset();
 
   // Make a CFStringRef from the supplied path

lldb/source/Host/macosx/cfcpp/CFCData.cpp

 
 {
   if (this != &rhs)
     *this = rhs;
   return *this;
 }
 
 // Destructor
-CFCData::~CFCData() {}
+CFCData::~CFCData() = default;
 
 CFIndex CFCData::GetLength() const {
   CFDataRef data = get();
   if (data)
     return CFDataGetLength(data);
   return 0;
 }
 

lldb/source/Host/macosx/cfcpp/CFCMutableArray.cpp

 CFCMutableArray &CFCMutableArray::operator=(const CFCMutableArray &rhs) {
   if (this != &rhs)
     *this = rhs; // NOTE: this operator won't make a copy of the array, just add
                  // a new reference to it
   return *this;
 }
 
 // Destructor
-CFCMutableArray::~CFCMutableArray() {}
+CFCMutableArray::~CFCMutableArray() = default;
 
 CFIndex CFCMutableArray::GetCount() const {
   CFMutableArrayRef array = get();
   if (array)
     return ::CFArrayGetCount(array);
   return 0;
 }
 

lldb/source/Host/macosx/cfcpp/CFCMutableDictionary.cpp

 const CFCMutableDictionary &CFCMutableDictionary::
 operator=(const CFCMutableDictionary &rhs) {
   if (this != &rhs)
     *this = rhs;
   return *this;
 }
 
 // Destructor
-CFCMutableDictionary::~CFCMutableDictionary() {}
+CFCMutableDictionary::~CFCMutableDictionary() = default;
 
 CFIndex CFCMutableDictionary::GetCount() const {
   CFMutableDictionaryRef dict = get();
   if (dict)
     return ::CFDictionaryGetCount(dict);
   return 0;
 }
 

lldb/source/Host/macosx/cfcpp/CFCMutableSet.cpp

 // CFCMutableSet copy constructor
 const CFCMutableSet &CFCMutableSet::operator=(const CFCMutableSet &rhs) {
   if (this != &rhs)
     *this = rhs;
   return *this;
 }
 
 // Destructor
-CFCMutableSet::~CFCMutableSet() {}
+CFCMutableSet::~CFCMutableSet() = default;
 
 CFIndex CFCMutableSet::GetCount() const {
   CFMutableSetRef set = get();
   if (set)
     return ::CFSetGetCount(set);
   return 0;
 }
 

lldb/source/Host/macosx/cfcpp/CFCString.cpp

CFCString::CFCString(const char *cstr, CFStringEncoding cstr_encoding)
     : CFCReleaser<CFStringRef>() {
   if (cstr && cstr[0]) {
     reset(
         ::CFStringCreateWithCString(kCFAllocatorDefault, cstr, cstr_encoding));
   }
 }
 
 // Destructor
-CFCString::~CFCString() {}
+CFCString::~CFCString() = default;
 
 const char *CFCString::GetFileSystemRepresentation(std::string &s) {
   return CFCString::FileSystemRepresentation(get(), s);
 }
 
 CFStringRef CFCString::SetFileSystemRepresentation(const char *path) {
   CFStringRef new_value = NULL;
   if (path && path[0])

lldb/source/Host/posix/HostProcessPosix.cpp

 //===-- HostProcessPosix.cpp ----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Host/Host.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/posix/HostProcessPosix.h"
 
 #include "llvm/ADT/STLExtras.h"
 
 #include <climits>
 #include <csignal>
 #include <unistd.h>
 
 using namespace lldb_private;
 
 namespace {
 const int kInvalidPosixProcess = 0;
 }
 
 HostProcessPosix::HostProcessPosix()
     : HostNativeProcessBase(kInvalidPosixProcess) {}
 
 HostProcessPosix::HostProcessPosix(lldb::process_t process)
     : HostNativeProcessBase(process) {}
 
-HostProcessPosix::~HostProcessPosix() {}
+HostProcessPosix::~HostProcessPosix() = default;
 
 Status HostProcessPosix::Signal(int signo) const {
   if (m_process == kInvalidPosixProcess) {
     Status error;
     error.SetErrorString("HostProcessPosix refers to an invalid process");
     return error;
   }
 

lldb/source/Host/posix/HostThreadPosix.cpp

 //===-- HostThreadPosix.cpp -----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Host/posix/HostThreadPosix.h"
 #include "lldb/Utility/Status.h"
 
 #include <cerrno>
 #include <pthread.h>
 
 using namespace lldb;
 using namespace lldb_private;
 
-HostThreadPosix::HostThreadPosix() {}
+HostThreadPosix::HostThreadPosix() = default;
 
 HostThreadPosix::HostThreadPosix(lldb::thread_t thread)
     : HostNativeThreadBase(thread) {}
 
-HostThreadPosix::~HostThreadPosix() {}
+HostThreadPosix::~HostThreadPosix() = default;
 
 Status HostThreadPosix::Join(lldb::thread_result_t *result) {
   Status error;
   if (IsJoinable()) {
     int err = ::pthread_join(m_thread, result);
     error.SetError(err, lldb::eErrorTypePOSIX);
   } else {
     if (result)

lldb/source/Initialization/SystemInitializer.cpp

 //===-- SystemInitializer.cpp ---------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Initialization/SystemInitializer.h"
 
 using namespace lldb_private;
 
-SystemInitializer::SystemInitializer() {}
+SystemInitializer::SystemInitializer() = default;
 
-SystemInitializer::~SystemInitializer() {}
+SystemInitializer::~SystemInitializer() = default;

lldb/source/Initialization/SystemInitializerCommon.cpp

 //===-- SystemInitializerCommon.cpp ---------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Initialization/SystemInitializerCommon.h"
 
 #include "Plugins/Process/gdb-remote/ProcessGDBRemoteLog.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/Socket.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/ReproducerProvider.h"
 #include "lldb/Utility/Timer.h"

 
 using namespace lldb_private;
 using namespace lldb_private::repro;
 
 SystemInitializerCommon::SystemInitializerCommon(
     HostInfo::SharedLibraryDirectoryHelper *helper)
     : m_shlib_dir_helper(helper) {}
 
-SystemInitializerCommon::~SystemInitializerCommon() {}
+SystemInitializerCommon::~SystemInitializerCommon() = default;
 
 /// Initialize the FileSystem based on the current reproducer mode.
 static llvm::Error InitializeFileSystem() {
   auto &r = repro::Reproducer::Instance();
   if (repro::Loader *loader = r.GetLoader()) {
     FileSpec vfs_mapping = loader->GetFile<FileProvider::Info>();
     if (vfs_mapping) {
       if (llvm::Error e = FileSystem::Initialize(vfs_mapping))

lldb/source/Interpreter/OptionGroupFile.cpp

 //===-- OptionGroupFile.cpp -----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Interpreter/OptionGroupFile.h"
 
 #include "lldb/Host/OptionParser.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 OptionGroupFile::OptionGroupFile(uint32_t usage_mask, bool required,
                                  const char *long_option, int short_option,
OptionGroupFileList::OptionGroupFileList(
   m_option_definition.validator = nullptr;
   m_option_definition.option_has_arg = OptionParser::eRequiredArgument;
   m_option_definition.enum_values = {};
   m_option_definition.completion_type = completion_type;
   m_option_definition.argument_type = argument_type;
   m_option_definition.usage_text = usage_text;
 }
 
-OptionGroupFileList::~OptionGroupFileList() {}
+OptionGroupFileList::~OptionGroupFileList() = default;
 
 Status
 OptionGroupFileList::SetOptionValue(uint32_t option_idx,
                                     llvm::StringRef option_value,
                                     ExecutionContext *execution_context) {
   Status error(m_file_list.SetValueFromString(option_value));
   return error;
 }
 
 void OptionGroupFileList::OptionParsingStarting(
     ExecutionContext *execution_context) {
   m_file_list.Clear();
 }

lldb/source/Interpreter/OptionValueFileColonLine.cpp

 //===-- OptionValueFileColonLine.cpp---------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Interpreter/OptionValueFileColonLine.h"
 
 #include "lldb/DataFormatters/FormatManager.h"
 #include "lldb/Interpreter/CommandCompletions.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Utility/Args.h"
 #include "lldb/Utility/State.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 // This is an OptionValue for parsing file:line:column specifications.
 // I set the completer to "source file" which isn't quite right, but we can
 // only usefully complete in the file name part of it so it should be good
 // enough.
-OptionValueFileColonLine::OptionValueFileColonLine()
-
-{}
+OptionValueFileColonLine::OptionValueFileColonLine() = default;
 
 OptionValueFileColonLine::OptionValueFileColonLine(llvm::StringRef input)
     : m_line_number(LLDB_INVALID_LINE_NUMBER),
       m_column_number(LLDB_INVALID_COLUMN_NUMBER),
       m_completion_mask(CommandCompletions::eSourceFileCompletion) {
   SetValueFromString(input, eVarSetOperationAssign);
 }
 
if (value.size() > 0) {
       // Then check whether the middle piece is an integer.  If it is, then it
       // was the line number, and if it isn't we're going to assume that there
       // was a colon in the filename (see note at the beginning of the function)
       // and ignore it.
       llvm::StringRef file_name;
       llvm::StringRef middle_piece;
 
       std::tie(file_name, middle_piece) = left_of_last_piece.rsplit(':');
-      if (middle_piece.empty() || !llvm::to_integer(middle_piece, 
-                                                    m_line_number)) {
+      if (middle_piece.empty() ||
+          !llvm::to_integer(middle_piece, m_line_number)) {
         // The middle piece was empty or not an integer, so there were only two
         // legit pieces; our original division was right.  Reassign the file
         // name and pull out the line number:
         file_name = left_of_last_piece;
         if (!llvm::to_integer(last_piece, m_line_number)) {
           error.SetErrorStringWithFormat("Bad line number value '%s' in: '%s'",
                                          last_piece.str().c_str(),
                                          value.str().c_str());

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

   };
 
   struct OSKextLoadedKextSummaryHeader {
     uint32_t version = 0;
     uint32_t entry_size = 0;
     uint32_t entry_count = 0;
     lldb::addr_t image_infos_addr = LLDB_INVALID_ADDRESS;
 
-    OSKextLoadedKextSummaryHeader()
-
-    {}
+    OSKextLoadedKextSummaryHeader() = default;
 
     uint32_t GetSize() {
       switch (version) {
       case 0:
         return 0; // Can't know the size without a valid version
       case 1:
         return 8; // Version 1 only had a version + entry_count
       default:
         break;
       }

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

     return g_setting_name;
   }
 
   DynamicLoaderDarwinKernelProperties() : Properties() {
     m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName());
     m_collection_sp->Initialize(g_dynamicloaderdarwinkernel_properties);
   }
 
-  ~DynamicLoaderDarwinKernelProperties() override {}
+  ~DynamicLoaderDarwinKernelProperties() override = default;
 
   bool GetLoadKexts() const {
     const uint32_t idx = ePropertyLoadKexts;
     return m_collection_sp->GetPropertyAtIndexAsBoolean(
         nullptr, idx,
         g_dynamicloaderdarwinkernel_properties[idx].default_uint_value != 0);
   }
 

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

 //===-- HexagonDYLDRendezvous.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_SOURCE_PLUGINS_DYNAMICLOADER_HEXAGON_DYLD_HEXAGONDYLDRENDEZVOUS_H
 #define LLDB_SOURCE_PLUGINS_DYNAMICLOADER_HEXAGON_DYLD_HEXAGONDYLDRENDEZVOUS_H
 
 #include <limits.h>
 #include <list>
 #include <map>
 #include <string>
 
 #include "lldb/lldb-defines.h"
 #include "lldb/lldb-types.h"
 
 namespace lldb_private {
 class Process;
 }
 
 /// \class HexagonDYLDRendezvous
 /// Interface to the runtime linker.
class HexagonDYLDRendezvous {
   // enough to hold the information on both 32 and 64 bit platforms.
   struct Rendezvous {
     uint64_t version = 0;
     lldb::addr_t map_addr = LLDB_INVALID_ADDRESS;
     lldb::addr_t brk = LLDB_INVALID_ADDRESS;
     uint64_t state = 0;
     lldb::addr_t ldbase = 0;
 
-    Rendezvous() {}
+    Rendezvous() = default;
   };
 
 public:
   // Various metadata supplied by the inferior's threading library to describe
   // the per-thread state.
   struct ThreadInfo {
     bool valid;             // whether we read valid metadata
     uint32_t dtv_offset;    // offset of DTV pointer within pthread

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

 
 // Constructor
 DynamicLoaderDarwin::DynamicLoaderDarwin(Process *process)
     : DynamicLoader(process), m_dyld_module_wp(), m_libpthread_module_wp(),
       m_pthread_getspecific_addr(), m_tid_to_tls_map(), m_dyld_image_infos(),
       m_dyld_image_infos_stop_id(UINT32_MAX), m_dyld(), m_mutex() {}
 
 // Destructor
-DynamicLoaderDarwin::~DynamicLoaderDarwin() {}
+DynamicLoaderDarwin::~DynamicLoaderDarwin() = default;
 
 /// Called after attaching a process.
 ///
 /// Allow DynamicLoader plug-ins to execute some code after
 /// attaching to a process.
 void DynamicLoaderDarwin::DidAttach() {
   PrivateInitialize(m_process);
   DoInitialImageFetch();

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

 // watchOS / BridgeOS)
 // platforms earlier than 2016, where lldb would read the "dyld_all_image_infos"
 // dyld internal structure to understand where things were loaded and the
 // solib loaded/unloaded notification function we put a breakpoint on gives us
 // an array of (load address, mod time, file path) tuples.
 //
 // As of late 2016, the new DynamicLoaderMacOS plugin should be used, which uses
 // dyld SPI functions to get the same information without reading internal dyld
 // data structures.
 
 #ifndef LLDB_SOURCE_PLUGINS_DYNAMICLOADER_MACOSX_DYLD_DYNAMICLOADERMACOSXDYLD_H
 #define LLDB_SOURCE_PLUGINS_DYNAMICLOADER_MACOSX_DYLD_DYNAMICLOADERMACOSXDYLD_H
 
 #include <mutex>
 #include <vector>
 
 #include "lldb/Host/SafeMachO.h"
 #include "lldb/Target/DynamicLoader.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/StructuredData.h"
 #include "lldb/Utility/UUID.h"
 
 #include "DynamicLoaderDarwin.h"
 

     uint32_t version = 0;
     uint32_t dylib_info_count = 0;                            // Version >= 1
     lldb::addr_t dylib_info_addr = LLDB_INVALID_ADDRESS;      // Version >= 1
     lldb::addr_t notification = LLDB_INVALID_ADDRESS;         // Version >= 1
     bool processDetachedFromSharedRegion = false;             // Version >= 1
     bool libSystemInitialized = false;                        // Version >= 2
     lldb::addr_t dyldImageLoadAddress = LLDB_INVALID_ADDRESS; // Version >= 2
 
-    DYLDAllImageInfos()
-
-    {}
+    DYLDAllImageInfos() = default;
 
     void Clear() {
       version = 0;
       dylib_info_count = 0;
       dylib_info_addr = LLDB_INVALID_ADDRESS;
       notification = LLDB_INVALID_ADDRESS;
       processDetachedFromSharedRegion = false;
       libSystemInitialized = false;
       dyldImageLoadAddress = LLDB_INVALID_ADDRESS;
     }

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

 //===-- DYLDRendezvous.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_SOURCE_PLUGINS_DYNAMICLOADER_POSIX_DYLD_DYLDRENDEZVOUS_H
 #define LLDB_SOURCE_PLUGINS_DYNAMICLOADER_POSIX_DYLD_DYLDRENDEZVOUS_H
 
 #include <list>
 #include <string>
 
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/lldb-defines.h"
 #include "lldb/lldb-types.h"
 
 #include "lldb/Core/LoadedModuleInfoList.h"
 
 using lldb_private::LoadedModuleInfoList;
 
 namespace lldb_private {
class DYLDRendezvous {
   // enough to hold the information on both 32 and 64 bit platforms.
   struct Rendezvous {
     uint64_t version = 0;
     lldb::addr_t map_addr = 0;
     lldb::addr_t brk = 0;
     uint64_t state = 0;
     lldb::addr_t ldbase = 0;
 
-    Rendezvous() {}
+    Rendezvous() = default;
   };
 
 public:
   // Various metadata supplied by the inferior's threading library to describe
   // the per-thread state.
   struct ThreadInfo {
     bool valid;             // whether we read valid metadata
     uint32_t dtv_offset;    // offset of DTV pointer within pthread

lldb/source/Plugins/DynamicLoader/Windows-DYLD/DynamicLoaderWindowsDYLD.cpp

 using namespace lldb;
 using namespace lldb_private;
 
 LLDB_PLUGIN_DEFINE(DynamicLoaderWindowsDYLD)
 
 DynamicLoaderWindowsDYLD::DynamicLoaderWindowsDYLD(Process *process)
     : DynamicLoader(process) {}
 
-DynamicLoaderWindowsDYLD::~DynamicLoaderWindowsDYLD() {}
+DynamicLoaderWindowsDYLD::~DynamicLoaderWindowsDYLD() = default;
 
 void DynamicLoaderWindowsDYLD::Initialize() {
   PluginManager::RegisterPlugin(GetPluginNameStatic(),
                                 GetPluginDescriptionStatic(), CreateInstance);
 }
 
 void DynamicLoaderWindowsDYLD::Terminate() {}
 

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

: m_ast_context(nullptr), m_passthrough(passthrough),
       m_passthrough_sema(nullptr), m_target(target), m_sema(nullptr),
       m_top_level(top_level) {
   if (!m_passthrough)
     return;
 
   m_passthrough_sema = dyn_cast<SemaConsumer>(passthrough);
 }
 
-ASTResultSynthesizer::~ASTResultSynthesizer() {}
+ASTResultSynthesizer::~ASTResultSynthesizer() = default;
 
 void ASTResultSynthesizer::Initialize(ASTContext &Context) {
   m_ast_context = &Context;
 
   if (m_passthrough)
     m_passthrough->Initialize(Context);
 }
 

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

: m_ast_context(nullptr), m_passthrough(passthrough),
       m_passthrough_sema(nullptr), m_sema(nullptr), m_function(function),
       m_struct_name(struct_name) {
   if (!m_passthrough)
     return;
 
   m_passthrough_sema = dyn_cast<SemaConsumer>(passthrough);
 }
 
-ASTStructExtractor::~ASTStructExtractor() {}
+ASTStructExtractor::~ASTStructExtractor() = default;
 
 void ASTStructExtractor::Initialize(ASTContext &Context) {
   m_ast_context = &Context;
 
   if (m_passthrough)
     m_passthrough->Initialize(Context);
 }
 

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

 //===-- ASTUtils.cpp ------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "ASTUtils.h"
 
-lldb_private::ExternalASTSourceWrapper::~ExternalASTSourceWrapper() {}
+lldb_private::ExternalASTSourceWrapper::~ExternalASTSourceWrapper() = default;
 
 void lldb_private::ExternalASTSourceWrapper::PrintStats() {
   m_Source->PrintStats();
 }
 
-lldb_private::ASTConsumerForwarder::~ASTConsumerForwarder() {}
+lldb_private::ASTConsumerForwarder::~ASTConsumerForwarder() = default;
 
 void lldb_private::ASTConsumerForwarder::PrintStats() { m_c->PrintStats(); }
 
-lldb_private::SemaSourceWithPriorities::~SemaSourceWithPriorities() {}
+lldb_private::SemaSourceWithPriorities::~SemaSourceWithPriorities() = default;
 
 void lldb_private::SemaSourceWithPriorities::PrintStats() {
   for (size_t i = 0; i < Sources.size(); ++i)
     Sources[i]->PrintStats();
 }

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

 
     context_md->m_map_completer = &completer;
   }
 
   void ForgetDestination(clang::ASTContext *dst_ctx);
   void ForgetSource(clang::ASTContext *dst_ctx, clang::ASTContext *src_ctx);
 
   struct DeclOrigin {
-    DeclOrigin() {}
+    DeclOrigin() = default;
 
     DeclOrigin(clang::ASTContext *_ctx, clang::Decl *_decl)
         : ctx(_ctx), decl(_decl) {
       // The decl has to be in its associated ASTContext.
       assert(_decl == nullptr || &_decl->getASTContext() == _ctx);
     }
 
     DeclOrigin(const DeclOrigin &rhs) {

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

                escaped_child);
       lldbassert(0 && "Couldn't override!");
     }
 
     OverrideOne(decl);
   }
 
 public:
-  DeclContextOverride() {}
+  DeclContextOverride() = default;
 
   void OverrideAllDeclsFromContainingFunction(clang::Decl *decl) {
     for (DeclContext *decl_context = decl->getLexicalDeclContext();
          decl_context; decl_context = decl_context->getLexicalParent()) {
       DeclContext *redecl_context = decl_context->getRedeclContext();
 
       if (llvm::isa<FunctionDecl>(redecl_context) &&
           llvm::isa<TranslationUnitDecl>(redecl_context->getLexicalParent())) {

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

 //===-- ClangDeclVendor.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_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_CLANGDECLVENDOR_H
 #define LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_CLANGDECLVENDOR_H
 
 #include "lldb/Symbol/DeclVendor.h"
 
 namespace clang {
 class NamedDecl;
 }
 
 namespace lldb_private {
 
 // A clang specialized extension to DeclVendor.
 class ClangDeclVendor : public DeclVendor {
 public:
   ClangDeclVendor(DeclVendorKind kind) : DeclVendor(kind) {}
 
-  virtual ~ClangDeclVendor() {}
+  virtual ~ClangDeclVendor() = default;
 
   using DeclVendor::FindDecls;
 
   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 &&

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

 
   lldb::addr_t GetSymbolAddress(ConstString name,
                                 lldb::SymbolType symbol_type);
 
   struct TargetInfo {
     lldb::ByteOrder byte_order = lldb::eByteOrderInvalid;
     size_t address_byte_size = 0;
 
-    TargetInfo() {}
+    TargetInfo() = default;
 
     bool IsValid() {
       return (byte_order != lldb::eByteOrderInvalid && address_byte_size != 0);
     }
   };
   TargetInfo GetTargetInfo();
 
   /// [Used by ClangASTSource] Find all entities matching a given name, using

   ValueObject *m_ctx_obj; ///< If not empty, then expression is
                           ///evaluated in context of this object.
                           ///For details see the comment to
                           ///`UserExpression::Evaluate`.
 
   /// The following values should not live beyond parsing
   class ParserVars {
   public:
-    ParserVars() {}
+    ParserVars() = default;
 
     Target *GetTarget() {
       if (m_exe_ctx.GetTargetPtr())
         return m_exe_ctx.GetTargetPtr();
       else if (m_sym_ctx.target_sp)
         return m_sym_ctx.target_sp.get();
       return nullptr;
     }

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

 //===-- ClangExpressionHelper.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_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_CLANGEXPRESSIONHELPER_H
 #define LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_CLANGEXPRESSIONHELPER_H
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "lldb/Expression/ExpressionTypeSystemHelper.h"
 #include "lldb/lldb-forward.h"
 #include "lldb/lldb-private.h"
 
 namespace clang {
 class ASTConsumer;
 }
 
 namespace lldb_private {
 
 class ClangExpressionDeclMap;
 class RecordingMemoryManager;
 
 // ClangExpressionHelper
 class ClangExpressionHelper : public ExpressionTypeSystemHelper {
 public:
   static bool classof(const ExpressionTypeSystemHelper *ts) {
     return ts->getKind() == eKindClangHelper;
   }
 
   ClangExpressionHelper()
       : ExpressionTypeSystemHelper(
             ExpressionTypeSystemHelper::LLVMCastKind::eKindClangHelper) {}
 
   /// Destructor
-  virtual ~ClangExpressionHelper() {}
+  virtual ~ClangExpressionHelper() = default;
 
   /// Return the object that the parser should use when resolving external
   /// values.  May be NULL if everything should be self-contained.
   virtual ClangExpressionDeclMap *DeclMap() = 0;
 
   /// Return the object that the parser should allow to access ASTs.
   /// May be NULL if the ASTs do not need to be transformed.
   ///

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

 
   m_llvm_context = std::make_unique<LLVMContext>();
   m_code_generator.reset(CreateLLVMCodeGen(
       m_compiler->getDiagnostics(), module_name,
       m_compiler->getHeaderSearchOpts(), m_compiler->getPreprocessorOpts(),
       m_compiler->getCodeGenOpts(), *m_llvm_context));
 }
 
-ClangExpressionParser::~ClangExpressionParser() {}
+ClangExpressionParser::~ClangExpressionParser() = default;
 
 namespace {
 
 /// \class CodeComplete
 ///
 /// A code completion consumer for the clang Sema that is responsible for
 /// creating the completion suggestions when a user requests completion
 /// of an incomplete `expr` invocation.

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

     if (i == m_parser_vars.end())
       return nullptr;
     else
       return &i->second;
   }
 
   /// The following values are valid if the variable is used by JIT code
   struct JITVars {
-    JITVars() {}
+    JITVars() = default;
 
     lldb::offset_t m_alignment =
         0;             ///< The required alignment of the variable, in bytes
     size_t m_size = 0; ///< The space required for the variable, in bytes
     lldb::offset_t m_offset =
         0; ///< The offset of the variable in the struct, in bytes
   };
 

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

: FunctionCaller(exe_scope, return_type, functionAddress, arg_value_list,
                      name),
       m_type_system_helper(*this) {
   m_jit_process_wp = lldb::ProcessWP(exe_scope.CalculateProcess());
   // Can't make a ClangFunctionCaller without a process.
   assert(m_jit_process_wp.lock());
 }
 
 // Destructor
-ClangFunctionCaller::~ClangFunctionCaller() {}
+ClangFunctionCaller::~ClangFunctionCaller() = default;
 
 unsigned
 
 ClangFunctionCaller::CompileFunction(lldb::ThreadSP thread_to_use_sp,
                                      DiagnosticManager &diagnostic_manager) {
   if (m_compiled)
     return 0;
 

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

 
 void StoringDiagnosticConsumer::EndSourceFile() {
   m_diag_printer->EndSourceFile();
 }
 
 ClangModulesDeclVendor::ClangModulesDeclVendor()
     : ClangDeclVendor(eClangModuleDeclVendor) {}
 
-ClangModulesDeclVendor::~ClangModulesDeclVendor() {}
+ClangModulesDeclVendor::~ClangModulesDeclVendor() = default;
 
 ClangModulesDeclVendorImpl::ClangModulesDeclVendorImpl(
     llvm::IntrusiveRefCntPtr<clang::DiagnosticsEngine> diagnostics_engine,
     std::shared_ptr<clang::CompilerInvocation> compiler_invocation,
     std::unique_ptr<clang::CompilerInstance> compiler_instance,
     std::unique_ptr<clang::Parser> parser)
     : m_diagnostics_engine(std::move(diagnostics_engine)),
       m_compiler_invocation(std::move(compiler_invocation)),

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

 //===-- ClangUserExpression.cpp -------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Host/Config.h"
 
 #include <cstdio>
 #if HAVE_SYS_TYPES_H
 #include <sys/types.h>
 #endif
 
 #include <cstdlib>
 #include <map>
ClangUserExpression::ClangUserExpression(
   case lldb::eLanguageTypeObjC_plus_plus:
   default:
     m_allow_cxx = true;
     m_allow_objc = true;
     break;
   }
 }
 
-ClangUserExpression::~ClangUserExpression() {}
+ClangUserExpression::~ClangUserExpression() = default;
 
 void ClangUserExpression::ScanContext(ExecutionContext &exe_ctx, Status &err) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
   LLDB_LOGF(log, "ClangUserExpression::ScanContext()");
 
   m_target = exe_ctx.GetTargetPtr();
 

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

public:
   }
 
   bool Install(DiagnosticManager &diagnostic_manager,
                ExecutionContext &exe_ctx) override;
 
 private:
   class ClangUtilityFunctionHelper : public ClangExpressionHelper {
   public:
-    ClangUtilityFunctionHelper() {}
+    ClangUtilityFunctionHelper() = default;
 
-    ~ClangUtilityFunctionHelper() override {}
+    ~ClangUtilityFunctionHelper() override = default;
 
     /// Return the object that the parser should use when resolving external
     /// values.  May be NULL if everything should be self-contained.
     ClangExpressionDeclMap *DeclMap() override {
       return m_expr_decl_map_up.get();
     }
 
     void ResetDeclMap() { m_expr_decl_map_up.reset(); }

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

 //===-- ClangUtilityFunction.cpp ------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Host/Config.h"
 
 #include "ClangUtilityFunction.h"
 #include "ClangExpressionDeclMap.h"
 #include "ClangExpressionParser.h"
 #include "ClangExpressionSourceCode.h"
 #include "ClangPersistentVariables.h"
 
 #include <cstdio>
if (temp_fd != -1) {
             std::string(ClangExpressionSourceCode::g_expression_prefix) + text +
             std::string(ClangExpressionSourceCode::g_expression_suffix);
       }
       file.Close();
     }
   }
 }
 
-ClangUtilityFunction::~ClangUtilityFunction() {}
+ClangUtilityFunction::~ClangUtilityFunction() = default;
 
 /// Install the utility function into a process
 ///
 /// \param[in] diagnostic_manager
 ///     A diagnostic manager to report errors and warnings to.
 ///
 /// \param[in] exe_ctx
 ///     The execution context to install the utility function to.

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

 //===-- CppModuleConfiguration.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_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_CPPMODULECONFIGURATION_H
 #define LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_CPPMODULECONFIGURATION_H
 
 #include <lldb/Core/FileSpecList.h>
 #include <llvm/Support/Regex.h>
 
 namespace lldb_private {
 
 /// A Clang configuration when importing C++ modules.
 ///
 /// Includes a list of include paths that should be used when importing
 /// and a list of modules that can be imported. Currently only used when
class CppModuleConfiguration {
   /// Returns false iff there was a fatal error that makes analyzing any
   /// further files pointless as the configuration is now invalid.
   bool analyzeFile(const FileSpec &f);
 
 public:
   /// Creates a configuration by analyzing the given list of used source files.
   explicit CppModuleConfiguration(const FileSpecList &support_files);
   /// Creates an empty and invalid configuration.
-  CppModuleConfiguration() {}
+  CppModuleConfiguration() = default;
 
   /// Returns true iff this is a valid configuration that can be used to
   /// load and compile modules.
   bool hasValidConfig();
 
   /// Returns a list of include directories that should be used when using this
   /// configuration (e.g. {"/usr/include", "/usr/include/c++/v1"}).
   llvm::ArrayRef<std::string> GetIncludeDirs() const { return m_include_dirs; }

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

 
 using namespace llvm;
 
 typedef SmallVector<Instruction *, 2> InstrList;
 
 IRForTarget::FunctionValueCache::FunctionValueCache(Maker const &maker)
     : m_maker(maker), m_values() {}
 
-IRForTarget::FunctionValueCache::~FunctionValueCache() {}
+IRForTarget::FunctionValueCache::~FunctionValueCache() = default;
 
 llvm::Value *
 IRForTarget::FunctionValueCache::GetValue(llvm::Function *function) {
   if (!m_values.count(function)) {
     llvm::Value *ret = m_maker(function);
     m_values[function] = ret;
     return ret;
   }

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

 //===-- EmulateInstructionARM.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_SOURCE_PLUGINS_INSTRUCTION_ARM_EMULATEINSTRUCTIONARM_H
 #define LLDB_SOURCE_PLUGINS_INSTRUCTION_ARM_EMULATEINSTRUCTIONARM_H
 
 #include "Plugins/Process/Utility/ARMDefines.h"
 #include "lldb/Core/EmulateInstruction.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Status.h"
 
 namespace lldb_private {
 
 // ITSession - Keep track of the IT Block progression.
 class ITSession {
 public:
-  ITSession() {}
-  ~ITSession() {}
+  ITSession() = default;
+  ~ITSession() = default;
 
   // InitIT - Initializes ITCounter/ITState.
   bool InitIT(uint32_t bits7_0);
 
   // ITAdvance - Updates ITCounter/ITState as IT Block progresses.
   void ITAdvance();
 
   // InITBlock - Returns true if we're inside an IT Block.

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

 
 using namespace lldb;
 using namespace lldb_private;
 
 EmulationStateARM::EmulationStateARM() : m_vfp_regs(), m_memory() {
   ClearPseudoRegisters();
 }
 
-EmulationStateARM::~EmulationStateARM() {}
+EmulationStateARM::~EmulationStateARM() = default;
 
 bool EmulationStateARM::LoadPseudoRegistersFromFrame(StackFrame &frame) {
   RegisterContext *reg_ctx = frame.GetRegisterContext().get();
   bool success = true;
   uint32_t reg_num;
 
   for (int i = dwarf_r0; i < dwarf_r0 + 17; ++i) {
     reg_num =

lldb/source/Plugins/Language/CPlusPlus/CPlusPlusNameParser.h

 //===-- CPlusPlusNameParser.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_SOURCE_PLUGINS_LANGUAGE_CPLUSPLUS_CPLUSPLUSNAMEPARSER_H
 #define LLDB_SOURCE_PLUGINS_LANGUAGE_CPLUSPLUS_CPLUSPLUSNAMEPARSER_H
 
 #include "clang/Lex/Lexer.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 
 #include "lldb/Utility/ConstString.h"
 #include "lldb/lldb-private.h"
 
 namespace lldb_private {
private:
   // Index of the next token to look at from m_tokens.
   size_t m_next_token_index = 0;
 
   // Range of tokens saved in m_next_token_index.
   struct Range {
     size_t begin_index = 0;
     size_t end_index = 0;
 
-    Range() {}
+    Range() = default;
     Range(size_t begin, size_t end) : begin_index(begin), end_index(end) {
       assert(end >= begin);
     }
 
     size_t size() const { return end_index - begin_index; }
 
     bool empty() const { return size() == 0; }
   };

lldb/source/Plugins/Language/ObjC/NSIndexPath.cpp

 
       void Clear() {
         m_indexes = 0;
         m_count = 0;
         m_ptr_size = 0;
         m_process = nullptr;
       }
 
-      InlinedIndexes() {}
+      InlinedIndexes() = default;
 
     private:
       uint64_t m_indexes = 0;
       size_t m_count = 0;
       uint32_t m_ptr_size = 0;
       Process *m_process = nullptr;
 
       // cfr. Foundation for the details of this code

         return nullptr;
       }
 
       void Clear() {
         m_indexes = nullptr;
         m_count = 0;
       }
 
-      OutsourcedIndexes() {}
+      OutsourcedIndexes() = default;
 
       ValueObject *m_indexes = nullptr;
       size_t m_count = 0;
     };
 
     union {
       struct InlinedIndexes m_inlined;
       struct OutsourcedIndexes m_outsourced;
     };
 
     void Clear() {
       m_mode = Mode::Invalid;
       m_inlined.Clear();
       m_outsourced.Clear();
     }
 
-    Impl() {}
+    Impl() = default;
 
     Mode m_mode = Mode::Invalid;
   } m_impl;
 
   uint32_t m_ptr_size;
   CompilerType m_uint_star_type;
 };
 

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

private:
   struct objc_class_t {
     ObjCLanguageRuntime::ObjCISA m_isa = 0; // The class's metaclass.
     ObjCLanguageRuntime::ObjCISA m_superclass = 0;
     lldb::addr_t m_cache_ptr = 0;
     lldb::addr_t m_vtable_ptr = 0;
     lldb::addr_t m_data_ptr = 0;
     uint8_t m_flags = 0;
 
-    objc_class_t() {}
+    objc_class_t() = default;
 
     void Clear() {
       m_isa = 0;
       m_superclass = 0;
       m_cache_ptr = 0;
       m_vtable_ptr = 0;
       m_data_ptr = 0;
       m_flags = 0;

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

 
 using namespace lldb;
 using namespace lldb_private;
 
 LLDB_PLUGIN_DEFINE(AppleObjCRuntime)
 
 char AppleObjCRuntime::ID = 0;
 
-AppleObjCRuntime::~AppleObjCRuntime() {}
+AppleObjCRuntime::~AppleObjCRuntime() = default;
 
 AppleObjCRuntime::AppleObjCRuntime(Process *process)
     : ObjCLanguageRuntime(process), m_read_objc_library(false),
       m_objc_trampoline_handler_up(), m_Foundation_major() {
   ReadObjCLibraryIfNeeded(process->GetTarget().GetImages());
 }
 
 void AppleObjCRuntime::Initialize() {

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

 
 protected:
   lldb::BreakpointResolverSP
   CreateExceptionResolver(const lldb::BreakpointSP &bkpt,
                           bool catch_bp, bool throw_bp) override;
 
   class HashTableSignature {
   public:
-    HashTableSignature() {}
+    HashTableSignature() = default;
 
     bool NeedsUpdate(uint32_t count, uint32_t num_buckets,
                      lldb::addr_t buckets_ptr) {
       return m_count != count || m_num_buckets != num_buckets ||
              m_buckets_ptr != buckets_ptr;
     }
 
     void UpdateSignature(uint32_t count, uint32_t num_buckets,

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

   lldb::addr_t m_buckets_ptr = LLDB_INVALID_ADDRESS;
   lldb_private::Process *m_process = nullptr;
   const_iterator m_end_iterator;
   lldb::addr_t m_load_addr = LLDB_INVALID_ADDRESS;
   size_t m_map_pair_size = 0;
   lldb::addr_t m_invalid_key = 0;
 };
 
-AppleObjCRuntimeV2::HashTableSignature::HashTableSignature() {}
+AppleObjCRuntimeV2::HashTableSignature::HashTableSignature() = default;
 
 void AppleObjCRuntimeV2::HashTableSignature::UpdateSignature(
     const RemoteNXMapTable &hash_table) {
   m_count = hash_table.GetCount();
   m_num_buckets = hash_table.GetBucketCount();
   m_buckets_ptr = hash_table.GetBucketDataPointer();
 }
 

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

 //===-- AppleObjCTrampolineHandler.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_SOURCE_PLUGINS_LANGUAGERUNTIME_OBJC_APPLEOBJCRUNTIME_APPLEOBJCTRAMPOLINEHANDLER_H
 #define LLDB_SOURCE_PLUGINS_LANGUAGERUNTIME_OBJC_APPLEOBJCRUNTIME_APPLEOBJCTRAMPOLINEHANDLER_H
 
 #include <map>
 #include <mutex>
 #include <vector>
 
 #include "lldb/Expression/UtilityFunction.h"
 #include "lldb/lldb-public.h"
 
 namespace lldb_private {
 
 class AppleObjCTrampolineHandler {
 public:
   AppleObjCTrampolineHandler(const lldb::ProcessSP &process_sp,
                              const lldb::ModuleSP &objc_module_sp);
struct VTableDescriptor {
           : flags(in_flags), code_start(in_code_start) {}
 
       uint32_t flags;
       lldb::addr_t code_start;
     };
 
     class VTableRegion {
     public:
-      VTableRegion() {}
+      VTableRegion() = default;
 
       VTableRegion(AppleObjCVTables *owner, lldb::addr_t header_addr);
 
       void SetUpRegion();
 
       lldb::addr_t GetNextRegionAddr() { return m_next_region; }
 
       lldb::addr_t GetCodeStart() { return m_code_start_addr; }

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

 
 AppleObjCTrampolineHandler::AppleObjCVTables::VTableRegion::VTableRegion(
     AppleObjCVTables *owner, lldb::addr_t header_addr)
     : m_valid(true), m_owner(owner), m_header_addr(header_addr),
       m_code_start_addr(0), m_code_end_addr(0), m_next_region(0) {
   SetUpRegion();
 }
 
-AppleObjCTrampolineHandler::~AppleObjCTrampolineHandler() {}
+AppleObjCTrampolineHandler::~AppleObjCTrampolineHandler() = default;
 
 void AppleObjCTrampolineHandler::AppleObjCVTables::VTableRegion::SetUpRegion() {
   // The header looks like:
   //
   //   uint16_t headerSize
   //   uint16_t descSize
   //   uint32_t descCount
   //   void * next

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

: ThreadPlan(ThreadPlan::eKindGeneric,
                  "MacOSX Step through ObjC Trampoline", thread, eVoteNoOpinion,
                  eVoteNoOpinion),
       m_trampoline_handler(trampoline_handler),
       m_args_addr(LLDB_INVALID_ADDRESS), m_input_values(input_values),
       m_isa_addr(isa_addr), m_sel_addr(sel_addr), m_impl_function(nullptr) {}
 
 // Destructor
 AppleThreadPlanStepThroughObjCTrampoline::
-    ~AppleThreadPlanStepThroughObjCTrampoline() {}
+    ~AppleThreadPlanStepThroughObjCTrampoline() = default;
 
 void AppleThreadPlanStepThroughObjCTrampoline::DidPush() {
   // Setting up the memory space for the called function text might require
   // allocations, i.e. a nested function call.  This needs to be done as a
   // PreResumeAction.
   m_process.AddPreResumeAction(PreResumeInitializeFunctionCaller, (void *)this);
 }
 

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

 //===-- ObjCLanguageRuntime.cpp -------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #include "clang/AST/Type.h"
 
 #include "ObjCLanguageRuntime.h"
 
 #include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
 #include "lldb/Core/MappedHash.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/ValueObject.h"

 #include "llvm/Support/DJB.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 char ObjCLanguageRuntime::ID = 0;
 
 // Destructor
-ObjCLanguageRuntime::~ObjCLanguageRuntime() {}
+ObjCLanguageRuntime::~ObjCLanguageRuntime() = default;
 
 ObjCLanguageRuntime::ObjCLanguageRuntime(Process *process)
     : LanguageRuntime(process), m_impl_cache(),
       m_has_new_literals_and_indexing(eLazyBoolCalculate),
       m_isa_to_descriptor(), m_hash_to_isa_map(), m_type_size_cache(),
       m_isa_to_descriptor_stop_id(UINT32_MAX), m_complete_class_cache(),
       m_negative_complete_class_cache() {}
 

 CompilerType
 ObjCLanguageRuntime::EncodingToType::RealizeType(const char *name,
                                                  bool for_expression) {
   if (m_scratch_ast_ctx_up)
     return RealizeType(*m_scratch_ast_ctx_up, name, for_expression);
   return CompilerType();
 }
 
-ObjCLanguageRuntime::EncodingToType::~EncodingToType() {}
+ObjCLanguageRuntime::EncodingToType::~EncodingToType() = default;
 
 ObjCLanguageRuntime::EncodingToTypeSP ObjCLanguageRuntime::GetEncodingToType() {
   return nullptr;
 }
 
 bool ObjCLanguageRuntime::GetTypeBitSize(const CompilerType &compiler_type,
                                          uint64_t &size) {
   void *opaque_ptr = compiler_type.GetOpaqueQualType();

 }
 
 // Exception breakpoint Precondition class for ObjC:
 void ObjCLanguageRuntime::ObjCExceptionPrecondition::AddClassName(
     const char *class_name) {
   m_class_names.insert(class_name);
 }
 
-ObjCLanguageRuntime::ObjCExceptionPrecondition::ObjCExceptionPrecondition() {}
+ObjCLanguageRuntime::ObjCExceptionPrecondition::ObjCExceptionPrecondition() =
+    default;
 
 bool ObjCLanguageRuntime::ObjCExceptionPrecondition::EvaluatePrecondition(
     StoppointCallbackContext &context) {
   return true;
 }
 
 void ObjCLanguageRuntime::ObjCExceptionPrecondition::GetDescription(
     Stream &stream, lldb::DescriptionLevel level) {}

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

   IRPasses();
   assert(process);
 
   EarlyPasses = std::make_shared<llvm::legacy::PassManager>();
   assert(EarlyPasses);
   EarlyPasses->add(new RenderScriptRuntimeModulePass(process));
 }
 
-RSIRPasses::~RSIRPasses() {}
+RSIRPasses::~RSIRPasses() = default;
 
 } // namespace lldb_renderscript
 } // namespace lldb_private

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

 #include <array>
 #include <map>
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Expression/LLVMUserExpression.h"
 #include "lldb/Target/LanguageRuntime.h"
 #include "lldb/lldb-private.h"
 
 #include "Plugins/LanguageRuntime/CPlusPlus/CPPLanguageRuntime.h"
 
 namespace clang {
 class TargetOptions;

 typedef std::shared_ptr<RSModuleDescriptor> RSModuleDescriptorSP;
 typedef std::shared_ptr<RSGlobalDescriptor> RSGlobalDescriptorSP;
 typedef std::shared_ptr<RSKernelDescriptor> RSKernelDescriptorSP;
 typedef std::shared_ptr<RSScriptGroupDescriptor> RSScriptGroupDescriptorSP;
 
 struct RSCoordinate {
   uint32_t x = 0, y = 0, z = 0;
 
-  RSCoordinate(){};
+  RSCoordinate() = default;
 
   bool operator==(const lldb_renderscript::RSCoordinate &rhs) {
     return x == rhs.x && y == rhs.y && z == rhs.z;
   }
 };
 
 // Breakpoint Resolvers decide where a breakpoint is placed, so having our own
 // allows us to limit the search scope to RS kernel modules. As well as check
 // for .expand kernels as a fallback.

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

 
 // The empirical_type adds a basic level of validation to arbitrary data
 // allowing us to track if data has been discovered and stored or not. An
 // empirical_type will be marked as valid only if it has been explicitly
 // assigned to.
 template <typename type_t> class empirical_type {
 public:
   // Ctor. Contents is invalid when constructed.
-  empirical_type() {}
+  empirical_type() = default;
 
   // Return true and copy contents to out if valid, else return false.
   bool get(type_t &out) const {
     if (valid)
       out = data;
     return valid;
   }
 

lldb/source/Plugins/ObjectContainer/BSD-Archive/ObjectContainerBSDArchive.cpp

 
 ObjectContainerBSDArchive::Archive::Archive(const lldb_private::ArchSpec &arch,
                                             const llvm::sys::TimePoint<> &time,
                                             lldb::offset_t file_offset,
                                             lldb_private::DataExtractor &data)
     : m_arch(arch), m_modification_time(time), m_file_offset(file_offset),
       m_objects(), m_data(data) {}
 
-ObjectContainerBSDArchive::Archive::~Archive() {}
+ObjectContainerBSDArchive::Archive::~Archive() = default;
 
 size_t ObjectContainerBSDArchive::Archive::ParseObjects() {
   DataExtractor &data = m_data;
   std::string str;
   lldb::offset_t offset = 0;
   str.assign((const char *)data.GetData(&offset, SARMAG), SARMAG);
   if (str == ARMAG) {
     Object obj;

     lldb::offset_t data_offset, const lldb_private::FileSpec *file,
     lldb::offset_t file_offset, lldb::offset_t size)
     : ObjectContainer(module_sp, file, file_offset, size, data_sp, data_offset),
       m_archive_sp() {}
 void ObjectContainerBSDArchive::SetArchive(Archive::shared_ptr &archive_sp) {
   m_archive_sp = archive_sp;
 }
 
-ObjectContainerBSDArchive::~ObjectContainerBSDArchive() {}
+ObjectContainerBSDArchive::~ObjectContainerBSDArchive() = default;
 
 bool ObjectContainerBSDArchive::ParseHeader() {
   if (m_archive_sp.get() == nullptr) {
     if (m_data.GetByteSize() > 0) {
       ModuleSP module_sp(GetModule());
       if (module_sp) {
         m_archive_sp = Archive::ParseAndCacheArchiveForFile(
             m_file, module_sp->GetArchitecture(),

lldb/source/Plugins/ObjectContainer/Universal-Mach-O/ObjectContainerUniversalMachO.cpp

ObjectContainerUniversalMachO::ObjectContainerUniversalMachO(
     lldb::offset_t data_offset, const FileSpec *file,
     lldb::offset_t file_offset, lldb::offset_t length)
     : ObjectContainer(module_sp, file, file_offset, length, data_sp,
                       data_offset),
       m_header(), m_fat_archs() {
   memset(&m_header, 0, sizeof(m_header));
 }
 
-ObjectContainerUniversalMachO::~ObjectContainerUniversalMachO() {}
+ObjectContainerUniversalMachO::~ObjectContainerUniversalMachO() = default;
 
 bool ObjectContainerUniversalMachO::ParseHeader() {
   bool success = ParseHeader(m_data, m_header, m_fat_archs);
   // We no longer need any data, we parsed all we needed to parse and cached it
   // in m_header and m_fat_archs
   m_data.Clear();
   return success;
 }

lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.h

 //===-- ObjectFileELF.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_SOURCE_PLUGINS_OBJECTFILE_ELF_OBJECTFILEELF_H
 #define LLDB_SOURCE_PLUGINS_OBJECTFILE_ELF_OBJECTFILEELF_H
 
 #include <cstdint>
 
 #include <vector>
 
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/UUID.h"
 #include "lldb/lldb-private.h"
 
 #include "ELFHeader.h"
 
 struct ELFNote {
   elf::elf_word n_namesz = 0;
   elf::elf_word n_descsz = 0;
   elf::elf_word n_type = 0;
 
   std::string n_name;
 
-  ELFNote() {}
+  ELFNote() = default;
 
   /// Parse an ELFNote entry from the given DataExtractor starting at position
   /// \p offset.
   ///
   /// \param[in] data
   ///    The DataExtractor to read from.
   ///
   /// \param[in,out] offset

lldb/source/Plugins/ObjectFile/JIT/ObjectFileJIT.cpp

     : ObjectFile(module_sp, nullptr, 0, 0, DataBufferSP(), 0), m_delegate_wp() {
   if (delegate_sp) {
     m_delegate_wp = delegate_sp;
     m_data.SetByteOrder(delegate_sp->GetByteOrder());
     m_data.SetAddressByteSize(delegate_sp->GetAddressByteSize());
   }
 }
 
-ObjectFileJIT::~ObjectFileJIT() {}
+ObjectFileJIT::~ObjectFileJIT() = default;
 
 bool ObjectFileJIT::ParseHeader() {
   // JIT code is never in a file, nor is it required to have any header
   return false;
 }
 
 ByteOrder ObjectFileJIT::GetByteOrder() const { return m_data.GetByteOrder(); }
 

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

                                    addr_t header_addr)
     : ObjectFile(module_sp, process_sp, header_addr, header_data_sp),
       m_dos_header(), m_coff_header(), m_sect_headers(),
       m_entry_point_address(), m_deps_filespec() {
   ::memset(&m_dos_header, 0, sizeof(m_dos_header));
   ::memset(&m_coff_header, 0, sizeof(m_coff_header));
 }
 
-ObjectFilePECOFF::~ObjectFilePECOFF() {}
+ObjectFilePECOFF::~ObjectFilePECOFF() = default;
 
 bool ObjectFilePECOFF::ParseHeader() {
   ModuleSP module_sp(GetModule());
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
     m_sect_headers.clear();
     m_data.SetByteOrder(eByteOrderLittle);
     lldb::offset_t offset = 0;

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

                 os_plugin_class_name.c_str(), process->CalculateProcess());
         if (object_sp && object_sp->IsValid())
           m_python_object_sp = object_sp;
       }
     }
   }
 }
 
-OperatingSystemPython::~OperatingSystemPython() {}
+OperatingSystemPython::~OperatingSystemPython() = default;
 
 DynamicRegisterInfo *OperatingSystemPython::GetDynamicRegisterInfo() {
   if (m_register_info_up == nullptr) {
     if (!m_interpreter || !m_python_object_sp)
       return nullptr;
     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OS));
 
     LLDB_LOGF(log,

lldb/source/Plugins/Platform/Android/AdbClient.cpp

                     connected_devices.size());
     adb.SetDeviceID(connected_devices.front());
   } else {
     adb.SetDeviceID(android_serial);
   }
   return error;
 }
 
-AdbClient::AdbClient() {}
+AdbClient::AdbClient() = default;
 
 AdbClient::AdbClient(const std::string &device_id) : m_device_id(device_id) {}
 
-AdbClient::~AdbClient() {}
+AdbClient::~AdbClient() = default;
 
 void AdbClient::SetDeviceID(const std::string &device_id) {
   m_device_id = device_id;
 }
 
 const std::string &AdbClient::GetDeviceID() const { return m_device_id; }
 
 Status AdbClient::Connect() {

 
   const auto error = cmd();
   if (error.Fail())
     m_conn.reset();
 
   return error;
 }
 
-AdbClient::SyncService::~SyncService() {}
+AdbClient::SyncService::~SyncService() = default;
 
 Status AdbClient::SyncService::SendSyncRequest(const char *request_id,
                                                const uint32_t data_len,
                                                const void *data) {
   const DataBufferSP data_sp(new DataBufferHeap(kSyncPacketLen, 0));
   DataEncoder encoder(data_sp, eByteOrderLittle, sizeof(void *));
   auto offset = encoder.PutData(0, request_id, strlen(request_id));
   encoder.PutUnsigned(offset, 4, data_len);

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

 //===-- PlatformAndroidRemoteGDBServer.cpp --------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/common/TCPSocket.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/UriParser.h"
 
 #include "PlatformAndroidRemoteGDBServer.h"
 
 #include <sstream>
static Status FindUnusedPort(uint16_t &port) {
 
   error = tcp_socket->Listen("127.0.0.1:0", 1);
   if (error.Success())
     port = tcp_socket->GetLocalPortNumber();
 
   return error;
 }
 
-PlatformAndroidRemoteGDBServer::PlatformAndroidRemoteGDBServer() {}
+PlatformAndroidRemoteGDBServer::PlatformAndroidRemoteGDBServer() = default;
 
 PlatformAndroidRemoteGDBServer::~PlatformAndroidRemoteGDBServer() {
   for (const auto &it : m_port_forwards)
     DeleteForwardPortWithAdb(it.second, m_device_id);
 }
 
 bool PlatformAndroidRemoteGDBServer::LaunchGDBServer(lldb::pid_t &pid,
                                                      std::string &connect_url) {

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

: PlatformDarwin(true), m_class_name(class_name),
       m_description(description), m_plugin_name(plugin_name), m_kind(kind),
       m_os_type(preferred_os), m_supported_triples(supported_triples),
       m_sdk(sdk), m_sdk_type(sdk_type) {}
 
 /// Destructor.
 ///
 /// The destructor is virtual since this class is designed to be
 /// inherited from by the plug-in instance.
-PlatformAppleSimulator::~PlatformAppleSimulator() {}
+PlatformAppleSimulator::~PlatformAppleSimulator() = default;
 
 lldb_private::Status PlatformAppleSimulator::LaunchProcess(
     lldb_private::ProcessLaunchInfo &launch_info) {
 #if defined(__APPLE__)
   LoadCoreSimulator();
   CoreSimulatorSupport::Device device(GetSimulatorDevice());
 
   if (device.GetState() != CoreSimulatorSupport::Device::State::Booted) {

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

 
 /// Default Constructor
 PlatformDarwin::PlatformDarwin(bool is_host) : PlatformPOSIX(is_host) {}
 
 /// Destructor.
 ///
 /// The destructor is virtual since this class is designed to be
 /// inherited from by the plug-in instance.
-PlatformDarwin::~PlatformDarwin() {}
+PlatformDarwin::~PlatformDarwin() = default;
 
 lldb_private::Status
 PlatformDarwin::PutFile(const lldb_private::FileSpec &source,
                         const lldb_private::FileSpec &destination, uint32_t uid,
                         uint32_t gid) {
   // Unconditionally unlink the destination. If it is an executable,
   // simply opening it and truncating its contents would invalidate
   // its cached code signature.

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

     return g_setting_name;
   }
 
   PlatformDarwinKernelProperties() : Properties() {
     m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName());
     m_collection_sp->Initialize(g_platformdarwinkernel_properties);
   }
 
-  virtual ~PlatformDarwinKernelProperties() {}
+  virtual ~PlatformDarwinKernelProperties() = default;
 
   FileSpecList GetKextDirectories() const {
     const uint32_t idx = ePropertyKextDirectories;
     const OptionValueFileSpecList *option_value =
         m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpecList(
             NULL, false, idx);
     assert(option_value);
     return option_value->GetCurrentValue();

   CollectKextAndKernelDirectories();
   SearchForKextsAndKernelsRecursively();
 }
 
 /// Destructor.
 ///
 /// The destructor is virtual since this class is designed to be
 /// inherited from by the plug-in instance.
-PlatformDarwinKernel::~PlatformDarwinKernel() {}
+PlatformDarwinKernel::~PlatformDarwinKernel() = default;
 
 void PlatformDarwinKernel::GetStatus(Stream &strm) {
   Platform::GetStatus(strm);
   strm.Printf(" Debug session type: ");
   if (m_ios_debug_session == eLazyBoolYes)
     strm.Printf("iOS kernel debugging\n");
   else if (m_ios_debug_session == eLazyBoolNo)
     strm.Printf("Mac OS X kernel debugging\n");

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

PlatformRemoteDarwinDevice::PlatformRemoteDarwinDevice()
     : PlatformDarwin(false), // This is a remote platform
       m_sdk_directory_infos(), m_device_support_directory(),
       m_device_support_directory_for_os_version(), m_build_update() {}
 
 /// Destructor.
 ///
 /// The destructor is virtual since this class is designed to be
 /// inherited from by the plug-in instance.
-PlatformRemoteDarwinDevice::~PlatformRemoteDarwinDevice() {}
+PlatformRemoteDarwinDevice::~PlatformRemoteDarwinDevice() = default;
 
 void PlatformRemoteDarwinDevice::GetStatus(Stream &strm) {
   Platform::GetStatus(strm);
   const char *sdk_directory = GetDeviceSupportDirectoryForOSVersion();
   if (sdk_directory)
     strm.Printf("  SDK Path: \"%s\"\n", sdk_directory);
   else
     strm.PutCString("  SDK Path: error: unable to locate SDK\n");

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

: RemoteAwarePlatform(is_host), // This is the local host platform
       m_option_group_platform_rsync(new OptionGroupPlatformRSync()),
       m_option_group_platform_ssh(new OptionGroupPlatformSSH()),
       m_option_group_platform_caching(new OptionGroupPlatformCaching()) {}
 
 /// Destructor.
 ///
 /// The destructor is virtual since this class is designed to be
 /// inherited from by the plug-in instance.
-PlatformPOSIX::~PlatformPOSIX() {}
+PlatformPOSIX::~PlatformPOSIX() = default;
 
 lldb_private::OptionGroupOptions *PlatformPOSIX::GetConnectionOptions(
     lldb_private::CommandInterpreter &interpreter) {
   auto iter = m_options.find(&interpreter), end = m_options.end();
   if (iter == end) {
     std::unique_ptr<lldb_private::OptionGroupOptions> options(
         new OptionGroupOptions());
     options->Append(m_option_group_platform_rsync.get());

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

   m_gdb_client.SetPacketTimeout(
       process_gdb_remote::ProcessGDBRemote::GetPacketTimeout());
 }
 
 /// Destructor.
 ///
 /// The destructor is virtual since this class is designed to be
 /// inherited from by the plug-in instance.
-PlatformRemoteGDBServer::~PlatformRemoteGDBServer() {}
+PlatformRemoteGDBServer::~PlatformRemoteGDBServer() = default;
 
 bool PlatformRemoteGDBServer::GetSupportedArchitectureAtIndex(uint32_t idx,
                                                               ArchSpec &arch) {
   ArchSpec remote_arch = m_gdb_client.GetSystemArchitecture();
 
   if (idx == 0) {
     arch = remote_arch;
     return arch.IsValid();

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

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

     return ProcessKDP::GetPluginNameStatic();
   }
 
   PluginProperties() : Properties() {
     m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName());
     m_collection_sp->Initialize(g_processkdp_properties);
   }
 
-  virtual ~PluginProperties() {}
+  virtual ~PluginProperties() = default;
 
   uint64_t GetPacketTimeout() {
     const uint32_t idx = ePropertyKDPPacketTimeout;
     return m_collection_sp->GetPropertyAtIndexAsUInt64(
         NULL, idx, g_processkdp_properties[idx].default_uint_value);
   }
 };
 

                       "Specify packet payload bytes as a hex ASCII string with "
                       "no spaces or hex prefixes.",
                       NULL) {
     m_option_group.Append(&m_command_byte, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
     m_option_group.Append(&m_packet_data, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
     m_option_group.Finalize();
   }
 
-  ~CommandObjectProcessKDPPacketSend() {}
+  ~CommandObjectProcessKDPPacketSend() = default;
 
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     const size_t argc = command.GetArgumentCount();
     if (argc == 0) {
       if (!m_command_byte.GetOptionValue().OptionWasSet()) {
         result.AppendError(
             "the --command option must be set to a valid command byte");
         result.SetStatus(eReturnStatusFailed);

       : CommandObjectMultiword(interpreter, "process plugin packet",
                                "Commands that deal with KDP remote packets.",
                                NULL) {
     LoadSubCommand(
         "send",
         CommandObjectSP(new CommandObjectProcessKDPPacketSend(interpreter)));
   }
 
-  ~CommandObjectProcessKDPPacket() {}
+  ~CommandObjectProcessKDPPacket() = default;
 };
 
 class CommandObjectMultiwordProcessKDP : public CommandObjectMultiword {
 public:
   CommandObjectMultiwordProcessKDP(CommandInterpreter &interpreter)
       : CommandObjectMultiword(
             interpreter, "process plugin",
             "Commands for operating on a ProcessKDP process.",
             "process plugin <subcommand> [<subcommand-options>]") {
     LoadSubCommand("packet", CommandObjectSP(new CommandObjectProcessKDPPacket(
                                  interpreter)));
   }
 
-  ~CommandObjectMultiwordProcessKDP() {}
+  ~CommandObjectMultiwordProcessKDP() = default;
 };
 
 CommandObject *ProcessKDP::GetPluginCommandObject() {
   if (!m_command_sp)
     m_command_sp = std::make_shared<CommandObjectMultiwordProcessKDP>(
         GetTarget().GetDebugger().GetCommandInterpreter());
   return m_command_sp.get();
 }

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

 using namespace lldb;
 using namespace lldb_private;
 
 RegisterContextKDP_arm::RegisterContextKDP_arm(ThreadKDP &thread,
                                                uint32_t concrete_frame_idx)
     : RegisterContextDarwin_arm(thread, concrete_frame_idx),
       m_kdp_thread(thread) {}
 
-RegisterContextKDP_arm::~RegisterContextKDP_arm() {}
+RegisterContextKDP_arm::~RegisterContextKDP_arm() = default;
 
 int RegisterContextKDP_arm::DoReadGPR(lldb::tid_t tid, int flavor, GPR &gpr) {
   ProcessSP process_sp(CalculateProcess());
   if (process_sp) {
     Status error;
     if (static_cast<ProcessKDP *>(process_sp.get())
             ->GetCommunication()
             .SendRequestReadRegisters(tid, GPRRegSet, &gpr, sizeof(gpr),

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

 using namespace lldb;
 using namespace lldb_private;
 
 RegisterContextKDP_arm64::RegisterContextKDP_arm64(ThreadKDP &thread,
                                                    uint32_t concrete_frame_idx)
     : RegisterContextDarwin_arm64(thread, concrete_frame_idx),
       m_kdp_thread(thread) {}
 
-RegisterContextKDP_arm64::~RegisterContextKDP_arm64() {}
+RegisterContextKDP_arm64::~RegisterContextKDP_arm64() = default;
 
 int RegisterContextKDP_arm64::DoReadGPR(lldb::tid_t tid, int flavor, GPR &gpr) {
   ProcessSP process_sp(CalculateProcess());
   if (process_sp) {
     Status error;
     if (static_cast<ProcessKDP *>(process_sp.get())
             ->GetCommunication()
             .SendRequestReadRegisters(tid, GPRRegSet, &gpr, sizeof(gpr),

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

 using namespace lldb;
 using namespace lldb_private;
 
 RegisterContextKDP_i386::RegisterContextKDP_i386(ThreadKDP &thread,
                                                  uint32_t concrete_frame_idx)
     : RegisterContextDarwin_i386(thread, concrete_frame_idx),
       m_kdp_thread(thread) {}
 
-RegisterContextKDP_i386::~RegisterContextKDP_i386() {}
+RegisterContextKDP_i386::~RegisterContextKDP_i386() = default;
 
 int RegisterContextKDP_i386::DoReadGPR(lldb::tid_t tid, int flavor, GPR &gpr) {
   ProcessSP process_sp(CalculateProcess());
   if (process_sp) {
     Status error;
     if (static_cast<ProcessKDP *>(process_sp.get())
             ->GetCommunication()
             .SendRequestReadRegisters(tid, GPRRegSet, &gpr, sizeof(gpr),

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

 using namespace lldb;
 using namespace lldb_private;
 
 RegisterContextKDP_x86_64::RegisterContextKDP_x86_64(
     ThreadKDP &thread, uint32_t concrete_frame_idx)
     : RegisterContextDarwin_x86_64(thread, concrete_frame_idx),
       m_kdp_thread(thread) {}
 
-RegisterContextKDP_x86_64::~RegisterContextKDP_x86_64() {}
+RegisterContextKDP_x86_64::~RegisterContextKDP_x86_64() = default;
 
 int RegisterContextKDP_x86_64::DoReadGPR(lldb::tid_t tid, int flavor,
                                          GPR &gpr) {
   ProcessSP process_sp(CalculateProcess());
   if (process_sp) {
     Status error;
     if (static_cast<ProcessKDP *>(process_sp.get())
             ->GetCommunication()

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

 //===-- HistoryUnwind.cpp -------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/lldb-private.h"
 
 #include "Plugins/Process/Utility/HistoryUnwind.h"
 #include "Plugins/Process/Utility/RegisterContextHistory.h"
 
 #include "lldb/Target/Process.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 
 #include <memory>
 
 using namespace lldb;
 using namespace lldb_private;
 
 // Constructor
 
 HistoryUnwind::HistoryUnwind(Thread &thread, std::vector<lldb::addr_t> pcs,
                              bool pcs_are_call_addresses)
     : Unwind(thread), m_pcs(pcs),
       m_pcs_are_call_addresses(pcs_are_call_addresses) {}
 
 // Destructor
 
-HistoryUnwind::~HistoryUnwind() {}
+HistoryUnwind::~HistoryUnwind() = default;
 
 void HistoryUnwind::DoClear() {
   std::lock_guard<std::recursive_mutex> guard(m_unwind_mutex);
   m_pcs.clear();
 }
 
 lldb::RegisterContextSP
 HistoryUnwind::DoCreateRegisterContextForFrame(StackFrame *frame) {

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

   uint32_t i;
   for (i = 0; i < kNumErrors; i++) {
     gpr_errs[i] = -1;
     fpu_errs[i] = -1;
     exc_errs[i] = -1;
   }
 }
 
-RegisterContextDarwin_arm::~RegisterContextDarwin_arm() {}
+RegisterContextDarwin_arm::~RegisterContextDarwin_arm() = default;
 
 void RegisterContextDarwin_arm::InvalidateAllRegisters() {
   InvalidateAllRegisterStates();
 }
 
 size_t RegisterContextDarwin_arm::GetRegisterCount() {
   assert(k_num_register_infos == k_num_registers);
   return k_num_registers;

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

   uint32_t i;
   for (i = 0; i < kNumErrors; i++) {
     gpr_errs[i] = -1;
     fpu_errs[i] = -1;
     exc_errs[i] = -1;
   }
 }
 
-RegisterContextDarwin_arm64::~RegisterContextDarwin_arm64() {}
+RegisterContextDarwin_arm64::~RegisterContextDarwin_arm64() = default;
 
 void RegisterContextDarwin_arm64::InvalidateAllRegisters() {
   InvalidateAllRegisterStates();
 }
 
 size_t RegisterContextDarwin_arm64::GetRegisterCount() {
   assert(k_num_register_infos == k_num_registers);
   return k_num_registers;

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

   uint32_t i;
   for (i = 0; i < kNumErrors; i++) {
     gpr_errs[i] = -1;
     fpu_errs[i] = -1;
     exc_errs[i] = -1;
   }
 }
 
-RegisterContextDarwin_i386::~RegisterContextDarwin_i386() {}
+RegisterContextDarwin_i386::~RegisterContextDarwin_i386() = default;
 
 void RegisterContextDarwin_i386::InvalidateAllRegisters() {
   InvalidateAllRegisterStates();
 }
 
 size_t RegisterContextDarwin_i386::GetRegisterCount() {
   assert(k_num_register_infos == k_num_registers);
   return k_num_registers;

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

   uint32_t i;
   for (i = 0; i < kNumErrors; i++) {
     gpr_errs[i] = -1;
     fpu_errs[i] = -1;
     exc_errs[i] = -1;
   }
 }
 
-RegisterContextDarwin_x86_64::~RegisterContextDarwin_x86_64() {}
+RegisterContextDarwin_x86_64::~RegisterContextDarwin_x86_64() = default;
 
 void RegisterContextDarwin_x86_64::InvalidateAllRegisters() {
   InvalidateAllRegisterStates();
 }
 
 size_t RegisterContextDarwin_x86_64::GetRegisterCount() {
   assert(k_num_register_infos == k_num_registers);
   return k_num_registers;

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

 #define DECLARE_REGISTER_INFOS_POWERPC_STRUCT
 #include "RegisterInfos_powerpc.h"
 #undef DECLARE_REGISTER_INFOS_POWERPC_STRUCT
 
 RegisterContextFreeBSD_powerpc::RegisterContextFreeBSD_powerpc(
     const ArchSpec &target_arch)
     : RegisterInfoInterface(target_arch) {}
 
-RegisterContextFreeBSD_powerpc::~RegisterContextFreeBSD_powerpc() {}
+RegisterContextFreeBSD_powerpc::~RegisterContextFreeBSD_powerpc() = default;
 
 size_t RegisterContextFreeBSD_powerpc::GetGPRSize() const {
   // This is an 'abstract' base, so no GPR struct.
   return 0;
 }
 
 const RegisterInfo *RegisterContextFreeBSD_powerpc::GetRegisterInfo() const {
   // assert (m_target_arch.GetCore() == ArchSpec::eCore_powerpc);
   llvm_unreachable("Abstract class!");
   return nullptr;
 }
 
 uint32_t RegisterContextFreeBSD_powerpc::GetRegisterCount() const { return 0; }
 
 RegisterContextFreeBSD_powerpc32::RegisterContextFreeBSD_powerpc32(
     const ArchSpec &target_arch)
     : RegisterContextFreeBSD_powerpc(target_arch) {}
 
-RegisterContextFreeBSD_powerpc32::~RegisterContextFreeBSD_powerpc32() {}
+RegisterContextFreeBSD_powerpc32::~RegisterContextFreeBSD_powerpc32() = default;
 
 size_t RegisterContextFreeBSD_powerpc32::GetGPRSize() const {
   return sizeof(GPR32);
 }
 
 const RegisterInfo *RegisterContextFreeBSD_powerpc32::GetRegisterInfo() const {
   // assert (m_target_arch.GetCore() == ArchSpec::eCore_powerpc);
   return g_register_infos_powerpc32;
 }
 
 uint32_t RegisterContextFreeBSD_powerpc32::GetRegisterCount() const {
   return static_cast<uint32_t>(sizeof(g_register_infos_powerpc32) /
                                sizeof(g_register_infos_powerpc32[0]));
 }
 
 RegisterContextFreeBSD_powerpc64::RegisterContextFreeBSD_powerpc64(
     const ArchSpec &target_arch)
     : RegisterContextFreeBSD_powerpc(target_arch) {}
 
-RegisterContextFreeBSD_powerpc64::~RegisterContextFreeBSD_powerpc64() {}
+RegisterContextFreeBSD_powerpc64::~RegisterContextFreeBSD_powerpc64() = default;
 
 size_t RegisterContextFreeBSD_powerpc64::GetGPRSize() const {
   return sizeof(GPR64);
 }
 
 const RegisterInfo *RegisterContextFreeBSD_powerpc64::GetRegisterInfo() const {
   // assert (m_target_arch.GetCore() == ArchSpec::eCore_powerpc);
   if (m_target_arch.GetMachine() == llvm::Triple::ppc)
     return g_register_infos_powerpc64_32;
   return g_register_infos_powerpc64;
 }
 
 uint32_t RegisterContextFreeBSD_powerpc64::GetRegisterCount() const {
   return static_cast<uint32_t>(sizeof(g_register_infos_powerpc64) /
                                sizeof(g_register_infos_powerpc64[0]));
 }

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

 
 using namespace lldb;
 using namespace lldb_private;
 
 RegisterContextMach_arm::RegisterContextMach_arm(Thread &thread,
                                                  uint32_t concrete_frame_idx)
     : RegisterContextDarwin_arm(thread, concrete_frame_idx) {}
 
-RegisterContextMach_arm::~RegisterContextMach_arm() {}
+RegisterContextMach_arm::~RegisterContextMach_arm() = default;
 
 int RegisterContextMach_arm::DoReadGPR(lldb::tid_t tid, int flavor, GPR &gpr) {
   mach_msg_type_number_t count = GPRWordCount;
   return ::thread_get_state(tid, flavor, (thread_state_t)&gpr, &count);
 }
 
 int RegisterContextMach_arm::DoReadFPU(lldb::tid_t tid, int flavor, FPU &fpu) {
   mach_msg_type_number_t count = FPUWordCount;

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

 
 using namespace lldb;
 using namespace lldb_private;
 
 RegisterContextMach_i386::RegisterContextMach_i386(Thread &thread,
                                                    uint32_t concrete_frame_idx)
     : RegisterContextDarwin_i386(thread, concrete_frame_idx) {}
 
-RegisterContextMach_i386::~RegisterContextMach_i386() {}
+RegisterContextMach_i386::~RegisterContextMach_i386() = default;
 
 int RegisterContextMach_i386::DoReadGPR(lldb::tid_t tid, int flavor, GPR &gpr) {
   mach_msg_type_number_t count = GPRWordCount;
   return ::thread_get_state(tid, flavor, (thread_state_t)&gpr, &count);
 }
 
 int RegisterContextMach_i386::DoReadFPU(lldb::tid_t tid, int flavor, FPU &fpu) {
   mach_msg_type_number_t count = FPUWordCount;

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

 
 using namespace lldb;
 using namespace lldb_private;
 
 RegisterContextMach_x86_64::RegisterContextMach_x86_64(
     Thread &thread, uint32_t concrete_frame_idx)
     : RegisterContextDarwin_x86_64(thread, concrete_frame_idx) {}
 
-RegisterContextMach_x86_64::~RegisterContextMach_x86_64() {}
+RegisterContextMach_x86_64::~RegisterContextMach_x86_64() = default;
 
 int RegisterContextMach_x86_64::DoReadGPR(lldb::tid_t tid, int flavor,
                                           GPR &gpr) {
   mach_msg_type_number_t count = GPRWordCount;
   return ::thread_get_state(tid, flavor, (thread_state_t)&gpr, &count);
 }
 
 int RegisterContextMach_x86_64::DoReadFPU(lldb::tid_t tid, int flavor,

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

RegisterContextMemory::RegisterContextMemory(Thread &thread,
 
   // Make a heap based buffer that is big enough to store all registers
   DataBufferSP reg_data_sp(
       new DataBufferHeap(reg_infos.GetRegisterDataByteSize(), 0));
   m_reg_data.SetData(reg_data_sp);
 }
 
 // Destructor
-RegisterContextMemory::~RegisterContextMemory() {}
+RegisterContextMemory::~RegisterContextMemory() = default;
 
 void RegisterContextMemory::InvalidateAllRegisters() {
   if (m_reg_data_addr != LLDB_INVALID_ADDRESS)
     SetAllRegisterValid(false);
 }
 
 void RegisterContextMemory::SetAllRegisterValid(bool b) {
   std::vector<bool>::iterator pos, end = m_reg_valid.end();

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

 //===-- RegisterContextPOSIX_arm.cpp --------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include <cerrno>
 #include <cstdint>
 #include <cstring>
 
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/Scalar.h"
 #include "llvm/Support/Compiler.h"

 }
 
 RegisterContextPOSIX_arm::RegisterContextPOSIX_arm(
     lldb_private::Thread &thread,
     std::unique_ptr<RegisterInfoPOSIX_arm> register_info)
     : lldb_private::RegisterContext(thread, 0),
       m_register_info_up(std::move(register_info)) {}
 
-RegisterContextPOSIX_arm::~RegisterContextPOSIX_arm() {}
+RegisterContextPOSIX_arm::~RegisterContextPOSIX_arm() = default;
 
 void RegisterContextPOSIX_arm::Invalidate() {}
 
 void RegisterContextPOSIX_arm::InvalidateAllRegisters() {}
 
 unsigned RegisterContextPOSIX_arm::GetRegisterOffset(unsigned reg) {
   return m_register_info_up->GetRegisterInfo()[reg].byte_offset;
 }

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

 //===-- RegisterContextPOSIX_arm64.cpp ------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include <cerrno>
 #include <cstdint>
 #include <cstring>
 
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/Scalar.h"
 #include "llvm/Support/Compiler.h"

 }
 
 RegisterContextPOSIX_arm64::RegisterContextPOSIX_arm64(
     lldb_private::Thread &thread,
     std::unique_ptr<RegisterInfoPOSIX_arm64> register_info)
     : lldb_private::RegisterContext(thread, 0),
       m_register_info_up(std::move(register_info)) {}
 
-RegisterContextPOSIX_arm64::~RegisterContextPOSIX_arm64() {}
+RegisterContextPOSIX_arm64::~RegisterContextPOSIX_arm64() = default;
 
 void RegisterContextPOSIX_arm64::Invalidate() {}
 
 void RegisterContextPOSIX_arm64::InvalidateAllRegisters() {}
 
 unsigned RegisterContextPOSIX_arm64::GetRegisterOffset(unsigned reg) {
   return m_register_info_up->GetRegisterInfo()[reg].byte_offset;
 }

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

 //===-- RegisterContextPOSIX_mips64.cpp -----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include <cerrno>
 #include <cstdint>
 #include <cstring>
 
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/Scalar.h"
 #include "llvm/Support/Compiler.h"
RegisterContextPOSIX_mips64::RegisterContextPOSIX_mips64(
   }
 
   assert(m_num_registers ==
          static_cast<uint32_t>(m_registers_count[gpr_registers_count] +
                                m_registers_count[fpr_registers_count] +
                                m_registers_count[msa_registers_count]));
 }
 
-RegisterContextPOSIX_mips64::~RegisterContextPOSIX_mips64() {}
+RegisterContextPOSIX_mips64::~RegisterContextPOSIX_mips64() = default;
 
 void RegisterContextPOSIX_mips64::Invalidate() {}
 
 void RegisterContextPOSIX_mips64::InvalidateAllRegisters() {}
 
 unsigned RegisterContextPOSIX_mips64::GetRegisterOffset(unsigned reg) {
   assert(reg < m_num_registers && "Invalid register number.");
   return GetRegisterInfo()[reg].byte_offset;

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

 //===-- RegisterContextPOSIX_powerpc.cpp ----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include <cerrno>
 #include <cstdint>
 #include <cstring>
 
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/Scalar.h"
 #include "llvm/Support/Compiler.h"

 
 RegisterContextPOSIX_powerpc::RegisterContextPOSIX_powerpc(
     Thread &thread, uint32_t concrete_frame_idx,
     RegisterInfoInterface *register_info)
     : RegisterContext(thread, concrete_frame_idx) {
   m_register_info_up.reset(register_info);
 }
 
-RegisterContextPOSIX_powerpc::~RegisterContextPOSIX_powerpc() {}
+RegisterContextPOSIX_powerpc::~RegisterContextPOSIX_powerpc() = default;
 
 void RegisterContextPOSIX_powerpc::Invalidate() {}
 
 void RegisterContextPOSIX_powerpc::InvalidateAllRegisters() {}
 
 unsigned RegisterContextPOSIX_powerpc::GetRegisterOffset(unsigned reg) {
   assert(reg < k_num_registers_powerpc && "Invalid register number.");
   return GetRegisterInfo()[reg].byte_offset;

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

 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include <cerrno>
 #include <cstdint>
 #include <cstring>
 
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/Scalar.h"
 #include "llvm/Support/Compiler.h"

     m_reg_info.last_fpr = k_last_fpr_s390x;
     break;
   default:
     assert(false && "Unhandled target architecture.");
     break;
   }
 }
 
-RegisterContextPOSIX_s390x::~RegisterContextPOSIX_s390x() {}
+RegisterContextPOSIX_s390x::~RegisterContextPOSIX_s390x() = default;
 
 void RegisterContextPOSIX_s390x::Invalidate() {}
 
 void RegisterContextPOSIX_s390x::InvalidateAllRegisters() {}
 
 const RegisterInfo *RegisterContextPOSIX_s390x::GetRegisterInfo() {
   return m_register_info_up->GetRegisterInfo();
 }

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

     break;
   }
 
   ::memset(&m_fpr, 0, sizeof(FPR));
 
   m_fpr_type = eNotValid;
 }
 
-RegisterContextPOSIX_x86::~RegisterContextPOSIX_x86() {}
+RegisterContextPOSIX_x86::~RegisterContextPOSIX_x86() = default;
 
 RegisterContextPOSIX_x86::FPRType RegisterContextPOSIX_x86::GetFPRType() {
   if (m_fpr_type == eNotValid) {
     // TODO: Use assembly to call cpuid on the inferior and query ebx or ecx
     m_fpr_type = eXSAVE; // extended floating-point registers, if available
     if (!ReadFPR())
       m_fpr_type = eFXSAVE; // assume generic floating-point registers
   }

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

 //===-- RegisterContextThreadMemory.cpp -----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Target/OperatingSystem.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/lldb-private.h"
 
 #include "RegisterContextThreadMemory.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 RegisterContextThreadMemory::RegisterContextThreadMemory(
     Thread &thread, lldb::addr_t register_data_addr)
     : RegisterContext(thread, 0), m_thread_wp(thread.shared_from_this()),
       m_reg_ctx_sp(), m_register_data_addr(register_data_addr), m_stop_id(0) {}
 
-RegisterContextThreadMemory::~RegisterContextThreadMemory() {}
+RegisterContextThreadMemory::~RegisterContextThreadMemory() = default;
 
 void RegisterContextThreadMemory::UpdateRegisterContext() {
   ThreadSP thread_sp(m_thread_wp.lock());
   if (thread_sp) {
     ProcessSP process_sp(thread_sp->GetProcess());
 
     if (process_sp) {
       const uint32_t stop_id = process_sp->GetModID().GetStopID();

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

 //===-- RegisterInfoInterface.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_SOURCE_PLUGINS_PROCESS_UTILITY_REGISTERINFOINTERFACE_H
 #define LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_REGISTERINFOINTERFACE_H
 
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/lldb-private-types.h"
 #include <vector>
 
 namespace lldb_private {
 
 /// \class RegisterInfoInterface
 ///
 /// RegisterInfo interface to patch RegisterInfo structure for archs.
 class RegisterInfoInterface {
 public:
   RegisterInfoInterface(const lldb_private::ArchSpec &target_arch)
       : m_target_arch(target_arch) {}
-  virtual ~RegisterInfoInterface() {}
+  virtual ~RegisterInfoInterface() = default;
 
   virtual size_t GetGPRSize() const = 0;
 
   virtual const lldb_private::RegisterInfo *GetRegisterInfo() const = 0;
 
   // Returns the number of registers including the user registers and the
   // lldb internal registers also
   virtual uint32_t GetRegisterCount() const = 0;

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

RegisterContextCorePOSIX_arm::RegisterContextCorePOSIX_arm(
     const DataExtractor &gpregset, llvm::ArrayRef<CoreNote> notes)
     : RegisterContextPOSIX_arm(thread, std::move(register_info)) {
   m_gpr_buffer = std::make_shared<DataBufferHeap>(gpregset.GetDataStart(),
                                                   gpregset.GetByteSize());
   m_gpr.SetData(m_gpr_buffer);
   m_gpr.SetByteOrder(gpregset.GetByteOrder());
 }
 
-RegisterContextCorePOSIX_arm::~RegisterContextCorePOSIX_arm() {}
+RegisterContextCorePOSIX_arm::~RegisterContextCorePOSIX_arm() = default;
 
 bool RegisterContextCorePOSIX_arm::ReadGPR() { return true; }
 
 bool RegisterContextCorePOSIX_arm::ReadFPR() { return false; }
 
 bool RegisterContextCorePOSIX_arm::WriteGPR() {
   assert(0);
   return false;

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

if (m_register_info_up->IsSVEEnabled())
     m_sve_data = getRegset(notes, target_triple, AARCH64_SVE_Desc);
 
   if (m_register_info_up->IsPAuthEnabled())
     m_pac_data = getRegset(notes, target_triple, AARCH64_PAC_Desc);
 
   ConfigureRegisterContext();
 }
 
-RegisterContextCorePOSIX_arm64::~RegisterContextCorePOSIX_arm64() {}
+RegisterContextCorePOSIX_arm64::~RegisterContextCorePOSIX_arm64() = default;
 
 bool RegisterContextCorePOSIX_arm64::ReadGPR() { return true; }
 
 bool RegisterContextCorePOSIX_arm64::ReadFPR() { return false; }
 
 bool RegisterContextCorePOSIX_arm64::WriteGPR() {
   assert(0);
   return false;

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

RegisterContextCorePOSIX_mips64::RegisterContextCorePOSIX_mips64(
   DataExtractor fpregset = getRegset(
       notes, register_info->GetTargetArchitecture().GetTriple(), FPR_Desc);
   m_fpr_buffer = std::make_shared<DataBufferHeap>(fpregset.GetDataStart(),
                                                   fpregset.GetByteSize());
   m_fpr.SetData(m_fpr_buffer);
   m_fpr.SetByteOrder(fpregset.GetByteOrder());
 }
 
-RegisterContextCorePOSIX_mips64::~RegisterContextCorePOSIX_mips64() {}
+RegisterContextCorePOSIX_mips64::~RegisterContextCorePOSIX_mips64() = default;
 
 bool RegisterContextCorePOSIX_mips64::ReadGPR() { return true; }
 
 bool RegisterContextCorePOSIX_mips64::ReadFPR() { return false; }
 
 bool RegisterContextCorePOSIX_mips64::WriteGPR() {
   assert(0);
   return false;

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

RegisterContextCorePOSIX_powerpc::RegisterContextCorePOSIX_powerpc(
 
   DataExtractor vregset = getRegset(notes, arch.GetTriple(), PPC_VMX_Desc);
   m_vec_buffer = std::make_shared<DataBufferHeap>(vregset.GetDataStart(),
                                                   vregset.GetByteSize());
   m_vec.SetData(m_vec_buffer);
   m_vec.SetByteOrder(vregset.GetByteOrder());
 }
 
-RegisterContextCorePOSIX_powerpc::~RegisterContextCorePOSIX_powerpc() {}
+RegisterContextCorePOSIX_powerpc::~RegisterContextCorePOSIX_powerpc() = default;
 
 bool RegisterContextCorePOSIX_powerpc::ReadGPR() { return true; }
 
 bool RegisterContextCorePOSIX_powerpc::ReadFPR() { return true; }
 
 bool RegisterContextCorePOSIX_powerpc::ReadVMX() { return true; }
 
 bool RegisterContextCorePOSIX_powerpc::WriteGPR() {

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

RegisterContextCorePOSIX_s390x::RegisterContextCorePOSIX_s390x(
   DataExtractor fpregset = getRegset(
       notes, register_info->GetTargetArchitecture().GetTriple(), FPR_Desc);
   m_fpr_buffer = std::make_shared<DataBufferHeap>(fpregset.GetDataStart(),
                                                   fpregset.GetByteSize());
   m_fpr.SetData(m_fpr_buffer);
   m_fpr.SetByteOrder(fpregset.GetByteOrder());
 }
 
-RegisterContextCorePOSIX_s390x::~RegisterContextCorePOSIX_s390x() {}
+RegisterContextCorePOSIX_s390x::~RegisterContextCorePOSIX_s390x() = default;
 
 bool RegisterContextCorePOSIX_s390x::ReadGPR() { return true; }
 
 bool RegisterContextCorePOSIX_s390x::ReadFPR() { return true; }
 
 bool RegisterContextCorePOSIX_s390x::WriteGPR() {
   assert(0);
   return false;

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

 using namespace lldb_private::process_gdb_remote;
 
 GDBRemoteCommunicationHistory::GDBRemoteCommunicationHistory(uint32_t size)
     : m_packets() {
   if (size)
     m_packets.resize(size);
 }
 
-GDBRemoteCommunicationHistory::~GDBRemoteCommunicationHistory() {}
+GDBRemoteCommunicationHistory::~GDBRemoteCommunicationHistory() = default;
 
 void GDBRemoteCommunicationHistory::AddPacket(char packet_char,
                                               GDBRemotePacket::Type type,
                                               uint32_t bytes_transmitted) {
   const size_t size = m_packets.size();
   if (size == 0)
     return;
 

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

 //===-- GDBRemoteCommunicationServer.cpp ----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include <cerrno>
 
 #include "lldb/Host/Config.h"
 
 #include "GDBRemoteCommunicationServer.h"
 
 #include "ProcessGDBRemoteLog.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/StringExtractorGDBRemote.h"
 #include "lldb/Utility/UnimplementedError.h"
 #include "llvm/Support/JSON.h"
 #include <cstring>
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::process_gdb_remote;
 using namespace llvm;
 
 GDBRemoteCommunicationServer::GDBRemoteCommunicationServer(
     const char *comm_name, const char *listener_name)
     : GDBRemoteCommunication(comm_name, listener_name), m_exit_now(false) {
   RegisterPacketHandler(
       StringExtractorGDBRemote::eServerPacketType_QEnableErrorStrings,
       [this](StringExtractorGDBRemote packet, Status &error, bool &interrupt,
              bool &quit) { return this->Handle_QErrorStringEnable(packet); });
 }
 
-GDBRemoteCommunicationServer::~GDBRemoteCommunicationServer() {}
+GDBRemoteCommunicationServer::~GDBRemoteCommunicationServer() = default;
 
 void GDBRemoteCommunicationServer::RegisterPacketHandler(
     StringExtractorGDBRemote::ServerPacketType packet_type,
     PacketHandler handler) {
   m_packet_handlers[packet_type] = std::move(handler);
 }
 
 GDBRemoteCommunication::PacketResult

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

       StringExtractorGDBRemote::eServerPacketType_vFile_symlink,
       &GDBRemoteCommunicationServerCommon::Handle_vFile_symlink);
   RegisterMemberFunctionHandler(
       StringExtractorGDBRemote::eServerPacketType_vFile_unlink,
       &GDBRemoteCommunicationServerCommon::Handle_vFile_unlink);
 }
 
 // Destructor
-GDBRemoteCommunicationServerCommon::~GDBRemoteCommunicationServerCommon() {}
+GDBRemoteCommunicationServerCommon::~GDBRemoteCommunicationServerCommon() =
+    default;
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerCommon::Handle_qHostInfo(
     StringExtractorGDBRemote &packet) {
   StreamString response;
 
   // $cputype:16777223;cpusubtype:3;ostype:Darwin;vendor:apple;endian:little;ptrsize:8;#00
 

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

                            bool &interrupt, bool &quit) {
                           error.SetErrorString("interrupt received");
                           interrupt = true;
                           return PacketResult::Success;
                         });
 }
 
 // Destructor
-GDBRemoteCommunicationServerPlatform::~GDBRemoteCommunicationServerPlatform() {}
+GDBRemoteCommunicationServerPlatform::~GDBRemoteCommunicationServerPlatform() =
+    default;
 
 Status GDBRemoteCommunicationServerPlatform::LaunchGDBServer(
     const lldb_private::Args &args, std::string hostname, lldb::pid_t &pid,
     llvm::Optional<uint16_t> &port, std::string &socket_name) {
   if (!port) {
     llvm::Expected<uint16_t> available_port = m_port_map.GetNextAvailablePort();
     if (available_port)
       port = *available_port;

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

GDBRemoteRegisterContext::GDBRemoteRegisterContext(
   // Make a heap based buffer that is big enough to store all registers
   DataBufferSP reg_data_sp(
       new DataBufferHeap(m_reg_info_sp->GetRegisterDataByteSize(), 0));
   m_reg_data.SetData(reg_data_sp);
   m_reg_data.SetByteOrder(thread.GetProcess()->GetByteOrder());
 }
 
 // Destructor
-GDBRemoteRegisterContext::~GDBRemoteRegisterContext() {}
+GDBRemoteRegisterContext::~GDBRemoteRegisterContext() = default;
 
 void GDBRemoteRegisterContext::InvalidateAllRegisters() {
   SetAllRegisterValid(false);
 }
 
 void GDBRemoteRegisterContext::SetAllRegisterValid(bool b) {
   m_gpacket_cached = b;
   std::vector<bool>::iterator pos, end = m_reg_valid.end();

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

     return ProcessGDBRemote::GetPluginNameStatic();
   }
 
   PluginProperties() : Properties() {
     m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName());
     m_collection_sp->Initialize(g_processgdbremote_properties);
   }
 
-  ~PluginProperties() override {}
+  ~PluginProperties() override = default;
 
   uint64_t GetPacketTimeout() {
     const uint32_t idx = ePropertyPacketTimeout;
     return m_collection_sp->GetPropertyAtIndexAsUInt64(
         nullptr, idx, g_processgdbremote_properties[idx].default_uint_value);
   }
 
   bool SetPacketTimeout(uint64_t timeout) {

                "Print the output as JSON data for easy parsing.", false, true) {
     m_option_group.Append(&m_num_packets, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
     m_option_group.Append(&m_max_send, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
     m_option_group.Append(&m_max_recv, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
     m_option_group.Append(&m_json, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
     m_option_group.Finalize();
   }
 
-  ~CommandObjectProcessGDBRemoteSpeedTest() override {}
+  ~CommandObjectProcessGDBRemoteSpeedTest() override = default;
 
   Options *GetOptions() override { return &m_option_group; }
 
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     const size_t argc = command.GetArgumentCount();
     if (argc == 0) {
       ProcessGDBRemote *process =
           (ProcessGDBRemote *)m_interpreter.GetExecutionContext()

 
 class CommandObjectProcessGDBRemotePacketHistory : public CommandObjectParsed {
 private:
 public:
   CommandObjectProcessGDBRemotePacketHistory(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "process plugin packet history",
                             "Dumps the packet history buffer. ", nullptr) {}
 
-  ~CommandObjectProcessGDBRemotePacketHistory() override {}
+  ~CommandObjectProcessGDBRemotePacketHistory() override = default;
 
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     const size_t argc = command.GetArgumentCount();
     if (argc == 0) {
       ProcessGDBRemote *process =
           (ProcessGDBRemote *)m_interpreter.GetExecutionContext()
               .GetProcessPtr();
       if (process) {

 private:
 public:
   CommandObjectProcessGDBRemotePacketXferSize(CommandInterpreter &interpreter)
       : CommandObjectParsed(
             interpreter, "process plugin packet xfer-size",
             "Maximum size that lldb will try to read/write one one chunk.",
             nullptr) {}
 
-  ~CommandObjectProcessGDBRemotePacketXferSize() override {}
+  ~CommandObjectProcessGDBRemotePacketXferSize() override = default;
 
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     const size_t argc = command.GetArgumentCount();
     if (argc == 0) {
       result.AppendErrorWithFormat("'%s' takes an argument to specify the max "
                                    "amount to be transferred when "
                                    "reading/writing",
                                    m_cmd_name.c_str());

       : CommandObjectParsed(interpreter, "process plugin packet send",
                             "Send a custom packet through the GDB remote "
                             "protocol and print the answer. "
                             "The packet header and footer will automatically "
                             "be added to the packet prior to sending and "
                             "stripped from the result.",
                             nullptr) {}
 
-  ~CommandObjectProcessGDBRemotePacketSend() override {}
+  ~CommandObjectProcessGDBRemotePacketSend() override = default;
 
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     const size_t argc = command.GetArgumentCount();
     if (argc == 0) {
       result.AppendErrorWithFormat(
           "'%s' takes a one or more packet content arguments",
           m_cmd_name.c_str());
       result.SetStatus(eReturnStatusFailed);

   CommandObjectProcessGDBRemotePacketMonitor(CommandInterpreter &interpreter)
       : CommandObjectRaw(interpreter, "process plugin packet monitor",
                          "Send a qRcmd packet through the GDB remote protocol "
                          "and print the response."
                          "The argument passed to this command will be hex "
                          "encoded into a valid 'qRcmd' packet, sent and the "
                          "response will be printed.") {}
 
-  ~CommandObjectProcessGDBRemotePacketMonitor() override {}
+  ~CommandObjectProcessGDBRemotePacketMonitor() override = default;
 
   bool DoExecute(llvm::StringRef command,
                  CommandReturnObject &result) override {
     if (command.empty()) {
       result.AppendErrorWithFormat("'%s' takes a command string argument",
                                    m_cmd_name.c_str());
       result.SetStatus(eReturnStatusFailed);
       return false;

         "xfer-size",
         CommandObjectSP(
             new CommandObjectProcessGDBRemotePacketXferSize(interpreter)));
     LoadSubCommand("speed-test",
                    CommandObjectSP(new CommandObjectProcessGDBRemoteSpeedTest(
                        interpreter)));
   }
 
-  ~CommandObjectProcessGDBRemotePacket() override {}
+  ~CommandObjectProcessGDBRemotePacket() override = default;
 };
 
 class CommandObjectMultiwordProcessGDBRemote : public CommandObjectMultiword {
 public:
   CommandObjectMultiwordProcessGDBRemote(CommandInterpreter &interpreter)
       : CommandObjectMultiword(
             interpreter, "process plugin",
             "Commands for operating on a ProcessGDBRemote process.",
             "process plugin <subcommand> [<subcommand-options>]") {
     LoadSubCommand(
         "packet",
         CommandObjectSP(new CommandObjectProcessGDBRemotePacket(interpreter)));
   }
 
-  ~CommandObjectMultiwordProcessGDBRemote() override {}
+  ~CommandObjectMultiwordProcessGDBRemote() override = default;
 };
 
 CommandObject *ProcessGDBRemote::GetPluginCommandObject() {
   if (!m_command_sp)
     m_command_sp = std::make_shared<CommandObjectMultiwordProcessGDBRemote>(
         GetTarget().GetDebugger().GetCommandInterpreter());
   return m_command_sp.get();
 }

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

     APPEND_OPT(m_fb_app_state);
     APPEND_OPT(m_fb_abort);
     APPEND_OPT(m_fb_thread);
     APPEND_OPT(m_fb_logcat);
     APPEND_OPT(m_fb_all);
     m_option_group.Finalize();
   }
 
-  ~CommandObjectProcessMinidumpDump() override {}
+  ~CommandObjectProcessMinidumpDump() override = default;
 
   Options *GetOptions() override { return &m_option_group; }
 
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     const size_t argc = command.GetArgumentCount();
     if (argc > 0) {
       result.AppendErrorWithFormat("'%s' take no arguments, only options",
                                    m_cmd_name.c_str());

   CommandObjectMultiwordProcessMinidump(CommandInterpreter &interpreter)
     : CommandObjectMultiword(interpreter, "process plugin",
           "Commands for operating on a ProcessMinidump process.",
           "process plugin <subcommand> [<subcommand-options>]") {
     LoadSubCommand("dump",
         CommandObjectSP(new CommandObjectProcessMinidumpDump(interpreter)));
   }
 
-  ~CommandObjectMultiwordProcessMinidump() override {}
+  ~CommandObjectMultiwordProcessMinidump() override = default;
 };
 
 CommandObject *ProcessMinidump::GetPluginCommandObject() {
   if (!m_command_sp)
     m_command_sp = std::make_shared<CommandObjectMultiwordProcessMinidump>(
         GetTarget().GetDebugger().GetCommandInterpreter());
   return m_command_sp.get();
 }

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

 using namespace lldb_private;
 using namespace minidump;
 
 ThreadMinidump::ThreadMinidump(Process &process, const minidump::Thread &td,
                                llvm::ArrayRef<uint8_t> gpregset_data)
     : Thread(process, td.ThreadId), m_thread_reg_ctx_sp(),
       m_gpregset_data(gpregset_data) {}
 
-ThreadMinidump::~ThreadMinidump() {}
+ThreadMinidump::~ThreadMinidump() = default;
 
 void ThreadMinidump::RefreshStateAfterStop() {}
 
 RegisterContextSP ThreadMinidump::GetRegisterContext() {
   if (!m_reg_context_sp) {
     m_reg_context_sp = CreateRegisterContextForFrame(nullptr);
   }
   return m_reg_context_sp;

lldb/source/Plugins/ScriptInterpreter/Lua/ScriptInterpreterLua.cpp

 
   bool IsQuitCommand(llvm::StringRef cmd) { return cmd.rtrim() == "quit"; }
 };
 
 ScriptInterpreterLua::ScriptInterpreterLua(Debugger &debugger)
     : ScriptInterpreter(debugger, eScriptLanguageLua),
       m_lua(std::make_unique<Lua>()) {}
 
-ScriptInterpreterLua::~ScriptInterpreterLua() {}
+ScriptInterpreterLua::~ScriptInterpreterLua() = default;
 
 bool ScriptInterpreterLua::ExecuteOneLine(llvm::StringRef command,
                                           CommandReturnObject *result,
                                           const ExecuteScriptOptions &options) {
   if (command.empty()) {
     if (result)
       result->AppendError("empty command passed to lua\n");
     return false;

lldb/source/Plugins/ScriptInterpreter/None/ScriptInterpreterNone.cpp

 using namespace lldb;
 using namespace lldb_private;
 
 LLDB_PLUGIN_DEFINE(ScriptInterpreterNone)
 
 ScriptInterpreterNone::ScriptInterpreterNone(Debugger &debugger)
     : ScriptInterpreter(debugger, eScriptLanguageNone) {}
 
-ScriptInterpreterNone::~ScriptInterpreterNone() {}
+ScriptInterpreterNone::~ScriptInterpreterNone() = default;
 
 bool ScriptInterpreterNone::ExecuteOneLine(llvm::StringRef command,
                                            CommandReturnObject *,
                                            const ExecuteScriptOptions &) {
   m_debugger.GetErrorStream().PutCString(
       "error: there is no embedded script interpreter in this mode.\n");
   return false;
 }

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

 struct PythonFormat<
     T, typename std::enable_if<std::is_base_of<PythonObject, T>::value>::type> {
   static constexpr char format = 'O';
   static auto get(const T &value) { return value.get(); }
 };
 
 class PythonObject {
 public:
-  PythonObject() {}
+  PythonObject() = default;
 
   PythonObject(PyRefType type, PyObject *py_obj) {
     m_py_obj = py_obj;
     // If this is a borrowed reference, we need to convert it to
     // an owned reference by incrementing it.  If it is an owned
     // reference (for example the caller allocated it with PyDict_New()
     // then we must *not* increment it.
     if (m_py_obj && Py_IsInitialized() && type == PyRefType::Borrowed)

       return;
     T::Convert(type, py_obj);
     if (T::Check(py_obj))
       PythonObject::operator=(PythonObject(type, py_obj));
     else if (type == PyRefType::Owned)
       Py_DECREF(py_obj);
   }
 
-  TypedPythonObject() {}
+  TypedPythonObject() = default;
 };
 
 class PythonBytes : public TypedPythonObject<PythonBytes> {
 public:
   using TypedPythonObject::TypedPythonObject;
   explicit PythonBytes(llvm::ArrayRef<uint8_t> bytes);
   PythonBytes(const uint8_t *bytes, size_t length);
 

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

 
 class IOHandlerPythonInterpreter : public IOHandler {
 public:
   IOHandlerPythonInterpreter(Debugger &debugger,
                              ScriptInterpreterPythonImpl *python)
       : IOHandler(debugger, IOHandler::Type::PythonInterpreter),
         m_python(python) {}
 
-  ~IOHandlerPythonInterpreter() override {}
+  ~IOHandlerPythonInterpreter() override = default;
 
   ConstString GetControlSequence(char ch) override {
     if (ch == 'd')
       return ConstString("quit()\n");
     return ConstString();
   }
 
   void Run() override {

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

     return g_setting_name;
   }
 
   StructuredDataDarwinLogProperties() : Properties() {
     m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName());
     m_collection_sp->Initialize(g_darwinlog_properties);
   }
 
-  ~StructuredDataDarwinLogProperties() override {}
+  ~StructuredDataDarwinLogProperties() override = default;
 
   bool GetEnableOnStartup() const {
     const uint32_t idx = ePropertyEnableOnStartup;
     return m_collection_sp->GetPropertyAtIndexAsBoolean(
         nullptr, idx, g_darwinlog_properties[idx].default_uint_value != 0);
   }
 
   llvm::StringRef GetAutoEnableOptions() const {

   return s_event_type;
 }
 
 class FilterRule;
 using FilterRuleSP = std::shared_ptr<FilterRule>;
 
 class FilterRule {
 public:
-  virtual ~FilterRule() {}
+  virtual ~FilterRule() = default;
 
   using OperationCreationFunc =
       std::function<FilterRuleSP(bool accept, size_t attribute_index,
                                  const std::string &op_arg, Status &error)>;
 
   static void RegisterOperation(ConstString operation,
                                 const OperationCreationFunc &creation_func) {
     GetCreationFuncMap().insert(std::make_pair(operation, creation_func));

lldb/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.h

 //===-- SymbolFileBreakpad.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_SOURCE_PLUGINS_SYMBOLFILE_BREAKPAD_SYMBOLFILEBREAKPAD_H
 #define LLDB_SOURCE_PLUGINS_SYMBOLFILE_BREAKPAD_SYMBOLFILEBREAKPAD_H
 
 #include "Plugins/ObjectFile/Breakpad/BreakpadRecords.h"
 #include "lldb/Core/FileSpecList.h"
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Symbol/PostfixExpression.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/UnwindPlan.h"
 
 namespace lldb_private {
 
public:
   static SymbolFile *CreateInstance(lldb::ObjectFileSP objfile_sp) {
     return new SymbolFileBreakpad(std::move(objfile_sp));
   }
 
   // Constructors and Destructors
   SymbolFileBreakpad(lldb::ObjectFileSP objfile_sp)
       : SymbolFile(std::move(objfile_sp)) {}
 
-  ~SymbolFileBreakpad() override {}
+  ~SymbolFileBreakpad() override = default;
 
   uint32_t CalculateAbilities() override;
 
   void InitializeObject() override {}
 
   // Compile Unit function calls
 
   lldb::LanguageType ParseLanguage(CompileUnit &comp_unit) override {

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

 namespace lldb_private {
 class CompileUnit;
 class ExecutionContext;
 }
 class SymbolFileDWARF;
 
 class DWARFASTParser {
 public:
-  virtual ~DWARFASTParser() {}
+  virtual ~DWARFASTParser() = default;
 
   virtual lldb::TypeSP ParseTypeFromDWARF(const lldb_private::SymbolContext &sc,
                                           const DWARFDIE &die,
                                           bool *type_is_new_ptr) = 0;
 
   virtual lldb_private::Function *
   ParseFunctionFromDWARF(lldb_private::CompileUnit &comp_unit,
                          const DWARFDIE &die) = 0;

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

 #define DEBUG_PRINTF(fmt, ...)
 #endif
 
 using namespace lldb;
 using namespace lldb_private;
 DWARFASTParserClang::DWARFASTParserClang(TypeSystemClang &ast)
     : m_ast(ast), m_die_to_decl_ctx(), m_decl_ctx_to_die() {}
 
-DWARFASTParserClang::~DWARFASTParserClang() {}
+DWARFASTParserClang::~DWARFASTParserClang() = default;
 
 static AccessType DW_ACCESS_to_AccessType(uint32_t dwarf_accessibility) {
   switch (dwarf_accessibility) {
   case DW_ACCESS_public:
     return eAccessPublic;
   case DW_ACCESS_private:
     return eAccessPrivate;
   case DW_ACCESS_protected:

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

 //===-- DWARFAttribute.cpp ------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "DWARFAttribute.h"
 #include "DWARFUnit.h"
 #include "DWARFDebugInfo.h"
 
 DWARFAttributes::DWARFAttributes() : m_infos() {}
 
-DWARFAttributes::~DWARFAttributes() {}
+DWARFAttributes::~DWARFAttributes() = default;
 
 uint32_t DWARFAttributes::FindAttributeIndex(dw_attr_t attr) const {
   collection::const_iterator end = m_infos.end();
   collection::const_iterator beg = m_infos.begin();
   collection::const_iterator pos;
   for (pos = beg; pos != end; ++pos) {
     if (pos->attr.get_attr() == attr)
       return std::distance(beg, pos);

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

 //===-- DWARFBaseDIE.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_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFBASEDIE_H
 #define LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFBASEDIE_H
 
 #include "lldb/Core/dwarf.h"
 #include "lldb/lldb-types.h"
 
 #include "llvm/Support/Error.h"
 
 class DIERef;
 class DWARFASTParser;
 class DWARFAttributes;
 class DWARFUnit;
 class DWARFDebugInfoEntry;
 class DWARFDeclContext;
 class SymbolFileDWARF;
 
 class DWARFBaseDIE {
 public:
-  DWARFBaseDIE() {}
+  DWARFBaseDIE() = default;
 
   DWARFBaseDIE(DWARFUnit *cu, DWARFDebugInfoEntry *die)
       : m_cu(cu), m_die(die) {}
 
   DWARFBaseDIE(const DWARFUnit *cu, DWARFDebugInfoEntry *die)
       : m_cu(const_cast<DWARFUnit *>(cu)), m_die(die) {}
 
   DWARFBaseDIE(DWARFUnit *cu, const DWARFDebugInfoEntry *die)

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

void Next() {
     }
   }
 
 public:
   /// An iterator starting at die d.
   explicit ElaboratingDIEIterator(DWARFDIE d) : m_worklist(1, d) {}
 
   /// End marker
-  ElaboratingDIEIterator() {}
+  ElaboratingDIEIterator() = default;
 
   const DWARFDIE &operator*() const { return m_worklist.back(); }
   ElaboratingDIEIterator &operator++() {
     Next();
     return *this;
   }
   ElaboratingDIEIterator operator++(int) {
     ElaboratingDIEIterator I = *this;

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

 //===-- DWARFDeclContext.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_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFDECLCONTEXT_H
 #define LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFDECLCONTEXT_H
 
 #include <string>
 #include <vector>
 #include "lldb/Utility/ConstString.h"
 #include "DWARFDefines.h"
 
 // DWARFDeclContext
 //
 // A class that represents a declaration context all the way down to a
 // DIE. This is useful when trying to find a DIE in one DWARF to a DIE
 // in another DWARF file.
 
 class DWARFDeclContext {
 public:
   struct Entry {
-    Entry() {}
+    Entry() = default;
     Entry(dw_tag_t t, const char *n) : tag(t), name(n) {}
 
     bool NameMatches(const Entry &rhs) const {
       if (name == rhs.name)
         return true;
       else if (name && rhs.name)
         return strcmp(name, rhs.name) == 0;
       return false;

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

 #include "lldb/lldb-defines.h"
 
 class DWARFUnit;
 
 class NameToDIE {
 public:
   NameToDIE() : m_map() {}
 
-  ~NameToDIE() {}
+  ~NameToDIE() = default;
 
   void Dump(lldb_private::Stream *s);
 
   void Insert(lldb_private::ConstString name, const DIERef &die_ref);
 
   void Append(const NameToDIE &other);
 
   void Finalize();

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

       UserID(0x7fffffff00000000), // Used by SymbolFileDWARFDebugMap to
                                   // when this class parses .o files to
                                   // contain the .o file index/ID
       m_debug_map_module_wp(), m_debug_map_symfile(nullptr),
       m_context(m_objfile_sp->GetModule()->GetSectionList(), dwo_section_list),
       m_fetched_external_modules(false),
       m_supports_DW_AT_APPLE_objc_complete_type(eLazyBoolCalculate) {}
 
-SymbolFileDWARF::~SymbolFileDWARF() {}
+SymbolFileDWARF::~SymbolFileDWARF() = default;
 
 static ConstString GetDWARFMachOSegmentName() {
   static ConstString g_dwarf_section_name("__DWARF");
   return g_dwarf_section_name;
 }
 
 UniqueDWARFASTTypeMap &SymbolFileDWARF::GetUniqueDWARFASTTypeMap() {
   SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile();

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

 
   UniqueDWARFASTTypeMap &GetUniqueDWARFASTTypeMap() {
     return m_unique_ast_type_map;
   }
 
   // OSOEntry
   class OSOEntry {
   public:
-    OSOEntry() {}
+    OSOEntry() = default;
 
     OSOEntry(uint32_t exe_sym_idx, lldb::addr_t oso_file_addr)
         : m_exe_sym_idx(exe_sym_idx), m_oso_file_addr(oso_file_addr) {}
 
     uint32_t GetExeSymbolIndex() const { return m_exe_sym_idx; }
 
     bool operator<(const OSOEntry &rhs) const {
       return m_exe_sym_idx < rhs.m_exe_sym_idx;

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

   return new SymbolFileDWARFDebugMap(std::move(objfile_sp));
 }
 
 SymbolFileDWARFDebugMap::SymbolFileDWARFDebugMap(ObjectFileSP objfile_sp)
     : SymbolFile(std::move(objfile_sp)), m_flags(), m_compile_unit_infos(),
       m_func_indexes(), m_glob_indexes(),
       m_supports_DW_AT_APPLE_objc_complete_type(eLazyBoolCalculate) {}
 
-SymbolFileDWARFDebugMap::~SymbolFileDWARFDebugMap() {}
+SymbolFileDWARFDebugMap::~SymbolFileDWARFDebugMap() = default;
 
 void SymbolFileDWARFDebugMap::InitializeObject() {}
 
 void SymbolFileDWARFDebugMap::InitOSO() {
   if (m_flags.test(kHaveInitializedOSOs))
     return;
 
   m_flags.set(kHaveInitializedOSOs);

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

UniqueDWARFASTType(lldb::TypeSP &type_sp, const DWARFDIE &die,
                      const lldb_private::Declaration &decl, int32_t byte_size)
       : m_type_sp(type_sp), m_die(die), m_declaration(decl),
         m_byte_size(byte_size) {}
 
   UniqueDWARFASTType(const UniqueDWARFASTType &rhs)
       : m_type_sp(rhs.m_type_sp), m_die(rhs.m_die),
         m_declaration(rhs.m_declaration), m_byte_size(rhs.m_byte_size) {}
 
-  ~UniqueDWARFASTType() {}
+  ~UniqueDWARFASTType() = default;
 
   UniqueDWARFASTType &operator=(const UniqueDWARFASTType &rhs) {
     if (this != &rhs) {
       m_type_sp = rhs.m_type_sp;
       m_die = rhs.m_die;
       m_declaration = rhs.m_declaration;
       m_byte_size = rhs.m_byte_size;
     }
     return *this;
   }
 
   lldb::TypeSP m_type_sp;
   DWARFDIE m_die;
   lldb_private::Declaration m_declaration;
   int32_t m_byte_size = -1;
 };
 
 class UniqueDWARFASTTypeList {
 public:
   UniqueDWARFASTTypeList() : m_collection() {}
 
-  ~UniqueDWARFASTTypeList() {}
+  ~UniqueDWARFASTTypeList() = default;
 
   uint32_t GetSize() { return (uint32_t)m_collection.size(); }
 
   void Append(const UniqueDWARFASTType &entry) {
     m_collection.push_back(entry);
   }
 
   bool Find(const DWARFDIE &die, const lldb_private::Declaration &decl,
             const int32_t byte_size, UniqueDWARFASTType &entry) const;
 
 protected:
   typedef std::vector<UniqueDWARFASTType> collection;
   collection m_collection;
 };
 
 class UniqueDWARFASTTypeMap {
 public:
   UniqueDWARFASTTypeMap() : m_collection() {}
 
-  ~UniqueDWARFASTTypeMap() {}
+  ~UniqueDWARFASTTypeMap() = default;
 
   void Insert(lldb_private::ConstString name,
               const UniqueDWARFASTType &entry) {
     m_collection[name.GetCString()].Append(entry);
   }
 
   bool Find(lldb_private::ConstString name, const DWARFDIE &die,
             const lldb_private::Declaration &decl, const int32_t byte_size,

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

 
 SymbolFile *SymbolFileNativePDB::CreateInstance(ObjectFileSP objfile_sp) {
   return new SymbolFileNativePDB(std::move(objfile_sp));
 }
 
 SymbolFileNativePDB::SymbolFileNativePDB(ObjectFileSP objfile_sp)
     : SymbolFile(std::move(objfile_sp)) {}
 
-SymbolFileNativePDB::~SymbolFileNativePDB() {}
+SymbolFileNativePDB::~SymbolFileNativePDB() = default;
 
 uint32_t SymbolFileNativePDB::CalculateAbilities() {
   uint32_t abilities = 0;
   if (!m_objfile_sp)
     return 0;
 
   if (!m_index) {
     // Lazily load and match the PDB file, but only do this once.

lldb/source/Plugins/SymbolFile/NativePDB/UdtRecordCompleter.h

 //===-- UdtRecordCompleter.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_SOURCE_PLUGINS_SYMBOLFILE_NATIVEPDB_UDTRECORDCOMPLETER_H
 #define LLDB_SOURCE_PLUGINS_SYMBOLFILE_NATIVEPDB_UDTRECORDCOMPLETER_H
 
 #include "Plugins/ExpressionParser/Clang/ClangASTImporter.h"
 #include "llvm/DebugInfo/CodeView/CVRecord.h"
 #include "llvm/DebugInfo/CodeView/TypeRecord.h"
 #include "llvm/DebugInfo/CodeView/TypeVisitorCallbacks.h"
 
 #include "PdbSymUid.h"
 
 namespace clang {
 class CXXBaseSpecifier;

 class PdbAstBuilder;
 class PdbIndex;
 
 class UdtRecordCompleter : public llvm::codeview::TypeVisitorCallbacks {
   using IndexedBase =
       std::pair<uint64_t, std::unique_ptr<clang::CXXBaseSpecifier>>;
 
   union UdtTagRecord {
-    UdtTagRecord() {}
+    UdtTagRecord() = default;
     llvm::codeview::UnionRecord ur;
     llvm::codeview::ClassRecord cr;
     llvm::codeview::EnumRecord er;
   } m_cvr;
 
   PdbTypeSymId m_id;
   CompilerType &m_derived_ct;
   clang::TagDecl &m_tag_decl;

lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp

   default:
     assert(false && "Unknown calling convention");
     return clang::CC_C;
   }
 }
 
 PDBASTParser::PDBASTParser(lldb_private::TypeSystemClang &ast) : m_ast(ast) {}
 
-PDBASTParser::~PDBASTParser() {}
+PDBASTParser::~PDBASTParser() = default;
 
 // DebugInfoASTParser interface
 
 lldb::TypeSP PDBASTParser::CreateLLDBTypeFromPDBType(const PDBSymbol &type) {
   Declaration decl;
   switch (type.getSymTag()) {
   case PDB_SymType::BaseClass: {
     auto symbol_file = m_ast.GetSymbolFile();

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

 lldb_private::SymbolFile *
 SymbolFilePDB::CreateInstance(ObjectFileSP objfile_sp) {
   return new SymbolFilePDB(std::move(objfile_sp));
 }
 
 SymbolFilePDB::SymbolFilePDB(lldb::ObjectFileSP objfile_sp)
     : SymbolFile(std::move(objfile_sp)), m_session_up(), m_global_scope_up() {}
 
-SymbolFilePDB::~SymbolFilePDB() {}
+SymbolFilePDB::~SymbolFilePDB() = default;
 
 uint32_t SymbolFilePDB::CalculateAbilities() {
   uint32_t abilities = 0;
   if (!m_objfile_sp)
     return 0;
 
   if (!m_session_up) {
     // Lazily load and match the PDB file, but only do this once.

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

 //===-- AppleGetItemInfoHandler.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_SOURCE_PLUGINS_SYSTEMRUNTIME_MACOSX_APPLEGETITEMINFOHANDLER_H
 #define LLDB_SOURCE_PLUGINS_SYSTEMRUNTIME_MACOSX_APPLEGETITEMINFOHANDLER_H
 
 #include <map>
 #include <mutex>
 #include <vector>
 
 #include "lldb/Expression/UtilityFunction.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/lldb-public.h"
 
 // This class will insert a UtilityFunction into the inferior process for
 // calling libBacktraceRecording's
 // __introspection_dispatch_queue_item_get_info()
 // function.  The function in the inferior will return a struct by value
public:
   ~AppleGetItemInfoHandler();
 
   struct GetItemInfoReturnInfo {
     lldb::addr_t item_buffer_ptr = LLDB_INVALID_ADDRESS; /* the address of the
                                      item buffer from libBacktraceRecording */
     lldb::addr_t item_buffer_size = 0; /* the size of the item buffer from
                                       libBacktraceRecording */
 
-    GetItemInfoReturnInfo() {}
+    GetItemInfoReturnInfo() = default;
   };
 
   /// Get the information about a work item by calling
   /// __introspection_dispatch_queue_item_get_info.  If there's a page of
   /// memory that needs to be freed, pass in the address and size and it will
   /// be freed before getting the list of queues.
   ///
   /// \param [in] thread

lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetItemInfoHandler.cpp

 ";
 
 AppleGetItemInfoHandler::AppleGetItemInfoHandler(Process *process)
     : m_process(process), m_get_item_info_impl_code(),
       m_get_item_info_function_mutex(),
       m_get_item_info_return_buffer_addr(LLDB_INVALID_ADDRESS),
       m_get_item_info_retbuffer_mutex() {}
 
-AppleGetItemInfoHandler::~AppleGetItemInfoHandler() {}
+AppleGetItemInfoHandler::~AppleGetItemInfoHandler() = default;
 
 void AppleGetItemInfoHandler::Detach() {
 
   if (m_process && m_process->IsAlive() &&
       m_get_item_info_return_buffer_addr != LLDB_INVALID_ADDRESS) {
     std::unique_lock<std::mutex> lock(m_get_item_info_retbuffer_mutex,
                                       std::defer_lock);
     (void)lock.try_lock(); // Even if we don't get the lock, deallocate the buffer

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

 //===-- AppleGetPendingItemsHandler.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_SOURCE_PLUGINS_SYSTEMRUNTIME_MACOSX_APPLEGETPENDINGITEMSHANDLER_H
 #define LLDB_SOURCE_PLUGINS_SYSTEMRUNTIME_MACOSX_APPLEGETPENDINGITEMSHANDLER_H
 
 #include <map>
 #include <mutex>
 #include <vector>
 
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/lldb-public.h"
 
 // This class will insert a UtilityFunction into the inferior process for
 // calling libBacktraceRecording's
 // __introspection_dispatch_queue_get_pending_items()
 // function.  The function in the inferior will return a struct by value
 // with these members:
public:
   struct GetPendingItemsReturnInfo {
     lldb::addr_t items_buffer_ptr =
         LLDB_INVALID_ADDRESS; /* the address of the pending items buffer
           from libBacktraceRecording */
     lldb::addr_t items_buffer_size = 0; /* the size of the pending items buffer
                                        from libBacktraceRecording */
     uint64_t count = 0; /* the number of pending items included in the buffer */
 
-    GetPendingItemsReturnInfo()
-
-    {}
+    GetPendingItemsReturnInfo() = default;
   };
 
   /// Get the list of pending items for a given queue via a call to
   /// __introspection_dispatch_queue_get_pending_items.  If there's a page of
   /// memory that needs to be freed, pass in the address and size and it will
   /// be freed before getting the list of queues.
   ///
   /// \param [in] thread

lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetPendingItemsHandler.cpp

 ";
 
 AppleGetPendingItemsHandler::AppleGetPendingItemsHandler(Process *process)
     : m_process(process), m_get_pending_items_impl_code(),
       m_get_pending_items_function_mutex(),
       m_get_pending_items_return_buffer_addr(LLDB_INVALID_ADDRESS),
       m_get_pending_items_retbuffer_mutex() {}
 
-AppleGetPendingItemsHandler::~AppleGetPendingItemsHandler() {}
+AppleGetPendingItemsHandler::~AppleGetPendingItemsHandler() = default;
 
 void AppleGetPendingItemsHandler::Detach() {
   if (m_process && m_process->IsAlive() &&
       m_get_pending_items_return_buffer_addr != LLDB_INVALID_ADDRESS) {
     std::unique_lock<std::mutex> lock(m_get_pending_items_retbuffer_mutex,
                                       std::defer_lock);
     (void)lock.try_lock(); // Even if we don't get the lock, deallocate the buffer
     m_process->DeallocateMemory(m_get_pending_items_return_buffer_addr);

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

 //===-- AppleGetQueuesHandler.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_SOURCE_PLUGINS_SYSTEMRUNTIME_MACOSX_APPLEGETQUEUESHANDLER_H
 #define LLDB_SOURCE_PLUGINS_SYSTEMRUNTIME_MACOSX_APPLEGETQUEUESHANDLER_H
 
 #include <map>
 #include <mutex>
 #include <vector>
 
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/lldb-public.h"
 
 // This class will insert a UtilityFunction into the inferior process for
 // calling libBacktraceRecording's introspection_get_dispatch_queues()
 // function.  The function in the inferior will return a struct by value
 // with these members:
 //
public:
   struct GetQueuesReturnInfo {
     lldb::addr_t queues_buffer_ptr =
         LLDB_INVALID_ADDRESS; /* the address of the queues buffer from
           libBacktraceRecording */
     lldb::addr_t queues_buffer_size = 0; /* the size of the queues buffer from
                                         libBacktraceRecording */
     uint64_t count = 0; /* the number of queues included in the queues buffer */
 
-    GetQueuesReturnInfo()
-
-    {}
+    GetQueuesReturnInfo() = default;
   };
 
   /// Get the list of queues that exist (with any active or pending items) via
   /// a call to introspection_get_dispatch_queues().  If there's a page of
   /// memory that needs to be freed, pass in the address and size and it will
   /// be freed before getting the list of queues.
   ///
   /// \param [in] thread

lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetQueuesHandler.cpp

 ";
 
 AppleGetQueuesHandler::AppleGetQueuesHandler(Process *process)
     : m_process(process), m_get_queues_impl_code_up(),
       m_get_queues_function_mutex(),
       m_get_queues_return_buffer_addr(LLDB_INVALID_ADDRESS),
       m_get_queues_retbuffer_mutex() {}
 
-AppleGetQueuesHandler::~AppleGetQueuesHandler() {}
+AppleGetQueuesHandler::~AppleGetQueuesHandler() = default;
 
 void AppleGetQueuesHandler::Detach() {
 
   if (m_process && m_process->IsAlive() &&
       m_get_queues_return_buffer_addr != LLDB_INVALID_ADDRESS) {
     std::unique_lock<std::mutex> lock(m_get_queues_retbuffer_mutex,
                                       std::defer_lock);
     (void)lock.try_lock(); // Even if we don't get the lock, deallocate the buffer

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

 //===-- AppleGetThreadItemInfoHandler.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_SOURCE_PLUGINS_SYSTEMRUNTIME_MACOSX_APPLEGETTHREADITEMINFOHANDLER_H
 #define LLDB_SOURCE_PLUGINS_SYSTEMRUNTIME_MACOSX_APPLEGETTHREADITEMINFOHANDLER_H
 
 #include <map>
 #include <mutex>
 #include <vector>
 
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/lldb-public.h"
 
 // This class will insert a UtilityFunction into the inferior process for
 // calling libBacktraceRecording's
 // __introspection_dispatch_thread_get_item_info()
 // function.  The function in the inferior will return a struct by value
 // with these members:
public:
   ~AppleGetThreadItemInfoHandler();
 
   struct GetThreadItemInfoReturnInfo {
     lldb::addr_t item_buffer_ptr = LLDB_INVALID_ADDRESS; /* the address of the
                                      item buffer from libBacktraceRecording */
     lldb::addr_t item_buffer_size = 0; /* the size of the item buffer from
                                       libBacktraceRecording */
 
-    GetThreadItemInfoReturnInfo() {}
+    GetThreadItemInfoReturnInfo() = default;
   };
 
   /// Get the information about a work item by calling
   /// __introspection_dispatch_thread_get_item_info.  If there's a page of
   /// memory that needs to be freed, pass in the address and size and it will
   /// be freed before getting the list of queues.
   ///
   /// \param [in] thread_id

lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetThreadItemInfoHandler.cpp

 ";
 
 AppleGetThreadItemInfoHandler::AppleGetThreadItemInfoHandler(Process *process)
     : m_process(process), m_get_thread_item_info_impl_code(),
       m_get_thread_item_info_function_mutex(),
       m_get_thread_item_info_return_buffer_addr(LLDB_INVALID_ADDRESS),
       m_get_thread_item_info_retbuffer_mutex() {}
 
-AppleGetThreadItemInfoHandler::~AppleGetThreadItemInfoHandler() {}
+AppleGetThreadItemInfoHandler::~AppleGetThreadItemInfoHandler() = default;
 
 void AppleGetThreadItemInfoHandler::Detach() {
 
   if (m_process && m_process->IsAlive() &&
       m_get_thread_item_info_return_buffer_addr != LLDB_INVALID_ADDRESS) {
     std::unique_lock<std::mutex> lock(m_get_thread_item_info_retbuffer_mutex,
                                       std::defer_lock);
     (void)lock.try_lock(); // Even if we don't get the lock, deallocate the buffer

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

 #include "lldb/Core/ModuleList.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/QueueItem.h"
 #include "lldb/Target/SystemRuntime.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/StructuredData.h"
 #include "lldb/Utility/UUID.h"
 

 
 private:
   struct libBacktraceRecording_info {
     uint16_t queue_info_version = 0;
     uint16_t queue_info_data_offset = 0;
     uint16_t item_info_version = 0;
     uint16_t item_info_data_offset = 0;
 
-    libBacktraceRecording_info() {}
+    libBacktraceRecording_info() = default;
   };
 
   // A structure which reflects the data recorded in the
   // libBacktraceRecording introspection_dispatch_item_info_s.
   struct ItemInfo {
     lldb::addr_t item_that_enqueued_this;
     lldb::addr_t function_or_block;
     uint64_t enqueuing_thread_id;

 
   struct LibdispatchVoucherOffsets {
     uint16_t vo_version = UINT16_MAX;
     uint16_t vo_activity_ids_count = UINT16_MAX;
     uint16_t vo_activity_ids_count_size = UINT16_MAX;
     uint16_t vo_activity_ids_array = UINT16_MAX;
     uint16_t vo_activity_ids_array_entry_size = UINT16_MAX;
 
-    LibdispatchVoucherOffsets()
-
-    {}
+    LibdispatchVoucherOffsets() = default;
 
     bool IsValid() { return vo_version != UINT16_MAX; }
   };
 
   struct LibdispatchTSDIndexes {
     uint16_t dti_version = UINT16_MAX;
     uint64_t dti_queue_index = UINT64_MAX;
     uint64_t dti_voucher_index = UINT64_MAX;
     uint64_t dti_qos_class_index = UINT64_MAX;
 
-    LibdispatchTSDIndexes() {}
+    LibdispatchTSDIndexes() = default;
 
     bool IsValid() { return dti_version != UINT16_MAX; }
   };
 
   struct LibpthreadOffsets {
     uint16_t plo_version = UINT16_MAX;
     uint16_t plo_pthread_tsd_base_offset = UINT16_MAX;
     uint16_t plo_pthread_tsd_base_address_offset = UINT16_MAX;
     uint16_t plo_pthread_tsd_entry_size = UINT16_MAX;
 
-    LibpthreadOffsets()
-
-    {}
+    LibpthreadOffsets() = default;
 
     bool IsValid() { return plo_version != UINT16_MAX; }
   };
 
   // The libBacktraceRecording function
   // __introspection_dispatch_queue_get_pending_items has
   // two forms.  It can either return a simple array of item_refs (void *) size
   // or it can return

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

 //===-- x86AssemblyInspectionEngine.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_SOURCE_PLUGINS_UNWINDASSEMBLY_X86_X86ASSEMBLYINSPECTIONENGINE_H
 #define LLDB_SOURCE_PLUGINS_UNWINDASSEMBLY_X86_X86ASSEMBLYINSPECTIONENGINE_H
 
 #include "llvm-c/Disassembler.h"
 
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/lldb-enumerations.h"
 #include "lldb/lldb-forward.h"
 #include "lldb/lldb-private.h"
 
 #include <map>
 #include <vector>
 
public:
 
   /// One of the two initialize methods that can be called on this object;
   /// they must be called before any of the assembly inspection methods
   /// are called.  This one takes a vector of register name and lldb
   /// register numbers.
   struct lldb_reg_info {
     const char *name = nullptr;
     uint32_t lldb_regnum = LLDB_INVALID_REGNUM;
-    lldb_reg_info() {}
+    lldb_reg_info() = default;
   };
   void Initialize(std::vector<lldb_reg_info> &reg_info);
 
   /// Create an UnwindPlan for a "non-call site" stack frame situation.
   /// This is usually when this function/method is currently executing, and may
   /// be at
   /// a location where exception-handling style unwind information (eh_frame,
   /// compact unwind info, arm unwind info)

lldb/source/Symbol/ArmUnwindInfo.cpp

 //===-- ArmUnwindInfo.cpp -------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include <vector>
 
 #include "Utility/ARM_DWARF_Registers.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Symbol/ArmUnwindInfo.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Symbol/UnwindPlan.h"
 #include "lldb/Utility/Endian.h"
 
 /*
while (m_arm_exidx_data.ValidOffset(offset)) {
     m_exidx_entries.emplace_back(file_addr, addr, data);
   }
 
   // Sort the entries in the exidx section. The entries should be sorted inside
   // the section but some old compiler isn't sorted them.
   llvm::sort(m_exidx_entries.begin(), m_exidx_entries.end());
 }
 
-ArmUnwindInfo::~ArmUnwindInfo() {}
+ArmUnwindInfo::~ArmUnwindInfo() = default;
 
 // Read a byte from the unwind instruction stream with the given offset. Custom
 // function is required because have to red in order of significance within
 // their containing word (most significant byte first) and in increasing word
 // address order.
 uint8_t ArmUnwindInfo::GetByteAtOffset(const uint32_t *data,
                                        uint16_t offset) const {
   uint32_t value = data[offset / 4];

lldb/source/Symbol/Block.cpp

 //===-- Block.cpp ---------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Symbol/Block.h"
 
 #include "lldb/Core/Module.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Utility/Log.h"
 
 #include <memory>
 
 using namespace lldb;
 using namespace lldb_private;
 
 Block::Block(lldb::user_id_t uid)
     : UserID(uid), m_parent_scope(nullptr), m_children(), m_ranges(),
       m_inlineInfoSP(), m_variable_list_sp(), m_parsed_block_info(false),
       m_parsed_block_variables(false), m_parsed_child_blocks(false) {}
 
-Block::~Block() {}
+Block::~Block() = default;
 
 void Block::GetDescription(Stream *s, Function *function,
                            lldb::DescriptionLevel level, Target *target) const {
   *s << "id = " << ((const UserID &)*this);
 
   size_t num_ranges = m_ranges.GetSize();
   if (num_ranges > 0) {
 

lldb/source/Symbol/CompactUnwindInfo.cpp

 CompactUnwindInfo::CompactUnwindInfo(ObjectFile &objfile, SectionSP &section_sp)
     : m_objfile(objfile), m_section_sp(section_sp),
       m_section_contents_if_encrypted(), m_mutex(), m_indexes(),
       m_indexes_computed(eLazyBoolCalculate), m_unwindinfo_data(),
       m_unwindinfo_data_computed(false), m_unwind_header() {}
 
 // destructor
 
-CompactUnwindInfo::~CompactUnwindInfo() {}
+CompactUnwindInfo::~CompactUnwindInfo() = default;
 
 bool CompactUnwindInfo::GetUnwindPlan(Target &target, Address addr,
                                       UnwindPlan &unwind_plan) {
   if (!IsValid(target.GetProcessSP())) {
     return false;
   }
   FunctionInfo function_info;
   if (GetCompactUnwindInfoForFunction(target, addr, function_info)) {

lldb/source/Symbol/FuncUnwinders.cpp

 //===-- FuncUnwinders.cpp -------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Symbol/FuncUnwinders.h"
 #include "lldb/Core/Address.h"
 #include "lldb/Core/AddressRange.h"
 #include "lldb/Symbol/ArmUnwindInfo.h"
 #include "lldb/Symbol/CallFrameInfo.h"
 #include "lldb/Symbol/CompactUnwindInfo.h"
 #include "lldb/Symbol/DWARFCallFrameInfo.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolFile.h"
: m_unwind_table(unwind_table), m_range(range), m_mutex(),
       m_tried_unwind_plan_arm_unwind(false),
       m_tried_unwind_plan_symbol_file(false), m_tried_unwind_fast(false),
       m_tried_unwind_arch_default(false),
       m_tried_unwind_arch_default_at_func_entry(false),
       m_first_non_prologue_insn() {}
 
 /// destructor
 
-FuncUnwinders::~FuncUnwinders() {}
+FuncUnwinders::~FuncUnwinders() = default;
 
 UnwindPlanSP FuncUnwinders::GetUnwindPlanAtCallSite(Target &target,
                                                     Thread &thread) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
   if (UnwindPlanSP plan_sp = GetObjectFileUnwindPlan(target))
     return plan_sp;
   if (UnwindPlanSP plan_sp = GetSymbolFileUnwindPlan(thread))

lldb/source/Symbol/Function.cpp

 //===-- Function.cpp ------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Symbol/Function.h"
 #include "lldb/Core/Disassembler.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/LineTable.h"

 // Basic function information is contained in the FunctionInfo class. It is
 // designed to contain the name, linkage name, and declaration location.
 FunctionInfo::FunctionInfo(const char *name, const Declaration *decl_ptr)
     : m_name(name), m_declaration(decl_ptr) {}
 
 FunctionInfo::FunctionInfo(ConstString name, const Declaration *decl_ptr)
     : m_name(name), m_declaration(decl_ptr) {}
 
-FunctionInfo::~FunctionInfo() {}
+FunctionInfo::~FunctionInfo() = default;
 
 void FunctionInfo::Dump(Stream *s, bool show_fullpaths) const {
   if (m_name)
     *s << ", name = \"" << m_name << "\"";
   m_declaration.Dump(s, show_fullpaths);
 }
 
 int FunctionInfo::Compare(const FunctionInfo &a, const FunctionInfo &b) {

 
 InlineFunctionInfo::InlineFunctionInfo(ConstString name,
                                        const Mangled &mangled,
                                        const Declaration *decl_ptr,
                                        const Declaration *call_decl_ptr)
     : FunctionInfo(name, decl_ptr), m_mangled(mangled),
       m_call_decl(call_decl_ptr) {}
 
-InlineFunctionInfo::~InlineFunctionInfo() {}
+InlineFunctionInfo::~InlineFunctionInfo() = default;
 
 void InlineFunctionInfo::Dump(Stream *s, bool show_fullpaths) const {
   FunctionInfo::Dump(s, show_fullpaths);
   if (m_mangled)
     m_mangled.Dump(s);
 }
 
 void InlineFunctionInfo::DumpStopContext(Stream *s) const {
Function::Function(CompileUnit *comp_unit, lldb::user_id_t func_uid,
                    const AddressRange &range)
     : UserID(func_uid), m_comp_unit(comp_unit), m_type_uid(type_uid),
       m_type(type), m_mangled(mangled), m_block(func_uid), m_range(range),
       m_frame_base(), m_flags(), m_prologue_byte_size(0) {
   m_block.SetParentScope(this);
   assert(comp_unit != nullptr);
 }
 
-Function::~Function() {}
+Function::~Function() = default;
 
 void Function::GetStartLineSourceInfo(FileSpec &source_file,
                                       uint32_t &line_no) {
   line_no = 0;
   source_file.Clear();
 
   if (m_comp_unit == nullptr)
     return;

lldb/source/Symbol/LineTable.cpp

 //===-- LineTable.cpp -----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Core/Address.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Utility/Stream.h"
 #include <algorithm>
 
 using namespace lldb;
LineTable::LineTable(CompileUnit *comp_unit,
   for (const auto &sequence : sequences) {
     LineSequenceImpl *seq = static_cast<LineSequenceImpl *>(sequence.get());
     m_entries.insert(m_entries.end(), seq->m_entries.begin(),
                      seq->m_entries.end());
   }
 }
 
 // Destructor
-LineTable::~LineTable() {}
+LineTable::~LineTable() = default;
 
 void LineTable::InsertLineEntry(lldb::addr_t file_addr, uint32_t line,
                                 uint16_t column, uint16_t file_idx,
                                 bool is_start_of_statement,
                                 bool is_start_of_basic_block,
                                 bool is_prologue_end, bool is_epilogue_begin,
                                 bool is_terminal_entry) {
   Entry entry(file_addr, line, column, file_idx, is_start_of_statement,
               is_start_of_basic_block, is_prologue_end, is_epilogue_begin,
               is_terminal_entry);
 
   LineTable::Entry::LessThanBinaryPredicate less_than_bp(this);
   entry_collection::iterator pos =
       llvm::upper_bound(m_entries, entry, less_than_bp);
 
   //  Stream s(stdout);
   //  s << "\n\nBefore:\n";
   //  Dump (&s, Address::DumpStyleFileAddress);
   m_entries.insert(pos, entry);
   //  s << "After:\n";
   //  Dump (&s, Address::DumpStyleFileAddress);
 }
 
-LineSequence::LineSequence() {}
+LineSequence::LineSequence() = default;
 
 void LineTable::LineSequenceImpl::Clear() { m_entries.clear(); }
 
 std::unique_ptr<LineSequence> LineTable::CreateLineSequenceContainer() {
   return std::make_unique<LineTable::LineSequenceImpl>();
 }
 
 void LineTable::AppendLineEntryToSequence(

lldb/source/Symbol/SymbolContext.cpp

 //===-- SymbolContext.cpp -------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Symbol/SymbolContext.h"
 
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/StringConvert.h"
 #include "lldb/Symbol/Block.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/ObjectFile.h"

 }
 
 SymbolContext::SymbolContext(SymbolContextScope *sc_scope)
     : target_sp(), module_sp(), comp_unit(nullptr), function(nullptr),
       block(nullptr), line_entry(), symbol(nullptr), variable(nullptr) {
   sc_scope->CalculateSymbolContext(this);
 }
 
-SymbolContext::~SymbolContext() {}
+SymbolContext::~SymbolContext() = default;
 
 void SymbolContext::Clear(bool clear_target) {
   if (clear_target)
     target_sp.reset();
   module_sp.reset();
   comp_unit = nullptr;
   function = nullptr;
   block = nullptr;

 //  SymbolContextSpecifier
 //
 
 SymbolContextSpecifier::SymbolContextSpecifier(const TargetSP &target_sp)
     : m_target_sp(target_sp), m_module_spec(), m_module_sp(), m_file_spec_up(),
       m_start_line(0), m_end_line(0), m_function_spec(), m_class_name(),
       m_address_range_up(), m_type(eNothingSpecified) {}
 
-SymbolContextSpecifier::~SymbolContextSpecifier() {}
+SymbolContextSpecifier::~SymbolContextSpecifier() = default;
 
 bool SymbolContextSpecifier::AddLineSpecification(uint32_t line_no,
                                                   SpecificationType type) {
   bool return_value = true;
   switch (type) {
   case eNothingSpecified:
     Clear();
     break;

 }
 
 //
 //  SymbolContextList
 //
 
 SymbolContextList::SymbolContextList() : m_symbol_contexts() {}
 
-SymbolContextList::~SymbolContextList() {}
+SymbolContextList::~SymbolContextList() = default;
 
 void SymbolContextList::Append(const SymbolContext &sc) {
   m_symbol_contexts.push_back(sc);
 }
 
 void SymbolContextList::Append(const SymbolContextList &sc_list) {
   collection::const_iterator pos, end = sc_list.m_symbol_contexts.end();
   for (pos = sc_list.m_symbol_contexts.begin(); pos != end; ++pos)

lldb/source/Symbol/Symtab.cpp

 //===-- Symtab.cpp --------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include <map>
 #include <set>
 
 #include "Plugins/Language/ObjC/ObjCLanguage.h"
 
 #include "lldb/Core/Module.h"
 #include "lldb/Core/RichManglingContext.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/Symtab.h"
Symtab::Symtab(ObjectFile *objfile)
   m_name_to_symbol_indices.emplace(std::make_pair(
       lldb::eFunctionNameTypeBase, UniqueCStringMap<uint32_t>()));
   m_name_to_symbol_indices.emplace(std::make_pair(
       lldb::eFunctionNameTypeMethod, UniqueCStringMap<uint32_t>()));
   m_name_to_symbol_indices.emplace(std::make_pair(
       lldb::eFunctionNameTypeSelector, UniqueCStringMap<uint32_t>()));
 }
 
-Symtab::~Symtab() {}
+Symtab::~Symtab() = default;
 
 void Symtab::Reserve(size_t count) {
   // Clients should grab the mutex from this symbol table and lock it manually
   // when calling this function to avoid performance issues.
   m_symbols.reserve(count);
 }
 
 Symbol *Symtab::Resize(size_t count) {

lldb/source/Symbol/TypeList.cpp

 //===-- TypeList.cpp ------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include <vector>
 
 #include "llvm/Support/FormattedStream.h"
 #include "llvm/Support/raw_ostream.h"
 
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Symbol/TypeList.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 TypeList::TypeList() : m_types() {}
 
 // Destructor
-TypeList::~TypeList() {}
+TypeList::~TypeList() = default;
 
 void TypeList::Insert(const TypeSP &type_sp) {
   // Just push each type on the back for now. We will worry about uniquing
   // later
   if (type_sp)
     m_types.push_back(type_sp);
 }
 

lldb/source/Symbol/TypeMap.cpp

 //===-- TypeMap.cpp -------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include <vector>
 
 #include "llvm/Support/FormattedStream.h"
 #include "llvm/Support/raw_ostream.h"
 
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Symbol/TypeMap.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 TypeMap::TypeMap() : m_types() {}
 
 // Destructor
-TypeMap::~TypeMap() {}
+TypeMap::~TypeMap() = default;
 
 void TypeMap::Insert(const TypeSP &type_sp) {
   // Just push each type on the back for now. We will worry about uniquing
   // later
   if (type_sp)
     m_types.insert(std::make_pair(type_sp->GetID(), type_sp));
 }
 

lldb/source/Symbol/TypeSystem.cpp

 //===-- TypeSystem.cpp ----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Symbol/TypeSystem.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Expression/UtilityFunction.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Target/Language.h"
 
 #include <set>
 
 using namespace lldb_private;
llvm::Optional<LanguageType> LanguageSet::GetSingularLanguage() {
   return {};
 }
 
 void LanguageSet::Insert(LanguageType language) { bitvector.set(language); }
 size_t LanguageSet::Size() const { return bitvector.count(); }
 bool LanguageSet::Empty() const { return bitvector.none(); }
 bool LanguageSet::operator[](unsigned i) const { return bitvector[i]; }
 
-TypeSystem::~TypeSystem() {}
+TypeSystem::~TypeSystem() = default;
 
 static lldb::TypeSystemSP CreateInstanceHelper(lldb::LanguageType language,
                                                Module *module, Target *target) {
   uint32_t i = 0;
   TypeSystemCreateInstance create_callback;
   while ((create_callback = PluginManager::GetTypeSystemCreateCallbackAtIndex(
               i++)) != nullptr) {
     lldb::TypeSystemSP type_system_sp =

 TypeSystem::CreateUtilityFunction(std::string text, std::string name) {
   return {};
 }
 
 #pragma mark TypeSystemMap
 
 TypeSystemMap::TypeSystemMap() : m_mutex(), m_map() {}
 
-TypeSystemMap::~TypeSystemMap() {}
+TypeSystemMap::~TypeSystemMap() = default;
 
 void TypeSystemMap::Clear() {
   collection map;
   {
     std::lock_guard<std::mutex> guard(m_mutex);
     map = m_map;
     m_clear_in_progress = true;
   }

lldb/source/Symbol/UnwindTable.cpp

 //===-- UnwindTable.cpp ---------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Symbol/UnwindTable.h"
 
 #include <cstdio>
 
 #include "lldb/Core/Module.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Symbol/ArmUnwindInfo.h"
 #include "lldb/Symbol/CallFrameInfo.h"
 #include "lldb/Symbol/CompactUnwindInfo.h"
if (sect) {
     SectionSP sect_extab = sl->FindSectionByType(eSectionTypeARMextab, true);
     if (sect_extab.get()) {
       m_arm_unwind_up =
           std::make_unique<ArmUnwindInfo>(*object_file, sect, sect_extab);
     }
   }
 }
 
-UnwindTable::~UnwindTable() {}
+UnwindTable::~UnwindTable() = default;
 
 llvm::Optional<AddressRange> UnwindTable::GetAddressRange(const Address &addr,
                                                           SymbolContext &sc) {
   AddressRange range;
 
   // First check the unwind info from the object file plugin
   if (m_object_file_unwind_up &&
       m_object_file_unwind_up->GetAddressRange(addr, range))

lldb/source/Symbol/Variable.cpp

 //===-- Variable.cpp ------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Symbol/Variable.h"
 
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectVariable.h"
 #include "lldb/Symbol/Block.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/CompilerDecl.h"
 #include "lldb/Symbol/CompilerDeclContext.h"
Variable::Variable(lldb::user_id_t uid, const char *name, const char *mangled,
                    bool static_member)
     : UserID(uid), m_name(name), m_mangled(ConstString(mangled)),
       m_symfile_type_sp(symfile_type_sp), m_scope(scope),
       m_owner_scope(context), m_scope_range(scope_range),
       m_declaration(decl_ptr), m_location(location), m_external(external),
       m_artificial(artificial), m_loc_is_const_data(location_is_constant_data),
       m_static_member(static_member) {}
 
-Variable::~Variable() {}
+Variable::~Variable() = default;
 
 lldb::LanguageType Variable::GetLanguage() const {
   lldb::LanguageType lang = m_mangled.GuessLanguage();
   if (lang != lldb::eLanguageTypeUnknown)
     return lang;
 
   if (auto *func = m_owner_scope->CalculateSymbolContextFunction()) {
     if ((lang = func->GetLanguage()) != lldb::eLanguageTypeUnknown)

lldb/source/Symbol/VariableList.cpp

 //===-- VariableList.cpp --------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Symbol/VariableList.h"
 
 #include "lldb/Symbol/Block.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Utility/RegularExpression.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 // VariableList constructor
 VariableList::VariableList() : m_variables() {}
 
 // Destructor
-VariableList::~VariableList() {}
+VariableList::~VariableList() = default;
 
 void VariableList::AddVariable(const VariableSP &var_sp) {
   m_variables.push_back(var_sp);
 }
 
 bool VariableList::AddVariableIfUnique(const lldb::VariableSP &var_sp) {
   if (FindVariableIndex(var_sp) == UINT32_MAX) {
     m_variables.push_back(var_sp);

lldb/source/Target/JITLoaderList.cpp

 //===-- JITLoaderList.cpp -------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Target/JITLoader.h"
 #include "lldb/Target/JITLoaderList.h"
 #include "lldb/lldb-private.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 JITLoaderList::JITLoaderList() : m_jit_loaders_vec(), m_jit_loaders_mutex() {}
 
-JITLoaderList::~JITLoaderList() {}
+JITLoaderList::~JITLoaderList() = default;
 
 void JITLoaderList::Append(const JITLoaderSP &jit_loader_sp) {
   std::lock_guard<std::recursive_mutex> guard(m_jit_loaders_mutex);
   m_jit_loaders_vec.push_back(jit_loader_sp);
 }
 
 void JITLoaderList::Remove(const JITLoaderSP &jit_loader_sp) {
   std::lock_guard<std::recursive_mutex> guard(m_jit_loaders_mutex);

lldb/source/Target/Language.cpp

 
 void Language::GetDefaultExceptionResolverDescription(bool catch_on,
                                                       bool throw_on,
                                                       Stream &s) {
   s.Printf("Exception breakpoint (catch: %s throw: %s)",
            catch_on ? "on" : "off", throw_on ? "on" : "off");
 }
 // Constructor
-Language::Language() {}
+Language::Language() = default;
 
 // Destructor
-Language::~Language() {}
+Language::~Language() = default;

lldb/source/Target/Memory.cpp

 //===-- Memory.cpp --------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Target/Memory.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/RangeMap.h"
 #include "lldb/Utility/State.h"
 
 #include <cinttypes>
 #include <memory>
 
 using namespace lldb;
 using namespace lldb_private;
 
 // MemoryCache constructor
 MemoryCache::MemoryCache(Process &process)
     : m_mutex(), m_L1_cache(), m_L2_cache(), m_invalid_ranges(),
       m_process(process),
       m_L2_cache_line_byte_size(process.GetMemoryCacheLineSize()) {}
 
 // Destructor
-MemoryCache::~MemoryCache() {}
+MemoryCache::~MemoryCache() = default;
 
 void MemoryCache::Clear(bool clear_invalid_ranges) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   m_L1_cache.clear();
   m_L2_cache.clear();
   if (clear_invalid_ranges)
     m_invalid_ranges.Clear();
   m_L2_cache_line_byte_size = m_process.GetMemoryCacheLineSize();

     : m_range(addr, byte_size), m_permissions(permissions),
       m_chunk_size(chunk_size)
 {
   // The entire address range is free to start with.
   m_free_blocks.Append(m_range);
   assert(byte_size > chunk_size);
 }
 
-AllocatedBlock::~AllocatedBlock() {}
+AllocatedBlock::~AllocatedBlock() = default;
 
 lldb::addr_t AllocatedBlock::ReserveBlock(uint32_t size) {
   // We must return something valid for zero bytes.
   if (size == 0)
     size = 1;
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
   
   const size_t free_count = m_free_blocks.GetSize();

   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
   LLDB_LOGV(log, "({0}) (addr = {1:x}) => {2}", this, addr, success);
   return success;
 }
 
 AllocatedMemoryCache::AllocatedMemoryCache(Process &process)
     : m_process(process), m_mutex(), m_memory_map() {}
 
-AllocatedMemoryCache::~AllocatedMemoryCache() {}
+AllocatedMemoryCache::~AllocatedMemoryCache() = default;
 
 void AllocatedMemoryCache::Clear() {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   if (m_process.IsAlive()) {
     PermissionsToBlockMap::iterator pos, end = m_memory_map.end();
     for (pos = m_memory_map.begin(); pos != end; ++pos)
       m_process.DoDeallocateMemory(pos->second->GetBaseAddress());
   }

lldb/source/Target/QueueItem.cpp

 //===-- QueueItem.cpp -----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Target/Queue.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/QueueItem.h"
 #include "lldb/Target/SystemRuntime.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 QueueItem::QueueItem(QueueSP queue_sp, ProcessSP process_sp,
                      lldb::addr_t item_ref, lldb_private::Address address)
     : m_queue_wp(), m_process_wp(), m_item_ref(item_ref), m_address(address),
       m_have_fetched_entire_item(false), m_kind(eQueueItemKindUnknown),
       m_item_that_enqueued_this_ref(LLDB_INVALID_ADDRESS),
       m_enqueueing_thread_id(LLDB_INVALID_THREAD_ID),
       m_enqueueing_queue_id(LLDB_INVALID_QUEUE_ID),
       m_target_queue_id(LLDB_INVALID_QUEUE_ID), m_stop_id(0), m_backtrace(),
       m_thread_label(), m_queue_label(), m_target_queue_label() {
   m_queue_wp = queue_sp;
   m_process_wp = process_sp;
 }
 
-QueueItem::~QueueItem() {}
+QueueItem::~QueueItem() = default;
 
 QueueItemKind QueueItem::GetKind() {
   FetchEntireItem();
   return m_kind;
 }
 
 void QueueItem::SetKind(QueueItemKind item_kind) { m_kind = item_kind; }
 

lldb/source/Target/StructuredDataPlugin.cpp

 //===-- StructuredDataPlugin.cpp ------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Target/StructuredDataPlugin.h"
 
 #include "lldb/Core/Debugger.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandObjectMultiword.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 namespace {
 class CommandStructuredData : public CommandObjectMultiword {
 public:
   CommandStructuredData(CommandInterpreter &interpreter)
       : CommandObjectMultiword(interpreter, "structured-data",
                                "Parent for per-plugin structured data commands",
                                "plugin structured-data <plugin>") {}
 
-  ~CommandStructuredData() override {}
+  ~CommandStructuredData() override = default;
 };
 }
 
 StructuredDataPlugin::StructuredDataPlugin(const ProcessWP &process_wp)
     : PluginInterface(), m_process_wp(process_wp) {}
 
-StructuredDataPlugin::~StructuredDataPlugin() {}
+StructuredDataPlugin::~StructuredDataPlugin() = default;
 
 bool StructuredDataPlugin::GetEnabled(ConstString type_name) const {
   // By default, plugins are always enabled.  Plugin authors should override
   // this if there is an enabled/disabled state for their plugin.
   return true;
 }
 
 ProcessSP StructuredDataPlugin::GetProcess() const {

lldb/source/Target/ThreadPlanBase.cpp

 //===-- ThreadPlanBase.cpp ------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Target/ThreadPlanBase.h"
 
 //
 #include "lldb/Breakpoint/Breakpoint.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Breakpoint/BreakpointSite.h"
 #include "lldb/Breakpoint/StoppointCallbackContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"

 #else
   ThreadPlanTracerSP new_tracer_sp(new ThreadPlanTracer(m_thread));
 #endif
   new_tracer_sp->EnableTracing(thread.GetTraceEnabledState());
   SetThreadPlanTracer(new_tracer_sp);
   SetIsMasterPlan(true);
 }
 
-ThreadPlanBase::~ThreadPlanBase() {}
+ThreadPlanBase::~ThreadPlanBase() = default;
 
 void ThreadPlanBase::GetDescription(Stream *s, lldb::DescriptionLevel level) {
   s->Printf("Base thread plan.");
 }
 
 bool ThreadPlanBase::ValidatePlan(Stream *error) { return true; }
 
 bool ThreadPlanBase::DoPlanExplainsStop(Event *event_ptr) {

lldb/source/Target/ThreadPlanCallUserExpression.cpp

 //===-- ThreadPlanCallUserExpression.cpp ----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Target/ThreadPlanCallUserExpression.h"
 
 
 #include "lldb/Breakpoint/Breakpoint.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Address.h"
 #include "lldb/Expression/DiagnosticManager.h"
 #include "lldb/Expression/DynamicCheckerFunctions.h"
 #include "lldb/Expression/UserExpression.h"
ThreadPlanCallUserExpression::ThreadPlanCallUserExpression(
     : ThreadPlanCallFunction(thread, function, CompilerType(), args, options),
       m_user_expression_sp(user_expression_sp) {
   // User expressions are generally "User generated" so we should set them up
   // to stop when done.
   SetIsMasterPlan(true);
   SetOkayToDiscard(false);
 }
 
-ThreadPlanCallUserExpression::~ThreadPlanCallUserExpression() {}
+ThreadPlanCallUserExpression::~ThreadPlanCallUserExpression() = default;
 
 void ThreadPlanCallUserExpression::GetDescription(
     Stream *s, lldb::DescriptionLevel level) {
   if (level == eDescriptionLevelBrief)
     s->Printf("User Expression thread plan");
   else
     ThreadPlanCallFunction::GetDescription(s, level);
 }

lldb/source/Target/ThreadPlanStepOverBreakpoint.cpp

 //===-- ThreadPlanStepOverBreakpoint.cpp ----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Target/ThreadPlanStepOverBreakpoint.h"
 
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Stream.h"
 
 using namespace lldb;
 using namespace lldb_private;

 
 {
   m_breakpoint_addr = thread.GetRegisterContext()->GetPC();
   m_breakpoint_site_id =
       thread.GetProcess()->GetBreakpointSiteList().FindIDByAddress(
           m_breakpoint_addr);
 }
 
-ThreadPlanStepOverBreakpoint::~ThreadPlanStepOverBreakpoint() {}
+ThreadPlanStepOverBreakpoint::~ThreadPlanStepOverBreakpoint() = default;
 
 void ThreadPlanStepOverBreakpoint::GetDescription(
     Stream *s, lldb::DescriptionLevel level) {
   s->Printf("Single stepping past breakpoint site %" PRIu64 " at 0x%" PRIx64,
             m_breakpoint_site_id, (uint64_t)m_breakpoint_addr);
 }
 
 bool ThreadPlanStepOverBreakpoint::ValidatePlan(Stream *error) { return true; }

lldb/source/Utility/ArchSpec.cpp

       return &entries[i];
   }
   return nullptr;
 }
 
 //===----------------------------------------------------------------------===//
 // Constructors and destructors.
 
-ArchSpec::ArchSpec() {}
+ArchSpec::ArchSpec() = default;
 
 ArchSpec::ArchSpec(const char *triple_cstr) {
   if (triple_cstr)
     SetTriple(triple_cstr);
 }
 
 ArchSpec::ArchSpec(llvm::StringRef triple_str) { SetTriple(triple_str); }
 

lldb/source/Utility/Args.cpp

     m_entries.emplace_back(entry.ref(), entry.quote);
     m_argv.push_back(m_entries.back().data());
   }
   m_argv.push_back(nullptr);
   return *this;
 }
 
 // Destructor
-Args::~Args() {}
+Args::~Args() = default;
 
 void Args::Dump(Stream &s, const char *label_name) const {
   if (!label_name)
     return;
 
   int i = 0;
   for (auto &entry : m_entries) {
     s.Indent();

lldb/source/Utility/DataBufferLLVM.cpp

 //===-- DataBufferLLVM.cpp ------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Utility/DataBufferLLVM.h"
 
 #include "llvm/Support/MemoryBuffer.h"
 
 #include <cassert>
 
 using namespace lldb_private;
 
 DataBufferLLVM::DataBufferLLVM(
     std::unique_ptr<llvm::WritableMemoryBuffer> MemBuffer)
     : Buffer(std::move(MemBuffer)) {
   assert(Buffer != nullptr &&
          "Cannot construct a DataBufferLLVM with a null buffer");
 }
 
-DataBufferLLVM::~DataBufferLLVM() {}
+DataBufferLLVM::~DataBufferLLVM() = default;
 
 uint8_t *DataBufferLLVM::GetBytes() {
   return reinterpret_cast<uint8_t *>(Buffer->getBufferStart());
 }
 
 const uint8_t *DataBufferLLVM::GetBytes() const {
   return reinterpret_cast<const uint8_t *>(Buffer->getBufferStart());
 }
 
 lldb::offset_t DataBufferLLVM::GetByteSize() const {
   return Buffer->getBufferSize();
 }

lldb/source/Utility/Event.cpp

     : EventData(), m_process_sp(), m_object_sp(), m_plugin_sp() {}
 
 EventDataStructuredData::EventDataStructuredData(
     const ProcessSP &process_sp, const StructuredData::ObjectSP &object_sp,
     const lldb::StructuredDataPluginSP &plugin_sp)
     : EventData(), m_process_sp(process_sp), m_object_sp(object_sp),
       m_plugin_sp(plugin_sp) {}
 
-EventDataStructuredData::~EventDataStructuredData() {}
+EventDataStructuredData::~EventDataStructuredData() = default;
 
 // EventDataStructuredData member functions
 
 ConstString EventDataStructuredData::GetFlavor() const {
   return EventDataStructuredData::GetFlavorString();
 }
 
 void EventDataStructuredData::Dump(Stream *s) const {

lldb/source/Utility/GDBRemote.cpp

 //===-- GDBRemote.cpp -----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Utility/GDBRemote.h"
 
 #include "lldb/Utility/Flags.h"
 #include "lldb/Utility/Stream.h"
 
 #include <cstdio>
 
 using namespace lldb;
 using namespace lldb_private::repro;
 using namespace lldb_private;
 using namespace llvm;
 
 StreamGDBRemote::StreamGDBRemote() : StreamString() {}
 
 StreamGDBRemote::StreamGDBRemote(uint32_t flags, uint32_t addr_size,
                                  ByteOrder byte_order)
     : StreamString(flags, addr_size, byte_order) {}
 
-StreamGDBRemote::~StreamGDBRemote() {}
+StreamGDBRemote::~StreamGDBRemote() = default;
 
 int StreamGDBRemote::PutEscapedBytes(const void *s, size_t src_len) {
   int bytes_written = 0;
   const uint8_t *src = static_cast<const uint8_t *>(s);
   bool binary_is_set = m_flags.Test(eBinary);
   m_flags.Clear(eBinary);
   while (src_len) {
     uint8_t byte = *src;

lldb/source/Utility/Stream.cpp

 //===-- Stream.cpp --------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Utility/Stream.h"
 
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/VASPrintf.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/LEB128.h"
 
 #include <string>
Stream::Stream(uint32_t flags, uint32_t addr_size, ByteOrder byte_order,
     : m_flags(flags), m_addr_size(addr_size), m_byte_order(byte_order),
       m_indent_level(0), m_forwarder(*this, colors) {}
 
 Stream::Stream(bool colors)
     : m_flags(0), m_byte_order(endian::InlHostByteOrder()),
       m_forwarder(*this, colors) {}
 
 // Destructor
-Stream::~Stream() {}
+Stream::~Stream() = default;
 
 ByteOrder Stream::SetByteOrder(ByteOrder byte_order) {
   ByteOrder old_byte_order = m_byte_order;
   m_byte_order = byte_order;
   return old_byte_order;
 }
 
 // Put an offset "uval" out to the stream using the printf format in "format".

lldb/source/Utility/StreamString.cpp

 //===-- StreamString.cpp --------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Utility/StreamString.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 StreamString::StreamString() : Stream(0, 4, eByteOrderBig) {}
 
 StreamString::StreamString(uint32_t flags, uint32_t addr_size,
                            ByteOrder byte_order)
     : Stream(flags, addr_size, byte_order), m_packet() {}
 
-StreamString::~StreamString() {}
+StreamString::~StreamString() = default;
 
 void StreamString::Flush() {
   // Nothing to do when flushing a buffer based stream...
 }
 
 size_t StreamString::WriteImpl(const void *s, size_t length) {
   m_packet.append(static_cast<const char *>(s), length);
   return length;

lldb/source/Utility/StringExtractor.cpp

 //===-- StringExtractor.cpp -----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Utility/StringExtractor.h"
 #include "llvm/ADT/StringExtras.h"
 
 #include <tuple>
 
 #include <cctype>
 #include <cstdlib>
 #include <cstring>
 

 
 StringExtractor::StringExtractor(const char *packet_cstr)
     : m_packet(), m_index(0) {
   if (packet_cstr)
     m_packet.assign(packet_cstr);
 }
 
 // Destructor
-StringExtractor::~StringExtractor() {}
+StringExtractor::~StringExtractor() = default;
 
 char StringExtractor::GetChar(char fail_value) {
   if (m_index < m_packet.size()) {
     char ch = m_packet[m_index];
     ++m_index;
     return ch;
   }
   m_index = UINT64_MAX;

lldb/source/Utility/StringList.cpp

 //===-- StringList.cpp ----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Utility/StringList.h"
 
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StreamString.h"
 #include "llvm/ADT/ArrayRef.h"
 
 #include <algorithm>
 #include <cstdint>

 
 StringList::StringList(const char **strv, int strc) : m_strings() {
   for (int i = 0; i < strc; ++i) {
     if (strv[i])
       m_strings.push_back(strv[i]);
   }
 }
 
-StringList::~StringList() {}
+StringList::~StringList() = default;
 
 void StringList::AppendString(const char *str) {
   if (str)
     m_strings.push_back(str);
 }
 
 void StringList::AppendString(const std::string &s) { m_strings.push_back(s); }
 

lldb/source/Utility/TildeExpressionResolver.cpp

 //===-- TildeExpressionResolver.cpp ---------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Utility/TildeExpressionResolver.h"
 
 #include <cassert>
 #include <system_error>
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 
 #if !defined(_WIN32)
 #include <pwd.h>
 #endif
 
 using namespace lldb_private;
 using namespace llvm;
 
 namespace fs = llvm::sys::fs;
 namespace path = llvm::sys::path;
 
-TildeExpressionResolver::~TildeExpressionResolver() {}
+TildeExpressionResolver::~TildeExpressionResolver() = default;
 
 bool StandardTildeExpressionResolver::ResolveExact(
     StringRef Expr, SmallVectorImpl<char> &Output) {
   // We expect the tilde expression to be ONLY the expression itself, and
   // contain no separators.
   assert(!llvm::any_of(Expr, [](char c) { return path::is_separator(c); }));
   assert(Expr.empty() || Expr[0] == '~');