Remove lldb streams from the Log class completely

[labath]

Summary

previously we switched to llvm streams for log output, this completes
the switch for the error streams.

I also clean up the includes and remove the unused argument from
DisableAllLogChannels().

This required adding a bit of boiler plate to convert the output in the
command interpreter, but that should go away when we switch command
results to use llvm streams as well.

[zturner]

Looks great.

tools/lldb-server/LLDBServerUtilities.cpp

59–60

How about llvm::errs() << formatv("Unable to setup logging for channel \"{0}\": {1}\n", channel, error_stream.str());

[labath]

tools/lldb-server/LLDBServerUtilities.cpp

59–60

good point. will do.

include/lldb/Core/Debugger.h

public:
 
   bool GetCloseInputOnEOF() const;
 
   void SetCloseInputOnEOF(bool b);
 
   bool EnableLog(llvm::StringRef channel,
                  llvm::ArrayRef<const char *> categories,
                  llvm::StringRef log_file, uint32_t log_options,
-                 Stream &error_stream);
+                 llvm::raw_ostream &error_stream);
 
   void SetLoggingCallback(lldb::LogOutputCallback log_callback, void *baton);
 
   //----------------------------------------------------------------------
   // Properties Functions
   //----------------------------------------------------------------------
   enum StopDisassemblyType {
     eStopDisassemblyTypeNever = 0,

include/lldb/Utility/Log.h

 //===-- Log.h ---------------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_UTILITY_LOG_H
 #define LLDB_UTILITY_LOG_H
 
 // Project includes
 #include "lldb/Utility/Flags.h"
 #include "lldb/Utility/Logging.h"
-#include "lldb/lldb-private.h"
 
 // Other libraries and framework includes
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/RWMutex.h"
 // C++ Includes
 #include <atomic>
 #include <cstdarg>
 #include <cstdint>
 // C Includes
public:
   //------------------------------------------------------------------
   static void Register(llvm::StringRef name, Channel &channel);
   static void Unregister(llvm::StringRef name);
 
   static bool
   EnableLogChannel(const std::shared_ptr<llvm::raw_ostream> &log_stream_sp,
                    uint32_t log_options, llvm::StringRef channel,
                    llvm::ArrayRef<const char *> categories,
-                   Stream &error_stream);
+                   llvm::raw_ostream &error_stream);
 
   static bool DisableLogChannel(llvm::StringRef channel,
                                 llvm::ArrayRef<const char *> categories,
-                                Stream &error_stream);
+                                llvm::raw_ostream &error_stream);
 
-  static bool ListChannelCategories(llvm::StringRef channel, Stream &stream);
+  static bool ListChannelCategories(llvm::StringRef channel, llvm::raw_ostream &stream);
 
-  static void DisableAllLogChannels(Stream *feedback_strm);
+  static void DisableAllLogChannels();
 
-  static void ListAllLogChannels(Stream *strm);
+  static void ListAllLogChannels(llvm::raw_ostream &stream);
 
   //------------------------------------------------------------------
   // Member functions
   //
   // These functions are safe to call at any time you have a Log* obtained from
   // the Channel class. If logging is disabled between you obtaining the Log
   // object and writing to it, the output will be silently discarded.
   //------------------------------------------------------------------
   Log(Channel &channel) : m_channel(channel) {}
   ~Log() = default;
 
   void PutCString(const char *cstr);
   void PutString(llvm::StringRef str);
 
   template <typename... Args>
   void Format(llvm::StringRef file, llvm::StringRef function,
               const char *format, Args &&... args) {
     Format(file, function, llvm::formatv(format, std::forward<Args>(args)...));
   }
 
-  // CLEANUP: Add llvm::raw_ostream &Stream() function.
   void Printf(const char *format, ...) __attribute__((format(printf, 2, 3)));
 
   void VAPrintf(const char *format, va_list args);
 
   void Error(const char *fmt, ...) __attribute__((format(printf, 2, 3)));
 
   void VAError(const char *format, va_list args);
 
private:
   void Enable(const std::shared_ptr<llvm::raw_ostream> &stream_sp,
               uint32_t options, uint32_t flags);
 
   void Disable(uint32_t flags);
 
   typedef llvm::StringMap<Log> ChannelMap;
   static llvm::ManagedStatic<ChannelMap> g_channel_map;
 
