Applying clang-tidy modernize-use-default-member-init over LLDB

[shafik]

Summary

Applied modernize-use-default-member-init clang-tidy check over LLDB.

It appears in many files we had already switched to in class member init but never updated the constructors to reflect that.

This check is already present in the lldb/.clang-tidy config.

[kastiglione]

lldb/source/API/SBQueue.cpp

31–32

should you also run clang-format?

[shafik]

Applying clang-format

[labath]

cool

lldb/source/API/SBBroadcaster.cpp

 #include "lldb/API/SBListener.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 SBBroadcaster::SBBroadcaster() { LLDB_INSTRUMENT_VA(this); }
 
 SBBroadcaster::SBBroadcaster(const char *name)
-    : m_opaque_sp(new Broadcaster(nullptr, name)), m_opaque_ptr(nullptr) {
+    : m_opaque_sp(new Broadcaster(nullptr, name)) {
   LLDB_INSTRUMENT_VA(this, 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/SBListener.cpp

 #include "lldb/Utility/StreamString.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 SBListener::SBListener() { LLDB_INSTRUMENT_VA(this); }
 
 SBListener::SBListener(const char *name)
-    : m_opaque_sp(Listener::MakeListener(name)), m_unused_ptr(nullptr) {
+    : m_opaque_sp(Listener::MakeListener(name)) {
   LLDB_INSTRUMENT_VA(this, name);
 }
 
-SBListener::SBListener(const SBListener &rhs)
-    : m_opaque_sp(rhs.m_opaque_sp), m_unused_ptr(nullptr) {
+SBListener::SBListener(const SBListener &rhs) : m_opaque_sp(rhs.m_opaque_sp) {
   LLDB_INSTRUMENT_VA(this, rhs);
 }
 
 const lldb::SBListener &SBListener::operator=(const lldb::SBListener &rhs) {
   LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this != &rhs) {
     m_opaque_sp = rhs.m_opaque_sp;
     m_unused_ptr = nullptr;
   }
   return *this;
 }
 
 SBListener::SBListener(const lldb::ListenerSP &listener_sp)
-    : m_opaque_sp(listener_sp), m_unused_ptr(nullptr) {}
+    : m_opaque_sp(listener_sp) {}
 
 SBListener::~SBListener() = default;
 
 bool SBListener::IsValid() const {
   LLDB_INSTRUMENT_VA(this);
   return this->operator bool();
 }
 SBListener::operator bool() const {

lldb/source/API/SBPlatform.cpp

struct PlatformConnectOptions {
   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_status(0), m_signo(0) {
+                       llvm::StringRef shell_command) {
     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()) {

lldb/source/API/SBQueue.cpp

 using namespace lldb;
 using namespace lldb_private;
 
 namespace lldb_private {
 
 class QueueImpl {
 public:
   QueueImpl() {}
 
-  QueueImpl(const lldb::QueueSP &queue_sp)
-      : m_thread_list_fetched(false), m_pending_items_fetched(false) {
-    m_queue_wp = queue_sp;
-  }
+  QueueImpl(const lldb::QueueSP &queue_sp) { m_queue_wp = queue_sp; }
 
   QueueImpl(const QueueImpl &rhs) {
     if (&rhs == this)
       return;
     m_queue_wp = rhs.m_queue_wp;
     m_threads = rhs.m_threads;
     m_thread_list_fetched = rhs.m_thread_list_fetched;
     m_pending_items = rhs.m_pending_items;

lldb/source/Commands/CommandObjectCommands.cpp

 };
 
 class CommandObjectPythonFunction : public CommandObjectRaw {
 public:
   CommandObjectPythonFunction(CommandInterpreter &interpreter, std::string name,
                               std::string funct, std::string help,
                               ScriptedCommandSynchronicity synch)
       : CommandObjectRaw(interpreter, name), m_function_name(funct),
-        m_synchro(synch), m_fetched_help_long(false) {
+        m_synchro(synch) {
     if (!help.empty())
       SetHelp(help);
     else {
       StreamString stream;
       stream.Printf("For more information run 'help %s'", name.c_str());
       SetHelp(stream.GetString());
     }
   }
bool DoExecute(llvm::StringRef raw_command_line,
     }
 
     return result.Succeeded();
   }
 
 private:
   std::string m_function_name;
   ScriptedCommandSynchronicity m_synchro;
-  bool m_fetched_help_long;
+  bool m_fetched_help_long = false;
 };
 
 class CommandObjectScriptingObject : public CommandObjectRaw {
 public:
   CommandObjectScriptingObject(CommandInterpreter &interpreter,
                                std::string name,
                                StructuredData::GenericSP cmd_obj_sp,
                                ScriptedCommandSynchronicity synch)

lldb/source/Commands/CommandObjectMemory.cpp

 public:
   CommandObjectMemoryRead(CommandInterpreter &interpreter)
       : CommandObjectParsed(
             interpreter, "memory read",
             "Read from the memory of the current target process.", nullptr,
             eCommandRequiresTarget | eCommandProcessMustBePaused),
         m_format_options(eFormatBytesWithASCII, 1, 8),
 
-        m_next_addr(LLDB_INVALID_ADDRESS), m_prev_byte_size(0),
         m_prev_format_options(eFormatBytesWithASCII, 1, 8) {
     CommandArgumentEntry arg1;
     CommandArgumentEntry arg2;
     CommandArgumentData start_addr_arg;
     CommandArgumentData end_addr_arg;
 
     // Define the first (and only) variant of this arg.
     start_addr_arg.arg_type = eArgTypeAddressOrExpression;
#undef ALL_KEYWORDS
     return true;
   }
 
   OptionGroupOptions m_option_group;
   OptionGroupFormat m_format_options;
   OptionGroupReadMemory m_memory_options;
   OptionGroupOutputFile m_outfile_options;
   OptionGroupValueObjectDisplay m_varobj_options;
-  lldb::addr_t m_next_addr;
-  lldb::addr_t m_prev_byte_size;
+  lldb::addr_t m_next_addr = LLDB_INVALID_ADDRESS;
+  lldb::addr_t m_prev_byte_size = 0;
   OptionGroupFormat m_prev_format_options;
   OptionGroupReadMemory m_prev_memory_options;
   OptionGroupOutputFile m_prev_outfile_options;
   OptionGroupValueObjectDisplay m_prev_varobj_options;
   CompilerType m_prev_compiler_type;
 };
 
 #define LLDB_OPTIONS_memory_find
public:
   ~CommandObjectMemoryFind() override = default;
 
   Options *GetOptions() override { return &m_option_group; }
 
 protected:
   class ProcessMemoryIterator {
   public:
     ProcessMemoryIterator(ProcessSP process_sp, lldb::addr_t base)
-        : m_process_sp(process_sp), m_base_addr(base), m_is_valid(true) {
+        : m_process_sp(process_sp), m_base_addr(base) {
       lldbassert(process_sp.get() != nullptr);
     }
 
     bool IsValid() { return m_is_valid; }
 
     uint8_t operator[](lldb::addr_t offset) {
       if (!IsValid())
         return 0;
 
       uint8_t retval = 0;
       Status error;
       if (0 ==
           m_process_sp->ReadMemory(m_base_addr + offset, &retval, 1, error)) {
         m_is_valid = false;
         return 0;
       }
 
       return retval;
     }
 
   private:
     ProcessSP m_process_sp;
     lldb::addr_t m_base_addr;
-    bool m_is_valid;
+    bool m_is_valid = true;
   };
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     // No need to check "process" for validity as eCommandRequiresProcess
     // ensures it is valid
     Process *process = m_exe_ctx.GetProcessPtr();
 
     const size_t argc = command.GetArgumentCount();
 

 class CommandObjectMemoryRegion : public CommandObjectParsed {
 public:
   CommandObjectMemoryRegion(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "memory region",
                             "Get information on the memory region containing "
                             "an address in the current target process.",
                             "memory region ADDR",
                             eCommandRequiresProcess | eCommandTryTargetAPILock |
-                                eCommandProcessMustBeLaunched),
-        m_prev_end_addr(LLDB_INVALID_ADDRESS) {}
+                                eCommandProcessMustBeLaunched) {}
 
   ~CommandObjectMemoryRegion() override = default;
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     ProcessSP process_sp = m_exe_ctx.GetProcessSP();
     if (!process_sp) {
       m_prev_end_addr = LLDB_INVALID_ADDRESS;
protected:
 
   llvm::Optional<std::string> GetRepeatCommand(Args &current_command_args,
                                                uint32_t index) override {
     // If we repeat this command, repeat it without any arguments so we can
     // show the next memory range
     return m_cmd_name;
   }
 
-  lldb::addr_t m_prev_end_addr;
+  lldb::addr_t m_prev_end_addr = LLDB_INVALID_ADDRESS;
 };
 
 // CommandObjectMemory
 
 CommandObjectMemory::CommandObjectMemory(CommandInterpreter &interpreter)
     : CommandObjectMultiword(
           interpreter, "memory",
           "Commands for operating on memory in the current target process.",

lldb/source/Commands/CommandObjectMemoryTag.cpp

 
 #define LLDB_OPTIONS_memory_tag_write
 #include "CommandOptions.inc"
 
 class CommandObjectMemoryTagWrite : public CommandObjectParsed {
 public:
   class OptionGroupTagWrite : public OptionGroup {
   public:
-    OptionGroupTagWrite() : m_end_addr(LLDB_INVALID_ADDRESS) {}
+    OptionGroupTagWrite() {}
 
     ~OptionGroupTagWrite() override = default;
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_memory_tag_write_options);
     }
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
 
       return status;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_end_addr = LLDB_INVALID_ADDRESS;
     }
 
-    lldb::addr_t m_end_addr;
+    lldb::addr_t m_end_addr = LLDB_INVALID_ADDRESS;
   };
 
   CommandObjectMemoryTagWrite(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "tag",
                             "Write memory tags starting from the granule that "
                             "contains the given address.",
                             nullptr,
                             eCommandRequiresTarget | eCommandRequiresProcess |

lldb/source/Commands/CommandObjectProcess.cpp

CommandObjectProcessSaveCore(CommandInterpreter &interpreter)
                 eCommandProcessMustBeLaunched) {}
 
   ~CommandObjectProcessSaveCore() override = default;
 
   Options *GetOptions() override { return &m_options; }
 
   class CommandOptions : public Options {
   public:
-    CommandOptions() : m_requested_save_core_style(eSaveCoreUnspecified) {}
+    CommandOptions() {}
 
     ~CommandOptions() override = default;
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_process_save_core_options);
     }
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
public:
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_requested_save_core_style = eSaveCoreUnspecified;
       m_requested_plugin_name.clear();
     }
 
     // Instance variables to hold the values for command options.
-    SaveCoreStyle m_requested_save_core_style;
+    SaveCoreStyle m_requested_save_core_style = eSaveCoreUnspecified;
     std::string m_requested_plugin_name;
   };
 
 protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     ProcessSP process_sp = m_exe_ctx.GetProcessSP();
     if (process_sp) {
       if (command.GetArgumentCount() == 1) {

lldb/source/Commands/CommandObjectThread.cpp

CommandObjectTraceDumpInstructions(CommandInterpreter &interpreter)
       : CommandObjectIterateOverThreads(
             interpreter, "thread trace dump instructions",
             "Dump the traced instructions for one or more threads. If no "
             "threads are specified, show the current thread.  Use the "
             "thread-index \"all\" to see all threads.",
             nullptr,
             eCommandRequiresProcess | eCommandTryTargetAPILock |
                 eCommandProcessMustBeLaunched | eCommandProcessMustBePaused |
-                eCommandProcessMustBeTraced),
-        m_create_repeat_command_just_invoked(false) {}
+                eCommandProcessMustBeTraced) {}
 
   ~CommandObjectTraceDumpInstructions() override = default;
 
   Options *GetOptions() override { return &m_options; }
 
   llvm::Optional<std::string> GetRepeatCommand(Args &current_command_args,
                                                uint32_t index) override {
     current_command_args.GetCommandString(m_repeat_command);
bool HandleOneThread(lldb::tid_t tid, CommandReturnObject &result) override {
     m_dumpers[thread_sp->GetID()]->DumpInstructions(s, m_options.m_count);
     return true;
   }
 
   CommandOptions m_options;
 
   // Repeat command helpers
   std::string m_repeat_command;
-  bool m_create_repeat_command_just_invoked;
+  bool m_create_repeat_command_just_invoked = false;
   std::map<lldb::tid_t, std::unique_ptr<TraceInstructionDumper>> m_dumpers;
 };
 
 // CommandObjectTraceDumpInfo
 #define LLDB_OPTIONS_thread_trace_dump_info
 #include "CommandOptions.inc"
 
 class CommandObjectTraceDumpInfo : public CommandObjectIterateOverThreads {

lldb/source/Core/Address.cpp

static size_t ReadCStringFromMemory(ExecutionContextScope *exe_scope,
   }
   strm->PutChar('"');
   return total_len;
 }
 
 Address::Address(lldb::addr_t abs_addr) : m_section_wp(), m_offset(abs_addr) {}
 
 Address::Address(addr_t address, const SectionList *section_list)
-    : m_section_wp(), m_offset(LLDB_INVALID_ADDRESS) {
+    : m_section_wp() {
   ResolveAddressUsingFileSections(address, section_list);
 }
 
 const Address &Address::operator=(const Address &rhs) {
   if (this != &rhs) {
     m_section_wp = rhs.m_section_wp;
     m_offset = rhs.m_offset;
   }

lldb/source/Core/FormatEntity.cpp

constexpr Definition g_top_level_entries[] = {
     Entry::DefinitionWithChildren("var", EntryType::Variable,
                                   g_var_child_entries, true)};
 
 constexpr Definition g_root = Entry::DefinitionWithChildren(
     "<root>", EntryType::Root, g_top_level_entries);
 
 FormatEntity::Entry::Entry(llvm::StringRef s)
     : string(s.data(), s.size()), printf_format(), children(),
-      type(Type::String), fmt(lldb::eFormatDefault), number(0), deref(false) {}
+      type(Type::String) {}
 
 FormatEntity::Entry::Entry(char ch)
-    : string(1, ch), printf_format(), children(), type(Type::String),
-      fmt(lldb::eFormatDefault), number(0), deref(false) {}
+    : string(1, ch), printf_format(), children(), type(Type::String) {}
 
 void FormatEntity::Entry::AppendChar(char ch) {
   if (children.empty() || children.back().type != Entry::Type::String)
     children.push_back(Entry(ch));
   else
     children.back().string.append(1, ch);
 }
 

lldb/source/Core/IOHandlerCursesGUI.cpp

public:
   HandleCharResult WindowDelegateHandleChar(Window &window, int key) override;
 
   size_t GetNumLines() const { return m_text.GetSize(); }
 
   size_t GetMaxLineLength() const { return m_text.GetMaxStringLength(); }
 
 protected:
   StringList m_text;
-  int m_first_visible_line;
+  int m_first_visible_line = 0;
 };
 
 // A surface is an abstraction for something than can be drawn on. The surface
 // have a width, a height, a cursor position, and a multitude of drawing
 // operations. This type should be sub-classed to get an actually useful ncurses
 // object, such as a Window or a Pad.
 class Surface {
 public:
   enum class Type { Window, Pad };
 
-  Surface(Surface::Type type) : m_type(type), m_window(nullptr) {}
+  Surface(Surface::Type type) : m_type(type) {}
 
   WINDOW *get() { return m_window; }
 
   operator WINDOW *() { return m_window; }
 
   Surface SubSurface(Rect bounds) {
     Surface subSurface(m_type);
     if (m_type == Type::Pad)
while (!string.empty()) {
       }
     }
     wattr_set(m_window, saved_attr, saved_pair, nullptr);
     return result;
   }
 
 protected:
   Type m_type;
-  WINDOW *m_window;
+  WINDOW *m_window = nullptr;
 };
 
 class Pad : public Surface {
 public:
   Pad(Size size) : Surface(Surface::Type::Pad) {
     m_window = ::newpad(size.height, size.width);
   }
 
protected:
   bool m_is_visible = true;
 };
 
 typedef std::unique_ptr<FieldDelegate> FieldDelegateUP;
 
 class TextFieldDelegate : public FieldDelegate {
 public:
   TextFieldDelegate(const char *label, const char *content, bool required)
-      : m_label(label), m_required(required), m_cursor_position(0),
-        m_first_visibile_char(0) {
+      : m_label(label), m_required(required) {
     if (content)
       m_content = content;
   }
 
   // Text fields are drawn as titled boxes of a single line, with a possible
   // error messages at the end.
   //
   // __[Label]___________

 
 protected:
   std::string m_label;
   bool m_required;
   // The position of the top left corner character of the border.
   std::string m_content;
   // The cursor position in the content string itself. Can be in the range
   // [0, GetContentLength()].
-  int m_cursor_position;
+  int m_cursor_position = 0;
   // The index of the first visible character in the content.
-  int m_first_visibile_char;
+  int m_first_visibile_char = 0;
   // Optional error message. If empty, field is considered to have no error.
   std::string m_error;
 };
 
 class IntegerFieldDelegate : public TextFieldDelegate {
 public:
   IntegerFieldDelegate(const char *label, int content, bool required)
       : TextFieldDelegate(label, std::to_string(content).c_str(), required) {}
protected:
   bool m_content;
 };
 
 class ChoicesFieldDelegate : public FieldDelegate {
 public:
   ChoicesFieldDelegate(const char *label, int number_of_visible_choices,
                        std::vector<std::string> choices)
       : m_label(label), m_number_of_visible_choices(number_of_visible_choices),
-        m_choices(choices), m_choice(0), m_first_visibile_choice(0) {}
+        m_choices(choices) {}
 
   // Choices fields are drawn as titles boxses of a number of visible choices.
   // The rest of the choices become visible as the user scroll. The selected
   // choice is denoted by a diamond as the first character.
   //
   // __[Label]___________
   // |-Choice 1         |
   // | Choice 2         |
void SetChoice(llvm::StringRef choice) {
     }
   }
 
 protected:
   std::string m_label;
   int m_number_of_visible_choices;
   std::vector<std::string> m_choices;
   // The index of the selected choice.
-  int m_choice;
+  int m_choice = 0;
   // The index of the first visible choice in the field.
-  int m_first_visibile_choice;
+  int m_first_visibile_choice = 0;
 };
 
 class PlatformPluginFieldDelegate : public ChoicesFieldDelegate {
 public:
   PlatformPluginFieldDelegate(Debugger &debugger)
       : ChoicesFieldDelegate("Platform Plugin", 3, GetPossiblePluginNames()) {
     PlatformSP platform_sp = debugger.GetPlatformList().GetSelectedPlatform();
     if (platform_sp)
LazyBool GetLazyBoolean() {
     else
       return eLazyBoolCalculate;
   }
 };
 
 template <class T> class ListFieldDelegate : public FieldDelegate {
 public:
   ListFieldDelegate(const char *label, T default_field)
-      : m_label(label), m_default_field(default_field), m_selection_index(0),
+      : m_label(label), m_default_field(default_field),
         m_selection_type(SelectionType::NewButton) {}
 
   // Signify which element is selected. If a field or a remove button is
   // selected, then m_selection_index signifies the particular field that
   // is selected or the field that the remove button belongs to.
   enum class SelectionType { Field, RemoveButton, NewButton };
 
   // A List field is drawn as a titled box of a number of other fields of the
public:
   T &GetField(int index) { return m_fields[index]; }
 
 protected:
   std::string m_label;
   // The default field delegate instance from which new field delegates will be
   // created though a copy.
   T m_default_field;
   std::vector<T> m_fields;
-  int m_selection_index;
+  int m_selection_index = 0;
   // See SelectionType class enum.
   SelectionType m_selection_type;
 };
 
 class ArgumentsFieldDelegate : public ListFieldDelegate<TextFieldDelegate> {
 public:
   ArgumentsFieldDelegate()
       : ListFieldDelegate("Arguments",
protected:
   // Optional error message. If empty, form is considered to have no error.
   std::string m_error;
 };
 
 typedef std::shared_ptr<FormDelegate> FormDelegateSP;
 
 class FormWindowDelegate : public WindowDelegate {
 public:
-  FormWindowDelegate(FormDelegateSP &delegate_sp)
-      : m_delegate_sp(delegate_sp), m_selection_index(0),
-        m_first_visible_line(0) {
+  FormWindowDelegate(FormDelegateSP &delegate_sp) : m_delegate_sp(delegate_sp) {
     assert(m_delegate_sp->GetNumberOfActions() > 0);
     if (m_delegate_sp->GetNumberOfFields() > 0)
       m_selection_type = SelectionType::Field;
     else
       m_selection_type = SelectionType::Action;
   }
 
   // Signify which element is selected. If a field or an action is selected,
HandleCharResult WindowDelegateHandleChar(Window &window, int key) override {
     }
 
     return eKeyHandled;
   }
 
 protected:
   FormDelegateSP m_delegate_sp;
   // The index of the currently selected SelectionType.
-  int m_selection_index;
+  int m_selection_index = 0;
   // See SelectionType class enum.
   SelectionType m_selection_type;
   // The first visible line from the pad.
-  int m_first_visible_line;
+  int m_first_visible_line = 0;
 };
 
 ///////////////////////////
 // Form Delegate Instances
 ///////////////////////////
 
 class DetachOrKillProcessFormDelegate : public FormDelegate {
 public:
public:
   virtual void ExecuteCallback(int match_index) = 0;
 };
 
 typedef std::shared_ptr<SearcherDelegate> SearcherDelegateSP;
 
 class SearcherWindowDelegate : public WindowDelegate {
 public:
   SearcherWindowDelegate(SearcherDelegateSP &delegate_sp)
-      : m_delegate_sp(delegate_sp), m_text_field("Search", "", false),
-        m_selected_match(0), m_first_visible_match(0) {
+      : m_delegate_sp(delegate_sp), m_text_field("Search", "", false) {
     ;
   }
 
   // A completion window is padded by one character from all sides. A text field
   // is first drawn for inputting the searcher request, then a list of matches
   // are displayed in a scrollable list.
   //
   // ___<Searcher Window Name>____________________________
HandleCharResult WindowDelegateHandleChar(Window &window, int key) override {
 
     return eKeyHandled;
   }
 
 protected:
   SearcherDelegateSP m_delegate_sp;
   TextFieldDelegate m_text_field;
   // The index of the currently selected match.
-  int m_selected_match;
+  int m_selected_match = 0;
   // The index of the first visible match.
-  int m_first_visible_match;
+  int m_first_visible_match = 0;
 };
 
 //////////////////////////////
 // Searcher Delegate Instances
 //////////////////////////////
 
 // This is a searcher delegate wrapper around CommandCompletions common
 // callbacks. The callbacks are only given the match string. The completion_mask
if (menu_type == Menu::Type::Bar) {
     }
   } else if (menu_type == Menu::Type::Separator) {
   }
   return result;
 }
 
 class Application {
 public:
-  Application(FILE *in, FILE *out)
-      : m_window_sp(), m_screen(nullptr), m_in(in), m_out(out) {}
+  Application(FILE *in, FILE *out) : m_window_sp(), m_in(in), m_out(out) {}
 
   ~Application() {
     m_window_delegates.clear();
     m_window_sp.reset();
     if (m_screen) {
       ::delscreen(m_screen);
       m_screen = nullptr;
     }
void TerminalSizeChanged() {
     touchwin(stdscr);
     redrawwin(m_window_sp->get());
     m_update_screen = true;
   }
 
 protected:
   WindowSP m_window_sp;
   WindowDelegates m_window_delegates;
-  SCREEN *m_screen;
+  SCREEN *m_screen = nullptr;
   FILE *m_in;
   FILE *m_out;
   bool m_update_screen = false;
 };
 
 } // namespace curses
 
 using namespace curses;
public:
   virtual bool TreeDelegateShouldDraw() { return true; }
 };
 
 typedef std::shared_ptr<TreeDelegate> TreeDelegateSP;
 
 class TreeItem {
 public:
   TreeItem(TreeItem *parent, TreeDelegate &delegate, bool might_have_children)
-      : m_parent(parent), m_delegate(delegate), m_user_data(nullptr),
-        m_identifier(0), m_row_idx(-1), m_children(),
-        m_might_have_children(might_have_children), m_is_expanded(false) {
+      : m_parent(parent), m_delegate(delegate), m_children(),
+        m_might_have_children(might_have_children) {
     if (m_parent == nullptr)
       m_is_expanded = m_delegate.TreeDelegateExpandRootByDefault();
   }
 
   TreeItem &operator=(const TreeItem &rhs) {
     if (this != &rhs) {
       m_parent = rhs.m_parent;
       m_delegate = rhs.m_delegate;
void SetText(const char *text) {
     m_text = text;
   }
 
   void SetMightHaveChildren(bool b) { m_might_have_children = b; }
 
 protected:
   TreeItem *m_parent;
   TreeDelegate &m_delegate;
-  void *m_user_data;
-  uint64_t m_identifier;
+  void *m_user_data = nullptr;
+  uint64_t m_identifier = 0;
   std::string m_text;
-  int m_row_idx; // Zero based visible row index, -1 if not visible or for the
-                 // root item
+  int m_row_idx = -1; // Zero based visible row index, -1 if not visible or for
+                      // the root item
   std::vector<TreeItem> m_children;
   bool m_might_have_children;
-  bool m_is_expanded;
+  bool m_is_expanded = false;
 };
 
 class TreeWindowDelegate : public WindowDelegate {
 public:
   TreeWindowDelegate(Debugger &debugger, const TreeDelegateSP &delegate_sp)
       : m_debugger(debugger), m_delegate_sp(delegate_sp),
-        m_root(nullptr, *delegate_sp, true), m_selected_item(nullptr),
-        m_num_rows(0), m_selected_row_idx(0), m_first_visible_row(0),
-        m_min_x(0), m_min_y(0), m_max_x(0), m_max_y(0) {}
+        m_root(nullptr, *delegate_sp, true) {}
 
   int NumVisibleRows() const { return m_max_y - m_min_y; }
 
   bool WindowDelegateDraw(Window &window, bool force) override {
     m_min_x = 2;
     m_min_y = 1;
     m_max_x = window.GetWidth() - 1;
     m_max_y = window.GetHeight() - 1;
HandleCharResult WindowDelegateHandleChar(Window &window, int c) override {
     }
     return eKeyNotHandled;
   }
 
 protected:
   Debugger &m_debugger;
   TreeDelegateSP m_delegate_sp;
   TreeItem m_root;
-  TreeItem *m_selected_item;
-  int m_num_rows;
-  int m_selected_row_idx;
-  int m_first_visible_row;
-  int m_min_x;
-  int m_min_y;
-  int m_max_x;
-  int m_max_y;
+  TreeItem *m_selected_item = nullptr;
+  int m_num_rows = 0;
+  int m_selected_row_idx = 0;
+  int m_first_visible_row = 0;
+  int m_min_x = 0;
+  int m_min_y = 0;
+  int m_max_x = 0;
+  int m_max_y = 0;
 };
 
 // A tree delegate that just draws the text member of the tree item, it doesn't
 // have any children or actions.
 class TextTreeDelegate : public TreeDelegate {
 public:
   TextTreeDelegate() : TreeDelegate() {}
 

 
 protected:
   FormatEntity::Entry m_format;
 };
 
 class ThreadTreeDelegate : public TreeDelegate {
 public:
   ThreadTreeDelegate(Debugger &debugger)
-      : TreeDelegate(), m_debugger(debugger), m_tid(LLDB_INVALID_THREAD_ID),
-        m_stop_id(UINT32_MAX) {
+      : TreeDelegate(), m_debugger(debugger) {
     FormatEntity::Parse("thread #${thread.index}: tid = ${thread.id}{, stop "
                         "reason = ${thread.stop-reason}}",
                         m_format);
   }
 
   ~ThreadTreeDelegate() override = default;
 
   ProcessSP GetProcess() {
if (process_sp && process_sp->IsAlive()) {
       }
     }
     return false;
   }
 
 protected:
   Debugger &m_debugger;
   std::shared_ptr<FrameTreeDelegate> m_frame_delegate_sp;
-  lldb::user_id_t m_tid;
-  uint32_t m_stop_id;
+  lldb::user_id_t m_tid = LLDB_INVALID_THREAD_ID;
+  uint32_t m_stop_id = UINT32_MAX;
   FormatEntity::Entry m_format;
 };
 
 class ThreadsTreeDelegate : public TreeDelegate {
 public:
   ThreadsTreeDelegate(Debugger &debugger)
-      : TreeDelegate(), m_thread_delegate_sp(), m_debugger(debugger),
-        m_stop_id(UINT32_MAX), m_update_selection(false) {
+      : TreeDelegate(), m_thread_delegate_sp(), m_debugger(debugger) {
     FormatEntity::Parse("process ${process.id}{, name = ${process.name}}",
                         m_format);
   }
 
   ~ThreadsTreeDelegate() override = default;
 
   ProcessSP GetProcess() {
     return m_debugger.GetCommandInterpreter()
public:
 
   bool TreeDelegateItemSelected(TreeItem &item) override { return false; }
 
   bool TreeDelegateExpandRootByDefault() override { return true; }
 
 protected:
   std::shared_ptr<ThreadTreeDelegate> m_thread_delegate_sp;
   Debugger &m_debugger;
-  uint32_t m_stop_id;
-  bool m_update_selection;
+  uint32_t m_stop_id = UINT32_MAX;
+  bool m_update_selection = false;
   FormatEntity::Entry m_format;
 };
 
 class BreakpointLocationTreeDelegate : public TreeDelegate {
 public:
   BreakpointLocationTreeDelegate(Debugger &debugger)
       : TreeDelegate(), m_debugger(debugger) {}
 
protected:
   Debugger &m_debugger;
   std::shared_ptr<BreakpointTreeDelegate> m_breakpoint_delegate_sp;
 };
 
 class ValueObjectListDelegate : public WindowDelegate {
 public:
   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) {
+  ValueObjectListDelegate(ValueObjectList &valobj_list) : m_rows() {
     SetValues(valobj_list);
   }
 
   ~ValueObjectListDelegate() override = default;
 
   void SetValues(ValueObjectList &valobj_list) {
     m_selected_row = nullptr;
     m_selected_row_idx = 0;
protected:
   int NumVisibleRows() const { return m_max_y - m_min_y; }
 
   static DisplayOptions g_options;
 };
 
 class FrameVariablesWindowDelegate : public ValueObjectListDelegate {
 public:
   FrameVariablesWindowDelegate(Debugger &debugger)
-      : ValueObjectListDelegate(), m_debugger(debugger),
-        m_frame_block(nullptr) {}
+      : ValueObjectListDelegate(), m_debugger(debugger) {}
 
   ~FrameVariablesWindowDelegate() override = default;
 
   const char *WindowDelegateGetHelpText() override {
     return "Frame variable window keyboard shortcuts:";
   }
 
   bool WindowDelegateDraw(Window &window, bool force) override {
if (frame_block) {
       SetValues(local_values);
     }
 
     return ValueObjectListDelegate::WindowDelegateDraw(window, force);
   }
 
 protected:
   Debugger &m_debugger;
-  Block *m_frame_block;
+  Block *m_frame_block = nullptr;
 };
 
 class RegistersWindowDelegate : public ValueObjectListDelegate {
 public:
   RegistersWindowDelegate(Debugger &debugger)
       : ValueObjectListDelegate(), m_debugger(debugger) {}
 
   ~RegistersWindowDelegate() override = default;
else
       snprintf(g_desc, sizeof(g_desc), "\\x%2.2x", ch);
     return g_desc;
   }
   return nullptr;
 }
 
 HelpDialogDelegate::HelpDialogDelegate(const char *text,
                                        KeyHelp *key_help_array)
-    : m_text(), m_first_visible_line(0) {
+    : m_text() {
   if (text && text[0]) {
     m_text.SplitIntoLines(text);
     m_text.AppendString("");
   }
   if (key_help_array) {
     for (KeyHelp *key = key_help_array; key->ch; ++key) {
       StreamString key_description;
       key_description.Printf("%10s - %s", CursesKeyToCString(key->ch),
protected:
   Debugger &m_debugger;
   FormatEntity::Entry m_format;
 };
 
 class SourceFileWindowDelegate : public WindowDelegate {
 public:
   SourceFileWindowDelegate(Debugger &debugger)
       : WindowDelegate(), m_debugger(debugger), m_sc(), m_file_sp(),
-        m_disassembly_scope(nullptr), m_disassembly_sp(), m_disassembly_range(),
-        m_title(), m_tid(LLDB_INVALID_THREAD_ID), m_line_width(4),
-        m_selected_line(0), m_pc_line(0), m_stop_id(0), m_frame_idx(UINT32_MAX),
-        m_first_visible_line(0), m_first_visible_column(0), m_min_x(0),
-        m_min_y(0), m_max_x(0), m_max_y(0) {}
+        m_disassembly_sp(), m_disassembly_range(), m_title() {}
 
   ~SourceFileWindowDelegate() override = default;
 
   void Update(const SymbolContext &sc) { m_sc = sc; }
 
   uint32_t NumVisibleLines() const { return m_max_y - m_min_y; }
 
   const char *WindowDelegateGetHelpText() override {

 
 protected:
   typedef std::set<uint32_t> BreakpointLines;
   typedef std::set<lldb::addr_t> BreakpointAddrs;
 
   Debugger &m_debugger;
   SymbolContext m_sc;
   SourceManager::FileSP m_file_sp;
-  SymbolContextScope *m_disassembly_scope;
+  SymbolContextScope *m_disassembly_scope = nullptr;
   lldb::DisassemblerSP m_disassembly_sp;
   AddressRange m_disassembly_range;
   StreamString m_title;
-  lldb::user_id_t m_tid;
-  int m_line_width;
-  uint32_t m_selected_line; // The selected line
-  uint32_t m_pc_line;       // The line with the PC
-  uint32_t m_stop_id;
-  uint32_t m_frame_idx;
-  int m_first_visible_line;
-  int m_first_visible_column;
-  int m_min_x;
-  int m_min_y;
-  int m_max_x;
-  int m_max_y;
+  lldb::user_id_t m_tid = LLDB_INVALID_THREAD_ID;
+  int m_line_width = 4;
+  uint32_t m_selected_line = 0; // The selected line
+  uint32_t m_pc_line = 0;       // The line with the PC
+  uint32_t m_stop_id = 0;
+  uint32_t m_frame_idx = UINT32_MAX;
+  int m_first_visible_line = 0;
+  int m_first_visible_column = 0;
+  int m_min_x = 0;
+  int m_min_y = 0;
+  int m_max_x = 0;
+  int m_max_y = 0;
 };
 
 DisplayOptions ValueObjectListDelegate::g_options = {true};
 
 IOHandlerCursesGUI::IOHandlerCursesGUI(Debugger &debugger)
     : IOHandler(debugger, IOHandler::Type::Curses) {}
 
 void IOHandlerCursesGUI::Activate() {

lldb/source/Core/Module.cpp

std::lock_guard<std::recursive_mutex> guard(
       GetAllocationModuleCollectionMutex());
   ModuleCollection &modules = GetModuleCollection();
   if (idx < modules.size())
     return modules[idx];
   return nullptr;
 }
 
 Module::Module(const ModuleSpec &module_spec)
-    : m_object_offset(0), m_file_has_changed(false),
-      m_first_file_changed_log(false) {
+    : m_file_has_changed(false), m_first_file_changed_log(false) {
   // Scope for locker below...
   {
     std::lock_guard<std::recursive_mutex> guard(
         GetAllocationModuleCollectionMutex());
     GetModuleCollection().push_back(this);
   }
 
   Log *log(GetLog(LLDBLog::Object | LLDBLog::Modules));
if (sc.comp_unit) {
         sc_list.Append(sc);
     }
   }
 }
 
 Module::LookupInfo::LookupInfo(ConstString name,
                                FunctionNameType name_type_mask,
                                LanguageType language)
-    : m_name(name), m_lookup_name(), m_language(language),
-      m_name_type_mask(eFunctionNameTypeNone),
-      m_match_name_after_lookup(false) {
+    : m_name(name), m_lookup_name(), m_language(language) {
   const char *name_cstr = name.GetCString();
   llvm::StringRef basename;
   llvm::StringRef context;
 
   if (name_type_mask & eFunctionNameTypeAuto) {
     if (CPlusPlusLanguage::IsCPPMangledName(name_cstr))
       m_name_type_mask = eFunctionNameTypeFull;
     else if ((language == eLanguageTypeUnknown ||

lldb/source/Core/ModuleList.cpp

 
 PathMappingList ModuleListProperties::GetSymlinkMappings() const {
   llvm::sys::ScopedReader lock(m_symlink_paths_mutex);
   return m_symlink_paths;
 }
 
 ModuleList::ModuleList() : m_modules(), m_modules_mutex() {}
 
-ModuleList::ModuleList(const ModuleList &rhs)
-    : m_modules(), m_modules_mutex(), m_notifier(nullptr) {
+ModuleList::ModuleList(const ModuleList &rhs) : m_modules(), m_modules_mutex() {
   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;
 }
 
 ModuleList::ModuleList(ModuleList::Notifier *notifier)
     : m_modules(), m_modules_mutex(), m_notifier(notifier) {}
 

lldb/source/Core/Value.cpp

 #include <cinttypes>
 
 using namespace lldb;
 using namespace lldb_private;
 
 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() {}
+    : m_value(scalar), m_compiler_type(), m_data_buffer() {}
 
 Value::Value(const void *bytes, int len)
-    : m_value(), m_compiler_type(), m_context(nullptr),
-      m_value_type(ValueType::HostAddress), m_context_type(ContextType::Invalid),
+    : m_value(), m_compiler_type(), m_value_type(ValueType::HostAddress),
       m_data_buffer() {
   SetBytes(bytes, len);
 }
 
 Value::Value(const Value &v)
     : m_value(v.m_value), m_compiler_type(v.m_compiler_type),
       m_context(v.m_context), m_value_type(v.m_value_type),
       m_context_type(v.m_context_type), m_data_buffer() {

lldb/source/Core/ValueObject.cpp

ValueObjectSP ValueObject::CastPointerType(const char *name, TypeSP &type_sp) {
   }
   return valobj_sp;
 }
 
 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) {
+    : m_mod_id(), m_exe_ctx_ref() {
   ExecutionContext exe_ctx(exe_scope);
   TargetSP target_sp(exe_ctx.GetTargetSP());
   if (target_sp) {
     m_exe_ctx_ref.SetTargetSP(target_sp);
     ProcessSP process_sp(exe_ctx.GetProcessSP());
     if (!process_sp)
       process_sp = target_sp->GetProcessSP();
 
if (process_sp) {
           m_exe_ctx_ref.SetFrameSP(frame_sp);
       }
     }
   }
 }
 
 ValueObject::EvaluationPoint::EvaluationPoint(
     const ValueObject::EvaluationPoint &rhs)
-    : m_mod_id(), m_exe_ctx_ref(rhs.m_exe_ctx_ref), m_needs_update(true) {}
+    : m_mod_id(), m_exe_ctx_ref(rhs.m_exe_ctx_ref) {}
 
 ValueObject::EvaluationPoint::~EvaluationPoint() = default;
 
 // This function checks the EvaluationPoint against the current process state.
 // If the current state matches the evaluation point, or the evaluation point
 // is already invalid, then we return false, meaning "no change".  If the
 // current state is different, we update our state, and return true meaning
 // "yes, change".  If we did see a change, we also set m_needs_update to true,

lldb/source/DataFormatters/VectorType.cpp

 }
 
 namespace lldb_private {
 namespace formatters {
 
 class VectorTypeSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
 public:
   VectorTypeSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
-      : SyntheticChildrenFrontEnd(*valobj_sp), m_parent_format(eFormatInvalid),
-        m_item_format(eFormatInvalid), m_child_type(), m_num_children(0) {}
+      : SyntheticChildrenFrontEnd(*valobj_sp), m_child_type() {}
 
   ~VectorTypeSyntheticFrontEnd() override = default;
 
   size_t CalculateNumChildren() override { return m_num_children; }
 
   lldb::ValueObjectSP GetChildAtIndex(size_t idx) override {
     if (idx >= CalculateNumChildren())
       return {};
size_t GetIndexOfChildWithName(ConstString name) override {
     const char *item_name = name.GetCString();
     uint32_t idx = ExtractIndexFromString(item_name);
     if (idx < UINT32_MAX && idx >= CalculateNumChildren())
       return UINT32_MAX;
     return idx;
   }
 
 private:
-  lldb::Format m_parent_format;
-  lldb::Format m_item_format;
+  lldb::Format m_parent_format = eFormatInvalid;
+  lldb::Format m_item_format = eFormatInvalid;
   CompilerType m_child_type;
-  size_t m_num_children;
+  size_t m_num_children = 0;
 };
 
 } // namespace formatters
 } // namespace lldb_private
 
 bool lldb_private::formatters::VectorTypeSummaryProvider(
     ValueObject &valobj, Stream &s, const TypeSummaryOptions &) {
   auto synthetic_children =

lldb/source/Expression/DWARFExpression.cpp

 }
 
 // DWARFExpression constructor
 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) {
+    : m_module_wp(), m_data(data), m_dwarf_cu(dwarf_cu) {
   if (module_sp)
     m_module_wp = module_sp;
 }
 
 // Destructor
 DWARFExpression::~DWARFExpression() = default;
 
 bool DWARFExpression::IsValid() const { return m_data.GetByteSize() > 0; }

lldb/source/Expression/IRInterpreter.cpp

 
 class InterpreterStackFrame {
 public:
   typedef std::map<const Value *, lldb::addr_t> ValueMap;
 
   ValueMap m_values;
   DataLayout &m_target_data;
   lldb_private::IRExecutionUnit &m_execution_unit;
-  const BasicBlock *m_bb;
-  const BasicBlock *m_prev_bb;
+  const BasicBlock *m_bb = nullptr;
+  const BasicBlock *m_prev_bb = nullptr;
   BasicBlock::const_iterator m_ii;
   BasicBlock::const_iterator m_ie;
 
   lldb::addr_t m_frame_process_address;
   size_t m_frame_size;
   lldb::addr_t m_stack_pointer;
 
   lldb::ByteOrder m_byte_order;
   size_t m_addr_byte_size;
 
   InterpreterStackFrame(DataLayout &target_data,
                         lldb_private::IRExecutionUnit &execution_unit,
                         lldb::addr_t stack_frame_bottom,
                         lldb::addr_t stack_frame_top)
-      : m_target_data(target_data), m_execution_unit(execution_unit),
-        m_bb(nullptr), m_prev_bb(nullptr) {
+      : m_target_data(target_data), m_execution_unit(execution_unit) {
     m_byte_order = (target_data.isLittleEndian() ? lldb::eByteOrderLittle
                                                  : lldb::eByteOrderBig);
     m_addr_byte_size = (target_data.getPointerSize(0));
 
     m_frame_process_address = stack_frame_bottom;
     m_frame_size = stack_frame_top - stack_frame_bottom;
     m_stack_pointer = stack_frame_top;
   }

lldb/source/Expression/Materializer.cpp

uint32_t Materializer::AddPersistentVariable(
   uint32_t ret = AddStructMember(**iter);
   (*iter)->SetOffset(ret);
   return ret;
 }
 
 class EntityVariable : public Materializer::Entity {
 public:
   EntityVariable(lldb::VariableSP &variable_sp)
-      : Entity(), m_variable_sp(variable_sp), m_is_reference(false),
-        m_temporary_allocation(LLDB_INVALID_ADDRESS),
-        m_temporary_allocation_size(0) {
+      : Entity(), m_variable_sp(variable_sp) {
     // Hard-coding to maximum size of a pointer since all variables are
     // materialized by reference
     m_size = 8;
     m_alignment = 8;
     m_is_reference =
         m_variable_sp->GetType()->GetForwardCompilerType().IsReferenceType();
   }
 
if (m_temporary_allocation != LLDB_INVALID_ADDRESS) {
 
       m_temporary_allocation = LLDB_INVALID_ADDRESS;
       m_temporary_allocation_size = 0;
     }
   }
 
 private:
   lldb::VariableSP m_variable_sp;
-  bool m_is_reference;
-  lldb::addr_t m_temporary_allocation;
-  size_t m_temporary_allocation_size;
+  bool m_is_reference = false;
+  lldb::addr_t m_temporary_allocation = LLDB_INVALID_ADDRESS;
+  size_t m_temporary_allocation_size = 0;
   lldb::DataBufferSP m_original_data;
 };
 
 uint32_t Materializer::AddVariable(lldb::VariableSP &variable_sp, Status &err) {
   EntityVector::iterator iter = m_entities.insert(m_entities.end(), EntityUP());
   *iter = std::make_unique<EntityVariable>(variable_sp);
   uint32_t ret = AddStructMember(**iter);
   (*iter)->SetOffset(ret);
   return ret;
 }
 
 class EntityResultVariable : public Materializer::Entity {
 public:
   EntityResultVariable(const CompilerType &type, bool is_program_reference,
                        bool keep_in_memory,
                        Materializer::PersistentVariableDelegate *delegate)
       : Entity(), m_type(type), m_is_program_reference(is_program_reference),
-        m_keep_in_memory(keep_in_memory),
-        m_temporary_allocation(LLDB_INVALID_ADDRESS),
-        m_temporary_allocation_size(0), m_delegate(delegate) {
+        m_keep_in_memory(keep_in_memory), m_delegate(delegate) {
     // Hard-coding to maximum size of a pointer since all results are
     // materialized by reference
     m_size = 8;
     m_alignment = 8;
   }
 
   void Materialize(lldb::StackFrameSP &frame_sp, IRMemoryMap &map,
                    lldb::addr_t process_address, Status &err) override {
void Wipe(IRMemoryMap &map, lldb::addr_t process_address) override {
     m_temporary_allocation_size = 0;
   }
 
 private:
   CompilerType m_type;
   bool m_is_program_reference;
   bool m_keep_in_memory;
 
-  lldb::addr_t m_temporary_allocation;
-  size_t m_temporary_allocation_size;
+  lldb::addr_t m_temporary_allocation = LLDB_INVALID_ADDRESS;
+  size_t m_temporary_allocation_size = 0;
   Materializer::PersistentVariableDelegate *m_delegate;
 };
 
 uint32_t Materializer::AddResultVariable(const CompilerType &type,
                                          bool is_program_reference,
                                          bool keep_in_memory,
                                          PersistentVariableDelegate *delegate,
                                          Status &err) {

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(thread_t thread)
-    : m_thread(thread), m_result(0) {} // NOLINT(modernize-use-nullptr)
+    : m_thread(thread) {}
 
 lldb::thread_t HostNativeThreadBase::GetSystemHandle() const {
   return m_thread;
 }
 
 lldb::thread_result_t HostNativeThreadBase::GetResult() const {
   return m_result;
 }

lldb/source/Host/common/ProcessLaunchInfo.cpp

: ProcessInfo(), m_working_dir(), m_plugin_name(), m_flags(0),
       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),
+      m_file_actions(), m_pty(new PseudoTerminal),
       m_scripted_process_class_name(), m_scripted_process_dictionary_sp() {
   if (stdin_file_spec) {
     FileAction file_action;
     const bool read = true;
     const bool write = false;
     if (file_action.Open(STDIN_FILENO, stdin_file_spec, read, write))
       AppendFileAction(file_action);
   }

lldb/source/Interpreter/OptionValueFileColonLine.cpp

 
 // 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() = default;
 
 OptionValueFileColonLine::OptionValueFileColonLine(llvm::StringRef input)
-    : m_line_number(LLDB_INVALID_LINE_NUMBER),
-      m_column_number(LLDB_INVALID_COLUMN_NUMBER),
-      m_completion_mask(CommandCompletions::eSourceFileCompletion) {
+
+{
   SetValueFromString(input, eVarSetOperationAssign);
 }
 
 void OptionValueFileColonLine::DumpValue(const ExecutionContext *exe_ctx,
                                          Stream &strm, uint32_t dump_mask) {
   if (dump_mask & eDumpOptionType)
     strm.Printf("(%s)", GetTypeAsCString());
   if (dump_mask & eDumpOptionValue) {

lldb/source/Interpreter/OptionValueFileSpec.cpp

 
 using namespace lldb;
 using namespace lldb_private;
 
 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,
                                          bool resolve)
     : m_current_value(current_value), m_default_value(default_value),
-      m_completion_mask(CommandCompletions::eDiskFileCompletion),
+
       m_resolve(resolve) {}
 
 void OptionValueFileSpec::DumpValue(const ExecutionContext *exe_ctx,
                                     Stream &strm, uint32_t dump_mask) {
   if (dump_mask & eDumpOptionType)
     strm.Printf("(%s)", GetTypeAsCString());
   if (dump_mask & eDumpOptionValue) {
     if (dump_mask & eDumpOptionType)

lldb/source/Plugins/Disassembler/LLVMC/DisassemblerLLVMC.cpp

 
 class InstructionLLVMC : public lldb_private::Instruction {
 public:
   InstructionLLVMC(DisassemblerLLVMC &disasm,
                    const lldb_private::Address &address,
                    AddressClass addr_class)
       : Instruction(address, addr_class),
         m_disasm_wp(std::static_pointer_cast<DisassemblerLLVMC>(
-            disasm.shared_from_this())),
-        m_using_file_addr(false) {}
+            disasm.shared_from_this())) {}
 
   ~InstructionLLVMC() override = default;
 
   bool DoesBranch() override {
     VisitInstruction();
     return m_does_branch;
   }
 
bool IsCall() override {
     VisitInstruction();
     return m_is_call;
   }
 
 protected:
   std::weak_ptr<DisassemblerLLVMC> m_disasm_wp;
 
   bool m_is_valid = false;
-  bool m_using_file_addr;
+  bool m_using_file_addr = false;
   bool m_has_visited_instruction = false;
 
   // Be conservative. If we didn't understand the instruction, say it:
   //   - Might branch
   //   - Does not have a delay slot
   //   - Is not a call
   //   - Is not a load
   //   - Is not an authenticated instruction

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

class AddMacroState {
   enum State {
     CURRENT_FILE_NOT_YET_PUSHED,
     CURRENT_FILE_PUSHED,
     CURRENT_FILE_POPPED
   };
 
 public:
   AddMacroState(const FileSpec &current_file, const uint32_t current_file_line)
-      : m_state(CURRENT_FILE_NOT_YET_PUSHED), m_current_file(current_file),
-        m_current_file_line(current_file_line) {}
+      : m_current_file(current_file), m_current_file_line(current_file_line) {}
 
   void StartFile(const FileSpec &file) {
     m_file_stack.push_back(file);
     if (file == m_current_file)
       m_state = CURRENT_FILE_PUSHED;
   }
 
   void EndFile() {
case CURRENT_FILE_PUSHED:
       return line < m_current_file_line;
     default:
       return false;
     }
   }
 
 private:
   std::vector<FileSpec> m_file_stack;
-  State m_state;
+  State m_state = CURRENT_FILE_NOT_YET_PUSHED;
   FileSpec m_current_file;
   uint32_t m_current_file_line;
 };
 
 } // anonymous namespace
 
 static void AddMacros(const DebugMacros *dm, CompileUnit *comp_unit,
                       AddMacroState &state, StreamString &stream) {

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

 class Instrumenter {
 public:
   /// Constructor
   ///
   /// \param[in] module
   ///     The module being instrumented.
   Instrumenter(llvm::Module &module,
                std::shared_ptr<UtilityFunction> checker_function)
-      : m_module(module), m_checker_function(checker_function),
-        m_i8ptr_ty(nullptr), m_intptr_ty(nullptr) {}
+      : m_module(module), m_checker_function(checker_function) {}
 
   virtual ~Instrumenter() = default;
 
   /// Inspect a function to find instructions to instrument
   ///
   /// \param[in] function
   ///     The function to inspect.
   ///
protected:
   typedef InstVector::iterator InstIterator;
 
   InstVector m_to_instrument; ///< List of instructions the inspector found
   llvm::Module &m_module;     ///< The module which is being instrumented
   std::shared_ptr<UtilityFunction>
       m_checker_function; ///< The dynamic checker function for the process
 
 private:
-  PointerType *m_i8ptr_ty;
-  IntegerType *m_intptr_ty;
+  PointerType *m_i8ptr_ty = nullptr;
+  IntegerType *m_intptr_ty = nullptr;
 };
 
 class ValidPointerChecker : public Instrumenter {
 public:
   ValidPointerChecker(llvm::Module &module,
                       std::shared_ptr<UtilityFunction> checker_function)
       : Instrumenter(module, checker_function),
         m_valid_pointer_check_func(nullptr) {}

lldb/source/Plugins/Language/CPlusPlus/LibCxxAtomic.cpp

public:
 
   bool Update() override;
 
   bool MightHaveChildren() override;
 
   size_t GetIndexOfChildWithName(ConstString name) override;
 
 private:
-  ValueObject *m_real_child;
+  ValueObject *m_real_child = nullptr;
 };
 } // namespace formatters
 } // namespace lldb_private
 
 lldb_private::formatters::LibcxxStdAtomicSyntheticFrontEnd::
     LibcxxStdAtomicSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
-    : SyntheticChildrenFrontEnd(*valobj_sp), m_real_child(nullptr) {}
+    : SyntheticChildrenFrontEnd(*valobj_sp) {}
 
 bool lldb_private::formatters::LibcxxStdAtomicSyntheticFrontEnd::Update() {
   ValueObjectSP atomic_value = GetLibCxxAtomicValue(m_backend);
   if (atomic_value)
     m_real_child = GetLibCxxAtomicValue(m_backend).get();
 
   return false;
 }

lldb/source/Plugins/Language/CPlusPlus/LibCxxInitializerList.cpp

public:
 
   bool Update() override;
 
   bool MightHaveChildren() override;
 
   size_t GetIndexOfChildWithName(ConstString name) override;
 
 private:
-  ValueObject *m_start;
+  ValueObject *m_start = nullptr;
   CompilerType m_element_type;
-  uint32_t m_element_size;
-  size_t m_num_elements;
+  uint32_t m_element_size = 0;
+  size_t m_num_elements = 0;
 };
 } // namespace formatters
 } // namespace lldb_private
 
 lldb_private::formatters::LibcxxInitializerListSyntheticFrontEnd::
     LibcxxInitializerListSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
-    : SyntheticChildrenFrontEnd(*valobj_sp), m_start(nullptr), m_element_type(),
-      m_element_size(0), m_num_elements(0) {
+    : SyntheticChildrenFrontEnd(*valobj_sp), m_element_type() {
   if (valobj_sp)
     Update();
 }
 
 lldb_private::formatters::LibcxxInitializerListSyntheticFrontEnd::
     ~LibcxxInitializerListSyntheticFrontEnd() {
   // this needs to stay around because it's a child object who will follow its
   // parent's life cycle

lldb/source/Plugins/Language/CPlusPlus/LibCxxList.cpp

public:
 
   size_t CalculateNumChildren() override;
 
   lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
 
   bool Update() override;
 
 private:
-  lldb::addr_t m_node_address;
-  ValueObject *m_tail;
+  lldb::addr_t m_node_address = 0;
+  ValueObject *m_tail = nullptr;
 };
 
 } // end anonymous namespace
 
 bool AbstractListFrontEnd::Update() {
   m_loop_detected = 0;
   m_count = UINT32_MAX;
   m_head = nullptr;
bool ForwardListFrontEnd::Update() {
   impl_sp = GetValueOfLibCXXCompressedPair(*impl_sp);
   if (!impl_sp)
     return false;
   m_head = impl_sp->GetChildMemberWithName(ConstString("__next_"), true).get();
   return false;
 }
 
 ListFrontEnd::ListFrontEnd(lldb::ValueObjectSP valobj_sp)
-    : AbstractListFrontEnd(*valobj_sp), m_node_address(), m_tail(nullptr) {
+    : AbstractListFrontEnd(*valobj_sp) {
   if (valobj_sp)
     Update();
 }
 
 size_t ListFrontEnd::CalculateNumChildren() {
   if (m_count != UINT32_MAX)
     return m_count;
   if (!m_head || !m_tail || m_node_address == 0)

lldb/source/Plugins/Language/CPlusPlus/LibCxxMap.cpp

public:
 
   size_t GetIndexOfChildWithName(ConstString name) override;
 
 private:
   bool GetDataType();
 
   void GetValueOffset(const lldb::ValueObjectSP &node);
 
-  ValueObject *m_tree;
-  ValueObject *m_root_node;
+  ValueObject *m_tree = nullptr;
+  ValueObject *m_root_node = nullptr;
   CompilerType m_element_type;
-  uint32_t m_skip_size;
-  size_t m_count;
+  uint32_t m_skip_size = UINT32_MAX;
+  size_t m_count = UINT32_MAX;
   std::map<size_t, MapIterator> m_iterators;
 };
 } // namespace formatters
 } // namespace lldb_private
 
 lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::
     LibcxxStdMapSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
-    : SyntheticChildrenFrontEnd(*valobj_sp), m_tree(nullptr),
-      m_root_node(nullptr), m_element_type(), m_skip_size(UINT32_MAX),
-      m_count(UINT32_MAX), m_iterators() {
+    : SyntheticChildrenFrontEnd(*valobj_sp), m_element_type(), m_iterators() {
   if (valobj_sp)
     Update();
 }
 
 size_t lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::
     CalculateNumChildren() {
   static ConstString g_pair3_("__pair3_");
   static ConstString g_first_("__first_");

lldb/source/Plugins/Language/CPlusPlus/LibCxxUnorderedMap.cpp

public:
 
   bool MightHaveChildren() override;
 
   size_t GetIndexOfChildWithName(ConstString name) override;
 
 private:
   CompilerType m_element_type;
   CompilerType m_node_type;
-  ValueObject *m_tree;
-  size_t m_num_elements;
-  ValueObject *m_next_element;
+  ValueObject *m_tree = nullptr;
+  size_t m_num_elements = 0;
+  ValueObject *m_next_element = nullptr;
   std::vector<std::pair<ValueObject *, uint64_t>> m_elements_cache;
 };
 } // namespace formatters
 } // namespace lldb_private
 
 lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEnd::
     LibcxxStdUnorderedMapSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
-    : SyntheticChildrenFrontEnd(*valobj_sp), m_element_type(), m_tree(nullptr),
-      m_num_elements(0), m_next_element(nullptr), m_elements_cache() {
+    : SyntheticChildrenFrontEnd(*valobj_sp), m_element_type(),
+      m_elements_cache() {
   if (valobj_sp)
     Update();
 }
 
 size_t lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEnd::
     CalculateNumChildren() {
   return m_num_elements;
 }

lldb/source/Plugins/Language/CPlusPlus/LibCxxVector.cpp

public:
 
   bool Update() override;
 
   bool MightHaveChildren() override;
 
   size_t GetIndexOfChildWithName(ConstString name) override;
 
 private:
-  ValueObject *m_start;
-  ValueObject *m_finish;
+  ValueObject *m_start = nullptr;
+  ValueObject *m_finish = nullptr;
   CompilerType m_element_type;
-  uint32_t m_element_size;
+  uint32_t m_element_size = 0;
 };
 
 class LibcxxVectorBoolSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
 public:
   LibcxxVectorBoolSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);
 
   size_t CalculateNumChildren() override;
 
   lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
 
   bool Update() override;
 
   bool MightHaveChildren() override { return true; }
 
   size_t GetIndexOfChildWithName(ConstString name) override;
 
 private:
   CompilerType m_bool_type;
   ExecutionContextRef m_exe_ctx_ref;
-  uint64_t m_count;
-  lldb::addr_t m_base_data_address;
+  uint64_t m_count = 0;
+  lldb::addr_t m_base_data_address = 0;
   std::map<size_t, lldb::ValueObjectSP> m_children;
 };
 
 } // namespace formatters
 } // namespace lldb_private
 
 lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::
     LibcxxStdVectorSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
-    : SyntheticChildrenFrontEnd(*valobj_sp), m_start(nullptr),
-      m_finish(nullptr), m_element_type(), m_element_size(0) {
+    : SyntheticChildrenFrontEnd(*valobj_sp), m_element_type() {
   if (valobj_sp)
     Update();
 }
 
 lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::
     ~LibcxxStdVectorSyntheticFrontEnd() {
   // these need to stay around because they are child objects who will follow
   // their parent's life cycle
size_t lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::
   if (!m_start || !m_finish)
     return UINT32_MAX;
   return ExtractIndexFromString(name.GetCString());
 }
 
 lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::
     LibcxxVectorBoolSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
     : SyntheticChildrenFrontEnd(*valobj_sp), m_bool_type(), m_exe_ctx_ref(),
-      m_count(0), m_base_data_address(0), m_children() {
+      m_children() {
   if (valobj_sp) {
     Update();
     m_bool_type =
         valobj_sp->GetCompilerType().GetBasicTypeFromAST(lldb::eBasicTypeBool);
   }
 }
 
 size_t lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::

lldb/source/Plugins/Language/CPlusPlus/LibStdcpp.cpp

public:
   bool Update() override;
 
   bool MightHaveChildren() override;
 
   size_t GetIndexOfChildWithName(ConstString name) override;
 
 private:
   ExecutionContextRef m_exe_ctx_ref;
-  lldb::addr_t m_pair_address;
+  lldb::addr_t m_pair_address = 0;
   CompilerType m_pair_type;
   lldb::ValueObjectSP m_pair_sp;
 };
 
 class LibStdcppSharedPtrSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
 public:
   explicit LibStdcppSharedPtrSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);
 
   size_t CalculateNumChildren() override;
 
   lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
 
   bool Update() override;
 
   bool MightHaveChildren() override;
 
   size_t GetIndexOfChildWithName(ConstString name) override;
 };
 
 } // end of anonymous namespace
 
 LibstdcppMapIteratorSyntheticFrontEnd::LibstdcppMapIteratorSyntheticFrontEnd(
     lldb::ValueObjectSP valobj_sp)
-    : SyntheticChildrenFrontEnd(*valobj_sp), m_exe_ctx_ref(), m_pair_address(0),
-      m_pair_type(), m_pair_sp() {
+    : SyntheticChildrenFrontEnd(*valobj_sp), m_exe_ctx_ref(), m_pair_type(),
+      m_pair_sp() {
   if (valobj_sp)
     Update();
 }
 
 bool LibstdcppMapIteratorSyntheticFrontEnd::Update() {
   ValueObjectSP valobj_sp = m_backend.GetSP();
   if (!valobj_sp)
     return false;

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

protected:
 
   virtual uint64_t GetUsedCount() = 0;
 
   virtual uint64_t GetOffset() = 0;
 
   virtual uint64_t GetSize() = 0;
 
   ExecutionContextRef m_exe_ctx_ref;
-  uint8_t m_ptr_size;
+  uint8_t m_ptr_size = 8;
   CompilerType m_id_type;
 };
 
 template <typename D32, typename D64>
 class GenericNSArrayMSyntheticFrontEnd : public NSArrayMSyntheticFrontEndBase {
 public:
   GenericNSArrayMSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);
 
public:
   bool Update() override;
 
   bool MightHaveChildren() override;
 
   size_t GetIndexOfChildWithName(ConstString name) override;
 
 private:
   ExecutionContextRef m_exe_ctx_ref;
-  uint8_t m_ptr_size;
+  uint8_t m_ptr_size = 8;
 
   D32 *m_data_32;
   D64 *m_data_64;
   CompilerType m_id_type;
 };
 
 namespace Foundation1300 {
     struct IDD32 {
if (Language *language = Language::FindPlugin(options.GetLanguage())) {
     }
   }
 
   stream.Printf("%s%" PRIu64 " %s%s%s", prefix.c_str(), value, "element",
                 value == 1 ? "" : "s", suffix.c_str());
   return true;
 }
 
-lldb_private::formatters::NSArrayMSyntheticFrontEndBase::NSArrayMSyntheticFrontEndBase(
-    lldb::ValueObjectSP valobj_sp)
-    : SyntheticChildrenFrontEnd(*valobj_sp), m_exe_ctx_ref(), m_ptr_size(8),
-      m_id_type() {
+lldb_private::formatters::NSArrayMSyntheticFrontEndBase::
+    NSArrayMSyntheticFrontEndBase(lldb::ValueObjectSP valobj_sp)
+    : SyntheticChildrenFrontEnd(*valobj_sp), m_exe_ctx_ref(), m_id_type() {
   if (valobj_sp) {
     auto *clang_ast_context = ScratchTypeSystemClang::GetForTarget(
         *valobj_sp->GetExecutionContextRef().GetTargetSP());
     if (clang_ast_context)
       m_id_type = CompilerType(
           clang_ast_context,
           clang_ast_context->getASTContext().ObjCBuiltinIdTy.getAsOpaquePtr());
     if (valobj_sp->GetProcessSP())
GenericNSArrayMSyntheticFrontEnd<D32, D64>::
     GenericNSArrayMSyntheticFrontEnd::GetSize() {
   if (!m_data_32 && !m_data_64)
     return 0;
   return m_data_32 ? m_data_32->_size : m_data_64->_size;
 }
 
 template <typename D32, typename D64, bool Inline>
 lldb_private::formatters::GenericNSArrayISyntheticFrontEnd<D32, D64, Inline>::
-  GenericNSArrayISyntheticFrontEnd(
-    lldb::ValueObjectSP valobj_sp)
-    : SyntheticChildrenFrontEnd(*valobj_sp), m_exe_ctx_ref(), m_ptr_size(8),
+    GenericNSArrayISyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
+    : SyntheticChildrenFrontEnd(*valobj_sp), m_exe_ctx_ref(),
       m_data_32(nullptr), m_data_64(nullptr) {
   if (valobj_sp) {
     CompilerType type = valobj_sp->GetCompilerType();
     if (type) {
       auto *clang_ast_context = ScratchTypeSystemClang::GetForTarget(
           *valobj_sp->GetExecutionContextRef().GetTargetSP());
       if (clang_ast_context)
         m_id_type = clang_ast_context->GetType(

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

private:
 
   struct DictionaryItemDescriptor {
     lldb::addr_t key_ptr;
     lldb::addr_t val_ptr;
     lldb::ValueObjectSP valobj_sp;
   };
 
   ExecutionContextRef m_exe_ctx_ref;
-  uint8_t m_ptr_size;
-  lldb::ByteOrder m_order;
-  DataDescriptor_32 *m_data_32;
-  DataDescriptor_64 *m_data_64;
+  uint8_t m_ptr_size = 8;
+  lldb::ByteOrder m_order = lldb::eByteOrderInvalid;
+  DataDescriptor_32 *m_data_32 = nullptr;
+  DataDescriptor_64 *m_data_64 = nullptr;
   lldb::addr_t m_data_ptr;
   CompilerType m_pair_type;
   std::vector<DictionaryItemDescriptor> m_children;
 };
 
 class NSConstantDictionarySyntheticFrontEnd : public SyntheticChildrenFrontEnd {
 public:
   NSConstantDictionarySyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);

 private:
   struct DictionaryItemDescriptor {
     lldb::addr_t key_ptr;
     lldb::addr_t val_ptr;
     lldb::ValueObjectSP valobj_sp;
   };
 
   ExecutionContextRef m_exe_ctx_ref;
-  uint8_t m_ptr_size;
-  lldb::ByteOrder m_order;
+  uint8_t m_ptr_size = 8;
+  lldb::ByteOrder m_order = lldb::eByteOrderInvalid;
 
   CFBasicHash m_hashtable;
 
   CompilerType m_pair_type;
   std::vector<DictionaryItemDescriptor> m_children;
 };
 
 class NSDictionary1SyntheticFrontEnd : public SyntheticChildrenFrontEnd {

 private:
   struct DictionaryItemDescriptor {
     lldb::addr_t key_ptr;
     lldb::addr_t val_ptr;
     lldb::ValueObjectSP valobj_sp;
   };
 
   ExecutionContextRef m_exe_ctx_ref;
-  uint8_t m_ptr_size;
-  lldb::ByteOrder m_order;
+  uint8_t m_ptr_size = 8;
+  lldb::ByteOrder m_order = lldb::eByteOrderInvalid;
   D32 *m_data_32;
   D64 *m_data_64;
   CompilerType m_pair_type;
   std::vector<DictionaryItemDescriptor> m_children;
 };
   
 namespace Foundation1100 {
   class NSDictionaryMSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
private:
     
     struct DictionaryItemDescriptor {
       lldb::addr_t key_ptr;
       lldb::addr_t val_ptr;
       lldb::ValueObjectSP valobj_sp;
     };
     
     ExecutionContextRef m_exe_ctx_ref;
-    uint8_t m_ptr_size;
-    lldb::ByteOrder m_order;
-    DataDescriptor_32 *m_data_32;
-    DataDescriptor_64 *m_data_64;
+    uint8_t m_ptr_size = 8;
+    lldb::ByteOrder m_order = lldb::eByteOrderInvalid;
+    DataDescriptor_32 *m_data_32 = nullptr;
+    DataDescriptor_64 *m_data_64 = nullptr;
     CompilerType m_pair_type;
     std::vector<DictionaryItemDescriptor> m_children;
   };
 }
   
 namespace Foundation1428 {
   namespace {
     struct DataDescriptor_32 {
if (class_name == g_DictionaryI) {
     }
   }
 
   return nullptr;
 }
 
 lldb_private::formatters::NSDictionaryISyntheticFrontEnd::
     NSDictionaryISyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
-    : SyntheticChildrenFrontEnd(*valobj_sp), m_exe_ctx_ref(), m_ptr_size(8),
-      m_order(lldb::eByteOrderInvalid), m_data_32(nullptr), m_data_64(nullptr),
-      m_pair_type() {}
+    : SyntheticChildrenFrontEnd(*valobj_sp), m_exe_ctx_ref(), m_pair_type() {}
 
 lldb_private::formatters::NSDictionaryISyntheticFrontEnd::
     ~NSDictionaryISyntheticFrontEnd() {
   delete m_data_32;
   m_data_32 = nullptr;
   delete m_data_64;
   m_data_64 = nullptr;
 }
if (!dict_item.valobj_sp) {
     dict_item.valobj_sp = CreateValueObjectFromData(idx_name.GetString(), data,
                                                     m_exe_ctx_ref, m_pair_type);
   }
   return dict_item.valobj_sp;
 }
 
 lldb_private::formatters::NSCFDictionarySyntheticFrontEnd::
     NSCFDictionarySyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
-    : SyntheticChildrenFrontEnd(*valobj_sp), m_exe_ctx_ref(), m_ptr_size(8),
-      m_order(lldb::eByteOrderInvalid), m_hashtable(), m_pair_type() {}
+    : SyntheticChildrenFrontEnd(*valobj_sp), m_exe_ctx_ref(), m_hashtable(),
+      m_pair_type() {}
 
 size_t lldb_private::formatters::NSCFDictionarySyntheticFrontEnd::
     GetIndexOfChildWithName(ConstString name) {
   const char *item_name = name.GetCString();
   const uint32_t idx = ExtractIndexFromString(item_name);
   if (idx < UINT32_MAX && idx >= CalculateNumChildren())
     return UINT32_MAX;
   return idx;
lldb_private::formatters::NSDictionary1SyntheticFrontEnd::GetChildAtIndex(
   DataExtractor data(buffer_sp, process_sp->GetByteOrder(), ptr_size);
   m_pair = CreateValueObjectFromData(
       "[0]", data, m_backend.GetExecutionContextRef(), pair_type);
 
   return m_pair;
 }
 
 template <typename D32, typename D64>
-lldb_private::formatters::GenericNSDictionaryMSyntheticFrontEnd<D32,D64>::
+lldb_private::formatters::GenericNSDictionaryMSyntheticFrontEnd<D32, D64>::
     GenericNSDictionaryMSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
-    : SyntheticChildrenFrontEnd(*valobj_sp), m_exe_ctx_ref(), m_ptr_size(8),
-      m_order(lldb::eByteOrderInvalid), m_data_32(nullptr), m_data_64(nullptr),
-      m_pair_type() {}
+    : SyntheticChildrenFrontEnd(*valobj_sp), m_exe_ctx_ref(),
+      m_data_32(nullptr), m_data_64(nullptr), m_pair_type() {}
 
 template <typename D32, typename D64>
 lldb_private::formatters::GenericNSDictionaryMSyntheticFrontEnd<D32,D64>::
     ~GenericNSDictionaryMSyntheticFrontEnd<D32,D64>() {
   delete m_data_32;
   m_data_32 = nullptr;
   delete m_data_64;
   m_data_64 = nullptr;
if (!dict_item.valobj_sp) {
     idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx);
     DataExtractor data(buffer_sp, m_order, m_ptr_size);
     dict_item.valobj_sp = CreateValueObjectFromData(idx_name.GetString(), data,
                                                     m_exe_ctx_ref, m_pair_type);
   }
   return dict_item.valobj_sp;
 }
 
-lldb_private::formatters::Foundation1100::
-  NSDictionaryMSyntheticFrontEnd::
+lldb_private::formatters::Foundation1100::NSDictionaryMSyntheticFrontEnd::
     NSDictionaryMSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
-    : SyntheticChildrenFrontEnd(*valobj_sp), m_exe_ctx_ref(), m_ptr_size(8),
-      m_order(lldb::eByteOrderInvalid), m_data_32(nullptr), m_data_64(nullptr),
-      m_pair_type() {}
+    : SyntheticChildrenFrontEnd(*valobj_sp), m_exe_ctx_ref(), m_pair_type() {}
 
 lldb_private::formatters::Foundation1100::
   NSDictionaryMSyntheticFrontEnd::~NSDictionaryMSyntheticFrontEnd() {
   delete m_data_32;
   m_data_32 = nullptr;
   delete m_data_64;
   m_data_64 = nullptr;
 }

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

 static constexpr size_t PACKED_INDEX_SHIFT_32(size_t i) {
   return (32 - (13 * (2 - i)));
 }
 
 class NSIndexPathSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
 public:
   NSIndexPathSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
       : SyntheticChildrenFrontEnd(*valobj_sp.get()), m_descriptor_sp(nullptr),
-        m_impl(), m_ptr_size(0), m_uint_star_type() {
+        m_impl(), m_uint_star_type() {
     m_ptr_size =
         m_backend.GetTargetSP()->GetArchitecture().GetAddressByteSize();
   }
 
   ~NSIndexPathSyntheticFrontEnd() override = default;
 
   size_t CalculateNumChildren() override { return m_impl.GetNumIndexes(); }
 
void Clear() {
       m_outsourced.Clear();
     }
 
     Impl() {}
 
     Mode m_mode = Mode::Invalid;
   } m_impl;
 
-  uint32_t m_ptr_size;
+  uint32_t m_ptr_size = 0;
   CompilerType m_uint_star_type;
 };
 
 namespace lldb_private {
 namespace formatters {
 
 SyntheticChildrenFrontEnd *
 NSIndexPathSyntheticFrontEndCreator(CXXSyntheticChildren *,
                                     lldb::ValueObjectSP valobj_sp) {
   if (valobj_sp)
     return new NSIndexPathSyntheticFrontEnd(valobj_sp);
   return nullptr;
 }
 
 } // namespace formatters
 } // namespace lldb_private

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

private:
   };
 
   struct SetItemDescriptor {
     lldb::addr_t item_ptr;
     lldb::ValueObjectSP valobj_sp;
   };
 
   ExecutionContextRef m_exe_ctx_ref;
-  uint8_t m_ptr_size;
-  DataDescriptor_32 *m_data_32;
-  DataDescriptor_64 *m_data_64;
+  uint8_t m_ptr_size = 8;
+  DataDescriptor_32 *m_data_32 = nullptr;
+  DataDescriptor_64 *m_data_64 = nullptr;
   lldb::addr_t m_data_ptr;
   std::vector<SetItemDescriptor> m_children;
 };
 
 class NSCFSetSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
 public:
   NSCFSetSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);
 

 
 private:
   struct SetItemDescriptor {
     lldb::addr_t item_ptr;
     lldb::ValueObjectSP valobj_sp;
   };
 
   ExecutionContextRef m_exe_ctx_ref;
-  uint8_t m_ptr_size;
-  lldb::ByteOrder m_order;
+  uint8_t m_ptr_size = 8;
+  lldb::ByteOrder m_order = lldb::eByteOrderInvalid;
 
   CFBasicHash m_hashtable;
 
   CompilerType m_pair_type;
   std::vector<SetItemDescriptor> m_children;
 };
 
 template <typename D32, typename D64>

 private:
 
   struct SetItemDescriptor {
     lldb::addr_t item_ptr;
     lldb::ValueObjectSP valobj_sp;
   };
 
   ExecutionContextRef m_exe_ctx_ref;
-  uint8_t m_ptr_size;
+  uint8_t m_ptr_size = 8;
   D32 *m_data_32;
   D64 *m_data_64;
   std::vector<SetItemDescriptor> m_children;
 };
   
 namespace Foundation1300 {
   struct DataDescriptor_32 {
     uint32_t _used : 26;
if (class_name == g_SetI || class_name == g_OrderedSetI) {
     if (iter != end)
       return iter->second(synth, valobj_sp);
     return nullptr;
   }
 }
 
 lldb_private::formatters::NSSetISyntheticFrontEnd::NSSetISyntheticFrontEnd(
     lldb::ValueObjectSP valobj_sp)
-    : SyntheticChildrenFrontEnd(*valobj_sp), m_exe_ctx_ref(), m_ptr_size(8),
-      m_data_32(nullptr), m_data_64(nullptr) {
+    : SyntheticChildrenFrontEnd(*valobj_sp), m_exe_ctx_ref() {
   if (valobj_sp)
     Update();
 }
 
 lldb_private::formatters::NSSetISyntheticFrontEnd::~NSSetISyntheticFrontEnd() {
   delete m_data_32;
   m_data_32 = nullptr;
   delete m_data_64;
set_item.valobj_sp = CreateValueObjectFromData(
         m_backend.GetCompilerType().GetBasicTypeFromAST(
             lldb::eBasicTypeObjCID));
   }
   return set_item.valobj_sp;
 }
 
 lldb_private::formatters::NSCFSetSyntheticFrontEnd::NSCFSetSyntheticFrontEnd(
     lldb::ValueObjectSP valobj_sp)
-    : SyntheticChildrenFrontEnd(*valobj_sp), m_exe_ctx_ref(), m_ptr_size(8),
-      m_order(lldb::eByteOrderInvalid), m_hashtable(), m_pair_type() {}
+    : SyntheticChildrenFrontEnd(*valobj_sp), m_exe_ctx_ref(), m_hashtable(),
+      m_pair_type() {}
 
 size_t
 lldb_private::formatters::NSCFSetSyntheticFrontEnd::GetIndexOfChildWithName(
     ConstString name) {
   const char *item_name = name.GetCString();
   const uint32_t idx = ExtractIndexFromString(item_name);
   if (idx < UINT32_MAX && idx >= CalculateNumChildren())
     return UINT32_MAX;
set_item.valobj_sp = CreateValueObjectFromData(
         m_backend.GetCompilerType().GetBasicTypeFromAST(
             lldb::eBasicTypeObjCID));
   }
 
   return set_item.valobj_sp;
 }
 
 template <typename D32, typename D64>
-lldb_private::formatters::
-  GenericNSSetMSyntheticFrontEnd<D32, D64>::GenericNSSetMSyntheticFrontEnd(
-    lldb::ValueObjectSP valobj_sp)
-    : SyntheticChildrenFrontEnd(*valobj_sp), m_exe_ctx_ref(), m_ptr_size(8),
+lldb_private::formatters::GenericNSSetMSyntheticFrontEnd<
+    D32, D64>::GenericNSSetMSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
+    : SyntheticChildrenFrontEnd(*valobj_sp), m_exe_ctx_ref(),
       m_data_32(nullptr), m_data_64(nullptr) {
   if (valobj_sp)
     Update();
 }
 
 template <typename D32, typename D64>
 lldb_private::formatters::
   GenericNSSetMSyntheticFrontEnd<D32, D64>::~GenericNSSetMSyntheticFrontEnd<D32, D64>() {

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

AppleObjCDeclVendor::GetDeclForISA(ObjCLanguageRuntime::ObjCISA isa) {
 
   m_isa_to_interface[isa] = new_iface_decl;
 
   return new_iface_decl;
 }
 
 class ObjCRuntimeMethodType {
 public:
-  ObjCRuntimeMethodType(const char *types) : m_is_valid(false) {
+  ObjCRuntimeMethodType(const char *types) {
     const char *cursor = types;
     enum ParserState { Start = 0, InType, InPos } state = Start;
     const char *type = nullptr;
     int brace_depth = 0;
 
     uint32_t stepsLeft = 256;
 
     while (true) {
public:
   size_t GetNumTypes() { return m_type_vector.size(); }
 
   const char *GetTypeAtIndex(size_t idx) { return m_type_vector[idx].c_str(); }
 
 private:
   typedef std::vector<std::string> TypeVector;
 
   TypeVector m_type_vector;
-  bool m_is_valid;
+  bool m_is_valid = false;
 };
 
 bool AppleObjCDeclVendor::FinishDecl(clang::ObjCInterfaceDecl *interface_decl) {
   Log *log(
       GetLog(LLDBLog::Expressions)); // FIXME - a more appropriate log channel?
 
   ClangASTMetadata *metadata = m_ast_ctx.GetMetadata(interface_decl);
   ObjCLanguageRuntime::ObjCISA objc_isa = 0;

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

if (debug)                                                               \n\
           return_struct.impl_addr);                                          \n\
                                                                              \n\
     return return_struct.impl_addr;                                          \n\
 }                                                                            \n\
 ";
 
 AppleObjCTrampolineHandler::AppleObjCVTables::VTableRegion::VTableRegion(
     AppleObjCVTables *owner, lldb::addr_t header_addr)
-    : m_valid(true), m_owner(owner), m_header_addr(header_addr),
-      m_code_start_addr(0), m_code_end_addr(0), m_next_region(0) {
+    : m_valid(true), m_owner(owner), m_header_addr(header_addr) {
   SetUpRegion();
 }
 
 AppleObjCTrampolineHandler::~AppleObjCTrampolineHandler() = default;
 
 void AppleObjCTrampolineHandler::AppleObjCVTables::VTableRegion::SetUpRegion() {
   // The header looks like:
   //

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

public:
 
   const UnwindInfo *GetUnwindInfo() const { return m_unwind_info; }
   const UnwindCode *GetUnwindCode() const { return m_unwind_code; }
   bool IsChained() const { return m_chained; }
 
 private:
   ObjectFilePECOFF &m_object_file;
 
-  bool m_error;
+  bool m_error = false;
 
   uint32_t m_unwind_info_rva;
   DataExtractor m_unwind_info_data;
-  const UnwindInfo *m_unwind_info;
+  const UnwindInfo *m_unwind_info = nullptr;
 
   DataExtractor m_unwind_code_data;
   offset_t m_unwind_code_offset;
-  const UnwindCode *m_unwind_code;
+  const UnwindCode *m_unwind_code = nullptr;
 
-  bool m_chained;
+  bool m_chained = false;
 };
 
 UnwindCodesIterator::UnwindCodesIterator(ObjectFilePECOFF &object_file,
                                          uint32_t unwind_info_rva)
-    : m_object_file(object_file), m_error(false),
-      m_unwind_info_rva(unwind_info_rva),
-      m_unwind_info(nullptr), m_unwind_code_offset{}, m_unwind_code(nullptr),
-      m_chained(false) {}
+    : m_object_file(object_file),
+      m_unwind_info_rva(unwind_info_rva), m_unwind_code_offset{} {}
 
 bool UnwindCodesIterator::GetNext() {
   static constexpr int UNWIND_INFO_SIZE = 4;
 
   m_error = false;
   m_unwind_code = nullptr;
   while (!m_unwind_code) {
     if (!m_unwind_info) {

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

 
 using namespace lldb_private;
 using namespace lldb_private::dwarf;
 
 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() {}
+    : m_tag(tag), m_has_children(has_children), m_attributes() {}
 
 llvm::Expected<DWARFEnumState>
 DWARFAbbreviationDeclaration::extract(const DWARFDataExtractor &data,
                                       lldb::offset_t *offset_ptr) {
   m_code = data.GetULEB128(offset_ptr);
   if (m_code == 0)
     return DWARFEnumState::Complete;
 

lldb/source/Symbol/Symbol.cpp

 Symbol::Symbol()
     : 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() {}
 
-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),
-      m_is_debug(is_debug), m_is_external(external), m_size_is_sibling(false),
+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_resolved(false),
+      m_is_synthetic(is_artificial), m_is_debug(is_debug),
+      m_is_external(external), m_size_is_sibling(false),
       m_size_is_synthesized(false), m_size_is_valid(size_is_valid || size > 0),
       m_demangled_is_synthesized(false),
       m_contains_linker_annotations(contains_linker_annotations),
-      m_is_weak(false), m_type(type),
-      m_mangled(name),
+      m_is_weak(false), m_type(type), m_mangled(name),
       m_addr_range(section_sp, offset, size), m_flags(flags) {}
 
 Symbol::Symbol(uint32_t symID, const Mangled &mangled, SymbolType type,
                bool external, bool is_debug, bool is_trampoline,
                bool is_artificial, const AddressRange &range,
                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),
-      m_is_debug(is_debug), m_is_external(external), m_size_is_sibling(false),
+    : SymbolContextScope(), m_uid(symID), m_type_data_resolved(false),
+      m_is_synthetic(is_artificial), m_is_debug(is_debug),
+      m_is_external(external), m_size_is_sibling(false),
       m_size_is_synthesized(false),
       m_size_is_valid(size_is_valid || range.GetByteSize() > 0),
       m_demangled_is_synthesized(false),
       m_contains_linker_annotations(contains_linker_annotations),
       m_is_weak(false), m_type(type), m_mangled(mangled), m_addr_range(range),
       m_flags(flags) {}
 
 Symbol::Symbol(const Symbol &rhs)

lldb/source/Symbol/SymbolContext.cpp

 using namespace lldb;
 using namespace lldb_private;
 
 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) {
+      line_entry(), symbol(s) {
   if (le)
     line_entry = *le;
 }
 
 SymbolContext::SymbolContext(const TargetSP &t, const ModuleSP &m,
                              CompileUnit *cu, Function *f, Block *b,
                              LineEntry *le, Symbol *s)
     : target_sp(t), module_sp(m), comp_unit(cu), function(f), block(b),
-      line_entry(), symbol(s), variable(nullptr) {
+      line_entry(), symbol(s) {
   if (le)
     line_entry = *le;
 }
 
 SymbolContext::SymbolContext(SymbolContextScope *sc_scope)
-    : target_sp(), module_sp(), comp_unit(nullptr), function(nullptr),
-      block(nullptr), line_entry(), symbol(nullptr), variable(nullptr) {
+    : target_sp(), module_sp(), line_entry() {
   sc_scope->CalculateSymbolContext(this);
 }
 
 SymbolContext::~SymbolContext() = default;
 
 void SymbolContext::Clear(bool clear_target) {
   if (clear_target)
     target_sp.reset();

lldb/source/Symbol/Type.cpp

 }
 
 Type::Type(lldb::user_id_t uid, SymbolFile *symbol_file, ConstString name,
            llvm::Optional<uint64_t> byte_size, SymbolContextScope *context,
            user_id_t encoding_uid, EncodingDataType encoding_uid_type,
            const Declaration &decl, const CompilerType &compiler_type,
            ResolveState compiler_type_resolve_state, uint32_t opaque_payload)
     : std::enable_shared_from_this<Type>(), UserID(uid), m_name(name),
-      m_symbol_file(symbol_file), m_context(context), m_encoding_type(nullptr),
+      m_symbol_file(symbol_file), m_context(context),
       m_encoding_uid(encoding_uid), m_encoding_uid_type(encoding_uid_type),
       m_decl(decl), m_compiler_type(compiler_type),
       m_compiler_type_resolve_state(compiler_type ? compiler_type_resolve_state
                                                   : ResolveState::Unresolved),
       m_payload(opaque_payload) {
   if (byte_size) {
     m_byte_size = *byte_size;
     m_byte_size_has_value = true;

lldb/source/Target/ExecutionContext.cpp

 bool ExecutionContext::HasFrameScope() const {
   return HasThreadScope() && m_frame_sp;
 }
 
 ExecutionContextRef::ExecutionContextRef()
     : 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() {
+    : m_target_wp(), m_process_wp(), m_thread_wp(), m_stack_id() {
   if (exe_ctx)
     *this = *exe_ctx;
 }
 
 ExecutionContextRef::ExecutionContextRef(const ExecutionContext &exe_ctx)
-    : 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() {
   *this = exe_ctx;
 }
 
 ExecutionContextRef::ExecutionContextRef(Target *target, bool adopt_selected)
-    : 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() {
   SetTargetPtr(target, adopt_selected);
 }
 
 ExecutionContextRef::ExecutionContextRef(const ExecutionContextRef &rhs)
     : m_target_wp(rhs.m_target_wp), m_process_wp(rhs.m_process_wp),
       m_thread_wp(rhs.m_thread_wp), m_tid(rhs.m_tid),
       m_stack_id(rhs.m_stack_id) {}
 

lldb/source/Target/LanguageRuntime.cpp

 // The Target is the one that knows how to create breakpoints, so this function
 // is meant to be used either by the target or internally in
 // Set/ClearExceptionBreakpoints.
 class ExceptionBreakpointResolver : public BreakpointResolver {
 public:
   ExceptionBreakpointResolver(lldb::LanguageType language, bool catch_bp,
                               bool throw_bp)
       : BreakpointResolver(nullptr, BreakpointResolver::ExceptionResolver),
-        m_language(language), m_language_runtime(nullptr), m_catch_bp(catch_bp),
-        m_throw_bp(throw_bp) {}
+        m_language(language), m_catch_bp(catch_bp), m_throw_bp(throw_bp) {}
 
   ~ExceptionBreakpointResolver() override = default;
 
   Searcher::CallbackReturn SearchCallback(SearchFilter &filter,
                                           SymbolContext &context,
                                           Address *addr) override {
 
     if (SetActualResolver())
if (breakpoint_sp) {
       m_actual_resolver_sp.reset();
       m_language_runtime = nullptr;
     }
     return (bool)m_actual_resolver_sp;
   }
 
   lldb::BreakpointResolverSP m_actual_resolver_sp;
   lldb::LanguageType m_language;
-  LanguageRuntime *m_language_runtime;
+  LanguageRuntime *m_language_runtime = nullptr;
   bool m_catch_bp;
   bool m_throw_bp;
 };
 
 LanguageRuntime *LanguageRuntime::FindPlugin(Process *process,
                                              lldb::LanguageType language) {
   LanguageRuntimeCreateInstance create_callback;
   for (uint32_t idx = 0;

lldb/source/Target/PathMappingList.cpp

std::string NormalizePath(llvm::StringRef path) {
   // us. We then grab the string.
   return FileSpec(path).GetPath();
 }
 }
 // PathMappingList constructor
 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) {}
+    : m_pairs(), m_callback(callback), m_callback_baton(callback_baton) {}
 
 PathMappingList::PathMappingList(const PathMappingList &rhs)
-    : m_pairs(rhs.m_pairs), m_callback(nullptr), m_callback_baton(nullptr),
-      m_mod_id(0) {}
+    : m_pairs(rhs.m_pairs) {}
 
 const PathMappingList &PathMappingList::operator=(const PathMappingList &rhs) {
   if (this != &rhs) {
     m_pairs = rhs.m_pairs;
     m_callback = nullptr;
     m_callback_baton = nullptr;
     m_mod_id = rhs.m_mod_id;
   }

lldb/source/Target/Process.cpp

 }
 
 // Process Event Data
 
 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) {
+    : EventData(), m_process_wp(), m_state(state) {
   if (process_sp)
     m_process_wp = process_sp;
 }
 
 Process::ProcessEventData::~ProcessEventData() = default;
 
 ConstString Process::ProcessEventData::GetFlavorString() {
   static ConstString g_flavor("Process::ProcessEventData");

 // "okay
 // to discard" fields of the plan we are running, and reset it on Clean or on
 // destruction. It will only reset the state once, so you can call Clean and
 // then monkey with the state and it won't get reset on you again.
 
 class RestorePlanState {
 public:
   RestorePlanState(lldb::ThreadPlanSP thread_plan_sp)
-      : m_thread_plan_sp(thread_plan_sp), m_already_reset(false) {
+      : m_thread_plan_sp(thread_plan_sp) {
     if (m_thread_plan_sp) {
       m_private = m_thread_plan_sp->GetPrivate();
       m_is_controlling = m_thread_plan_sp->IsControllingPlan();
       m_okay_to_discard = m_thread_plan_sp->OkayToDiscard();
     }
   }
 
   ~RestorePlanState() { Clean(); }
 
   void Clean() {
     if (!m_already_reset && m_thread_plan_sp) {
       m_already_reset = true;
       m_thread_plan_sp->SetPrivate(m_private);
       m_thread_plan_sp->SetIsControllingPlan(m_is_controlling);
       m_thread_plan_sp->SetOkayToDiscard(m_okay_to_discard);
     }
   }
 
 private:
   lldb::ThreadPlanSP m_thread_plan_sp;
-  bool m_already_reset;
+  bool m_already_reset = false;
   bool m_private;
   bool m_is_controlling;
   bool m_okay_to_discard;
 };
 } // anonymous namespace
 
 static microseconds
 GetOneThreadExpressionTimeout(const EvaluateExpressionOptions &options) {

lldb/source/Target/StopInfo.cpp

public:
 
   private:
     ProcessSP process_sp;
     WatchpointSP watchpoint_sp;
   };
 
   StopInfoWatchpoint(Thread &thread, break_id_t watch_id,
                      lldb::addr_t watch_hit_addr)
-      : StopInfo(thread, watch_id), m_should_stop(false),
-        m_should_stop_is_valid(false), m_watch_hit_addr(watch_hit_addr) {}
+      : StopInfo(thread, watch_id), m_watch_hit_addr(watch_hit_addr) {}
 
   ~StopInfoWatchpoint() override = default;
 
   StopReason GetStopReason() const override { return eStopReasonWatchpoint; }
 
   const char *GetDescription() override {
     if (m_description.empty()) {
       StreamString strm;
if (thread_sp) {
                 "Process::%s returning from action with m_should_stop: %d.",
                 __FUNCTION__, m_should_stop);
 
       m_should_stop_is_valid = true;
     }
   }
 
 private:
-  bool m_should_stop;
-  bool m_should_stop_is_valid;
+  bool m_should_stop = false;
+  bool m_should_stop_is_valid = false;
   lldb::addr_t m_watch_hit_addr;
 };
 
 // StopInfoUnixSignal
 
 class StopInfoUnixSignal : public StopInfo {
 public:
   StopInfoUnixSignal(Thread &thread, int signo, const char *description)
private:
   ValueObjectSP m_return_valobj_sp;
   ExpressionVariableSP m_expression_variable_sp;
 };
 
 // StopInfoExec
 
 class StopInfoExec : public StopInfo {
 public:
-  StopInfoExec(Thread &thread)
-      : StopInfo(thread, LLDB_INVALID_UID), m_performed_action(false) {}
+  StopInfoExec(Thread &thread) : StopInfo(thread, LLDB_INVALID_UID) {}
 
   ~StopInfoExec() override = default;
 
   bool ShouldStop(Event *event_ptr) override {
     ThreadSP thread_sp(m_thread_wp.lock());
     if (thread_sp)
       return thread_sp->GetProcess()->GetStopOnExec();
     return false;
void PerformAction(Event *event_ptr) override {
     if (m_performed_action)
       return;
     m_performed_action = true;
     ThreadSP thread_sp(m_thread_wp.lock());
     if (thread_sp)
       thread_sp->GetProcess()->DidExec();
   }
 
-  bool m_performed_action;
+  bool m_performed_action = false;
 };
 
 // StopInfoFork
 
 class StopInfoFork : public StopInfo {
 public:
   StopInfoFork(Thread &thread, lldb::pid_t child_pid, lldb::tid_t child_tid)
-      : StopInfo(thread, child_pid), m_performed_action(false),
-        m_child_pid(child_pid), m_child_tid(child_tid) {}
+      : StopInfo(thread, child_pid), m_child_pid(child_pid),
+        m_child_tid(child_tid) {}
 
   ~StopInfoFork() override = default;
 
   bool ShouldStop(Event *event_ptr) override { return false; }
 
   StopReason GetStopReason() const override { return eStopReasonFork; }
 
   const char *GetDescription() override { return "fork"; }
 
 protected:
   void PerformAction(Event *event_ptr) override {
     // Only perform the action once
     if (m_performed_action)
       return;
     m_performed_action = true;
     ThreadSP thread_sp(m_thread_wp.lock());
     if (thread_sp)
       thread_sp->GetProcess()->DidFork(m_child_pid, m_child_tid);
   }
 
-  bool m_performed_action;
+  bool m_performed_action = false;
 
 private:
   lldb::pid_t m_child_pid;
   lldb::tid_t m_child_tid;
 };
 
 // StopInfoVFork
 
 class StopInfoVFork : public StopInfo {
 public:
   StopInfoVFork(Thread &thread, lldb::pid_t child_pid, lldb::tid_t child_tid)
-      : StopInfo(thread, child_pid), m_performed_action(false),
-        m_child_pid(child_pid), m_child_tid(child_tid) {}
+      : StopInfo(thread, child_pid), m_child_pid(child_pid),
+        m_child_tid(child_tid) {}
 
   ~StopInfoVFork() override = default;
 
   bool ShouldStop(Event *event_ptr) override { return false; }
 
   StopReason GetStopReason() const override { return eStopReasonVFork; }
 
   const char *GetDescription() override { return "vfork"; }
 
 protected:
   void PerformAction(Event *event_ptr) override {
     // Only perform the action once
     if (m_performed_action)
       return;
     m_performed_action = true;
     ThreadSP thread_sp(m_thread_wp.lock());
     if (thread_sp)
       thread_sp->GetProcess()->DidVFork(m_child_pid, m_child_tid);
   }
 
-  bool m_performed_action;
+  bool m_performed_action = false;
 
 private:
   lldb::pid_t m_child_pid;
   lldb::tid_t m_child_tid;
 };
 
 // StopInfoVForkDone
 
 class StopInfoVForkDone : public StopInfo {
 public:
-  StopInfoVForkDone(Thread &thread)
-      : StopInfo(thread, 0), m_performed_action(false) {}
+  StopInfoVForkDone(Thread &thread) : StopInfo(thread, 0) {}
 
   ~StopInfoVForkDone() override = default;
 
   bool ShouldStop(Event *event_ptr) override { return false; }
 
   StopReason GetStopReason() const override { return eStopReasonVForkDone; }
 
   const char *GetDescription() override { return "vforkdone"; }
 
 protected:
   void PerformAction(Event *event_ptr) override {
     // Only perform the action once
     if (m_performed_action)
       return;
     m_performed_action = true;
     ThreadSP thread_sp(m_thread_wp.lock());
     if (thread_sp)
       thread_sp->GetProcess()->DidVForkDone();
   }
 
-  bool m_performed_action;
+  bool m_performed_action = false;
 };
 
 } // namespace lldb_private
 
 StopInfoSP StopInfo::CreateStopReasonWithBreakpointSiteID(Thread &thread,
                                                           break_id_t break_id) {
   return StopInfoSP(new StopInfoBreakpoint(thread, break_id));
 }

lldb/source/Utility/DataExtractor.cpp

 
 // Make a shared pointer reference to the shared data in "data_sp" and set the
 // endian swapping setting to "swap", and the address size to "addr_size". The
 // shared data reference will ensure the data lives as long as any
 // DataExtractor objects exist that have a reference to this data.
 DataExtractor::DataExtractor(const DataBufferSP &data_sp, ByteOrder endian,
                              uint32_t addr_size,
                              uint32_t target_byte_size /*=1*/)
-    : m_start(nullptr), m_end(nullptr), m_byte_order(endian),
-      m_addr_size(addr_size), m_data_sp(),
+    : m_byte_order(endian), m_addr_size(addr_size), m_data_sp(),
       m_target_byte_size(target_byte_size) {
   assert(addr_size >= 1 && addr_size <= 8);
   SetData(data_sp);
 }
 
 // Initialize this object with a subset of the data bytes in "data". If "data"
 // contains shared data, then a reference to this shared data will added and
 // the shared data will stay around as long as any object contains a reference
 // to that data. The endian swap and address size settings are copied from
 // "data".
 DataExtractor::DataExtractor(const DataExtractor &data, offset_t offset,
                              offset_t length, uint32_t target_byte_size /*=1*/)
-    : m_start(nullptr), m_end(nullptr), m_byte_order(data.m_byte_order),
-      m_addr_size(data.m_addr_size), m_data_sp(),
-      m_target_byte_size(target_byte_size) {
+    : m_byte_order(data.m_byte_order), m_addr_size(data.m_addr_size),
+      m_data_sp(), m_target_byte_size(target_byte_size) {
   assert(m_addr_size >= 1 && m_addr_size <= 8);
   if (data.ValidOffset(offset)) {
     offset_t bytes_available = data.GetByteSize() - offset;
     if (length > bytes_available)
       length = bytes_available;
     SetData(data, offset, length);
   }
 }

lldb/source/Utility/Instrumentation.cpp

 // Whether we're currently across the API boundary.
 static thread_local bool g_global_boundary = false;
 
 // Instrument SB API calls with singposts when supported.
 static llvm::ManagedStatic<llvm::SignpostEmitter> g_api_signposts;
 
 Instrumenter::Instrumenter(llvm::StringRef pretty_func,
                            std::string &&pretty_args)
-    : m_pretty_func(pretty_func), m_local_boundary(false) {
+    : m_pretty_func(pretty_func) {
   if (!g_global_boundary) {
     g_global_boundary = true;
     m_local_boundary = true;
     g_api_signposts->startInterval(this, m_pretty_func);
   }
   LLDB_LOG(GetLog(LLDBLog::API), "[{0}] {1} ({2})",
            m_local_boundary ? "external" : "internal", m_pretty_func,
            pretty_args);
 }
 
 Instrumenter::~Instrumenter() {
   if (m_local_boundary) {
     g_global_boundary = false;
     g_api_signposts->endInterval(this, m_pretty_func);
   }
 }

lldb/source/Utility/ProcessInfo.cpp

 using namespace lldb_private;
 using namespace lldb_private::repro;
 
 ProcessInfo::ProcessInfo()
     : 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) {}
+    : m_executable(name), m_arguments(), m_environment(), m_arch(arch),
+      m_pid(pid) {}
 
 void ProcessInfo::Clear() {
   m_executable.Clear();
   m_arguments.Clear();
   m_environment.clear();
   m_uid = UINT32_MAX;
   m_gid = UINT32_MAX;
   m_arch.Clear();

lldb/source/Utility/Status.cpp

 // "generic errors", while we use the term "generic" to mean completely
 // arbitrary (text-based) errors.
 Status::Status(std::error_code EC)
     : m_code(EC.value()),
       m_type(EC.category() == std::generic_category() ? eErrorTypePOSIX
                                                       : eErrorTypeGeneric),
       m_string(EC.message()) {}
 
-Status::Status(const char *format, ...)
-    : m_code(0), m_type(eErrorTypeInvalid), m_string() {
+Status::Status(const char *format, ...) : m_string() {
   va_list args;
   va_start(args, format);
   SetErrorToGenericError();
   SetErrorStringWithVarArg(format, args);
   va_end(args);
 }
 
 const Status &Status::operator=(llvm::Error error) {

lldb/source/Utility/Stream.cpp

 #include <cstddef>
 
 using namespace lldb;
 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) {}
+      m_forwarder(*this, colors) {}
 
 Stream::Stream(bool colors)
     : m_flags(0), m_byte_order(endian::InlHostByteOrder()),
       m_forwarder(*this, colors) {}
 
 // Destructor
 Stream::~Stream() = default;
 

lldb/source/Utility/StringExtractor.cpp

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

lldb/unittests/Editline/EditlineTest.cpp

 
 private:
   bool IsInputComplete(lldb_private::Editline *editline,
                        lldb_private::StringList &lines);
 
   std::unique_ptr<lldb_private::Editline> _editline_sp;
 
   PseudoTerminal _pty;
-  int _pty_primary_fd;
-  int _pty_secondary_fd;
+  int _pty_primary_fd = -1;
+  int _pty_secondary_fd = -1;
 
   std::unique_ptr<FilePointer> _el_secondary_file;
 };
 
 EditlineAdapter::EditlineAdapter()
-    : _editline_sp(), _pty(), _pty_primary_fd(-1), _pty_secondary_fd(-1),
-      _el_secondary_file() {
+    : _editline_sp(), _pty(), _el_secondary_file() {
   lldb_private::Status error;
 
   // Open the first primary pty available.
   EXPECT_THAT_ERROR(_pty.OpenFirstAvailablePrimary(O_RDWR), llvm::Succeeded());
 
   // Grab the primary fd.  This is a file descriptor we will:
   // (1) write to when we want to send input to editline.
   // (2) read from when we want to see what editline sends back.

lldb/unittests/Host/FileSystemTest.cpp

getBuffer(const Twine &Name, int64_t FileSize, bool RequiresNullTerminator,
             bool IsVolatile) override {
     llvm_unreachable("unimplemented");
   }
   std::error_code close() override { return std::error_code(); }
 };
 
 class DummyFileSystem : public vfs::FileSystem {
   int FSID;   // used to produce UniqueIDs
-  int FileID; // used to produce UniqueIDs
+  int FileID = 0; // used to produce UniqueIDs
   std::string cwd;
   std::map<std::string, vfs::Status> FilesAndDirs;
 
   static int getNextFSID() {
     static int Count = 0;
     return Count++;
   }
 
 public:
-  DummyFileSystem() : FSID(getNextFSID()), FileID(0) {}
+  DummyFileSystem() : FSID(getNextFSID()) {}
 
   ErrorOr<vfs::Status> status(const Twine &Path) override {
     std::map<std::string, vfs::Status>::iterator I =
         FilesAndDirs.find(Path.str());
     if (I == FilesAndDirs.end())
       return make_error_code(llvm::errc::no_such_file_or_directory);
     return I->second;
   }

lldb/unittests/Process/ProcessEventDataTest.cpp

CreateRegisterContextForFrame(StackFrame *frame) override {
     return nullptr;
   }
 
   bool CalculateStopInfo() override { return false; }
 };
 
 class DummyStopInfo : public StopInfo {
 public:
-  DummyStopInfo(Thread &thread, uint64_t value)
-      : StopInfo(thread, value), m_should_stop(true),
-        m_stop_reason(eStopReasonBreakpoint) {}
+  DummyStopInfo(Thread &thread, uint64_t value) : StopInfo(thread, value) {}
 
   bool ShouldStop(Event *event_ptr) override { return m_should_stop; }
 
   StopReason GetStopReason() const override { return m_stop_reason; }
 
-  bool m_should_stop;
-  StopReason m_stop_reason;
+  bool m_should_stop = true;
+  StopReason m_stop_reason = eStopReasonBreakpoint;
 };
 
 class DummyProcessEventData : public Process::ProcessEventData {
 public:
   DummyProcessEventData(ProcessSP &process_sp, StateType state)
-      : ProcessEventData(process_sp, state), m_should_stop_hit_count(0) {}
+      : ProcessEventData(process_sp, state) {}
   bool ShouldStop(Event *event_ptr, bool &found_valid_stopinfo) override {
     m_should_stop_hit_count++;
     return false;
   }
 
-  int m_should_stop_hit_count;
+  int m_should_stop_hit_count = 0;
 };
 } // namespace
 
 typedef std::shared_ptr<Process::ProcessEventData> ProcessEventDataSP;
 typedef std::shared_ptr<Event> EventSP;
 
 TargetSP CreateTarget(DebuggerSP &debugger_sp, ArchSpec &arch) {
   PlatformSP platform_sp;