[LLDB][NFC][Reliability] Fix uninitialized variables from Coverity scan. Part 3

[fixathon]

Summary

Improve LLDB reliability by fixing the following "uninitialized variables" static code inspection warnings from
scan.coverity.com/projects/llvm:

1355854, 1347549, 1316348, 1372028, 1431625,
1315634, 1315637, 1355855, 1364803, 1420505,
1420563, 1420685, 1366014, 1203966, 1204029,
1204031, 1204032, 1328411, 1325969, 1325968,
1374921, 1094809

[JDevlieghere]

LGTM

lldb/include/lldb/Core/LoadedModuleInfoList.h

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

lldb/include/lldb/DataFormatters/TypeSummary.h

public:
 
   virtual std::string GetDescription() = 0;
 
   uint32_t &GetRevision() { return m_my_revision; }
 
   typedef std::shared_ptr<TypeSummaryImpl> SharedPointer;
 
 protected:
-  uint32_t m_my_revision;
+  uint32_t m_my_revision = 0;
   Flags m_flags;
 
   TypeSummaryImpl(Kind kind, const TypeSummaryImpl::Flags &flags);
 
 private:
   Kind m_kind;
   TypeSummaryImpl(const TypeSummaryImpl &) = delete;
   const TypeSummaryImpl &operator=(const TypeSummaryImpl &) = delete;

lldb/include/lldb/Symbol/DebugMacros.h

public:
   static DebugMacroEntry CreateStartFileEntry(uint32_t line,
                                               uint32_t debug_line_file_idx);
 
   static DebugMacroEntry CreateEndFileEntry();
 
   static DebugMacroEntry
   CreateIndirectEntry(const DebugMacrosSP &debug_macros_sp);
 
-  DebugMacroEntry() : m_type(INVALID) {}
+  DebugMacroEntry() : m_type(INVALID), m_line(0), m_debug_line_file_idx(0) {}
 
   ~DebugMacroEntry() = default;
 
   EntryType GetType() const { return static_cast<EntryType>(m_type); }
 
   uint64_t GetLineNumber() const { return m_line; }
 
   ConstString GetMacroString() const { return m_str; }

lldb/include/lldb/Target/ProcessStructReader.h

protected:
 
   std::map<ConstString, FieldImpl> m_fields;
   DataExtractor m_data;
   lldb::ByteOrder m_byte_order;
   size_t m_addr_byte_size;
 
 public:
   ProcessStructReader(Process *process, lldb::addr_t base_addr,
-                      CompilerType struct_type) {
+                      CompilerType struct_type)
+      : m_byte_order(lldb::eByteOrderInvalid), m_addr_byte_size(0) {
     if (!process)
       return;
     if (base_addr == 0 || base_addr == LLDB_INVALID_ADDRESS)
       return;
     m_byte_order = process->GetByteOrder();
     m_addr_byte_size = process->GetAddressByteSize();
 
     for (size_t idx = 0; idx < struct_type.GetNumFields(); idx++) {

lldb/include/lldb/Utility/Args.h

 public:
   struct ArgEntry {
   private:
     friend class Args;
     friend struct llvm::yaml::MappingTraits<Args>;
     friend struct llvm::yaml::MappingTraits<Args::ArgEntry>;
 
     std::unique_ptr<char[]> ptr;
-    char quote;
+    char quote = '\0';
 
     char *data() { return ptr.get(); }
 
   public:
     ArgEntry() = default;
     ArgEntry(llvm::StringRef str, char quote);
 
     llvm::StringRef ref() const { return c_str(); }
template <> struct MappingTraits<lldb_private::Args::ArgEntry> {
   public:
     NormalizedArgEntry(IO &) {}
     NormalizedArgEntry(IO &, lldb_private::Args::ArgEntry &entry)
         : value(entry.ref()), quote(entry.quote) {}
     lldb_private::Args::ArgEntry denormalize(IO &) {
       return lldb_private::Args::ArgEntry(value, quote);
     }
     StringRef value;
-    uint8_t quote;
+    uint8_t quote = '\0';
   };
   static void mapping(IO &io, lldb_private::Args::ArgEntry &v);
 };
 template <> struct MappingTraits<lldb_private::Args> {
   static void mapping(IO &io, lldb_private::Args &v);
 };
 } // namespace yaml
 } // namespace llvm
 
 LLVM_YAML_IS_SEQUENCE_VECTOR(lldb_private::Args::ArgEntry)
 
 #endif // LLDB_UTILITY_ARGS_H

