[LLDB][NFC][Reliability] Fix uninitialized variables from Coverity scan

[fixathon]

Summary

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

1094796 1095721 1095728 1095737 1095741
1095756 1095779 1095789 1095805 1214552
1229457 1232475 1274006 1274010 1293427
1364800 1364802 1364804 1364812 1364816
1374902 1374909 1384975 1399312 1420451
1431704 1454230 1454554 1454615 1454579
1454594 1454832 1457759 1458696 1461909
1467658 1487814 1487830 1487845

[jingham]

Thanks for finding these uninitialized variables. That's a valuable exercise. Couple of comments;

Most of the time you set lldb::addr_t's to 0, they probably should have been set to LLDB_INVALID_ADDRESS. Also as I said above, any ivars of CommandObject subclasses actually get initialized before use by the OptionParsingStarting method, so the initialized values don't actually matter, but to avoid confusion if set they should be the same as the values given in that method. I found one that was different but didn't do an exhaustive check.

You are also inconsistent in setting int variables either to {} or 0. I think you set the ones you could tell were int's to 0 and the ones you couldn't tell off the bat to {}? But for all the ones that are typedef's to some kind of scalar, and explicit 0 (or LLDB_INVALID_ADDRESS in a bunch of places) would be easier to read.

lldb/source/Commands/CommandObjectTarget.cpp

4646

Because of the way CommandObjects work, the constructed values of its ivars are never used. You have to call OptionParsingStarting before doing any work with the object, so the values set in that function are the real ones. There's no actual point in initializing these variables, but it mostly doesn't hurt except if you set them to different values from the ones in OptionParsingStarting, in which case they could cause confusion in people reading the code. Here you've set m_thread_index to 0 but the correct starting value is actually UINT32_MAX as you can see from the OptionParsingStarting just above.

Can you go through all of the CommandObject subclass ivars that you've given values to and make sure they are the ones in the class's OptionParsingStarting? Thanks.

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

140

Invalid addresses in lldb are indicated by the value LLDB_INVALID_ADDRESS. Not sure what {} does for an int value, but probably not that.

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

79

Again, this should be LLDB_INVALID_ADDRESS

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

163 ↗

(On Diff #445854)

The other ones here are also all intialized to LLDB_INVALID_ADDRESS in the constructor, so this one should be too. I also find it confusing to have some variables initialized in the class definition and some in the constructor definition. Since all the other ivars are initialized in the constructor in the .cpp file, it would be better to either switch all the ivars over to in-class initialization or to add the missing ones to the constructor. Either way is fine, but the mixed method seems confusing.

lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.h

274–275

These are all typedef to int types. Putting {} for the initializer seems overly mysterious. And the address should be LLDB_INVALID_ADDRESS anyway.

[jingham]

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

140

Zero, which is in this case wrong.

[clayborg]

lldb/include/lldb/Core/EmulateInstruction.h

182

This doesn't fall into the un initialized variable case, I would revert this. You can always submit a new patch if you want to fix this.

lldb/source/Commands/CommandObjectTarget.cpp

4646

yeah, I would like to get everything initialized if we can to limit our static analysis warnings.

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

412

set to nullptr instead of empty string? Check the code to see if they check this variable for NULL and use nullptr if they do.

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

140

yes, for lldb::addr_t the LLDB_INVALID_ADDRESS is the value we need to use

lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp

1305–1306

There are more members than just "cmdsize" that should be initialized to zero. Hopefully adding "= {};" will init everything to zero and avoid us having to say "= {0,0};"

5424–5425

5491–5492

Ditto, and please apply to all other places where you only initialize "cmdsize" to zero. llvm::MachO::load_command only has two entries, but the other definitions below have more members.

lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.h

274–275

I would set any "lldb::offset_t" values to zero instead of {} for clarity

275

LLDB_INVALID_ADDRESS

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

416–417

Looking at the header file, we define our own copy of these types, so we should add a bunch of "= 0;" to each member just like coff_opt_header_t does.

Then we can remove this memset stuff.

416–417

425–426

Remove these memsets after we fix the constructors for all types we define in the ObjectFilePECOFF.h header file.

425–426

[fixathon]

Update code based on revew comments

[clayborg]

You missed a few comments. It would also be nice to remove the memset from the ObjectFilePECOFF by adding "= 0;" to all of the struct definitions in ObjectFilePECOFF.h that would be great as well.

lldb/include/lldb/Core/EmulateInstruction.h

182

I would revert this change as it isn't related to uninitialized vars.

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

416–417

m_image_base should be set to LLDB_INVALID_ADDRESS, I had a suggested code edit, but not sure if you saw it above.

425–426

m_image_base should be set to LLDB_INVALID_ADDRESS, I had a suggested code edit, but not sure if you saw it above.

[fixathon]

Update the init value in ObjectFilePECOFF.cpp

[fixathon]

Adding review comments

lldb/include/lldb/Core/EmulateInstruction.h

182

This is fixing Coverity scan warning 1094796 "Uninitialized scalar field".
"Non-static class member InfoType is not initialized in this constructor nor in any functions that it calls"

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

412

An empty string literal is a reasonable and safe init value for what is semantically a string (C-string). The warning related to this fix is triggered by line 403:
Written += From.size();
I am not sure that nullptr += (llvm::StringRef type) will pay nice, but I am not opposed to changing it to nullptr if you feel strongly about it.

[clayborg]

lldb/include/lldb/Core/EmulateInstruction.h

182

Gotcha, ok to leave this in then!

[jingham]

lldb/source/Commands/CommandObjectTarget.cpp

4646

If we just called OptionParsingStarting in the constructor would your static analysis tools be smart enough to see that they were initialized? That's the initialization that actually matters so it would be better not to have to write the values in two places (one of which looks like it matters but actually doesn't...)

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

284

If you use

llvm-project/clang/tools/clang-format/git-clang-format

to clang-format your changes, then it will only apply to your diff, and you won't pick up spurious changes like this that make diffs harder to read.

[fixathon]

Respond to comments

lldb/source/Commands/CommandObjectTarget.cpp

