[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

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

410

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

417

419–420

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.

428

430–431

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

[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

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.

428

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

410

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

281–282

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

281–282

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:
 
   bool Cascades() const { return m_flags.GetCascades(); }
 
   bool SkipsPointers() const { return m_flags.GetSkipPointers(); }
 
   bool SkipsReferences() const { return m_flags.GetSkipReferences(); }
 
   bool NonCacheable() const { return m_flags.GetNonCacheable(); }
-  
-  bool WantsDereference() const { return m_flags.GetFrontEndWantsDereference();} 
+  bool WantsDereference() const {
+    return m_flags.GetFrontEndWantsDereference();
+  }
 
   void SetCascades(bool value) { m_flags.SetCascades(value); }
 
   void SetSkipsPointers(bool value) { m_flags.SetSkipPointers(value); }
 
   void SetSkipsReferences(bool value) { m_flags.SetSkipReferences(value); }
 
   void SetNonCacheable(bool value) { m_flags.SetNonCacheable(value); }
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

void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_use_one_liner = false;
       m_one_liner.clear();
       m_auto_continue = false;
     }
 
     std::string m_class_name;
     std::string m_function_name;
     uint32_t m_line_start = 0;
-    uint32_t m_line_end;
+    uint32_t m_line_end = UINT_MAX;
     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

 }
 
 bool CPlusPlusLanguage::MethodName::ContainsPath(llvm::StringRef path) {
   if (!m_parsed)
     Parse();
   // If we can't parse the incoming name, then just check that it contains path.
   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);
+  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;
   // Incoming path has context but this method does not, no match.
   if (m_context.empty())
     return false;
 
   llvm::StringRef haystack = m_context;
   if (!haystack.consume_back(context))
     return false;
   if (haystack.empty() || !isalnum(haystack.back()))
     return true;
-    
   return false;
 }
 
 bool CPlusPlusLanguage::IsCPPMangledName(llvm::StringRef name) {
   // FIXME!! we should really run through all the known C++ Language plugins
   // and ask each one if this is a C++ mangled name
 
   Mangled::ManglingScheme scheme = Mangled::GetManglingScheme(name);
 
   if (scheme == Mangled::eManglingSchemeNone)
     return false;
 
   return true;
 }
 
-bool CPlusPlusLanguage::DemangledNameContainsPath(llvm::StringRef path, 
+bool CPlusPlusLanguage::DemangledNameContainsPath(llvm::StringRef path,
                                                   ConstString demangled) const {
   MethodName demangled_name(demangled);
   return demangled_name.ContainsPath(path);
 }
 
 bool CPlusPlusLanguage::ExtractContextAndIdentifier(
     const char *name, llvm::StringRef &context, llvm::StringRef &identifier) {
   if (MSVCUndecoratedNameParser::IsMSVCUndecoratedName(name))
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);
 
private:
   ExecutionContextRef m_exe_ctx_ref;
   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 {
   public:
     NSDictionaryMSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);
-    
     ~NSDictionaryMSyntheticFrontEnd() override;
-    
     size_t CalculateNumChildren() override;
-    
     lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
-    
     bool Update() override;
-    
     bool MightHaveChildren() override;
-    
     size_t GetIndexOfChildWithName(ConstString name) override;
-    
   private:
     struct DataDescriptor_32 {
       uint32_t _used : 26;
       uint32_t _kvo : 1;
       uint32_t _size;
       uint32_t _mutations;
       uint32_t _objs_addr;
       uint32_t _keys_addr;
     };
-    
     struct DataDescriptor_64 {
       uint64_t _used : 58;
       uint32_t _kvo : 1;
       uint64_t _size;
       uint64_t _mutations;
       uint64_t _objs_addr;
       uint64_t _keys_addr;
     };
-    
     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 = 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 {
       uint32_t _used : 26;
       uint32_t _kvo : 1;
       uint32_t _size;
       uint32_t _buffer;
       uint64_t GetSize() { return _size; }
     };
-    
     struct DataDescriptor_64 {
       uint64_t _used : 58;
       uint32_t _kvo : 1;
       uint64_t _size;
       uint64_t _buffer;
       uint64_t GetSize() { return _size; }
     };
   }
 
   using NSDictionaryMSyntheticFrontEnd =
     GenericNSDictionaryMSyntheticFrontEnd<DataDescriptor_32, DataDescriptor_64>;
 }