lldb/include/lldb/Utility/RegisterValue.h

 protected:
   RegisterValue::Type m_type = eTypeInvalid;
   Scalar m_scalar;
 
   struct {
     mutable uint8_t
         bytes[kMaxRegisterByteSize]; // This must be big enough to hold any
                                      // register for any supported target.
-    uint16_t length;
-    lldb::ByteOrder byte_order;
+    uint16_t length = 0;
+    lldb::ByteOrder byte_order = lldb::eByteOrderInvalid;
   } buffer;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_UTILITY_REGISTERVALUE_H

lldb/include/lldb/Utility/StringExtractorGDBRemote.h

public:
   // Read thread-id from the packet.  If the packet is valid, returns
   // the pair (PID, TID), otherwise returns llvm::None.  If the packet
   // does not list a PID, default_pid is used.
   llvm::Optional<std::pair<lldb::pid_t, lldb::tid_t>>
   GetPidTid(lldb::pid_t default_pid);
 
 protected:
   ResponseValidatorCallback m_validator = nullptr;
-  void *m_validator_baton;
+  void *m_validator_baton = nullptr;
 };
 
 #endif // LLDB_UTILITY_STRINGEXTRACTORGDBREMOTE_H

lldb/source/Breakpoint/BreakpointOptions.cpp

bool BreakpointOptions::NullCallback(void *baton,
   return true;
 }
 
 // BreakpointOptions constructor
 BreakpointOptions::BreakpointOptions(bool all_flags_set)
     : m_callback(BreakpointOptions::NullCallback),
       m_baton_is_command_baton(false), m_callback_is_synchronous(false),
       m_enabled(true), m_one_shot(false), m_ignore_count(0),