4646

I believe so. Would you like to make that change then?

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

284

Thank you for that. Should I attempt to undo the spurious changes for this commit or just keep it in mind for the future?

[fixathon]

Addressing comments

Updating D130098: [LLDB][NFC][Reliability] Fix uninitialized variables from Coverity scan # # Enter a

brief description of the changes included in this update. # The first line is used as subject, next lines
as comment. # # If you intended to create a new revision, use: # $ arc diff --create

[fixathon]

Replied to comments

lldb/source/Commands/CommandObjectTarget.cpp

4646

On a second thought, OptionParsingStarting() is a virtual function override. Calling virtual functions from constructor is bad practice.

[clayborg]

Looks good to me. Jim, anything you still want fixed?

[JDevlieghere]

The changes themselves look good, but please undo the formatting/unrelated changes before landing this. When I've been in a situation like this where I accidentally formatted unrelated things, I usually unstage my changes and use git add -p to interactively pick the chunks I want to stage.

There's a script called git-clang-format that allows you to format only the lines that have been changed: https://clang.llvm.org/docs/ClangFormat.html#git-integration. Once you've added it to your PATH, you can run git clang-format after staging your changes (but before committing).

lldb/source/Commands/CommandObjectTarget.cpp

4640

LLDB_INVALID_LINE_NUMBER

[fixathon]

Remove formatting for unrelated lines

[fixathon]

Address the comments: revert the formatting for lines unrelated to my changes

lldb/include/lldb/Core/EmulateInstruction.h

enum InfoType {
     eInfoTypeRegister,
     eInfoTypeImmediate,
     eInfoTypeImmediateSigned,
     eInfoTypeAddress,
     eInfoTypeISAAndImmediate,
     eInfoTypeISAAndImmediateSigned,
     eInfoTypeISA,
     eInfoTypeNoArgs
-  } InfoType;
+  };
 
   struct Context {
     ContextType type = eContextInvalid;
     enum InfoType info_type = eInfoTypeNoArgs;
     union {
       struct RegisterPlusOffset {
         RegisterInfo reg;      // base register
         int64_t signed_offset; // signed offset added to base register

lldb/include/lldb/DataFormatters/TypeCategory.h

private:
   IFormatChangeListener *m_change_listener;
 
   std::recursive_mutex m_mutex;
 
   ConstString m_name;
 
   std::vector<lldb::LanguageType> m_languages;
 
-  uint32_t m_enabled_position;
+  uint32_t m_enabled_position = 0;
 
   void Enable(bool value, uint32_t position);
 
   void Disable() { Enable(false, UINT32_MAX); }
 
   bool IsApplicable(lldb::LanguageType lang);
 
   uint32_t GetLastEnabledPosition() { return m_enabled_position; }

lldb/include/lldb/DataFormatters/TypeSynthetic.h

public:
   virtual SyntheticChildrenFrontEnd::AutoPointer
   GetFrontEnd(ValueObject &backend) = 0;
 
   typedef std::shared_ptr<SyntheticChildren> SharedPointer;
 
   uint32_t &GetRevision() { return m_my_revision; }
 
 protected:
-  uint32_t m_my_revision;
+  uint32_t m_my_revision = 0;
   Flags m_flags;
 
 private:
   SyntheticChildren(const SyntheticChildren &) = delete;
   const SyntheticChildren &operator=(const SyntheticChildren &) = delete;
 };
 
 class TypeFilterImpl : public SyntheticChildren {

lldb/source/Commands/CommandObjectMemory.cpp

bool AnyOptionWasSet() const {
     return m_num_per_line.OptionWasSet() || m_output_as_binary ||
            m_view_as_type.OptionWasSet() || m_offset.OptionWasSet() ||
            m_language_for_type.OptionWasSet();
   }
 
   OptionValueUInt64 m_num_per_line;
   bool m_output_as_binary = false;
   OptionValueString m_view_as_type;
-  bool m_force;
+  bool m_force = false;
   OptionValueUInt64 m_offset;
   OptionValueLanguage m_language_for_type;
 };
 
 // Read memory from the inferior process
 class CommandObjectMemoryRead : public CommandObjectParsed {
 public:
   CommandObjectMemoryRead(CommandInterpreter &interpreter)

lldb/source/Commands/CommandObjectTarget.cpp

Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
       }
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_class_name.clear();
       m_function_name.clear();
       m_line_start = 0;
-      m_line_end = UINT_MAX;
+      m_line_end = LLDB_INVALID_LINE_NUMBER;
       m_file_name.clear();
       m_module_name.clear();
       m_func_name_type_mask = eFunctionNameTypeAuto;
       m_thread_id = LLDB_INVALID_THREAD_ID;
       m_thread_index = UINT32_MAX;
       m_thread_name.clear();
       m_queue_name.clear();
 
       m_no_inlines = false;
       m_sym_ctx_specified = false;
       m_thread_specified = false;
 
       m_use_one_liner = false;
       m_one_liner.clear();
       m_auto_continue = false;
     }
 
     std::string m_class_name;
     std::string m_function_name;
     uint32_t m_line_start = 0;
-    uint32_t m_line_end;
+    uint32_t m_line_end = LLDB_INVALID_LINE_NUMBER;
     std::string m_file_name;
     std::string m_module_name;
     uint32_t m_func_name_type_mask =
         eFunctionNameTypeAuto; // A pick from lldb::FunctionNameType.
-    lldb::tid_t m_thread_id;
-    uint32_t m_thread_index;
+    lldb::tid_t m_thread_id = LLDB_INVALID_THREAD_ID;
+    uint32_t m_thread_index = UINT32_MAX;
     std::string m_thread_name;
     std::string m_queue_name;
     bool m_sym_ctx_specified = false;
-    bool m_no_inlines;
+    bool m_no_inlines = false;
     bool m_thread_specified = false;
     // Instance variables to hold the values for one_liner options.
     bool m_use_one_liner = false;
     std::vector<std::string> m_one_liner;
 
-    bool m_auto_continue;
+    bool m_auto_continue = false;
   };
 
   CommandObjectTargetStopHookAdd(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "target stop-hook add",
                             "Add a hook to be executed when the target stops."
                             "The hook can either be a list of commands or an "
                             "appropriately defined Python class.  You can also "
                             "add filters so the hook only runs a certain stop "

lldb/source/Commands/CommandObjectThread.cpp

void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_stop_others = false;
       m_until_addrs.clear();
     }
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_thread_until_options);
     }
 
