[lldb] Convert the default constructor’s member initializers into default member initializers

[JDevlieghere]

Summary

Converts a default constructor’s member initializers into the new default member initializers in C++11. Other member initializers that match the default member initializer are removed.

This was automatically generated with modernize-use-default-member-init and our .clang-tidy file was updated accordingly.

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

This is a mass-refactoring patch and the resulting commit should be added to .git-blame-ignore-revs.

[JDevlieghere]

FWIW this is more of an RFC and as always there's some manual fixing up to be done and formatting to be fixed. I wanted to put this up for review before sinking time in that.

[teemperor]

+1. I'm anyway doing the same whenever I have to touching constructors, so we might as well pull out the big hammer.

I'm also glad you volunteer to resolve all the downstream conflicts :)

lldb/include/lldb/Breakpoint/BreakpointOptions.h

46

If we anyway touch this, could we also delete these default member initializers?

[jingham]

Thanks for taking this on. The in-class initialization is so much less boiler-plate and easier to read!

[shafik]

Thank you for doing this! This will be a big improvement.

I am not done going through this change but I think it will require a bit more careful look though to make sure we are getting the maximum benefit from this refactor.

lldb/include/lldb/Utility/VMRange.h

29

= default

lldb/source/API/SBBroadcaster.cpp

19

We don't need m_opaque_sp() this is a std::shared_ptr the default constructor will do the right thing.

24

We don't need m_opaque_ptr(nullptr)

lldb/source/API/SBCommandReturnObject.cpp

24

We can remove m_ptr(new CommandReturnObject(false)) and use =default

43

CommandReturnObject *m_ptr = new CommandReturnObject(false)

Note, this is ok w/ the other constructors b/c class.base.init/p10 tell us

If a given non-static data member has both a default member initializer and a mem-initializer, the initialization specified by the mem-initializer is performed, and the non- static data member's default member initializer is ignored.

[aprantl]

Impressive. I spot-checked a few instances and this generally looks great. Let's hope the test suite agrees!

[aprantl]

lldb/include/lldb/Host/FileSystem.h

35

why is m_collector not caught? Because it's also explicitly initialized below?

36

but then — why isn't m_home_directory() removed?

[JDevlieghere]

Fix compilation issues

[teemperor]

This doesn't compile for me (on Linux):

In file included from /home/teemperor/work/ci/llvm-project/lldb/unittests/Platform/PlatformAppleSimulatorTest.cpp:11:
In file included from /home/teemperor/work/ci/llvm-project/lldb/source/Plugins/Platform/MacOSX/PlatformAppleSimulator.h:15:
/home/teemperor/work/ci/llvm-project/lldb/source/Plugins/Platform/MacOSX/objcxx/PlatformiOSSimulatorCoreSimulatorSupport.h:96:14: error: use of undeclared identifier 'nil'
  id m_dev = nil;
             ^
/home/teemperor/work/ci/llvm-project/lldb/source/Plugins/Platform/MacOSX/objcxx/PlatformiOSSimulatorCoreSimulatorSupport.h:132:14: error: use of undeclared identifier 'nil'
  id m_dev = nil;
             ^
/home/teemperor/work/ci/llvm-project/lldb/source/Plugins/Platform/MacOSX/objcxx/PlatformiOSSimulatorCoreSimulatorSupport.h:172:14: error: use of undeclared identifier 'nil'
  id m_dev = nil;
             ^

The nil is some Obj-C thing but the headers are includes from a C++ file. I don't think we should add Obj-C includes to the header as we really need to keep the Objective-C++ code in LLDB as small as possible, so maybe change this to nullptr?

Beside that I couldn't find anything that would block this patch. There are a bunch of additional NFC cleanups possible but that seems out of scope, so LGTM modulo nil -> nullptr.

[JDevlieghere]

• Rebase
• Replace nil with nullptr

lldb/.clang-tidy

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

lldb/include/lldb/API/SBBlock.h

private:
 
   void SetPtr(lldb_private::Block *lldb_object_ptr);
 
   SBBlock(lldb_private::Block *lldb_object_ptr);
 
   void AppendVariables(bool can_create, bool get_parent_variables,
                        lldb_private::VariableList *var_list);
 
-  lldb_private::Block *m_opaque_ptr;
+  lldb_private::Block *m_opaque_ptr = nullptr;
 };
 
 } // namespace lldb
 
 #endif // LLDB_API_SBBLOCK_H

lldb/include/lldb/API/SBBroadcaster.h

protected:
   SBBroadcaster(lldb_private::Broadcaster *broadcaster, bool owns);
 
   lldb_private::Broadcaster *get() const;
 
   void reset(lldb_private::Broadcaster *broadcaster, bool owns);
 
 private:
   lldb::BroadcasterSP m_opaque_sp;
-  lldb_private::Broadcaster *m_opaque_ptr;
+  lldb_private::Broadcaster *m_opaque_ptr = nullptr;
 };
 
 } // namespace lldb
 
 #endif // LLDB_API_SBBROADCASTER_H

lldb/include/lldb/API/SBCommunication.h

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

lldb/include/lldb/API/SBCompileUnit.h

private:
   const lldb_private::CompileUnit *operator->() const;
 
   const lldb_private::CompileUnit &operator*() const;
 
   lldb_private::CompileUnit *get();
 
   void reset(lldb_private::CompileUnit *lldb_object_ptr);
 
-  lldb_private::CompileUnit *m_opaque_ptr;
+  lldb_private::CompileUnit *m_opaque_ptr = nullptr;
 };
 
 } // namespace lldb
 
 #endif // LLDB_API_SBCOMPILEUNIT_H

lldb/include/lldb/API/SBEvent.h

protected:
   void reset(lldb::EventSP &event_sp);
 
   void reset(lldb_private::Event *event);
 
   lldb_private::Event *get() const;
 
 private:
   mutable lldb::EventSP m_event_sp;
-  mutable lldb_private::Event *m_opaque_ptr;
+  mutable lldb_private::Event *m_opaque_ptr = nullptr;
 };
 
 } // namespace lldb
 
 #endif // LLDB_API_SBEVENT_H

lldb/include/lldb/API/SBFunction.h

 
 private:
   friend class SBAddress;
   friend class SBFrame;
   friend class SBSymbolContext;
 
   SBFunction(lldb_private::Function *lldb_object_ptr);
 
-  lldb_private::Function *m_opaque_ptr;
+  lldb_private::Function *m_opaque_ptr = nullptr;
 };
 
 } // namespace lldb
 
 #endif // LLDB_API_SBFUNCTION_H

lldb/include/lldb/API/SBListener.h

 private:
   lldb_private::Listener *operator->() const;
 
   lldb_private::Listener *get() const;
 
   void reset(lldb::ListenerSP listener_sp);
 
   lldb::ListenerSP m_opaque_sp;
-  lldb_private::Listener *m_unused_ptr;
+  lldb_private::Listener *m_unused_ptr = nullptr;
 };
 
 } // namespace lldb
 
 #endif // LLDB_API_SBLISTENER_H

lldb/include/lldb/API/SBStream.h

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

lldb/include/lldb/API/SBSymbol.h

private:
   friend class SBFrame;
   friend class SBModule;
   friend class SBSymbolContext;
 
   SBSymbol(lldb_private::Symbol *lldb_object_ptr);
 
   void SetSymbol(lldb_private::Symbol *lldb_object_ptr);
 
-  lldb_private::Symbol *m_opaque_ptr;
+  lldb_private::Symbol *m_opaque_ptr = nullptr;
 };
 
 } // namespace lldb
 
 #endif // LLDB_API_SBSYMBOL_H

lldb/include/lldb/Breakpoint/BreakpointOptions.h

enum OptionKind {
     eIgnoreCount  = 1 << 3,
     eThreadSpec   = 1 << 4,
     eCondition    = 1 << 5,
     eAutoContinue = 1 << 6,
     eAllOptions   = (eCallback | eEnabled | eOneShot | eIgnoreCount | eThreadSpec
                      | eCondition | eAutoContinue)
   };
   struct CommandData {
-    CommandData()
-        : user_source(), script_source(),
-          interpreter(lldb::eScriptLanguageNone), stop_on_error(true) {}
+    CommandData() : user_source(), script_source() {}
 
     CommandData(const StringList &user_source, lldb::ScriptLanguage interp)
         : user_source(user_source), script_source(), interpreter(interp),
           stop_on_error(true) {}
 
     virtual ~CommandData() = default;
 
     static const char *GetSerializationKey() { return "BKPTCMDData"; }
 
     StructuredData::ObjectSP SerializeToStructuredData();
 
     static std::unique_ptr<CommandData>
     CreateFromStructuredData(const StructuredData::Dictionary &options_dict,
                              Status &error);
 
     StringList user_source;
     std::string script_source;
-    enum lldb::ScriptLanguage
-        interpreter; // eScriptLanguageNone means command interpreter.
-    bool stop_on_error;
+    enum lldb::ScriptLanguage interpreter =
+        lldb::eScriptLanguageNone; // eScriptLanguageNone means command
+                                   // interpreter.
+    bool stop_on_error = true;
 
   private:
     enum class OptionNames : uint32_t {
       UserSource = 0,
       Interpreter,
       StopOnError,
       LastOptionName
     };

lldb/include/lldb/Breakpoint/Stoppoint.h

public:
 
   virtual void SetEnabled(bool enable) = 0;
 
   lldb::break_id_t GetID() const;
 
   void SetID(lldb::break_id_t bid);
 
 protected:
-  lldb::break_id_t m_bid;
+  lldb::break_id_t m_bid = LLDB_INVALID_BREAK_ID;
 
 private:
   // For Stoppoint only
   Stoppoint(const Stoppoint &) = delete;
   const Stoppoint &operator=(const Stoppoint &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_BREAKPOINT_STOPPOINT_H

lldb/include/lldb/Breakpoint/StoppointCallbackContext.h

public:
 
   /// Clear the object's state.
   ///
   /// Sets the event, process and thread to NULL, and the frame index to an
   /// invalid value.
   void Clear();
 
   // Member variables
-  Event *event; // This is the event, the callback can modify this to indicate
-                // the meaning of the breakpoint hit
+  Event *event = nullptr; // This is the event, the callback can modify this to
+                          // indicate the meaning of the breakpoint hit
   ExecutionContextRef
       exe_ctx_ref;     // This tells us where we have stopped, what thread.
-  bool is_synchronous; // Is the callback being executed synchronously with the
-                       // breakpoint,
-                       // or asynchronously as the event is retrieved?
+  bool is_synchronous =
+      false; // Is the callback being executed synchronously with the
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_BREAKPOINT_STOPPOINTCALLBACKCONTEXT_H

lldb/include/lldb/Breakpoint/WatchpointList.h

protected:
   wp_collection::iterator GetIDIterator(lldb::watch_id_t watchID);
 
   wp_collection::const_iterator
   GetIDConstIterator(lldb::watch_id_t watchID) const;
 
   wp_collection m_watchpoints;
   mutable std::recursive_mutex m_mutex;
 
-  lldb::watch_id_t m_next_wp_id;
+  lldb::watch_id_t m_next_wp_id = 0;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_BREAKPOINT_WATCHPOINTLIST_H

lldb/include/lldb/Breakpoint/WatchpointOptions.h

public:
   /// This is the default empty callback.
   /// \return
   ///     The thread id for which the watchpoint hit will stop,
   ///     LLDB_INVALID_THREAD_ID for all threads.
   static bool NullCallback(void *baton, StoppointCallbackContext *context,
                            lldb::user_id_t watch_id);
 
   struct CommandData {
-    CommandData() : user_source(), script_source(), stop_on_error(true) {}
+    CommandData() : user_source(), script_source() {}
 
     ~CommandData() = default;
 
     StringList user_source;
     std::string script_source;
-    bool stop_on_error;
+    bool stop_on_error = true;
   };
 
   class CommandBaton : public TypedBaton<CommandData> {
   public:
     CommandBaton(std::unique_ptr<CommandData> Data)
         : TypedBaton(std::move(Data)) {}
 
     void GetDescription(llvm::raw_ostream &s, lldb::DescriptionLevel level,
                         unsigned indentation) const override;
   };
 
 protected:
   // Classes that inherit from WatchpointOptions can see and modify these
 
 private:
   // For WatchpointOptions only
   WatchpointHitCallback m_callback;  // This is the callback function pointer
   lldb::BatonSP m_callback_baton_sp; // This is the client data for the callback
-  bool m_callback_is_synchronous;
+  bool m_callback_is_synchronous = false;
   std::unique_ptr<ThreadSpec>
       m_thread_spec_up; // Thread for which this watchpoint will take
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_BREAKPOINT_WATCHPOINTOPTIONS_H

lldb/include/lldb/Core/Address.h

enum DumpStyle {
     /// dereferenced address using DumpStyleResolvedDescription
     DumpStyleResolvedPointerDescription
   };
 
   /// Default constructor.
   ///
   /// Initialize with a invalid section (NULL) and an invalid offset
   /// (LLDB_INVALID_ADDRESS).
-  Address() : m_section_wp(), m_offset(LLDB_INVALID_ADDRESS) {}
+  Address() : m_section_wp() {}
 
   /// Copy constructor
   ///
   /// Makes a copy of the another Address object \a rhs.
   ///
   /// \param[in] rhs
   ///     A const Address object reference to copy.
   Address(const Address &rhs)
///     A const Address object reference to \a this.
   // contains a valid weak reference to a section. Returns false if the section
   // weak pointer has no reference to a section, or if the section is still
   // valid
   bool SectionWasDeleted() const;
 
 protected:
   // Member variables.
   lldb::SectionWP m_section_wp; ///< The section for the address, can be NULL.
-  lldb::addr_t m_offset; ///< Offset into section if \a m_section_wp is valid...
+  lldb::addr_t m_offset = LLDB_INVALID_ADDRESS; ///< Offset into section if \a
+                                                ///< m_section_wp is valid...
 
   // Returns true if the m_section_wp once had a reference to a valid section
   // shared pointer, but no longer does. This can happen if we have an address
   // from a module that gets unloaded and deleted. This function should only be
   // called if GetSection() returns an empty shared pointer and you want to
   // know if this address used to have a valid section.
   bool SectionWasDeletedPrivate() const;
 };

lldb/include/lldb/Core/AddressRange.h

public:
   ///
   /// \param[in] byte_size
   ///     The new size in bytes of this address range.
   void SetByteSize(lldb::addr_t byte_size) { m_byte_size = byte_size; }
 
 protected:
   // Member variables
   Address m_base_addr;      ///< The section offset base address of this range.
-  lldb::addr_t m_byte_size; ///< The size in bytes of this address range.
+  lldb::addr_t m_byte_size = 0; ///< The size in bytes of this address range.
 };
 
 // bool operator== (const AddressRange& lhs, const AddressRange& rhs);
 
 } // namespace lldb_private
 
 #endif // LLDB_CORE_ADDRESSRANGE_H

lldb/include/lldb/Core/Declaration.h

 ///        lldb object.
 ///
 /// The declarations include the file specification, line number, and the
 /// column info and can help track where functions, blocks, inlined functions,
 /// types, variables, any many other debug core objects were declared.
 class Declaration {
 public:
   /// Default constructor.
-  Declaration() : m_file(), m_line(0), m_column(LLDB_INVALID_COLUMN_NUMBER) {}
+  Declaration() : m_file() {}
 
   /// Construct with file specification, and optional line and column.
   ///
   /// \param[in] file_spec
   ///     The file specification that describes where this was
   ///     declared.
   ///
   /// \param[in] line
public:
   void SetColumn(uint16_t column) { m_column = column; }
 
 protected:
   /// The file specification that points to the source file where the
   /// declaration occurred.
   FileSpec m_file;
   /// Non-zero values indicates a valid line number, zero indicates no line
   /// number information is available.
-  uint32_t m_line;
+  uint32_t m_line = 0;
   /// Non-zero values indicates a valid column number, zero indicates no column
   /// information is available.
-  uint16_t m_column;
+  uint16_t m_column = LLDB_INVALID_COLUMN_NUMBER;
 };
 
 bool operator==(const Declaration &lhs, const Declaration &rhs);
 
 } // namespace lldb_private
 
 #endif // LLDB_SYMBOL_DECLARATION_H

lldb/include/lldb/Core/Disassembler.h

virtual bool FlavorValidForArchSpec(const lldb_private::ArchSpec &arch,
                                       const char *flavor) = 0;
 
 protected:
   // SourceLine and SourceLinesToDisplay structures are only used in the mixed
   // source and assembly display methods internal to this class.
 
   struct SourceLine {
     FileSpec file;
-    uint32_t line;
-    uint32_t column;
+    uint32_t line = LLDB_INVALID_LINE_NUMBER;
+    uint32_t column = 0;
 
-    SourceLine() : file(), line(LLDB_INVALID_LINE_NUMBER), column(0) {}
+    SourceLine() : file() {}
 
     bool operator==(const SourceLine &rhs) const {
       return file == rhs.file && line == rhs.line && rhs.column == column;
     }
 
     bool operator!=(const SourceLine &rhs) const {
       return file != rhs.file || line != rhs.line || column != rhs.column;
     }
 
     bool IsValid() const { return line != LLDB_INVALID_LINE_NUMBER; }
   };
 
   struct SourceLinesToDisplay {
     std::vector<SourceLine> lines;
 
     // index of the "current" source line, if we want to highlight that when
     // displaying the source lines.  (as opposed to the surrounding source
     // lines provided to give context)
-    size_t current_source_line;
+    size_t current_source_line = -1;
 
     // Whether to print a blank line at the end of the source lines.
-    bool print_source_context_end_eol;
+    bool print_source_context_end_eol = true;
 
-    SourceLinesToDisplay()
-        : lines(), current_source_line(-1), print_source_context_end_eol(true) {
-    }
+    SourceLinesToDisplay() : lines() {}
   };
 
   // Get the function's declaration line number, hopefully a line number
   // earlier than the opening curly brace at the start of the function body.
   static SourceLine GetFunctionDeclLineEntry(const SymbolContext &sc);
 
   // Add the provided SourceLine to the map of filenames-to-source-lines-seen.
   static void AddLineToSourceLineTables(

lldb/include/lldb/Core/EmulateInstruction.h

enum InfoType {
     eInfoTypeAddress,
     eInfoTypeISAAndImmediate,
     eInfoTypeISAAndImmediateSigned,
     eInfoTypeISA,
     eInfoTypeNoArgs
   } InfoType;
 
   struct Context {
-    ContextType type;
-    enum InfoType info_type;
+    ContextType type = eContextInvalid;
+    enum InfoType info_type = eInfoTypeNoArgs;
     union {
       struct RegisterPlusOffset {
         RegisterInfo reg;      // base register
         int64_t signed_offset; // signed offset added to base register
       } RegisterPlusOffset;
 
       struct RegisterPlusIndirectOffset {
         RegisterInfo base_reg;   // base register number
union {
       struct ISAAndImmediateSigned {
         uint32_t isa;
         int32_t signed_data32; // signed immediate data
       } ISAAndImmediateSigned;
 
       uint32_t isa;
     } info;
 
-    Context() : type(eContextInvalid), info_type(eInfoTypeNoArgs) {}
+    Context() {}
 
     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/FileLineResolver.h

 /// \class FileLineResolver FileLineResolver.h "lldb/Core/FileLineResolver.h"
 /// This class finds address for source file and line.  Optionally, it will
 /// look for inlined instances of the file and line specification.
 
 class FileLineResolver : public Searcher {
 public:
   FileLineResolver()
       : m_file_spec(),
-        m_line_number(UINT32_MAX), // Set this to zero for all lines in a file
-        m_sc_list(), m_inlines(true) {}
+        // Set this to zero for all lines in a file
+        m_sc_list() {}
 
   FileLineResolver(const FileSpec &resolver, uint32_t line_no,
                    bool check_inlines);
 
   ~FileLineResolver() override;
 
   Searcher::CallbackReturn SearchCallback(SearchFilter &filter,
                                           SymbolContext &context,
                                           Address *addr) override;
 
   lldb::SearchDepth GetDepth() override;
 
   void GetDescription(Stream *s) override;
 
   const SymbolContextList &GetFileLineMatches() { return m_sc_list; }
 
   void Clear();
 
   void Reset(const FileSpec &file_spec, uint32_t line, bool check_inlines);
 
 protected:
   FileSpec m_file_spec;   // This is the file spec we are looking for.
-  uint32_t m_line_number; // This is the line number that we are looking for.
+  uint32_t m_line_number =
+      UINT32_MAX; // This is the line number that we are looking for.
   SymbolContextList m_sc_list;
-  bool m_inlines; // This determines whether the resolver looks for inlined
-                  // functions or not.
+  bool m_inlines = true; // This determines whether the resolver looks for
+                         // inlined functions or not.
 
 private:
   FileLineResolver(const FileLineResolver &) = delete;
   const FileLineResolver &operator=(const FileLineResolver &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_CORE_FILELINERESOLVER_H

lldb/include/lldb/Core/FormatEntity.h

struct Definition {
       constexpr Definition(const char *name, const FormatEntity::Entry::Type t)
           : name(name), type(t) {}
 
       constexpr Definition(const char *name, const char *string)
           : name(name), string(string), type(Entry::Type::EscapeCode) {}
 
       constexpr Definition(const char *name, const FormatEntity::Entry::Type t,
                            const uint64_t data)
-          : name(name), string(nullptr), type(t), data(data) {}
+          : name(name), type(t), data(data) {}
 
       constexpr Definition(const char *name, const FormatEntity::Entry::Type t,
                            const uint64_t num_children,
                            const Definition *children,
                            const bool keep_separator = false)
           : name(name), type(t), num_children(num_children), children(children),
             keep_separator(keep_separator) {}
     };
 
     template <size_t N>
     static constexpr Definition
     DefinitionWithChildren(const char *name, const FormatEntity::Entry::Type t,
                            const Definition (&children)[N],
                            bool keep_separator = false) {
       return Definition(name, t, N, children, keep_separator);
     }
 
     Entry(Type t = Type::Invalid, const char *s = nullptr,
           const char *f = nullptr)
-        : string(s ? s : ""), printf_format(f ? f : ""), children(), type(t),
-          fmt(lldb::eFormatDefault), number(0), deref(false) {}
+        : string(s ? s : ""), printf_format(f ? f : ""), children(), type(t) {}
 
     Entry(llvm::StringRef s);
     Entry(char ch);
 
     void AppendChar(char ch);
 
     void AppendText(const llvm::StringRef &s);
 
bool operator==(const Entry &rhs) const {
         return false;
       return true;
     }
 
     std::string string;
     std::string printf_format;
     std::vector<Entry> children;
     Type type;
-    lldb::Format fmt;
-    lldb::addr_t number;
-    bool deref;
+    lldb::Format fmt = lldb::eFormatDefault;
+    lldb::addr_t number = 0;
+    bool deref = false;
   };
 
   static bool Format(const Entry &entry, Stream &s, const SymbolContext *sc,
                      const ExecutionContext *exe_ctx, const Address *addr,
                      ValueObject *valobj, bool function_changed,
                      bool initial_function);
 
   static bool FormatStringRef(const llvm::StringRef &format, Stream &s,

lldb/include/lldb/Core/LoadedModuleInfoList.h

protected:
     bool m_has[e_num];
     std::string m_name;
     lldb::addr_t m_link_map;
     lldb::addr_t m_base;
     bool m_base_is_offset;
     lldb::addr_t m_dynamic;
   };
 
-  LoadedModuleInfoList() : m_list(), m_link_map(LLDB_INVALID_ADDRESS) {}
+  LoadedModuleInfoList() : m_list() {}
 
   void add(const LoadedModuleInfo &mod) { m_list.push_back(mod); }
 
   void clear() { m_list.clear(); }
 
   std::vector<LoadedModuleInfo> m_list;
-  lldb::addr_t m_link_map;
+  lldb::addr_t m_link_map = LLDB_INVALID_ADDRESS;
 };
 } // namespace lldb_private
 
 #endif // LLDB_CORE_LOADEDMODULEINFOLIST_H

lldb/include/lldb/Core/MappedHash.h

public:
   static const uint32_t HASH_MAGIC = 0x48415348u;
   static const uint32_t HASH_CIGAM = 0x48534148u;
 
   template <typename T> struct Header {
     typedef T HeaderData;
 
     uint32_t
         magic; // HASH_MAGIC or HASH_CIGAM magic value to allow endian detection
-    uint16_t version;         // Version number
-    uint16_t hash_function;   // The hash function enumeration that was used
-    uint32_t bucket_count;    // The number of buckets in this hash table
-    uint32_t hashes_count;    // The total number of unique hash values and hash
-                              // data offsets in this table
+    uint16_t version = 1; // Version number
+    uint16_t hash_function =
+        eHashFunctionDJB;      // The hash function enumeration that was used
+    uint32_t bucket_count = 0; // The number of buckets in this hash table
+    uint32_t hashes_count = 0; // The total number of unique hash values and
+                               // hash data offsets in this table
     uint32_t header_data_len; // The size in bytes of the "header_data" template
                               // member below
     HeaderData header_data;   //
 
-    Header()
-        : magic(HASH_MAGIC), version(1), hash_function(eHashFunctionDJB),
-          bucket_count(0), hashes_count(0), header_data_len(sizeof(T)),
-          header_data() {}
+    Header() : magic(HASH_MAGIC), header_data_len(sizeof(T)), header_data() {}
 
     virtual ~Header() = default;
 
     size_t GetByteSize() const {
       return sizeof(magic) + sizeof(version) + sizeof(hash_function) +
              sizeof(bucket_count) + sizeof(hashes_count) +
              sizeof(header_data_len) + header_data_len;
     }

lldb/include/lldb/Core/Module.h

public:
   /// member variable tells us what kinds of names we are looking for and can
   /// help us prune out unwanted results.
   ///
   /// Function lookups are done in Module.cpp, ModuleList.cpp and in
   /// BreakpointResolverName.cpp and they all now use this class to do lookups
   /// correctly.
   class LookupInfo {
   public:
-    LookupInfo()
-        : m_name(), m_lookup_name(), m_language(lldb::eLanguageTypeUnknown),
-          m_name_type_mask(lldb::eFunctionNameTypeNone),
-          m_match_name_after_lookup(false) {}
+    LookupInfo() : m_name(), m_lookup_name() {}
 
     LookupInfo(ConstString name, lldb::FunctionNameType name_type_mask,
                lldb::LanguageType language);
 
     ConstString GetName() const { return m_name; }
 
     void SetName(ConstString name) { m_name = name; }
 
public:
   protected:
     /// What the user originally typed
     ConstString m_name;
 
     /// The actual name will lookup when calling in the object or symbol file
     ConstString m_lookup_name;
 
     /// Limit matches to only be for this language
-    lldb::LanguageType m_language;
+    lldb::LanguageType m_language = lldb::eLanguageTypeUnknown;
 
     /// One or more bits from lldb::FunctionNameType that indicate what kind of
     /// names we are looking for
-    lldb::FunctionNameType m_name_type_mask;
+    lldb::FunctionNameType m_name_type_mask = lldb::eFunctionNameTypeNone;
 
     ///< If \b true, then demangled names that match will need to contain
     ///< "m_name" in order to be considered a match
-    bool m_match_name_after_lookup;
+    bool m_match_name_after_lookup = false;
   };
 
 protected:
   // Member Variables
   mutable std::recursive_mutex m_mutex; ///< A mutex to keep this object happy
                                         ///in multi-threaded environments.
 
   /// The modification time for this module when it was created.
FileSpec m_remote_install_file; ///< If set when debugging on remote
                                   ///platforms, this module will be installed at
                                   ///this location
   FileSpec m_symfile_spec;   ///< If this path is valid, then this is the file
                              ///that _will_ be used as the symbol file for this
                              ///module
   ConstString m_object_name; ///< The name an object within this module that is
                              ///selected, or empty of the module is represented
                              ///by \a m_file.
-  uint64_t m_object_offset;
+  uint64_t m_object_offset = 0;
   llvm::sys::TimePoint<> m_object_mod_time;
 
   /// DataBuffer containing the module image, if it was provided at
   /// construction time. Otherwise the data will be retrieved by mapping
   /// one of the FileSpec members above.
   lldb::DataBufferSP m_data_sp;
 
   lldb::ObjectFileSP m_objfile_sp; ///< A shared pointer to the object file

lldb/include/lldb/Core/ModuleList.h

collection::iterator RemoveImpl(collection::iterator pos,
                                   bool use_notifier = true);
 
   void ClearImpl(bool use_notifier = true);
 
   // Member variables.
   collection m_modules; ///< The collection of modules.
   mutable std::recursive_mutex m_modules_mutex;
 
-  Notifier *m_notifier;
+  Notifier *m_notifier = nullptr;
 
 public:
   typedef LockingAdaptedIterable<collection, lldb::ModuleSP, vector_adapter,
                                  std::recursive_mutex>
       ModuleIterable;
   ModuleIterable Modules() const {
     return ModuleIterable(m_modules, GetMutex());
   }

lldb/include/lldb/Core/ModuleSpec.h

 #include <vector>
 
 namespace lldb_private {
 
 class ModuleSpec {
 public:
   ModuleSpec()
       : m_file(), m_platform_file(), m_symbol_file(), m_arch(), m_uuid(),
-        m_object_name(), m_object_offset(0), m_object_size(0),
-        m_source_mappings() {}
+        m_object_name(), m_source_mappings() {}
 
   /// If the \c data argument is passed, its contents will be used
   /// as the module contents instead of trying to read them from
   /// \c file_spec .
   ModuleSpec(const FileSpec &file_spec, const UUID &uuid = UUID(),
              lldb::DataBufferSP data = lldb::DataBufferSP())
       : m_file(file_spec), m_platform_file(), m_symbol_file(), m_arch(),
         m_uuid(uuid), m_object_name(), m_object_offset(0), m_source_mappings(),

 
 protected:
   FileSpec m_file;
   FileSpec m_platform_file;
   FileSpec m_symbol_file;
   ArchSpec m_arch;
   UUID m_uuid;
   ConstString m_object_name;
-  uint64_t m_object_offset;
-  uint64_t m_object_size;
+  uint64_t m_object_offset = 0;
+  uint64_t m_object_size = 0;
   llvm::sys::TimePoint<> m_object_mod_time;
   mutable PathMappingList m_source_mappings;
   lldb::DataBufferSP m_data = {};
 };
 
 class ModuleSpecList {
 public:
   ModuleSpecList() : m_specs(), m_mutex() {}

lldb/include/lldb/Core/Opcode.h

enum Type {
     eType8,
     eType16,
     eType16_2, // a 32-bit Thumb instruction, made up of two words
     eType32,
     eType64,
     eTypeBytes
   };
 
-  Opcode() : m_byte_order(lldb::eByteOrderInvalid), m_type(eTypeInvalid) {}
+  Opcode() {}
 
   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) {
protected:
 
   bool GetEndianSwap() const {
     return (m_byte_order == lldb::eByteOrderBig &&
             endian::InlHostByteOrder() == lldb::eByteOrderLittle) ||
            (m_byte_order == lldb::eByteOrderLittle &&
             endian::InlHostByteOrder() == lldb::eByteOrderBig);
   }
 
-  lldb::ByteOrder m_byte_order;
+  lldb::ByteOrder m_byte_order = lldb::eByteOrderInvalid;
 
-  Opcode::Type m_type;
+  Opcode::Type m_type = eTypeInvalid;
   union {
     uint8_t inst8;
     uint16_t inst16;
     uint32_t inst32;
     uint64_t inst64;
     struct {
       uint8_t bytes[16]; // This must be big enough to handle any opcode for any
                          // supported target.
       uint8_t length;
     } inst;
   } m_data;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_CORE_OPCODE_H

lldb/include/lldb/Core/RichManglingContext.h

 #include "llvm/Demangle/Demangle.h"
 
 namespace lldb_private {
 
 /// Uniform wrapper for access to rich mangling information from different
 /// providers. See Mangled::DemangleWithRichManglingInfo()
 class RichManglingContext {
 public:
-  RichManglingContext() : m_provider(None), m_ipd_buf_size(2048) {
+  RichManglingContext() {
     m_ipd_buf = static_cast<char *>(std::malloc(m_ipd_buf_size));
     m_ipd_buf[0] = '\0';
   }
 
   ~RichManglingContext();
 
   /// Use the ItaniumPartialDemangler to obtain rich mangling information from
   /// the given mangled name.
llvm::StringRef GetBufferRef() const {
     assert(m_provider != None && "Initialize a provider first");
     return m_buffer;
   }
 
 private:
   enum InfoProvider { None, ItaniumPartialDemangler, PluginCxxLanguage };
 
   /// Selects the rich mangling info provider.
-  InfoProvider m_provider;
+  InfoProvider m_provider = None;
 
   /// Reference to the buffer used for results of ParseXy() operations.
   llvm::StringRef m_buffer;
 
   /// Members for ItaniumPartialDemangler
   llvm::ItaniumPartialDemangler m_ipd;
   /// Note: m_ipd_buf is a raw pointer due to being resized by realloc via
   /// ItaniumPartialDemangler. It should be managed with malloc/free, not
   /// new/delete.
   char *m_ipd_buf;
-  size_t m_ipd_buf_size;
+  size_t m_ipd_buf_size = 2048;
 
   /// Members for PluginCxxLanguage
   /// Cannot forward declare inner class CPlusPlusLanguage::MethodName. The
   /// respective header is in Plugins and including it from here causes cyclic
   /// dependency. Instead keep a llvm::Any and cast it on-access in the cpp.
   llvm::Any m_cxx_method_parser;
 
   /// Clean up memory when using PluginCxxLanguage

lldb/include/lldb/Core/Value.h

public:
 
   bool GetData(DataExtractor &data);
 
   void Clear();
 
 protected:
   Scalar m_value;
   CompilerType m_compiler_type;
-  void *m_context;
-  ValueType m_value_type;
-  ContextType m_context_type;
+  void *m_context = nullptr;
+  ValueType m_value_type = ValueType::Scalar;
+  ContextType m_context_type = ContextType::Invalid;
   DataBufferHeap m_data_buffer;
 };
 
 class ValueList {
 public:
   ValueList() : m_values() {}
 
   ValueList(const ValueList &rhs);

lldb/include/lldb/Core/ValueObject.h

public:
     }
 
   private:
     bool SyncWithProcessState(bool accept_invalid_exe_ctx);
 
     ProcessModID m_mod_id; // This is the stop id when this ValueObject was last
                            // evaluated.
     ExecutionContextRef m_exe_ctx_ref;
-    bool m_needs_update;
+    bool m_needs_update = true;
   };
 
   virtual ~ValueObject();
 
   const EvaluationPoint &GetUpdatePoint() const { return m_update_point; }
 
   EvaluationPoint &GetUpdatePoint() { return m_update_point; }
 
public:
 
   virtual void SetLanguageFlags(uint64_t flags) { m_language_flags = flags; }
 
 protected:
   typedef ClusterManager<ValueObject> ValueObjectManager;
 
   class ChildrenManager {
   public:
-    ChildrenManager() : m_mutex(), m_children(), m_children_count(0) {}
+    ChildrenManager() : m_mutex(), m_children() {}
 
     bool HasChildAtIndex(size_t idx) {
       std::lock_guard<std::recursive_mutex> guard(m_mutex);
       return (m_children.find(idx) != m_children.end());
     }
 
     ValueObject *GetChildAtIndex(size_t idx) {
       std::lock_guard<std::recursive_mutex> guard(m_mutex);
public:
     }
 
   private:
     typedef std::map<size_t, ValueObject *> ChildrenMap;
     typedef ChildrenMap::iterator ChildrenIterator;
     typedef ChildrenMap::value_type ChildrenPair;
     std::recursive_mutex m_mutex;
     ChildrenMap m_children;
-    size_t m_children_count;
+    size_t m_children_count = 0;
   };
 
   // Classes that inherit from ValueObject can see and modify these
 
   /// The parent value object, or nullptr if this has no parent.
   ValueObject *m_parent = nullptr;
   /// The root of the hierarchy for this ValueObject (or nullptr if never
   /// calculated).

lldb/include/lldb/DataFormatters/DumpValueObjectOptions.h

PointerDepth operator--() const {
         return PointerDepth{m_mode, m_count - 1};
       return PointerDepth{m_mode, m_count};
     }
 
     bool CanAllowExpansion() const;
   };
 
   struct PointerAsArraySettings {
-    size_t m_element_count;
-    size_t m_base_element;
-    size_t m_stride;
+    size_t m_element_count = 0;
+    size_t m_base_element = 0;
+    size_t m_stride = 0;
 
-    PointerAsArraySettings()
-        : m_element_count(0), m_base_element(0), m_stride() {}
+    PointerAsArraySettings() {}
 
     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; }
   };

lldb/include/lldb/DataFormatters/FormatClasses.h

private:
   lldb::DynamicValueType m_dynamic_value_type;
   std::pair<FormattersMatchVector, bool> m_formatters_match_vector;
   ConstString m_type_for_cache;
   CandidateLanguagesVector m_candidate_languages;
 };
 
 class TypeNameSpecifierImpl {
 public:
-  TypeNameSpecifierImpl() : m_is_regex(false), m_type() {}
+  TypeNameSpecifierImpl() : m_type() {}
 
   TypeNameSpecifierImpl(llvm::StringRef name, bool is_regex)
       : m_is_regex(is_regex), m_type() {
     m_type.m_type_name = std::string(name);
   }
 
   // if constructing with a given type, is_regex cannot be true since we are
   // giving an exact type to match
CompilerType GetCompilerType() {
     if (m_type.m_compiler_type.IsValid())
       return m_type.m_compiler_type;
     return CompilerType();
   }
 
   bool IsRegex() { return m_is_regex; }
 
 private:
-  bool m_is_regex;
+  bool m_is_regex = false;
   // TODO: Replace this with TypeAndOrName.
   struct TypeOrName {
     std::string m_type_name;
     CompilerType m_compiler_type;
   };
   TypeOrName m_type;
 
   TypeNameSpecifierImpl(const TypeNameSpecifierImpl &) = delete;
   const TypeNameSpecifierImpl &
   operator=(const TypeNameSpecifierImpl &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_DATAFORMATTERS_FORMATCLASSES_H

lldb/include/lldb/DataFormatters/TypeFormat.h

 
 #include "lldb/Core/ValueObject.h"
 
 namespace lldb_private {
 class TypeFormatImpl {
 public:
   class Flags {
   public:
-    Flags() : m_flags(lldb::eTypeOptionCascade) {}
+    Flags() {}
 
     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;
Flags &SetNonCacheable(bool value = true) {
       return *this;
     }
 
     uint32_t GetValue() { return m_flags; }
 
     void SetValue(uint32_t value) { m_flags = value; }
 
   private:
-    uint32_t m_flags;
+    uint32_t m_flags = lldb::eTypeOptionCascade;
   };
 
   TypeFormatImpl(const Flags &flags = Flags());
 
   typedef std::shared_ptr<TypeFormatImpl> SharedPointer;
 
   virtual ~TypeFormatImpl();
 
public:
   // ValueObject to stay around for as long as it is required for us to
   // generate its value
   virtual bool FormatObject(ValueObject *valobj, std::string &dest) const = 0;
 
   virtual std::string GetDescription() = 0;
 
 protected:
   Flags m_flags;
-  uint32_t m_my_revision;
+  uint32_t m_my_revision = 0;
 
 private:
   TypeFormatImpl(const TypeFormatImpl &) = delete;
   const TypeFormatImpl &operator=(const TypeFormatImpl &) = delete;
 };
 
 class TypeFormatImpl_Format : public TypeFormatImpl {
 public:

lldb/include/lldb/DataFormatters/TypeSummary.h

public:
 
   lldb::TypeSummaryCapping GetCapping() const;
 
   TypeSummaryOptions &SetLanguage(lldb::LanguageType);
 
   TypeSummaryOptions &SetCapping(lldb::TypeSummaryCapping);
 
 private:
-  lldb::LanguageType m_lang;
-  lldb::TypeSummaryCapping m_capping;
+  lldb::LanguageType m_lang = lldb::eLanguageTypeUnknown;
+  lldb::TypeSummaryCapping m_capping = lldb::eTypeSummaryCapped;
 };
 
 class TypeSummaryImpl {
 public:
   enum class Kind { eSummaryString, eScript, eCallback, eInternal };
 
   virtual ~TypeSummaryImpl() = default;
 
   Kind GetKind() const { return m_kind; }
 
   class Flags {
   public:
-    Flags() : m_flags(lldb::eTypeOptionCascade) {}
+    Flags() {}
 
     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;
Flags &SetNonCacheable(bool value = true) {
       return *this;
     }
 
     uint32_t GetValue() { return m_flags; }
 
     void SetValue(uint32_t value) { m_flags = value; }
 
   private:
-    uint32_t m_flags;
+    uint32_t m_flags = lldb::eTypeOptionCascade;
   };
 
   bool Cascades() const { return m_flags.GetCascades(); }
 
   bool SkipsPointers() const { return m_flags.GetSkipPointers(); }
 
   bool SkipsReferences() const { return m_flags.GetSkipReferences(); }
 

lldb/include/lldb/DataFormatters/TypeSynthetic.h

private:
   const SyntheticValueProviderFrontEnd &
   operator=(const SyntheticValueProviderFrontEnd &) = delete;
 };
 
 class SyntheticChildren {
 public:
   class Flags {
   public:
-    Flags() : m_flags(lldb::eTypeOptionCascade) {}
+    Flags() {}
 
     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;
Flags &SetFrontEndWantsDereference(bool value = true) {
       return *this;
     }
 
     uint32_t GetValue() { return m_flags; }
 
     void SetValue(uint32_t value) { m_flags = value; }
 
   private:
-    uint32_t m_flags;
+    uint32_t m_flags = lldb::eTypeOptionCascade;
   };
 
   SyntheticChildren(const Flags &flags) : m_flags(flags) {}
 
   virtual ~SyntheticChildren() = default;
 
   bool Cascades() const { return m_flags.GetCascades(); }
 

lldb/include/lldb/Expression/DWARFExpression.h

private:
   lldb::ModuleWP m_module_wp;
 
   /// A data extractor capable of reading opcode bytes
   DataExtractor m_data;
 
   /// The DWARF compile unit this expression belongs to. It is used to evaluate
   /// values indexing into the .debug_addr section (e.g. DW_OP_GNU_addr_index,
   /// DW_OP_GNU_const_index)
-  const DWARFUnit *m_dwarf_cu;
+  const DWARFUnit *m_dwarf_cu = nullptr;
 
   /// One of the defines that starts with LLDB_REGKIND_
-  lldb::RegisterKind m_reg_kind;
+  lldb::RegisterKind m_reg_kind = lldb::eRegisterKindDWARF;
 
   struct LoclistAddresses {
     lldb::addr_t cu_file_addr;
     lldb::addr_t func_file_addr;
   };
   llvm::Optional<LoclistAddresses> m_loclist_addresses;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_EXPRESSION_DWARFEXPRESSION_H

lldb/include/lldb/Expression/Materializer.h

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() : m_alignment(1), m_size(0), m_offset(0) {}
+    Entity() {}
 
     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::addr_t frame_bottom, Status &err) = 0;
     virtual void DumpToLog(IRMemoryMap &map, lldb::addr_t process_address,
                            Log *log) = 0;
     virtual void Wipe(IRMemoryMap &map, lldb::addr_t process_address) = 0;
 
     uint32_t GetAlignment() { return m_alignment; }
 
     uint32_t GetSize() { return m_size; }
 
     uint32_t GetOffset() { return m_offset; }
 
     void SetOffset(uint32_t offset) { m_offset = offset; }
 
   protected:
-    uint32_t m_alignment;
-    uint32_t m_size;
-    uint32_t m_offset;
+    uint32_t m_alignment = 1;
+    uint32_t m_size = 0;
+    uint32_t m_offset = 0;
   };
 
 private:
   uint32_t AddStructMember(Entity &entity);
 
   typedef std::unique_ptr<Entity> EntityUP;
   typedef std::vector<EntityUP> EntityVector;
 

lldb/include/lldb/Host/File.h

public:
   };
 
   static mode_t ConvertOpenOptionsForPOSIXOpen(OpenOptions open_options);
   static llvm::Expected<OpenOptions> GetOptionsFromMode(llvm::StringRef mode);
   static bool DescriptorIsValid(int descriptor) { return descriptor >= 0; };
   static llvm::Expected<const char *>
   GetStreamOpenModeFromOptions(OpenOptions options);
 
-  File()
-      : IOObject(eFDTypeFile), m_is_interactive(eLazyBoolCalculate),
-        m_is_real_terminal(eLazyBoolCalculate),
-        m_supports_colors(eLazyBoolCalculate){};
+  File() : IOObject(eFDTypeFile){};
 
   /// Read bytes from a file from the current file position into buf.
   ///
   /// NOTE: This function is NOT thread safe. Use the read function
   /// that takes an "off_t &offset" to ensure correct operation in multi-
   /// threaded environments.
   ///
   /// \param[in,out] num_bytes
public:
 
   bool operator!() const { return !IsValid(); };
 
   static char ID;
   virtual bool isA(const void *classID) const { return classID == &ID; }
   static bool classof(const File *file) { return file->isA(&ID); }
 
 protected:
-  LazyBool m_is_interactive;
-  LazyBool m_is_real_terminal;
-  LazyBool m_supports_colors;
+  LazyBool m_is_interactive = eLazyBoolCalculate;
+  LazyBool m_is_real_terminal = eLazyBoolCalculate;
+  LazyBool m_supports_colors = eLazyBoolCalculate;
 
   void CalculateInteractiveAndTerminal();
 
 private:
   File(const File &) = delete;
   const File &operator=(const File &) = delete;
 };
 
 class NativeFile : public File {
 public:
-  NativeFile()
-      : m_descriptor(kInvalidDescriptor), m_own_descriptor(false),
-        m_stream(kInvalidStream), m_options(), m_own_stream(false) {}
+  NativeFile() : m_descriptor(kInvalidDescriptor), m_stream(kInvalidStream) {}
 
   NativeFile(FILE *fh, bool transfer_ownership)
       : m_descriptor(kInvalidDescriptor), m_own_descriptor(false), m_stream(fh),
         m_options(), m_own_stream(transfer_ownership) {}
 
   NativeFile(int fd, OpenOptions options, bool transfer_ownership)
       : m_descriptor(fd), m_own_descriptor(transfer_ownership),
         m_stream(kInvalidStream), m_options(options), m_own_stream(false) {}

 protected:
   bool DescriptorIsValid() const {
     return File::DescriptorIsValid(m_descriptor);
   }
   bool StreamIsValid() const { return m_stream != kInvalidStream; }
 
   // Member variables
   int m_descriptor;
-  bool m_own_descriptor;
+  bool m_own_descriptor = false;
   FILE *m_stream;
-  OpenOptions m_options;
-  bool m_own_stream;
+  OpenOptions m_options{};
+  bool m_own_stream = false;
   std::mutex offset_access_mutex;
 
 private:
   NativeFile(const NativeFile &) = delete;
   const NativeFile &operator=(const NativeFile &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_HOST_FILE_H

lldb/include/lldb/Host/FileAction.h

public:
 
   llvm::StringRef GetPath() const;
 
   const FileSpec &GetFileSpec() const;
 
   void Dump(Stream &stream) const;
 
 protected:
-  Action m_action; // The action for this file
-  int m_fd;        // An existing file descriptor
-  int m_arg; // oflag for eFileActionOpen*, dup_fd for eFileActionDuplicate
+  Action m_action = eFileActionNone; // The action for this file
+  int m_fd = -1;                     // An existing file descriptor
+  int m_arg = -1; // oflag for eFileActionOpen*, dup_fd for eFileActionDuplicate
   FileSpec
       m_file_spec; // A file spec to use for opening after fork or posix_spawn
 };
 
 } // namespace lldb_private
 
 #endif

lldb/include/lldb/Host/FileSystem.h

 
 namespace lldb_private {
 class FileSystem {
 public:
   static const char *DEV_NULL;
   static const char *PATH_CONVERSION_ERROR;
 
   FileSystem()
       : m_fs(llvm::vfs::getRealFileSystem()), m_collector(nullptr),
-        m_home_directory(), m_mapped(false) {}
+        m_home_directory() {}
   FileSystem(std::shared_ptr<llvm::FileCollectorBase> collector)
       : m_fs(llvm::vfs::getRealFileSystem()), m_collector(std::move(collector)),
         m_home_directory(), m_mapped(false) {}
   FileSystem(llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> fs,
              bool mapped = false)
       : m_fs(std::move(fs)), m_collector(nullptr), m_home_directory(),
         m_mapped(mapped) {}
 
public:
 
   void SetHomeDirectory(std::string home_directory);
 
 private:
   static llvm::Optional<FileSystem> &InstanceImpl();
   llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> m_fs;
   std::shared_ptr<llvm::FileCollectorBase> m_collector;
   std::string m_home_directory;
-  bool m_mapped;
+  bool m_mapped = false;
 };
 } // namespace lldb_private
 
 #endif

lldb/include/lldb/Host/HostNativeThreadBase.h

public:
   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;
+  lldb::thread_result_t m_result = 0;
 };
 }
 
 #endif

lldb/include/lldb/Host/ProcessLaunchInfo.h

 
 protected:
   FileSpec m_working_dir;
   std::string m_plugin_name;
   FileSpec m_shell;
   Flags m_flags; // Bitwise OR of bits from lldb::LaunchFlags
   std::vector<FileAction> m_file_actions; // File actions for any other files
   std::shared_ptr<PseudoTerminal> m_pty;
-  uint32_t m_resume_count; // How many times do we resume after launching
+  uint32_t m_resume_count = 0; // How many times do we resume after launching
   Host::MonitorChildProcessCallback m_monitor_callback;
-  void *m_monitor_callback_baton;
-  bool m_monitor_signals;
+  void *m_monitor_callback_baton = nullptr;
+  bool m_monitor_signals = false;
   std::string m_event_data; // A string passed to the plugin launch, having no
                             // meaning to the upper levels of lldb.
   lldb::ListenerSP m_listener_sp;
   lldb::ListenerSP m_hijack_listener_sp;
   std::string m_scripted_process_class_name; // The name of the class that will
                                              // manage a scripted process.
   StructuredData::DictionarySP
       m_scripted_process_dictionary_sp; // A dictionary that holds key/value
                                         // pairs passed to the scripted process.
 };
 }
 
 #endif // LLDB_HOST_PROCESSLAUNCHINFO_H

