diff --git a/lldb/source/Commands/CommandObjectHelp.cpp b/lldb/source/Commands/CommandObjectHelp.cpp
index 4a8f01c..41da682 100644
--- a/lldb/source/Commands/CommandObjectHelp.cpp
+++ b/lldb/source/Commands/CommandObjectHelp.cpp
@@ -25,21 +25,26 @@
 //-------------------------------------------------------------------------
 
 void CommandObjectHelp::GenerateAdditionalHelpAvenuesMessage(
-    Stream *s, const char *command, const char *prefix, const char *subcommand,
+    Stream *s, llvm::StringRef command, llvm::StringRef prefix, llvm::StringRef subcommand,
     bool include_apropos, bool include_type_lookup) {
-  if (s && command && *command) {
-    s->Printf("'%s' is not a known command.\n", command);
-    s->Printf("Try '%shelp' to see a current list of commands.\n",
-              prefix ? prefix : "");
-    if (include_apropos) {
-      s->Printf("Try '%sapropos %s' for a list of related commands.\n",
-                prefix ? prefix : "", subcommand ? subcommand : command);
-    }
-    if (include_type_lookup) {
-      s->Printf("Try '%stype lookup %s' for information on types, methods, "
-                "functions, modules, etc.",
-                prefix ? prefix : "", subcommand ? subcommand : command);
-    }
+  if (!s || command.empty())
+    return;
+
+  std::string command_str = command.str();
+  std::string prefix_str = prefix.str();
+  std::string subcommand_str = subcommand.str();
+  const std::string &lookup_str = !subcommand_str.empty() ? subcommand_str : command_str;
+  s->Printf("'%s' is not a known command.\n", command_str.c_str());
+  s->Printf("Try '%shelp' to see a current list of commands.\n",
+            prefix.str().c_str());
+  if (include_apropos) {
+    s->Printf("Try '%sapropos %s' for a list of related commands.\n",
+      prefix_str.c_str(), lookup_str.c_str());
+  }
+  if (include_type_lookup) {
+    s->Printf("Try '%stype lookup %s' for information on types, methods, "
+              "functions, modules, etc.",
+      prefix_str.c_str(), lookup_str.c_str());
   }
 }
 
@@ -198,7 +203,7 @@
         StreamString error_msg_stream;
         GenerateAdditionalHelpAvenuesMessage(&error_msg_stream,
                                              command.GetArgumentAtIndex(0),
-                                             m_interpreter.GetCommandPrefix());
+                                             m_interpreter.GetCommandPrefix(), "");
         result.AppendError(error_msg_stream.GetString());
         result.SetStatus(eReturnStatusFailed);
       }