-  
 namespace Foundation1437 {
     static const uint64_t NSDictionaryCapacities[] = {
         0, 3, 7, 13, 23, 41, 71, 127, 191, 251, 383, 631, 1087, 1723,
         2803, 4523, 7351, 11959, 19447, 31231, 50683, 81919, 132607,
         214519, 346607, 561109, 907759, 1468927, 2376191, 3845119,
         6221311, 10066421, 16287743, 26354171, 42641881, 68996069,
         111638519, 180634607, 292272623, 472907251
     };
-    
     static const size_t NSDictionaryNumSizeBuckets =
         sizeof(NSDictionaryCapacities) / sizeof(uint64_t);
 
     namespace {
     struct DataDescriptor_32 {
       uint32_t _buffer;
       uint32_t _muts;
       uint32_t _used : 25;
       uint32_t _kvo : 1;
       uint32_t _szidx : 6;
 
       uint64_t GetSize() {
         return (_szidx) >= NSDictionaryNumSizeBuckets ?
             0 : NSDictionaryCapacities[_szidx];
       }
     };
-    
     struct DataDescriptor_64 {
       uint64_t _buffer;
       uint32_t _muts;
       uint32_t _used : 25;
       uint32_t _kvo : 1;
       uint32_t _szidx : 6;
 
       uint64_t GetSize() {
         return (_szidx) >= NSDictionaryNumSizeBuckets ?
             0 : NSDictionaryCapacities[_szidx];
       }
     };
     } // namespace
 
   using NSDictionaryMSyntheticFrontEnd =
     GenericNSDictionaryMSyntheticFrontEnd<DataDescriptor_32, DataDescriptor_64>;
-  
   template <typename DD>
   uint64_t
   __NSDictionaryMSize_Impl(lldb_private::Process &process,
                            lldb::addr_t valobj_addr, Status &error) {
     const lldb::addr_t start_of_descriptor =
         valobj_addr + process.GetAddressByteSize();
     DD descriptor = DD();
     process.ReadMemory(start_of_descriptor, &descriptor, sizeof(descriptor),
                        error);
     if (error.Fail()) {
       return 0;
     }
     return descriptor._used;
   }
-  
   uint64_t
   __NSDictionaryMSize(lldb_private::Process &process, lldb::addr_t valobj_addr,
                Status &error) {
     if (process.GetAddressByteSize() == 4) {
       return __NSDictionaryMSize_Impl<DataDescriptor_32>(process, valobj_addr,
                                                          error);
     } else {
       return __NSDictionaryMSize_Impl<DataDescriptor_64>(process, valobj_addr,

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;
private:
   };
 
   ExecutionContextRef m_exe_ctx_ref;
   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;
     uint32_t _size;
     uint32_t _mutations;
     uint32_t _objs_addr;
   };
-  
   struct DataDescriptor_64 {
     uint64_t _used : 58;
     uint64_t _size;
     uint64_t _mutations;
     uint64_t _objs_addr;
   };
-  
   using NSSetMSyntheticFrontEnd =
       GenericNSSetMSyntheticFrontEnd<DataDescriptor_32, DataDescriptor_64>;
 }
-  
 namespace Foundation1428 {
   struct DataDescriptor_32 {
     uint32_t _used : 26;
     uint32_t _size;
     uint32_t _objs_addr;
     uint32_t _mutations;
   };
-  
   struct DataDescriptor_64 {
     uint64_t _used : 58;
     uint64_t _size;
     uint64_t _objs_addr;
     uint64_t _mutations;
   };
-  
   using NSSetMSyntheticFrontEnd =
       GenericNSSetMSyntheticFrontEnd<DataDescriptor_32, DataDescriptor_64>;
 }
-  
 namespace Foundation1437 {
   struct DataDescriptor_32 {
     uint32_t _cow;
     // __table storage
     uint32_t _objs_addr;
     uint32_t _muts;
     uint32_t _used : 26;
     uint32_t _szidx : 6;
   };
-  
   struct DataDescriptor_64 {
     uint64_t _cow;
     // __Table storage
     uint64_t _objs_addr;
     uint32_t _muts;
     uint32_t _used : 26;
     uint32_t _szidx : 6;
   };
-  
   using NSSetMSyntheticFrontEnd =
       GenericNSSetMSyntheticFrontEnd<DataDescriptor_32, DataDescriptor_64>;
-  
   template <typename DD>
   uint64_t
   __NSSetMSize_Impl(lldb_private::Process &process, lldb::addr_t valobj_addr,
                     Status &error) {
     const lldb::addr_t start_of_descriptor =
         valobj_addr + process.GetAddressByteSize();
     DD descriptor = DD();
     process.ReadMemory(start_of_descriptor, &descriptor, sizeof(descriptor),
                        error);
     if (error.Fail()) {
       return 0;
     }
     return descriptor._used;
   }
-  
   uint64_t
   __NSSetMSize(lldb_private::Process &process, lldb::addr_t valobj_addr,
                Status &error) {
     if (process.GetAddressByteSize() == 4) {
       return __NSSetMSize_Impl<DataDescriptor_32>(process, valobj_addr, error);
     } else {
       return __NSSetMSize_Impl<DataDescriptor_64>(process, valobj_addr, error);
     }
   }
 }
-  
 class NSSetCodeRunningSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
 public:
   NSSetCodeRunningSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);
 
   ~NSSetCodeRunningSyntheticFrontEnd() override;
 
   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.h