lldb/include/lldb/Host/ProcessRunLock.h

public:
   bool ReadTryLock();
   bool ReadUnlock();
   bool SetRunning();
   bool TrySetRunning();
   bool SetStopped();
 
   class ProcessRunLocker {
   public:
-    ProcessRunLocker() : m_lock(nullptr) {}
+    ProcessRunLocker() {}
 
     ~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
public:
   protected:
     void Unlock() {
       if (m_lock) {
         m_lock->ReadUnlock();
         m_lock = nullptr;
       }
     }
 
-    ProcessRunLock *m_lock;
+    ProcessRunLock *m_lock = nullptr;
 
   private:
     ProcessRunLocker(const ProcessRunLocker &) = delete;
     const ProcessRunLocker &operator=(const ProcessRunLocker &) = delete;
   };
 
 protected:
   lldb::rwlock_t m_rwlock;
-  bool m_running;
+  bool m_running = false;
 
 private:
   ProcessRunLock(const ProcessRunLock &) = delete;
   const ProcessRunLock &operator=(const ProcessRunLock &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_HOST_PROCESSRUNLOCK_H

lldb/include/lldb/Host/PseudoTerminal.h

public:
   ///
   /// \return
   ///     The secondary file descriptor, or PseudoTerminal::invalid_fd
   ///     if the secondary file descriptor is not currently valid.
   int ReleaseSecondaryFileDescriptor();
 
 protected:
   // Member variables
-  int m_primary_fd;   ///< The file descriptor for the primary.
-  int m_secondary_fd; ///< The file descriptor for the secondary.
+  int m_primary_fd = invalid_fd;   ///< The file descriptor for the primary.
+  int m_secondary_fd = invalid_fd; ///< The file descriptor for the secondary.
 
 private:
   PseudoTerminal(const PseudoTerminal &) = delete;
   const PseudoTerminal &operator=(const PseudoTerminal &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_HOST_PSEUDOTERMINAL_H

lldb/include/lldb/Host/Terminal.h

protected:
   ///
   /// \return
   ///     Returns \b true if \a m_process_group is valid and can be
   ///     restored, \b false otherwise.
   bool ProcessGroupIsValid() const;
 
   // Member variables
   Terminal m_tty; ///< A terminal
-  int m_tflags;   ///< Cached tflags information.
+  int m_tflags = -1; ///< Cached tflags information.
 #if LLDB_ENABLE_TERMIOS
   std::unique_ptr<struct termios>
       m_termios_up; ///< Cached terminal state information.
 #endif
-  lldb::pid_t m_process_group; ///< Cached process group information.
+  lldb::pid_t m_process_group = -1; ///< Cached process group information.
 };
 
 /// \class TerminalStateSwitcher Terminal.h "lldb/Host/Terminal.h"
 /// A TTY state switching class.
 ///
 /// This class can be used to remember 2 TTY states for a given file
 /// descriptor and switch between the two states.
 class TerminalStateSwitcher {
public:
   ///
   /// \return
   ///     Returns \b true if the save was successful, \b false
   ///     otherwise.
   bool Save(uint32_t idx, int fd, bool save_process_group);
 
 protected:
   // Member variables
-  mutable uint32_t m_currentState; ///< The currently active TTY state index.
+  mutable uint32_t m_currentState =
+      UINT32_MAX; ///< The currently active TTY state index.
   TerminalState
       m_ttystates[2]; ///< The array of TTY states that holds saved TTY info.
 };
 
 } // namespace lldb_private
 
 #endif // #if defined(__cplusplus)
 #endif // LLDB_HOST_TERMINAL_H

lldb/include/lldb/Host/XML.h

public:
   void ForEachChildElement(NodeCallback const &callback) const;
 
   void ForEachChildElementWithName(const char *name,
                                    NodeCallback const &callback) const;
 
   void ForEachAttribute(AttributeCallback const &callback) const;
 
 protected:
-  XMLNodeImpl m_node;
+  XMLNodeImpl m_node = nullptr;
 };
 
 class XMLDocument {
 public:
   XMLDocument();
 
   ~XMLDocument();
 
public:
 
   llvm::StringRef GetErrors() const;
 
   static void ErrorCallback(void *ctx, const char *format, ...);
 
   static bool XMLEnabled();
 
 protected:
-  XMLDocumentImpl m_document;
+  XMLDocumentImpl m_document = nullptr;
   StreamString m_errors;
 };
 
 class ApplePropertyList {
 public:
   ApplePropertyList();
 
   ApplePropertyList(const char *path);

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

Predicate<uint16_t>
                         // that creates the socket, binds and listens to
                         // resolve the port number.
 
   Pipe m_pipe;
   std::recursive_mutex m_mutex;
   std::atomic<bool> m_shutting_down; // This marks that we are shutting down so
                                      // if we get woken up from
   // BytesAvailable to disconnect, we won't try to read again.
-  bool m_waiting_for_accept;
+  bool m_waiting_for_accept = false;
   bool m_child_processes_inherit;
 
   std::string m_uri;
 
 private:
   void InitializeSocket(Socket *socket);
 
   ConnectionFileDescriptor(const ConnectionFileDescriptor &) = delete;
   const ConnectionFileDescriptor &
   operator=(const ConnectionFileDescriptor &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_HOST_POSIX_CONNECTIONFILEDESCRIPTORPOSIX_H

lldb/include/lldb/Initialization/SystemLifetimeManager.h

public:
 
   llvm::Error Initialize(std::unique_ptr<SystemInitializer> initializer,
                          LoadPluginCallbackType plugin_callback);
   void Terminate();
 
 private:
   std::recursive_mutex m_mutex;
   std::unique_ptr<SystemInitializer> m_initializer;
-  bool m_initialized;
+  bool m_initialized = false;
 
   // Noncopyable.
   SystemLifetimeManager(const SystemLifetimeManager &other) = delete;
   SystemLifetimeManager &operator=(const SystemLifetimeManager &other) = delete;
 };
 }
 
 #endif

