[lldb][NFCI] UUID::Dump should take a reference instead of a pointer

[bulbazord]

Summary

We always assume the Stream pointer is valid, might as well be taking a
reference instead.

[JDevlieghere]

Makes sense

lldb/include/lldb/Core/ModuleSpec.h

if (m_arch.IsValid()) {
       strm.Printf("arch = ");
       m_arch.DumpTriple(strm.AsRawOstream());
       dumped_something = true;
     }
     if (m_uuid.IsValid()) {
       if (dumped_something)
         strm.PutCString(", ");
       strm.PutCString("uuid = ");
-      m_uuid.Dump(&strm);
+      m_uuid.Dump(strm);
       dumped_something = true;
     }
     if (m_object_name) {
       if (dumped_something)
         strm.PutCString(", ");
       strm.Printf("object_name = %s", m_object_name.GetCString());
       dumped_something = true;
     }

lldb/include/lldb/Utility/UUID.h

if (!bytes)
       return;
     *this 
         = UUID(llvm::ArrayRef<uint8_t>(reinterpret_cast<const uint8_t *>(bytes), 
                num_bytes));
   }
 
   void Clear() { m_bytes.clear(); }
 
-  void Dump(Stream *s) const;
+  void Dump(Stream &s) const;
 
   llvm::ArrayRef<uint8_t> GetBytes() const { return m_bytes; }
 
   explicit operator bool() const { return IsValid(); }
   bool IsValid() const { return !m_bytes.empty(); }
   
   std::string GetAsString(llvm::StringRef separator = "-") const;
 

lldb/source/Commands/CommandObjectTarget.cpp