-    uint32_t m_step_thread_idx;
-    bool m_stop_others;
+    uint32_t m_step_thread_idx = LLDB_INVALID_THREAD_ID;
+    bool m_stop_others = false;
     std::vector<lldb::addr_t> m_until_addrs;
 
     // Instance variables to hold the values for command options.
   };
 
   CommandObjectThreadUntil(CommandInterpreter &interpreter)
       : CommandObjectParsed(
             interpreter, "thread until",

lldb/source/Commands/CommandObjectType.cpp

public:
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_type_summary_add_options);
     }
 
     // Instance variables to hold the values for command options.
 
     TypeSummaryImpl::Flags m_flags;
-    bool m_regex;
+    bool m_regex = false;
     std::string m_format_string;
     ConstString m_name;
     std::string m_python_script;
     std::string m_python_function;
-    bool m_is_add_script;
+    bool m_is_add_script = false;
     std::string m_category;
   };
 
   CommandOptions m_options;
 
   Options *GetOptions() override { return &m_options; }
 
   bool Execute_ScriptSummary(Args &command, CommandReturnObject &result);

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

static addr_t ResolveRendezvousAddress(Process *process) {
 
   return info_addr;
 }
 
 HexagonDYLDRendezvous::HexagonDYLDRendezvous(Process *process)
     : m_process(process), m_rendezvous_addr(LLDB_INVALID_ADDRESS), m_current(),
       m_previous(), m_soentries(), m_added_soentries(), m_removed_soentries() {
   m_thread_info.valid = false;
+  m_thread_info.dtv_offset = 0;
+  m_thread_info.dtv_slot_size = 0;
+  m_thread_info.modid_offset = 0;
+  m_thread_info.tls_offset = 0;
 
   // Cache a copy of the executable path
   if (m_process) {
     Module *exe_mod = m_process->GetTarget().GetExecutableModulePointer();
     if (exe_mod)
       exe_mod->GetFileSpec().GetPath(m_exe_path, PATH_MAX);
   }
 }

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

public:
   llvm::StringRef GetPluginName() override { return GetPluginNameStatic(); }
 
   bool SetTargetTriple(const ArchSpec &arch) override;
 
   enum Mode { eModeInvalid = -1, eModeARM, eModeThumb };
 
   EmulateInstructionARM(const ArchSpec &arch)
       : EmulateInstruction(arch), m_arm_isa(0), m_opcode_mode(eModeInvalid),
-        m_opcode_cpsr(0), m_it_session(), m_ignore_conditions(false) {
+        m_opcode_cpsr(0), m_new_inst_cpsr(0), m_it_session(),
+        m_ignore_conditions(false) {
     SetArchitecture(arch);
   }
 
   //    EmulateInstructionARM (const ArchSpec &arch,
   //                           bool ignore_conditions,
   //                           void *baton,
   //                           ReadMemory read_mem_callback,
   //                           WriteMemory write_mem_callback,

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

if (m_parse_error)
     return m_full.GetStringRef().contains(path);
     
   llvm::StringRef identifier;
   llvm::StringRef context;
   std::string path_str = path.str();
   bool success 
       = CPlusPlusLanguage::ExtractContextAndIdentifier(path_str.c_str(),
                                                        context,
                                                        identifier);
   if (!success)
     return m_full.GetStringRef().contains(path);
 
   if (identifier != GetBasename())
     return false;
   // Incoming path only had an identifier, so we match.
   if (context.empty())
     return true;
void trySubstitute(llvm::StringRef From, llvm::StringRef To) {
     Result += To;
     Written += From.size();
     Substituted = true;
   }
 
 private:
   /// Input character until which we have constructed the respective output
   /// already.
-  const char *Written;
+  const char *Written = "";
 
   llvm::SmallString<128> Result;
 
   /// Whether we have performed any substitutions.
-  bool Substituted;
+  bool Substituted = false;
 
   const char *currentParserPos() const { return this->First; }
 
   void appendUnchangedInput() {
     Result +=
         llvm::StringRef(Written, std::distance(Written, currentParserPos()));
     Written = currentParserPos();
   }

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

public:
   }
   bool MightHaveChildren() override { return true; }
   bool Update() override;
 
 protected:
   AbstractListFrontEnd(ValueObject &valobj)
       : SyntheticChildrenFrontEnd(valobj) {}
 
-  size_t m_count;
-  ValueObject *m_head;
+  size_t m_count = 0;
+  ValueObject *m_head = nullptr;
 
   static constexpr bool g_use_loop_detect = true;
-  size_t m_loop_detected; // The number of elements that have had loop detection
-                          // run over them.
+  size_t m_loop_detected = 0; // The number of elements that have had loop
+                              // detection run over them.
   ListEntry m_slow_runner; // Used for loop detection
   ListEntry m_fast_runner; // Used for loop detection
 
