[lldb][NFCI] Stop creating additional temporary string in Log::VAPrintf

[bulbazord]

Summary

Instead of creating a std::string from the SmallString,
let's just use a std::string from the start. I initially tried to make
SmallString work but getting it right proved complicated because
LogHandler::Emit will take its StringRef parameter and touch the raw
const char * from it directly, which isn't guaranteed to be
null-terminated with a SmallString.

I changed WriteMessage to take a StringRef instead of a
const std::string & for flexibility.

[mib]

Makes sense. LGTM!

lldb/include/lldb/Utility/Log.h

private:
   llvm::sys::RWMutex m_mutex;
 
   std::shared_ptr<LogHandler> m_handler;
   std::atomic<uint32_t> m_options{0};
   std::atomic<MaskType> m_mask{0};
 
   void WriteHeader(llvm::raw_ostream &OS, llvm::StringRef file,
                    llvm::StringRef function);
-  void WriteMessage(const std::string &message);
+  void WriteMessage(llvm::StringRef message);
 
   void Format(llvm::StringRef file, llvm::StringRef function,
               const llvm::formatv_object_base &payload);
 
   std::shared_ptr<LogHandler> GetHandler() {
     llvm::sys::ScopedReader lock(m_mutex);
     return m_handler;
   }

lldb/source/Utility/Log.cpp

void Log::Printf(const char *format, ...) {
   VAPrintf(format, args);
   va_end(args);
 }
 
 // All logging eventually boils down to this function call. If we have a
 // callback registered, then we call the logging callback. If we have a valid
 // file handle, we also log to the file.
 void Log::VAPrintf(const char *format, va_list args) {
-  llvm::SmallString<64> FinalMessage;
-  llvm::raw_svector_ostream Stream(FinalMessage);
+  std::string FinalMessage;
+  llvm::raw_string_ostream Stream(FinalMessage);
   WriteHeader(Stream, "", "");
 
   llvm::SmallString<64> Content;
   lldb_private::VASprintf(Content, format, args);
 
   Stream << Content << "\n";
 
-  WriteMessage(std::string(FinalMessage.str()));
+  WriteMessage(FinalMessage);
 }
 
 // Printing of errors that are not fatal.
 void Log::Error(const char *format, ...) {
   va_list args;
   va_start(args, format);
   VAError(format, args);
   va_end(args);
void Log::WriteHeader(llvm::raw_ostream &OS, llvm::StringRef file,
   if (options.Test(LLDB_LOG_OPTION_PREPEND_FILE_FUNCTION) &&
       (!file.empty() || !function.empty())) {
     file = llvm::sys::path::filename(file).take_front(40);
     function = function.take_front(40);
     OS << llvm::formatv("{0,-60:60} ", (file + ":" + function).str());
   }
 }
 
-void Log::WriteMessage(const std::string &message) {
+void Log::WriteMessage(llvm::StringRef message) {
   // Make a copy of our stream shared pointer in case someone disables our log
   // while we are logging and releases the stream
   auto handler_sp = GetHandler();
   if (!handler_sp)
     return;
   handler_sp->Emit(message);
 }