public:
     bool is_super = false;
     bool is_super2 = false;
     FixUpState fixedup = eFixUpNone;
   };
 
   lldb::addr_t SetupDispatchFunction(Thread &thread,
                                      ValueList &dispatch_values);
   const DispatchFunction *FindDispatchFunction(lldb::addr_t addr);
-  void ForEachDispatchFunction(std::function<void(lldb::addr_t, 
-                                                  const DispatchFunction &)>);
+  void ForEachDispatchFunction(
+      std::function<void(lldb::addr_t, const DispatchFunction &)>);
 
 private:
   /// These hold the code for the function that finds the implementation of
   /// an ObjC message send given the class & selector and the kind of dispatch.
   /// There are two variants depending on whether the platform uses a separate
   /// _stret passing convention (e.g. Intel) or not (e.g. ARM).  The difference
   /// is only at the very end of the function, so the code is broken into the
   /// common prefix and the suffix, which get composed appropriately before
private:
   lldb::ProcessWP m_process_wp;
   lldb::ModuleSP m_objc_module_sp;
   std::string m_lookup_implementation_function_code;
   std::unique_ptr<UtilityFunction> m_impl_code;
   std::mutex m_impl_function_mutex;
   lldb::addr_t m_impl_fn_addr;
   lldb::addr_t m_impl_stret_fn_addr;
   lldb::addr_t m_msg_forward_addr;
   lldb::addr_t m_msg_forward_stret_addr;
   std::unique_ptr<AppleObjCVTables> m_vtables_up;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_LANGUAGERUNTIME_OBJC_APPLEOBJCRUNTIME_APPLEOBJCTRAMPOLINEHANDLER_H

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

 extern "C"
 {
   extern void *class_getMethodImplementation(void *objc_class, void *sel);
   extern void *class_getMethodImplementation_stret(void *objc_class, void *sel);
   extern void * object_getClass (id object);
   extern void * sel_getUid(char *name);
   extern int printf(const char *format, ...);
 }
