[lldb] Remove __FUNCTION__ from log messages in lldbHost (NFC)

[JDevlieghere]

Summary

LLDB's logging infrastructure supports prepending log messages with the name of the file and function that generates the log (see help log enable). Therefore it's unnecessary to include the current __FUNCTION__ in the log message itself. This patch removes __FUNCTION__ from log messages in the Host library.

[bulbazord]

The change itself looks fine and is fairly mechanical. Easy to verify.

One thing that I see here is we're treating the result of llvm::StringRef::data() as a c-string which isn't guaranteed to be true. That makes me a little nervous. As frustrating as temporary allocations are, the right thing to do would be something like foo.str().c_str() where foo is a StringRef. If you think it's appropriate, can you change those instances in this patch? If not we can do it in a follow-up.

[mib]

LGTM! Are you considering doing it for the rest of the codebase as well ? That would be very nice :)

[JDevlieghere]

In D151762#4382679, @mib wrote:

LGTM! Are you considering doing it for the rest of the codebase as well ? That would be very nice :)

Yup, that's the goal. I wanted to gather some initial feedback before I go through the other libs.

[JDevlieghere]

Use LLDB_LOG when StringRefs are involved.

lldb/source/Host/common/HostInfoBase.cpp

bool HostInfoBase::ComputePathRelativeToLibrary(FileSpec &file_spec,
                                                 llvm::StringRef dir) {
   Log *log = GetLog(LLDBLog::Host);
 
   FileSpec lldb_file_spec = GetShlibDir();
   if (!lldb_file_spec)
     return false;
 
   std::string raw_path = lldb_file_spec.GetPath();
-  LLDB_LOGF(log,
-            "HostInfo::%s() attempting to "
-            "derive the path %s relative to liblldb install path: %s",
-            __FUNCTION__, dir.data(), raw_path.c_str());
+  LLDB_LOGF(
+      log,
+      "Attempting to derive the path %s relative to liblldb install path: %s",
+      dir.data(), raw_path.c_str());
 
   // Drop bin (windows) or lib
   llvm::StringRef parent_path = llvm::sys::path::parent_path(raw_path);
   if (parent_path.empty()) {
-    LLDB_LOGF(log,
-              "HostInfo::%s() failed to find liblldb within the shared "
-              "lib path",
-              __FUNCTION__);
+    LLDB_LOGF(log, "Failed to find liblldb within the shared lib path");
     return false;
   }
 
   raw_path = (parent_path + dir).str();
-  LLDB_LOGF(log, "HostInfo::%s() derived the path as: %s", __FUNCTION__,
-            raw_path.c_str());
+  LLDB_LOGF(log, "Derived the path as: %s", raw_path.c_str());
   file_spec.SetDirectory(raw_path);
   return (bool)file_spec.GetDirectory();
 }
 
 bool HostInfoBase::ComputeSharedLibraryDirectory(FileSpec &file_spec) {
   // To get paths related to LLDB we get the path to the executable that
   // contains this function. On MacOSX this will be "LLDB.framework/.../LLDB".
   // On other posix systems, we will get .../lib(64|32)?/liblldb.so.

lldb/source/Host/common/NativeRegisterContext.cpp

const char *NativeRegisterContext::GetRegisterSetNameForRegisterAtIndex(
   return nullptr;
 }
 
 lldb::addr_t NativeRegisterContext::GetPC(lldb::addr_t fail_value) {
   Log *log = GetLog(LLDBLog::Thread);
 
   uint32_t reg = ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric,
                                                      LLDB_REGNUM_GENERIC_PC);
-  LLDB_LOGF(log,
-            "NativeRegisterContext::%s using reg index %" PRIu32
-            " (default %" PRIu64 ")",
-            __FUNCTION__, reg, fail_value);
+  LLDB_LOGF(log, "Using reg index %" PRIu32 " (default %" PRIu64 ")", reg,
+            fail_value);
 
   const uint64_t retval = ReadRegisterAsUnsigned(reg, fail_value);
 
-  LLDB_LOGF(log, "NativeRegisterContext::%s " PRIu32 " retval %" PRIu64,
-            __FUNCTION__, retval);
+  LLDB_LOGF(log, PRIu32 " retval %" PRIu64, retval);
 
   return retval;
 }
 
 lldb::addr_t
 NativeRegisterContext::GetPCfromBreakpointLocation(lldb::addr_t fail_value) {
   return GetPC(fail_value);
 }
