[lldb][NFC] Migrate to raw_ostream in ArchSpec::DumpTriple

[davide]

LGTM.

[clayborg]

lldb/include/lldb/Utility/ArchSpec.h

436

Should we just make a static operator << function for this instead so we can use in formats?

lldb/include/lldb/Core/ModuleSpec.h

if (m_symbol_file) {
       strm << m_symbol_file;
       strm.PutCString("'");
       dumped_something = true;
     }
     if (m_arch.IsValid()) {
       if (dumped_something)
         strm.PutCString(", ");
       strm.Printf("arch = ");
-      m_arch.DumpTriple(strm);
+      m_arch.DumpTriple(strm.AsRawOstream());
       dumped_something = true;
     }
     if (m_uuid.IsValid()) {
       if (dumped_something)
         strm.PutCString(", ");
       strm.PutCString("uuid = ");
       m_uuid.Dump(&strm);
       dumped_something = true;

lldb/include/lldb/Utility/ArchSpec.h

public:
   /// \return A triple describing this ArchSpec.
   llvm::Triple &GetTriple() { return m_triple; }
 
   /// Architecture triple accessor.
   ///
   /// \return A triple describing this ArchSpec.
   const llvm::Triple &GetTriple() const { return m_triple; }
 
-  void DumpTriple(Stream &s) const;
+  void DumpTriple(llvm::raw_ostream &s) const;
 
   /// Architecture triple setter.
   ///
   /// Configures this ArchSpec according to the given triple.  If the triple
   /// has unknown components in all of the vendor, OS, and the optional
   /// environment field (i.e. "i386-unknown-unknown") then default values are
   /// taken from the host.  Architecture and environment components are used
   /// to further resolve the CPU type and subtype, endian characteristics,

lldb/source/Commands/CommandObjectTarget.cpp

if (!exe_valid)
     ::strcpy(exe_path, "<none>");
 
   strm.Printf("%starget #%u: %s", prefix_cstr ? prefix_cstr : "", target_idx,
               exe_path);
 
   uint32_t properties = 0;
   if (target_arch.IsValid()) {
     strm.Printf("%sarch=", properties++ > 0 ? ", " : " ( ");
-    target_arch.DumpTriple(strm);
+    target_arch.DumpTriple(strm.AsRawOstream());
     properties++;
   }
   PlatformSP platform_sp(target->GetPlatform());
   if (platform_sp)
     strm.Printf("%splatform=%s", properties++ > 0 ? ", " : " ( ",
                 platform_sp->GetName().GetCString());
 
   ProcessSP process_sp(target->GetProcessSP());

 
 // Static Helper functions
 static void DumpModuleArchitecture(Stream &strm, Module *module,
                                    bool full_triple, uint32_t width) {
   if (module) {
     StreamString arch_strm;
 
     if (full_triple)
-      module->GetArchitecture().DumpTriple(arch_strm);
+      module->GetArchitecture().DumpTriple(arch_strm.AsRawOstream());
     else
       arch_strm.PutCString(module->GetArchitecture().GetArchitectureName());
     std::string arch_str = arch_strm.GetString();
 
     if (width)
       strm.Printf("%-*s", width, arch_str.c_str());
     else
       strm.PutCString(arch_str);

lldb/source/Target/Platform.cpp

 void Platform::GetStatus(Stream &strm) {
   std::string s;
   strm.Printf("  Platform: %s\n", GetPluginName().GetCString());
 
   ArchSpec arch(GetSystemArchitecture());
   if (arch.IsValid()) {
     if (!arch.GetTriple().str().empty()) {
       strm.Printf("    Triple: ");
-      arch.DumpTriple(strm);
+      arch.DumpTriple(strm.AsRawOstream());
       strm.EOL();
     }
   }
 
   llvm::VersionTuple os_version = GetOSVersion();
   if (!os_version.empty()) {
     strm.Format("OS Version: {0}", os_version.getAsString());
 

lldb/source/Target/TargetList.cpp

if (num_specs > 0) {
                   !platform_arch.TripleVendorWasSpecified()) {
                 prefer_platform_arch = true;
                 platform_arch = matching_module_spec.GetArchitecture();
               }
             } else {
               StreamString platform_arch_strm;
               StreamString module_arch_strm;
 
-              platform_arch.DumpTriple(platform_arch_strm);
+              platform_arch.DumpTriple(platform_arch_strm.AsRawOstream());
               matching_module_spec.GetArchitecture().DumpTriple(
-                  module_arch_strm);
+                  module_arch_strm.AsRawOstream());
               error.SetErrorStringWithFormat(
                   "the specified architecture '%s' is not compatible with '%s' "
                   "in '%s'",
                   platform_arch_strm.GetData(), module_arch_strm.GetData(),
                   module_spec.GetFileSpec().GetPath().c_str());
               return error;
             }
           } else {

lldb/source/Utility/ArchSpec.cpp

if (GetTriple().getArch() == llvm::Triple::arm ||
     }
     // Windows on ARM is always thumb.
     if (GetTriple().isOSWindows())
       return true;
   }
   return false;
 }
 
-void ArchSpec::DumpTriple(Stream &s) const {
+void ArchSpec::DumpTriple(llvm::raw_ostream &s) const {
   const llvm::Triple &triple = GetTriple();
   llvm::StringRef arch_str = triple.getArchName();
   llvm::StringRef vendor_str = triple.getVendorName();
   llvm::StringRef os_str = triple.getOSName();
   llvm::StringRef environ_str = triple.getEnvironmentName();
 
-  s.Printf("%s-%s-%s", arch_str.empty() ? "*" : arch_str.str().c_str(),
-           vendor_str.empty() ? "*" : vendor_str.str().c_str(),
-           os_str.empty() ? "*" : os_str.str().c_str());
+  s << llvm::formatv("{0}-{1}-{2}", arch_str.empty() ? "*" : arch_str,
+                     vendor_str.empty() ? "*" : vendor_str,
+                     os_str.empty() ? "*" : os_str);
 
   if (!environ_str.empty())
-    s.Printf("-%s", environ_str.str().c_str());
+    s << "-" << environ_str;
 }

lldb/source/Utility/ProcessInfo.cpp

 
 llvm::StringRef ProcessInfo::GetNameAsStringRef() const {
   return m_executable.GetFilename().GetStringRef();
 }
 
 void ProcessInfo::Dump(Stream &s, Platform *platform) const {
   s << "Executable: " << GetName() << "\n";
   s << "Triple: ";
-  m_arch.DumpTriple(s);
+  m_arch.DumpTriple(s.AsRawOstream());
   s << "\n";
 
   s << "Arguments:\n";
   m_arguments.Dump(s);
 
   s.Format("Environment:\n{0}", m_environment);
 }
 
for (uint32_t i = 0; i < argc; i++) {
         s.Printf("arg[%u] = %s\n", i, arg);
     }
   }
 
   s.Format("{0}", m_environment);
 
   if (m_arch.IsValid()) {
     s.Printf("   arch = ");
-    m_arch.DumpTriple(s);
+    m_arch.DumpTriple(s.AsRawOstream());
     s.EOL();
   }
 
   if (UserIDIsValid()) {
     s.Format("    uid = {0,-5} ({1})\n", GetUserID(),
              resolver.GetUserName(GetUserID()).getValueOr(""));
   }
   if (GroupIDIsValid()) {

 
 void ProcessInstanceInfo::DumpAsTableRow(Stream &s, UserIDResolver &resolver,
                                          bool show_args, bool verbose) const {
   if (m_pid != LLDB_INVALID_PROCESS_ID) {
     s.Printf("%-6" PRIu64 " %-6" PRIu64 " ", m_pid, m_parent_pid);
 
     StreamString arch_strm;
     if (m_arch.IsValid())
-      m_arch.DumpTriple(arch_strm);
+      m_arch.DumpTriple(arch_strm.AsRawOstream());
 
     auto print = [&](bool (ProcessInstanceInfo::*isValid)() const,
                      uint32_t (ProcessInstanceInfo::*getID)() const,
                      llvm::Optional<llvm::StringRef> (UserIDResolver::*getName)(
                          UserIDResolver::id_t id)) {
       const char *format = "{0,-10} ";
       if (!(this->*isValid)()) {
         s.Format(format, "");