-      m_condition_text_hash(0), m_auto_continue(false), m_set_flags(0) {
+      m_condition_text_hash(0), m_inject_condition(false),
+      m_auto_continue(false), m_set_flags(0) {
   if (all_flags_set)
     m_set_flags.Set(~((Flags::ValueType)0));
 }
 
 BreakpointOptions::BreakpointOptions(const char *condition, bool enabled,
                                      int32_t ignore, bool one_shot, 
                                      bool auto_continue)
     : m_callback(nullptr), m_baton_is_command_baton(false),
       m_callback_is_synchronous(false), m_enabled(enabled),
-      m_one_shot(one_shot), m_ignore_count(ignore),
-      m_condition_text_hash(0), m_auto_continue(auto_continue)
-{
-    m_set_flags.Set(eEnabled | eIgnoreCount | eOneShot 
-                   | eAutoContinue);
+      m_one_shot(one_shot), m_ignore_count(ignore), m_condition_text_hash(0),
+      m_inject_condition(false), m_auto_continue(auto_continue) {
+  m_set_flags.Set(eEnabled | eIgnoreCount | eOneShot | eAutoContinue);
     if (condition && *condition != '\0') {
       SetCondition(condition);
     }
 }
 
 // BreakpointOptions copy constructor
 BreakpointOptions::BreakpointOptions(const BreakpointOptions &rhs)
     : m_callback(rhs.m_callback), m_callback_baton_sp(rhs.m_callback_baton_sp),
       m_baton_is_command_baton(rhs.m_baton_is_command_baton),
       m_callback_is_synchronous(rhs.m_callback_is_synchronous),
       m_enabled(rhs.m_enabled), m_one_shot(rhs.m_one_shot),
-      m_ignore_count(rhs.m_ignore_count), m_auto_continue(rhs.m_auto_continue),
-      m_set_flags(rhs.m_set_flags) {
+      m_ignore_count(rhs.m_ignore_count), m_inject_condition(false),
+      m_auto_continue(rhs.m_auto_continue), m_set_flags(rhs.m_set_flags) {
   if (rhs.m_thread_spec_up != nullptr)
     m_thread_spec_up = std::make_unique<ThreadSpec>(*rhs.m_thread_spec_up);
   m_condition_text = rhs.m_condition_text;
   m_condition_text_hash = rhs.m_condition_text_hash;
 }
 
 // BreakpointOptions assignment operator
 const BreakpointOptions &BreakpointOptions::
 operator=(const BreakpointOptions &rhs) {
   m_callback = rhs.m_callback;
   m_callback_baton_sp = rhs.m_callback_baton_sp;
   m_baton_is_command_baton = rhs.m_baton_is_command_baton;
   m_callback_is_synchronous = rhs.m_callback_is_synchronous;
   m_enabled = rhs.m_enabled;
   m_one_shot = rhs.m_one_shot;
   m_ignore_count = rhs.m_ignore_count;
   if (rhs.m_thread_spec_up != nullptr)
     m_thread_spec_up = std::make_unique<ThreadSpec>(*rhs.m_thread_spec_up);
   m_condition_text = rhs.m_condition_text;
   m_condition_text_hash = rhs.m_condition_text_hash;
+  m_inject_condition = rhs.m_inject_condition;
   m_auto_continue = rhs.m_auto_continue;
   m_set_flags = rhs.m_set_flags;
   return *this;
 }
 
 void BreakpointOptions::CopyOverSetOptions(const BreakpointOptions &incoming)
 {
   if (incoming.m_set_flags.Test(eEnabled))

lldb/source/Core/Debugger.cpp

Status Debugger::SetPropertyValue(const ExecutionContext *exe_ctx,
   bool invalidate_data_vis = (property_path == "escape-non-printables");
   invalidate_data_vis |=
       (property_path == "target.max-zero-padding-in-float-format");
   if (invalidate_data_vis) {
     DataVisualization::ForceUpdate();
   }
 
   TargetSP target_sp;
-  LoadScriptFromSymFile load_script_old_value;
+  LoadScriptFromSymFile load_script_old_value = eLoadScriptFromSymFileFalse;
   if (is_load_script && exe_ctx->GetTargetSP()) {
     target_sp = exe_ctx->GetTargetSP();
     load_script_old_value =
         target_sp->TargetProperties::GetLoadScriptFromSymbolFile();
   }
   Status error(Properties::SetPropertyValue(exe_ctx, op, property_path, value));
   if (error.Success()) {
     // FIXME it would be nice to have "on-change" callbacks for properties

lldb/source/Core/IOHandlerCursesGUI.cpp

Window(const char *name, WINDOW *w, bool del = true)
         m_curr_active_window_idx(UINT32_MAX),
         m_prev_active_window_idx(UINT32_MAX), m_delete(del),
         m_needs_update(true), m_can_activate(true), m_is_subwin(false) {
     if (w)
       Reset(w);
   }
 
   Window(const char *name, const Rect &bounds)
-      : Surface(Surface::Type::Window), m_name(name), m_parent(nullptr),
-        m_subwindows(), m_delegate_sp(), m_curr_active_window_idx(UINT32_MAX),
-        m_prev_active_window_idx(UINT32_MAX), m_delete(true),
+      : Surface(Surface::Type::Window), m_name(name), m_panel(nullptr),
+        m_parent(nullptr), m_subwindows(), m_delegate_sp(),
+        m_curr_active_window_idx(UINT32_MAX),
+        m_prev_active_window_idx(UINT32_MAX), m_delete(false),
         m_needs_update(true), m_can_activate(true), m_is_subwin(false) {
     Reset(::newwin(bounds.size.height, bounds.size.width, bounds.origin.y,
                    bounds.origin.y));
   }
 
   virtual ~Window() {
     RemoveSubWindows();
     Reset();
public:
   }
 
 protected:
   std::vector<Row> m_rows;
   Row *m_selected_row = nullptr;
   uint32_t m_selected_row_idx = 0;
   uint32_t m_first_visible_row = 0;
   uint32_t m_num_rows = 0;
-  int m_min_x;
-  int m_min_y;
+  int m_min_x = 0;
+  int m_min_y = 0;
   int m_max_x = 0;
   int m_max_y = 0;
 
   static Format FormatForChar(int c) {
     switch (c) {
     case 'x':
       return eFormatHex;
     case 'X':

lldb/source/Expression/FunctionCaller.cpp

FunctionCaller::FunctionCaller(ExecutionContextScope &exe_scope,
                                const ValueList &arg_value_list,
                                const char *name)
     : Expression(exe_scope), m_execution_unit_sp(), m_parser(),
       m_jit_module_wp(), m_name(name ? name : "<unknown>"),
       m_function_ptr(nullptr), m_function_addr(functionAddress),
       m_function_return_type(return_type),
       m_wrapper_function_name("__lldb_caller_function"),
       m_wrapper_struct_name("__lldb_caller_struct"), m_wrapper_args_addrs(),
-      m_struct_valid(false), m_arg_values(arg_value_list), m_compiled(false),
+      m_struct_valid(false), m_struct_size(0), m_return_size(0),
+      m_return_offset(0), m_arg_values(arg_value_list), m_compiled(false),
       m_JITted(false) {
   m_jit_process_wp = lldb::ProcessWP(exe_scope.CalculateProcess());
   // Can't make a FunctionCaller without a process.
   assert(m_jit_process_wp.lock());
 }
 
 // Destructor
 FunctionCaller::~FunctionCaller() {

lldb/source/Expression/LLVMUserExpression.cpp

LLVMUserExpression::LLVMUserExpression(ExecutionContextScope &exe_scope,
                                        llvm::StringRef prefix,
                                        lldb::LanguageType language,
                                        ResultType desired_type,
                                        const EvaluateExpressionOptions &options)
     : UserExpression(exe_scope, expr, prefix, language, desired_type, options),
       m_stack_frame_bottom(LLDB_INVALID_ADDRESS),
       m_stack_frame_top(LLDB_INVALID_ADDRESS), m_allow_cxx(false),
       m_allow_objc(false), m_transformed_text(), m_execution_unit_sp(),
-      m_materializer_up(), m_jit_module_wp(), m_can_interpret(false),
-      m_materialized_address(LLDB_INVALID_ADDRESS) {}
+      m_materializer_up(), m_jit_module_wp(), m_target(nullptr),
+      m_can_interpret(false), m_materialized_address(LLDB_INVALID_ADDRESS) {}
 
 LLVMUserExpression::~LLVMUserExpression() {
   if (m_target) {
     lldb::ModuleSP jit_module_sp(m_jit_module_wp.lock());
     if (jit_module_sp)
       m_target->GetImages().Remove(jit_module_sp);
   }
 }

lldb/source/Host/common/MainLoop.cpp

for (const auto &signal : signals) {
     if (loop.m_terminate_request)
       return;
     g_signal_flags[signal] = 0;
     loop.ProcessSignal(signal);
   }
 }
 #endif
 
-MainLoop::MainLoop() {
+MainLoop::MainLoop() : m_terminate_request(false) {
 #if HAVE_SYS_EVENT_H
   m_kqueue = kqueue();
   assert(m_kqueue >= 0);
 #endif
 }
 MainLoop::~MainLoop() {
 #if HAVE_SYS_EVENT_H
   close(m_kqueue);

lldb/source/Interpreter/OptionGroupFormat.cpp

 };
 
 OptionGroupFormat::OptionGroupFormat(
     lldb::Format default_format, uint64_t default_byte_size,
     uint64_t default_count, OptionGroupFormatUsageTextVector usage_text_vector)
     : m_format(default_format, default_format),
       m_byte_size(default_byte_size, default_byte_size),
       m_count(default_count, default_count), m_prev_gdb_format('x'),
-      m_prev_gdb_size('w') {
+      m_prev_gdb_size('w'), m_has_gdb_format(false) {
   // Copy the default option definitions.
   std::copy(std::begin(g_default_option_definitions),
             std::end(g_default_option_definitions),
             std::begin(m_option_definitions));
 
   for (auto usage_text_tuple : usage_text_vector) {
     switch (std::get<0>(usage_text_tuple)) {
     case eArgTypeFormat:

lldb/source/Interpreter/OptionGroupVariable.cpp

 
 static Status ValidateSummaryString(const char *str, void *) {
   if (!str || !str[0])
     return Status("must specify a non-empty summary string");
   return Status();
 }
 
 OptionGroupVariable::OptionGroupVariable(bool show_frame_options)
-    : include_frame_options(show_frame_options), summary(ValidateNamedSummary),
-      summary_string(ValidateSummaryString) {}
+    : include_frame_options(show_frame_options), show_args(false),
+      show_recognized_args(false), show_locals(false), show_globals(false),
+      use_regex(false), show_scope(false), show_decl(false),
+      summary(ValidateNamedSummary), summary_string(ValidateSummaryString) {}
 
 Status
 OptionGroupVariable::SetOptionValue(uint32_t option_idx,
                                     llvm::StringRef option_arg,
                                     ExecutionContext *execution_context) {
   Status error;
   if (!include_frame_options)
     option_idx += 3;