-extern "C" void * 
+extern "C" void *
 __lldb_objc_find_implementation_for_selector (void *object,
                                               void *sel,
                                               int is_str_ptr,
                                               int is_stret,
                                               int is_super,
                                               int is_super2,
                                               int is_fixup,
                                               int is_fixed,
struct __lldb_objc_super {
     struct __lldb_objc_class *class_ptr;
   };
   struct __lldb_msg_ref {
     void *dont_know;
     void *sel;
   };
 
   struct __lldb_imp_return_struct return_struct;
-                                                                           
   if (debug)
     printf ("\n*** Called with obj: %p sel: %p is_str_ptr: %d "
             "is_stret: %d is_super: %d, "
             "is_super2: %d, is_fixup: %d, is_fixed: %d\n",
              object, sel, is_str_ptr, is_stret,
              is_super, is_super2, is_fixup, is_fixed);
 
   if (is_str_ptr) {
     if (debug)
       printf("*** Turning string: '%s'", sel);
     sel = sel_getUid((char *)sel);
     if (debug)
       printf("*** into sel to %p", sel);
   }
   if (is_super) {
     if (is_super2) {
-      return_struct.class_addr 
+      return_struct.class_addr
           = ((__lldb_objc_super *) object)->class_ptr->super_ptr;
     } else {
       return_struct.class_addr = ((__lldb_objc_super *) object)->class_ptr;
     }
     if (debug)
       printf("*** Super, class addr: %p\n", return_struct.class_addr);
   } else {
     // This code seems a little funny, but has its reasons...
-    // The call to [object class] is here because if this is a class, and has 
-    // not been called into yet, we need to do something to force the class to 
+    // The call to [object class] is here because if this is a class, and has
+    // not been called into yet, we need to do something to force the class to
     // initialize itself.
-    // Then the call to object_getClass will actually return the correct class, 
-    // either the class if object is a class instance, or the meta-class if it 
+    // Then the call to object_getClass will actually return the correct class,
+    // either the class if object is a class instance, or the meta-class if it
     // is a class pointer.
     void *class_ptr = (void *) [(id) object class];
     return_struct.class_addr = (id)  object_getClass((id) object);
     if (debug) {
       if (class_ptr == object) {
         printf ("Found a class object, need to return the meta class %p -> %p\n",
                 class_ptr, return_struct.class_addr);
       } else {
AppleObjCTrampolineHandler::g_dispatch_functions[] = {
          DispatchFunction::eFixUpToFix},
         {"objc_msgSendSuper2_stret_fixedup", true, true, true,
          DispatchFunction::eFixUpFixed},
 };
 
 // This is the table of ObjC "accelerated dispatch" functions.  They are a set
 // of objc methods that are "seldom overridden" and so the compiler replaces the
 // objc_msgSend with a call to one of the dispatch functions.  That will check
-// whether the method has been overridden, and directly call the Foundation 
-// implementation if not.  
+// whether the method has been overridden, and directly call the Foundation
+// implementation if not.
 // This table is supposed to be complete.  If ones get added in the future, we
 // will have to add them to the table.
 const char *AppleObjCTrampolineHandler::g_opt_dispatch_names[] = {
     "objc_alloc",
     "objc_autorelease",
     "objc_release",
     "objc_retain",
     "objc_alloc_init",
     "objc_allocWithZone",
     "objc_opt_class",
     "objc_opt_isKindOfClass",
     "objc_opt_new",
     "objc_opt_respondsToSelector",
     "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");
if (m_impl_fn_addr == LLDB_INVALID_ADDRESS) {
     if (process_sp->CanJIT()) {
       process_sp->GetTarget().GetDebugger().GetErrorStream().Printf(
           "Could not find implementation lookup function \"%s\""
           " step in through ObjC method dispatch will not work.\n",
           get_impl_name.AsCString());
     }
     return;
   }
-  
   // We will either set the implementation to the _stret or non_stret version,
   // so either way it's safe to start filling the m_lookup_..._code here.
   m_lookup_implementation_function_code.assign(
           g_lookup_implementation_function_common_code);
 
   if (m_impl_stret_fn_addr == LLDB_INVALID_ADDRESS) {
     // It there is no stret return lookup function, assume that it is the same
     // as the straight lookup:
if (msgSend_symbol && msgSend_symbol->ValueIsAddress()) {
       // functions.  If that's as complex as it gets, we're fine.
 
       lldb::addr_t sym_addr =
           msgSend_symbol->GetAddressRef().GetOpcodeLoadAddress(target);
 
       m_msgSend_map.insert(std::pair<lldb::addr_t, int>(sym_addr, i));
     }
   }
-  
   // Similarly, cache the addresses of the "optimized dispatch" function.
   for (size_t i = 0; i != llvm::array_lengthof(g_opt_dispatch_names); i++) {
     ConstString name_const_str(g_opt_dispatch_names[i]);
     const Symbol *msgSend_symbol =
         m_objc_module_sp->FindFirstSymbolWithNameAndType(name_const_str,
                                                          eSymbolTypeCode);
     if (msgSend_symbol && msgSend_symbol->ValueIsAddress()) {
       lldb::addr_t sym_addr =
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) {
if (impl_addr != LLDB_INVALID_ADDRESS) {
           sym_name);
       if (log) {
         StreamString s;
         ret_plan_sp->GetDescription(&s, eDescriptionLevelFull);
         LLDB_LOGF(log, "Using ObjC step plan: %s.\n", s.GetData());
       }
     }
   }
-  
   // Finally, check if we have hit an "optimized dispatch" function.  This will
   // either directly call the base implementation or dispatch an objc_msgSend
   // if the method has been overridden.  So we just do a "step in/step out",
-  // setting a breakpoint on objc_msgSend, and if we hit the msgSend, we 
-  // will automatically step in again.  That's the job of the 
+  // setting a breakpoint on objc_msgSend, and if we hit the msgSend, we
+  // will automatically step in again.  That's the job of the
   // AppleThreadPlanStepThroughDirectDispatch.
   if (!this_dispatch && !ret_plan_sp) {
     MsgsendMap::iterator pos;
     pos = m_opt_dispatch_map.find(curr_pc);
     if (pos != m_opt_dispatch_map.end()) {
       const char *opt_name = g_opt_dispatch_names[(*pos).second];
       ret_plan_sp = std::make_shared<AppleThreadPlanStepThroughDirectDispatch>(
           thread, *this, opt_name);

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

empirical_type<uint32_t>
       type_vec_size; // Vector size of each data point, e.g '4' for uchar4
   empirical_type<uint32_t> field_count; // Number of Subelements
   empirical_type<uint32_t> datum_size;  // Size of a single Element with padding
   empirical_type<uint32_t> padding;     // Number of padding bytes
   empirical_type<uint32_t>
       array_size;        // Number of items in array, only needed for structs
   ConstString type_name; // Name of type, only needed for structs
 
-  static ConstString 
+  static ConstString
   GetFallbackStructName(); // Print this as the type name of a struct Element
                            // If we can't resolve the actual struct name
 
   bool ShouldRefresh() const {
     const bool valid_ptr = element_ptr.isValid() && *element_ptr.get() != 0x0;
     const bool valid_type =
         type.isValid() && type_vec_size.isValid() && type_kind.isValid();
     return !valid_ptr || !valid_type || !datum_size.isValid();
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.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_dos_header(), m_coff_header(), m_sect_headers(), m_image_base(),
       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));
 }
 
 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_dos_header(), m_coff_header(), m_sect_headers(), m_image_base(),
       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));
 }
 
 ObjectFilePECOFF::~ObjectFilePECOFF() = default;
 
 bool ObjectFilePECOFF::ParseHeader() {
   ModuleSP module_sp(GetModule());
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());

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);
if (*p == 0x89) {
     regno = ((*(p + 1) >> 3) & 0x7) | src_reg_prefix_bit;
     rbp_offset = offset > 0 ? offset : -offset;
     return true;
   }
   return false;
 }
 
 // Returns true if this is a jmp instruction where we can't