lldb/include/lldb/Interpreter/CommandInterpreter.h

 #include <mutex>
 #include <stack>
 
 namespace lldb_private {
 class CommandInterpreter;
 
 class CommandInterpreterRunResult {
 public:
-  CommandInterpreterRunResult()
-      : m_num_errors(0), m_result(lldb::eCommandInterpreterResultSuccess) {}
+  CommandInterpreterRunResult() {}
 
   uint32_t GetNumErrors() const { return m_num_errors; }
 
   lldb::CommandInterpreterResult GetResult() const { return m_result; }
 
   bool IsResult(lldb::CommandInterpreterResult result) {
     return m_result == result;
   }
 
 protected:
   friend CommandInterpreter;
 
   void IncrementNumberOfErrors() { m_num_errors++; }
 
   void SetResult(lldb::CommandInterpreterResult result) { m_result = result; }
 
 private:
-  int m_num_errors;
-  lldb::CommandInterpreterResult m_result;
+  int m_num_errors = 0;
+  lldb::CommandInterpreterResult m_result =
+      lldb::eCommandInterpreterResultSuccess;
 };
 
 class CommandInterpreterRunOptions {
 public:
   /// Construct a CommandInterpreterRunOptions object. This class is used to
   /// control all the instances where we run multiple commands, e.g.
   /// HandleCommands, HandleCommandsFromFile, RunCommandInterpreter.
   ///
CommandInterpreterRunOptions(LazyBool stop_on_continue,
                                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()
-      : m_stop_on_continue(eLazyBoolCalculate),
-        m_stop_on_error(eLazyBoolCalculate),
-        m_stop_on_crash(eLazyBoolCalculate),
-        m_echo_commands(eLazyBoolCalculate),
-        m_echo_comment_commands(eLazyBoolCalculate),
-        m_print_results(eLazyBoolCalculate), m_print_errors(eLazyBoolCalculate),
-        m_add_to_history(eLazyBoolCalculate) {}
+
+  {}
 
   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;
public:
   }
 
   bool GetSpawnThread() const { return DefaultToNo(m_spawn_thread); }
 
   void SetSpawnThread(bool spawn_thread) {
     m_spawn_thread = spawn_thread ? eLazyBoolYes : eLazyBoolNo;
   }
 
-  LazyBool m_stop_on_continue;
-  LazyBool m_stop_on_error;
-  LazyBool m_stop_on_crash;
-  LazyBool m_echo_commands;
-  LazyBool m_echo_comment_commands;
-  LazyBool m_print_results;
-  LazyBool m_print_errors;
-  LazyBool m_add_to_history;
+  LazyBool m_stop_on_continue = eLazyBoolCalculate;
+  LazyBool m_stop_on_error = eLazyBoolCalculate;
+  LazyBool m_stop_on_crash = eLazyBoolCalculate;
+  LazyBool m_echo_commands = eLazyBoolCalculate;
+  LazyBool m_echo_comment_commands = eLazyBoolCalculate;
+  LazyBool m_print_results = eLazyBoolCalculate;
+  LazyBool m_print_errors = eLazyBoolCalculate;
+  LazyBool m_add_to_history = eLazyBoolCalculate;
   LazyBool m_auto_handle_events;
   LazyBool m_spawn_thread;
 
 private:
   static bool DefaultToYes(LazyBool flag) {
     switch (flag) {
     case eLazyBoolNo:
       return false;

lldb/include/lldb/Interpreter/OptionValue.h

enum {
     eDumpOptionRaw = (1u << 4),
     eDumpOptionCommand = (1u << 5),
     eDumpGroupValue = (eDumpOptionName | eDumpOptionType | eDumpOptionValue),
     eDumpGroupHelp =
         (eDumpOptionName | eDumpOptionType | eDumpOptionDescription),
     eDumpGroupExport = (eDumpOptionCommand | eDumpOptionName | eDumpOptionValue)
   };
 
-  OptionValue() : m_value_was_set(false) {}
+  OptionValue() {}
 
   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.
protected:
   using TopmostBase = OptionValue;
 
   // Must be overriden by a derived class for correct downcasting the result of
   // DeepCopy to it. Inherit from Cloneable to avoid doing this manually.
   virtual lldb::OptionValueSP Clone() const = 0;
 
   lldb::OptionValueWP m_parent_wp;
   std::function<void()> m_callback;
-  bool m_value_was_set; // This can be used to see if a value has been set
-                        // by a call to SetValueFromCString(). It is often
-                        // handy to know if an option value was set from the
-                        // command line or as a setting, versus if we just have
-                        // the default value that was already populated in the
-                        // option value.
+  bool m_value_was_set = false; // This can be used to see if a value has been
+                                // set by a call to SetValueFromCString(). It is
+                                // often handy to know if an option value was
+                                // set from the command line or as a setting,
+                                // versus if we just have the default value that
+                                // was already populated in the option value.
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_INTERPRETER_OPTIONVALUE_H

lldb/include/lldb/Interpreter/OptionValueFileColonLine.h

 //===-- OptionValueFileColonLine.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_OPTIONVALUEFILECOLONLINE_H
 #define LLDB_INTERPRETER_OPTIONVALUEFILECOLONLINE_H
 
+#include "lldb/Interpreter/CommandCompletions.h"
 #include "lldb/Interpreter/OptionValue.h"
-
 #include "lldb/Utility/FileSpec.h"
 #include "llvm/Support/Chrono.h"
 
 namespace lldb_private {
 
 class OptionValueFileColonLine :
     public Cloneable<OptionValueFileColonLine, OptionValue> {
 public:
public:
   FileSpec &GetFileSpec() { return m_file_spec; }
   uint32_t GetLineNumber() { return m_line_number; }
   uint32_t GetColumnNumber() { return m_column_number; }
 
   void SetCompletionMask(uint32_t mask) { m_completion_mask = mask; }
 
 protected:
   FileSpec m_file_spec;
-  uint32_t m_line_number;
-  uint32_t m_column_number;
-  uint32_t m_completion_mask;
+  uint32_t m_line_number = LLDB_INVALID_LINE_NUMBER;
+  uint32_t m_column_number = LLDB_INVALID_COLUMN_NUMBER;
+  uint32_t m_completion_mask = CommandCompletions::eSourceFileCompletion;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_INTERPRETER_OPTIONVALUEFILECOLONLINE_H

lldb/include/lldb/Interpreter/OptionValueFileSpec.h

 //===-- OptionValueFileSpec.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_OPTIONVALUEFILESPEC_H
 #define LLDB_INTERPRETER_OPTIONVALUEFILESPEC_H
 
+#include "lldb/Interpreter/CommandCompletions.h"
 #include "lldb/Interpreter/OptionValue.h"
 
 #include "lldb/Utility/FileSpec.h"
 #include "llvm/Support/Chrono.h"
 
 namespace lldb_private {
 
 class OptionValueFileSpec : public Cloneable<OptionValueFileSpec, OptionValue> {
public:
 
   void SetCompletionMask(uint32_t mask) { m_completion_mask = mask; }
 
 protected:
   FileSpec m_current_value;
   FileSpec m_default_value;
   lldb::DataBufferSP m_data_sp;
   llvm::sys::TimePoint<> m_data_mod_time;
-  uint32_t m_completion_mask;
+  uint32_t m_completion_mask = CommandCompletions::eDiskFileCompletion;
   bool m_resolve;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_INTERPRETER_OPTIONVALUEFILESPEC_H

lldb/include/lldb/Interpreter/Options.h

virtual Status OptionParsingFinished(ExecutionContext *execution_context) {
     // can implement this function to do extra checking
     Status error;
     return error;
   }
 };
 
 class OptionGroupOptions : public Options {
 public:
-  OptionGroupOptions() : m_did_finalize(false) {}
+  OptionGroupOptions() {}
 
   ~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.
   ///
struct OptionInfo {
     OptionInfo(OptionGroup *g, uint32_t i) : option_group(g), option_index(i) {}
     OptionGroup *option_group; // The group that this option came from
     uint32_t option_index;     // The original option index from the OptionGroup
   };
   typedef std::vector<OptionInfo> OptionInfos;
 
   std::vector<OptionDefinition> m_option_defs;
   OptionInfos m_option_infos;
-  bool m_did_finalize;
+  bool m_did_finalize = false;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_INTERPRETER_OPTIONS_H

lldb/include/lldb/Interpreter/ScriptInterpreter.h

public:
   ScriptInterpreter(
       Debugger &debugger, lldb::ScriptLanguage script_lang,
       lldb::ScriptedProcessInterfaceUP scripted_process_interface_up = {});
 
   ~ScriptInterpreter() override = default;
 
   struct ExecuteScriptOptions {
   public:
-    ExecuteScriptOptions()
-        : m_enable_io(true), m_set_lldb_globals(true), m_maskout_errors(true) {}
+    ExecuteScriptOptions() {}
 
     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
public:
     }
 
     ExecuteScriptOptions &SetMaskoutErrors(bool maskout) {
       m_maskout_errors = maskout;
       return *this;
     }
 
   private:
-    bool m_enable_io;
-    bool m_set_lldb_globals;
-    bool m_maskout_errors;
+    bool m_enable_io = true;
+    bool m_set_lldb_globals = true;
+    bool m_maskout_errors = true;
   };
 
   virtual bool Interrupt() { return false; }
 
   virtual bool ExecuteOneLine(
       llvm::StringRef command, CommandReturnObject *result,
       const ExecuteScriptOptions &options = ExecuteScriptOptions()) = 0;
 

lldb/include/lldb/Symbol/CompactUnwindInfo.h

 
 private:
   // The top level index entries of the compact unwind info
   //   (internal representation of struct
   //   unwind_info_section_header_index_entry)
   // There are relatively few of these (one per 500/1000 functions, depending
   // on format) so creating them on first scan will not be too costly.
   struct UnwindIndex {
-    uint32_t function_offset; // The offset of the first function covered by
+    uint32_t function_offset = 0; // The offset of the first function covered by
                                   // this index
-    uint32_t second_level; // The offset (inside unwind_info sect) to the second
-                           // level page for this index
+    uint32_t second_level = 0;    // The offset (inside unwind_info sect) to the
+                                  // second level page for this index
     // (either UNWIND_SECOND_LEVEL_REGULAR or UNWIND_SECOND_LEVEL_COMPRESSED)
-    uint32_t lsda_array_start; // The offset (inside unwind_info sect) LSDA
+    uint32_t lsda_array_start = 0; // The offset (inside unwind_info sect) LSDA
                                    // array for this index
-    uint32_t lsda_array_end; // The offset to the LSDA array for the NEXT index
-    bool sentinal_entry; // There is an empty index at the end which provides
-                         // the upper bound of
+    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()
-        : function_offset(0), second_level(0), lsda_array_start(0),
-          lsda_array_end(0), sentinal_entry(false) {}
+    UnwindIndex() {}
 
     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;
     }
   };
 
   // An internal object used to store the information we retrieve about a
   // function -- the encoding bits and possibly the LSDA/personality function.
   struct FunctionInfo {
-    uint32_t encoding;    // compact encoding 32-bit value for this function
+    uint32_t encoding = 0; // compact encoding 32-bit value for this function
     Address lsda_address; // the address of the LSDA data for this function
     Address personality_ptr_address; // the address where the personality
                                      // routine addr can be found
 
-    uint32_t valid_range_offset_start; // first offset that this encoding is
+    uint32_t valid_range_offset_start = 0; // first offset that this encoding is
                                            // valid for (start of the function)
-    uint32_t
-        valid_range_offset_end; // the offset of the start of the next function
-    FunctionInfo()
-        : encoding(0), lsda_address(), personality_ptr_address(),
-          valid_range_offset_start(0), valid_range_offset_end(0) {}
+    uint32_t valid_range_offset_end =
+        0; // the offset of the start of the next function
+    FunctionInfo() : lsda_address(), personality_ptr_address() {}
   };
 
   struct UnwindHeader {
     uint32_t version;
-    uint32_t common_encodings_array_offset;
-    uint32_t common_encodings_array_count;
-    uint32_t personality_array_offset;
-    uint32_t personality_array_count;
-
-    UnwindHeader()
-        : common_encodings_array_offset(0), common_encodings_array_count(0),
-          personality_array_offset(0), personality_array_count(0) {}
+    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() {}
   };
 
   void ScanIndex(const lldb::ProcessSP &process_sp);
 
   bool GetCompactUnwindInfoForFunction(Target &target, Address address,
                                        FunctionInfo &unwind_info);
 
   lldb::offset_t

lldb/include/lldb/Symbol/LineEntry.h

struct LineEntry {
   ///     Shared pointer to the target this LineEntry belongs to.
   void ApplyFileMappings(lldb::TargetSP target_sp);
 
   // Member variables.
   AddressRange range; ///< The section offset address range for this line entry.
   FileSpec file; ///< The source file, possibly mapped by the target.source-map
                  ///setting
   FileSpec original_file; ///< The original source file, from debug info.
-  uint32_t line; ///< The source line number, or zero if there is no line number
-                 ///information.
-  uint16_t column; ///< The column number of the source line, or zero if there
-                   ///is no column information.
+  uint32_t line = LLDB_INVALID_LINE_NUMBER; ///< The source line number, or zero
+                                            ///< if there is no line number
+                                            /// information.
+  uint16_t column =
+      0; ///< The column number of the source line, or zero if there
+         /// is no column information.
   uint16_t is_start_of_statement : 1, ///< Indicates this entry is the beginning
                                       ///of a statement.
       is_start_of_basic_block : 1, ///< Indicates this entry is the beginning of
                                    ///a basic block.
       is_prologue_end : 1,   ///< Indicates this entry is one (of possibly many)
                              ///where execution should be suspended for an entry
                              ///breakpoint of a function.
       is_epilogue_begin : 1, ///< Indicates this entry is one (of possibly many)

lldb/include/lldb/Symbol/LineTable.h

public:
   typedef RangeDataVector<lldb::addr_t, lldb::addr_t, lldb::addr_t>
       FileRangeMap;
 
   LineTable *LinkLineTable(const FileRangeMap &file_range_map);
 
 protected:
   struct Entry {
     Entry()
-        : file_addr(LLDB_INVALID_ADDRESS), line(0),
-          is_start_of_statement(false), is_start_of_basic_block(false),
+        : line(0), is_start_of_statement(false), is_start_of_basic_block(false),
           is_prologue_end(false), is_epilogue_begin(false),
-          is_terminal_entry(false), column(0), file_idx(0) {}
+          is_terminal_entry(false) {}
 
     Entry(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)
         : file_addr(_file_addr), line(_line),
           is_start_of_statement(_is_start_of_statement),
           is_start_of_basic_block(_is_start_of_basic_block),
#undef SCALAR_COMPARE
     };
 
     static bool EntryAddressLessThan(const Entry &lhs, const Entry &rhs) {
       return lhs.file_addr < rhs.file_addr;
     }
 
     // Member variables.
     /// The file address for this line entry.
-    lldb::addr_t file_addr;
+    lldb::addr_t file_addr = LLDB_INVALID_ADDRESS;
     /// The source line number, or zero if there is no line number
     /// information.
     uint32_t line : 27;
     /// Indicates this entry is the beginning of a statement.
     uint32_t is_start_of_statement : 1;
     /// Indicates this entry is the beginning of a basic block.
     uint32_t is_start_of_basic_block : 1;
     /// Indicates this entry is one (of possibly many) where execution
     /// should be suspended for an entry breakpoint of a function.
     uint32_t is_prologue_end : 1;
     /// Indicates this entry is one (of possibly many) where execution
     /// should be suspended for an exit breakpoint of a function.
     uint32_t is_epilogue_begin : 1;
     /// Indicates this entry is that of the first byte after the end
     /// of a sequence of target machine instructions.
     uint32_t is_terminal_entry : 1;
     /// The column number of the source line, or zero if there is no
     /// column information.
-    uint16_t column;
+    uint16_t column = 0;
     /// The file index into CompileUnit's file table, or zero if there
     /// is no file information.
-    uint16_t file_idx;
+    uint16_t file_idx = 0;
   };
 
   struct EntrySearchInfo {
     LineTable *line_table;
     lldb_private::Section *a_section;
     Entry *a_entry;
   };
 

lldb/include/lldb/Symbol/Symbol.h

protected:
   // reexport_name is not null, and that module_spec is valid.  We track the
   // modules we've already seen to make sure we don't get caught in a cycle.
 
   Symbol *ResolveReExportedSymbolInModuleSpec(
       Target &target, ConstString &reexport_name,
       lldb_private::ModuleSpec &module_spec,
       lldb_private::ModuleList &seen_modules) const;
 
-  uint32_t m_uid;       // User ID (usually the original symbol table index)
-  uint16_t m_type_data; // data specific to m_type
+  uint32_t m_uid =
+      UINT32_MAX;           // User ID (usually the original symbol table index)
+  uint16_t m_type_data = 0; // data specific to m_type
   uint16_t m_type_data_resolved : 1, // True if the data in m_type_data has
                                      // already been calculated
       m_is_synthetic : 1, // non-zero if this symbol is not actually in the
                           // symbol table, but synthesized from other info in
                           // the object file.
       m_is_debug : 1,     // non-zero if this symbol is debug information in a
                           // symbol
       m_is_external : 1,  // non-zero if this symbol is globally visible
uint16_t m_type_data_resolved : 1, // True if the data in m_type_data has
                                          // annotations, which are optional when
                                          // doing name lookups
       m_is_weak : 1,
       m_type : 6;            // Values from the lldb::SymbolType enum.
   Mangled m_mangled;         // uniqued symbol name/mangled name pair
   AddressRange m_addr_range; // Contains the value, or the section offset
                              // address when the value is an address in a
                              // section, and the size (if any)
-  uint32_t m_flags; // A copy of the flags from the original symbol table, the
-                    // ObjectFile plug-in can interpret these
+  uint32_t m_flags = 0; // A copy of the flags from the original symbol table,
+                        // the ObjectFile plug-in can interpret these
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SYMBOL_SYMBOL_H

lldb/include/lldb/Symbol/SymbolContext.h

public:
   ///     \a inlined_frame_addr will be filled in correctly.
   bool GetParentOfInlinedScope(const Address &curr_frame_pc,
                                SymbolContext &next_frame_sc,
                                Address &inlined_frame_addr) const;
 
   // Member variables
   lldb::TargetSP target_sp; ///< The Target for a given query
   lldb::ModuleSP module_sp; ///< The Module for a given query
-  CompileUnit *comp_unit;   ///< The CompileUnit for a given query
-  Function *function;       ///< The Function for a given query
-  Block *block;             ///< The Block for a given query
+  CompileUnit *comp_unit = nullptr; ///< The CompileUnit for a given query
+  Function *function = nullptr;     ///< The Function for a given query
+  Block *block = nullptr;           ///< The Block for a given query
   LineEntry line_entry;     ///< The LineEntry for a given query
-  Symbol *symbol;           ///< The Symbol for a given query
-  Variable *variable;       ///< The global variable matching the given query
+  Symbol *symbol = nullptr; ///< The Symbol for a given query
+  Variable *variable =
+      nullptr; ///< The global variable matching the given query
 };
 
 class SymbolContextSpecifier {
 public:
   enum SpecificationType {
     eNothingSpecified = 0,
     eModuleSpecified = 1 << 0,
     eFileSpecified = 1 << 1,

lldb/include/lldb/Symbol/Type.h

public:
   typedef uint32_t Payload;
   /// Return the language-specific payload.
   Payload GetPayload() { return m_payload; }
   /// Return the language-specific payload.
   void SetPayload(Payload opaque_payload) { m_payload = opaque_payload; }
 
 protected:
   ConstString m_name;
-  SymbolFile *m_symbol_file;
+  SymbolFile *m_symbol_file = nullptr;
   /// The symbol context in which this type is defined.
-  SymbolContextScope *m_context;
-  Type *m_encoding_type;
-  lldb::user_id_t m_encoding_uid;
-  EncodingDataType m_encoding_uid_type;
+  SymbolContextScope *m_context = nullptr;
+  Type *m_encoding_type = nullptr;
+  lldb::user_id_t m_encoding_uid = LLDB_INVALID_UID;
+  EncodingDataType m_encoding_uid_type = eEncodingInvalid;
   uint64_t m_byte_size : 63;
   uint64_t m_byte_size_has_value : 1;
   Declaration m_decl;
   CompilerType m_compiler_type;
-  ResolveState m_compiler_type_resolve_state;
+  ResolveState m_compiler_type_resolve_state = ResolveState::Unresolved;
   /// Language-specific flags.
   Payload m_payload;
 
   Type *GetEncodingType();
 
   bool ResolveCompilerType(ResolveState compiler_type_resolve_state);
 };
 

 
 private:
   std::vector<lldb::TypeImplSP> m_content;
 };
 
 class TypeMemberImpl {
 public:
   TypeMemberImpl()
-      : m_type_impl_sp(), m_bit_offset(0), m_name(), m_bitfield_bit_size(0),
-        m_is_bitfield(false)
+      : m_type_impl_sp(), m_name()
 
   {}
 
   TypeMemberImpl(const lldb::TypeImplSP &type_impl_sp, uint64_t bit_offset,
                  ConstString name, uint32_t bitfield_bit_size = 0,
                  bool is_bitfield = false)
       : m_type_impl_sp(type_impl_sp), m_bit_offset(bit_offset), m_name(name),
         m_bitfield_bit_size(bitfield_bit_size), m_is_bitfield(is_bitfield) {}
public:
   }
 
   bool GetIsBitfield() const { return m_is_bitfield; }
 
   void SetIsBitfield(bool is_bitfield) { m_is_bitfield = is_bitfield; }
 
 protected:
   lldb::TypeImplSP m_type_impl_sp;
-  uint64_t m_bit_offset;
+  uint64_t m_bit_offset = 0;
   ConstString m_name;
-  uint32_t m_bitfield_bit_size; // Bit size for bitfield members only
-  bool m_is_bitfield;
+  uint32_t m_bitfield_bit_size = 0; // Bit size for bitfield members only
+  bool m_is_bitfield = false;
 };
 
 ///
 /// Sometimes you can find the name of the type corresponding to an object, but
 /// we don't have debug
 /// information for it.  If that is the case, you can return one of these
 /// objects, and then if it
 /// has a full type, you can use that, but if not at least you can print the

 
 private:
   CompilerType m_compiler_type;
   ConstString m_type_name;
 };
 
 class TypeMemberFunctionImpl {
 public:
-  TypeMemberFunctionImpl()
-      : m_type(), m_decl(), m_name(), m_kind(lldb::eMemberFunctionKindUnknown) {
-  }
+  TypeMemberFunctionImpl() : m_type(), m_decl(), m_name() {}
 
   TypeMemberFunctionImpl(const CompilerType &type, const CompilerDecl &decl,
                          const std::string &name,
                          const lldb::MemberFunctionKind &kind)
       : m_type(type), m_decl(decl), m_name(name), m_kind(kind) {}
 
   bool IsValid();
 

 
 protected:
   std::string GetPrintableTypeName();
 
 private:
   CompilerType m_type;
   CompilerDecl m_decl;
   ConstString m_name;
-  lldb::MemberFunctionKind m_kind;
+  lldb::MemberFunctionKind m_kind = lldb::eMemberFunctionKindUnknown;
 };
 
 class TypeEnumMemberImpl {
 public:
-  TypeEnumMemberImpl()
-      : m_integer_type_sp(), m_name("<invalid>"), m_value(), m_valid(false) {}
+  TypeEnumMemberImpl() : m_integer_type_sp(), m_name("<invalid>"), m_value() {}
 
   TypeEnumMemberImpl(const lldb::TypeImplSP &integer_type_sp,
                      ConstString name, const llvm::APSInt &value);
 
   TypeEnumMemberImpl(const TypeEnumMemberImpl &rhs) = default;
 
   TypeEnumMemberImpl &operator=(const TypeEnumMemberImpl &rhs);
 
   bool IsValid() { return m_valid; }
 
   ConstString GetName() const { return m_name; }
 
   const lldb::TypeImplSP &GetIntegerType() const { return m_integer_type_sp; }
 
   uint64_t GetValueAsUnsigned() const { return m_value.getZExtValue(); }
 
   int64_t GetValueAsSigned() const { return m_value.getSExtValue(); }
 
 protected:
   lldb::TypeImplSP m_integer_type_sp;
   ConstString m_name;
   llvm::APSInt m_value;
-  bool m_valid;
+  bool m_valid = false;
 };
 
 class TypeEnumMemberListImpl {
 public:
   TypeEnumMemberListImpl() : m_content() {}
 
   void Append(const lldb::TypeEnumMemberImplSP &type) {
     m_content.push_back(type);

lldb/include/lldb/Symbol/TypeSystem.h

public:
   GetTypeSystemForLanguage(lldb::LanguageType language, Target *target,
                            bool can_create);
 
 protected:
   typedef std::map<lldb::LanguageType, lldb::TypeSystemSP> collection;
   mutable std::mutex m_mutex; ///< A mutex to keep this object happy in
                               ///multi-threaded environments.
   collection m_map;
-  bool m_clear_in_progress;
+  bool m_clear_in_progress = false;
 
 private:
   typedef llvm::function_ref<lldb::TypeSystemSP()> CreateCallback;
   /// Finds the type system for the given language. If no type system could be
   /// found for a language and a CreateCallback was provided, the value returned
   /// by the callback will be treated as the TypeSystem for the language.
   ///
   /// \param language The language for which the type system should be found.

lldb/include/lldb/Symbol/UnwindPlan.h

public:
         isCFAPlusOffset,   // reg = CFA + offset
         atAFAPlusOffset,   // reg = deref(AFA + offset)
         isAFAPlusOffset,   // reg = AFA + offset
         inOtherRegister,   // reg = other reg
         atDWARFExpression, // reg = deref(eval(dwarf_expr))
         isDWARFExpression  // reg = eval(dwarf_expr)
       };
 
-      RegisterLocation() : m_type(unspecified), m_location() {}
+      RegisterLocation() : m_location() {}
 
       bool operator==(const RegisterLocation &rhs) const;
 
       bool operator!=(const RegisterLocation &rhs) const {
         return !(*this == rhs);
       }
 
       void SetUnspecified() { m_type = unspecified; }
public:
           return m_location.expr.length;
         return 0;
       }
 
       void Dump(Stream &s, const UnwindPlan *unwind_plan,
                 const UnwindPlan::Row *row, Thread *thread, bool verbose) const;
 
     private:
-      RestoreType m_type; // How do we locate this register?
+      RestoreType m_type = unspecified; // How do we locate this register?
       union {
         // For m_type == atCFAPlusOffset or m_type == isCFAPlusOffset
         int32_t offset;
         // For m_type == inOtherRegister
         uint32_t reg_num; // The register number
         // For m_type == atDWARFExpression or m_type == isDWARFExpression
         struct {
           const uint8_t *opcodes;
           uint16_t length;
         } expr;
       } m_location;
     };
 
     class FAValue {
     public:
       enum ValueType {
         unspecified,            // not specified
         isRegisterPlusOffset,   // FA = register + offset
         isRegisterDereferenced, // FA = [reg]
         isDWARFExpression,      // FA = eval(dwarf_expr)
         isRaSearch,             // FA = SP + offset + ???
       };
 
-      FAValue() : m_type(unspecified), m_value() {}
+      FAValue() : m_value() {}
 
       bool operator==(const FAValue &rhs) const;
 
       bool operator!=(const FAValue &rhs) const { return !(*this == rhs); }
 
       void SetUnspecified() { m_type = unspecified; }
 
       bool IsUnspecified() const { return m_type == unspecified; }
public:
         if (m_type == isDWARFExpression)
           return m_value.expr.length;
         return 0;
       }
 
       void Dump(Stream &s, const UnwindPlan *unwind_plan, Thread *thread) const;
 
     private:
-      ValueType m_type; // How do we compute CFA value?
+      ValueType m_type = unspecified; // How do we compute CFA value?
       union {
         struct {
           // For m_type == isRegisterPlusOffset or m_type ==
           // isRegisterDereferenced
           uint32_t reg_num; // The register number
           // For m_type == isRegisterPlusOffset
           int32_t offset;
         } reg;
public:
 
     void Clear();
 
     void Dump(Stream &s, const UnwindPlan *unwind_plan, Thread *thread,
               lldb::addr_t base_addr) const;
 
   protected:
     typedef std::map<uint32_t, RegisterLocation> collection;
-    lldb::addr_t m_offset; // Offset into the function for this row
+    lldb::addr_t m_offset = 0; // Offset into the function for this row
 
     FAValue m_cfa_value;
     FAValue m_afa_value;
     collection m_register_locations;
-    bool m_unspecified_registers_are_undefined;
+    bool m_unspecified_registers_are_undefined = false;
   }; // class Row
 
   typedef std::shared_ptr<Row> RowSP;
 
   UnwindPlan(lldb::RegisterKind reg_kind)
       : m_row_list(), m_plan_valid_address_range(), m_register_kind(reg_kind),
         m_return_addr_register(LLDB_INVALID_REGNUM), m_source_name(),
         m_plan_is_sourced_from_compiler(eLazyBoolCalculate),

lldb/include/lldb/Target/ExecutionContext.h

public:
 
   void ClearFrame() { m_stack_id.Clear(); }
 
 protected:
   // Member variables
   lldb::TargetWP m_target_wp;         ///< A weak reference to a target
   lldb::ProcessWP m_process_wp;       ///< A weak reference to a process
   mutable lldb::ThreadWP m_thread_wp; ///< A weak reference to a thread
-  lldb::tid_t m_tid;  ///< The thread ID that this object refers to in case the
-                      ///backing object changes
+  lldb::tid_t m_tid = LLDB_INVALID_THREAD_ID; ///< The thread ID that this
+                                              ///< object refers to in case the
+                                              /// backing object changes
   StackID m_stack_id; ///< The stack ID that this object refers to in case the
                       ///backing object changes
 };
 
 /// \class ExecutionContext ExecutionContext.h
 /// "lldb/Target/ExecutionContext.h"
 /// A class that contains an execution context.
 ///

lldb/include/lldb/Target/PathMappingList.h

protected:
   typedef collection::iterator iterator;
   typedef collection::const_iterator const_iterator;
 
   iterator FindIteratorForPath(ConstString path);
 
   const_iterator FindIteratorForPath(ConstString path) const;
 
   collection m_pairs;
-  ChangedCallback m_callback;
-  void *m_callback_baton;
-  uint32_t m_mod_id; // Incremented anytime anything is added or removed.
+  ChangedCallback m_callback = nullptr;
+  void *m_callback_baton = nullptr;
+  uint32_t m_mod_id = 0; // Incremented anytime anything is added or removed.
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_PATHMAPPINGLIST_H

lldb/include/lldb/Target/Process.h

 // ProcessAttachInfo
 //
 // Describes any information that is required to attach to a process.
 
 class ProcessAttachInfo : public ProcessInstanceInfo {
 public:
   ProcessAttachInfo()
       : ProcessInstanceInfo(), m_listener_sp(), m_hijack_listener_sp(),
-        m_plugin_name(), m_resume_count(0), m_wait_for_launch(false),
-        m_ignore_existing(true), m_continue_once_attached(false),
-        m_detach_on_error(true), m_async(false) {}
+        m_plugin_name() {}
 
   ProcessAttachInfo(const ProcessLaunchInfo &launch_info)
       : ProcessInstanceInfo(), m_listener_sp(), m_hijack_listener_sp(),
         m_plugin_name(), m_resume_count(0), m_wait_for_launch(false),
         m_ignore_existing(true), m_continue_once_attached(false),
         m_detach_on_error(true), m_async(false) {
     ProcessInfo::operator=(launch_info);
     SetProcessPluginName(launch_info.GetProcessPluginName());
public:
   }
 
   lldb::ListenerSP GetListenerForProcess(Debugger &debugger);
 
 protected:
   lldb::ListenerSP m_listener_sp;
   lldb::ListenerSP m_hijack_listener_sp;
   std::string m_plugin_name;
-  uint32_t m_resume_count; // How many times do we resume after launching
-  bool m_wait_for_launch;
-  bool m_ignore_existing;
-  bool m_continue_once_attached; // Supports the use-case scenario of
-                                 // immediately continuing the process once
-                                 // attached.
-  bool m_detach_on_error; // If we are debugging remotely, instruct the stub to
-                          // detach rather than killing the target on error.
-  bool m_async; // Use an async attach where we start the attach and return
-                // immediately (used by GUI programs with --waitfor so they can
-                // call SBProcess::Stop() to cancel attach)
+  uint32_t m_resume_count = 0; // How many times do we resume after launching
+  bool m_wait_for_launch = false;
+  bool m_ignore_existing = true;
+  bool m_continue_once_attached = false; // Supports the use-case scenario of
+                                         // immediately continuing the process
+                                         // once attached.
+  bool m_detach_on_error =
+      true; // If we are debugging remotely, instruct the stub to
+  bool m_async =
+      false; // Use an async attach where we start the attach and return
 };
 
 // This class tracks the Modification state of the process.  Things that can
 // 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()
-      : m_stop_id(0), m_last_natural_stop_id(0), m_resume_id(0), m_memory_id(0),
-        m_last_user_expression_resume(0), m_running_user_expression(false),
-        m_running_utility_function(0) {}
+
+  {}
 
   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;
public:
 
   lldb::EventSP GetStopEventForStopID(uint32_t stop_id) const {
     if (stop_id == m_last_natural_stop_id)
       return m_last_natural_stop_event;
     return lldb::EventSP();
   }
 
 private:
-  uint32_t m_stop_id;
-  uint32_t m_last_natural_stop_id;
-  uint32_t m_resume_id;
-  uint32_t m_memory_id;
-  uint32_t m_last_user_expression_resume;
-  uint32_t m_running_user_expression;
-  uint32_t m_running_utility_function;
+  uint32_t m_stop_id = 0;
+  uint32_t m_last_natural_stop_id = 0;
+  uint32_t m_resume_id = 0;
+  uint32_t m_memory_id = 0;
+  uint32_t m_last_user_expression_resume = 0;
+  uint32_t m_running_user_expression = false;
+  uint32_t m_running_utility_function = 0;
   lldb::EventSP m_last_natural_stop_event;
 };
 
 inline bool operator==(const ProcessModID &lhs, const ProcessModID &rhs) {
   if (lhs.StopIDEqual(rhs) && lhs.MemoryIDEqual(rhs))
     return true;
   else
     return false;
private:
 
     void SetInterrupted(bool new_value) { m_interrupted = new_value; }
 
     void AddRestartedReason(const char *reason) {
       m_restarted_reasons.push_back(reason);
     }
 
     lldb::ProcessWP m_process_wp;
-    lldb::StateType m_state;
+    lldb::StateType m_state = lldb::eStateInvalid;
     std::vector<std::string> m_restarted_reasons;
-    bool m_restarted; // For "eStateStopped" events, this is true if the target
-                      // was automatically restarted.
-    int m_update_state;
-    bool m_interrupted;
+    bool m_restarted = false; // For "eStateStopped" events, this is true if the
+                              // target was automatically restarted.
+    int m_update_state = 0;
+    bool m_interrupted = false;
 
     ProcessEventData(const ProcessEventData &) = delete;
     const ProcessEventData &operator=(const ProcessEventData &) = delete;
   };
 
   /// Construct with a shared pointer to a target, and the Process listener.
   /// Uses the Host UnixSignalsSP by default.
   Process(lldb::TargetSP target_sp, lldb::ListenerSP listener_sp);

lldb/include/lldb/Target/RegisterNumber.h

public:
   lldb::RegisterKind GetRegisterKind() const;
 
   const char *GetName();
 
 private:
   typedef std::map<lldb::RegisterKind, uint32_t> Collection;
 
   lldb::RegisterContextSP m_reg_ctx_sp;
-  uint32_t m_regnum;
-  lldb::RegisterKind m_kind;
+  uint32_t m_regnum = LLDB_INVALID_REGNUM;
+  lldb::RegisterKind m_kind = lldb::kNumRegisterKinds;
   Collection m_kind_regnum_map;
-  const char *m_name;
+  const char *m_name = nullptr;
 };
 
 #endif // LLDB_TARGET_REGISTERNUMBER_H