NativeRegisterContext::ReadRegisterAsUnsigned(const RegisterInfo *reg_info,
                                               lldb::addr_t fail_value) {
   Log *log = GetLog(LLDBLog::Thread);
 
   if (reg_info) {
     RegisterValue value;
     Status error = ReadRegister(reg_info, value);
     if (error.Success()) {
       LLDB_LOGF(log,
-                "NativeRegisterContext::%s ReadRegister() succeeded, value "
+                "Read register succeeded: value "
                 "%" PRIu64,
-                __FUNCTION__, value.GetAsUInt64());
+                value.GetAsUInt64());
       return value.GetAsUInt64();
     } else {
-      LLDB_LOGF(log,
-                "NativeRegisterContext::%s ReadRegister() failed, error %s",
-                __FUNCTION__, error.AsCString());
+      LLDB_LOGF(log, "Read register failed: error %s", error.AsCString());
     }
   } else {
-    LLDB_LOGF(log, "NativeRegisterContext::%s ReadRegister() null reg_info",
-              __FUNCTION__);
+    LLDB_LOGF(log, "Read register failed: null reg_info");
   }
   return fail_value;
 }
 
 Status NativeRegisterContext::WriteRegisterFromUnsigned(uint32_t reg,
                                                         uint64_t uval) {
   if (reg == LLDB_INVALID_REGNUM)
-    return Status("NativeRegisterContext::%s (): reg is invalid", __FUNCTION__);
+    return Status("Write register failed: reg is invalid");
   return WriteRegisterFromUnsigned(GetRegisterInfoAtIndex(reg), uval);
 }
 
 Status
 NativeRegisterContext::WriteRegisterFromUnsigned(const RegisterInfo *reg_info,
                                                  uint64_t uval) {
   assert(reg_info);
   if (!reg_info)

lldb/source/Host/common/TCPSocket.cpp

Status TCPSocket::CreateSocket(int domain) {
   m_socket = Socket::CreateSocket(domain, kType, IPPROTO_TCP,
                                   m_child_processes_inherit, error);
   return error;
 }
 
 Status TCPSocket::Connect(llvm::StringRef name) {
 
   Log *log = GetLog(LLDBLog::Communication);
-  LLDB_LOGF(log, "TCPSocket::%s (host/port = %s)", __FUNCTION__, name.data());
+  LLDB_LOGF(log, "Connect to host/port %s", name.data());
 
   Status error;
   llvm::Expected<HostAndPort> host_port = DecodeHostAndPort(name);
   if (!host_port)
     return Status(host_port.takeError());
 
   std::vector<SocketAddress> addresses =
       SocketAddress::GetAddressInfo(host_port->hostname.c_str(), nullptr,
Status TCPSocket::Connect(llvm::StringRef name) {
   }
 
   error.SetErrorString("Failed to connect port");
   return error;
 }
 
 Status TCPSocket::Listen(llvm::StringRef name, int backlog) {
   Log *log = GetLog(LLDBLog::Connection);
-  LLDB_LOGF(log, "TCPSocket::%s (%s)", __FUNCTION__, name.data());
+  LLDB_LOGF(log, "Listen to %s", name.data());
 
   Status error;
   llvm::Expected<HostAndPort> host_port = DecodeHostAndPort(name);
   if (!host_port)
     return Status(host_port.takeError());
 
   if (host_port->hostname == "*")
     host_port->hostname = "0.0.0.0";

lldb/source/Host/macosx/objcxx/HostInfoMacOSX.mm

#endif
     // It is not going to work to do it by the executable path either,
     // as in the case of a python script, the executable is python, not
     // the lldb driver.
     raw_path.append("/../bin");
     FileSpec support_dir_spec(raw_path);
     FileSystem::Instance().Resolve(support_dir_spec);
     if (!FileSystem::Instance().IsDirectory(support_dir_spec)) {
       Log *log = GetLog(LLDBLog::Host);
-      LLDB_LOGF(log, "HostInfoMacOSX::%s(): failed to find support directory",
-                __FUNCTION__);
+      LLDB_LOG(log, "failed to find support directory");
       return false;
     }
 
     // Get normalization from support_dir_spec.  Note the FileSpec resolve
     // does not remove '..' in the path.
     char *const dir_realpath =
         realpath(support_dir_spec.GetPath().c_str(), NULL);
     if (dir_realpath) {