-  size_t m_list_capping_size;
+  size_t m_list_capping_size = 0;
   CompilerType m_element_type;
   std::map<size_t, ListIterator> m_iterators;
 
   bool HasLoop(size_t count);
   ValueObjectSP GetItem(size_t idx);
 };
 
 class ForwardListFrontEnd : public AbstractListFrontEnd {

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

bool is_left_child(const MapEntry &x) {
     if (x.null())
       return false;
     MapEntry rhs(x.parent());
     rhs.SetEntry(rhs.left());
     return x.value() == rhs.value();
   }
 
   MapEntry m_entry;
-  size_t m_max_depth;
-  bool m_error;
+  size_t m_max_depth = 0;
+  bool m_error = false;
 };
 
 namespace lldb_private {
 namespace formatters {
 class LibcxxStdMapSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
 public:
   LibcxxStdMapSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);
 

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

private:
   uint32_t m_ptr_size = UINT32_MAX;
   lldb::ByteOrder m_byte_order = lldb::eByteOrderInvalid;
   Address m_address = LLDB_INVALID_ADDRESS;
   std::unique_ptr<__CFBasicHash<uint32_t>> m_ht_32 = nullptr;
   std::unique_ptr<__CFBasicHash<uint64_t>> m_ht_64 = nullptr;
   ExecutionContextRef m_exe_ctx_ref;
   bool m_mutable = true;
   bool m_multi = false;
-  HashType m_type;
+  HashType m_type = HashType::set;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_LANGUAGE_OBJC_CFBASICHASH_H

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

struct DictionaryItemDescriptor {
     lldb::ValueObjectSP valobj_sp;
   };
 
   ExecutionContextRef m_exe_ctx_ref;
   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;
+  lldb::addr_t m_data_ptr = LLDB_INVALID_ADDRESS;
   CompilerType m_pair_type;
   std::vector<DictionaryItemDescriptor> m_children;
 };
 
 class NSConstantDictionarySyntheticFrontEnd : public SyntheticChildrenFrontEnd {
 public:
   NSConstantDictionarySyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);
 

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

 
 private:
   // the child here can be "real" (i.e. an actual child of the root) or
   // synthetized from raw memory if the former, I need to store a plain pointer
   // to it - or else a loop of references will cause this entire hierarchy of
   // values to leak if the latter, then I need to store a SharedPointer to it -
   // so that it only goes away when everyone else in the cluster goes away oh
   // joy!
-  ValueObject *m_child_ptr;
+  ValueObject *m_child_ptr = nullptr;
   ValueObjectSP m_child_sp;
 };
 
 SyntheticChildrenFrontEnd *
 lldb_private::formatters::NSErrorSyntheticFrontEndCreator(
     CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) {
   lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());
   if (!process_sp)

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

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

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

public:
   }
 
   virtual uint64_t GetInfoBits() { return (IsValid() ? m_info_bits : 0); }
 
   virtual uint64_t GetPayload() { return (IsValid() ? m_payload : 0); }
 
 private:
   ConstString m_name;
-  uint8_t m_pointer_size;
-  bool m_valid;
-  uint64_t m_info_bits;
-  uint64_t m_value_bits;
-  int64_t m_value_bits_signed;
-  uint64_t m_payload;
+  uint8_t m_pointer_size = 0;
+  bool m_valid = false;
+  uint64_t m_info_bits = 0;
+  uint64_t m_value_bits = 0;
+  int64_t m_value_bits_signed = 0;
+  uint64_t m_payload = 0;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_LANGUAGERUNTIME_OBJC_APPLEOBJCRUNTIME_APPLEOBJCCLASSDESCRIPTORV2_H

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

const char *AppleObjCTrampolineHandler::g_opt_dispatch_names[] = {
     "objc_opt_self",
 };
 
 AppleObjCTrampolineHandler::AppleObjCTrampolineHandler(
     const ProcessSP &process_sp, const ModuleSP &objc_module_sp)
     : m_process_wp(), m_objc_module_sp(objc_module_sp),
       m_impl_fn_addr(LLDB_INVALID_ADDRESS),
       m_impl_stret_fn_addr(LLDB_INVALID_ADDRESS),
