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

[fixathon]

Summary

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

1476275, 1274012, 1455035, 1364789, 1454282
1467483, 1406152, 1406255, 1454837, 1454416
1467446, 1462022, 1461909, 1420566, 1327228
1367767, 1431254, 1467299, 1312678, 1431780
1454731, 1490403

[fixathon]

Reopen to fix up a couple of typomatic bugs

[shafik]

I believe this broke the lldb build bot: https://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/45608/console

[fixathon]

Fix the build

lldb/source/Plugins/ObjectFile/Minidump/MinidumpFileBuilder.cpp

 llvm::support::ulittle64_t read_register_u64(RegisterContext *reg_ctx,
                                              const std::string &reg_name) {
   return static_cast<llvm::support::ulittle64_t>(
       read_register_u64_raw(reg_ctx, reg_name));
 }
 
 lldb_private::minidump::MinidumpContext_x86_64
 GetThreadContext_64(RegisterContext *reg_ctx) {
-  lldb_private::minidump::MinidumpContext_x86_64 thread_context;
+  lldb_private::minidump::MinidumpContext_x86_64 thread_context = {};
   thread_context.p1_home = {};
   thread_context.context_flags = static_cast<uint32_t>(
       lldb_private::minidump::MinidumpContext_x86_64_Flags::x86_64_Flag |
       lldb_private::minidump::MinidumpContext_x86_64_Flags::Control |
       lldb_private::minidump::MinidumpContext_x86_64_Flags::Segments |
       lldb_private::minidump::MinidumpContext_x86_64_Flags::Integer);
   thread_context.rax = read_register_u64(reg_ctx, "rax");
   thread_context.rbx = read_register_u64(reg_ctx, "rbx");
Status MinidumpFileBuilder::AddException(const lldb::ProcessSP &process_sp) {
   thread_context_memory_locator.DataSize =
       static_cast<llvm::support::ulittle32_t>(sizeof(thread_context));
   thread_context_memory_locator.RVA = static_cast<llvm::support::ulittle32_t>(
       size_before + minidump_exception_size + helper_data.GetByteSize());
 
   helper_data.AppendData(
       &thread_context, sizeof(lldb_private::minidump::MinidumpContext_x86_64));
 
-  Exception exp_record;
+  Exception exp_record = {};
   exp_record.ExceptionCode =
       static_cast<llvm::support::ulittle32_t>(stop_info_sp->GetValue());
   exp_record.ExceptionFlags = static_cast<llvm::support::ulittle32_t>(0);
   exp_record.ExceptionRecord = static_cast<llvm::support::ulittle64_t>(0);
   exp_record.ExceptionAddress = read_register_u64(reg_ctx, "rip");
   exp_record.NumberParameters = static_cast<llvm::support::ulittle32_t>(0);
   exp_record.UnusedAlignment = static_cast<llvm::support::ulittle32_t>(0);
   // exp_record.ExceptionInformation;

lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp

::pid_t pid = ProcessLauncherPosixFork()
                     .GetProcessId();
   LLDB_LOG(log, "pid = {0:x}", pid);
   if (status.Fail()) {
     LLDB_LOG(log, "failed to launch process: {0}", status);
     return status.ToError();
   }
 
   // Wait for the child process to trap on its call to execve.
-  int wstatus;
+  int wstatus = 0;
   ::pid_t wpid = llvm::sys::RetryAfterSignal(-1, ::waitpid, pid, &wstatus, 0);
   assert(wpid == pid);
   (void)wpid;
   if (!WIFSTOPPED(wstatus)) {
     LLDB_LOG(log, "Could not sync with inferior process: wstatus={1}",
              WaitStatus::Decode(wstatus));
     return llvm::make_error<StringError>("Could not sync with inferior process",
                                          llvm::inconvertibleErrorCode());

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

 
 static uint32_t g_exc_regnums[] = {exc_far, exc_esr, exc_exception};
 
 static size_t k_num_register_infos =
     llvm::array_lengthof(g_register_infos_arm64_le);
 
 RegisterContextDarwin_arm64::RegisterContextDarwin_arm64(
     Thread &thread, uint32_t concrete_frame_idx)
-    : RegisterContext(thread, concrete_frame_idx), gpr(), fpu(), exc() {
+    : RegisterContext(thread, concrete_frame_idx), gpr(), fpu(), exc(), dbg() {
   uint32_t i;
   for (i = 0; i < kNumErrors; i++) {
     gpr_errs[i] = -1;
     fpu_errs[i] = -1;
     exc_errs[i] = -1;
   }
 }
 

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

 #include <memory>
 
 using namespace lldb;
 using namespace lldb_private;
 
 ThreadMemory::ThreadMemory(Process &process, tid_t tid,
                            const ValueObjectSP &thread_info_valobj_sp)
     : Thread(process, tid), m_backing_thread_sp(),
-      m_thread_info_valobj_sp(thread_info_valobj_sp), m_name(), m_queue() {}
+      m_thread_info_valobj_sp(thread_info_valobj_sp), m_name(), m_queue(),
+      m_register_data_addr(LLDB_INVALID_ADDRESS) {}
 
 ThreadMemory::ThreadMemory(Process &process, lldb::tid_t tid,
                            llvm::StringRef name, llvm::StringRef queue,
                            lldb::addr_t register_data_addr)
     : Thread(process, tid), m_backing_thread_sp(), m_thread_info_valobj_sp(),
       m_name(std::string(name)), m_queue(std::string(queue)),
       m_register_data_addr(register_data_addr) {}
 

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

 ///
 llvm::Error ProcessElfCore::parseNetBSDNotes(llvm::ArrayRef<CoreNote> notes) {
   ThreadData thread_data;
   bool had_nt_regs = false;
 
   // To be extracted from struct netbsd_elfcore_procinfo
   // Used to sanity check of the LWPs of the process
   uint32_t nlwps = 0;
-  uint32_t signo;  // killing signal
-  uint32_t siglwp; // LWP target of killing signal
-  uint32_t pr_pid;
+  uint32_t signo = 0;  // killing signal
+  uint32_t siglwp = 0; // LWP target of killing signal
+  uint32_t pr_pid = 0;
 
   for (const auto &note : notes) {
     llvm::StringRef name = note.info.n_name;
 
     if (name == "NetBSD-CORE") {
       if (note.info.n_type == NETBSD::NT_PROCINFO) {
         llvm::Error error = ParseNetBSDProcInfo(note.data, nlwps, signo,
                                                 siglwp, pr_pid);
if (!passed)
           "Error parsing NetBSD core(5) notes: Signal passed to unknown LWP",
           llvm::inconvertibleErrorCode());
   }
 
   return llvm::Error::success();
 }
 
 llvm::Error ProcessElfCore::parseOpenBSDNotes(llvm::ArrayRef<CoreNote> notes) {
-  ThreadData thread_data;
+  ThreadData thread_data = {};
   for (const auto &note : notes) {
     // OpenBSD per-thread information is stored in notes named "OpenBSD@nnn" so
     // match on the initial part of the string.
     if (!llvm::StringRef(note.info.n_name).startswith("OpenBSD"))
       continue;
 
     switch (note.info.n_type) {
     case OPENBSD::NT_PROCINFO:

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

bool ProcessMinidump::CanDebug(lldb::TargetSP target_sp,
   return true;
 }
 
 ProcessMinidump::ProcessMinidump(lldb::TargetSP target_sp,
                                  lldb::ListenerSP listener_sp,
                                  const FileSpec &core_file,
                                  DataBufferSP core_data)
     : PostMortemProcess(target_sp, listener_sp), m_core_file(core_file),
-      m_core_data(std::move(core_data)), m_is_wow64(false) {}
+      m_core_data(std::move(core_data)), m_active_exception(nullptr),
+      m_is_wow64(false) {}
 
 ProcessMinidump::~ProcessMinidump() {
   Clear();
   // We need to call finalize on the process before destroying ourselves to
   // make sure all of the broadcaster cleanup goes as planned. If we destruct
   // this class, then Process::~Process() might have problems trying to fully
   // destroy the broadcaster.
   Finalize();

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

TypeIndex lldb_private::npdb::LookThroughModifierRecord(CVType modifier) {
   return mr.ModifiedType;
 }
 
 llvm::StringRef lldb_private::npdb::DropNameScope(llvm::StringRef name) {
   return MSVCUndecoratedNameParser::DropScope(name);
 }
 
 VariableInfo lldb_private::npdb::GetVariableNameInfo(CVSymbol sym) {
-  VariableInfo result;
+  VariableInfo result = {};
 
   if (sym.kind() == S_REGREL32) {
     RegRelativeSym reg(SymbolRecordKind::RegRelativeSym);
     cantFail(SymbolDeserializer::deserializeAs<RegRelativeSym>(sym, reg));
     result.type = reg.Type;
     result.name = reg.Name;
     return result;
   }

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

 // Returns either an array of introspection_dispatch_item_info_ref's for the
 // pending items on a queue or an array introspection_dispatch_item_info_ref's
 // and code addresses for the pending items on a queue.  The information about
 // each of these pending items then needs to be fetched individually by passing
 // the ref to libBacktraceRecording.
 
 SystemRuntimeMacOSX::PendingItemsForQueue
 SystemRuntimeMacOSX::GetPendingItemRefsForQueue(lldb::addr_t queue) {
-  PendingItemsForQueue pending_item_refs;
+  PendingItemsForQueue pending_item_refs = {};
   AppleGetPendingItemsHandler::GetPendingItemsReturnInfo pending_items_pointer;
   ThreadSP cur_thread_sp(
       m_process->GetThreadList().GetExpressionExecutionThread());
   if (cur_thread_sp) {
     Status error;
     pending_items_pointer = m_get_pending_items_handler.GetPendingItems(
         *cur_thread_sp.get(), queue, m_page_to_free, m_page_to_free_size,
         error);

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

bool x86AssemblyInspectionEngine::GetNonCallSiteUnwindPlanFromAssembly(
   // Once the prologue has completed we'll save a copy of the unwind
   // instructions If there is an epilogue in the middle of the function, after
   // that epilogue we'll reinstate the unwind setup -- we assume that some code
   // path jumps over the mid-function epilogue
 
   UnwindPlan::RowSP prologue_completed_row; // copy of prologue row of CFI
   int prologue_completed_sp_bytes_offset_from_cfa; // The sp value before the
                                                    // epilogue started executed
-  bool prologue_completed_is_aligned;
+  bool prologue_completed_is_aligned = false;
   std::vector<bool> prologue_completed_saved_registers;
 
   while (current_func_text_offset < size) {
     int stack_offset, insn_len;
     int machine_regno;   // register numbers masked directly out of instructions
     uint32_t lldb_regno; // register numbers in lldb's eRegisterKindLLDB
                          // numbering scheme
 

lldb/source/Symbol/Type.cpp

if (byte_size) {
     m_byte_size_has_value = true;
   } else {
     m_byte_size = 0;
     m_byte_size_has_value = false;
   }
 }
 
 Type::Type()
-    : std::enable_shared_from_this<Type>(), UserID(0),
-      m_name("<INVALID TYPE>") {
+    : std::enable_shared_from_this<Type>(), UserID(0), m_name("<INVALID TYPE>"),
+      m_payload(0) {
   m_byte_size = 0;
   m_byte_size_has_value = false;
 }
 
 void Type::GetDescription(Stream *s, lldb::DescriptionLevel level,
                           bool show_name, ExecutionContextScope *exe_scope) {
   *s << "id = " << (const UserID &)*this;
 

lldb/source/Target/Process.cpp

: ProcessProperties(this),
       m_notifications(), m_image_tokens(), m_listener_sp(listener_sp),
       m_breakpoint_site_list(), m_dynamic_checkers_up(),
       m_unix_signals_sp(unix_signals_sp), m_abi_sp(), m_process_input_reader(),
       m_stdio_communication("process.stdio"), m_stdio_communication_mutex(),
       m_stdin_forward(false), m_stdout_data(), m_stderr_data(),
       m_profile_data_comm_mutex(), m_profile_data(), m_iohandler_sync(0),
       m_memory_cache(*this), m_allocated_memory_cache(*this),
       m_should_detach(false), m_next_event_action_up(), m_public_run_lock(),
-      m_private_run_lock(), m_finalizing(false),
+      m_private_run_lock(), m_currently_handling_do_on_removals(false),
+      m_resume_requested(false), m_finalizing(false),
       m_clear_thread_plans_on_stop(false), m_force_next_event_delivery(false),
       m_last_broadcast_state(eStateInvalid), m_destroy_in_process(false),
       m_can_interpret_function_calls(false), m_run_thread_plan_lock(),
       m_can_jit(eCanJITDontKnow) {
   CheckInWithManager();
 
   Log *log = GetLog(LLDBLog::Object);
   LLDB_LOGF(log, "%p Process::Process()", static_cast<void *>(this));
if (state == eStateExited) {
     // We exited while trying to launch somehow.  Don't call DidLaunch
     // as that's not likely to work, and return an invalid pid.
     HandlePrivateEvent(event_sp);
     return Status();
   }
 
   if (state == eStateStopped || state == eStateCrashed) {
     DidLaunch();
-    
-    // Now that we know the process type, update its signal responses from the 
+    // Now that we know the process type, update its signal responses from the
     // ones stored in the Target:
     if (m_unix_signals_sp) {
       StreamSP warning_strm = GetTarget().GetDebugger().GetAsyncErrorStream();
       GetTarget().UpdateSignalsFromDummy(m_unix_signals_sp, warning_strm);
     }
 
     DynamicLoader *dyld = GetDynamicLoader();
     if (dyld)
if (target_arch.IsValid() &&
         LLDB_LOGF(log,
                   "Process::%s switching architecture to %s based on info "
                   "the platform retrieved for pid %" PRIu64,
                   __FUNCTION__, process_arch.GetTriple().getTriple().c_str(),
                   GetID());
       }
     }
   }
-  // Now that we know the process type, update its signal responses from the 
+  // Now that we know the process type, update its signal responses from the
   // ones stored in the Target:
   if (m_unix_signals_sp) {
     StreamSP warning_strm = GetTarget().GetDebugger().GetAsyncErrorStream();
     GetTarget().UpdateSignalsFromDummy(m_unix_signals_sp, warning_strm);
   }
 
   // We have completed the attach, now it is time to find the dynamic loader
   // plug-in
if (!m_already_reset && m_thread_plan_sp) {
       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 = false;
-  bool m_private;
-  bool m_is_controlling;
-  bool m_okay_to_discard;
+  bool m_private = false;
+  bool m_is_controlling = false;
+  bool m_okay_to_discard = false;
 };
 } // anonymous namespace
 
 static microseconds
 GetOneThreadExpressionTimeout(const EvaluateExpressionOptions &options) {
   const milliseconds default_one_thread_timeout(250);
 
   // If the overall wait is forever, then we don't need to worry about it.

lldb/source/Target/RegisterContextUnwind.cpp

if (IsFrameZero()) {
                    regnum.GetAsKind(eRegisterKindLLDB),
                    unwindplan_name.c_str());
     }
     return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
   }
 
   // unwindplan_regloc has valid contents about where to retrieve the register
   if (unwindplan_regloc.IsUnspecified()) {
-    lldb_private::UnwindLLDB::RegisterLocation new_regloc;
+    lldb_private::UnwindLLDB::RegisterLocation new_regloc = {};
     new_regloc.type = UnwindLLDB::RegisterLocation::eRegisterNotSaved;
     m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = new_regloc;
     UnwindLogMsg("save location for %s (%d) is unspecified, continue searching",
                  regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
     return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
   }
 
   if (unwindplan_regloc.IsUndefined()) {
bool RegisterContextUnwind::TryFallbackUnwindPlan() {
   // unwind plan, re-fetch the caller's pc value and CFA value. If they're the
   // same, then the fallback unwind plan provides no benefit.
 
   RegisterNumber pc_regnum(m_thread, eRegisterKindGeneric,
                            LLDB_REGNUM_GENERIC_PC);
 
   addr_t old_caller_pc_value = LLDB_INVALID_ADDRESS;
   addr_t new_caller_pc_value = LLDB_INVALID_ADDRESS;
-  UnwindLLDB::RegisterLocation regloc;
+  UnwindLLDB::RegisterLocation regloc = {};
   if (SavedLocationForRegister(pc_regnum.GetAsKind(eRegisterKindLLDB),
                                regloc) ==
       UnwindLLDB::RegisterSearchResult::eRegisterFound) {
     const RegisterInfo *reg_info =
         GetRegisterInfoAtIndex(pc_regnum.GetAsKind(eRegisterKindLLDB));
     if (reg_info) {
       RegisterValue reg_value;
       if (ReadRegisterValueFromRegisterLocation(regloc, reg_info, reg_value)) {

lldb/source/Target/ThreadPlanCallFunction.cpp

ThreadPlanCallFunction::ThreadPlanCallFunction(
     llvm::ArrayRef<addr_t> args, const EvaluateExpressionOptions &options)
     : ThreadPlan(ThreadPlan::eKindCallFunction, "Call function plan", thread,
                  eVoteNoOpinion, eVoteNoOpinion),
       m_valid(false), m_stop_other_threads(options.GetStopOthers()),
       m_unwind_on_error(options.DoesUnwindOnError()),
       m_ignore_breakpoints(options.DoesIgnoreBreakpoints()),
       m_debug_execution(options.GetDebug()),
       m_trap_exceptions(options.GetTrapExceptions()), m_function_addr(function),
-      m_function_sp(0), m_takedown_done(false),
+      m_start_addr(), m_function_sp(0), m_subplan_sp(),
+      m_cxx_language_runtime(nullptr), m_objc_language_runtime(nullptr),
+      m_stored_thread_state(), m_real_stop_info_sp(), m_constructor_errors(),
+      m_return_valobj_sp(), m_takedown_done(false),
       m_should_clear_objc_exception_bp(false),
       m_should_clear_cxx_exception_bp(false),
       m_stop_address(LLDB_INVALID_ADDRESS), m_return_type(return_type) {
   lldb::addr_t start_load_addr = LLDB_INVALID_ADDRESS;
   lldb::addr_t function_load_addr = LLDB_INVALID_ADDRESS;
   ABI *abi = nullptr;
 
   if (!ConstructorSetup(thread, abi, start_load_addr, function_load_addr))
ThreadPlanCallFunction::ThreadPlanCallFunction(
     const EvaluateExpressionOptions &options)
     : ThreadPlan(ThreadPlan::eKindCallFunction, "Call function plan", thread,
                  eVoteNoOpinion, eVoteNoOpinion),
       m_valid(false), m_stop_other_threads(options.GetStopOthers()),
       m_unwind_on_error(options.DoesUnwindOnError()),
       m_ignore_breakpoints(options.DoesIgnoreBreakpoints()),
       m_debug_execution(options.GetDebug()),
       m_trap_exceptions(options.GetTrapExceptions()), m_function_addr(function),
-      m_function_sp(0), m_takedown_done(false),
+      m_start_addr(), m_function_sp(0), m_subplan_sp(),
+      m_cxx_language_runtime(nullptr), m_objc_language_runtime(nullptr),
+      m_stored_thread_state(), m_real_stop_info_sp(), m_constructor_errors(),
+      m_return_valobj_sp(), m_takedown_done(false),
       m_should_clear_objc_exception_bp(false),
       m_should_clear_cxx_exception_bp(false),
       m_stop_address(LLDB_INVALID_ADDRESS), m_return_type(CompilerType()) {}
 
 ThreadPlanCallFunction::~ThreadPlanCallFunction() {
   DoTakedown(PlanSucceeded());
 }
 

lldb/source/Target/ThreadPlanTracer.cpp

 
 using namespace lldb;
 using namespace lldb_private;
 
 #pragma mark ThreadPlanTracer
 
 ThreadPlanTracer::ThreadPlanTracer(Thread &thread, lldb::StreamSP &stream_sp)
     : m_process(*thread.GetProcess().get()), m_tid(thread.GetID()),
-      m_enabled(false), m_stream_sp(stream_sp) {}
+      m_enabled(false), m_stream_sp(stream_sp), m_thread(nullptr) {}
 
 ThreadPlanTracer::ThreadPlanTracer(Thread &thread)
     : m_process(*thread.GetProcess().get()), m_tid(thread.GetID()),
-      m_enabled(false), m_stream_sp() {}
+      m_enabled(false), m_stream_sp(), m_thread(nullptr) {}
 
 Stream *ThreadPlanTracer::GetLogStream() {
   if (m_stream_sp)
     return m_stream_sp.get();
   else {
     TargetSP target_sp(GetThread().CalculateTarget());
     if (target_sp)
       return &(target_sp->GetDebugger().GetOutputStream());

lldb/source/Target/TraceDumper.cpp

TraceDumper::TraceDumper(lldb::TraceCursorUP &&cursor_up, Stream &s,
   m_cursor_up->SetForwards(m_options.forwards);
   if (m_options.skip) {
     m_cursor_up->Seek((m_options.forwards ? 1 : -1) * *m_options.skip,
                       TraceCursor::SeekType::Current);
   }
 }
 
 TraceDumper::TraceItem TraceDumper::CreatRawTraceItem() {
-  TraceItem item;
+  TraceItem item = {};
   item.id = m_cursor_up->GetId();
 
   if (m_options.show_tsc)
     item.tsc = m_cursor_up->GetCounter(lldb::eTraceCounterTSC);
   return item;
 }
 
 /// Find the symbol context for the given address reusing the previous