-  static void ListCategories(Stream &stream,
+  static void ListCategories(llvm::raw_ostream &stream,
                              const ChannelMap::value_type &entry);
-  static uint32_t GetFlags(Stream &stream, const ChannelMap::value_type &entry,
+  static uint32_t GetFlags(llvm::raw_ostream &stream, const ChannelMap::value_type &entry,
                            llvm::ArrayRef<const char *> categories);
 
-  DISALLOW_COPY_AND_ASSIGN(Log);
+  Log(const Log &) = delete;
+  void operator=(const Log &) = delete;
 };
 
 } // namespace lldb_private
 
 #define LLDB_LOG(log, ...)                                                     \
   do {                                                                         \
     ::lldb_private::Log *log_private = (log);                                  \
     if (log_private)                                                           \

include/lldb/Utility/Logging.h

 //===-- Logging.h -----------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_UTILITY_LOGGING_H
 #define LLDB_UTILITY_LOGGING_H
 
-// Project includes
-#include "lldb/lldb-private.h"
-// Other libraries and framework includes
-#include "llvm/Support/raw_ostream.h"
+#include <cstdint>
 
 //----------------------------------------------------------------------
 // Log Bits specific to logging in lldb
 //----------------------------------------------------------------------
 #define LIBLLDB_LOG_PROCESS (1u << 1)
 #define LIBLLDB_LOG_THREAD (1u << 2)
 #define LIBLLDB_LOG_DYNAMIC_LOADER (1u << 3)
 #define LIBLLDB_LOG_EVENTS (1u << 4)

 #define LIBLLDB_LOG_DEFAULT                                                    \
   (LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD | LIBLLDB_LOG_DYNAMIC_LOADER |     \
    LIBLLDB_LOG_BREAKPOINTS | LIBLLDB_LOG_WATCHPOINTS | LIBLLDB_LOG_STEP |      \
    LIBLLDB_LOG_STATE | LIBLLDB_LOG_SYMBOLS | LIBLLDB_LOG_TARGET |              \
    LIBLLDB_LOG_COMMANDS)
 
 namespace lldb_private {
 
+class Log;
+
 void LogIfAnyCategoriesSet(uint32_t mask, const char *format, ...);
 
 Log *GetLogIfAllCategoriesSet(uint32_t mask);
 
 Log *GetLogIfAnyCategoriesSet(uint32_t mask);
 
 void InitializeLog();
 
 } // namespace lldb_private
 
 #endif // LLDB_UTILITY_LOGGING_H

source/API/SBDebugger.cpp

while (categories[len] != nullptr)
     ++len;
   return llvm::makeArrayRef(categories, len);
 }
 
 bool SBDebugger::EnableLog(const char *channel, const char **categories) {
   if (m_opaque_sp) {
     uint32_t log_options =
         LLDB_LOG_OPTION_PREPEND_TIMESTAMP | LLDB_LOG_OPTION_PREPEND_THREAD_NAME;
-    StreamString errors;
+    std::string error;
+    llvm::raw_string_ostream error_stream(error);
     return m_opaque_sp->EnableLog(channel, GetCategoryArray(categories), "",
-                                  log_options, errors);
+                                  log_options, error_stream);
   } else
     return false;
 }
 
 void SBDebugger::SetLoggingCallback(lldb::LogOutputCallback log_callback,
                                     void *baton) {
   if (m_opaque_sp) {
     return m_opaque_sp->SetLoggingCallback(log_callback, baton);
   }
 }

source/Commands/CommandObjectLog.cpp

bool DoExecute(Args &args, CommandReturnObject &result) override {
     // Store into a std::string since we're about to shift the channel off.
     const std::string channel = args[0].ref;
     args.Shift(); // Shift off the channel
     char log_file[PATH_MAX];
     if (m_options.log_file)
       m_options.log_file.GetPath(log_file, sizeof(log_file));
     else
       log_file[0] = '\0';
+
+    std::string error;
+    llvm::raw_string_ostream error_stream(error);
     bool success = m_interpreter.GetDebugger().EnableLog(
         channel, args.GetArgumentArrayRef(), log_file, m_options.log_options,
-        result.GetErrorStream());
+        error_stream);
+    result.GetErrorStream() << error_stream.str();
+
     if (success)
       result.SetStatus(eReturnStatusSuccessFinishNoResult);
     else
       result.SetStatus(eReturnStatusFailed);
     return result.Succeeded();
   }
 
   CommandOptions m_options;
if (args.empty()) {
           "%s takes a log channel and one or more log types.\n",
           m_cmd_name.c_str());
       return false;
     }
 
     const std::string channel = args[0].ref;
     args.Shift(); // Shift off the channel
     if (channel == "all") {
-      Log::DisableAllLogChannels(&result.GetErrorStream());
+      Log::DisableAllLogChannels();
       result.SetStatus(eReturnStatusSuccessFinishNoResult);
     } else {
+      std::string error;
+      llvm::raw_string_ostream error_stream(error);
       if (Log::DisableLogChannel(channel, args.GetArgumentArrayRef(),
-                                 result.GetErrorStream()))
+                                 error_stream))
         result.SetStatus(eReturnStatusSuccessFinishNoResult);