-      m_msg_forward_addr(LLDB_INVALID_ADDRESS) {
+      m_msg_forward_addr(LLDB_INVALID_ADDRESS),
+      m_msg_forward_stret_addr(LLDB_INVALID_ADDRESS) {
   if (process_sp)
     m_process_wp = process_sp;
   // Look up the known resolution functions:
 
   ConstString get_impl_name("class_getMethodImplementation");
   ConstString get_impl_stret_name("class_getMethodImplementation_stret");
   ConstString msg_forward_name("_objc_msgForward");
   ConstString msg_forward_stret_name("_objc_msgForward_stret");
AppleObjCTrampolineHandler::FindDispatchFunction(lldb::addr_t addr) {
   MsgsendMap::iterator pos;
   pos = m_msgSend_map.find(addr);
   if (pos != m_msgSend_map.end()) {
     return &g_dispatch_functions[(*pos).second];
   }
   return nullptr;
 }
 
-void
-AppleObjCTrampolineHandler::ForEachDispatchFunction(
-    std::function<void(lldb::addr_t, 
-                       const DispatchFunction &)> callback) {
+void AppleObjCTrampolineHandler::ForEachDispatchFunction(
+    std::function<void(lldb::addr_t, const DispatchFunction &)> callback) {
   for (auto elem : m_msgSend_map) {
     callback(elem.first, g_dispatch_functions[elem.second]);
   }
 }
 
 ThreadPlanSP
 AppleObjCTrampolineHandler::GetStepThroughDispatchPlan(Thread &thread,
                                                        bool stop_others) {

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

 struct RSReductionDescriptor {
   RSReductionDescriptor(const RSModuleDescriptor *module, uint32_t sig,
                         uint32_t accum_data_size, llvm::StringRef name,
                         llvm::StringRef init_name, llvm::StringRef accum_name,
                         llvm::StringRef comb_name, llvm::StringRef outc_name,
                         llvm::StringRef halter_name = ".")
       : m_module(module), m_reduce_name(name), m_init_name(init_name),
         m_accum_name(accum_name), m_comb_name(comb_name),
-        m_outc_name(outc_name), m_halter_name(halter_name) {
+        m_outc_name(outc_name), m_halter_name(halter_name), m_accum_sig(0),
+        m_accum_data_size(0), m_comb_name_generated(false) {
     // TODO Check whether the combiner is an autogenerated name, and track
     // this
   }
 
   void Dump(Stream &strm) const;
 
   const RSModuleDescriptor *m_module;
   ConstString m_reduce_name; // This is the name given to the general reduction

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

bool ParseReductionTypes(llvm::StringRef option_val,
       }
 
       return true;
     }
 
     int m_kernel_types = RSReduceBreakpointResolver::eKernelTypeAll;
     llvm::StringRef m_reduce_name;
     RSCoordinate m_coord;
-    bool m_have_coord;
+    bool m_have_coord = false;
   };
 
   Options *GetOptions() override { return &m_options; }
 
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     const size_t argc = command.GetArgumentCount();
     if (argc < 1) {
       result.AppendErrorWithFormat("'%s' takes 1 argument of reduction name, "
void OptionParsingStarting(ExecutionContext *exe_ctx) override {
       m_have_coord = false;
     }
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_renderscript_kernel_bp_set_options);
     }
 
     RSCoordinate m_coord;
-    bool m_have_coord;
+    bool m_have_coord = false;
   };
 
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     const size_t argc = command.GetArgumentCount();
     if (argc < 1) {
       result.AppendErrorWithFormat(
           "'%s' takes 1 argument of kernel name, and an optional coordinate.",
           m_cmd_name.c_str());

lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.h

protected:
   llvm::MachO::dysymtab_command m_dysymtab;
   std::vector<llvm::MachO::segment_command_64> m_mach_segments;
   std::vector<llvm::MachO::section_64> m_mach_sections;
   llvm::Optional<llvm::VersionTuple> m_min_os_version;
   llvm::Optional<llvm::VersionTuple> m_sdk_versions;
   typedef lldb_private::RangeVector<uint32_t, uint32_t> FileRangeArray;
   lldb_private::Address m_entry_point_address;
   FileRangeArray m_thread_context_offsets;
-  lldb::offset_t m_linkedit_original_offset;
-  lldb::addr_t m_text_address;
+  lldb::offset_t m_linkedit_original_offset = 0;
+  lldb::addr_t m_text_address = LLDB_INVALID_ADDRESS;
   bool m_thread_context_offsets_valid;
   lldb_private::FileSpecList m_reexported_dylibs;
   bool m_allow_assembly_emulation_unwind_plans;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_OBJECTFILE_MACH_O_OBJECTFILEMACHO_H

lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp

 bool ObjectFileMachO::IsStripped() {
   if (m_dysymtab.cmd == 0) {
     ModuleSP module_sp(GetModule());
     if (module_sp) {
       lldb::offset_t offset = MachHeaderSizeFromMagic(m_header.magic);
       for (uint32_t i = 0; i < m_header.ncmds; ++i) {
         const lldb::offset_t load_cmd_offset = offset;
 
-        llvm::MachO::load_command lc;
+        llvm::MachO::load_command lc = {};
         if (m_data.GetU32(&offset, &lc.cmd, 2) == nullptr)
           break;
         if (lc.cmd == LC_DYSYMTAB) {
           m_dysymtab.cmd = lc.cmd;
           m_dysymtab.cmdsize = lc.cmdsize;
           if (m_data.GetU32(&offset, &m_dysymtab.ilocalsym,
                             (sizeof(m_dysymtab) / sizeof(uint32_t)) - 2) ==
               nullptr) {
             // Clear m_dysymtab if we were unable to read all items from the
std::string ObjectFileMachO::GetIdentifierString() {
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
 
     // First, look over the load commands for an LC_NOTE load command with
     // data_owner string "kern ver str" & use that if found.
     lldb::offset_t offset = MachHeaderSizeFromMagic(m_header.magic);
     for (uint32_t i = 0; i < m_header.ncmds; ++i) {
       const uint32_t cmd_offset = offset;
-      llvm::MachO::load_command lc;
+      llvm::MachO::load_command lc = {};
       if (m_data.GetU32(&offset, &lc.cmd, 2) == nullptr)
         break;
       if (lc.cmd == LC_NOTE) {
         char data_owner[17];
         m_data.CopyData(offset, 16, data_owner);
         data_owner[16] = '\0';
         offset += 16;
         uint64_t fileoff = m_data.GetU64_unchecked(&offset);
         uint64_t size = m_data.GetU64_unchecked(&offset);

 addr_t ObjectFileMachO::GetAddressMask() {
   addr_t mask = 0;
   ModuleSP module_sp(GetModule());
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
     lldb::offset_t offset = MachHeaderSizeFromMagic(m_header.magic);
     for (uint32_t i = 0; i < m_header.ncmds; ++i) {
       const uint32_t cmd_offset = offset;
-      llvm::MachO::load_command lc;
+      llvm::MachO::load_command lc = {};
       if (m_data.GetU32(&offset, &lc.cmd, 2) == nullptr)
         break;
       if (lc.cmd == LC_NOTE) {
         char data_owner[17];
         m_data.CopyData(offset, 16, data_owner);
         data_owner[16] = '\0';
         offset += 16;
         uint64_t fileoff = m_data.GetU64_unchecked(&offset);
 
bool ObjectFileMachO::GetCorefileMainBinaryInfo(addr_t &value,
   uint32_t log2_pagesize = 0; // not currently passed up to caller
   uint32_t platform = 0;      // not currently passed up to caller
   ModuleSP module_sp(GetModule());
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
     lldb::offset_t offset = MachHeaderSizeFromMagic(m_header.magic);
     for (uint32_t i = 0; i < m_header.ncmds; ++i) {
       const uint32_t cmd_offset = offset;
-      llvm::MachO::load_command lc;
+      llvm::MachO::load_command lc = {};
       if (m_data.GetU32(&offset, &lc.cmd, 2) == nullptr)
         break;
       if (lc.cmd == LC_NOTE) {
         char data_owner[17];
         memset(data_owner, 0, sizeof(data_owner));
         m_data.CopyData(offset, 16, data_owner);
         offset += 16;
         uint64_t fileoff = m_data.GetU64_unchecked(&offset);

 }
 
 llvm::VersionTuple ObjectFileMachO::GetMinimumOSVersion() {
   if (!m_min_os_version) {
     lldb::offset_t offset = MachHeaderSizeFromMagic(m_header.magic);
     for (uint32_t i = 0; i < m_header.ncmds; ++i) {
       const lldb::offset_t load_cmd_offset = offset;
 
-      llvm::MachO::version_min_command lc;
+      llvm::MachO::version_min_command lc = {};
       if (m_data.GetU32(&offset, &lc.cmd, 2) == nullptr)
         break;
       if (lc.cmd == llvm::MachO::LC_VERSION_MIN_MACOSX ||
           lc.cmd == llvm::MachO::LC_VERSION_MIN_IPHONEOS ||
           lc.cmd == llvm::MachO::LC_VERSION_MIN_TVOS ||
           lc.cmd == llvm::MachO::LC_VERSION_MIN_WATCHOS) {
         if (m_data.GetU32(&offset, &lc.version,
                           (sizeof(lc) / sizeof(uint32_t)) - 2)) {

 }
 
 llvm::VersionTuple ObjectFileMachO::GetSDKVersion() {
   if (!m_sdk_versions) {
     lldb::offset_t offset = MachHeaderSizeFromMagic(m_header.magic);
     for (uint32_t i = 0; i < m_header.ncmds; ++i) {
       const lldb::offset_t load_cmd_offset = offset;
 
-      llvm::MachO::version_min_command lc;
+      llvm::MachO::version_min_command lc = {};
       if (m_data.GetU32(&offset, &lc.cmd, 2) == nullptr)
         break;
       if (lc.cmd == llvm::MachO::LC_VERSION_MIN_MACOSX ||
           lc.cmd == llvm::MachO::LC_VERSION_MIN_IPHONEOS ||
           lc.cmd == llvm::MachO::LC_VERSION_MIN_TVOS ||
           lc.cmd == llvm::MachO::LC_VERSION_MIN_WATCHOS) {
         if (m_data.GetU32(&offset, &lc.version,
                           (sizeof(lc) / sizeof(uint32_t)) - 2)) {
for (uint32_t i = 0; i < m_header.ncmds; ++i) {
       offset = load_cmd_offset + lc.cmdsize;
     }
 
     if (!m_sdk_versions) {
       offset = MachHeaderSizeFromMagic(m_header.magic);
       for (uint32_t i = 0; i < m_header.ncmds; ++i) {
         const lldb::offset_t load_cmd_offset = offset;
 
-        llvm::MachO::version_min_command lc;
+        llvm::MachO::version_min_command lc = {};
         if (m_data.GetU32(&offset, &lc.cmd, 2) == nullptr)
           break;
         if (lc.cmd == llvm::MachO::LC_BUILD_VERSION) {
           // struct build_version_command {
           //     uint32_t    cmd;            /* LC_BUILD_VERSION */
           //     uint32_t    cmdsize;        /* sizeof(struct
           //     build_version_command) plus */
           //                                 /* ntools * sizeof(struct

 ObjectFileMachO::MachOCorefileAllImageInfos
 ObjectFileMachO::GetCorefileAllImageInfos() {
   MachOCorefileAllImageInfos image_infos;
 
   // Look for an "all image infos" LC_NOTE.
   lldb::offset_t offset = MachHeaderSizeFromMagic(m_header.magic);
   for (uint32_t i = 0; i < m_header.ncmds; ++i) {
     const uint32_t cmd_offset = offset;
-    llvm::MachO::load_command lc;
+    llvm::MachO::load_command lc = {};
     if (m_data.GetU32(&offset, &lc.cmd, 2) == nullptr)
       break;
     if (lc.cmd == LC_NOTE) {
       char data_owner[17];
       m_data.CopyData(offset, 16, data_owner);
       data_owner[16] = '\0';
       offset += 16;
       uint64_t fileoff = m_data.GetU64_unchecked(&offset);

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;
+  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");
   thread_context.rcx = read_register_u64(reg_ctx, "rcx");

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

public:
   lldb_private::DataExtractor ReadImageDataByRVA(uint32_t rva, size_t size);
 
   std::unique_ptr<lldb_private::CallFrameInfo> CreateCallFrameInfo() override;
 
 protected:
   bool NeedsEndianSwap() const;
 
   typedef struct dos_header { // DOS .EXE header
-    uint16_t e_magic;         // Magic number
-    uint16_t e_cblp;          // Bytes on last page of file
-    uint16_t e_cp;            // Pages in file
-    uint16_t e_crlc;          // Relocations
-    uint16_t e_cparhdr;       // Size of header in paragraphs
-    uint16_t e_minalloc;      // Minimum extra paragraphs needed
-    uint16_t e_maxalloc;      // Maximum extra paragraphs needed
-    uint16_t e_ss;            // Initial (relative) SS value
-    uint16_t e_sp;            // Initial SP value
-    uint16_t e_csum;          // Checksum
-    uint16_t e_ip;            // Initial IP value
-    uint16_t e_cs;            // Initial (relative) CS value
-    uint16_t e_lfarlc;        // File address of relocation table
-    uint16_t e_ovno;          // Overlay number
+    uint16_t e_magic = 0;     // Magic number
+    uint16_t e_cblp = 0;      // Bytes on last page of file
+    uint16_t e_cp = 0;        // Pages in file
+    uint16_t e_crlc = 0;      // Relocations
+    uint16_t e_cparhdr = 0;   // Size of header in paragraphs
+    uint16_t e_minalloc = 0;  // Minimum extra paragraphs needed
+    uint16_t e_maxalloc = 0;  // Maximum extra paragraphs needed
+    uint16_t e_ss = 0;        // Initial (relative) SS value
+    uint16_t e_sp = 0;        // Initial SP value
+    uint16_t e_csum = 0;      // Checksum
+    uint16_t e_ip = 0;        // Initial IP value
+    uint16_t e_cs = 0;        // Initial (relative) CS value
+    uint16_t e_lfarlc = 0;    // File address of relocation table
+    uint16_t e_ovno = 0;      // Overlay number
     uint16_t e_res[4];        // Reserved words
-    uint16_t e_oemid;         // OEM identifier (for e_oeminfo)
-    uint16_t e_oeminfo;       // OEM information; e_oemid specific
-    uint16_t e_res2[10];      // Reserved words
-    uint32_t e_lfanew;        // File address of new exe header
+    uint16_t e_oemid = 0;     // OEM identifier (for e_oeminfo)
+    uint16_t e_oeminfo = 0;   // OEM information; e_oemid specific
+    uint16_t e_res2[10] = {}; // Reserved words
+    uint32_t e_lfanew = 0;    // File address of new exe header
   } dos_header_t;
 
   typedef struct coff_header {
-    uint16_t machine;
-    uint16_t nsects;
-    uint32_t modtime;
-    uint32_t symoff;
-    uint32_t nsyms;
-    uint16_t hdrsize;
-    uint16_t flags;
+    uint16_t machine = 0;
+    uint16_t nsects = 0;
+    uint32_t modtime = 0;
+    uint32_t symoff = 0;
+    uint32_t nsyms = 0;
+    uint16_t hdrsize = 0;
+    uint16_t flags = 0;
   } coff_header_t;
 
   typedef struct data_directory {
-    uint32_t vmaddr;
-    uint32_t vmsize;
+    uint32_t vmaddr = 0;
+    uint32_t vmsize = 0;
   } data_directory_t;
 
   typedef struct coff_opt_header {
     uint16_t magic = 0;
     uint8_t major_linker_version = 0;
     uint8_t minor_linker_version = 0;
     uint32_t code_size = 0;
     uint32_t data_size = 0;
protected:
 
   enum coff_data_dir_type {
     coff_data_dir_export_table = 0,
     coff_data_dir_import_table = 1,
     coff_data_dir_exception_table = 3
   };
 
   typedef struct section_header {
-    char name[8];
-    uint32_t vmsize;  // Virtual Size
-    uint32_t vmaddr;  // Virtual Addr
-    uint32_t size;    // File size
-    uint32_t offset;  // File offset
-    uint32_t reloff;  // Offset to relocations
-    uint32_t lineoff; // Offset to line table entries
-    uint16_t nreloc;  // Number of relocation entries
-    uint16_t nline;   // Number of line table entries
-    uint32_t flags;
+    char name[8] = {};
+    uint32_t vmsize = 0;  // Virtual Size
+    uint32_t vmaddr = 0;  // Virtual Addr
+    uint32_t size = 0;    // File size
+    uint32_t offset = 0;  // File offset
+    uint32_t reloff = 0;  // Offset to relocations
+    uint32_t lineoff = 0; // Offset to line table entries
+    uint16_t nreloc = 0;  // Number of relocation entries
+    uint16_t nline = 0;   // Number of line table entries
+    uint32_t flags = 0;
   } section_header_t;
 
   typedef struct coff_symbol {
-    char name[8];
-    uint32_t value;
-    uint16_t sect;
-    uint16_t type;
-    uint8_t storage;
-    uint8_t naux;
+    char name[8] = {};
+    uint32_t value = 0;
+    uint16_t sect = 0;
+    uint16_t type = 0;
+    uint8_t storage = 0;
+    uint8_t naux = 0;
   } coff_symbol_t;
 
   typedef struct export_directory_entry {
-    uint32_t characteristics;
-    uint32_t time_date_stamp;
-    uint16_t major_version;
-    uint16_t minor_version;
-    uint32_t name;
-    uint32_t base;
-    uint32_t number_of_functions;
-    uint32_t number_of_names;
-    uint32_t address_of_functions;
-    uint32_t address_of_names;
-    uint32_t address_of_name_ordinals;
+    uint32_t characteristics = 0;
+    uint32_t time_date_stamp = 0;
+    uint16_t major_version = 0;
+    uint16_t minor_version = 0;
+    uint32_t name = 0;
+    uint32_t base = 0;
+    uint32_t number_of_functions = 0;
+    uint32_t number_of_names = 0;
+    uint32_t address_of_functions = 0;
+    uint32_t address_of_names = 0;
+    uint32_t address_of_name_ordinals = 0;
   } export_directory_entry;
 
   static bool ParseDOSHeader(lldb_private::DataExtractor &data,
                              dos_header_t &dos_header);
   static bool ParseCOFFHeader(lldb_private::DataExtractor &data,
                               lldb::offset_t *offset_ptr,
                               coff_header_t &coff_header);
   bool ParseCOFFOptionalHeader(lldb::offset_t *offset_ptr);

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

 }
 
 ObjectFilePECOFF::ObjectFilePECOFF(const lldb::ModuleSP &module_sp,
                                    DataBufferSP data_sp,
                                    lldb::offset_t data_offset,
                                    const FileSpec *file,
                                    lldb::offset_t file_offset,
                                    lldb::offset_t length)
     : ObjectFile(module_sp, file, file_offset, length, data_sp, data_offset),
-      m_dos_header(), m_coff_header(), m_sect_headers(),
-      m_entry_point_address(), m_deps_filespec() {
-  ::memset(&m_dos_header, 0, sizeof(m_dos_header));
-  ::memset(&m_coff_header, 0, sizeof(m_coff_header));
-}
+      m_dos_header(), m_coff_header(), m_coff_header_opt(), m_sect_headers(),
+      m_image_base(LLDB_INVALID_ADDRESS), m_entry_point_address(),
+      m_deps_filespec() {}
 
 ObjectFilePECOFF::ObjectFilePECOFF(const lldb::ModuleSP &module_sp,
                                    WritableDataBufferSP header_data_sp,
                                    const lldb::ProcessSP &process_sp,
                                    addr_t header_addr)
     : ObjectFile(module_sp, process_sp, header_addr, header_data_sp),
-      m_dos_header(), m_coff_header(), m_sect_headers(),
-      m_entry_point_address(), m_deps_filespec() {
-  ::memset(&m_dos_header, 0, sizeof(m_dos_header));
-  ::memset(&m_coff_header, 0, sizeof(m_coff_header));
-}
+      m_dos_header(), m_coff_header(), m_coff_header_opt(), m_sect_headers(),
+      m_image_base(LLDB_INVALID_ADDRESS), m_entry_point_address(),
+      m_deps_filespec() {}
 
 ObjectFilePECOFF::~ObjectFilePECOFF() = default;
 
 bool ObjectFilePECOFF::ParseHeader() {
   ModuleSP module_sp(GetModule());
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
     m_sect_headers.clear();

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

case llvm::Triple::x86_64:
     m_reg_info.gpr_flags = lldb_rflags_x86_64;
     break;
   default:
     assert(false && "Unhandled target architecture.");
     break;
   }
 
   ::memset(&m_fpr, 0, sizeof(FPR));
+  ::memset(&m_ymm_set, 0, sizeof(YMM));
 
   m_fpr_type = eNotValid;
 }
 
 RegisterContextPOSIX_x86::~RegisterContextPOSIX_x86() = default;
 
 RegisterContextPOSIX_x86::FPRType RegisterContextPOSIX_x86::GetFPRType() {
   if (m_fpr_type == eNotValid) {

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

GDBRemoteCommunication::GDBRemoteCommunication(const char *comm_name,
                                                const char *listener_name)
     : Communication(comm_name),
 #ifdef LLDB_CONFIGURATION_DEBUG
       m_packet_timeout(1000),
 #else
       m_packet_timeout(1),
 #endif
       m_echo_number(0), m_supports_qEcho(eLazyBoolCalculate), m_history(512),
-      m_send_acks(true), m_compression_type(CompressionType::None),
-      m_listen_url() {
+      m_send_acks(true), m_is_platform(false),
+      m_compression_type(CompressionType::None), m_listen_url() {
 }
 
 // Destructor
 GDBRemoteCommunication::~GDBRemoteCommunication() {
   if (IsConnected()) {
     Disconnect();
   }
 
GDBRemoteCommunication::ConnectLocally(GDBRemoteCommunication &client,
 
   server.SetConnection(
       std::make_unique<ConnectionFileDescriptor>(accept_socket));
   return llvm::Error::success();
 }
 
 GDBRemoteCommunication::ScopedTimeout::ScopedTimeout(
     GDBRemoteCommunication &gdb_comm, std::chrono::seconds timeout)
-    : m_gdb_comm(gdb_comm), m_timeout_modified(false) {
+    : m_gdb_comm(gdb_comm), m_saved_timeout(0), m_timeout_modified(false) {
   auto curr_timeout = gdb_comm.GetPacketTimeout();
   // Only update the timeout if the timeout is greater than the current
   // timeout. If the current timeout is larger, then just use that.
   if (curr_timeout < timeout) {
     m_timeout_modified = true;
     m_saved_timeout = m_gdb_comm.SetPacketTimeout(timeout);
   }
 }

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

LibdispatchOffsets() {
       dqo_serialnum = UINT16_MAX;
       dqo_label = UINT16_MAX;
       dqo_width = UINT16_MAX;
       dqo_running = UINT16_MAX;
       dqo_suspend_cnt = UINT16_MAX;
       dqo_target_queue = UINT16_MAX;
       dqo_target_queue = UINT16_MAX;
       dqo_priority = UINT16_MAX;
+      dqo_label_size = 0;
+      dqo_flags_size = 0;
+      dqo_serialnum_size = 0;
+      dqo_width_size = 0;
+      dqo_running_size = 0;
+      dqo_suspend_cnt_size = 0;
+      dqo_target_queue_size = 0;
+      dqo_priority_size = 0;
     }
 
     bool IsValid() { return dqo_version != UINT16_MAX; }
 
     bool LabelIsValid() { return dqo_label != UINT16_MAX; }
   };
 
   struct LibdispatchVoucherOffsets {

lldb/source/Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.h

public:
   llvm::StringRef GetPluginName() override { return GetPluginNameStatic(); }
 
 private:
   // Call CreateInstance to get an instance of this class
   UnwindAssemblyInstEmulation(const lldb_private::ArchSpec &arch,
                               lldb_private::EmulateInstruction *inst_emulator)
       : UnwindAssembly(arch), m_inst_emulator_up(inst_emulator),
         m_range_ptr(nullptr), m_unwind_plan_ptr(nullptr), m_curr_row(),
-        m_cfa_reg_info(), m_fp_is_cfa(false), m_register_values(),
-        m_pushed_regs(), m_curr_row_modified(false),
+        m_initial_sp(0), m_cfa_reg_info(), m_fp_is_cfa(false),
+        m_register_values(), m_pushed_regs(), m_curr_row_modified(false),
         m_forward_branch_offset(0) {
     if (m_inst_emulator_up.get()) {
       m_inst_emulator_up->SetBaton(this);
       m_inst_emulator_up->SetCallbacks(ReadMemory, WriteMemory, ReadRegister,
                                        WriteRegister);
     }
   }
 

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

 
 using namespace lldb_private;
 using namespace lldb;
 
 x86AssemblyInspectionEngine::x86AssemblyInspectionEngine(const ArchSpec &arch)
     : m_cur_insn(nullptr), m_machine_ip_regnum(LLDB_INVALID_REGNUM),
       m_machine_sp_regnum(LLDB_INVALID_REGNUM),
       m_machine_fp_regnum(LLDB_INVALID_REGNUM),
+      m_machine_alt_fp_regnum(LLDB_INVALID_REGNUM),
       m_lldb_ip_regnum(LLDB_INVALID_REGNUM),
       m_lldb_sp_regnum(LLDB_INVALID_REGNUM),
       m_lldb_fp_regnum(LLDB_INVALID_REGNUM),
-
-      m_reg_map(), m_arch(arch), m_cpu(k_cpu_unspecified), m_wordsize(-1),
+      m_lldb_alt_fp_regnum(LLDB_INVALID_REGNUM), m_reg_map(), m_arch(arch),
+      m_cpu(k_cpu_unspecified), m_wordsize(-1),
       m_register_map_initialized(false), m_disasm_context() {
   m_disasm_context =
       ::LLVMCreateDisasm(arch.GetTriple().getTriple().c_str(), nullptr,
                          /*TagType=*/1, nullptr, nullptr);
 }
 
 x86AssemblyInspectionEngine::~x86AssemblyInspectionEngine() {
   ::LLVMDisasmDispose(m_disasm_context);