lldb/include/lldb/Target/StackID.h

 #include "lldb/lldb-private.h"
 
 namespace lldb_private {
 
 class StackID {
 public:
   // Constructors and Destructors
   StackID()
-      : m_pc(LLDB_INVALID_ADDRESS), m_cfa(LLDB_INVALID_ADDRESS),
-        m_symbol_scope(nullptr) {}
+
+  {}
 
   explicit StackID(lldb::addr_t pc, lldb::addr_t cfa,
                    SymbolContextScope *symbol_scope)
       : m_pc(pc), m_cfa(cfa), m_symbol_scope(symbol_scope) {}
 
   StackID(const StackID &rhs)
       : m_pc(rhs.m_pc), m_cfa(rhs.m_cfa), m_symbol_scope(rhs.m_symbol_scope) {}
 

 
 protected:
   friend class StackFrame;
 
   void SetPC(lldb::addr_t pc) { m_pc = pc; }
 
   void SetCFA(lldb::addr_t cfa) { m_cfa = cfa; }
 
-  lldb::addr_t
-      m_pc; // The pc value for the function/symbol for this frame. This will
+  lldb::addr_t m_pc =
+      LLDB_INVALID_ADDRESS; // The pc value for the function/symbol for this
+                            // frame. This will
   // only get used if the symbol scope is nullptr (the code where we are
   // stopped is not represented by any function or symbol in any shared
   // library).
-  lldb::addr_t m_cfa; // The call frame address (stack pointer) value
+  lldb::addr_t m_cfa =
+      LLDB_INVALID_ADDRESS; // The call frame address (stack pointer) value
                             // at the beginning of the function that uniquely
                             // identifies this frame (along with m_symbol_scope
                             // below)
-  SymbolContextScope *
-      m_symbol_scope; // If nullptr, there is no block or symbol for this frame.
-                      // If not nullptr, this will either be the scope for the
-                      // lexical block for the frame, or the scope for the
-                      // symbol. Symbol context scopes are always be unique
-                      // pointers since the are part of the Block and Symbol
-                      // objects and can easily be used to tell if a stack ID
-                      // is the same as another.
+  SymbolContextScope *m_symbol_scope =
+      nullptr; // If nullptr, there is no block or symbol for this frame.
 };
 
 bool operator==(const StackID &lhs, const StackID &rhs);
 bool operator!=(const StackID &lhs, const StackID &rhs);
 
 // frame_id_1 < frame_id_2 means "frame_id_1 is YOUNGER than frame_id_2"
 bool operator<(const StackID &lhs, const StackID &rhs);
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_STACKID_H

lldb/include/lldb/Target/ThreadSpec.h

enum class OptionNames {
     LastOptionName
   };
   static const char *g_option_names[(size_t)OptionNames::LastOptionName];
 
   static const char *GetKey(OptionNames enum_value) {
     return g_option_names[(size_t) enum_value];
   }
 
-  uint32_t m_index;
-  lldb::tid_t m_tid;
+  uint32_t m_index = UINT32_MAX;
+  lldb::tid_t m_tid = LLDB_INVALID_THREAD_ID;
   std::string m_name;
   std::string m_queue_name;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_THREADSPEC_H

lldb/include/lldb/Target/UnwindLLDB.h

protected:
   ///     Vector of ConstStrings of trap handler function names.  May be
   ///     empty.
   const std::vector<ConstString> &GetUserSpecifiedTrapHandlerFunctionNames() {
     return m_user_supplied_trap_handler_functions;
   }
 
 private:
   struct Cursor {
-    lldb::addr_t start_pc; // The start address of the function/symbol for this
-                           // frame - current pc if unknown
-    lldb::addr_t cfa;      // The canonical frame address for this stack frame
+    lldb::addr_t start_pc =
+        LLDB_INVALID_ADDRESS; // The start address of the function/symbol for
+                              // this frame - current pc if unknown
+    lldb::addr_t cfa = LLDB_INVALID_ADDRESS; // The canonical frame address for
+                                             // this stack frame
     lldb_private::SymbolContext sctx; // A symbol context we'll contribute to &
                                       // provide to the StackFrame creation
     RegisterContextLLDBSP
         reg_ctx_lldb_sp; // These are all RegisterContextUnwind's
 
-    Cursor()
-        : start_pc(LLDB_INVALID_ADDRESS), cfa(LLDB_INVALID_ADDRESS), sctx(),
-          reg_ctx_lldb_sp() {}
+    Cursor() : sctx(), reg_ctx_lldb_sp() {}
 
   private:
     Cursor(const Cursor &) = delete;
     const Cursor &operator=(const Cursor &) = delete;
   };
 
   typedef std::shared_ptr<Cursor> CursorSP;
   std::vector<CursorSP> m_frames;

lldb/include/lldb/Utility/DataEncoder.h

private:
 
   /// Get the number of bytes contained in this object.
   ///
   /// \return
   ///     The total number of bytes of data this object refers to.
   size_t GetByteSize() const { return m_end - m_start; }
 
   /// A pointer to the first byte of data.
-  uint8_t *m_start;
+  uint8_t *m_start = nullptr;
 
   /// A pointer to the byte that is past the end of the data.
-  uint8_t *m_end;
+  uint8_t *m_end = nullptr;
 
   /// The byte order of the data we are extracting from.
   lldb::ByteOrder m_byte_order;
 
   /// The address size to use when extracting pointers or
   /// addresses
   uint8_t m_addr_size;
 

lldb/include/lldb/Utility/DataExtractor.h

template <typename T> T Get(lldb::offset_t *offset_ptr, T fail_value) const {
     memcpy(&val, src, src_size);
     if (m_byte_order != endian::InlHostByteOrder())
       llvm::sys::swapByteOrder(val);
 
     return val;
   }
 
   // Member variables
-  const uint8_t *m_start; ///< A pointer to the first byte of data.
-  const uint8_t
-      *m_end; ///< A pointer to the byte that is past the end of the data.
+  const uint8_t *m_start = nullptr; ///< A pointer to the first byte of data.
+  const uint8_t *m_end =
+      nullptr; ///< A pointer to the byte that is past the end of the data.
   lldb::ByteOrder
       m_byte_order;     ///< The byte order of the data we are extracting from.
   uint32_t m_addr_size; ///< The address size to use when extracting addresses.
   /// The shared pointer to data that can be shared among multiple instances
   lldb::DataBufferSP m_data_sp;
-  const uint32_t m_target_byte_size;
+  const uint32_t m_target_byte_size = 1;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_UTILITY_DATAEXTRACTOR_H

lldb/include/lldb/Utility/GDBRemote.h

 /// GDB remote packet as used by the reproducer and the GDB remote
 /// communication history. Packets can be serialized to file.
 struct GDBRemotePacket {
 
   friend llvm::yaml::MappingTraits<GDBRemotePacket>;
 
   enum Type { ePacketTypeInvalid = 0, ePacketTypeSend, ePacketTypeRecv };
 
-  GDBRemotePacket()
-      : packet(), type(ePacketTypeInvalid), bytes_transmitted(0), packet_idx(0),
-        tid(LLDB_INVALID_THREAD_ID) {}
+  GDBRemotePacket() : packet() {}
 
   void Clear() {
     packet.data.clear();
     type = ePacketTypeInvalid;
     bytes_transmitted = 0;
     packet_idx = 0;
     tid = LLDB_INVALID_THREAD_ID;
   }
 
   struct BinaryData {
     std::string data;
   };
 
   void Dump(Stream &strm) const;
 
   BinaryData packet;
-  Type type;
-  uint32_t bytes_transmitted;
-  uint32_t packet_idx;
-  lldb::tid_t tid;
+  Type type = ePacketTypeInvalid;
+  uint32_t bytes_transmitted = 0;
+  uint32_t packet_idx = 0;
+  lldb::tid_t tid = LLDB_INVALID_THREAD_ID;
 
 private:
   llvm::StringRef GetTypeStr() const;
 };
 
 namespace repro {
 class PacketRecorder : public AbstractRecorder {
 public:

lldb/include/lldb/Utility/ProcessInfo.h

 protected:
   template <class T> friend struct llvm::yaml::MappingTraits;
   FileSpec m_executable;
   std::string m_arg0; // argv[0] if supported. If empty, then use m_executable.
   // Not all process plug-ins support specifying an argv[0] that differs from
   // the resolved platform executable (which is in m_executable)
   Args m_arguments; // All program arguments except argv[0]
   Environment m_environment;
-  uint32_t m_uid;
-  uint32_t m_gid;
+  uint32_t m_uid = UINT32_MAX;
+  uint32_t m_gid = UINT32_MAX;
   ArchSpec m_arch;
-  lldb::pid_t m_pid;
+  lldb::pid_t m_pid = LLDB_INVALID_PROCESS_ID;
 };
 
 // ProcessInstanceInfo
 //
 // Describes an existing process and any discoverable information that pertains
 // to that process.
 class ProcessInstanceInfo : public ProcessInfo {
 public:
-  ProcessInstanceInfo()
-      : ProcessInfo(), m_euid(UINT32_MAX), m_egid(UINT32_MAX),
-        m_parent_pid(LLDB_INVALID_PROCESS_ID) {}
+  ProcessInstanceInfo() : ProcessInfo() {}
 
   ProcessInstanceInfo(const char *name, const ArchSpec &arch, lldb::pid_t pid)
       : ProcessInfo(name, arch, pid), m_euid(UINT32_MAX), m_egid(UINT32_MAX),
         m_parent_pid(LLDB_INVALID_PROCESS_ID) {}
 
   void Clear() {
     ProcessInfo::Clear();
     m_euid = UINT32_MAX;
public:
 
   static void DumpTableHeader(Stream &s, bool show_args, bool verbose);
 
   void DumpAsTableRow(Stream &s, UserIDResolver &resolver, bool show_args,
                       bool verbose) const;
 
 protected:
   friend struct llvm::yaml::MappingTraits<ProcessInstanceInfo>;
-  uint32_t m_euid;
-  uint32_t m_egid;
-  lldb::pid_t m_parent_pid;
+  uint32_t m_euid = UINT32_MAX;
+  uint32_t m_egid = UINT32_MAX;
+  lldb::pid_t m_parent_pid = LLDB_INVALID_PROCESS_ID;
 };
 
 typedef std::vector<ProcessInstanceInfo> ProcessInstanceInfoList;
 
 // ProcessInstanceInfoMatch
 //
 // A class to help matching one ProcessInstanceInfo to another.
 
 class ProcessInstanceInfoMatch {
 public:
-  ProcessInstanceInfoMatch()
-      : m_match_info(), m_name_match_type(NameMatch::Ignore),
-        m_match_all_users(false) {}
+  ProcessInstanceInfoMatch() : m_match_info() {}
 
   ProcessInstanceInfoMatch(const char *process_name,
                            NameMatch process_name_match_type)
       : m_match_info(), m_name_match_type(process_name_match_type),
         m_match_all_users(false) {
     m_match_info.GetExecutableFile().SetFile(process_name,
                                              FileSpec::Style::native);
   }
public:
 
   bool Matches(const ProcessInstanceInfo &proc_info) const;
 
   bool MatchAllProcesses() const;
   void Clear();
 
 protected:
   ProcessInstanceInfo m_match_info;
-  NameMatch m_name_match_type;
-  bool m_match_all_users;
+  NameMatch m_name_match_type = NameMatch::Ignore;
+  bool m_match_all_users = false;
 };
 
 namespace repro {
 llvm::Optional<ProcessInstanceInfoList> GetReplayProcessInstanceInfoList();
 } // namespace repro
 } // namespace lldb_private
 
 LLVM_YAML_IS_SEQUENCE_VECTOR(lldb_private::ProcessInstanceInfo)

lldb/include/lldb/Utility/RegisterValue.h

enum Type {
     eTypeUInt64,
     eTypeUInt128,
     eTypeFloat,
     eTypeDouble,
     eTypeLongDouble,
     eTypeBytes
   };
 
-  RegisterValue()
-      : m_type(eTypeInvalid), m_scalar(static_cast<unsigned long>(0)) {}
+  RegisterValue() : m_scalar(static_cast<unsigned long>(0)) {}
 
   explicit RegisterValue(uint8_t inst) : m_type(eTypeUInt8) { m_scalar = inst; }
 
   explicit RegisterValue(uint16_t inst) : m_type(eTypeUInt16) {
     m_scalar = inst;
   }
 
   explicit RegisterValue(uint32_t inst) : m_type(eTypeUInt32) {
public:
 
   uint32_t GetByteSize() const;
 
   static uint32_t GetMaxByteSize() { return kMaxRegisterByteSize; }
 
   void Clear();
 
 protected:
-  RegisterValue::Type m_type;
+  RegisterValue::Type m_type = eTypeInvalid;
   Scalar m_scalar;
 
   struct {
     mutable uint8_t
         bytes[kMaxRegisterByteSize]; // This must be big enough to hold any
                                      // register for any supported target.
     uint16_t length;
     lldb::ByteOrder byte_order;
   } buffer;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_UTILITY_REGISTERVALUE_H

lldb/include/lldb/Utility/ReproducerInstrumentation.h

public:
   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()
-      : m_serializer(nullptr), m_deserializer(nullptr), m_registry(nullptr) {}
+  InstrumentationData() {}
   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:
   static llvm::Optional<InstrumentationData> &InstanceImpl();
 
-  Serializer *m_serializer;
-  Deserializer *m_deserializer;
-  Registry *m_registry;
+  Serializer *m_serializer = nullptr;
+  Deserializer *m_deserializer = nullptr;
+  Registry *m_registry = nullptr;
 };
 
 struct EmptyArg {};
 
 /// RAII object that records function invocations and their return value.
 ///
 /// API calls are only captured when the API boundary is crossed. Once we're in
 /// the API layer, and another API function is called, it doesn't need to be

 
 #ifdef LLDB_REPRO_INSTR_TRACE
   void Log(unsigned id) {
     this_thread_id() << "Recording " << id << ": " << m_pretty_func << " ("
                      << m_pretty_args << ")\n";
   }
 #endif
 
-  Serializer *m_serializer;
+  Serializer *m_serializer = nullptr;
 
   /// Pretty function for logging.
   llvm::StringRef m_pretty_func;
   std::string m_pretty_args;
 
   /// Whether this function call was the one crossing the API boundary.
-  bool m_local_boundary;
+  bool m_local_boundary = false;
 
   /// Whether the return value was recorded explicitly.
-  bool m_result_recorded;
+  bool m_result_recorded = true;
 
   /// The sequence number for this pair of function and result.
   unsigned m_sequence;
 
   /// Whether we're currently across the API boundary.
   static thread_local bool g_global_boundary;
 
   /// Global mutex to protect concurrent access.

lldb/include/lldb/Utility/Scalar.h

 public:
   enum Type {
     e_void = 0,
     e_int,
     e_float,
   };
 
   // Constructors and Destructors
-  Scalar() : m_type(e_void), m_float(0.0f) {}
+  Scalar() : m_float(0.0f) {}
   Scalar(int v) : m_type(e_int), m_integer(MakeAPSInt(v)), m_float(0.0f) {}
   Scalar(unsigned int v)
       : m_type(e_int), m_integer(MakeAPSInt(v)), m_float(0.0f) {}
   Scalar(long v) : m_type(e_int), m_integer(MakeAPSInt(v)), m_float(0.0f) {}
   Scalar(unsigned long v)
       : m_type(e_int), m_integer(MakeAPSInt(v)), m_float(0.0f) {}
   Scalar(long long v)
       : m_type(e_int), m_integer(MakeAPSInt(v)), m_float(0.0f) {}
public:
 
   Status SetValueFromCString(const char *s, lldb::Encoding encoding,
                              size_t byte_size);
 
   Status SetValueFromData(const DataExtractor &data, lldb::Encoding encoding,
                           size_t byte_size);
 
 protected:
-  Scalar::Type m_type;
+  Scalar::Type m_type = e_void;
   llvm::APSInt m_integer;
   llvm::APFloat m_float;
 
   template <typename T> T GetAs(T fail_value) const;
 
   static Type PromoteToMaxType(Scalar &lhs, Scalar &rhs);
 
   using PromotionKey = std::tuple<Type, unsigned, bool>;

lldb/include/lldb/Utility/Status.h

public:
   ///
   /// \return
   ///     \b true if this object contains an value that describes
   ///     failure due to interrupt, \b false otherwise.
   bool WasInterrupted() const;
 
 protected:
   /// Member variables
-  ValueType m_code;             ///< Status code as an integer value.
-  lldb::ErrorType m_type;       ///< The type of the above error code.
+  ValueType m_code = 0; ///< Status code as an integer value.
+  lldb::ErrorType m_type =
+      lldb::eErrorTypeInvalid;  ///< The type of the above error code.
   mutable std::string m_string; ///< A string representation of the error code.
 };
 
 } // namespace lldb_private
 
 namespace llvm {
 template <> struct format_provider<lldb_private::Status> {
   static void format(const lldb_private::Status &error, llvm::raw_ostream &OS,

lldb/include/lldb/Utility/Stream.h

public:
   /// Returns a raw_ostream that forwards the data to this Stream object.
   llvm::raw_ostream &AsRawOstream() {
     return m_forwarder;
   }
 
 protected:
   // Member variables
   Flags m_flags;        ///< Dump flags.
-  uint32_t m_addr_size; ///< Size of an address in bytes.
+  uint32_t m_addr_size = 4; ///< Size of an address in bytes.
   lldb::ByteOrder
       m_byte_order;   ///< Byte order to use when encoding scalar types.
-  unsigned m_indent_level;         ///< Indention level.
+  unsigned m_indent_level = 0;     ///< Indention level.
   std::size_t m_bytes_written = 0; ///< Number of bytes written so far.
 
   void _PutHex8(uint8_t uvalue, bool add_prefix);
 
   /// Output character bytes to the stream.
   ///
   /// Appends \a src_len characters from the buffer \a src to the stream.
   ///

lldb/include/lldb/Utility/StringExtractor.h

protected:
   }
 
   /// The string in which to extract data.
   std::string m_packet;
 
   /// When extracting data from a packet, this index will march along as things
   /// get extracted. If set to UINT64_MAX the end of the packet data was
   /// reached when decoding information.
-  uint64_t m_index;
+  uint64_t m_index = 0;
 };
 
 #endif // LLDB_UTILITY_STRINGEXTRACTOR_H

lldb/include/lldb/Utility/StringExtractorGDBRemote.h

 #include <cstddef>
 #include <cstdint>
 
 class StringExtractorGDBRemote : public StringExtractor {
 public:
   typedef bool (*ResponseValidatorCallback)(
       void *baton, const StringExtractorGDBRemote &response);
 
-  StringExtractorGDBRemote() : StringExtractor(), m_validator(nullptr) {}
+  StringExtractorGDBRemote() : StringExtractor() {}
 
   StringExtractorGDBRemote(llvm::StringRef str)
       : StringExtractor(str), m_validator(nullptr) {}
 
   StringExtractorGDBRemote(const char *cstr)
       : StringExtractor(cstr), m_validator(nullptr) {}
 
   bool ValidateResponse() const;
public:
 
   // Read thread-id from the packet.  If the packet is valid, returns
   // the pair (PID, TID), otherwise returns llvm::None.  If the packet
   // does not list a PID, default_pid is used.
   llvm::Optional<std::pair<lldb::pid_t, lldb::tid_t>>
   GetPidTid(lldb::pid_t default_pid);
 
 protected:
-  ResponseValidatorCallback m_validator;
+  ResponseValidatorCallback m_validator = nullptr;
   void *m_validator_baton;
 };
 
 #endif // LLDB_UTILITY_STRINGEXTRACTORGDBREMOTE_H

lldb/include/lldb/Utility/VMRange.h

 // 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() : m_base_addr(0), m_byte_size(0) {}
+  VMRange() {}
 
   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() {}
 
   void Clear() {
public:
 
   static bool ContainsValue(const VMRange::collection &coll,
                             lldb::addr_t value);
 
   static bool ContainsRange(const VMRange::collection &coll,
                             const VMRange &range);
 
 protected:
-  lldb::addr_t m_base_addr;
-  lldb::addr_t m_byte_size;
+  lldb::addr_t m_base_addr = 0;
+  lldb::addr_t m_byte_size = 0;
 };
 
 bool operator==(const VMRange &lhs, const VMRange &rhs);
 bool operator!=(const VMRange &lhs, const VMRange &rhs);
 bool operator<(const VMRange &lhs, const VMRange &rhs);
 bool operator<=(const VMRange &lhs, const VMRange &rhs);
 bool operator>(const VMRange &lhs, const VMRange &rhs);
 bool operator>=(const VMRange &lhs, const VMRange &rhs);
 
 } // namespace lldb_private
 
 #endif // LLDB_UTILITY_VMRANGE_H

lldb/source/API/SBBlock.cpp

 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-SBBlock::SBBlock() : m_opaque_ptr(nullptr) {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBlock);
-}
+SBBlock::SBBlock() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBlock); }
 
 SBBlock::SBBlock(lldb_private::Block *lldb_object_ptr)
     : m_opaque_ptr(lldb_object_ptr) {}
 
 SBBlock::SBBlock(const SBBlock &rhs) : m_opaque_ptr(rhs.m_opaque_ptr) {
   LLDB_RECORD_CONSTRUCTOR(SBBlock, (const lldb::SBBlock &), rhs);
 }
 

lldb/source/API/SBBroadcaster.cpp

 
 #include "lldb/API/SBBroadcaster.h"
 #include "lldb/API/SBEvent.h"
 #include "lldb/API/SBListener.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-SBBroadcaster::SBBroadcaster() : m_opaque_sp(), m_opaque_ptr(nullptr) {
+SBBroadcaster::SBBroadcaster() : m_opaque_sp() {
   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBroadcaster);
 }
 
 SBBroadcaster::SBBroadcaster(const char *name)
     : m_opaque_sp(new Broadcaster(nullptr, name)), m_opaque_ptr(nullptr) {
   LLDB_RECORD_CONSTRUCTOR(SBBroadcaster, (const char *), name);
 
   m_opaque_ptr = m_opaque_sp.get();
 }
 
 SBBroadcaster::SBBroadcaster(lldb_private::Broadcaster *broadcaster, bool owns)
     : m_opaque_sp(owns ? broadcaster : nullptr), m_opaque_ptr(broadcaster) {}
 

lldb/source/API/SBCommandReturnObject.cpp

 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Status.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 class lldb_private::SBCommandReturnObjectImpl {
 public:
-  SBCommandReturnObjectImpl()
-      : m_ptr(new CommandReturnObject(false)), m_owned(true) {}
+  SBCommandReturnObjectImpl() : m_ptr(new CommandReturnObject(false)) {}
   SBCommandReturnObjectImpl(CommandReturnObject &ref)
       : m_ptr(&ref), m_owned(false) {}
   SBCommandReturnObjectImpl(const SBCommandReturnObjectImpl &rhs)
       : m_ptr(new CommandReturnObject(*rhs.m_ptr)), m_owned(rhs.m_owned) {}
   SBCommandReturnObjectImpl &operator=(const SBCommandReturnObjectImpl &rhs) {
     SBCommandReturnObjectImpl copy(rhs);
     std::swap(*this, copy);
     return *this;
   }
   // rvalue ctor+assignment are not used by SBCommandReturnObject.
   ~SBCommandReturnObjectImpl() {
     if (m_owned)
       delete m_ptr;
   }
 
   CommandReturnObject &operator*() const { return *m_ptr; }
 
 private:
   CommandReturnObject *m_ptr;
-  bool m_owned;
+  bool m_owned = true;
 };
 
 SBCommandReturnObject::SBCommandReturnObject()
     : m_opaque_up(new SBCommandReturnObjectImpl()) {
   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommandReturnObject);
 }
 
 SBCommandReturnObject::SBCommandReturnObject(CommandReturnObject &ref)

lldb/source/API/SBCommunication.cpp

 #include "lldb/API/SBBroadcaster.h"
 #include "lldb/Core/Communication.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/Host.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-SBCommunication::SBCommunication() : m_opaque(nullptr), m_opaque_owned(false) {
+SBCommunication::SBCommunication() {
   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommunication);
 }
 
 SBCommunication::SBCommunication(const char *broadcaster_name)
     : m_opaque(new Communication(broadcaster_name)), m_opaque_owned(true) {
   LLDB_RECORD_CONSTRUCTOR(SBCommunication, (const char *), broadcaster_name);
 }
 

lldb/source/API/SBCompileUnit.cpp

 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Symbol/TypeList.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-SBCompileUnit::SBCompileUnit() : m_opaque_ptr(nullptr) {
+SBCompileUnit::SBCompileUnit() {
   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCompileUnit);
 }
 
 SBCompileUnit::SBCompileUnit(lldb_private::CompileUnit *lldb_object_ptr)
     : m_opaque_ptr(lldb_object_ptr) {}
 
 SBCompileUnit::SBCompileUnit(const SBCompileUnit &rhs)
     : m_opaque_ptr(rhs.m_opaque_ptr) {

lldb/source/API/SBEvent.cpp

 #include "lldb/Target/Process.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Event.h"
 #include "lldb/Utility/Stream.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-SBEvent::SBEvent() : m_event_sp(), m_opaque_ptr(nullptr) {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBEvent);
-}
+SBEvent::SBEvent() : m_event_sp() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBEvent); }
 
 SBEvent::SBEvent(uint32_t event_type, const char *cstr, uint32_t cstr_len)
     : m_event_sp(new Event(event_type, new EventDataBytes(cstr, cstr_len))),
       m_opaque_ptr(m_event_sp.get()) {
   LLDB_RECORD_CONSTRUCTOR(SBEvent, (uint32_t, const char *, uint32_t),
                           event_type, cstr, cstr_len);
 }
 

lldb/source/API/SBFunction.cpp

 #include "lldb/Symbol/Type.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Target.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-SBFunction::SBFunction() : m_opaque_ptr(nullptr) {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBFunction);
-}
+SBFunction::SBFunction() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBFunction); }
 
 SBFunction::SBFunction(lldb_private::Function *lldb_object_ptr)
     : m_opaque_ptr(lldb_object_ptr) {}
 
 SBFunction::SBFunction(const lldb::SBFunction &rhs)
     : m_opaque_ptr(rhs.m_opaque_ptr) {
   LLDB_RECORD_CONSTRUCTOR(SBFunction, (const lldb::SBFunction &), rhs);
 }

lldb/source/API/SBListener.cpp

 #include "lldb/Core/Debugger.h"
 #include "lldb/Utility/Broadcaster.h"
 #include "lldb/Utility/Listener.h"
 #include "lldb/Utility/StreamString.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-SBListener::SBListener() : m_opaque_sp(), m_unused_ptr(nullptr) {
+SBListener::SBListener() : m_opaque_sp() {
   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBListener);
 }
 
 SBListener::SBListener(const char *name)
     : m_opaque_sp(Listener::MakeListener(name)), m_unused_ptr(nullptr) {
   LLDB_RECORD_CONSTRUCTOR(SBListener, (const char *), name);
 }
 

lldb/source/API/SBPlatform.cpp

 
 using namespace lldb;
 using namespace lldb_private;
 
 // PlatformConnectOptions
 struct PlatformConnectOptions {
   PlatformConnectOptions(const char *url = nullptr)
       : m_url(), m_rsync_options(), m_rsync_remote_path_prefix(),
-        m_rsync_enabled(false), m_rsync_omit_hostname_from_remote_path(false),
+
         m_local_cache_directory() {
     if (url && url[0])
       m_url = url;
   }
 
   ~PlatformConnectOptions() = default;
 
   std::string m_url;
   std::string m_rsync_options;
   std::string m_rsync_remote_path_prefix;
-  bool m_rsync_enabled;
-  bool m_rsync_omit_hostname_from_remote_path;
+  bool m_rsync_enabled = false;
+  bool m_rsync_omit_hostname_from_remote_path = false;
   ConstString m_local_cache_directory;
 };
 
 // PlatformShellCommand
 struct PlatformShellCommand {
   PlatformShellCommand(llvm::StringRef shell_interpreter,
                        llvm::StringRef shell_command)
       : m_command(), m_working_dir(), m_status(0), m_signo(0) {
     if (!shell_interpreter.empty())
       m_shell = shell_interpreter.str();
 
     if (!m_shell.empty() && !shell_command.empty())
       m_command = shell_command.str();
   }
 
   PlatformShellCommand(llvm::StringRef shell_command = llvm::StringRef())
-      : m_shell(), m_command(), m_working_dir(), m_status(0), m_signo(0) {
+      : m_shell(), m_command(), m_working_dir() {
     if (!shell_command.empty())
       m_command = shell_command.str();
   }
 
   ~PlatformShellCommand() = default;
 
   std::string m_shell;
   std::string m_command;
   std::string m_working_dir;
   std::string m_output;
-  int m_status;
-  int m_signo;
+  int m_status = 0;
+  int m_signo = 0;
   Timeout<std::ratio<1>> m_timeout = llvm::None;
 };
 // SBPlatformConnectOptions
 SBPlatformConnectOptions::SBPlatformConnectOptions(const char *url)
     : m_opaque_ptr(new PlatformConnectOptions(url)) {
   LLDB_RECORD_CONSTRUCTOR(SBPlatformConnectOptions, (const char *), url);
 }
 

lldb/source/API/SBQueue.cpp

 
 using namespace lldb;
 using namespace lldb_private;
 
 namespace lldb_private {
 
 class QueueImpl {
 public:
-  QueueImpl()
-      : m_queue_wp(), m_threads(), m_thread_list_fetched(false),
-        m_pending_items(), m_pending_items_fetched(false) {}
+  QueueImpl() : m_queue_wp(), m_threads(), m_pending_items() {}
 
   QueueImpl(const lldb::QueueSP &queue_sp)
       : m_queue_wp(), m_threads(), m_thread_list_fetched(false),
         m_pending_items(), m_pending_items_fetched(false) {
     m_queue_wp = queue_sp;
   }
 
   QueueImpl(const QueueImpl &rhs) {
lldb::QueueKind GetKind() {
 
     return kind;
   }
 
 private:
   lldb::QueueWP m_queue_wp;
   std::vector<lldb::ThreadWP>
       m_threads; // threads currently executing this queue's items
-  bool
-      m_thread_list_fetched; // have we tried to fetch the threads list already?
+  bool m_thread_list_fetched =
+      false; // have we tried to fetch the threads list already?
   std::vector<lldb::QueueItemSP> m_pending_items; // items currently enqueued
-  bool m_pending_items_fetched; // have we tried to fetch the item list already?
+  bool m_pending_items_fetched =
+      false; // have we tried to fetch the item list already?
 };
 }
 
 SBQueue::SBQueue() : m_opaque_sp(new QueueImpl()) {
   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBQueue);
 }
 
 SBQueue::SBQueue(const QueueSP &queue_sp)

lldb/source/API/SBStream.cpp

 #include "lldb/Host/FileSystem.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StreamString.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-SBStream::SBStream() : m_opaque_up(new StreamString()), m_is_file(false) {
+SBStream::SBStream() : m_opaque_up(new StreamString()) {
   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBStream);
 }
 
 SBStream::SBStream(SBStream &&rhs)
     : m_opaque_up(std::move(rhs.m_opaque_up)), m_is_file(rhs.m_is_file) {}
 
 SBStream::~SBStream() = default;
 

lldb/source/API/SBSymbol.cpp

 #include "lldb/Core/Module.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Target.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-SBSymbol::SBSymbol() : m_opaque_ptr(nullptr) {
-  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBSymbol);
-}
+SBSymbol::SBSymbol() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBSymbol); }
 
 SBSymbol::SBSymbol(lldb_private::Symbol *lldb_object_ptr)
     : m_opaque_ptr(lldb_object_ptr) {}
 
 SBSymbol::SBSymbol(const lldb::SBSymbol &rhs) : m_opaque_ptr(rhs.m_opaque_ptr) {
   LLDB_RECORD_CONSTRUCTOR(SBSymbol, (const lldb::SBSymbol &), rhs);
 }
 

lldb/source/API/SBVariablesOptions.cpp

 using namespace lldb;
 using namespace lldb_private;
 
 class VariablesOptionsImpl {
 public:
   VariablesOptionsImpl()
       : m_include_arguments(false), m_include_locals(false),
         m_include_statics(false), m_in_scope_only(false),
-        m_include_runtime_support_values(false),
-        m_include_recognized_arguments(eLazyBoolCalculate),
-        m_use_dynamic(lldb::eNoDynamicValues) {}
+        m_include_runtime_support_values(false) {}
 
   VariablesOptionsImpl(const VariablesOptionsImpl &) = default;
 
   ~VariablesOptionsImpl() = default;
 
   VariablesOptionsImpl &operator=(const VariablesOptionsImpl &) = default;
 
   bool GetIncludeArguments() const { return m_include_arguments; }
public:
   void SetUseDynamic(lldb::DynamicValueType d) { m_use_dynamic = d; }
 
 private:
   bool m_include_arguments : 1;
   bool m_include_locals : 1;
   bool m_include_statics : 1;
   bool m_in_scope_only : 1;
   bool m_include_runtime_support_values : 1;
-  LazyBool m_include_recognized_arguments; // can be overridden with a setting
-  lldb::DynamicValueType m_use_dynamic;
+  LazyBool m_include_recognized_arguments =
+      eLazyBoolCalculate; // can be overridden with a setting
+  lldb::DynamicValueType m_use_dynamic = lldb::eNoDynamicValues;
 };
 
 SBVariablesOptions::SBVariablesOptions()
     : m_opaque_up(new VariablesOptionsImpl()) {
   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBVariablesOptions);
 }
 
 SBVariablesOptions::SBVariablesOptions(const SBVariablesOptions &options)

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() : m_bid(LLDB_INVALID_BREAK_ID) {}
+Stoppoint::Stoppoint() {}
 
 // Destructor
 Stoppoint::~Stoppoint() {}
 
 break_id_t Stoppoint::GetID() const { return m_bid; }
 
 void Stoppoint::SetID(break_id_t bid) { m_bid = bid; }

lldb/source/Breakpoint/StoppointCallbackContext.cpp

 //===-- StoppointCallbackContext.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/StoppointCallbackContext.h"
 
 using namespace lldb_private;
 
-StoppointCallbackContext::StoppointCallbackContext()
-    : event(nullptr), exe_ctx_ref(), is_synchronous(false) {}
+StoppointCallbackContext::StoppointCallbackContext() : exe_ctx_ref() {}
 
 StoppointCallbackContext::StoppointCallbackContext(
     Event *e, const ExecutionContext &exe_ctx, bool synchronously)
     : event(e), exe_ctx_ref(exe_ctx), is_synchronous(synchronously) {}
 
 void StoppointCallbackContext::Clear() {
   event = nullptr;
   exe_ctx_ref.Clear();
   is_synchronous = false;
 }

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(), m_next_wp_id(0) {}
+WatchpointList::WatchpointList() : m_watchpoints(), m_mutex() {}
 
 WatchpointList::~WatchpointList() {}
 
 // 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);

lldb/source/Breakpoint/WatchpointOptions.cpp

bool WatchpointOptions::NullCallback(void *baton,
                                      StoppointCallbackContext *context,
                                      lldb::user_id_t watch_id) {
   return true;
 }
 
 // WatchpointOptions constructor
 WatchpointOptions::WatchpointOptions()
     : m_callback(WatchpointOptions::NullCallback), m_callback_baton_sp(),
-      m_callback_is_synchronous(false), m_thread_spec_up() {}
+      m_thread_spec_up() {}
 
 // WatchpointOptions copy constructor
 WatchpointOptions::WatchpointOptions(const WatchpointOptions &rhs)
     : m_callback(rhs.m_callback), m_callback_baton_sp(rhs.m_callback_baton_sp),
       m_callback_is_synchronous(rhs.m_callback_is_synchronous),
       m_thread_spec_up() {
   if (rhs.m_thread_spec_up != nullptr)
     m_thread_spec_up = std::make_unique<ThreadSpec>(*rhs.m_thread_spec_up);

lldb/source/Commands/CommandObjectBreakpoint.cpp

public:
 
   ~CommandObjectBreakpointSet() override = default;
 
   Options *GetOptions() override { return &m_all_options; }
 
   class CommandOptions : public OptionGroup {
   public:
     CommandOptions()
-        : OptionGroup(), m_condition(), m_filenames(), m_line_num(0),
-          m_column(0), m_func_names(),
-          m_func_name_type_mask(eFunctionNameTypeNone), m_func_regexp(),
-          m_source_text_regexp(), m_modules(), m_load_addr(), m_catch_bp(false),
-          m_throw_bp(true), m_hardware(false),
-          m_exception_language(eLanguageTypeUnknown),
-          m_language(lldb::eLanguageTypeUnknown),
-          m_skip_prologue(eLazyBoolCalculate), m_all_files(false),
-          m_move_to_nearest_code(eLazyBoolCalculate) {}
+        : OptionGroup(), m_condition(), m_filenames(), m_func_names(),
+          m_func_regexp(), m_source_text_regexp(), m_modules() {}
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
       const int short_option =
           g_breakpoint_set_options[option_idx].short_option;
public:
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_breakpoint_set_options);
     }
 
     // Instance variables to hold the values for command options.
 
     std::string m_condition;
     FileSpecList m_filenames;
-    uint32_t m_line_num;
-    uint32_t m_column;
+    uint32_t m_line_num = 0;
+    uint32_t m_column = 0;
     std::vector<std::string> m_func_names;
     std::vector<std::string> m_breakpoint_names;
-    lldb::FunctionNameType m_func_name_type_mask;
+    lldb::FunctionNameType m_func_name_type_mask = eFunctionNameTypeNone;
     std::string m_func_regexp;
     std::string m_source_text_regexp;
     FileSpecList m_modules;
-    lldb::addr_t m_load_addr;
+    lldb::addr_t m_load_addr = 0;
     lldb::addr_t m_offset_addr;
-    bool m_catch_bp;
-    bool m_throw_bp;
-    bool m_hardware; // Request to use hardware breakpoints
-    lldb::LanguageType m_exception_language;
-    lldb::LanguageType m_language;
-    LazyBool m_skip_prologue;
-    bool m_all_files;
+    bool m_catch_bp = false;
+    bool m_throw_bp = true;
+    bool m_hardware = false; // Request to use hardware breakpoints
+    lldb::LanguageType m_exception_language = eLanguageTypeUnknown;
+    lldb::LanguageType m_language = lldb::eLanguageTypeUnknown;
+    LazyBool m_skip_prologue = eLazyBoolCalculate;
+    bool m_all_files = false;
     Args m_exception_extra_args;
-    LazyBool m_move_to_nearest_code;
+    LazyBool m_move_to_nearest_code = eLazyBoolCalculate;
     std::unordered_set<std::string> m_source_regex_func_names;
     std::string m_current_key;
   };
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     Target &target = GetSelectedOrDummyTarget(m_dummy_options.m_use_dummy);
 
public:
   }
 
   ~CommandObjectBreakpointList() override = default;
 
   Options *GetOptions() override { return &m_options; }
 
   class CommandOptions : public Options {
   public:
-    CommandOptions()
-        : Options(), m_level(lldb::eDescriptionLevelBrief), m_use_dummy(false) {
-    }
+    CommandOptions() : Options() {}
 
     ~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;
 
public:
     }
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_breakpoint_list_options);
     }
 
     // Instance variables to hold the values for command options.
 
-    lldb::DescriptionLevel m_level;
+    lldb::DescriptionLevel m_level = lldb::eDescriptionLevelBrief;
 
     bool m_internal;
-    bool m_use_dummy;
+    bool m_use_dummy = false;
   };
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     Target &target = GetSelectedOrDummyTarget(m_options.m_use_dummy);
 
     const BreakpointList &breakpoints =
         target.GetBreakpointList(m_options.m_internal);
CommandObjectBreakpointClear(CommandInterpreter &interpreter)
         m_options() {}
 
   ~CommandObjectBreakpointClear() override = default;
 
   Options *GetOptions() override { return &m_options; }
 
   class CommandOptions : public Options {
   public:
-    CommandOptions() : Options(), m_filename(), m_line_num(0) {}
+    CommandOptions() : Options(), m_filename() {}
 
     ~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;
 
public:
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_breakpoint_clear_options);
     }
 
     // Instance variables to hold the values for command options.
 
     std::string m_filename;
-    uint32_t m_line_num;
+    uint32_t m_line_num = 0;
   };
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     Target &target = GetSelectedOrDummyTarget();
 
     // The following are the various types of breakpoints that could be
     // cleared:
CommandCompletions::InvokeCommonCompletionCallbacks(
         GetCommandInterpreter(), CommandCompletions::eBreakpointCompletion,
         request, nullptr);
   }
 
   Options *GetOptions() override { return &m_options; }
 
   class CommandOptions : public Options {
   public:
-    CommandOptions() : Options(), m_use_dummy(false), m_force(false),
-      m_delete_disabled(false) {}
+    CommandOptions() : Options() {}
 
     ~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;
 
void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_delete_disabled = false;
     }
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_breakpoint_delete_options);
     }
 
     // Instance variables to hold the values for command options.
-    bool m_use_dummy;
-    bool m_force;
-    bool m_delete_disabled;
+    bool m_use_dummy = false;
+    bool m_force = false;
+    bool m_delete_disabled = false;
   };
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     Target &target = GetSelectedOrDummyTarget(m_options.m_use_dummy);
     result.Clear();
     
     std::unique_lock<std::recursive_mutex> lock;

lldb/source/Commands/CommandObjectBreakpointCommand.cpp

for (auto bp_options : bp_options_vec) {
       cmd_data->stop_on_error = m_options.m_stop_on_error;
 
       bp_options->SetCommandDataCallback(cmd_data);
     }
   }
 
   class CommandOptions : public OptionGroup {
   public:
-    CommandOptions()
-        : OptionGroup(), m_use_commands(false), m_use_script_language(false),
-          m_script_language(eScriptLanguageNone), m_use_one_liner(false),
-          m_one_liner() {}
+    CommandOptions() : OptionGroup(), m_one_liner() {}
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
       const int short_option =
           g_breakpoint_command_add_options[option_idx].short_option;
public:
     }
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_breakpoint_command_add_options);
     }
 
     // Instance variables to hold the values for command options.
 
-    bool m_use_commands;
-    bool m_use_script_language;
-    lldb::ScriptLanguage m_script_language;
+    bool m_use_commands = false;
+    bool m_use_script_language = false;
+    lldb::ScriptLanguage m_script_language = eScriptLanguageNone;
 
     // Instance variables to hold the values for one_liner options.
-    bool m_use_one_liner;
+    bool m_use_one_liner = false;
     std::string m_one_liner;
     bool m_stop_on_error;
     bool m_use_dummy;
   };
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     Target &target = GetSelectedOrDummyTarget(m_options.m_use_dummy);
public:
   }
 
   ~CommandObjectBreakpointCommandDelete() override = default;
 
   Options *GetOptions() override { return &m_options; }
 
   class CommandOptions : public Options {
   public:
-    CommandOptions() : Options(), m_use_dummy(false) {}
+    CommandOptions() : Options() {}
 
     ~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;
 
void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_use_dummy = false;
     }
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_breakpoint_command_delete_options);
     }
 
     // Instance variables to hold the values for command options.
-    bool m_use_dummy;
+    bool m_use_dummy = false;
   };
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     Target &target = GetSelectedOrDummyTarget(m_options.m_use_dummy);
 
     const BreakpointList &breakpoints = target.GetBreakpointList();
     size_t num_breakpoints = breakpoints.GetSize();

lldb/source/Commands/CommandObjectCommands.cpp