+      result.GetErrorStream() << error_stream.str();
     }
     return result.Succeeded();
   }
 };
 
 class CommandObjectLogList : public CommandObjectParsed {
 public:
   //------------------------------------------------------------------
CommandObjectLogList(CommandInterpreter &interpreter)
     // Push the data for the first argument into the m_arguments vector.
     m_arguments.push_back(arg);
   }
 
   ~CommandObjectLogList() override = default;
 
 protected:
   bool DoExecute(Args &args, CommandReturnObject &result) override {
+    std::string output;
+    llvm::raw_string_ostream output_stream(output);
     if (args.empty()) {
-      Log::ListAllLogChannels(&result.GetOutputStream());
+      Log::ListAllLogChannels(output_stream);
       result.SetStatus(eReturnStatusSuccessFinishResult);
     } else {
       bool success = true;
       for (const auto &entry : args.entries())
-        success = success && Log::ListChannelCategories(
-                                 entry.ref, result.GetOutputStream());
+        success =
+            success && Log::ListChannelCategories(entry.ref, output_stream);
       if (success)
         result.SetStatus(eReturnStatusSuccessFinishResult);
     }
+    result.GetOutputStream() << output_stream.str();
     return result.Succeeded();
   }
 };
 
 class CommandObjectLogTimer : public CommandObjectParsed {
 public:
   //------------------------------------------------------------------
   // Constructors and Destructors

source/Core/Debugger.cpp

void Debugger::SetLoggingCallback(lldb::LogOutputCallback log_callback,
   // open logging streams, I just redirect everything from here on out to the
   // callback.
   m_log_callback_stream_sp.reset(new StreamCallback(log_callback, baton));
 }
 
 bool Debugger::EnableLog(llvm::StringRef channel,
                          llvm::ArrayRef<const char *> categories,
                          llvm::StringRef log_file, uint32_t log_options,
-                         Stream &error_stream) {
+                         llvm::raw_ostream &error_stream) {
   const bool should_close = true;
   const bool unbuffered = true;
 
   std::shared_ptr<llvm::raw_ostream> log_stream_sp;
   if (m_log_callback_stream_sp) {
     log_stream_sp = m_log_callback_stream_sp;
     // For now when using the callback mode you always get thread & timestamp.
     log_options |=
         LLDB_LOG_OPTION_PREPEND_TIMESTAMP | LLDB_LOG_OPTION_PREPEND_THREAD_NAME;
   } else if (log_file.empty()) {
     log_stream_sp = std::make_shared<llvm::raw_fd_ostream>(
         GetOutputFile()->GetFile().GetDescriptor(), !should_close, unbuffered);
   } else {
     auto pos = m_log_streams.find(log_file);
     if (pos != m_log_streams.end())
       log_stream_sp = pos->second.lock();
     if (!log_stream_sp) {
       llvm::sys::fs::OpenFlags flags = llvm::sys::fs::F_Text;
       if (log_options & LLDB_LOG_OPTION_APPEND)
         flags |= llvm::sys::fs::F_Append;
       int FD;
       if (std::error_code ec =
               llvm::sys::fs::openFileForWrite(log_file, FD, flags)) {
-        error_stream.Format("Unable to open log file: {0}", ec.message());
+        error_stream << "Unable to open log file: " << ec.message();
         return false;
       }
       log_stream_sp.reset(
           new llvm::raw_fd_ostream(FD, should_close, unbuffered));
       m_log_streams[log_file] = log_stream_sp;
     }
   }
   assert(log_stream_sp);

source/Host/posix/ProcessLauncherPosixFork.cpp

static void DupDescriptor(int error_fd, const FileSpec &file_spec, int fd,
 
   ::close(target_fd);
   return;
 }
 
 static void LLVM_ATTRIBUTE_NORETURN ChildFunc(int error_fd,
                                               const ProcessLaunchInfo &info) {
   // First, make sure we disable all logging. If we are logging to stdout, our
-  // logs can be
-  // mistaken for inferior output.
-  Log::DisableAllLogChannels(nullptr);
+  // logs can be mistaken for inferior output.
+  Log::DisableAllLogChannels();
 
   // Do not inherit setgid powers.
   if (setgid(getgid()) != 0)
     ExitWithError(error_fd, "setgid");
 
   if (info.GetFlags().Test(eLaunchFlagLaunchInSeparateProcessGroup)) {
     if (setpgid(0, 0) != 0)
       ExitWithError(error_fd, "setpgid");

source/Initialization/SystemInitializerCommon.cpp

#if defined(__APPLE__)
   ObjectFileMachO::Terminate();
 #endif
 
 #if defined(_MSC_VER)
   ProcessWindowsLog::Terminate();
 #endif
 
   HostInfo::Terminate();
-  Log::DisableAllLogChannels(nullptr);
+  Log::DisableAllLogChannels();
 }

source/Plugins/Process/POSIX/ProcessPOSIXLog.cpp

 //===-- ProcessPOSIXLog.cpp ---------------------------------------*- C++
 //-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "ProcessPOSIXLog.h"
 
 #include "llvm/Support/Threading.h"
 
-using namespace lldb;
 using namespace lldb_private;
 
 static constexpr Log::Category g_categories[] = {
   {{"break"}, {"log breakpoints"}, POSIX_LOG_BREAKPOINTS},
   {{"memory"}, {"log memory reads and writes"}, POSIX_LOG_MEMORY},
   {{"process"}, {"log process events and activities"}, POSIX_LOG_PROCESS},
   {{"ptrace"}, {"log all calls to ptrace"}, POSIX_LOG_PTRACE},
   {{"registers"}, {"log register read/writes"}, POSIX_LOG_REGISTERS},

source/Plugins/SymbolFile/DWARF/LogChannelDWARF.cpp

 //===-- LogChannelDWARF.cpp ------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "LogChannelDWARF.h"
 
-using namespace lldb;
 using namespace lldb_private;
 
 static constexpr Log::Category g_categories[] = {
     {{"aranges"},
      {"log the parsing of .debug_aranges"},
      DWARF_LOG_DEBUG_ARANGES},
     {{"comp"},
      {"log insertions of object files into DWARF debug maps"},

source/Utility/Log.cpp

 //===-- Log.cpp -------------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // Project includes
 #include "lldb/Utility/Log.h"
-
-#include "lldb/Utility/NameMatches.h"
-#include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/VASPrintf.h"
+#include "lldb/lldb-types.h"
 
 // Other libraries and framework includes
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/Chrono.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/Threading.h"
 #include "llvm/Support/raw_ostream.h"
 
 // C Includes
 // C++ Includes
 #include <cstdarg>
 #include <cstdio>
 #include <cstdlib>
 #include <map>
 #include <mutex>
 #include <string>
 
-using namespace lldb;
 using namespace lldb_private;
 
 llvm::ManagedStatic<Log::ChannelMap> Log::g_channel_map;
 
-void Log::ListCategories(Stream &stream, const ChannelMap::value_type &entry) {
-  stream.Format("Logging categories for '{0}':\n", entry.first());
-  stream.Format("  all - all available logging categories\n");
-  stream.Format("  default - default set of logging categories\n");
+void Log::ListCategories(llvm::raw_ostream &stream, const ChannelMap::value_type &entry) {
+  stream << llvm::formatv("Logging categories for '{0}':\n", entry.first());
+  stream << "  all - all available logging categories\n";
+  stream << "  default - default set of logging categories\n";
   for (const auto &category : entry.second.m_channel.categories)
-    stream.Format("  {0} - {1}\n", category.name, category.description);
+    stream << llvm::formatv("  {0} - {1}\n", category.name,
+                            category.description);
 }
 
-uint32_t Log::GetFlags(Stream &stream, const ChannelMap::value_type &entry,
+uint32_t Log::GetFlags(llvm::raw_ostream &stream, const ChannelMap::value_type &entry,
                          llvm::ArrayRef<const char *> categories) {
   bool list_categories = false;
   uint32_t flags = 0;
   for (const char *category : categories) {
     if (llvm::StringRef("all").equals_lower(category)) {
       flags |= UINT32_MAX;
       continue;
     }
     if (llvm::StringRef("default").equals_lower(category)) {
       flags |= entry.second.m_channel.default_flags;
       continue;
     }
     auto cat = llvm::find_if(
         entry.second.m_channel.categories,
         [&](const Log::Category &c) { return c.name.equals_lower(category); });
     if (cat != entry.second.m_channel.categories.end()) {
       flags |= cat->flag;
       continue;
     }
-    stream.Format("error: unrecognized log category '{0}'\n", category);
+    stream << llvm::formatv("error: unrecognized log category '{0}'\n",
+                            category);
     list_categories = true;
   }
   if (list_categories)
     ListCategories(stream, entry);
   return flags;
 }
 
 void Log::Enable(const std::shared_ptr<llvm::raw_ostream> &stream_sp,
void Log::Unregister(llvm::StringRef name) {
   assert(iter != g_channel_map->end());
   iter->second.Disable(UINT32_MAX);
   g_channel_map->erase(iter);
 }
 
 bool Log::EnableLogChannel(
     const std::shared_ptr<llvm::raw_ostream> &log_stream_sp,
     uint32_t log_options, llvm::StringRef channel,
-    llvm::ArrayRef<const char *> categories, Stream &error_stream) {
+    llvm::ArrayRef<const char *> categories, llvm::raw_ostream &error_stream) {
   auto iter = g_channel_map->find(channel);
   if (iter == g_channel_map->end()) {
-    error_stream.Format("Invalid log channel '{0}'.\n", channel);
+    error_stream << llvm::formatv("Invalid log channel '{0}'.\n", channel);
     return false;
   }
   uint32_t flags = categories.empty()
                        ? iter->second.m_channel.default_flags
                        : GetFlags(error_stream, *iter, categories);
   iter->second.Enable(log_stream_sp, log_options, flags);
   return true;
 }
 
 bool Log::DisableLogChannel(llvm::StringRef channel,
                             llvm::ArrayRef<const char *> categories,
-                            Stream &error_stream) {
+                            llvm::raw_ostream &error_stream) {
   auto iter = g_channel_map->find(channel);
   if (iter == g_channel_map->end()) {
-    error_stream.Format("Invalid log channel '{0}'.\n", channel);
+    error_stream << llvm::formatv("Invalid log channel '{0}'.\n", channel);
     return false;
   }
   uint32_t flags = categories.empty()
                        ? UINT32_MAX
                        : GetFlags(error_stream, *iter, categories);
   iter->second.Disable(flags);
   return true;
 }
 
-bool Log::ListChannelCategories(llvm::StringRef channel, Stream &stream) {
+bool Log::ListChannelCategories(llvm::StringRef channel,
+                                llvm::raw_ostream &stream) {
   auto ch = g_channel_map->find(channel);
   if (ch == g_channel_map->end()) {
-    stream.Format("Invalid log channel '{0}'.\n", channel);
+    stream << llvm::formatv("Invalid log channel '{0}'.\n", channel);
     return false;
   }
   ListCategories(stream, *ch);
   return true;
 }
 
-void Log::DisableAllLogChannels(Stream *feedback_strm) {
+void Log::DisableAllLogChannels() {
   for (auto &entry : *g_channel_map)
     entry.second.Disable(UINT32_MAX);
 }
 
-void Log::ListAllLogChannels(Stream *strm) {
+void Log::ListAllLogChannels(llvm::raw_ostream &stream) {
   if (g_channel_map->empty()) {
-    strm->PutCString("No logging channels are currently registered.\n");
+    stream << "No logging channels are currently registered.\n";
     return;
   }
 
   for (const auto &channel : *g_channel_map)
-    ListCategories(*strm, channel);
+    ListCategories(stream, channel);
 }
+
 bool Log::GetVerbose() const {
   return m_options.load(std::memory_order_relaxed) & LLDB_LOG_OPTION_VERBOSE;
 }
 
 void Log::WriteHeader(llvm::raw_ostream &OS, llvm::StringRef file,
                       llvm::StringRef function) {
   Flags options = GetOptions();
   static uint32_t g_sequence_id = 0;

source/Utility/Logging.cpp

 //===-- Logging.cpp ---------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Utility/Logging.h"
-
-// C Includes
-// C++ Includes
-#include <atomic>
-#include <cstring>
-
-// Other libraries and framework includes
-// Project includes
 #include "lldb/Utility/Log.h"
 
-using namespace lldb;
 using namespace lldb_private;
 
 static constexpr Log::Category g_categories[] = {
   {{"api"}, {"log API calls and return values"}, LIBLLDB_LOG_API},
   {{"break"}, {"log breakpoints"}, LIBLLDB_LOG_BREAKPOINTS},
   {{"commands"}, {"log command argument parsing"}, LIBLLDB_LOG_COMMANDS},
   {{"comm"}, {"log communication activities"}, LIBLLDB_LOG_COMMUNICATION},
   {{"conn"}, {"log connection details"}, LIBLLDB_LOG_CONNECTION},

tools/lldb-server/LLDBServerUtilities.cpp

bool LLDBServerUtilities::SetupLogging(const std::string &log_file,
                                        const StringRef &log_channels,
                                        uint32_t log_options) {
 
   auto log_stream_sp = GetLogStream(log_file);
 
   SmallVector<StringRef, 32> channel_array;
   log_channels.split(channel_array, ":", /*MaxSplit*/ -1, /*KeepEmpty*/ false);
   for (auto channel_with_categories : channel_array) {
-    StreamString error_stream;
+    std::string error;
+    llvm::raw_string_ostream error_stream(error);
     Args channel_then_categories(channel_with_categories);
     std::string channel(channel_then_categories.GetArgumentAtIndex(0));
     channel_then_categories.Shift(); // Shift off the channel
 
     bool success = Log::EnableLogChannel(
         log_stream_sp, log_options, channel,
         channel_then_categories.GetArgumentArrayRef(), error_stream);
     if (!success) {
-      fprintf(stderr, "Unable to open log file '%s' for channel \"%s\"\n",
-              log_file.c_str(), channel_with_categories.str().c_str());
+      fprintf(stderr, "Unable to setup logging for channel \"%s\": %s",
+              channel.c_str(), error_stream.str().c_str());
       return false;
     }
   }
   return true;
 }

unittests/Utility/LogTest.cpp

 static constexpr Log::Category test_categories[] = {
     {{"foo"}, {"log foo"}, FOO}, {{"bar"}, {"log bar"}, BAR},
 };
 static constexpr uint32_t default_flags = FOO;
 
 static Log::Channel test_channel(test_categories, default_flags);
 
 struct LogChannelTest : public ::testing::Test {
-  void TearDown() override { Log::DisableAllLogChannels(nullptr); }
+  void TearDown() override { Log::DisableAllLogChannels(); }
 
   static void SetUpTestCase() {
     Log::Register("chan", test_channel);
   }
 
   static void TearDownTestCase() {
     Log::Unregister("chan");
     llvm::llvm_shutdown();
   }
 };
 
+// Wrap enable, disable and list functions to make them easier to test.
+static bool EnableChannel(std::shared_ptr<llvm::raw_ostream> stream_sp,
+                          uint32_t log_options, llvm::StringRef channel,
+                          llvm::ArrayRef<const char *> categories,
+                          std::string &error) {
+  error.clear();
+  llvm::raw_string_ostream error_stream(error);
+  return Log::EnableLogChannel(stream_sp, log_options, channel, categories,
+                               error_stream);
+}
+
+static bool DisableChannel(llvm::StringRef channel,
+                           llvm::ArrayRef<const char *> categories,
+                           std::string &error) {
+  error.clear();
+  llvm::raw_string_ostream error_stream(error);
+  return Log::DisableLogChannel(channel, categories, error_stream);
+}
+
+static bool ListCategories(llvm::StringRef channel, std::string &result) {
+  result.clear();
+  llvm::raw_string_ostream result_stream(result);
+  return Log::ListChannelCategories(channel, result_stream);
+}
+
 TEST(LogTest, LLDB_LOG_nullptr) {
   Log *log = nullptr;
   LLDB_LOG(log, "{0}", 0); // Shouldn't crash
 }
 
 TEST(LogTest, Register) {
   llvm::llvm_shutdown_obj obj;
   Log::Register("chan", test_channel);
   Log::Unregister("chan");
   Log::Register("chan", test_channel);
   Log::Unregister("chan");
 }
 
 TEST(LogTest, Unregister) {
   llvm::llvm_shutdown_obj obj;
   Log::Register("chan", test_channel);
   EXPECT_EQ(nullptr, test_channel.GetLogIfAny(FOO));
-  const char *cat1[] = {"foo"};
   std::string message;
   std::shared_ptr<llvm::raw_string_ostream> stream_sp(
       new llvm::raw_string_ostream(message));
-  StreamString err;
-  EXPECT_TRUE(Log::EnableLogChannel(stream_sp, 0, "chan", cat1, err));
+  EXPECT_TRUE(Log::EnableLogChannel(stream_sp, 0, "chan", {"foo"}, llvm::nulls()));
   EXPECT_NE(nullptr, test_channel.GetLogIfAny(FOO));
   Log::Unregister("chan");
   EXPECT_EQ(nullptr, test_channel.GetLogIfAny(FOO));
 }
 
 TEST_F(LogChannelTest, Enable) {
   EXPECT_EQ(nullptr, test_channel.GetLogIfAll(FOO));
   std::string message;
   std::shared_ptr<llvm::raw_string_ostream> stream_sp(
       new llvm::raw_string_ostream(message));
-  StreamString err;
-  EXPECT_FALSE(Log::EnableLogChannel(stream_sp, 0, "chanchan", {}, err));
-  EXPECT_EQ("Invalid log channel 'chanchan'.\n", err.GetString());
-  err.Clear();
+  std::string error;
+  ASSERT_FALSE(EnableChannel(stream_sp, 0, "chanchan", {}, error));
+  EXPECT_EQ("Invalid log channel 'chanchan'.\n", error);
 
-  EXPECT_TRUE(Log::EnableLogChannel(stream_sp, 0, "chan", {}, err));
-  EXPECT_EQ("", err.GetString()) << "err: " << err.GetString().str();
+  EXPECT_TRUE(EnableChannel(stream_sp, 0, "chan", {}, error));
   EXPECT_NE(nullptr, test_channel.GetLogIfAll(FOO));
   EXPECT_EQ(nullptr, test_channel.GetLogIfAll(BAR));
 
-  const char *cat2[] = {"bar"};
-  EXPECT_TRUE(Log::EnableLogChannel(stream_sp, 0, "chan", cat2, err));
+  EXPECT_TRUE(EnableChannel(stream_sp, 0, "chan", {"bar"}, error));
   EXPECT_NE(nullptr, test_channel.GetLogIfAll(FOO | BAR));
 
-  const char *cat3[] = {"baz"};
-  EXPECT_TRUE(Log::EnableLogChannel(stream_sp, 0, "chan", cat3, err));
-  EXPECT_TRUE(err.GetString().contains("unrecognized log category 'baz'"))
-      << "err: " << err.GetString().str();
+  EXPECT_TRUE(EnableChannel(stream_sp, 0, "chan", {"baz"}, error));
+  EXPECT_NE(std::string::npos, error.find("unrecognized log category 'baz'"))
+      << "error: " << error;
   EXPECT_NE(nullptr, test_channel.GetLogIfAll(FOO | BAR));
 }
 
 TEST_F(LogChannelTest, EnableOptions) {
   EXPECT_EQ(nullptr, test_channel.GetLogIfAll(FOO));
   std::string message;
   std::shared_ptr<llvm::raw_string_ostream> stream_sp(
       new llvm::raw_string_ostream(message));
-  StreamString err;
-  EXPECT_TRUE(Log::EnableLogChannel(stream_sp, LLDB_LOG_OPTION_VERBOSE, "chan",
-                                    {}, err));
+  std::string error;
+  EXPECT_TRUE(
+      EnableChannel(stream_sp, LLDB_LOG_OPTION_VERBOSE, "chan", {}, error));
 
   Log *log = test_channel.GetLogIfAll(FOO);
   ASSERT_NE(nullptr, log);
   EXPECT_TRUE(log->GetVerbose());
 }
 
 TEST_F(LogChannelTest, Disable) {
   EXPECT_EQ(nullptr, test_channel.GetLogIfAll(FOO));
-  const char *cat12[] = {"foo", "bar"};
   std::string message;
   std::shared_ptr<llvm::raw_string_ostream> stream_sp(
       new llvm::raw_string_ostream(message));
-  StreamString err;
-  EXPECT_TRUE(Log::EnableLogChannel(stream_sp, 0, "chan", cat12, err));
+  std::string error;
+  EXPECT_TRUE(EnableChannel(stream_sp, 0, "chan", {"foo", "bar"}, error));
   EXPECT_NE(nullptr, test_channel.GetLogIfAll(FOO | BAR));
 
-  const char *cat2[] = {"bar"};
-  EXPECT_TRUE(Log::DisableLogChannel("chan", cat2, err));
+  EXPECT_TRUE(DisableChannel("chan", {"bar"}, error));
   EXPECT_NE(nullptr, test_channel.GetLogIfAll(FOO));
   EXPECT_EQ(nullptr, test_channel.GetLogIfAll(BAR));
 
-  const char *cat3[] = {"baz"};
-  EXPECT_TRUE(Log::DisableLogChannel("chan", cat3, err));
-  EXPECT_TRUE(err.GetString().contains("unrecognized log category 'baz'"))
-      << "err: " << err.GetString().str();
+  EXPECT_TRUE(DisableChannel("chan", {"baz"}, error));
+  EXPECT_NE(std::string::npos, error.find("unrecognized log category 'baz'"))
+      << "error: " << error;
   EXPECT_NE(nullptr, test_channel.GetLogIfAll(FOO));
   EXPECT_EQ(nullptr, test_channel.GetLogIfAll(BAR));
-  err.Clear();
 
-  EXPECT_TRUE(Log::DisableLogChannel("chan", {}, err));
+  EXPECT_TRUE(DisableChannel("chan", {}, error));
   EXPECT_EQ(nullptr, test_channel.GetLogIfAny(FOO | BAR));
 }
 
 TEST_F(LogChannelTest, List) {
-  StreamString str;
-  EXPECT_TRUE(Log::ListChannelCategories("chan", str));
+  std::string list;
+  EXPECT_TRUE(ListCategories("chan", list));
   std::string expected =
       R"(Logging categories for 'chan':
   all - all available logging categories
   default - default set of logging categories
   foo - log foo
   bar - log bar
 )";
-  EXPECT_EQ(expected, str.GetString().str());
-  str.Clear();
+  EXPECT_EQ(expected, list);
 
-  EXPECT_FALSE(Log::ListChannelCategories("chanchan", str));
-  EXPECT_EQ("Invalid log channel 'chanchan'.\n", str.GetString().str());
+  EXPECT_FALSE(ListCategories("chanchan", list));
+  EXPECT_EQ("Invalid log channel 'chanchan'.\n", list);
 }
 
 static std::string GetLogString(uint32_t log_options, const char *format,
                                 int arg) {
   std::string message;
   std::shared_ptr<llvm::raw_string_ostream> stream_sp(
       new llvm::raw_string_ostream(message));
-  StreamString err;
-  EXPECT_TRUE(Log::EnableLogChannel(stream_sp, log_options, "chan", {}, err));
+  std::string error;
+  llvm::raw_string_ostream error_stream(error);
+  EXPECT_TRUE(
+      Log::EnableLogChannel(stream_sp, log_options, "chan", {}, error_stream));
 
   Log *log = test_channel.GetLogIfAll(FOO);
   EXPECT_NE(nullptr, log);
 
   LLDB_LOG(log, format, arg);
-  EXPECT_TRUE(Log::DisableLogChannel("chan", {}, err));
+  EXPECT_TRUE(Log::DisableLogChannel("chan", {}, error_stream));
 
   return stream_sp->str();
 }
 
 TEST_F(LogChannelTest, log_options) {
   EXPECT_EQ("Hello World 47\n", GetLogString(0, "Hello World {0}", 47));
   EXPECT_EQ("Hello World 47\n",
             GetLogString(LLDB_LOG_OPTION_THREADSAFE, "Hello World {0}", 47));

 }
 
 TEST_F(LogChannelTest, LogThread) {
   // Test that we are able to concurrently write to a log channel and disable
   // it.
   std::string message;
   std::shared_ptr<llvm::raw_string_ostream> stream_sp(
       new llvm::raw_string_ostream(message));
-  StreamString err;
-  EXPECT_TRUE(Log::EnableLogChannel(stream_sp, 0, "chan", {}, err));
+  std::string err;
+  EXPECT_TRUE(EnableChannel(stream_sp, 0, "chan", {}, err));
 
   Log *log = test_channel.GetLogIfAll(FOO);
 
   // Start logging on one thread. Concurrently, try disabling the log channel.
   std::thread log_thread([log] { LLDB_LOG(log, "Hello World"); });
-  EXPECT_TRUE(Log::DisableLogChannel("chan", {}, err));
+  EXPECT_TRUE(DisableChannel("chan", {}, err));
   log_thread.join();
 
   // The log thread either managed to write to the log in time, or it didn't. In
   // either case, we should not trip any undefined behavior (run the test under
   // TSAN to verify this).
   EXPECT_TRUE(stream_sp->str() == "" || stream_sp->str() == "Hello World\n")
       << "str(): " << stream_sp->str();
 }
 
 TEST_F(LogChannelTest, LogVerboseThread) {
   // Test that we are able to concurrently check the verbose flag of a log
   // channel and enable it.
   std::string message;
   std::shared_ptr<llvm::raw_string_ostream> stream_sp(
       new llvm::raw_string_ostream(message));
-  StreamString err;
-  EXPECT_TRUE(Log::EnableLogChannel(stream_sp, 0, "chan", {}, err));
+  std::string err;
+  EXPECT_TRUE(EnableChannel(stream_sp, 0, "chan", {}, err));
 
   Log *log = test_channel.GetLogIfAll(FOO);
 
   // Start logging on one thread. Concurrently, try enabling the log channel
   // (with different log options).
   std::thread log_thread([log] { LLDB_LOGV(log, "Hello World"); });
-  EXPECT_TRUE(Log::EnableLogChannel(stream_sp, LLDB_LOG_OPTION_VERBOSE, "chan",
+  EXPECT_TRUE(EnableChannel(stream_sp, LLDB_LOG_OPTION_VERBOSE, "chan",
                                     {}, err));
   log_thread.join();
-  EXPECT_TRUE(Log::DisableLogChannel("chan", {}, err));
+  EXPECT_TRUE(DisableChannel("chan", {}, err));
 
   // The log thread either managed to write to the log, or it didn't. In either
   // case, we should not trip any undefined behavior (run the test under TSAN to
   // verify this).
   EXPECT_TRUE(stream_sp->str() == "" || stream_sp->str() == "Hello World\n")
       << "str(): " << stream_sp->str();
 }
 
 TEST_F(LogChannelTest, LogGetLogThread) {
   // Test that we are able to concurrently get mask of a Log object and disable
   // it.
   std::string message;
   std::shared_ptr<llvm::raw_string_ostream> stream_sp(
       new llvm::raw_string_ostream(message));
-  StreamString err;
-  EXPECT_TRUE(Log::EnableLogChannel(stream_sp, 0, "chan", {}, err));
+  std::string err;
+  EXPECT_TRUE(EnableChannel(stream_sp, 0, "chan", {}, err));
   Log *log = test_channel.GetLogIfAll(FOO);
 
   // Try fetching the log on one thread. Concurrently, try disabling the log
   // channel.
   uint32_t mask;
   std::thread log_thread([log, &mask] { mask = log->GetMask().Get(); });
-  EXPECT_TRUE(Log::DisableLogChannel("chan", {}, err));
+  EXPECT_TRUE(DisableChannel("chan", {}, err));
   log_thread.join();
 
   // The mask should be either zero of "FOO". In either case, we should not trip
   // any undefined behavior (run the test under TSAN to verify this).
   EXPECT_TRUE(mask == 0 || mask == FOO) << "mask: " << mask;
 }