[lldb] Improve formatting of dlopen error messages (NFC)

[kastiglione]

Summary

Ensure there's a space between "utility" and "function", and also makes
it easier to grep/search for "utility function".

While making this change, I also re-formatted the other dlopen error messages
(with clang-format). This fix other instances of spaces missing between words,
and makes each of these strings fit a single line, making them greppable.

[JDevlieghere]

LGTM

lldb/source/Plugins/Platform/POSIX/PlatformPOSIX.cpp

PlatformPOSIX::MakeLoadImageUtilityFunction(ExecutionContext &exe_ctx,
   expr.append(dlopen_wrapper_code);
   Status utility_error;
   DiagnosticManager diagnostics;
 
   auto utility_fn_or_error = process->GetTarget().CreateUtilityFunction(
       std::move(expr), dlopen_wrapper_name, eLanguageTypeC_plus_plus, exe_ctx);
   if (!utility_fn_or_error) {
     std::string error_str = llvm::toString(utility_fn_or_error.takeError());
-    error.SetErrorStringWithFormat("dlopen error: could not create utility"
-                                   "function: %s",
-                                   error_str.c_str());
+    error.SetErrorStringWithFormat(
+        "dlopen error: could not create utility function: %s",
     return nullptr;
   }
   std::unique_ptr<UtilityFunction> dlopen_utility_func_up =
       std::move(*utility_fn_or_error);
 
   Value value;
   ValueList arguments;
   FunctionCaller *do_dlopen_function = nullptr;
PlatformPOSIX::MakeLoadImageUtilityFunction(ExecutionContext &exe_ctx,
   value.SetCompilerType(clang_char_pointer_type);
   arguments.PushValue(value);
   arguments.PushValue(value);
   arguments.PushValue(value);
   
   do_dlopen_function = dlopen_utility_func_up->MakeFunctionCaller(
       clang_void_pointer_type, arguments, exe_ctx.GetThreadSP(), utility_error);
   if (utility_error.Fail()) {
-    error.SetErrorStringWithFormat("dlopen error: could not make function"
-                                   "caller: %s", utility_error.AsCString());
+    error.SetErrorStringWithFormat(
+        "dlopen error: could not make function caller: %s",
+        utility_error.AsCString());
     return nullptr;
   }
   
   do_dlopen_function = dlopen_utility_func_up->GetFunctionCaller();
   if (!do_dlopen_function) {
     error.SetErrorString("dlopen error: could not get function caller.");
     return nullptr;
   }
uint32_t PlatformPOSIX::DoLoadImage(lldb_private::Process *process,
   // Now insert the path we are searching for and the result structure into the
   // target.
   uint32_t permissions = ePermissionsReadable|ePermissionsWritable;
   size_t path_len = path.size() + 1;
   lldb::addr_t path_addr = process->AllocateMemory(path_len, 
                                                    permissions,
                                                    utility_error);
   if (path_addr == LLDB_INVALID_ADDRESS) {
-    error.SetErrorStringWithFormat("dlopen error: could not allocate memory"
-                                    "for path: %s", utility_error.AsCString());
+    error.SetErrorStringWithFormat(
+        "dlopen error: could not allocate memory for path: %s",
+        utility_error.AsCString());
     return LLDB_INVALID_IMAGE_TOKEN;
   }
 
   // Make sure we deallocate the input string memory:
   auto path_cleanup = llvm::make_scope_exit([process, path_addr] {
     // Deallocate the buffer.
     process->DeallocateMemory(path_addr);
   });
 
   process->WriteMemory(path_addr, path.c_str(), path_len, utility_error);
   if (utility_error.Fail()) {
-    error.SetErrorStringWithFormat("dlopen error: could not write path string:"
-                                    " %s", utility_error.AsCString());
+    error.SetErrorStringWithFormat(
+        "dlopen error: could not write path string: %s",
+        utility_error.AsCString());
     return LLDB_INVALID_IMAGE_TOKEN;
   }
   
   // Make space for our return structure.  It is two pointers big: the token
   // and the error string.
   const uint32_t addr_size = process->GetAddressByteSize();
   lldb::addr_t return_addr = process->CallocateMemory(2*addr_size,
                                                       permissions,
                                                       utility_error);
   if (utility_error.Fail()) {
-    error.SetErrorStringWithFormat("dlopen error: could not allocate memory"
-                                    "for path: %s", utility_error.AsCString());
+    error.SetErrorStringWithFormat(
+        "dlopen error: could not allocate memory for path: %s",
+        utility_error.AsCString());
     return LLDB_INVALID_IMAGE_TOKEN;
   }
   
   // Make sure we deallocate the result structure memory
   auto return_cleanup = llvm::make_scope_exit([process, return_addr] {
     // Deallocate the buffer
     process->DeallocateMemory(return_addr);
   });
for (auto path : *paths) {
         buffer_size = path_size;
     }
     path_array.push_back('\0');
     
     path_array_addr = process->AllocateMemory(path_array.size(), 
                                               permissions,
                                               utility_error);
     if (path_array_addr == LLDB_INVALID_ADDRESS) {
-      error.SetErrorStringWithFormat("dlopen error: could not allocate memory"
-                                      "for path array: %s", 
-                                      utility_error.AsCString());
+      error.SetErrorStringWithFormat(
+          "dlopen error: could not allocate memory for path array: %s",
       return LLDB_INVALID_IMAGE_TOKEN;
     }
     
     // Make sure we deallocate the paths array.
     path_array_cleanup.emplace([process, path_array_addr]() {
       // Deallocate the path array.
       process->DeallocateMemory(path_array_addr);
     });
 
     process->WriteMemory(path_array_addr, path_array.data(), 
                          path_array.size(), utility_error);
 
     if (utility_error.Fail()) {
-      error.SetErrorStringWithFormat("dlopen error: could not write path array:"
-                                     " %s", utility_error.AsCString());
+      error.SetErrorStringWithFormat(
+          "dlopen error: could not write path array: %s",
+          utility_error.AsCString());
       return LLDB_INVALID_IMAGE_TOKEN;
     }
     // Now make spaces in the target for the buffer.  We need to add one for
     // the '/' that the utility function will insert and one for the '\0':
     buffer_size += path.size() + 2;
     
     buffer_addr = process->AllocateMemory(buffer_size, 
                                           permissions,
                                           utility_error);
     if (buffer_addr == LLDB_INVALID_ADDRESS) {
-      error.SetErrorStringWithFormat("dlopen error: could not allocate memory"
-                                      "for buffer: %s", 
-                                      utility_error.AsCString());
+      error.SetErrorStringWithFormat(
+          "dlopen error: could not allocate memory for buffer: %s",
       return LLDB_INVALID_IMAGE_TOKEN;
     }
   
     // Make sure we deallocate the buffer memory:
     buffer_cleanup.emplace([process, buffer_addr]() {
       // Deallocate the buffer.
       process->DeallocateMemory(buffer_addr);
     });
   }
     
   arguments.GetValueAtIndex(0)->GetScalar() = path_addr;
   arguments.GetValueAtIndex(1)->GetScalar() = path_array_addr;
   arguments.GetValueAtIndex(2)->GetScalar() = buffer_addr;
   arguments.GetValueAtIndex(3)->GetScalar() = return_addr;
 
   lldb::addr_t func_args_addr = LLDB_INVALID_ADDRESS;
   
   diagnostics.Clear();
   if (!do_dlopen_function->WriteFunctionArguments(exe_ctx, 
                                                  func_args_addr,
                                                  arguments,
                                                  diagnostics)) {
-    error.SetErrorStringWithFormat("dlopen error: could not write function "
-                                   "arguments: %s", 
-                                   diagnostics.GetString().c_str());
+    error.SetErrorStringWithFormat(
+        "dlopen error: could not write function arguments: %s",
     return LLDB_INVALID_IMAGE_TOKEN;
   }
   
   // Make sure we clean up the args structure.  We can't reuse it because the
   // Platform lives longer than the process and the Platforms don't get a
   // signal to clean up cached data when a process goes away.
   auto args_cleanup =
       llvm::make_scope_exit([do_dlopen_function, &exe_ctx, func_args_addr] {
uint32_t PlatformPOSIX::DoLoadImage(lldb_private::Process *process,
   CompilerType clang_void_pointer_type
       = ast->GetBasicType(eBasicTypeVoid).GetPointerType();
 
   return_value.SetCompilerType(clang_void_pointer_type);
   
   ExpressionResults results = do_dlopen_function->ExecuteFunction(
       exe_ctx, &func_args_addr, options, diagnostics, return_value);
   if (results != eExpressionCompleted) {
-    error.SetErrorStringWithFormat("dlopen error: failed executing "
-                                   "dlopen wrapper function: %s", 
-                                   diagnostics.GetString().c_str());
+    error.SetErrorStringWithFormat(
+        "dlopen error: failed executing dlopen wrapper function: %s",
     return LLDB_INVALID_IMAGE_TOKEN;
   }
   
   // Read the dlopen token from the return area:
   lldb::addr_t token = process->ReadPointerFromMemory(return_addr, 
                                                       utility_error);
   if (utility_error.Fail()) {
-    error.SetErrorStringWithFormat("dlopen error: could not read the return "
-                                    "struct: %s", utility_error.AsCString());
+    error.SetErrorStringWithFormat(
+        "dlopen error: could not read the return struct: %s",
+        utility_error.AsCString());
     return LLDB_INVALID_IMAGE_TOKEN;
   }
   
   // The dlopen succeeded!
   if (token != 0x0) {
     if (loaded_image && buffer_addr != 0x0)
     {
       // Capture the image which was loaded.  We leave it in the buffer on
       // exit from the dlopen function, so we can just read it from there:
       std::string name_string;
       process->ReadCStringFromMemory(buffer_addr, name_string, utility_error);
       if (utility_error.Success())
         loaded_image->SetFile(name_string, llvm::sys::path::Style::posix);
     }
     return process->AddImageToken(token);
   }
     
   // We got an error, lets read in the error string:
   std::string dlopen_error_str;
   lldb::addr_t error_addr 
     = process->ReadPointerFromMemory(return_addr + addr_size, utility_error);
   if (utility_error.Fail()) {
-    error.SetErrorStringWithFormat("dlopen error: could not read error string: "
-                                    "%s", utility_error.AsCString());
+    error.SetErrorStringWithFormat(
+        "dlopen error: could not read error string: %s",
+        utility_error.AsCString());
     return LLDB_INVALID_IMAGE_TOKEN;
   }
   
   size_t num_chars = process->ReadCStringFromMemory(error_addr + addr_size, 
                                                     dlopen_error_str, 
                                                     utility_error);
   if (utility_error.Success() && num_chars > 0)
     error.SetErrorStringWithFormat("dlopen error: %s",