public:
   ~CommandObjectCommandsScriptAdd() override = default;
 
   Options *GetOptions() override { return &m_options; }
 
 protected:
   class CommandOptions : public Options {
   public:
     CommandOptions()
-        : Options(), m_class_name(), m_funct_name(), m_short_help(),
-          m_synchronicity(eScriptedCommandSynchronicitySynchronous) {}
+        : Options(), m_class_name(), m_funct_name(), m_short_help() {}
 
     ~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;
 
llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_script_add_options);
     }
 
     // Instance variables to hold the values for command options.
 
     std::string m_class_name;
     std::string m_funct_name;
     std::string m_short_help;
-    ScriptedCommandSynchronicity m_synchronicity;
+    ScriptedCommandSynchronicity m_synchronicity =
+        eScriptedCommandSynchronicitySynchronous;
   };
 
   void IOHandlerActivated(IOHandler &io_handler, bool interactive) override {
     StreamFileSP output_sp(io_handler.GetOutputStreamFileSP());
     if (output_sp && interactive) {
       output_sp->PutCString(g_python_command_instructions);
       output_sp->Flush();
     }

lldb/source/Commands/CommandObjectDisassemble.h

const char *GetFlavorString() {
         return nullptr;
       return flavor_string.c_str();
     }
 
     Status OptionParsingFinished(ExecutionContext *execution_context) override;
 
     bool show_mixed; // Show mixed source/assembly
     bool show_bytes;
-    uint32_t num_lines_context;
-    uint32_t num_instructions;
+    uint32_t num_lines_context = 0;
+    uint32_t num_instructions = 0;
     bool raw;
     std::string func_name;
-    bool current_function;
-    lldb::addr_t start_addr;
-    lldb::addr_t end_addr;
-    bool at_pc;
-    bool frame_line;
+    bool current_function = false;
+    lldb::addr_t start_addr = 0;
+    lldb::addr_t end_addr = 0;
+    bool at_pc = false;
+    bool frame_line = false;
     std::string plugin_name;
     std::string flavor_string;
     ArchSpec arch;
-    bool some_location_specified; // If no location was specified, we'll select
-                                  // "at_pc".  This should be set
+    bool some_location_specified = false; // If no location was specified, we'll
+                                          // select "at_pc".  This should be set
     // in SetOptionValue if anything the selects a location is set.
-    lldb::addr_t symbol_containing_addr;
+    lldb::addr_t symbol_containing_addr = 0;
     bool force = false;
   };
 
   CommandObjectDisassemble(CommandInterpreter &interpreter);
 
   ~CommandObjectDisassemble() override;
 
   Options *GetOptions() override { return &m_options; }

lldb/source/Commands/CommandObjectDisassemble.cpp

 
 using namespace lldb;
 using namespace lldb_private;
 
 #define LLDB_OPTIONS_disassemble
 #include "CommandOptions.inc"
 
 CommandObjectDisassemble::CommandOptions::CommandOptions()
-    : Options(), num_lines_context(0), num_instructions(0), func_name(),
-      current_function(false), start_addr(), end_addr(), at_pc(false),
-      frame_line(false), plugin_name(), flavor_string(), arch(),
-      some_location_specified(false), symbol_containing_addr() {
+    : Options(), func_name(), plugin_name(), flavor_string(), arch() {
   OptionParsingStarting(nullptr);
 }
 
 CommandObjectDisassemble::CommandOptions::~CommandOptions() = default;
 
 Status CommandObjectDisassemble::CommandOptions::SetOptionValue(
     uint32_t option_idx, llvm::StringRef option_arg,
     ExecutionContext *execution_context) {

lldb/source/Commands/CommandObjectLog.cpp

public:
   }
 
   ~CommandObjectLogEnable() override = default;
 
   Options *GetOptions() override { return &m_options; }
 
   class CommandOptions : public Options {
   public:
-    CommandOptions() : Options(), log_file(), log_options(0) {}
+    CommandOptions() : Options(), log_file() {}
 
     ~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;
 
public:
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_log_options);
     }
 
     // Instance variables to hold the values for command options.
 
     FileSpec log_file;
-    uint32_t log_options;
+    uint32_t log_options = 0;
   };
 
   void
   HandleArgumentCompletion(CompletionRequest &request,
                            OptionElementVector &opt_element_vector) override {
     CompleteEnableDisable(request);
   }
 

lldb/source/Commands/CommandObjectMemory.cpp

 using namespace lldb_private;
 
 #define LLDB_OPTIONS_memory_read
 #include "CommandOptions.inc"
 
 class OptionGroupReadMemory : public OptionGroup {
 public:
   OptionGroupReadMemory()
-      : m_num_per_line(1, 1), m_output_as_binary(false), m_view_as_type(),
-        m_offset(0, 0), m_language_for_type(eLanguageTypeUnknown) {}
+      : m_num_per_line(1, 1), m_view_as_type(), m_offset(0, 0),
+        m_language_for_type(eLanguageTypeUnknown) {}
 
   ~OptionGroupReadMemory() override = default;
 
   llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
     return llvm::makeArrayRef(g_memory_read_options);
   }
 
   Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
public:
 
   bool AnyOptionWasSet() const {
     return m_num_per_line.OptionWasSet() || m_output_as_binary ||
            m_view_as_type.OptionWasSet() || m_offset.OptionWasSet() ||
            m_language_for_type.OptionWasSet();
   }
 
   OptionValueUInt64 m_num_per_line;
-  bool m_output_as_binary;
+  bool m_output_as_binary = false;
   OptionValueString m_view_as_type;
   bool m_force;
   OptionValueUInt64 m_offset;
   OptionValueLanguage m_language_for_type;
 };
 
 // Read memory from the inferior process
 class CommandObjectMemoryRead : public CommandObjectParsed {

lldb/source/Commands/CommandObjectPlatform.cpp

if (platform_sp) {
       result.AppendError("no platform is selected\n");
       result.SetStatus(eReturnStatusFailed);
     }
     return result.Succeeded();
   }
 
   class CommandOptions : public Options {
   public:
-    CommandOptions()
-        : Options(), match_info(), show_args(false), verbose(false) {}
+    CommandOptions() : Options(), match_info() {}
 
     ~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;
       bool success = false;
public:
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_platform_process_list_options);
     }
 
     // Instance variables to hold the values for command options.
 
     ProcessInstanceInfoMatch match_info;
-    bool show_args;
-    bool verbose;
+    bool show_args = false;
+    bool verbose = false;
   };
 
   CommandOptions m_options;
 };
 
 // "platform process info"
 class CommandObjectPlatformProcessInfo : public CommandObjectParsed {
 public:

lldb/source/Commands/CommandObjectProcess.cpp

CommandObjectProcessStatus(CommandInterpreter &interpreter)
         m_options() {}
 
   ~CommandObjectProcessStatus() override = default;
 
   Options *GetOptions() override { return &m_options; }
 
   class CommandOptions : public Options {
   public:
-    CommandOptions() : Options(), m_verbose(false) {}
+    CommandOptions() : Options() {}
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       const int short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_verbose = false;
     }
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_process_status_options);
     }
 
     // Instance variables to hold the values for command options.
-    bool m_verbose;
+    bool m_verbose = false;
   };
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     Stream &strm = result.GetOutputStream();
     result.SetStatus(eReturnStatusSuccessFinishNoResult);
 
     if (command.GetArgumentCount()) {

lldb/source/Commands/CommandObjectSettings.cpp

insert-before or insert-after.");
   // Overrides base class's behavior where WantsCompletion =
   // !WantsRawCommandString.
   bool WantsCompletion() override { return true; }
 
   Options *GetOptions() override { return &m_options; }
 
   class CommandOptions : public Options {
   public:
-    CommandOptions() : Options(), m_global(false) {}
+    CommandOptions() : Options() {}
 
     ~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;
 
void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_force = false;
     }
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_settings_set_options);
     }
 
     // Instance variables to hold the values for command options.
-    bool m_global;
+    bool m_global = false;
     bool m_force;
   };
 
   void
   HandleArgumentCompletion(CompletionRequest &request,
                            OptionElementVector &opt_element_vector) override {
 
     const size_t argc = request.GetParsedLine().GetArgumentCount();

lldb/source/Commands/CommandObjectTarget.cpp

CommandObjectTargetModulesDumpSymtab(CommandInterpreter &interpreter)
         m_options() {}
 
   ~CommandObjectTargetModulesDumpSymtab() override = default;
 
   Options *GetOptions() override { return &m_options; }
 
   class CommandOptions : public Options {
   public:
-    CommandOptions() : Options(), m_sort_order(eSortOrderNone) {}
+    CommandOptions() : Options() {}
 
     ~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;
 
void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_sort_order = eSortOrderNone;
       m_prefer_mangled.Clear();
     }
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_target_modules_dump_symtab_options);
     }
 
-    SortOrder m_sort_order;
+    SortOrder m_sort_order = eSortOrderNone;
     OptionValueBoolean m_prefer_mangled = {false, false};
   };
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     Target *target = &GetSelectedTarget();
     uint32_t num_dumped = 0;
     Mangled::NamePreference name_preference =

 // List images with associated information
 #define LLDB_OPTIONS_target_modules_list
 #include "CommandOptions.inc"
 
 class CommandObjectTargetModulesList : public CommandObjectParsed {
 public:
   class CommandOptions : public Options {
   public:
-    CommandOptions()
-        : Options(), m_format_array(), m_use_global_module_list(false),
-          m_module_addr(LLDB_INVALID_ADDRESS) {}
+    CommandOptions() : Options(), m_format_array() {}
 
     ~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;
public:
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_target_modules_list_options);
     }
 
     // Instance variables to hold the values for command options.
     typedef std::vector<std::pair<char, uint32_t>> FormatWidthCollection;
     FormatWidthCollection m_format_array;
-    bool m_use_global_module_list;
-    lldb::addr_t m_module_addr;
+    bool m_use_global_module_list = false;
+    lldb::addr_t m_module_addr = LLDB_INVALID_ADDRESS;
   };
 
   CommandObjectTargetModulesList(CommandInterpreter &interpreter)
       : CommandObjectParsed(
             interpreter, "target modules list",
             "List current executable and dependent shared library images.",
             "target modules list [<cmd-options>]"),
         m_options() {}
enum {
     eLookupTypeSymbol,
     eLookupTypeFunction,
     eLookupTypeFunctionOrSymbol,
     kNumLookupTypes
   };
 
   class CommandOptions : public Options {
   public:
-    CommandOptions()
-        : Options(), m_type(eLookupTypeInvalid), m_str(),
-          m_addr(LLDB_INVALID_ADDRESS) {}
+    CommandOptions() : Options(), m_str() {}
 
     ~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;
public:
     }
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_target_modules_show_unwind_options);
     }
 
     // Instance variables to hold the values for command options.
 
-    int m_type;        // Should be a eLookupTypeXXX enum after parsing options
+    int m_type = eLookupTypeInvalid; // Should be a eLookupTypeXXX enum after
+                                     // parsing options
     std::string m_str; // Holds name lookup
-    lldb::addr_t m_addr; // Holds the address to lookup
+    lldb::addr_t m_addr = LLDB_INVALID_ADDRESS; // Holds the address to lookup
   };
 
   CommandObjectTargetModulesShowUnwind(CommandInterpreter &interpreter)
       : CommandObjectParsed(
             interpreter, "target modules show-unwind",
             "Show synthesized unwind instructions for a function.", nullptr,
             eCommandRequiresTarget | eCommandRequiresProcess |
                 eCommandProcessMustBeLaunched | eCommandProcessMustBePaused),

 #define LLDB_OPTIONS_target_stop_hook_add
 #include "CommandOptions.inc"
 
 class CommandObjectTargetStopHookAdd : public CommandObjectParsed,
                                        public IOHandlerDelegateMultiline {
 public:
   class CommandOptions : public OptionGroup {
   public:
-    CommandOptions()
-        : OptionGroup(), m_line_start(0), m_line_end(UINT_MAX),
-          m_func_name_type_mask(eFunctionNameTypeAuto),
-          m_sym_ctx_specified(false), m_thread_specified(false),
-          m_use_one_liner(false), m_one_liner() {}
+    CommandOptions() : OptionGroup(), m_line_end(UINT_MAX), m_one_liner() {}
 
     ~CommandOptions() override = default;
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_target_stop_hook_add_options);
     }
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
void OptionParsingStarting(ExecutionContext *execution_context) override {
 
       m_use_one_liner = false;
       m_one_liner.clear();
       m_auto_continue = false;
     }
 
     std::string m_class_name;
     std::string m_function_name;
-    uint32_t m_line_start;
+    uint32_t m_line_start = 0;
     uint32_t m_line_end;
     std::string m_file_name;
     std::string m_module_name;
-    uint32_t m_func_name_type_mask; // A pick from lldb::FunctionNameType.
+    uint32_t m_func_name_type_mask =
+        eFunctionNameTypeAuto; // A pick from lldb::FunctionNameType.
     lldb::tid_t m_thread_id;
     uint32_t m_thread_index;
     std::string m_thread_name;
     std::string m_queue_name;
-    bool m_sym_ctx_specified;
+    bool m_sym_ctx_specified = false;
     bool m_no_inlines;
-    bool m_thread_specified;
+    bool m_thread_specified = false;
     // Instance variables to hold the values for one_liner options.
-    bool m_use_one_liner;
+    bool m_use_one_liner = false;
     std::vector<std::string> m_one_liner;
 
     bool m_auto_continue;
   };
 
   CommandObjectTargetStopHookAdd(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "target stop-hook add",
                             "Add a hook to be executed when the target stops."

lldb/source/Commands/CommandObjectThread.cpp

 
 #define LLDB_OPTIONS_thread_until
 #include "CommandOptions.inc"
 
 class CommandObjectThreadUntil : public CommandObjectParsed {
 public:
   class CommandOptions : public Options {
   public:
-    uint32_t m_thread_idx;
-    uint32_t m_frame_idx;
+    uint32_t m_thread_idx = LLDB_INVALID_THREAD_ID;
+    uint32_t m_frame_idx = LLDB_INVALID_FRAME_ID;
 
-    CommandOptions()
-        : Options(), m_thread_idx(LLDB_INVALID_THREAD_ID),
-          m_frame_idx(LLDB_INVALID_FRAME_ID) {
+    CommandOptions() : Options() {
       // Keep default values of all options in one place: OptionParsingStarting
       // ()
       OptionParsingStarting(nullptr);
     }
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,

 // CommandObjectThreadReturn
 #define LLDB_OPTIONS_thread_return
 #include "CommandOptions.inc"
 
 class CommandObjectThreadReturn : public CommandObjectRaw {
 public:
   class CommandOptions : public Options {
   public:
-    CommandOptions() : Options(), m_from_expression(false) {
+    CommandOptions() : Options() {
       // Keep default values of all options in one place: OptionParsingStarting
       // ()
       OptionParsingStarting(nullptr);
     }
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
public:
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_from_expression = false;
     }
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_thread_return_options);
     }
 
-    bool m_from_expression;
+    bool m_from_expression = false;
 
     // Instance variables to hold the values for command options.
   };
 
   CommandObjectThreadReturn(CommandInterpreter &interpreter)
       : CommandObjectRaw(interpreter, "thread return",
                          "Prematurely return from a stack frame, "
                          "short-circuiting execution of newer frames "

lldb/source/Commands/CommandObjectType.cpp

lldb::LanguageType GuessLanguage(StackFrame *frame) {
     if (s)
       lang_type = s->GetMangled().GuessLanguage();
 
     return lang_type;
   }
 
   class CommandOptions : public OptionGroup {
   public:
-    CommandOptions()
-        : OptionGroup(), m_show_help(false), m_language(eLanguageTypeUnknown) {}
+    CommandOptions() : OptionGroup() {}
 
     ~CommandOptions() override = default;
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_type_lookup_options);
     }
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
public:
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_show_help = false;
       m_language = eLanguageTypeUnknown;
     }
 
     // Options table: Required for subclasses of Options.
 
-    bool m_show_help;
-    lldb::LanguageType m_language;
+    bool m_show_help = false;
+    lldb::LanguageType m_language = eLanguageTypeUnknown;
   };
 
   OptionGroupOptions m_option_group;
   CommandOptions m_command_options;
 
 public:
   CommandObjectTypeLookup(CommandInterpreter &interpreter)
       : CommandObjectRaw(interpreter, "type lookup",

lldb/source/Commands/CommandObjectWatchpoint.cpp

public:
   }
 
   ~CommandObjectWatchpointList() override = default;
 
   Options *GetOptions() override { return &m_options; }
 
   class CommandOptions : public Options {
   public:
-    CommandOptions()
-        : Options(),
-          m_level(lldb::eDescriptionLevelBrief) // Watchpoint List defaults to
-                                                // brief descriptions
-    {}
+    CommandOptions() : Options() {}
 
     ~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;
 
public:
     }
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_watchpoint_list_options);
     }
 
     // Instance variables to hold the values for command options.
 
-    lldb::DescriptionLevel m_level;
+    lldb::DescriptionLevel m_level = lldb::eDescriptionLevelBrief;
   };
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     Target *target = &GetSelectedTarget();
 
     if (target->GetProcessSP() && target->GetProcessSP()->IsAlive()) {
       uint32_t num_supported_hardware_watchpoints;
CommandCompletions::InvokeCommonCompletionCallbacks(
         GetCommandInterpreter(), CommandCompletions::eWatchPointIDCompletion,
         request, nullptr);
   }
 
   Options *GetOptions() override { return &m_options; }
 
   class CommandOptions : public Options {
   public:
-    CommandOptions() : Options(), m_force(false) {}
+    CommandOptions() : Options() {}
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       const int short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_force = false;
     }
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_watchpoint_delete_options);
     }
 
     // Instance variables to hold the values for command options.
-    bool m_force;
+    bool m_force = false;
   };
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     Target *target = &GetSelectedTarget();
     if (!CheckTargetForWatchpointOperations(target, result))
       return false;
 
CommandCompletions::InvokeCommonCompletionCallbacks(
         GetCommandInterpreter(), CommandCompletions::eWatchPointIDCompletion,
         request, nullptr);
   }
 
   Options *GetOptions() override { return &m_options; }
 
   class CommandOptions : public Options {
   public:
-    CommandOptions() : Options(), m_ignore_count(0) {}
+    CommandOptions() : Options() {}
 
     ~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;
 
public:
     }
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_watchpoint_ignore_options);
     }
 
     // Instance variables to hold the values for command options.
 
-    uint32_t m_ignore_count;
+    uint32_t m_ignore_count = 0;
   };
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     Target *target = &GetSelectedTarget();
     if (!CheckTargetForWatchpointOperations(target, result))
       return false;
 
CommandCompletions::InvokeCommonCompletionCallbacks(
         GetCommandInterpreter(), CommandCompletions::eWatchPointIDCompletion,
         request, nullptr);
   }
 
   Options *GetOptions() override { return &m_options; }
 
   class CommandOptions : public Options {
   public:
-    CommandOptions() : Options(), m_condition(), m_condition_passed(false) {}
+    CommandOptions() : Options(), m_condition() {}
 
     ~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;
 
public:
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_watchpoint_modify_options);
     }
 
     // Instance variables to hold the values for command options.
 
     std::string m_condition;
-    bool m_condition_passed;
+    bool m_condition_passed = false;
   };
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     Target *target = &GetSelectedTarget();
     if (!CheckTargetForWatchpointOperations(target, result))
       return false;
 

lldb/source/Commands/CommandObjectWatchpointCommand.cpp

if (commands.GetSize() > 0) {
         result.GetImmediateErrorStream()->Flush();
       }
     }
     return ret_value;
   }
 
   class CommandOptions : public Options {
   public:
-    CommandOptions()
-        : Options(), m_use_commands(false), m_use_script_language(false),
-          m_script_language(eScriptLanguageNone), m_use_one_liner(false),
-          m_one_liner(), m_function_name() {}
+    CommandOptions() : Options(), m_one_liner(), m_function_name() {}
 
     ~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;
 
public:
     }
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_watchpoint_command_add_options);
     }
 
     // Instance variables to hold the values for command options.
 
-    bool m_use_commands;
-    bool m_use_script_language;
-    lldb::ScriptLanguage m_script_language;
+    bool m_use_commands = false;
+    bool m_use_script_language = false;
+    lldb::ScriptLanguage m_script_language = eScriptLanguageNone;
 
     // Instance variables to hold the values for one_liner options.
-    bool m_use_one_liner;
+    bool m_use_one_liner = false;
     std::string m_one_liner;
     bool m_stop_on_error;
     std::string m_function_name;
   };
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     Target *target = &GetSelectedTarget();

lldb/source/Core/AddressRange.cpp

 
 namespace lldb_private {
 class SectionList;
 }
 
 using namespace lldb;
 using namespace lldb_private;
 
-AddressRange::AddressRange() : m_base_addr(), m_byte_size(0) {}
+AddressRange::AddressRange() : m_base_addr() {}
 
 AddressRange::AddressRange(addr_t file_addr, addr_t byte_size,
                            const SectionList *section_list)
     : m_base_addr(file_addr, section_list), m_byte_size(byte_size) {}
 
 AddressRange::AddressRange(const lldb::SectionSP &section, addr_t offset,
                            addr_t byte_size)
     : m_base_addr(section, offset), m_byte_size(byte_size) {}

lldb/source/Core/IOHandlerCursesGUI.cpp

protected:
   std::shared_ptr<ThreadTreeDelegate> m_thread_delegate_sp;
   Debugger &m_debugger;
   uint32_t m_stop_id;
   FormatEntity::Entry m_format;
 };
 
 class ValueObjectListDelegate : public WindowDelegate {
 public:
-  ValueObjectListDelegate()
-      : m_rows(), m_selected_row(nullptr), m_selected_row_idx(0),
-        m_first_visible_row(0), m_num_rows(0), m_max_x(0), m_max_y(0) {}
+  ValueObjectListDelegate() : m_rows() {}
 
   ValueObjectListDelegate(ValueObjectList &valobj_list)
       : m_rows(), m_selected_row(nullptr), m_selected_row_idx(0),
         m_first_visible_row(0), m_num_rows(0), m_max_x(0), m_max_y(0) {
     SetValues(valobj_list);
   }
 
   ~ValueObjectListDelegate() override = default;
HandleCharResult WindowDelegateHandleChar(Window &window, int c) override {
     default:
       break;
     }
     return eKeyNotHandled;
   }
 
 protected:
   std::vector<Row> m_rows;
-  Row *m_selected_row;
-  uint32_t m_selected_row_idx;
-  uint32_t m_first_visible_row;
-  uint32_t m_num_rows;
+  Row *m_selected_row = nullptr;
+  uint32_t m_selected_row_idx = 0;
+  uint32_t m_first_visible_row = 0;
+  uint32_t m_num_rows = 0;
   int m_min_x;
   int m_min_y;