if (width)
       strm.Printf("%-*s", width, arch_str.c_str());
     else
       strm.PutCString(arch_str);
   }
 }
 
 static void DumpModuleUUID(Stream &strm, Module *module) {
   if (module && module->GetUUID().IsValid())
-    module->GetUUID().Dump(&strm);
+    module->GetUUID().Dump(strm);
   else
     strm.PutCString("                                    ");
 }
 
 static uint32_t DumpCompileUnitLineTable(CommandInterpreter &interpreter,
                                          Stream &strm, Module *module,
                                          const FileSpec &file_spec,
                                          lldb::DescriptionLevel desc_level) {
if (argc == 0) {
         if (Symbols::DownloadObjectAndSymbolFile(module_spec, error)) {
           ModuleSP module_sp(
               target->GetOrCreateModule(module_spec, true /* notify */));
           if (module_sp) {
             result.SetStatus(eReturnStatusSuccessFinishResult);
             return true;
           } else {
             StreamString strm;
-            module_spec.GetUUID().Dump(&strm);
+            module_spec.GetUUID().Dump(strm);
             if (module_spec.GetFileSpec()) {
               if (module_spec.GetSymbolFileSpec()) {
                 result.AppendErrorWithFormat(
                     "Unable to create the executable or symbol file with "
                     "UUID %s with path %s and symbol file %s",
                     strm.GetData(), module_spec.GetFileSpec().GetPath().c_str(),
                     module_spec.GetSymbolFileSpec().GetPath().c_str());
               } else {
                 result.AppendErrorWithFormat(
                     "Unable to create the executable or symbol file with "
                     "UUID %s with path %s",
                     strm.GetData(),
                     module_spec.GetFileSpec().GetPath().c_str());
               }
             } else {
               result.AppendErrorWithFormat("Unable to create the executable "
                                            "or symbol file with UUID %s",
                                            strm.GetData());
             }
             return false;
           }
         } else {
           StreamString strm;
-          module_spec.GetUUID().Dump(&strm);
+          module_spec.GetUUID().Dump(strm);
           result.AppendErrorWithFormat(
               "Unable to locate the executable or symbol file with UUID %s",
               strm.GetData());
           result.SetError(error);
           return false;
         }
       } else {
         result.AppendError(
if (matching_modules.GetSize() == 1) {
       }
       // Clear the symbol file spec if anything went wrong
       module_sp->SetSymbolFileFileSpec(FileSpec());
     }
 
     StreamString ss_symfile_uuid;
     if (module_spec.GetUUID().IsValid()) {
       ss_symfile_uuid << " (";
-      module_spec.GetUUID().Dump(&ss_symfile_uuid);
+      module_spec.GetUUID().Dump(ss_symfile_uuid);
       ss_symfile_uuid << ')';
     }
     result.AppendErrorWithFormat(
         "symbol file '%s'%s does not match any existing module%s\n",
         symfile_path, ss_symfile_uuid.GetData(),
         !llvm::sys::fs::is_regular_file(symbol_fspec.GetPath())
             ? "\n       please specify the full path to the symbol file"
             : "");
bool AddSymbolsForUUID(CommandReturnObject &result, bool &flush) {
 
     ModuleSpec module_spec;
     module_spec.GetUUID() =
         m_uuid_option_group.GetOptionValue().GetCurrentValue();
 
     if (!DownloadObjectAndSymbolFile(module_spec, result, flush)) {
       StreamString error_strm;
       error_strm.PutCString("unable to find debug symbols for UUID ");
-      module_spec.GetUUID().Dump(&error_strm);
+      module_spec.GetUUID().Dump(error_strm);
       result.AppendError(error_strm.GetString());
       return false;
     }
 
     return true;
   }
 
   bool AddSymbolsForFile(CommandReturnObject &result, bool &flush) {

lldb/source/Interpreter/OptionValueUUID.cpp

 
 void OptionValueUUID::DumpValue(const ExecutionContext *exe_ctx, Stream &strm,
                                 uint32_t dump_mask) {
   if (dump_mask & eDumpOptionType)
     strm.Printf("(%s)", GetTypeAsCString());
   if (dump_mask & eDumpOptionValue) {
     if (dump_mask & eDumpOptionType)
       strm.PutCString(" = ");
-    m_uuid.Dump(&strm);
+    m_uuid.Dump(strm);
   }
 }
 
 Status OptionValueUUID::SetValueFromString(llvm::StringRef value,
                                            VarSetOperationType op) {
   Status error;
   switch (op) {
   case eVarSetOperationClear:

lldb/source/Plugins/SymbolVendor/MacOSX/SymbolVendorMacOSX.cpp

if (module && ofile) {
 
     if (dsym_uuid == module->GetUUID())
       return true;
 
     // Emit some warning messages since the UUIDs do not match!
     if (feedback_strm) {
       feedback_strm->PutCString(
           "warning: UUID mismatch detected between modules:\n    ");
-      module->GetUUID().Dump(feedback_strm);
+      module->GetUUID().Dump(*feedback_strm);
       feedback_strm->PutChar(' ');
       module->GetFileSpec().Dump(feedback_strm->AsRawOstream());
       feedback_strm->PutCString("\n    ");
-      dsym_uuid.Dump(feedback_strm);
+      dsym_uuid.Dump(*feedback_strm);
       feedback_strm->PutChar(' ');
       ofile->GetFileSpec().Dump(feedback_strm->AsRawOstream());
       feedback_strm->EOL();
     }
   }
   return false;
 }
 

lldb/source/Target/Target.cpp

if (module_sp) {
             auto dump = [&message](Module &dump_module) -> void {
               UUID dump_uuid = dump_module.GetUUID();
 
               message << '[';
               dump_module.GetDescription(message.AsRawOstream());
               message << " (uuid ";
 
               if (dump_uuid.IsValid())
-                dump_uuid.Dump(&message);
+                dump_uuid.Dump(message);
               else
                 message << "not specified";
 
               message << ")]";
             };
 
             message << "New module ";
             dump(*module_sp);

lldb/source/Utility/UUID.cpp

for (auto B : llvm::enumerate(GetBytes())) {
 
     os << llvm::format_hex_no_prefix(B.value(), 2, true);
   }
   os.flush();
 
   return result;
 }
 
-void UUID::Dump(Stream *s) const { s->PutCString(GetAsString()); }
+void UUID::Dump(Stream &s) const { s.PutCString(GetAsString()); }
 
 static inline int xdigit_to_int(char ch) {
   ch = tolower(ch);
   if (ch >= 'a' && ch <= 'f')
     return 10 + ch - 'a';
   return ch - '0';
 }