-// know the destination address statically. 
+// know the destination address statically.
 //
 // ff e0                                   jmpq   *%rax
 // ff e1                                   jmpq   *%rcx
 // ff 60 28                                jmpq   *0x28(%rax)
 // ff 60 60                                jmpq   *0x60(%rax)
 bool x86AssemblyInspectionEngine::jmp_to_reg_p() {
   if (*m_cur_insn != 0xff)
     return false;
bool x86AssemblyInspectionEngine::jmp_to_reg_p() {
   return false;
 }
 
 // Detect branches to fixed pc-relative offsets.
 // Returns the offset from the address of the next instruction
 // that may be branch/jumped to.
 //
 // Cannot determine the offset of a JMP that jumps to the address in
-// a register ("jmpq *%rax") or offset from a register value 
+// a register ("jmpq *%rax") or offset from a register value
 // ("jmpq *0x28(%rax)"), this method will return false on those
 // instructions.
 //
 // These instructions all end in either a relative 8/16/32 bit value
 // depending on the instruction and the current execution mode of the
-// inferior process.  Once we know the size of the opcode instruction, 
+// inferior process.  Once we know the size of the opcode instruction,
 // we can use the total instruction length to determine the size of
 // the relative offset without having to compute it correctly.
 
 bool x86AssemblyInspectionEngine::pc_rel_branch_or_jump_p (
     const int instruction_length, int &offset)
 {
   int opcode_size = 0;
 

 
 int32_t x86AssemblyInspectionEngine::extract_4_signed(uint8_t *b) {
   int32_t v = 0;
   for (int i = 3; i >= 0; i--)
     v = (v << 8) | b[i];
   return v;
 }
 
-
-bool x86AssemblyInspectionEngine::instruction_length(uint8_t *insn_p,
-                                                     int &length, 
-                                                     uint32_t buffer_remaining_bytes) {
+bool x86AssemblyInspectionEngine::instruction_length(
+    uint8_t *insn_p, int &length, uint32_t buffer_remaining_bytes) {
 
   uint32_t max_op_byte_size = std::min(buffer_remaining_bytes, m_arch.GetMaximumOpcodeByteSize());
   llvm::SmallVector<uint8_t, 32> opcode_data;
   opcode_data.resize(max_op_byte_size);
 
   char out_string[512];
   const size_t inst_size =
       ::LLVMDisasmInstruction(m_disasm_context, insn_p, max_op_byte_size, 0,
while (current_func_text_offset < size) {
     int machine_regno;   // register numbers masked directly out of instructions
     uint32_t lldb_regno; // register numbers in lldb's eRegisterKindLLDB
                          // numbering scheme
 
     bool in_epilogue = false; // we're in the middle of an epilogue sequence
     bool row_updated = false; // The UnwindPlan::Row 'row' has been updated
 
     m_cur_insn = data + current_func_text_offset;
-    if (!instruction_length(m_cur_insn, insn_len, size - current_func_text_offset)
-        || insn_len == 0 
-        || insn_len > kMaxInstructionByteSize) {
+    if (!instruction_length(m_cur_insn, insn_len,
+                            size - current_func_text_offset) ||
+        insn_len == 0 || insn_len > kMaxInstructionByteSize) {
       // An unrecognized/junk instruction
       break;
     }
 
     auto &cfa_value = row->GetCFAValue();
     auto &afa_value = row->GetAFAValue();
     auto fa_value_ptr = is_aligned ? &afa_value : &cfa_value;
 
else if (lea_rbx_rsp_pattern_p(stack_offset)) {
         afa_value.SetUnspecified();
         row_updated = true;
       }
       if (fa_value_ptr->GetRegisterNumber() == m_lldb_alt_fp_regnum) {
         current_sp_bytes_offset_from_fa = fa_value_ptr->GetOffset() - stack_offset;
       }
     }
 
-    else if (prologue_completed_row.get() && 
+    else if (prologue_completed_row.get() &&
              (ret_pattern_p() ||
-              non_local_branch_p (current_func_text_offset, func_range, insn_len) ||
+              non_local_branch_p(current_func_text_offset, func_range,
+                                 insn_len) ||
               jmp_to_reg_p())) {
       // Check if the current instruction is the end of an epilogue sequence,
       // and if so, re-instate the prologue-completed unwind state.
 
-      // The current instruction is a branch/jump outside this function, 
-      // a ret, or a jump through a register value which we cannot 
-      // determine the effcts of.  Verify that the stack frame state 
-      // has been unwound to the same as it was at function entry to avoid 
+      // The current instruction is a branch/jump outside this function,
+      // a ret, or a jump through a register value which we cannot
+      // determine the effcts of.  Verify that the stack frame state
+      // has been unwound to the same as it was at function entry to avoid
       // mis-identifying a JMP instruction as an epilogue.
       UnwindPlan::Row::RegisterLocation sp, pc;
       if (row->GetRegisterInfo(m_lldb_sp_regnum, sp) &&
           row->GetRegisterInfo(m_lldb_ip_regnum, pc)) {
         // Any ret instruction variant is definitely indicative of an
         // epilogue; for other insn patterns verify that we're back to
         // the original unwind state.
         if (ret_pattern_p() ||
if (!m_register_map_initialized)
     return false;
 
   while (offset < size) {
     int regno;
     int insn_len;
     int scratch;
 
     m_cur_insn = data + offset;
-    if (!instruction_length(m_cur_insn, insn_len, size - offset) 
-        || insn_len > kMaxInstructionByteSize 
-        || insn_len == 0) {
+    if (!instruction_length(m_cur_insn, insn_len, size - offset) ||
+        insn_len > kMaxInstructionByteSize || insn_len == 0) {
       // An error parsing the instruction, i.e. probably data/garbage - stop
       // scanning
       break;
     }
 
     if (push_rbp_pattern_p() || mov_rsp_rbp_pattern_p() ||
         sub_rsp_pattern_p(scratch) || push_reg_p(regno) ||
         mov_reg_to_local_stack_frame_p(regno, scratch) ||