-  int m_max_x;
-  int m_max_y;
+  int m_max_x = 0;
+  int m_max_y = 0;
 
   static Format FormatForChar(int c) {
     switch (c) {
     case 'x':
       return eFormatHex;
     case 'X':
       return eFormatHexUppercase;
     case 'o':

lldb/source/Core/Module.cpp

Module::Module(const FileSpec &file_spec, const ArchSpec &arch,
   if (log != nullptr)
     LLDB_LOGF(log, "%p Module::Module((%s) '%s%s%s%s')",
               static_cast<void *>(this), m_arch.GetArchitectureName(),
               m_file.GetPath().c_str(), m_object_name.IsEmpty() ? "" : "(",
               m_object_name.IsEmpty() ? "" : m_object_name.AsCString(""),
               m_object_name.IsEmpty() ? "" : ")");
 }
 
-Module::Module()
-    : m_object_offset(0), m_file_has_changed(false),
-      m_first_file_changed_log(false) {
+Module::Module() : m_file_has_changed(false), m_first_file_changed_log(false) {
   std::lock_guard<std::recursive_mutex> guard(
       GetAllocationModuleCollectionMutex());
   GetModuleCollection().push_back(this);
 }
 
 Module::~Module() {
   // Lock our module down while we tear everything down to make sure we don't
   // get any access to the module while it is being destroyed

lldb/source/Core/ModuleList.cpp

void ModuleListProperties::UpdateSymlinkMappings() {
   }
 }
 
 PathMappingList ModuleListProperties::GetSymlinkMappings() const {
   llvm::sys::ScopedReader lock(m_symlink_paths_mutex);
   return m_symlink_paths;
 }
 
-ModuleList::ModuleList()
-    : m_modules(), m_modules_mutex(), m_notifier(nullptr) {}
+ModuleList::ModuleList() : m_modules(), m_modules_mutex() {}
 
 ModuleList::ModuleList(const ModuleList &rhs)
     : m_modules(), m_modules_mutex(), m_notifier(nullptr) {
   std::lock_guard<std::recursive_mutex> lhs_guard(m_modules_mutex);
   std::lock_guard<std::recursive_mutex> rhs_guard(rhs.m_modules_mutex);
   m_modules = rhs.m_modules;
 }
 

lldb/source/Core/PluginManager.cpp

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

lldb/source/Core/Value.cpp

 #include <memory>
 #include <string>
 
 #include <cinttypes>
 
 using namespace lldb;
 using namespace lldb_private;
 
-Value::Value()
-    : m_value(), m_compiler_type(), m_context(nullptr),
-      m_value_type(ValueType::Scalar), m_context_type(ContextType::Invalid),
-      m_data_buffer() {}
+Value::Value() : m_value(), m_compiler_type(), m_data_buffer() {}
 
 Value::Value(const Scalar &scalar)
     : m_value(scalar), m_compiler_type(), m_context(nullptr),
       m_value_type(ValueType::Scalar), m_context_type(ContextType::Invalid),
       m_data_buffer() {}
 
 Value::Value(const void *bytes, int len)
     : m_value(), m_compiler_type(), m_context(nullptr),

lldb/source/Core/ValueObject.cpp

if (ptr_value != LLDB_INVALID_ADDRESS) {
     Address ptr_addr(ptr_value);
     ExecutionContext exe_ctx(GetExecutionContextRef());
     valobj_sp = ValueObjectMemory::Create(
         exe_ctx.GetBestExecutionContextScope(), name, ptr_addr, type_sp);
   }
   return valobj_sp;
 }
 
-ValueObject::EvaluationPoint::EvaluationPoint()
-    : m_mod_id(), m_exe_ctx_ref(), m_needs_update(true) {}
+ValueObject::EvaluationPoint::EvaluationPoint() : m_mod_id(), m_exe_ctx_ref() {}
 
 ValueObject::EvaluationPoint::EvaluationPoint(ExecutionContextScope *exe_scope,
                                               bool use_selected)
     : m_mod_id(), m_exe_ctx_ref(), m_needs_update(true) {
   ExecutionContext exe_ctx(exe_scope);
   TargetSP target_sp(exe_ctx.GetTargetSP());
   if (target_sp) {
     m_exe_ctx_ref.SetTargetSP(target_sp);

lldb/source/DataFormatters/TypeFormat.cpp

 #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), m_my_revision(0) {}
+TypeFormatImpl::TypeFormatImpl(const Flags &flags) : m_flags(flags) {}
 
 TypeFormatImpl::~TypeFormatImpl() {}
 
 TypeFormatImpl_Format::TypeFormatImpl_Format(lldb::Format f,
                                              const TypeFormatImpl::Flags &flags)
     : TypeFormatImpl(flags), m_format(f) {}
 
 TypeFormatImpl_Format::~TypeFormatImpl_Format() {}

lldb/source/DataFormatters/TypeSummary.cpp

 #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()
-    : m_lang(eLanguageTypeUnknown), m_capping(eTypeSummaryCapped) {}
+TypeSummaryOptions::TypeSummaryOptions() {}
 
 lldb::LanguageType TypeSummaryOptions::GetLanguage() const { return m_lang; }
 
 lldb::TypeSummaryCapping TypeSummaryOptions::GetCapping() const {
   return m_capping;
 }
 
 TypeSummaryOptions &TypeSummaryOptions::SetLanguage(lldb::LanguageType lang) {

lldb/source/Expression/DWARFExpression.cpp

ReadAddressFromDebugAddrSection(const DWARFUnit *dwarf_cu,
   const DWARFDataExtractor &data =
       dwarf_cu->GetSymbolFileDWARF().GetDWARFContext().getOrLoadAddrData();
   if (data.ValidOffsetForDataOfSize(offset, index_size))
     return data.GetMaxU64_unchecked(&offset, index_size);
   return LLDB_INVALID_ADDRESS;
 }
 
 // DWARFExpression constructor
-DWARFExpression::DWARFExpression()
-    : m_module_wp(), m_data(), m_dwarf_cu(nullptr),
-      m_reg_kind(eRegisterKindDWARF) {}
+DWARFExpression::DWARFExpression() : m_module_wp(), m_data() {}
 
 DWARFExpression::DWARFExpression(lldb::ModuleSP module_sp,
                                  const DataExtractor &data,
                                  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;

lldb/source/Host/common/FileAction.cpp

 #include "lldb/Host/FileAction.h"
 #include "lldb/Host/PosixApi.h"
 #include "lldb/Utility/Stream.h"
 
 using namespace lldb_private;
 
 // FileAction member functions
 
-FileAction::FileAction()
-    : m_action(eFileActionNone), m_fd(-1), m_arg(-1), m_file_spec() {}
+FileAction::FileAction() : m_file_spec() {}
 
 void FileAction::Clear() {
   m_action = eFileActionNone;
   m_fd = -1;
   m_arg = -1;
   m_file_spec.Clear();
 }
 

lldb/source/Host/common/Host.cpp

 
 #if !defined(__linux__)
 bool Host::FindProcessThreads(const lldb::pid_t pid, TidMap &tids_to_attach) {
   return false;
 }
 #endif
 
 struct ShellInfo {
-  ShellInfo()
-      : process_reaped(false), pid(LLDB_INVALID_PROCESS_ID), signo(-1),
-        status(-1) {}
+  ShellInfo() : process_reaped(false) {}
 
   lldb_private::Predicate<bool> process_reaped;
-  lldb::pid_t pid;
-  int signo;
-  int status;
+  lldb::pid_t pid = LLDB_INVALID_PROCESS_ID;
+  int signo = -1;
+  int status = -1;
 };
 
 static bool
 MonitorShellCommand(std::shared_ptr<ShellInfo> shell_info, lldb::pid_t pid,
                     bool exited, // True if the process did exit
                     int signo,   // Zero for no signal
                     int status)  // Exit value of process if signal is zero
 {

lldb/source/Host/common/HostNativeThreadBase.cpp

 
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/Threading.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 HostNativeThreadBase::HostNativeThreadBase()
-    : m_thread(LLDB_INVALID_HOST_THREAD), m_result(0) {}
+    : m_thread(LLDB_INVALID_HOST_THREAD) {}
 
 HostNativeThreadBase::HostNativeThreadBase(thread_t thread)
     : m_thread(thread), m_result(0) {}
 
 lldb::thread_t HostNativeThreadBase::GetSystemHandle() const {
   return m_thread;
 }
 

lldb/source/Host/common/ProcessLaunchInfo.cpp

 
 using namespace lldb;
 using namespace lldb_private;
 
 // ProcessLaunchInfo member functions
 
 ProcessLaunchInfo::ProcessLaunchInfo()
     : ProcessInfo(), m_working_dir(), m_plugin_name(), m_flags(0),
-      m_file_actions(), m_pty(new PseudoTerminal), m_resume_count(0),
-      m_monitor_callback(nullptr), m_monitor_callback_baton(nullptr),
-      m_monitor_signals(false), m_listener_sp(), m_hijack_listener_sp(),
-      m_scripted_process_class_name(), m_scripted_process_dictionary_sp() {}
+      m_file_actions(), m_pty(new PseudoTerminal), m_monitor_callback(nullptr),
+      m_listener_sp(), m_hijack_listener_sp(), m_scripted_process_class_name(),
+      m_scripted_process_dictionary_sp() {}
 
 ProcessLaunchInfo::ProcessLaunchInfo(const FileSpec &stdin_file_spec,
                                      const FileSpec &stdout_file_spec,
                                      const FileSpec &stderr_file_spec,
                                      const FileSpec &working_directory,
                                      uint32_t launch_flags)
     : ProcessInfo(), m_working_dir(), m_plugin_name(), m_flags(launch_flags),
       m_file_actions(), m_pty(new PseudoTerminal), m_resume_count(0),

lldb/source/Host/common/ProcessRunLock.cpp

 //===-- ProcessRunLock.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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _WIN32
 #include "lldb/Host/ProcessRunLock.h"
 
 namespace lldb_private {
 
-ProcessRunLock::ProcessRunLock() : m_running(false) {
+ProcessRunLock::ProcessRunLock() {
   int err = ::pthread_rwlock_init(&m_rwlock, nullptr);
   (void)err;
 }
 
 ProcessRunLock::~ProcessRunLock() {
   int err = ::pthread_rwlock_destroy(&m_rwlock);
   (void)err;
 }

lldb/source/Host/common/PseudoTerminal.cpp

 
 #if defined(__ANDROID__)
 int posix_openpt(int flags);
 #endif
 
 using namespace lldb_private;
 
 // PseudoTerminal constructor
-PseudoTerminal::PseudoTerminal()
-    : m_primary_fd(invalid_fd), m_secondary_fd(invalid_fd) {}
+PseudoTerminal::PseudoTerminal() {}
 
 // 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/Terminal.cpp

#if LLDB_ENABLE_TERMIOS
     }
 #endif // #if LLDB_ENABLE_TERMIOS
   }
   return false;
 }
 
 // Default constructor
 TerminalState::TerminalState()
-    : m_tty(), m_tflags(-1),
+    : m_tty()
 #if LLDB_ENABLE_TERMIOS
-      m_termios_up(),
+      ,
+      m_termios_up()
 #endif
-      m_process_group(-1) {
+{
 }
 
 // Destructor
 TerminalState::~TerminalState() {}
 
 void TerminalState::Clear() {
   m_tty.Clear();
   m_tflags = -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() : m_currentState(UINT32_MAX) {}
+TerminalStateSwitcher::TerminalStateSwitcher() {}
 
 // Destructor
 TerminalStateSwitcher::~TerminalStateSwitcher() {}
 
 // Returns the number of states that this switcher contains
 uint32_t TerminalStateSwitcher::GetNumberOfStates() const {
   return llvm::array_lengthof(m_ttystates);
 }

lldb/source/Host/common/XML.cpp

 #include "lldb/Host/StringConvert.h"
 #include "lldb/Host/XML.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 #pragma mark-- XMLDocument
 
-XMLDocument::XMLDocument() : m_document(nullptr) {}
+XMLDocument::XMLDocument() {}
 
 XMLDocument::~XMLDocument() { Clear(); }
 
 void XMLDocument::Clear() {
 #if LLDB_ENABLE_LIBXML2
   if (m_document) {
     xmlDocPtr doc = m_document;
     m_document = nullptr;
#if LLDB_ENABLE_LIBXML2
   return true;
 #else
   return false;
 #endif
 }
 
 #pragma mark-- XMLNode
 
-XMLNode::XMLNode() : m_node(nullptr) {}
+XMLNode::XMLNode() {}
 
 XMLNode::XMLNode(XMLNodeImpl node) : m_node(node) {}
 
 XMLNode::~XMLNode() {}
 
 void XMLNode::Clear() { m_node = nullptr; }
 
 XMLNode XMLNode::GetParent() const {

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

 
 namespace {
 
 pthread_once_t g_thread_create_once = PTHREAD_ONCE_INIT;
 pthread_key_t g_thread_create_key = 0;
 
 class MacOSXDarwinThread {
 public:
-  MacOSXDarwinThread() : m_pool(nil) {
-    m_pool = [[NSAutoreleasePool alloc] init];
-  }
+  MacOSXDarwinThread() { m_pool = [[NSAutoreleasePool alloc] init]; }
 
   ~MacOSXDarwinThread() {
     if (m_pool) {
       [m_pool drain];
       m_pool = nil;
     }
   }
 
   static void PThreadDestructor(void *v) {
     if (v)
       delete static_cast<MacOSXDarwinThread *>(v);
     ::pthread_setspecific(g_thread_create_key, NULL);
   }
 
 protected:
-  NSAutoreleasePool *m_pool;
+  NSAutoreleasePool *m_pool = nil;
 
 private:
   MacOSXDarwinThread(const MacOSXDarwinThread &) = delete;
   const MacOSXDarwinThread &operator=(const MacOSXDarwinThread &) = delete;
 };
 
 void InitThreadCreated() {
   ::pthread_key_create(&g_thread_create_key,

lldb/source/Host/posix/ConnectionFileDescriptorPosix.cpp

llvm::Optional<llvm::StringRef> GetURLAddress(llvm::StringRef url,
   if (!url.consume_front("://"))
     return llvm::None;
   return url;
 }
 }
 
 ConnectionFileDescriptor::ConnectionFileDescriptor(bool child_processes_inherit)
     : Connection(), m_pipe(), m_mutex(), m_shutting_down(false),
-      m_waiting_for_accept(false),
+
       m_child_processes_inherit(child_processes_inherit) {
   Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_CONNECTION |
                                                   LIBLLDB_LOG_OBJECT));
   LLDB_LOGF(log, "%p ConnectionFileDescriptor::ConnectionFileDescriptor ()",
             static_cast<void *>(this));
 }
 
 ConnectionFileDescriptor::ConnectionFileDescriptor(int fd, bool owns_fd)

lldb/source/Initialization/SystemLifetimeManager.cpp

 
 #include "lldb/Core/Debugger.h"
 #include "lldb/Initialization/SystemInitializer.h"
 
 #include <utility>
 
 using namespace lldb_private;
 
-SystemLifetimeManager::SystemLifetimeManager()
-    : m_mutex(), m_initialized(false) {}
+SystemLifetimeManager::SystemLifetimeManager() : m_mutex() {}
 
 SystemLifetimeManager::~SystemLifetimeManager() {
   assert(!m_initialized &&
          "SystemLifetimeManager destroyed without calling Terminate!");
 }
 
 llvm::Error SystemLifetimeManager::Initialize(
     std::unique_ptr<SystemInitializer> initializer,

lldb/source/Interpreter/OptionValueFileColonLine.cpp

 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()
-    : m_line_number(LLDB_INVALID_LINE_NUMBER),
-      m_column_number(LLDB_INVALID_COLUMN_NUMBER),
-      m_completion_mask(CommandCompletions::eSourceFileCompletion) {}
+
+{}
 
 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);
 }
 

lldb/source/Interpreter/OptionValueFileSpec.cpp

 #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;
 
-OptionValueFileSpec::OptionValueFileSpec(bool resolve)
-    : m_completion_mask(CommandCompletions::eDiskFileCompletion),
-      m_resolve(resolve) {}
+OptionValueFileSpec::OptionValueFileSpec(bool resolve) : m_resolve(resolve) {}
 
 OptionValueFileSpec::OptionValueFileSpec(const FileSpec &value, bool resolve)
     : m_current_value(value), m_default_value(value),
       m_completion_mask(CommandCompletions::eDiskFileCompletion),
       m_resolve(resolve) {}
 
 OptionValueFileSpec::OptionValueFileSpec(const FileSpec &current_value,
                                          const FileSpec &default_value,

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

protected:
   // of memory at the start of a kernel session.  But we should build up /
   // maintain a
   // list of kexts that the kernel has told us about so we can relocate a kext
   // module
   // later if the user explicitly adds it to the target.
 
   class KextImageInfo {
   public:
-    KextImageInfo()
-        : m_name(), m_module_sp(), m_memory_module_sp(),
-          m_load_process_stop_id(UINT32_MAX), m_uuid(),
-          m_load_address(LLDB_INVALID_ADDRESS), m_size(0),
-          m_kernel_image(false) {}
+    KextImageInfo() : m_name(), m_module_sp(), m_memory_module_sp(), m_uuid() {}
 
     void Clear() {
       m_load_address = LLDB_INVALID_ADDRESS;
       m_size = 0;
       m_name.clear();
       m_uuid.Clear();
       m_module_sp.reset();
       m_memory_module_sp.reset();
public:
     typedef std::vector<KextImageInfo> collection;
     typedef collection::iterator iterator;
     typedef collection::const_iterator const_iterator;
 
   private:
     std::string m_name;
     lldb::ModuleSP m_module_sp;
     lldb::ModuleSP m_memory_module_sp;
-    uint32_t m_load_process_stop_id; // the stop-id when this module was added
-                                     // to the Target
+    uint32_t m_load_process_stop_id =
+        UINT32_MAX; // the stop-id when this module was added
     lldb_private::UUID
         m_uuid; // UUID for this dylib if it has one, else all zeros
-    lldb::addr_t m_load_address;
-    uint64_t m_size;
-    bool m_kernel_image; // true if this is the kernel, false if this is a kext
+    lldb::addr_t m_load_address = LLDB_INVALID_ADDRESS;
+    uint64_t m_size = 0;
+    bool m_kernel_image =
+        false; // true if this is the kernel, false if this is a kext
   };
 
   struct OSKextLoadedKextSummaryHeader {
-    uint32_t version;
-    uint32_t entry_size;
-    uint32_t entry_count;
-    lldb::addr_t image_infos_addr;
+    uint32_t version = 0;
+    uint32_t entry_size = 0;
+    uint32_t entry_count = 0;
+    lldb::addr_t image_infos_addr = LLDB_INVALID_ADDRESS;
 
     OSKextLoadedKextSummaryHeader()
-        : version(0), entry_size(0), entry_count(0),
-          image_infos_addr(LLDB_INVALID_ADDRESS) {}
+
+    {}
 
     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:

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

 /// snapshot of the currently loaded modules.
 class HexagonDYLDRendezvous {
 
   // This structure is used to hold the contents of the debug rendezvous
   // information (struct r_debug) as found in the inferiors memory.  Note that
   // the layout of this struct is not binary compatible, it is simply large
   // enough to hold the information on both 32 and 64 bit platforms.
   struct Rendezvous {
-    uint64_t version;
-    lldb::addr_t map_addr;
-    lldb::addr_t brk;
-    uint64_t state;
-    lldb::addr_t ldbase;
-
-    Rendezvous()
-        : version(0), map_addr(LLDB_INVALID_ADDRESS), brk(LLDB_INVALID_ADDRESS),
-          state(0), ldbase(0) {}
+    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() {}
   };
 
 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.h

protected:
   virtual void DoClear() = 0;
 
   void SetDYLDModule(lldb::ModuleSP &dyld_module_sp);
 
   lldb::ModuleSP GetDYLDModule();
 
   class Segment {
   public:
-    Segment()
-        : name(), vmaddr(LLDB_INVALID_ADDRESS), vmsize(0), fileoff(0),
-          filesize(0), maxprot(0), initprot(0), nsects(0), flags(0) {}
+    Segment() : name() {}
 
     lldb_private::ConstString name;
-    lldb::addr_t vmaddr;
-    lldb::addr_t vmsize;
-    lldb::addr_t fileoff;
-    lldb::addr_t filesize;
-    uint32_t maxprot;
-    uint32_t initprot;
-    uint32_t nsects;
-    uint32_t flags;
+    lldb::addr_t vmaddr = LLDB_INVALID_ADDRESS;
+    lldb::addr_t vmsize = 0;
+    lldb::addr_t fileoff = 0;
+    lldb::addr_t filesize = 0;
+    uint32_t maxprot = 0;
+    uint32_t initprot = 0;
+    uint32_t nsects = 0;
+    uint32_t flags = 0;
 
     bool operator==(const Segment &rhs) const {
       return name == rhs.name && vmaddr == rhs.vmaddr && vmsize == rhs.vmsize;
     }
 
     void PutToLog(lldb_private::Log *log, lldb::addr_t slide) const;
   };
 

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

protected:
   bool ReadMachHeader(lldb::addr_t addr, llvm::MachO::mach_header *header,
                       lldb_private::DataExtractor *load_command_data);
 
   uint32_t ParseLoadCommands(const lldb_private::DataExtractor &data,
                              ImageInfo &dylib_info,
                              lldb_private::FileSpec *lc_id_dylinker);
 
   struct DYLDAllImageInfos {
-    uint32_t version;
-    uint32_t dylib_info_count;            // Version >= 1
-    lldb::addr_t dylib_info_addr;         // Version >= 1
-    lldb::addr_t notification;            // Version >= 1
-    bool processDetachedFromSharedRegion; // Version >= 1
-    bool libSystemInitialized;            // Version >= 2
-    lldb::addr_t dyldImageLoadAddress;    // Version >= 2
+    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()
-        : version(0), dylib_info_count(0),
-          dylib_info_addr(LLDB_INVALID_ADDRESS),
-          notification(LLDB_INVALID_ADDRESS),
-          processDetachedFromSharedRegion(false), libSystemInitialized(false),
-          dyldImageLoadAddress(LLDB_INVALID_ADDRESS) {}
+
+    {}
 
     void Clear() {
       version = 0;
       dylib_info_count = 0;
       dylib_info_addr = LLDB_INVALID_ADDRESS;
       notification = LLDB_INVALID_ADDRESS;
       processDetachedFromSharedRegion = false;
       libSystemInitialized = false;

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

 /// snapshot of the currently loaded modules.
 class DYLDRendezvous {
 
   // This structure is used to hold the contents of the debug rendezvous
   // information (struct r_debug) as found in the inferiors memory.  Note that
   // the layout of this struct is not binary compatible, it is simply large
   // enough to hold the information on both 32 and 64 bit platforms.
   struct Rendezvous {
-    uint64_t version;
-    lldb::addr_t map_addr;
-    lldb::addr_t brk;
-    uint64_t state;
-    lldb::addr_t ldbase;
+    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() : version(0), map_addr(0), brk(0), state(0), ldbase(0) {}
+    Rendezvous() {}
   };
 
 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/ExpressionParser/Clang/ClangASTImporter.h

void InstallMapCompleter(clang::ASTContext *dst_ctx,
 
     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() : ctx(nullptr), decl(nullptr) {}
+    DeclOrigin() {}
 
     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) {
       ctx = rhs.ctx;
       decl = rhs.decl;
     }
 
     void operator=(const DeclOrigin &rhs) {
       ctx = rhs.ctx;
       decl = rhs.decl;
     }
 
     bool Valid() const { return (ctx != nullptr || decl != nullptr); }
 
-    clang::ASTContext *ctx;
-    clang::Decl *decl;
+    clang::ASTContext *ctx = nullptr;
+    clang::Decl *decl = nullptr;
   };
 
   /// Listener interface used by the ASTImporterDelegate to inform other code
   /// about decls that have been imported the first time.
   struct NewDeclListener {
     virtual ~NewDeclListener() = default;
     /// A decl has been imported for the first time.
     virtual void NewDeclImported(clang::Decl *from, clang::Decl *to) = 0;

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

public:
   lldb::addr_t GetSymbolAddress(Target &target, Process *process,
                                 ConstString name, lldb::SymbolType symbol_type,
                                 Module *module = nullptr);
 
   lldb::addr_t GetSymbolAddress(ConstString name,
                                 lldb::SymbolType symbol_type);
 
   struct TargetInfo {
-    lldb::ByteOrder byte_order;
-    size_t address_byte_size;
+    lldb::ByteOrder byte_order = lldb::eByteOrderInvalid;
+    size_t address_byte_size = 0;
 
-    TargetInfo() : byte_order(lldb::eByteOrderInvalid), address_byte_size(0) {}
+    TargetInfo() {}
 
     bool IsValid() {
       return (byte_order != lldb::eByteOrderInvalid && address_byte_size != 0);
     }
   };
   TargetInfo GetTargetInfo();
 
   /// [Used by ClangASTSource] Find all entities matching a given name, using
private:
   }
 
   /// Deallocate parser-specific variables
   void DisableParserVars() { m_parser_vars.reset(); }
 
   /// The following values contain layout information for the materialized
   /// struct, but are not specific to a single materialization
   struct StructVars {
-    StructVars()
-        : m_struct_alignment(0), m_struct_size(0), m_struct_laid_out(false),
-          m_result_name(), m_object_pointer_type(nullptr, nullptr) {}
-
-    lldb::offset_t
-        m_struct_alignment; ///< The alignment of the struct in bytes.
-    size_t m_struct_size;   ///< The size of the struct in bytes.
-    bool m_struct_laid_out; ///< True if the struct has been laid out and the
-                            ///layout is valid (that is, no new fields have been
-                            ///added since).
+    StructVars() : m_result_name(), m_object_pointer_type(nullptr, nullptr) {}
+
+    lldb::offset_t m_struct_alignment =
+        0;                    ///< The alignment of the struct in bytes.
+    size_t m_struct_size = 0; ///< The size of the struct in bytes.
+    bool m_struct_laid_out =
+        false; ///< True if the struct has been laid out and the
+               /// layout is valid (that is, no new fields have been
+               /// added since).
     ConstString
         m_result_name; ///< The name of the result variable ($1, for example)
     TypeFromUser m_object_pointer_type; ///< The type of the "this" variable, if
                                         ///one exists
   };
 
   std::unique_ptr<StructVars> m_struct_vars;
 

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

public:
   /// \return
   ///     True on success; false otherwise (in particular, if this variable
   ///     does not contain its own data).
   bool PointValueAtData(Value &value, ExecutionContext *exe_ctx);
 
   /// The following values should not live beyond parsing
   class ParserVars {
   public:
-    ParserVars()
-        : m_named_decl(nullptr), m_llvm_value(nullptr),
-          m_lldb_value(), m_lldb_var(), m_lldb_sym(nullptr) {}
-
-    const clang::NamedDecl
-        *m_named_decl;         ///< The Decl corresponding to this variable
-    llvm::Value *m_llvm_value; ///< The IR value corresponding to this variable;
-                               ///usually a GlobalValue
+    ParserVars() : m_lldb_value(), m_lldb_var() {}
+
+    const clang::NamedDecl *m_named_decl =
+        nullptr; ///< The Decl corresponding to this variable
+    llvm::Value *m_llvm_value =
+        nullptr; ///< The IR value corresponding to this variable;
+                 /// usually a GlobalValue
     lldb_private::Value
         m_lldb_value;            ///< The value found in LLDB for this variable
     lldb::VariableSP m_lldb_var; ///< The original variable for this variable
-    const lldb_private::Symbol *m_lldb_sym; ///< The original symbol for this
-                                            ///variable, if it was a symbol
+    const lldb_private::Symbol *m_lldb_sym =
+        nullptr; ///< The original symbol for this
+                 /// variable, if it was a symbol
   };
 
 private:
   typedef std::map<uint64_t, ParserVars> ParserVarMap;
   ParserVarMap m_parser_vars;
 
 public:
   /// Make this variable usable by the parser by allocating space for parser-
ParserVars *GetParserVars(uint64_t parser_id) {
     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() : m_alignment(0), m_size(0), m_offset(0) {}
+    JITVars() {}
 
-    lldb::offset_t
-        m_alignment; ///< The required alignment of the variable, in bytes
-    size_t m_size;   ///< The space required for the variable, in bytes
-    lldb::offset_t
-        m_offset; ///< The offset of the variable in the struct, in bytes
+    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
   };
 
 private:
   typedef std::map<uint64_t, JITVars> JITVarMap;
   JITVarMap m_jit_vars;
 
 public:
   /// Make this variable usable for materializing for the JIT by allocating

lldb/source/Plugins/Instruction/ARM/EmulateInstructionARM.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() : ITCounter(0), ITState(0) {}
+  ITSession() {}
   ~ITSession() {}
 
   // 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.
   bool InITBlock();
 
   // LastInITBlock - Returns true if we're the last instruction inside an IT
   // Block.
   bool LastInITBlock();
 
   // GetCond - Gets condition bits for the current thumb instruction.
   uint32_t GetCond();
 
 private:
-  uint32_t ITCounter; // Possible values: 0, 1, 2, 3, 4.
-  uint32_t ITState;   // A2.5.2 Consists of IT[7:5] and IT[4:0] initially.
+  uint32_t ITCounter = 0; // Possible values: 0, 1, 2, 3, 4.
+  uint32_t ITState = 0;   // A2.5.2 Consists of IT[7:5] and IT[4:0] initially.
 };
 
 class EmulateInstructionARM : public EmulateInstruction {
 public:
   enum ARMEncoding {
     eEncodingA1,
     eEncodingA2,
     eEncodingA3,

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

public:
   static bool
   WritePseudoRegister(lldb_private::EmulateInstruction *instruction,
                       void *baton,
                       const lldb_private::EmulateInstruction::Context &context,
                       const lldb_private::RegisterInfo *reg_info,
                       const lldb_private::RegisterValue &reg_value);
 
 private:
-  uint32_t m_gpr[17];
+  uint32_t m_gpr[17] = {0};
   struct _sd_regs {
     uint32_t s_regs[32]; // sregs 0 - 31 & dregs 0 - 15
 
     uint64_t d_regs[16]; // dregs 16-31
 
   } m_vfp_regs;
 
   std::map<lldb::addr_t, uint32_t> m_memory; // Eventually will want to change
                                              // uint32_t to a data buffer heap
                                              // type.
 
   EmulationStateARM(const EmulationStateARM &) = delete;
   const EmulationStateARM &operator=(const EmulationStateARM &) = delete;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_INSTRUCTION_ARM_EMULATIONSTATEARM_H

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

 #include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/Scalar.h"
 
 #include "Utility/ARM_DWARF_Registers.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-EmulationStateARM::EmulationStateARM() : m_gpr(), m_vfp_regs(), m_memory() {
+EmulationStateARM::EmulationStateARM() : m_vfp_regs(), m_memory() {
   ClearPseudoRegisters();
 }
 
 EmulationStateARM::~EmulationStateARM() {}
 
 bool EmulationStateARM::LoadPseudoRegistersFromFrame(StackFrame &frame) {
   RegisterContext *reg_ctx = frame.GetRegisterContext().get();
   bool success = true;

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

 
 class CPlusPlusLanguage : public Language {
   ClangHighlighter m_highlighter;
 
 public:
   class MethodName {
   public:
     MethodName()
-        : m_full(), m_basename(), m_context(), m_arguments(), m_qualifiers(),
-          m_parsed(false), m_parse_error(false) {}
+        : m_full(), m_basename(), m_context(), m_arguments(), m_qualifiers() {}
 
     MethodName(ConstString s)
         : m_full(s), m_basename(), m_context(), m_arguments(), m_qualifiers(),
           m_parsed(false), m_parse_error(false) {}
 
     void Clear();
 
     bool IsValid() {
protected:
 
     ConstString m_full; // Full name:
                         // "lldb::SBTarget::GetBreakpointAtIndex(unsigned int)
                         // const"
     llvm::StringRef m_basename;   // Basename:     "GetBreakpointAtIndex"
     llvm::StringRef m_context;    // Decl context: "lldb::SBTarget"
     llvm::StringRef m_arguments;  // Arguments:    "(unsigned int)"
     llvm::StringRef m_qualifiers; // Qualifiers:   "const"
-    bool m_parsed;
-    bool m_parse_error;
+    bool m_parsed = false;
+    bool m_parse_error = false;
   };
 
   CPlusPlusLanguage() = default;
 
   ~CPlusPlusLanguage() override = default;
 
   lldb::LanguageType GetLanguageType() const override {
     return lldb::eLanguageTypeC_plus_plus;

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

public:
 
       void Clear() {
         m_indexes = 0;
         m_count = 0;
         m_ptr_size = 0;
         m_process = nullptr;
       }
 
-      InlinedIndexes()
-          : m_indexes(0), m_count(0), m_ptr_size(0), m_process(nullptr) {}
+      InlinedIndexes() {}
 
     private:
-      uint64_t m_indexes;
-      size_t m_count;
-      uint32_t m_ptr_size;
-      Process *m_process;
+      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
       size_t _lengthForInlinePayload(uint32_t ptr_size) {
         m_ptr_size = ptr_size;
         if (m_ptr_size == 8)
           m_count = ((m_indexes >> 3) & 0x7);
         else
           m_count = ((m_indexes >> 3) & 0x3);
struct OutsourcedIndexes {
         return nullptr;
       }
 
       void Clear() {
         m_indexes = nullptr;
         m_count = 0;
       }
 
-      OutsourcedIndexes() : m_indexes(nullptr), m_count(0) {}
+      OutsourcedIndexes() {}
 
-      ValueObject *m_indexes;
-      size_t m_count;
+      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() : m_mode(Mode::Invalid) {}
+    Impl() {}
 
-    Mode m_mode;
+    Mode m_mode = Mode::Invalid;
   } m_impl;
 
   uint32_t m_ptr_size;
   CompilerType m_uint_star_type;
 };
 
 namespace lldb_private {
 namespace formatters {

lldb/source/Plugins/Language/ObjC/ObjCLanguage.h

 class ObjCLanguage : public Language {
   ClangHighlighter m_highlighter;
 
 public:
   class MethodName {
   public:
     enum Type { eTypeUnspecified, eTypeClassMethod, eTypeInstanceMethod };
 
-    MethodName()
-        : m_full(), m_class(), m_category(), m_selector(),
-          m_type(eTypeUnspecified), m_category_is_valid(false) {}
+    MethodName() : m_full(), m_class(), m_category(), m_selector() {}
 
     MethodName(const char *name, bool strict)
         : m_full(), m_class(), m_category(), m_selector(),
           m_type(eTypeUnspecified), m_category_is_valid(false) {
       SetName(name, strict);
     }
     MethodName(llvm::StringRef name, bool strict)
         : m_full(), m_class(), m_category(), m_selector(),
public:
   protected:
     ConstString
         m_full; // Full name:   "+[NSString(my_additions) myStringWithCString:]"
     ConstString m_class; // Class name:  "NSString"
     ConstString
         m_class_category;   // Class with category: "NSString(my_additions)"
     ConstString m_category; // Category:    "my_additions"
     ConstString m_selector; // Selector:    "myStringWithCString:"
-    Type m_type;
-    bool m_category_is_valid;
+    Type m_type = eTypeUnspecified;
+    bool m_category_is_valid = false;
   };
 
   ObjCLanguage() = default;
 
   ~ObjCLanguage() override = default;
 
   lldb::LanguageType GetLanguageType() const override {
     return lldb::eLanguageTypeObjC;

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

 
 protected:
   void GetIVarInformation();
 
 private:
   static const uint32_t RW_REALIZED = (1 << 31);
 
   struct objc_class_t {
-    ObjCLanguageRuntime::ObjCISA m_isa; // The class's metaclass.
-    ObjCLanguageRuntime::ObjCISA m_superclass;
-    lldb::addr_t m_cache_ptr;
-    lldb::addr_t m_vtable_ptr;
-    lldb::addr_t m_data_ptr;
-    uint8_t m_flags;
-
-    objc_class_t()
-        : m_isa(0), m_superclass(0), m_cache_ptr(0), m_vtable_ptr(0),
-          m_data_ptr(0), m_flags(0) {}
+    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() {}
 
     void Clear() {
       m_isa = 0;
       m_superclass = 0;
       m_cache_ptr = 0;
       m_vtable_ptr = 0;
       m_data_ptr = 0;
       m_flags = 0;
public:
 
     size_t size();
 
     iVarDescriptor &operator[](size_t idx);
 
     void fill(AppleObjCRuntimeV2 &runtime, ClassDescriptorV2 &descriptor);
 
   private:
-    bool m_filled;
+    bool m_filled = false;
     std::vector<iVarDescriptor> m_ivars;
     std::recursive_mutex m_mutex;
   };
 
   // The constructor should only be invoked by the runtime as it builds its
   // caches
   // or populates them.  A ClassDescriptorV2 should only ever exist in a cache.
   ClassDescriptorV2(AppleObjCRuntimeV2 &runtime,

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

if (!Read_class_row(process, *objc_class, class_ro, class_rw))
       return 0;
 
     return class_ro->m_instanceSize;
   }
 
   return 0;
 }
 
-ClassDescriptorV2::iVarsStorage::iVarsStorage()
-    : m_filled(false), m_ivars(), m_mutex() {}
+ClassDescriptorV2::iVarsStorage::iVarsStorage() : m_ivars(), m_mutex() {}
 
 size_t ClassDescriptorV2::iVarsStorage::size() { return m_ivars.size(); }
 
 ClassDescriptorV2::iVarDescriptor &ClassDescriptorV2::iVarsStorage::
 operator[](size_t idx) {
   return m_ivars[idx];
 }
 

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()
-        : m_count(0), m_num_buckets(0), m_buckets_ptr(LLDB_INVALID_ADDRESS) {}
+    HashTableSignature() {}
 
     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::addr_t buckets_ptr) {
       m_count = count;
       m_num_buckets = num_buckets;
       m_buckets_ptr = buckets_ptr;
     }
 
   protected:
-    uint32_t m_count;
-    uint32_t m_num_buckets;
-    lldb::addr_t m_buckets_ptr;
+    uint32_t m_count = 0;
+    uint32_t m_num_buckets = 0;
+    lldb::addr_t m_buckets_ptr = LLDB_INVALID_ADDRESS;
   };
 
   lldb::addr_t GetISAHashTablePointer();
 
   HashTableSignature m_hash_signature;
   lldb::addr_t m_isa_hash_table_ptr;
   std::unique_ptr<DeclVendor> m_decl_vendor_up;
 
 private:
   AppleObjCRuntimeV1(Process *process);
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_LANGUAGERUNTIME_OBJC_APPLEOBJCRUNTIME_APPLEOBJCRUNTIMEV1_H

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

public:
     HashTableSignature();
 
     bool NeedsUpdate(Process *process, AppleObjCRuntimeV2 *runtime,
                      RemoteNXMapTable &hash_table);
 
     void UpdateSignature(const RemoteNXMapTable &hash_table);
 
   protected:
-    uint32_t m_count;
-    uint32_t m_num_buckets;
-    lldb::addr_t m_buckets_ptr;
+    uint32_t m_count = 0;
+    uint32_t m_num_buckets = 0;
+    lldb::addr_t m_buckets_ptr = 0;
   };
 
   class NonPointerISACache {
   public:
     static NonPointerISACache *
     CreateInstance(AppleObjCRuntimeV2 &runtime,
                    const lldb::ModuleSP &objc_module_sp);
 

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

 bool AppleObjCRuntimeV2::IsTaggedPointer(addr_t ptr) {
   if (!m_tagged_pointer_vendor_up)
     return false;
   return m_tagged_pointer_vendor_up->IsPossibleTaggedPointer(ptr);
 }
 
 class RemoteNXMapTable {
 public:
-  RemoteNXMapTable()
-      : m_count(0), m_num_buckets_minus_one(0),
-        m_buckets_ptr(LLDB_INVALID_ADDRESS), m_process(nullptr),
-        m_end_iterator(*this, -1), m_load_addr(LLDB_INVALID_ADDRESS),
-        m_map_pair_size(0), m_invalid_key(0) {}
+  RemoteNXMapTable() : m_end_iterator(*this, -1) {}
 
   void Dump() {
     printf("RemoteNXMapTable.m_load_addr = 0x%" PRIx64 "\n", m_load_addr);
     printf("RemoteNXMapTable.m_count = %u\n", m_count);
     printf("RemoteNXMapTable.m_num_buckets_minus_one = %u\n",
            m_num_buckets_minus_one);
     printf("RemoteNXMapTable.m_buckets_ptr = 0x%" PRIX64 "\n", m_buckets_ptr);
   }
public:
   uint32_t GetBucketCount() const { return m_num_buckets_minus_one; }
 
   lldb::addr_t GetBucketDataPointer() const { return m_buckets_ptr; }
 
   lldb::addr_t GetTableLoadAddress() const { return m_load_addr; }
 
 private:
   // contents of _NXMapTable struct
-  uint32_t m_count;
-  uint32_t m_num_buckets_minus_one;
-  lldb::addr_t m_buckets_ptr;
-  lldb_private::Process *m_process;
+  uint32_t m_count = 0;
+  uint32_t m_num_buckets_minus_one = 0;
+  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;
-  size_t m_map_pair_size;
-  lldb::addr_t m_invalid_key;
+  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()
-    : m_count(0), m_num_buckets(0), m_buckets_ptr(0) {}
+AppleObjCRuntimeV2::HashTableSignature::HashTableSignature() {}
 
 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

struct VTableDescriptor {
           : flags(in_flags), code_start(in_code_start) {}
 
       uint32_t flags;
       lldb::addr_t code_start;
     };
 
     class VTableRegion {
     public:
-      VTableRegion()
-          : m_valid(false), m_owner(nullptr),
-            m_header_addr(LLDB_INVALID_ADDRESS), m_code_start_addr(0),
-            m_code_end_addr(0), m_next_region(0) {}
+      VTableRegion() {}
 
       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::addr_t GetCodeEnd() { return m_code_end_addr; }
 
       uint32_t GetFlagsForVTableAtAddress(lldb::addr_t address) { return 0; }
 
       bool IsValid() { return m_valid; }
 
       bool AddressInRegion(lldb::addr_t addr, uint32_t &flags);
 
       void Dump(Stream &s);
 
-      bool m_valid;
-      AppleObjCVTables *m_owner;
-      lldb::addr_t m_header_addr;
-      lldb::addr_t m_code_start_addr;
-      lldb::addr_t m_code_end_addr;
+      bool m_valid = false;
+      AppleObjCVTables *m_owner = nullptr;
+      lldb::addr_t m_header_addr = LLDB_INVALID_ADDRESS;
+      lldb::addr_t m_code_start_addr = 0;
+      lldb::addr_t m_code_end_addr = 0;
       std::vector<VTableDescriptor> m_descriptors;
-      lldb::addr_t m_next_region;
+      lldb::addr_t m_next_region = 0;
     };
 
   public:
     AppleObjCVTables(const lldb::ProcessSP &process_sp,
                      const lldb::ModuleSP &objc_module_sp);
 
     ~AppleObjCVTables();
 

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

public:
 
   CompilerType RealizeType(TypeSystemClang &ast_ctx, const char *name,
                            bool for_expression) override;
 
 private:
   struct StructElement {
     std::string name;
     clang::QualType type;
-    uint32_t bitfield;
+    uint32_t bitfield = 0;
 
     StructElement();
     ~StructElement() = default;
   };
 
   clang::QualType BuildType(TypeSystemClang &clang_ast_ctx, StringLexer &type,
                             bool for_expression,
                             uint32_t *bitfield_bit_size = nullptr);

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

uint32_t AppleObjCTypeEncodingParser::ReadNumber(StringLexer &type) {
   return total;
 }
 
 // as an extension to the published grammar recent runtimes emit structs like
 // this:
 // "{CGRect=\"origin\"{CGPoint=\"x\"d\"y\"d}\"size\"{CGSize=\"width\"d\"height\"d}}"
 
 AppleObjCTypeEncodingParser::StructElement::StructElement()
-    : name(""), type(clang::QualType()), bitfield(0) {}
+    : name(""), type(clang::QualType()) {}
 
 AppleObjCTypeEncodingParser::StructElement
 AppleObjCTypeEncodingParser::ReadStructElement(TypeSystemClang &ast_ctx,
                                                StringLexer &type,
                                                bool for_expression) {
   StructElement retval;
   if (type.NextIf('"'))
     retval.name = ReadQuotedString(type);

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

public:
   class ClassDescriptor;
   typedef std::shared_ptr<ClassDescriptor> ClassDescriptorSP;
 
   // the information that we want to support retrieving from an ObjC class this
   // needs to be pure virtual since there are at least 2 different
   // implementations of the runtime, and more might come
   class ClassDescriptor {
   public:
-    ClassDescriptor()
-        : m_is_kvo(eLazyBoolCalculate), m_is_cf(eLazyBoolCalculate),
-          m_type_wp() {}
+    ClassDescriptor() : m_type_wp() {}
 
     virtual ~ClassDescriptor() = default;
 
     virtual ConstString GetClassName() = 0;
 
     virtual ClassDescriptorSP GetSuperclass() = 0;
 
     virtual ClassDescriptorSP GetMetaclass() const = 0;
public:
     }
 
   protected:
     bool IsPointerValid(lldb::addr_t value, uint32_t ptr_size,
                         bool allow_NULLs = false, bool allow_tagged = false,
                         bool check_version_specific = false) const;
 
   private:
-    LazyBool m_is_kvo;
-    LazyBool m_is_cf;
+    LazyBool m_is_kvo = eLazyBoolCalculate;
+    LazyBool m_is_cf = eLazyBoolCalculate;
     lldb::TypeWP m_type_wp;
   };
 
   class EncodingToType {
   public:
     virtual ~EncodingToType();
 
     virtual CompilerType RealizeType(TypeSystemClang &ast_ctx, const char *name,

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

 struct RSScriptGroupDescriptor;
 
 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, y, z;
+  uint32_t x = 0, y = 0, z = 0;
 
-  RSCoordinate() : x(), y(), z(){};
+  RSCoordinate(){};
 
   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

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() : valid(false) {}
+  empirical_type() {}
 
   // Return true and copy contents to out if valid, else return false.
   bool get(type_t &out) const {
     if (valid)
       out = data;
     return valid;
   }
 
public:
   // Dereference operator returns contents.
   // Warning: Will assert if not valid so use only when you know data is valid.
   const type_t &operator*() const {
     assert(valid);
     return data;
   }
 
 protected:
-  bool valid;
+  bool valid = false;
   type_t data;
 };
 
 // ArgItem is used by the GetArgs() function when reading function arguments
 // from the target.
 struct ArgItem {
   enum { ePointer, eInt32, eInt64, eLong, eBool } type;
 
CommandObjectRenderScriptRuntimeReductionBreakpointSet(
             "renderscript reduction breakpoint set  <kernel_name> [-t "
             "<reduction_kernel_type,...>]",
             eCommandRequiresProcess | eCommandProcessMustBeLaunched |
                 eCommandProcessMustBePaused),
         m_options(){};
 
   class CommandOptions : public Options {
   public:
-    CommandOptions()
-        : Options(),
-          m_kernel_types(RSReduceBreakpointResolver::eKernelTypeAll) {}
+    CommandOptions() : Options() {}
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *exe_ctx) override {
       Status err;
       StreamString err_str;
       const int short_option = m_getopt_table[option_idx].val;
bool ParseReductionTypes(llvm::StringRef option_val,
           return false;
         }
         m_kernel_types |= type;
       }
 
       return true;
     }
 
-    int m_kernel_types;
+    int m_kernel_types = RSReduceBreakpointResolver::eKernelTypeAll;
     llvm::StringRef m_reduce_name;
     RSCoordinate m_coord;
     bool m_have_coord;
   };
 
   Options *GetOptions() override { return &m_options; }
 
   bool DoExecute(Args &command, CommandReturnObject &result) override {
CommandObjectRenderScriptRuntimeAllocationList(
         m_options() {}
 
   ~CommandObjectRenderScriptRuntimeAllocationList() override = default;
 
   Options *GetOptions() override { return &m_options; }
 
   class CommandOptions : public Options {
   public:
-    CommandOptions() : Options(), m_id(0) {}
+    CommandOptions() : Options() {}
 
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *exe_ctx) override {
       Status err;
       const int short_option = m_getopt_table[option_idx].val;
 
public:
     }
 
     void OptionParsingStarting(ExecutionContext *exe_ctx) override { m_id = 0; }
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_renderscript_runtime_alloc_list_options);
     }
 
-    uint32_t m_id;
+    uint32_t m_id = 0;
   };
 
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     RenderScriptRuntime *runtime = static_cast<RenderScriptRuntime *>(
         m_exe_ctx.GetProcessPtr()->GetLanguageRuntime(
             eLanguageTypeExtRenderScript));
     runtime->ListAllocations(result.GetOutputStream(), m_exe_ctx.GetFramePtr(),
                              m_options.m_id);

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

struct Object {
     void Clear();
 
     lldb::offset_t Extract(const lldb_private::DataExtractor &data,
                            lldb::offset_t offset);
     /// Object name in the archive.
     lldb_private::ConstString ar_name;
 
     /// Object modification time in the archive.
-    uint32_t modification_time;
+    uint32_t modification_time = 0;
 
     /// Object user id in the archive.
-    uint16_t uid;
+    uint16_t uid = 0;
 
     /// Object group id in the archive.
-    uint16_t gid;
+    uint16_t gid = 0;
 
     /// Object octal file permissions in the archive.
-    uint16_t mode;
+    uint16_t mode = 0;
 
     /// Object size in bytes in the archive.
-    uint32_t size;
+    uint32_t size = 0;
 
     /// File offset in bytes from the beginning of the file of the object data.
-    lldb::offset_t file_offset;
+    lldb::offset_t file_offset = 0;
 
     /// Length of the object data.
-    lldb::offset_t file_size;
+    lldb::offset_t file_size = 0;
   };
 
   class Archive {
   public:
     typedef std::shared_ptr<Archive> shared_ptr;
     typedef std::multimap<lldb_private::FileSpec, shared_ptr> Map;
 
     Archive(const lldb_private::ArchSpec &arch,

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

 
 #include "llvm/Support/MemoryBuffer.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 LLDB_PLUGIN_DEFINE(ObjectContainerBSDArchive)
 
-ObjectContainerBSDArchive::Object::Object()
-    : ar_name(), modification_time(0), uid(0), gid(0), mode(0), size(0),
-      file_offset(0), file_size(0) {}
+ObjectContainerBSDArchive::Object::Object() : ar_name() {}
 
 void ObjectContainerBSDArchive::Object::Clear() {
   ar_name.Clear();
   modification_time = 0;
   uid = 0;
   gid = 0;
   mode = 0;
   size = 0;

lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.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;
-  elf::elf_word n_descsz;
-  elf::elf_word n_type;
+  elf::elf_word n_namesz = 0;
+  elf::elf_word n_descsz = 0;
+  elf::elf_word n_type = 0;
 
   std::string n_name;
 
-  ELFNote() : n_namesz(0), n_descsz(0), n_type(0) {}
+  ELFNote() {}
 
   /// 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/Platform/MacOSX/PlatformRemoteDarwinDevice.h

protected:
 
   typedef std::vector<SDKDirectoryInfo> SDKDirectoryInfoCollection;
 
   std::mutex m_sdk_dir_mutex;
   SDKDirectoryInfoCollection m_sdk_directory_infos;
   std::string m_device_support_directory;
   std::string m_device_support_directory_for_os_version;
   std::string m_build_update;
-  uint32_t m_last_module_sdk_idx;
-  uint32_t m_connected_module_sdk_idx;
+  uint32_t m_last_module_sdk_idx = UINT32_MAX;
+  uint32_t m_connected_module_sdk_idx = UINT32_MAX;
 
   bool UpdateSDKDirectoryInfosIfNeeded();
 
   const char *GetDeviceSupportDirectory();
 
   const char *GetDeviceSupportDirectoryForOSVersion();
 
   const SDKDirectoryInfo *GetSDKDirectoryForLatestOSVersion();

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

PlatformRemoteDarwinDevice::SDKDirectoryInfo::SDKDirectoryInfo(
   std::tie(version, build_str) = ParseVersionBuildDir(dirname_str);
   build.SetString(build_str);
 }
 
 /// Default Constructor
 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(),
-      m_last_module_sdk_idx(UINT32_MAX),
-      m_connected_module_sdk_idx(UINT32_MAX) {}
+      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() {}
 
 void PlatformRemoteDarwinDevice::GetStatus(Stream &strm) {

lldb/source/Plugins/Platform/MacOSX/objcxx/PlatformiOSSimulatorCoreSimulatorSupport.h

public:
 
   ModelIdentifier GetModelIdentifier();
 
   lldb_private::ConstString GetProductFamily();
 
   ProductFamilyID GetProductFamilyID();
 
 private:
-  id m_dev;
+  id m_dev = nullptr;
   llvm::Optional<ModelIdentifier> m_model_identifier;
 };
 
 class OSVersion {
 public:
   OSVersion(const std::string &ver, const std::string &build);
 
   OSVersion();
public:
 
   explicit operator bool();
 
   OSVersion GetVersion();
 
   bool IsAvailable();
 
 private:
-  id m_dev;
+  id m_dev = nullptr;
   llvm::Optional<OSVersion> m_os_version;
 };
 
 class Device {
 private:
   typedef unsigned long int NSUInteger;
 
 public:
public:
 
   bool Shutdown(lldb_private::Status &err);
 
   std::string GetUDID() const;
 
   Process Spawn(lldb_private::ProcessLaunchInfo &launch_info);
 
 private:
-  id m_dev;
+  id m_dev = nullptr;
   llvm::Optional<DeviceType> m_dev_type;
   llvm::Optional<DeviceRuntime> m_dev_runtime;
 
   friend class DeviceSet;
 };
 
 bool operator>(const OSVersion &lhs, const OSVersion &rhs);
 

lldb/source/Plugins/Platform/MacOSX/objcxx/PlatformiOSSimulatorCoreSimulatorSupport.mm

 CoreSimulatorSupport::Process::Process(lldb::pid_t p) : m_pid(p), m_error() {}
 
 CoreSimulatorSupport::Process::Process(Status error)
     : m_pid(LLDB_INVALID_PROCESS_ID), m_error(error) {}
 
 CoreSimulatorSupport::Process::Process(lldb::pid_t p, Status error)
     : m_pid(p), m_error(error) {}
 
-CoreSimulatorSupport::DeviceType::DeviceType()
-    : m_dev(nil), m_model_identifier() {}
+CoreSimulatorSupport::DeviceType::DeviceType() : m_model_identifier() {}
 
 CoreSimulatorSupport::DeviceType::DeviceType(id d)
     : m_dev(d), m_model_identifier() {}
 
 CoreSimulatorSupport::DeviceType::operator bool() { return m_dev != nil; }
 
 ConstString CoreSimulatorSupport::DeviceType::GetIdentifier() {
   return ConstString([[m_dev identifier] UTF8String]);
 }
 
 ConstString CoreSimulatorSupport::DeviceType::GetProductFamily() {
   return ConstString([[m_dev productFamily] UTF8String]);
 }
 
 CoreSimulatorSupport::DeviceType::ProductFamilyID
 CoreSimulatorSupport::DeviceType::GetProductFamilyID() {
   return ProductFamilyID([m_dev productFamilyID]);
 }
 
-CoreSimulatorSupport::DeviceRuntime::DeviceRuntime()
-    : m_dev(nil), m_os_version() {}
+CoreSimulatorSupport::DeviceRuntime::DeviceRuntime() : m_os_version() {}
 
 CoreSimulatorSupport::DeviceRuntime::DeviceRuntime(id d)
     : m_dev(d), m_os_version() {}
 
 CoreSimulatorSupport::DeviceRuntime::operator bool() { return m_dev != nil; }
 
 bool CoreSimulatorSupport::DeviceRuntime::IsAvailable() {
   return [m_dev available];
 }
 
-CoreSimulatorSupport::Device::Device()
-    : m_dev(nil), m_dev_type(), m_dev_runtime() {}
+CoreSimulatorSupport::Device::Device() : m_dev_type(), m_dev_runtime() {}
 
 CoreSimulatorSupport::Device::Device(id d)
     : m_dev(d), m_dev_type(), m_dev_runtime() {}
 
 CoreSimulatorSupport::Device::operator bool() { return m_dev != nil; }
 
 CoreSimulatorSupport::Device::State CoreSimulatorSupport::Device::GetState() {
   return (State)([m_dev state]);

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

public:
   llvm::Error SendTraceStop(const TraceStopRequest &request);
 
   llvm::Expected<std::string> SendTraceGetState(llvm::StringRef type);
 
   llvm::Expected<std::vector<uint8_t>>
   SendTraceGetBinaryData(const TraceGetBinaryDataRequest &request);
 
 protected:
-  LazyBool m_supports_not_sending_acks;
-  LazyBool m_supports_thread_suffix;
-  LazyBool m_supports_threads_in_stop_reply;
-  LazyBool m_supports_vCont_all;
-  LazyBool m_supports_vCont_any;
-  LazyBool m_supports_vCont_c;
-  LazyBool m_supports_vCont_C;
-  LazyBool m_supports_vCont_s;
-  LazyBool m_supports_vCont_S;
-  LazyBool m_qHostInfo_is_valid;
-  LazyBool m_curr_pid_is_valid;
-  LazyBool m_qProcessInfo_is_valid;
-  LazyBool m_qGDBServerVersion_is_valid;
-  LazyBool m_supports_alloc_dealloc_memory;
-  LazyBool m_supports_memory_region_info;
-  LazyBool m_supports_watchpoint_support_info;
-  LazyBool m_supports_detach_stay_stopped;
-  LazyBool m_watchpoints_trigger_after_instruction;
-  LazyBool m_attach_or_wait_reply;
-  LazyBool m_prepare_for_reg_writing_reply;
-  LazyBool m_supports_p;
-  LazyBool m_supports_x;
-  LazyBool m_avoid_g_packets;
-  LazyBool m_supports_QSaveRegisterState;
-  LazyBool m_supports_qXfer_auxv_read;
-  LazyBool m_supports_qXfer_libraries_read;
-  LazyBool m_supports_qXfer_libraries_svr4_read;
-  LazyBool m_supports_qXfer_features_read;
-  LazyBool m_supports_qXfer_memory_map_read;
-  LazyBool m_supports_augmented_libraries_svr4_read;
-  LazyBool m_supports_jThreadExtendedInfo;
-  LazyBool m_supports_jLoadedDynamicLibrariesInfos;
-  LazyBool m_supports_jGetSharedCacheInfo;
-  LazyBool m_supports_QPassSignals;
-  LazyBool m_supports_error_string_reply;
-  LazyBool m_supports_multiprocess;
+  LazyBool m_supports_not_sending_acks = eLazyBoolCalculate;
+  LazyBool m_supports_thread_suffix = eLazyBoolCalculate;
+  LazyBool m_supports_threads_in_stop_reply = eLazyBoolCalculate;
+  LazyBool m_supports_vCont_all = eLazyBoolCalculate;
+  LazyBool m_supports_vCont_any = eLazyBoolCalculate;
+  LazyBool m_supports_vCont_c = eLazyBoolCalculate;
+  LazyBool m_supports_vCont_C = eLazyBoolCalculate;
+  LazyBool m_supports_vCont_s = eLazyBoolCalculate;
+  LazyBool m_supports_vCont_S = eLazyBoolCalculate;
+  LazyBool m_qHostInfo_is_valid = eLazyBoolCalculate;
+  LazyBool m_curr_pid_is_valid = eLazyBoolCalculate;
+  LazyBool m_qProcessInfo_is_valid = eLazyBoolCalculate;
+  LazyBool m_qGDBServerVersion_is_valid = eLazyBoolCalculate;
+  LazyBool m_supports_alloc_dealloc_memory = eLazyBoolCalculate;
+  LazyBool m_supports_memory_region_info = eLazyBoolCalculate;
+  LazyBool m_supports_watchpoint_support_info = eLazyBoolCalculate;
+  LazyBool m_supports_detach_stay_stopped = eLazyBoolCalculate;
+  LazyBool m_watchpoints_trigger_after_instruction = eLazyBoolCalculate;
+  LazyBool m_attach_or_wait_reply = eLazyBoolCalculate;
+  LazyBool m_prepare_for_reg_writing_reply = eLazyBoolCalculate;
+  LazyBool m_supports_p = eLazyBoolCalculate;
+  LazyBool m_supports_x = eLazyBoolCalculate;
+  LazyBool m_avoid_g_packets = eLazyBoolCalculate;
+  LazyBool m_supports_QSaveRegisterState = eLazyBoolCalculate;
+  LazyBool m_supports_qXfer_auxv_read = eLazyBoolCalculate;
+  LazyBool m_supports_qXfer_libraries_read = eLazyBoolCalculate;
+  LazyBool m_supports_qXfer_libraries_svr4_read = eLazyBoolCalculate;
+  LazyBool m_supports_qXfer_features_read = eLazyBoolCalculate;
+  LazyBool m_supports_qXfer_memory_map_read = eLazyBoolCalculate;
+  LazyBool m_supports_augmented_libraries_svr4_read = eLazyBoolCalculate;
+  LazyBool m_supports_jThreadExtendedInfo = eLazyBoolCalculate;
+  LazyBool m_supports_jLoadedDynamicLibrariesInfos = eLazyBoolCalculate;
+  LazyBool m_supports_jGetSharedCacheInfo = eLazyBoolCalculate;
+  LazyBool m_supports_QPassSignals = eLazyBoolCalculate;
+  LazyBool m_supports_error_string_reply = eLazyBoolCalculate;
+  LazyBool m_supports_multiprocess = eLazyBoolCalculate;
 
   bool m_supports_qProcessInfoPID : 1, m_supports_qfProcessInfo : 1,
       m_supports_qUserName : 1, m_supports_qGroupName : 1,
       m_supports_qThreadStopInfo : 1, m_supports_z0 : 1, m_supports_z1 : 1,
       m_supports_z2 : 1, m_supports_z3 : 1, m_supports_z4 : 1,
       m_supports_QEnvironment : 1, m_supports_QEnvironmentHexEncoded : 1,
       m_supports_qSymbol : 1, m_qSymbol_requests_done : 1,
       m_supports_qModuleInfo : 1, m_supports_jThreadsInfo : 1,
       m_supports_jModulesInfo : 1;
 
-  lldb::pid_t m_curr_pid;
-  lldb::tid_t m_curr_tid; // Current gdb remote protocol thread index for all
-                          // other operations
-  lldb::tid_t m_curr_tid_run; // Current gdb remote protocol thread index for
+  lldb::pid_t m_curr_pid = LLDB_INVALID_PROCESS_ID;
+  lldb::tid_t m_curr_tid =
+      LLDB_INVALID_THREAD_ID; // Current gdb remote protocol thread index for
+                              // all other operations
+  lldb::tid_t m_curr_tid_run =
+      LLDB_INVALID_THREAD_ID; // Current gdb remote protocol thread index for
                               // continue, step, etc
 
-  uint32_t m_num_supported_hardware_watchpoints;
-  uint32_t m_addressing_bits;
+  uint32_t m_num_supported_hardware_watchpoints = 0;
+  uint32_t m_addressing_bits = 0;
 
   ArchSpec m_host_arch;
   ArchSpec m_process_arch;
   llvm::VersionTuple m_os_version;
   llvm::VersionTuple m_maccatalyst_version;
   std::string m_os_build;
   std::string m_os_kernel;
   std::string m_hostname;
   std::string m_gdb_server_name; // from reply to qGDBServerVersion, empty if
                                  // qGDBServerVersion is not supported
-  uint32_t m_gdb_server_version; // from reply to qGDBServerVersion, zero if
-                                 // qGDBServerVersion is not supported
+  uint32_t m_gdb_server_version =
+      UINT32_MAX; // from reply to qGDBServerVersion, zero if
   std::chrono::seconds m_default_packet_timeout;
-  uint64_t m_max_packet_size;        // as returned by qSupported
+  uint64_t m_max_packet_size = 0;    // as returned by qSupported
   std::string m_qSupported_response; // the complete response to qSupported
 
-  bool m_supported_async_json_packets_is_valid;
+  bool m_supported_async_json_packets_is_valid = false;
   lldb_private::StructuredData::ObjectSP m_supported_async_json_packets_sp;
 
   std::vector<MemoryRegionInfo> m_qXfer_memory_map;
-  bool m_qXfer_memory_map_loaded;
+  bool m_qXfer_memory_map_loaded = false;
 
   bool GetCurrentProcessInfo(bool allow_lazy_pid = true);
 
   bool GetGDBServerVersion();
 
   // Given the list of compression types that the remote debug stub can support,
   // possibly enable compression if we find an encoding we can handle.
   void MaybeEnableCompression(

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

llvm::raw_ostream &process_gdb_remote::operator<<(llvm::raw_ostream &os,
   return os << llvm::formatv(
              "QOffsets({0}, [{1:@[x]}])", offsets.segments,
              llvm::make_range(offsets.offsets.begin(), offsets.offsets.end()));
 }
 
 // GDBRemoteCommunicationClient constructor
 GDBRemoteCommunicationClient::GDBRemoteCommunicationClient()
     : GDBRemoteClientBase("gdb-remote.client", "gdb-remote.client.rx_packet"),
-      m_supports_not_sending_acks(eLazyBoolCalculate),
-      m_supports_thread_suffix(eLazyBoolCalculate),
-      m_supports_threads_in_stop_reply(eLazyBoolCalculate),
-      m_supports_vCont_all(eLazyBoolCalculate),
-      m_supports_vCont_any(eLazyBoolCalculate),
-      m_supports_vCont_c(eLazyBoolCalculate),
-      m_supports_vCont_C(eLazyBoolCalculate),
-      m_supports_vCont_s(eLazyBoolCalculate),
-      m_supports_vCont_S(eLazyBoolCalculate),
-      m_qHostInfo_is_valid(eLazyBoolCalculate),
-      m_curr_pid_is_valid(eLazyBoolCalculate),
-      m_qProcessInfo_is_valid(eLazyBoolCalculate),
-      m_qGDBServerVersion_is_valid(eLazyBoolCalculate),
-      m_supports_alloc_dealloc_memory(eLazyBoolCalculate),
-      m_supports_memory_region_info(eLazyBoolCalculate),
-      m_supports_watchpoint_support_info(eLazyBoolCalculate),
-      m_supports_detach_stay_stopped(eLazyBoolCalculate),
-      m_watchpoints_trigger_after_instruction(eLazyBoolCalculate),
-      m_attach_or_wait_reply(eLazyBoolCalculate),
-      m_prepare_for_reg_writing_reply(eLazyBoolCalculate),
-      m_supports_p(eLazyBoolCalculate), m_supports_x(eLazyBoolCalculate),
-      m_avoid_g_packets(eLazyBoolCalculate),
-      m_supports_QSaveRegisterState(eLazyBoolCalculate),
-      m_supports_qXfer_auxv_read(eLazyBoolCalculate),
-      m_supports_qXfer_libraries_read(eLazyBoolCalculate),
-      m_supports_qXfer_libraries_svr4_read(eLazyBoolCalculate),
-      m_supports_qXfer_features_read(eLazyBoolCalculate),
-      m_supports_qXfer_memory_map_read(eLazyBoolCalculate),
-      m_supports_augmented_libraries_svr4_read(eLazyBoolCalculate),
-      m_supports_jThreadExtendedInfo(eLazyBoolCalculate),
-      m_supports_jLoadedDynamicLibrariesInfos(eLazyBoolCalculate),
-      m_supports_jGetSharedCacheInfo(eLazyBoolCalculate),
-      m_supports_QPassSignals(eLazyBoolCalculate),
-      m_supports_error_string_reply(eLazyBoolCalculate),
-      m_supports_multiprocess(eLazyBoolCalculate),
+
       m_supports_qProcessInfoPID(true), m_supports_qfProcessInfo(true),
       m_supports_qUserName(true), m_supports_qGroupName(true),
       m_supports_qThreadStopInfo(true), m_supports_z0(true),
       m_supports_z1(true), m_supports_z2(true), m_supports_z3(true),
       m_supports_z4(true), m_supports_QEnvironment(true),
       m_supports_QEnvironmentHexEncoded(true), m_supports_qSymbol(true),
       m_qSymbol_requests_done(false), m_supports_qModuleInfo(true),
       m_supports_jThreadsInfo(true), m_supports_jModulesInfo(true),
-      m_curr_pid(LLDB_INVALID_PROCESS_ID), m_curr_tid(LLDB_INVALID_THREAD_ID),
-      m_curr_tid_run(LLDB_INVALID_THREAD_ID),
-      m_num_supported_hardware_watchpoints(0), m_addressing_bits(0),
+
       m_host_arch(), m_process_arch(), m_os_build(), m_os_kernel(),
-      m_hostname(), m_gdb_server_name(), m_gdb_server_version(UINT32_MAX),
-      m_default_packet_timeout(0), m_max_packet_size(0),
-      m_qSupported_response(), m_supported_async_json_packets_is_valid(false),
-      m_supported_async_json_packets_sp(), m_qXfer_memory_map(),
-      m_qXfer_memory_map_loaded(false) {}
+      m_hostname(), m_gdb_server_name(), m_default_packet_timeout(0),
+      m_qSupported_response(), m_supported_async_json_packets_sp(),
+      m_qXfer_memory_map() {}
 
 // Destructor
 GDBRemoteCommunicationClient::~GDBRemoteCommunicationClient() {
   if (IsConnected())
     Disconnect();
 }
 
 bool GDBRemoteCommunicationClient::HandshakeWithServer(Status *error_ptr) {

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

uint32_t GetNextIndex() {
     return idx;
   }
 
   uint32_t NormalizeIndex(uint32_t i) const {
     return m_packets.empty() ? 0 : i % m_packets.size();
   }
 
   std::vector<GDBRemotePacket> m_packets;
-  uint32_t m_curr_idx;
-  uint32_t m_total_packet_count;
-  mutable bool m_dumped_to_log;
+  uint32_t m_curr_idx = 0;
+  uint32_t m_total_packet_count = 0;
+  mutable bool m_dumped_to_log = false;
   repro::PacketRecorder *m_recorder = nullptr;
 };
 
 } // namespace process_gdb_remote
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_PROCESS_GDB_REMOTE_GDBREMOTECOMMUNICATIONHISTORY_H

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

 #include "lldb/Utility/Log.h"
 
 using namespace llvm;
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::process_gdb_remote;
 
 GDBRemoteCommunicationHistory::GDBRemoteCommunicationHistory(uint32_t size)
-    : m_packets(), m_curr_idx(0), m_total_packet_count(0),
-      m_dumped_to_log(false) {
+    : m_packets() {
   if (size)
     m_packets.resize(size);
 }
 
 GDBRemoteCommunicationHistory::~GDBRemoteCommunicationHistory() {}
 
 void GDBRemoteCommunicationHistory::AddPacket(char packet_char,
                                               GDBRemotePacket::Type type,

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

protected:
   std::vector<GDBRemotePacket> m_packet_history;
 
   /// Server thread.
   Broadcaster m_async_broadcaster;
   lldb::ListenerSP m_async_listener_sp;
   HostThread m_async_thread;
   std::recursive_mutex m_async_thread_state_mutex;
 
-  bool m_skip_acks;
+  bool m_skip_acks = false;
 
 private:
   GDBRemoteCommunicationReplayServer(
       const GDBRemoteCommunicationReplayServer &) = delete;
   const GDBRemoteCommunicationReplayServer &
   operator=(const GDBRemoteCommunicationReplayServer &) = delete;
 };
 
 } // namespace process_gdb_remote
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_PROCESS_GDB_REMOTE_GDBREMOTECOMMUNICATIONREPLAYSERVER_H

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

static bool skip(llvm::StringRef data) {
   return false;
 }
 
 GDBRemoteCommunicationReplayServer::GDBRemoteCommunicationReplayServer()
     : GDBRemoteCommunication("gdb-replay", "gdb-replay.rx_packet"),
       m_async_broadcaster(nullptr, "lldb.gdb-replay.async-broadcaster"),
       m_async_listener_sp(
           Listener::MakeListener("lldb.gdb-replay.async-listener")),
-      m_async_thread_state_mutex(), m_skip_acks(false) {
+      m_async_thread_state_mutex() {
   m_async_broadcaster.SetEventName(eBroadcastBitAsyncContinue,
                                    "async thread continue");
   m_async_broadcaster.SetEventName(eBroadcastBitAsyncThreadShouldExit,
                                    "async thread should exit");
 
   const uint32_t async_event_mask =
       eBroadcastBitAsyncContinue | eBroadcastBitAsyncThreadShouldExit;
   m_async_listener_sp->StartListeningForEvents(&m_async_broadcaster,

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() : m_py_obj(nullptr) {}
+  PythonObject() {}
 
   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)
if (!m_py_obj || !cls.IsValid())
       return nullDeref();
     int r = PyObject_IsInstance(m_py_obj, cls.get());
     if (r < 0)
       return exception();
     return !!r;
   }
 
 protected:
-  PyObject *m_py_obj;
+  PyObject *m_py_obj = nullptr;
 };
 
 
 // This is why C++ needs monads.
 template <typename T> llvm::Expected<T> As(llvm::Expected<PythonObject> &&obj) {
   if (!obj)
     return obj.takeError();
   if (!T::Check(obj.get().get()))

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

 // Initializing Python is not a straightforward process.  We cannot control
 // what external code may have done before getting to this point in LLDB,
 // including potentially having already initialized Python, so we need to do a
 // lot of work to ensure that the existing state of the system is maintained
 // across our initialization.  We do this by using an RAII pattern where we
 // save off initial state at the beginning, and restore it at the end
 struct InitializePythonRAII {
 public:
-  InitializePythonRAII()
-      : m_gil_state(PyGILState_UNLOCKED), m_was_already_initialized(false) {
+  InitializePythonRAII() {
     InitializePythonHome();
 
 #ifdef LLDB_USE_LIBEDIT_READLINE_COMPAT_MODULE
     // Python's readline is incompatible with libedit being linked into lldb.
     // Provide a patched version local to the embedded interpreter.
     bool ReadlinePatched = false;
     for (auto *p = PyImport_Inittab; p->name != NULL; p++) {
       if (strcmp(p->name, "readline") == 0) {
if (PyEval_ThreadsInitialized()) {
       return;
     }
 
     // InitThreads acquires the GIL if it hasn't been called before.
     PyEval_InitThreads();
   }
 
   TerminalState m_stdin_tty_state;
-  PyGILState_STATE m_gil_state;
-  bool m_was_already_initialized;
+  PyGILState_STATE m_gil_state = PyGILState_UNLOCKED;
+  bool m_was_already_initialized = false;
 };
 } // namespace
 
 void ScriptInterpreterPython::ComputePythonDirForApple(
     llvm::SmallVectorImpl<char> &path) {
   auto style = llvm::sys::path::Style::posix;
 
   llvm::StringRef path_ref(path.begin(), path.size());

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

static constexpr OptionDefinition g_enable_option_table[] = {
      "{parent-activity}:{activity}[:...]."},
     {LLDB_OPT_SET_ALL, false, "all-fields", 'A', OptionParser::eNoArgument,
      nullptr, {}, 0, eArgTypeNone,
      "Shortcut to specify that all header fields should be displayed."}};
 
 class EnableOptions : public Options {
 public:
   EnableOptions()
-      : Options(), m_include_debug_level(false), m_include_info_level(false),
-        m_include_any_process(false),
+      : Options(),
         m_filter_fall_through_accepts(DEFAULT_FILTER_FALLTHROUGH_ACCEPTS),
-        m_echo_to_stderr(false), m_display_timestamp_relative(false),
-        m_display_subsystem(false), m_display_category(false),
-        m_display_activity_chain(false), m_broadcast_events(true),
-        m_live_stream(true), m_filter_rules() {}
+        m_filter_rules() {}
 
   void OptionParsingStarting(ExecutionContext *execution_context) override {
     m_include_debug_level = false;
     m_include_info_level = false;
     m_include_any_process = false;
     m_filter_fall_through_accepts = DEFAULT_FILTER_FALLTHROUGH_ACCEPTS;
     m_echo_to_stderr = false;
     m_display_timestamp_relative = false;
for (const auto &Item : llvm::enumerate(s_filter_attributes)) {
       if (attribute_name == Item.value())
         return Item.index();
     }
 
     // We didn't match anything.
     return -1;
   }
 
-  bool m_include_debug_level;
-  bool m_include_info_level;
-  bool m_include_any_process;
+  bool m_include_debug_level = false;
+  bool m_include_info_level = false;
+  bool m_include_any_process = false;
   bool m_filter_fall_through_accepts;
-  bool m_echo_to_stderr;
-  bool m_display_timestamp_relative;
-  bool m_display_subsystem;
-  bool m_display_category;
-  bool m_display_activity_chain;
-  bool m_broadcast_events;
-  bool m_live_stream;
+  bool m_echo_to_stderr = false;
+  bool m_display_timestamp_relative = false;
+  bool m_display_subsystem = false;
+  bool m_display_category = false;
+  bool m_display_activity_chain = false;
+  bool m_broadcast_events = true;
+  bool m_live_stream = true;
   FilterRules m_filter_rules;
 };
 
 class EnableCommand : public CommandObjectParsed {
 public:
   EnableCommand(CommandInterpreter &interpreter, bool enable, const char *name,
                 const char *help, const char *syntax)
       : CommandObjectParsed(interpreter, name, help, syntax), m_enable(enable),

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

public:
   ///       user should call this function again to retrieve the next decl.
   ///   llvm::Error - A parsing error occurred.  The debug info is malformed.
   llvm::Expected<lldb_private::DWARFEnumState>
   extract(const lldb_private::DWARFDataExtractor &data,
           lldb::offset_t *offset_ptr);
   bool IsValid();
 
 protected:
-  dw_uleb128_t m_code;
-  dw_tag_t m_tag;
-  uint8_t m_has_children;
+  dw_uleb128_t m_code = InvalidCode;
+  dw_tag_t m_tag = llvm::dwarf::DW_TAG_null;
+  uint8_t m_has_children = 0;
   DWARFAttribute::collection m_attributes;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFABBREVIATIONDECLARATION_H

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

 #include "lldb/Utility/Stream.h"
 
 #include "llvm/Object/Error.h"
 
 #include "DWARFFormValue.h"
 
 using namespace lldb_private;
 
-DWARFAbbreviationDeclaration::DWARFAbbreviationDeclaration()
-    : m_code(InvalidCode), m_tag(llvm::dwarf::DW_TAG_null), m_has_children(0),
-      m_attributes() {}
+DWARFAbbreviationDeclaration::DWARFAbbreviationDeclaration() : m_attributes() {}
 
 DWARFAbbreviationDeclaration::DWARFAbbreviationDeclaration(dw_tag_t tag,
                                                            uint8_t has_children)
     : m_code(InvalidCode), m_tag(tag), m_has_children(has_children),
       m_attributes() {}
 
 llvm::Expected<DWARFEnumState>
 DWARFAbbreviationDeclaration::extract(const DWARFDataExtractor &data,

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

 class DWARFAttributes;
 class DWARFUnit;
 class DWARFDebugInfoEntry;
 class DWARFDeclContext;
 class SymbolFileDWARF;
 
 class DWARFBaseDIE {
 public:
-  DWARFBaseDIE() : m_cu(nullptr), m_die(nullptr) {}
+  DWARFBaseDIE() {}
 
   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)
public:
   uint64_t GetAttributeValueAsAddress(const dw_attr_t attr,
                                       uint64_t fail_value) const;
 
   enum class Recurse : bool { no, yes };
   size_t GetAttributes(DWARFAttributes &attributes,
                        Recurse recurse = Recurse::yes) const;
 
 protected:
-  DWARFUnit *m_cu;
-  DWARFDebugInfoEntry *m_die;
+  DWARFUnit *m_cu = nullptr;
+  DWARFDebugInfoEntry *m_die = nullptr;
 };
 
 bool operator==(const DWARFBaseDIE &lhs, const DWARFBaseDIE &rhs);
 bool operator!=(const DWARFBaseDIE &lhs, const DWARFBaseDIE &rhs);
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFBASEDIE_H

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

typedef std::vector<DWARFAbbreviationDeclaration>
     DWARFAbbreviationDeclarationColl;
 typedef DWARFAbbreviationDeclarationColl::iterator
     DWARFAbbreviationDeclarationCollIter;
 typedef DWARFAbbreviationDeclarationColl::const_iterator
     DWARFAbbreviationDeclarationCollConstIter;
 
 class DWARFAbbreviationDeclarationSet {
 public:
-  DWARFAbbreviationDeclarationSet()
-      : m_offset(DW_INVALID_OFFSET), m_idx_offset(0), m_decls() {}
+  DWARFAbbreviationDeclarationSet() : m_offset(DW_INVALID_OFFSET), m_decls() {}
 
   DWARFAbbreviationDeclarationSet(dw_offset_t offset, uint32_t idx_offset)
       : m_offset(offset), m_idx_offset(idx_offset), m_decls() {}
 
   void Clear();
   dw_offset_t GetOffset() const { return m_offset; }
 
   /// Extract all abbrev decls in a set.  Returns llvm::ErrorSuccess() on
   /// success, and an appropriate llvm::Error object otherwise.
   llvm::Error extract(const lldb_private::DWARFDataExtractor &data,
                       lldb::offset_t *offset_ptr);
   // void Encode(BinaryStreamBuf& debug_abbrev_buf) const;
   void GetUnsupportedForms(std::set<dw_form_t> &invalid_forms) const;
 
   const DWARFAbbreviationDeclaration *
   GetAbbreviationDeclaration(dw_uleb128_t abbrCode) const;
 
   /// Unit test accessor functions.
   /// @{
   uint32_t GetIndexOffset() const { return m_idx_offset; }
   /// @}
 private:
   dw_offset_t m_offset;
-  uint32_t m_idx_offset;
+  uint32_t m_idx_offset = 0;
   std::vector<DWARFAbbreviationDeclaration> m_decls;
 };
 
 typedef std::map<dw_offset_t, DWARFAbbreviationDeclarationSet>
     DWARFAbbreviationDeclarationCollMap;
 typedef DWARFAbbreviationDeclarationCollMap::iterator
     DWARFAbbreviationDeclarationCollMapIter;
 typedef DWARFAbbreviationDeclarationCollMap::const_iterator

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

 /// std::vector, we cannot delete the copy constructor.
 class DWARFDebugInfoEntry {
 public:
   typedef std::vector<DWARFDebugInfoEntry> collection;
   typedef collection::iterator iterator;
   typedef collection::const_iterator const_iterator;
 
   DWARFDebugInfoEntry()
-      : m_offset(DW_INVALID_OFFSET), m_parent_idx(0), m_sibling_idx(0),
-        m_has_children(false), m_abbr_idx(0), m_tag(llvm::dwarf::DW_TAG_null) {}
+      : m_offset(DW_INVALID_OFFSET), m_sibling_idx(0), m_has_children(false) {}
 
   explicit operator bool() const { return m_offset != DW_INVALID_OFFSET; }
   bool operator==(const DWARFDebugInfoEntry &rhs) const;
   bool operator!=(const DWARFDebugInfoEntry &rhs) const;
 
   void BuildFunctionAddressRangeTable(DWARFUnit *cu,
                                       DWARFDebugAranges *debug_aranges) const;
 
public:
   // that are local to a function, as they have local scope.
   bool IsGlobalOrStaticScopeVariable() const;
 
 protected:
   static DWARFDeclContext
   GetDWARFDeclContextStatic(const DWARFDebugInfoEntry *die, DWARFUnit *cu);
 
   dw_offset_t m_offset; // Offset within the .debug_info/.debug_types
-  uint32_t m_parent_idx; // How many to subtract from "this" to get the parent.
-                         // If zero this die has no parent
+  uint32_t m_parent_idx = 0;   // How many to subtract from "this" to get the
+                               // parent. If zero this die has no parent
   uint32_t m_sibling_idx : 31, // How many to add to "this" to get the sibling.
       // If it is zero, then the DIE doesn't have children, or the
       // DWARF claimed it had children but the DIE only contained
       // a single NULL terminating child.
       m_has_children : 1;
-  uint16_t m_abbr_idx;
+  uint16_t m_abbr_idx = 0;
   /// A copy of the DW_TAG value so we don't have to go through the compile
   /// unit abbrev table
   dw_tag_t m_tag = llvm::dwarf::DW_TAG_null;
 
 private:
   size_t GetAttributes(DWARFUnit *cu, DWARFAttributes &attrs, Recurse recurse,
                        uint32_t curr_depth) const;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFDEBUGINFOENTRY_H

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

 //
 // 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() : tag(llvm::dwarf::DW_TAG_null), name(nullptr) {}
+    Entry() {}
     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;
     }
 
     // Test operator
     explicit operator bool() const { return tag != 0; }
 
-    dw_tag_t tag;
-    const char *name;
+    dw_tag_t tag = llvm::dwarf::DW_TAG_null;
+    const char *name = nullptr;
   };
 
-  DWARFDeclContext() : m_entries(), m_language(lldb::eLanguageTypeUnknown) {}
+  DWARFDeclContext() : m_entries() {}
 
   void AppendDeclContext(dw_tag_t tag, const char *name) {
     m_entries.push_back(Entry(tag, name));
   }
 
   bool operator==(const DWARFDeclContext &rhs) const;
   bool operator!=(const DWARFDeclContext &rhs) const { return !(*this == rhs); }
 
public:
   lldb::LanguageType GetLanguage() const { return m_language; }
 
   void SetLanguage(lldb::LanguageType language) { m_language = language; }
 
 protected:
   typedef std::vector<Entry> collection;
   collection m_entries;
   mutable std::string m_qualified_name;
-  lldb::LanguageType m_language;
+  lldb::LanguageType m_language = lldb::eLanguageTypeUnknown;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFDECLCONTEXT_H

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

 
 class DWARFUnit;
 class SymbolFileDWARF;
 class DWARFDIE;
 
 class DWARFFormValue {
 public:
   typedef struct ValueTypeTag {
-    ValueTypeTag() : value(), data(nullptr) { value.uval = 0; }
+    ValueTypeTag() : value() { value.uval = 0; }
 
     union {
       uint64_t uval;
       int64_t sval;
       const char *cstr;
     } value;
-    const uint8_t *data;
+    const uint8_t *data = nullptr;
   } ValueType;
 
   enum {
     eValueTypeInvalid = 0,
     eValueTypeUnsigned,
     eValueTypeSigned,
     eValueTypeCStr,
     eValueTypeBlock

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

public:
 
     size_t GetMinimumHashDataByteSize() const;
 
     bool HashDataHasFixedByteSize() const;
 
     /// DIE offset base so die offsets in hash_data can be CU relative.
     dw_offset_t die_base_offset;
     AtomArray atoms;
-    uint32_t atom_mask;
-    size_t min_hash_data_byte_size;
-    bool hash_data_has_fixed_byte_size;
+    uint32_t atom_mask = 0;
+    size_t min_hash_data_byte_size = 0;
+    bool hash_data_has_fixed_byte_size = true;
   };
 
   class Header : public MappedHash::Header<Prologue> {
   public:
     size_t GetByteSize(const HeaderData &header_data) override;
 
     lldb::offset_t Read(lldb_private::DataExtractor &data,
                         lldb::offset_t offset) override;

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

const char *DWARFMappedHash::GetAtomTypeName(uint16_t atom) {
   return "<invalid>";
 }
 
 DWARFMappedHash::DIEInfo::DIEInfo(dw_offset_t o, dw_tag_t t, uint32_t f,
                                   uint32_t h)
     : die_offset(o), tag(t), type_flags(f), qualified_name_hash(h) {}
 
 DWARFMappedHash::Prologue::Prologue(dw_offset_t _die_base_offset)
-    : die_base_offset(_die_base_offset), atoms(), atom_mask(0),
-      min_hash_data_byte_size(0), hash_data_has_fixed_byte_size(true) {
+    : die_base_offset(_die_base_offset), atoms() {
   // Define an array of DIE offsets by first defining an array, and then define
   // the atom type for the array, in this case we have an array of DIE offsets.
   AppendAtom(eAtomTypeDIEOffset, DW_FORM_data4);
 }
 
 void DWARFMappedHash::Prologue::ClearAtoms() {
   hash_data_has_fixed_byte_size = true;
   min_hash_data_byte_size = 0;

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

protected:
 
   // Class specific types
   struct CompileUnitInfo {
     lldb_private::FileSpec so_file;
     lldb_private::ConstString oso_path;
     llvm::sys::TimePoint<> oso_mod_time;
     OSOInfoSP oso_sp;
     lldb::CompUnitSP compile_unit_sp;
-    uint32_t first_symbol_index;
-    uint32_t last_symbol_index;
-    uint32_t first_symbol_id;
-    uint32_t last_symbol_id;
+    uint32_t first_symbol_index = UINT32_MAX;
+    uint32_t last_symbol_index = UINT32_MAX;
+    uint32_t first_symbol_id = UINT32_MAX;
+    uint32_t last_symbol_id = UINT32_MAX;
     FileRangeMap file_range_map;
-    bool file_range_map_valid;
+    bool file_range_map_valid = false;
 
     CompileUnitInfo()
         : so_file(), oso_path(), oso_mod_time(), oso_sp(), compile_unit_sp(),
-          first_symbol_index(UINT32_MAX), last_symbol_index(UINT32_MAX),
-          first_symbol_id(UINT32_MAX), last_symbol_id(UINT32_MAX),
-          file_range_map(), file_range_map_valid(false) {}
+
+          file_range_map() {}
 
     const FileRangeMap &GetFileRangeMap(SymbolFileDWARFDebugMap *exe_symfile);
   };
 
   // Protected Member Functions
   void InitOSO();
 
   uint32_t CalculateNumCompileUnits() override;
protected:
 
   UniqueDWARFASTTypeMap &GetUniqueDWARFASTTypeMap() {
     return m_unique_ast_type_map;
   }
 
   // OSOEntry
   class OSOEntry {
   public:
-    OSOEntry()
-        : m_exe_sym_idx(UINT32_MAX), m_oso_file_addr(LLDB_INVALID_ADDRESS) {}
+    OSOEntry() {}
 
     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::addr_t GetOSOFileAddress() const { return m_oso_file_addr; }
 
     void SetOSOFileAddress(lldb::addr_t oso_file_addr) {
       m_oso_file_addr = oso_file_addr;
     }
 
   protected:
-    uint32_t m_exe_sym_idx;
-    lldb::addr_t m_oso_file_addr;
+    uint32_t m_exe_sym_idx = UINT32_MAX;
+    lldb::addr_t m_oso_file_addr = LLDB_INVALID_ADDRESS;
   };
 
   typedef lldb_private::RangeDataVector<lldb::addr_t, lldb::addr_t, OSOEntry>
       DebugMap;
 
   // Member Variables
   std::bitset<kNumFlags> m_flags;
   std::vector<CompileUnitInfo> m_compile_unit_infos;

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

 #include "llvm/ADT/DenseMap.h"
 
 #include "DWARFDIE.h"
 #include "lldb/Core/Declaration.h"
 
 class UniqueDWARFASTType {
 public:
   // Constructors and Destructors
-  UniqueDWARFASTType()
-      : m_type_sp(), m_die(), m_declaration(),
-        m_byte_size(
-            -1) // Set to negative value to make sure we have a valid value
-  {}
+  UniqueDWARFASTType() : m_type_sp(), m_die(), m_declaration() {}
 
   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),
if (this != &rhs) {
       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;
+  int32_t m_byte_size = -1;
 };
 
 class UniqueDWARFASTTypeList {
 public:
   UniqueDWARFASTTypeList() : m_collection() {}
 
   ~UniqueDWARFASTTypeList() {}
 

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

 
 class AppleGetItemInfoHandler {
 public:
   AppleGetItemInfoHandler(lldb_private::Process *process);
 
   ~AppleGetItemInfoHandler();
 
   struct GetItemInfoReturnInfo {
-    lldb::addr_t item_buffer_ptr;  /* the address of the item buffer from
-                                      libBacktraceRecording */
-    lldb::addr_t item_buffer_size; /* the size of the item buffer from
+    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()
-        : item_buffer_ptr(LLDB_INVALID_ADDRESS), item_buffer_size(0) {}
+    GetItemInfoReturnInfo() {}
   };
 
   /// 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/AppleGetPendingItemsHandler.h

 
 class AppleGetPendingItemsHandler {
 public:
   AppleGetPendingItemsHandler(lldb_private::Process *process);
 
   ~AppleGetPendingItemsHandler();
 
   struct GetPendingItemsReturnInfo {
-    lldb::addr_t items_buffer_ptr; /* the address of the pending items buffer
-                                      from libBacktraceRecording */
-    lldb::addr_t
-        items_buffer_size; /* the size of the pending items buffer from
-                              libBacktraceRecording */
-    uint64_t count; /* the number of pending items included in the buffer */
+    lldb::addr_t items_buffer_ptr =
+        LLDB_INVALID_ADDRESS; /* the address of the pending items buffer
+    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()
-        : items_buffer_ptr(LLDB_INVALID_ADDRESS), items_buffer_size(0),
-          count(0) {}
+
+    {}
   };
 
   /// 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/AppleGetQueuesHandler.h

 
 class AppleGetQueuesHandler {
 public:
   AppleGetQueuesHandler(lldb_private::Process *process);
 
   ~AppleGetQueuesHandler();
 
   struct GetQueuesReturnInfo {
-    lldb::addr_t queues_buffer_ptr;  /* the address of the queues buffer from
-                                        libBacktraceRecording */
-    lldb::addr_t queues_buffer_size; /* the size of the queues buffer from
+    lldb::addr_t queues_buffer_ptr =
+        LLDB_INVALID_ADDRESS; /* the address of the queues buffer from
+    lldb::addr_t queues_buffer_size = 0; /* the size of the queues buffer from
                                         libBacktraceRecording */
-    uint64_t count; /* the number of queues included in the queues buffer */
+    uint64_t count = 0; /* the number of queues included in the queues buffer */
 
     GetQueuesReturnInfo()
-        : queues_buffer_ptr(LLDB_INVALID_ADDRESS), queues_buffer_size(0),
-          count(0) {}
+
+    {}
   };
 
   /// 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/AppleGetThreadItemInfoHandler.h

 
 class AppleGetThreadItemInfoHandler {
 public:
   AppleGetThreadItemInfoHandler(lldb_private::Process *process);
 
   ~AppleGetThreadItemInfoHandler();
 
   struct GetThreadItemInfoReturnInfo {
-    lldb::addr_t item_buffer_ptr;  /* the address of the item buffer from
-                                      libBacktraceRecording */
-    lldb::addr_t item_buffer_size; /* the size of the item buffer from
+    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()
-        : item_buffer_ptr(LLDB_INVALID_ADDRESS), item_buffer_size(0) {}
+    GetThreadItemInfoReturnInfo() {}
   };
 
   /// 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/SystemRuntimeMacOSX.h

public:
   uint32_t GetPluginVersion() override;
 
 protected:
   lldb::user_id_t m_break_id;
   mutable std::recursive_mutex m_mutex;
 
 private:
   struct libBacktraceRecording_info {
-    uint16_t queue_info_version;
-    uint16_t queue_info_data_offset;
-    uint16_t item_info_version;
-    uint16_t item_info_data_offset;
-
-    libBacktraceRecording_info()
-        : queue_info_version(0), queue_info_data_offset(0),
-          item_info_version(0), item_info_data_offset(0) {}
+    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() {}
   };
 
   // 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 LibdispatchOffsets {
     }
 
     bool IsValid() { return dqo_version != UINT16_MAX; }
 
     bool LabelIsValid() { return dqo_label != UINT16_MAX; }
   };
 
   struct LibdispatchVoucherOffsets {
-    uint16_t vo_version;
-    uint16_t vo_activity_ids_count;
-    uint16_t vo_activity_ids_count_size;
-    uint16_t vo_activity_ids_array;
-    uint16_t vo_activity_ids_array_entry_size;
+    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()
-        : vo_version(UINT16_MAX), vo_activity_ids_count(UINT16_MAX),
-          vo_activity_ids_count_size(UINT16_MAX),
-          vo_activity_ids_array(UINT16_MAX),
-          vo_activity_ids_array_entry_size(UINT16_MAX) {}
+
+    {}
 
     bool IsValid() { return vo_version != UINT16_MAX; }
   };
 
   struct LibdispatchTSDIndexes {
-    uint16_t dti_version;
-    uint64_t dti_queue_index;
-    uint64_t dti_voucher_index;
-    uint64_t dti_qos_class_index;
-
-    LibdispatchTSDIndexes()
-        : dti_version(UINT16_MAX), dti_queue_index(UINT64_MAX),
-          dti_voucher_index(UINT64_MAX), dti_qos_class_index(UINT64_MAX) {}
+    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() {}
 
     bool IsValid() { return dti_version != UINT16_MAX; }
   };
 
   struct LibpthreadOffsets {
-    uint16_t plo_version;
-    uint16_t plo_pthread_tsd_base_offset;
-    uint16_t plo_pthread_tsd_base_address_offset;
-    uint16_t plo_pthread_tsd_entry_size;
+    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()
-        : plo_version(UINT16_MAX), plo_pthread_tsd_base_offset(UINT16_MAX),
-          plo_pthread_tsd_base_address_offset(UINT16_MAX),
-          plo_pthread_tsd_entry_size(UINT16_MAX) {}
+
+    {}
 
     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

public:
   /// valid RegisterContext.
   void Initialize(lldb::RegisterContextSP &reg_ctx);
 
   /// 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;
-    uint32_t lldb_regnum;
-    lldb_reg_info() : name(nullptr), lldb_regnum(LLDB_INVALID_REGNUM) {}
+    const char *name = nullptr;
+    uint32_t lldb_regnum = LLDB_INVALID_REGNUM;
+    lldb_reg_info() {}
   };
   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/LineEntry.cpp

 //===-- LineEntry.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/LineEntry.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 
 using namespace lldb_private;
 
 LineEntry::LineEntry()
-    : range(), file(), line(LLDB_INVALID_LINE_NUMBER), column(0),
-      is_start_of_statement(0), is_start_of_basic_block(0), is_prologue_end(0),
-      is_epilogue_begin(0), is_terminal_entry(0) {}
+    : range(), file(), is_start_of_statement(0), is_start_of_basic_block(0),
+      is_prologue_end(0), is_epilogue_begin(0), is_terminal_entry(0) {}
 
 LineEntry::LineEntry(const lldb::SectionSP &section_sp,
                      lldb::addr_t section_offset, lldb::addr_t byte_size,
                      const FileSpec &_file, uint32_t _line, uint16_t _column,
                      bool _is_start_of_statement, bool _is_start_of_basic_block,
                      bool _is_prologue_end, bool _is_epilogue_begin,
                      bool _is_terminal_entry)
     : range(section_sp, section_offset, byte_size), file(_file),

lldb/source/Symbol/Symbol.cpp

 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/Stream.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 Symbol::Symbol()
-    : SymbolContextScope(), m_uid(UINT32_MAX), m_type_data(0),
-      m_type_data_resolved(false), m_is_synthetic(false), m_is_debug(false),
-      m_is_external(false), m_size_is_sibling(false),
+    : SymbolContextScope(), m_type_data_resolved(false), m_is_synthetic(false),
+      m_is_debug(false), m_is_external(false), m_size_is_sibling(false),
       m_size_is_synthesized(false), m_size_is_valid(false),
       m_demangled_is_synthesized(false), m_contains_linker_annotations(false),
-      m_is_weak(false), m_type(eSymbolTypeInvalid), m_mangled(), m_addr_range(),
-      m_flags() {}
+      m_is_weak(false), m_type(eSymbolTypeInvalid), m_mangled(),
+      m_addr_range() {}
 
 Symbol::Symbol(uint32_t symID, llvm::StringRef name, SymbolType type, bool external,
                bool is_debug, bool is_trampoline, bool is_artificial,
                const lldb::SectionSP &section_sp, addr_t offset, addr_t size,
                bool size_is_valid, bool contains_linker_annotations,
                uint32_t flags)
     : SymbolContextScope(), m_uid(symID), m_type_data(0),
       m_type_data_resolved(false), m_is_synthetic(is_artificial),

lldb/source/Symbol/SymbolContext.cpp

 #include "lldb/Symbol/Variable.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-SymbolContext::SymbolContext()
-    : target_sp(), module_sp(), comp_unit(nullptr), function(nullptr),
-      block(nullptr), line_entry(), symbol(nullptr), variable(nullptr) {}
+SymbolContext::SymbolContext() : target_sp(), module_sp(), line_entry() {}
 
 SymbolContext::SymbolContext(const ModuleSP &m, CompileUnit *cu, Function *f,
                              Block *b, LineEntry *le, Symbol *s)
     : target_sp(), module_sp(m), comp_unit(cu), function(f), block(b),
       line_entry(), symbol(s), variable(nullptr) {
   if (le)
     line_entry = *le;
 }

lldb/source/Symbol/Type.cpp

if (byte_size) {
     m_byte_size_has_value = true;
   } else {
     m_byte_size = 0;
     m_byte_size_has_value = false;
   }
 }
 
 Type::Type()
-    : std::enable_shared_from_this<Type>(), UserID(0), m_name("<INVALID TYPE>"),
-      m_symbol_file(nullptr), m_context(nullptr), m_encoding_type(nullptr),
-      m_encoding_uid(LLDB_INVALID_UID), m_encoding_uid_type(eEncodingInvalid),
-      m_compiler_type_resolve_state(ResolveState::Unresolved) {
+    : std::enable_shared_from_this<Type>(), UserID(0),
+      m_name("<INVALID TYPE>") {
   m_byte_size = 0;
   m_byte_size_has_value = false;
 }
 
 void Type::GetDescription(Stream *s, lldb::DescriptionLevel level,
                           bool show_name, ExecutionContextScope *exe_scope) {
   *s << "id = " << (const UserID &)*this;
 

lldb/source/Symbol/TypeSystem.cpp

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

lldb/source/Symbol/UnwindPlan.cpp

for (collection::const_iterator idx = m_register_locations.begin();
        idx != m_register_locations.end(); ++idx) {
     DumpRegisterName(s, unwind_plan, thread, idx->first);
     const bool verbose = false;
     idx->second.Dump(s, unwind_plan, this, thread, verbose);
     s.PutChar(' ');
   }
 }
 
-UnwindPlan::Row::Row()
-    : m_offset(0), m_cfa_value(), m_afa_value(), m_register_locations(),
-      m_unspecified_registers_are_undefined(false) {}
+UnwindPlan::Row::Row() : m_cfa_value(), m_afa_value(), m_register_locations() {}
 
 bool UnwindPlan::Row::GetRegisterInfo(
     uint32_t reg_num,
     UnwindPlan::Row::RegisterLocation &register_location) const {
   collection::const_iterator pos = m_register_locations.find(reg_num);
   if (pos != m_register_locations.end()) {
     register_location = pos->second;
     return true;

lldb/source/Target/ExecutionContext.cpp

bool ExecutionContext::HasThreadScope() const {
   return (HasProcessScope() && ((bool)m_thread_sp && m_thread_sp->IsValid()));
 }
 
 bool ExecutionContext::HasFrameScope() const {
   return HasThreadScope() && m_frame_sp;
 }
 
 ExecutionContextRef::ExecutionContextRef()
-    : m_target_wp(), m_process_wp(), m_thread_wp(),
-      m_tid(LLDB_INVALID_THREAD_ID), m_stack_id() {}
+    : m_target_wp(), m_process_wp(), m_thread_wp(), m_stack_id() {}
 
 ExecutionContextRef::ExecutionContextRef(const ExecutionContext *exe_ctx)
     : m_target_wp(), m_process_wp(), m_thread_wp(),
       m_tid(LLDB_INVALID_THREAD_ID), m_stack_id() {
   if (exe_ctx)
     *this = *exe_ctx;
 }
 

lldb/source/Target/PathMappingList.cpp

namespace {
   // nomalized path pairs to ensure things match up.
   ConstString NormalizePath(ConstString path) {
     // If we use "path" to construct a FileSpec, it will normalize the path for
     // us. We then grab the string and turn it back into a ConstString.
     return ConstString(FileSpec(path.GetStringRef()).GetPath());
   }
 }
 // PathMappingList constructor
-PathMappingList::PathMappingList()
-    : m_pairs(), m_callback(nullptr), m_callback_baton(nullptr), m_mod_id(0) {}
+PathMappingList::PathMappingList() : m_pairs() {}
 
 PathMappingList::PathMappingList(ChangedCallback callback, void *callback_baton)
     : m_pairs(), m_callback(callback), m_callback_baton(callback_baton),
       m_mod_id(0) {}
 
 PathMappingList::PathMappingList(const PathMappingList &rhs)
     : m_pairs(rhs.m_pairs), m_callback(nullptr), m_callback_baton(nullptr),
       m_mod_id(0) {}

lldb/source/Target/Process.cpp

thread_result_t Process::RunPrivateStateThread(bool is_secondary_thread) {
   // it was doing yet, so don't try to change it on the way out.
   if (!is_secondary_thread)
     m_public_run_lock.SetStopped();
   return {};
 }
 
 // Process Event Data
 
-Process::ProcessEventData::ProcessEventData()
-    : EventData(), m_process_wp(), m_state(eStateInvalid), m_restarted(false),
-      m_update_state(0), m_interrupted(false) {}
+Process::ProcessEventData::ProcessEventData() : EventData(), m_process_wp() {}
 
 Process::ProcessEventData::ProcessEventData(const ProcessSP &process_sp,
                                             StateType state)
     : EventData(), m_process_wp(), m_state(state), m_restarted(false),
       m_update_state(0), m_interrupted(false) {
   if (process_sp)
     m_process_wp = process_sp;
 }

lldb/source/Target/RegisterNumber.cpp

const lldb_private::RegisterInfo *reginfo =
         m_reg_ctx_sp->GetRegisterInfoAtIndex(
             GetAsKind(lldb::eRegisterKindLLDB));
     if (reginfo && reginfo->name) {
       m_name = reginfo->name;
     }
   }
 }
 
-RegisterNumber::RegisterNumber()
-    : m_reg_ctx_sp(), m_regnum(LLDB_INVALID_REGNUM),
-      m_kind(lldb::kNumRegisterKinds), m_kind_regnum_map(), m_name(nullptr) {}
+RegisterNumber::RegisterNumber() : m_reg_ctx_sp(), m_kind_regnum_map() {}
 
 void RegisterNumber::init(lldb_private::Thread &thread, lldb::RegisterKind kind,
                           uint32_t num) {
   m_reg_ctx_sp = thread.GetRegisterContext();
   m_regnum = num;
   m_kind = kind;
   if (m_reg_ctx_sp.get()) {
     const lldb_private::RegisterInfo *reginfo =

lldb/source/Target/ThreadSpec.cpp

 
 using namespace lldb;
 using namespace lldb_private;
 
 const char *ThreadSpec::g_option_names[static_cast<uint32_t>(
     ThreadSpec::OptionNames::LastOptionName)]{"Index", "ID", "Name",
                                               "QueueName"};
 
-ThreadSpec::ThreadSpec()
-    : m_index(UINT32_MAX), m_tid(LLDB_INVALID_THREAD_ID), m_name(),
-      m_queue_name() {}
+ThreadSpec::ThreadSpec() : m_name(), m_queue_name() {}
 
 std::unique_ptr<ThreadSpec> ThreadSpec::CreateFromStructuredData(
     const StructuredData::Dictionary &spec_dict, Status &error) {
   uint32_t index = UINT32_MAX;
   lldb::tid_t tid = LLDB_INVALID_THREAD_ID;
   llvm::StringRef name;
   llvm::StringRef queue_name;
 

lldb/source/Utility/DataEncoder.cpp

 #include <cstring>
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace llvm::support::endian;
 
 // Default constructor.
 DataEncoder::DataEncoder()
-    : m_start(nullptr), m_end(nullptr),
-      m_byte_order(endian::InlHostByteOrder()), m_addr_size(sizeof(void *)),
+    : m_byte_order(endian::InlHostByteOrder()), m_addr_size(sizeof(void *)),
       m_data_sp() {}
 
 // This constructor allows us to use data that is owned by someone else. The
 // data must stay around as long as this object is valid.
 DataEncoder::DataEncoder(void *data, uint32_t length, ByteOrder endian,
                          uint8_t addr_size)
     : m_start(static_cast<uint8_t *>(data)),
       m_end(static_cast<uint8_t *>(data) + length), m_byte_order(endian),

lldb/source/Utility/DataExtractor.cpp

else {
     assert(byte_order == eByteOrderLittle);
     for (size_t i = 0; i < byte_size; ++i)
       res = (res << 8) | data[byte_size - 1 - i];
   }
   return res;
 }
 
 DataExtractor::DataExtractor()
-    : m_start(nullptr), m_end(nullptr),
-      m_byte_order(endian::InlHostByteOrder()), m_addr_size(sizeof(void *)),
-      m_data_sp(), m_target_byte_size(1) {}
+    : m_byte_order(endian::InlHostByteOrder()), m_addr_size(sizeof(void *)),
+      m_data_sp() {}
 
 // This constructor allows us to use data that is owned by someone else. The
 // data must stay around as long as this object is valid.
 DataExtractor::DataExtractor(const void *data, offset_t length,
                              ByteOrder endian, uint32_t addr_size,
                              uint32_t target_byte_size /*=1*/)
     : m_start(const_cast<uint8_t *>(static_cast<const uint8_t *>(data))),
       m_end(const_cast<uint8_t *>(static_cast<const uint8_t *>(data)) + length),

lldb/source/Utility/ProcessInfo.cpp

 
 #include <climits>
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::repro;
 
 ProcessInfo::ProcessInfo()
-    : m_executable(), m_arguments(), m_environment(), m_uid(UINT32_MAX),
-      m_gid(UINT32_MAX), m_arch(), m_pid(LLDB_INVALID_PROCESS_ID) {}
+    : m_executable(), m_arguments(), m_environment(), m_arch() {}
 
 ProcessInfo::ProcessInfo(const char *name, const ArchSpec &arch,
                          lldb::pid_t pid)
     : m_executable(name), m_arguments(), m_environment(), m_uid(UINT32_MAX),
       m_gid(UINT32_MAX), m_arch(arch), m_pid(pid) {}
 
 void ProcessInfo::Clear() {
   m_executable.Clear();

lldb/source/Utility/ReproducerInstrumentation.cpp

unsigned ObjectToIndex::GetIndexForObjectImpl(const void *object) {
   unsigned index = m_mapping.size() + 1;
   auto it = m_mapping.find(object);
   if (it == m_mapping.end())
     m_mapping[object] = index;
   return m_mapping[object];
 }
 
 Recorder::Recorder()
-    : m_serializer(nullptr), m_pretty_func(), m_pretty_args(),
-      m_local_boundary(false), m_result_recorded(true),
+    : m_pretty_func(), m_pretty_args(),
+
       m_sequence(std::numeric_limits<unsigned>::max()) {
   if (!g_global_boundary) {
     g_global_boundary = true;
     m_local_boundary = true;
     m_sequence = GetNextSequenceNumber();
   }
 }
 

lldb/source/Utility/Status.cpp

 
 namespace llvm {
 class raw_ostream;
 }
 
 using namespace lldb;
 using namespace lldb_private;
 
-Status::Status() : m_code(0), m_type(eErrorTypeInvalid), m_string() {}
+Status::Status() : m_string() {}
 
 Status::Status(ValueType err, ErrorType type)
     : m_code(err), m_type(type), m_string() {}
 
 // This logic is confusing because c++ calls the traditional (posix) errno codes
 // "generic errors", while we use the term "generic" to mean completely
 // arbitrary (text-based) errors.
 Status::Status(std::error_code EC)

lldb/source/Utility/Stream.cpp

 using namespace lldb_private;
 
 Stream::Stream(uint32_t flags, uint32_t addr_size, ByteOrder byte_order,
                bool colors)
     : 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_addr_size(4), m_byte_order(endian::InlHostByteOrder()),
-      m_indent_level(0), m_forwarder(*this, colors) {}
+    : m_flags(0), m_byte_order(endian::InlHostByteOrder()),
+      m_forwarder(*this, colors) {}
 
 // Destructor
 Stream::~Stream() {}
 
 ByteOrder Stream::SetByteOrder(ByteOrder byte_order) {
   ByteOrder old_byte_order = m_byte_order;
   m_byte_order = byte_order;
   return old_byte_order;

lldb/source/Utility/StringExtractor.cpp

static inline int xdigit_to_sint(char ch) {
   if (ch >= 'A' && ch <= 'F')
     return 10 + ch - 'A';
   if (ch >= '0' && ch <= '9')
     return ch - '0';
   return -1;
 }
 
 // StringExtractor constructor
-StringExtractor::StringExtractor() : m_packet(), m_index(0) {}
+StringExtractor::StringExtractor() : m_packet() {}
 
 StringExtractor::StringExtractor(llvm::StringRef packet_str)
     : m_packet(), m_index(0) {
   m_packet.assign(packet_str.begin(), packet_str.end());
 }
 
 StringExtractor::StringExtractor(const char *packet_cstr)
     : m_packet(), m_index(0) {