Replace HostInfo::GetLLDBPath with specific functions

[labath]

Summary

Instead of a function taking an enum value determining which path to
return, we now have a suite of functions, each returning a single path
kind. This makes it easy to move the python-path function into a
specific plugin in a follow-up commit.

All the users of GetLLDBPath were converted to call specific functions
instead. Most of them were hard-coding the enum value anyway, so this
conversion was simple. The only exception was SBHostOS, which I've
changed to use a switch on the incoming enum value.

[clayborg]

Looks good. My only question is do we not require people to only fill in the directory portion of the FileSpec anymore for these functions? I am fine with way since hopefully FileSpec::AppendPathComponent handles things correctly.

[labath]

In D48272#1135373, @clayborg wrote:

Looks good. My only question is do we not require people to only fill in the directory portion of the FileSpec anymore for these functions? I am fine with way since hopefully FileSpec::AppendPathComponent handles things correctly.

I'm not sure if anyone actually depends on this behavior, but there is a test which actually requires this (TestPaths.py). I did consider dropping this promise for the internal API and doing the fixup in the SB layer, but I chose not to go along with that for now. I believe AppendPathComponent et al. will mostly work for these kinds of FileSpecs, but they are definitely a less well tested path.

lldb/trunk/include/lldb/Host/HostInfoBase.h

eArchKind64  // If this host supports 64 bit programs, return the default 64
                  // bit arch
   };
 
   static const ArchSpec &
   GetArchitecture(ArchitectureKind arch_kind = eArchKindDefault);
 
   static llvm::Optional<ArchitectureKind> ParseArchitectureKind(llvm::StringRef kind);
 
-  //------------------------------------------------------------------
-  /// Find a resource files that are related to LLDB.
-  ///
-  /// Operating systems have different ways of storing shared
-  /// libraries and related resources. This function abstracts the
-  /// access to these paths.
-  ///
-  /// @param[in] path_type
-  ///     The type of LLDB resource path you are looking for. If the
-  ///     enumeration ends with "Dir", then only the \a file_spec's
-  ///     directory member gets filled in.
-  ///
-  /// @param[in] file_spec
-  ///     A file spec that gets filled in with the appropriate path.
-  ///
-  /// @return
-  ///     \b true if \a resource_path was resolved, \a false otherwise.
-  //------------------------------------------------------------------
-  static bool GetLLDBPath(lldb::PathType type, FileSpec &file_spec);
+  /// Returns the directory containing the lldb shared library. Only the
+  /// directory member of the FileSpec is filled in.
+  static FileSpec GetShlibDir();
+
+  /// Returns the directory containing the support executables (debugserver,
+  /// ...). Only the directory member of the FileSpec is filled in.
+  static FileSpec GetSupportExeDir();
+
+  /// Returns the directory containing the lldb headers. Only the directory
+  /// member of the FileSpec is filled in.
+  static FileSpec GetHeaderDir();
+
+  /// Returns the directory containing the python modules. Only the directory
+  /// member of the FileSpec is filled in.
+  static FileSpec GetPythonDir();
+
+  /// Returns the directory containing the system plugins. Only the directory
+  /// member of the FileSpec is filled in.
+  static FileSpec GetSystemPluginDir();
+
+  /// Returns the directory containing the user plugins. Only the directory
+  /// member of the FileSpec is filled in.
+  static FileSpec GetUserPluginDir();
+
+  /// Returns the proces temporary directory. This directory will be cleaned up
+  /// when this process exits. Only the directory member of the FileSpec is
+  /// filled in.
+  static FileSpec GetProcessTempDir();
+
+  /// Returns the global temporary directory. This directory will **not** be
+  /// cleaned up when this process exits. Only the directory member of the
+  /// FileSpec is filled in.
+  static FileSpec GetGlobalTempDir();
 
   //---------------------------------------------------------------------------
   /// If the triple does not specify the vendor, os, and environment parts, we
   /// "augment" these using information from the host and return the resulting
   /// ArchSpec object.
   //---------------------------------------------------------------------------
   static ArchSpec GetAugmentedArchSpec(llvm::StringRef triple);
 

lldb/trunk/source/API/SBHostOS.cpp

 
 SBFileSpec SBHostOS::GetProgramFileSpec() {
   SBFileSpec sb_filespec;
   sb_filespec.SetFileSpec(HostInfo::GetProgramFileSpec());
   return sb_filespec;
 }
 
 SBFileSpec SBHostOS::GetLLDBPythonPath() {
-  SBFileSpec sb_lldb_python_filespec;
-  FileSpec lldb_python_spec;
-  if (HostInfo::GetLLDBPath(ePathTypePythonDir, lldb_python_spec)) {
-    sb_lldb_python_filespec.SetFileSpec(lldb_python_spec);
-  }
-  return sb_lldb_python_filespec;
+  return GetLLDBPath(ePathTypePythonDir);
 }
 
 SBFileSpec SBHostOS::GetLLDBPath(lldb::PathType path_type) {
-  SBFileSpec sb_fspec;
   FileSpec fspec;
-  bool Success = true;
-  if (path_type == ePathTypeClangDir)
+  switch (path_type) {
+  case ePathTypeLLDBShlibDir:
+    fspec = HostInfo::GetShlibDir();
+    break;
+  case ePathTypeSupportExecutableDir:
+    fspec = HostInfo::GetSupportExeDir();
+    break;
+  case ePathTypeHeaderDir:
+    fspec = HostInfo::GetHeaderDir();
+    break;
+  case ePathTypePythonDir:
+    fspec = HostInfo::GetPythonDir();
+    break;
+  case ePathTypeLLDBSystemPlugins:
+    fspec = HostInfo::GetSystemPluginDir();
+    break;
+  case ePathTypeLLDBUserPlugins:
+    fspec = HostInfo::GetUserPluginDir();
+    break;
+  case ePathTypeLLDBTempSystemDir:
+    fspec = HostInfo::GetProcessTempDir();
+    break;
+  case ePathTypeGlobalLLDBTempSystemDir:
+    fspec = HostInfo::GetGlobalTempDir();
+    break;
+  case ePathTypeClangDir:
     fspec = GetClangResourceDir();
-  else
-    Success = HostInfo::GetLLDBPath(path_type, fspec);
-  if (Success)
-    sb_fspec.SetFileSpec(fspec);
+    break;
+  }
+
+  SBFileSpec sb_fspec;
   return sb_fspec;
 }
 
 SBFileSpec SBHostOS::GetUserHomeDirectory() {
   SBFileSpec sb_fspec;
 
   llvm::SmallString<64> home_dir_path;
   llvm::sys::path::home_directory(home_dir_path);

lldb/trunk/source/Core/Debugger.cpp

if (ft == fs::file_type::regular_file || ft == fs::file_type::symlink_file ||
     // information.
     return FileSpec::eEnumerateDirectoryResultEnter;
   }
 
   return FileSpec::eEnumerateDirectoryResultNext;
 }
 
 void Debugger::InstanceInitialize() {
-  FileSpec dir_spec;
   const bool find_directories = true;
   const bool find_files = true;
   const bool find_other = true;
   char dir_path[PATH_MAX];
-  if (HostInfo::GetLLDBPath(ePathTypeLLDBSystemPlugins, dir_spec)) {
+  if (FileSpec dir_spec = HostInfo::GetSystemPluginDir()) {
     if (dir_spec.Exists() && dir_spec.GetPath(dir_path, sizeof(dir_path))) {
       FileSpec::EnumerateDirectory(dir_path, find_directories, find_files,
                                    find_other, LoadPluginCallback, this);
     }
   }
 
-  if (HostInfo::GetLLDBPath(ePathTypeLLDBUserPlugins, dir_spec)) {
+  if (FileSpec dir_spec = HostInfo::GetUserPluginDir()) {
     if (dir_spec.Exists() && dir_spec.GetPath(dir_path, sizeof(dir_path))) {
       FileSpec::EnumerateDirectory(dir_path, find_directories, find_files,
                                    find_other, LoadPluginCallback, this);
     }
   }
 
   PluginManager::DebuggerInitialize(*this);
 }

lldb/trunk/source/Core/PluginManager.cpp

if (ft == fs::file_type::directory_file ||
     return FileSpec::eEnumerateDirectoryResultEnter;
   }
 
   return FileSpec::eEnumerateDirectoryResultNext;
 }
 
 void PluginManager::Initialize() {
 #if 1
-  FileSpec dir_spec;
   const bool find_directories = true;
   const bool find_files = true;
   const bool find_other = true;
   char dir_path[PATH_MAX];
-  if (HostInfo::GetLLDBPath(ePathTypeLLDBSystemPlugins, dir_spec)) {
+  if (FileSpec dir_spec = HostInfo::GetSystemPluginDir()) {
     if (dir_spec.Exists() && dir_spec.GetPath(dir_path, sizeof(dir_path))) {
       FileSpec::EnumerateDirectory(dir_path, find_directories, find_files,
                                    find_other, LoadPluginCallback, nullptr);
     }
   }
 
-  if (HostInfo::GetLLDBPath(ePathTypeLLDBUserPlugins, dir_spec)) {
+  if (FileSpec dir_spec = HostInfo::GetUserPluginDir()) {
     if (dir_spec.Exists() && dir_spec.GetPath(dir_path, sizeof(dir_path))) {
       FileSpec::EnumerateDirectory(dir_path, find_directories, find_files,
                                    find_other, LoadPluginCallback, nullptr);
     }
   }
 #endif
 }
 

lldb/trunk/source/Expression/REPL.cpp

while (REPLCreateInstance create_instance =
     }
   }
 
   return ret;
 }
 
 std::string REPL::GetSourcePath() {
   ConstString file_basename = GetSourceFileBasename();
-
-  FileSpec tmpdir_file_spec;
-  if (HostInfo::GetLLDBPath(lldb::ePathTypeLLDBTempSystemDir,
-                            tmpdir_file_spec)) {
+  FileSpec tmpdir_file_spec = HostInfo::GetProcessTempDir();
+  if (tmpdir_file_spec) {
     tmpdir_file_spec.GetFilename().SetCString(file_basename.AsCString());
     m_repl_source_path = tmpdir_file_spec.GetPath();
   } else {
     tmpdir_file_spec = FileSpec("/tmp", false);
     tmpdir_file_spec.AppendPathComponent(file_basename.AsCString());
   }
 
   return tmpdir_file_spec.GetPath();

lldb/trunk/source/Host/common/Host.cpp

Status Host::RunShellCommand(const Args &args, const FileSpec &working_dir,
   if (working_dir)
     launch_info.SetWorkingDirectory(working_dir);
   llvm::SmallString<PATH_MAX> output_file_path;
 
   if (command_output_ptr) {
     // Create a temporary file to get the stdout/stderr and redirect the output
     // of the command into this file. We will later read this file if all goes
     // well and fill the data into "command_output_ptr"
-    FileSpec tmpdir_file_spec;
-    if (HostInfo::GetLLDBPath(ePathTypeLLDBTempSystemDir, tmpdir_file_spec)) {
+    if (FileSpec tmpdir_file_spec = HostInfo::GetProcessTempDir()) {
       tmpdir_file_spec.AppendPathComponent("lldb-shell-output.%%%%%%");
       llvm::sys::fs::createUniqueFile(tmpdir_file_spec.GetPath(),
                                       output_file_path);
     } else {
       llvm::sys::fs::createTemporaryFile("lldb-shell-output.%%%%%%", "",
                                          output_file_path);
     }
   }

lldb/trunk/source/Host/common/HostInfoBase.cpp

 llvm::Optional<HostInfoBase::ArchitectureKind> HostInfoBase::ParseArchitectureKind(llvm::StringRef kind) {
   return llvm::StringSwitch<llvm::Optional<ArchitectureKind>>(kind)
       .Case(LLDB_ARCH_DEFAULT, eArchKindDefault)
       .Case(LLDB_ARCH_DEFAULT_32BIT, eArchKind32)
       .Case(LLDB_ARCH_DEFAULT_64BIT, eArchKind64)
       .Default(llvm::None);
 }
 
-bool HostInfoBase::GetLLDBPath(lldb::PathType type, FileSpec &file_spec) {
-  file_spec.Clear();
-
-  assert(type != lldb::ePathTypeClangDir);
-
-#if defined(LLDB_DISABLE_PYTHON)
-  if (type == lldb::ePathTypePythonDir)
-    return false;
-#endif
-
-  FileSpec *result = nullptr;
-  switch (type) {
-  case lldb::ePathTypeLLDBShlibDir: {
-    static llvm::once_flag g_once_flag;
-    static bool success = false;
-    llvm::call_once(g_once_flag, []() {
-      success =
-          HostInfo::ComputeSharedLibraryDirectory(g_fields->m_lldb_so_dir);
-      Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
-      if (log)
-        log->Printf("HostInfoBase::GetLLDBPath(ePathTypeLLDBShlibDir) => '%s'",
-                    g_fields->m_lldb_so_dir.GetPath().c_str());
-    });
-    if (success)
-      result = &g_fields->m_lldb_so_dir;
-  } break;
-  case lldb::ePathTypeSupportExecutableDir: {
-    static llvm::once_flag g_once_flag;
-    static bool success = false;
-    llvm::call_once(g_once_flag, []() {
-      success = HostInfo::ComputeSupportExeDirectory(
-          g_fields->m_lldb_support_exe_dir);
-      Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
-      if (log)
-        log->Printf(
-            "HostInfoBase::GetLLDBPath(ePathTypeSupportExecutableDir) => '%s'",
-            g_fields->m_lldb_support_exe_dir.GetPath().c_str());
-    });
-    if (success)
-      result = &g_fields->m_lldb_support_exe_dir;
-  } break;
-  case lldb::ePathTypeHeaderDir: {
-    static llvm::once_flag g_once_flag;
-    static bool success = false;
-    llvm::call_once(g_once_flag, []() {
-      success = HostInfo::ComputeHeaderDirectory(g_fields->m_lldb_headers_dir);
-      Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
-      if (log)
-        log->Printf("HostInfoBase::GetLLDBPath(ePathTypeHeaderDir) => '%s'",
-                    g_fields->m_lldb_headers_dir.GetPath().c_str());
-    });
-    if (success)
-      result = &g_fields->m_lldb_headers_dir;
-  } break;
-  case lldb::ePathTypePythonDir: {
-    static llvm::once_flag g_once_flag;
-    static bool success = false;
-    llvm::call_once(g_once_flag, []() {
-      success = HostInfo::ComputePythonDirectory(g_fields->m_lldb_python_dir);
-      Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
-      if (log)
-        log->Printf("HostInfoBase::GetLLDBPath(ePathTypePythonDir) => '%s'",
-                    g_fields->m_lldb_python_dir.GetPath().c_str());
-    });
-    if (success)
-      result = &g_fields->m_lldb_python_dir;
-  } break;
-  case lldb::ePathTypeLLDBSystemPlugins: {
-    static llvm::once_flag g_once_flag;
-    static bool success = false;
-    llvm::call_once(g_once_flag, []() {
-      success = HostInfo::ComputeSystemPluginsDirectory(
-          g_fields->m_lldb_system_plugin_dir);
-      Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
-      if (log)
-        log->Printf(
-            "HostInfoBase::GetLLDBPath(ePathTypeLLDBSystemPlugins) => '%s'",
-            g_fields->m_lldb_system_plugin_dir.GetPath().c_str());
-    });
-    if (success)
-      result = &g_fields->m_lldb_system_plugin_dir;
-  } break;
-  case lldb::ePathTypeLLDBUserPlugins: {
-    static llvm::once_flag g_once_flag;
-    static bool success = false;
-    llvm::call_once(g_once_flag, []() {
-      success = HostInfo::ComputeUserPluginsDirectory(
-          g_fields->m_lldb_user_plugin_dir);
-      Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
-      if (log)
-        log->Printf(
-            "HostInfoBase::GetLLDBPath(ePathTypeLLDBUserPlugins) => '%s'",
-            g_fields->m_lldb_user_plugin_dir.GetPath().c_str());
-    });
-    if (success)
-      result = &g_fields->m_lldb_user_plugin_dir;
-  } break;
-  case lldb::ePathTypeLLDBTempSystemDir: {
-    static llvm::once_flag g_once_flag;
-    static bool success = false;
-    llvm::call_once(g_once_flag, []() {
-      success = HostInfo::ComputeProcessTempFileDirectory(
-          g_fields->m_lldb_process_tmp_dir);
-      Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
-      if (log)
-        log->Printf(
-            "HostInfoBase::GetLLDBPath(ePathTypeLLDBTempSystemDir) => '%s'",
-            g_fields->m_lldb_process_tmp_dir.GetPath().c_str());
-    });
-    if (success)
-      result = &g_fields->m_lldb_process_tmp_dir;
-  } break;
-  case lldb::ePathTypeGlobalLLDBTempSystemDir: {
-    static llvm::once_flag g_once_flag;
-    static bool success = false;
-    llvm::call_once(g_once_flag, []() {
-      success = HostInfo::ComputeGlobalTempFileDirectory(
-          g_fields->m_lldb_global_tmp_dir);
-      Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
-      if (log)
-        log->Printf("HostInfoBase::GetLLDBPath("
-                    "ePathTypeGlobalLLDBTempSystemDir) => '%s'",
-                    g_fields->m_lldb_global_tmp_dir.GetPath().c_str());
-    });
-    if (success)
-      result = &g_fields->m_lldb_global_tmp_dir;
-  } break;
-  default:
-    llvm_unreachable("Unreachable!");
-  }
-
-  if (!result)
-    return false;
-  file_spec = *result;
-  return true;
+FileSpec HostInfoBase::GetShlibDir() {
+    success = HostInfo::ComputeSharedLibraryDirectory(g_fields->m_lldb_so_dir);
+    LLDB_LOG(log, "shlib dir -> `{0}`", g_fields->m_lldb_so_dir);
+  return success ? g_fields->m_lldb_so_dir : FileSpec();
+}
+
+FileSpec HostInfoBase::GetSupportExeDir() {
+    success =
+        HostInfo::ComputeSupportExeDirectory(g_fields->m_lldb_support_exe_dir);
+    LLDB_LOG(log, "support exe dir -> `{0}`", g_fields->m_lldb_support_exe_dir);
+  return success ? g_fields->m_lldb_support_exe_dir : FileSpec();
+}
+
+FileSpec HostInfoBase::GetHeaderDir() {
+    LLDB_LOG(log, "header dir -> `{0}`", g_fields->m_lldb_headers_dir);
+  return success ? g_fields->m_lldb_headers_dir : FileSpec();
+}
+
+FileSpec HostInfoBase::GetPythonDir() {
+    LLDB_LOG(log, "python dir -> `{0}`", g_fields->m_lldb_python_dir);
+  return success ? g_fields->m_lldb_python_dir : FileSpec();
+}
+
+FileSpec HostInfoBase::GetSystemPluginDir() {
+    LLDB_LOG(log, "system plugin dir -> `{0}`",
+             g_fields->m_lldb_system_plugin_dir);
+  return success ? g_fields->m_lldb_system_plugin_dir : FileSpec();
+}
+
+FileSpec HostInfoBase::GetUserPluginDir() {
+    success =
+        HostInfo::ComputeUserPluginsDirectory(g_fields->m_lldb_user_plugin_dir);
+    LLDB_LOG(log, "user plugin dir -> `{0}`", g_fields->m_lldb_user_plugin_dir);
+  return success ? g_fields->m_lldb_user_plugin_dir : FileSpec();
+}
+
+FileSpec HostInfoBase::GetProcessTempDir() {
+    LLDB_LOG(log, "process temp dir -> `{0}`",
+             g_fields->m_lldb_process_tmp_dir);
+  return success ? g_fields->m_lldb_process_tmp_dir : FileSpec();
+}
+
+FileSpec HostInfoBase::GetGlobalTempDir() {
+    LLDB_LOG(log, "global temp dir -> `{0}`", g_fields->m_lldb_global_tmp_dir);
+  return success ? g_fields->m_lldb_global_tmp_dir : FileSpec();
 }
 
 ArchSpec HostInfoBase::GetAugmentedArchSpec(llvm::StringRef triple) {
   if (triple.empty())
     return ArchSpec();
   llvm::Triple normalized_triple(llvm::Triple::normalize(triple));
   if (!ArchSpec::ContainsOnlyArch(normalized_triple))
     return ArchSpec(triple);
ArchSpec HostInfoBase::GetAugmentedArchSpec(llvm::StringRef triple) {
   return ArchSpec(normalized_triple);
 }
 
 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.
 
-  FileSpec lldb_file_spec(
-      Host::GetModuleFileSpecForHostAddress(reinterpret_cast<void *>(
-          reinterpret_cast<intptr_t>(HostInfoBase::GetLLDBPath))));
+  FileSpec lldb_file_spec(Host::GetModuleFileSpecForHostAddress(
+      reinterpret_cast<void *>(reinterpret_cast<intptr_t>(
+          HostInfoBase::ComputeSharedLibraryDirectory))));
 
   // This is necessary because when running the testsuite the shlib might be a
   // symbolic link inside the Python resource dir.
   FileSystem::ResolveSymbolicLink(lldb_file_spec, lldb_file_spec);
 
   // Remove the filename so that this FileSpec only represents the directory.
   file_spec.GetDirectory() = lldb_file_spec.GetDirectory();
 
   return (bool)file_spec.GetDirectory();
 }
 
 bool HostInfoBase::ComputeSupportExeDirectory(FileSpec &file_spec) {
-  return GetLLDBPath(lldb::ePathTypeLLDBShlibDir, file_spec);
+  file_spec = GetShlibDir();
+  return bool(file_spec);
 }
 
 bool HostInfoBase::ComputeProcessTempFileDirectory(FileSpec &file_spec) {
   FileSpec temp_file_spec;
   if (!HostInfo::ComputeGlobalTempFileDirectory(temp_file_spec))
     return false;
 
   std::string pid_str{llvm::to_string(Host::GetCurrentProcessID())};

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

LaunchInNewTerminalWithAppleScript(const char *exe_path,
   Status error;
   char unix_socket_name[PATH_MAX] = "/tmp/XXXXXX";
   if (::mktemp(unix_socket_name) == NULL) {
     error.SetErrorString("failed to make temporary path for a unix socket");
     return error;
   }
 
   StreamString command;
-  FileSpec darwin_debug_file_spec;
-  if (!HostInfo::GetLLDBPath(ePathTypeSupportExecutableDir,
-                             darwin_debug_file_spec)) {
+  FileSpec darwin_debug_file_spec = HostInfo::GetSupportExeDir();
+  if (!darwin_debug_file_spec) {
     error.SetErrorString("can't locate the 'darwin-debug' executable");
     return error;
   }
 
   darwin_debug_file_spec.GetFilename().SetCString("darwin-debug");
 
   if (!darwin_debug_file_spec.Exists()) {
     error.SetErrorStringWithFormat(
if (error.Success())
       error.SetErrorString("process launch failed for unknown reasons");
   }
   return error;
 }
 
 Status Host::ShellExpandArguments(ProcessLaunchInfo &launch_info) {
   Status error;
   if (launch_info.GetFlags().Test(eLaunchFlagShellExpandArguments)) {
-    FileSpec expand_tool_spec;
-    if (!HostInfo::GetLLDBPath(lldb::ePathTypeSupportExecutableDir,
-                               expand_tool_spec)) {
+    FileSpec expand_tool_spec = HostInfo::GetSupportExeDir();
+    if (!expand_tool_spec) {
       error.SetErrorString(
           "could not get support executable directory for lldb-argdumper tool");
       return error;
     }
     expand_tool_spec.AppendPathComponent("lldb-argdumper");
     if (!expand_tool_spec.Exists()) {
       error.SetErrorStringWithFormat(
           "could not find the lldb-argdumper tool: %s",

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

else if (err == -1) {
 
       ::free(large_program_fullpath);
     }
   }
   return g_program_filespec;
 }
 
 bool HostInfoMacOSX::ComputeSupportExeDirectory(FileSpec &file_spec) {
-  FileSpec lldb_file_spec;
-  if (!GetLLDBPath(lldb::ePathTypeLLDBShlibDir, lldb_file_spec))
+  FileSpec lldb_file_spec = GetShlibDir();
+  if (!lldb_file_spec)
     return false;
 
   std::string raw_path = lldb_file_spec.GetPath();
 
   size_t framework_pos = raw_path.find("LLDB.framework");
   if (framework_pos != std::string::npos) {
     framework_pos += strlen("LLDB.framework");
 #if defined(__arm__) || defined(__arm64__) || defined(__aarch64__)
#endif
   }
 
   file_spec.GetDirectory().SetString(
       llvm::StringRef(raw_path.c_str(), raw_path.size()));
   return (bool)file_spec.GetDirectory();
 }
 
 bool HostInfoMacOSX::ComputeHeaderDirectory(FileSpec &file_spec) {
-  FileSpec lldb_file_spec;
-  if (!HostInfo::GetLLDBPath(lldb::ePathTypeLLDBShlibDir, lldb_file_spec))
+  FileSpec lldb_file_spec = GetShlibDir();
+  if (!lldb_file_spec)
     return false;
 
   std::string raw_path = lldb_file_spec.GetPath();
 
   size_t framework_pos = raw_path.find("LLDB.framework");
   if (framework_pos != std::string::npos) {
     framework_pos += strlen("LLDB.framework");
     raw_path.resize(framework_pos);
     raw_path.append("/Headers");
   }
   file_spec.GetDirectory().SetString(
       llvm::StringRef(raw_path.c_str(), raw_path.size()));
   return true;
 }
 
 bool HostInfoMacOSX::ComputePythonDirectory(FileSpec &file_spec) {
 #ifndef LLDB_DISABLE_PYTHON
-  FileSpec lldb_file_spec;
-  if (!GetLLDBPath(lldb::ePathTypeLLDBShlibDir, lldb_file_spec))
+  FileSpec lldb_file_spec = GetShlibDir();
+  if (!lldb_file_spec)
     return false;
 
   std::string raw_path = lldb_file_spec.GetPath();
 
   size_t framework_pos = raw_path.find("LLDB.framework");
   if (framework_pos != std::string::npos) {
     framework_pos += strlen("LLDB.framework");
     raw_path.resize(framework_pos);
file_spec.GetDirectory().SetString(
       llvm::StringRef(raw_path.c_str(), raw_path.size()));
   return true;
 #else
   return false;
 #endif
 }
 
 bool HostInfoMacOSX::ComputeSystemPluginsDirectory(FileSpec &file_spec) {
-  FileSpec lldb_file_spec;
-  if (!GetLLDBPath(lldb::ePathTypeLLDBShlibDir, lldb_file_spec))
+  FileSpec lldb_file_spec = GetShlibDir();
+  if (!lldb_file_spec)
     return false;
 
   std::string raw_path = lldb_file_spec.GetPath();
 
   size_t framework_pos = raw_path.find("LLDB.framework");
   if (framework_pos == std::string::npos)
     return false;
 

lldb/trunk/source/Host/posix/HostInfoPosix.cpp

 uint32_t HostInfoPosix::GetEffectiveGroupID() { return getegid(); }
 
 FileSpec HostInfoPosix::GetDefaultShell() { return FileSpec("/bin/sh", false); }
 
 bool HostInfoPosix::ComputePathRelativeToLibrary(FileSpec &file_spec,
                                                  llvm::StringRef dir) {
   Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
 
-  FileSpec lldb_file_spec;
-  if (!GetLLDBPath(lldb::ePathTypeLLDBShlibDir, lldb_file_spec))
+  FileSpec lldb_file_spec = GetShlibDir();
+  if (!lldb_file_spec)
     return false;
 
   std::string raw_path = lldb_file_spec.GetPath();
   // drop library directory
   llvm::StringRef parent_path = llvm::sys::path::parent_path(raw_path);
 
   // Most Posix systems (e.g. Linux/*BSD) will attempt to replace a */lib with
   // */bin as the base directory for helper exe programs.  This will fail if

 bool HostInfoPosix::ComputeHeaderDirectory(FileSpec &file_spec) {
   FileSpec temp_file("/opt/local/include/lldb", false);
   file_spec.GetDirectory().SetCString(temp_file.GetPath().c_str());
   return true;
 }
 
 bool HostInfoPosix::ComputePythonDirectory(FileSpec &file_spec) {
 #ifndef LLDB_DISABLE_PYTHON
-  FileSpec lldb_file_spec;
-  if (!GetLLDBPath(lldb::ePathTypeLLDBShlibDir, lldb_file_spec))
+  FileSpec lldb_file_spec = GetShlibDir();
+  if (!lldb_file_spec)
     return false;
 
   char raw_path[PATH_MAX];
   lldb_file_spec.GetPath(raw_path, sizeof(raw_path));
 
 #if defined(LLDB_PYTHON_RELATIVE_LIBDIR)
   // Build the path by backing out of the lib dir, then building with whatever
   // the real python interpreter uses.  (e.g. lib for most, lib64 on RHEL

lldb/trunk/source/Host/posix/PipePosix.cpp

Status PipePosix::CreateNew(llvm::StringRef name, bool child_process_inherit) {
   return error;
 }
 
 Status PipePosix::CreateWithUniqueName(llvm::StringRef prefix,
                                        bool child_process_inherit,
                                        llvm::SmallVectorImpl<char> &name) {
   llvm::SmallString<PATH_MAX> named_pipe_path;
   llvm::SmallString<PATH_MAX> pipe_spec((prefix + ".%%%%%%").str());
-  FileSpec tmpdir_file_spec;
-  tmpdir_file_spec.Clear();
-  if (HostInfo::GetLLDBPath(ePathTypeLLDBTempSystemDir, tmpdir_file_spec)) {
-    tmpdir_file_spec.AppendPathComponent(pipe_spec.c_str());
-  } else {
+  FileSpec tmpdir_file_spec = HostInfo::GetProcessTempDir();
+  if (!tmpdir_file_spec)
     tmpdir_file_spec.AppendPathComponent("/tmp");
-    tmpdir_file_spec.AppendPathComponent(pipe_spec.c_str());
-  }
+  tmpdir_file_spec.AppendPathComponent(pipe_spec);
 
   // It's possible that another process creates the target path after we've
   // verified it's available but before we create it, in which case we should
   // try again.
   Status error;
   do {
     llvm::sys::fs::createUniqueFile(tmpdir_file_spec.GetPath(),
                                     named_pipe_path);

lldb/trunk/source/Host/windows/Host.cpp

HostThread Host::StartMonitoringChildProcess(
     const Host::MonitorChildProcessCallback &callback, lldb::pid_t pid,
     bool monitor_signals) {
   return HostThread();
 }
 
 Status Host::ShellExpandArguments(ProcessLaunchInfo &launch_info) {
   Status error;
   if (launch_info.GetFlags().Test(eLaunchFlagShellExpandArguments)) {
-    FileSpec expand_tool_spec;
-    if (!HostInfo::GetLLDBPath(lldb::ePathTypeSupportExecutableDir,
-                               expand_tool_spec)) {
+    FileSpec expand_tool_spec = HostInfo::GetSupportExeDir();
+    if (!expand_tool_spec) {
       error.SetErrorString("could not find support executable directory for "
                            "the lldb-argdumper tool");
       return error;
     }
     expand_tool_spec.AppendPathComponent("lldb-argdumper.exe");
     if (!expand_tool_spec.Exists()) {
       error.SetErrorString("could not find the lldb-argdumper tool");
       return error;

lldb/trunk/source/Host/windows/HostInfoWindows.cpp

 
 FileSpec HostInfoWindows::GetDefaultShell() {
   std::string shell;
   GetEnvironmentVar("ComSpec", shell);
   return FileSpec(shell, false);
 }
 
 bool HostInfoWindows::ComputePythonDirectory(FileSpec &file_spec) {
-  FileSpec lldb_file_spec;
-  if (!GetLLDBPath(lldb::ePathTypeLLDBShlibDir, lldb_file_spec))
+  FileSpec lldb_file_spec = GetShlibDir();
+  if (!lldb_file_spec)
     return false;
   llvm::SmallString<64> path(lldb_file_spec.GetDirectory().AsCString());
   llvm::sys::path::remove_filename(path);
   llvm::sys::path::append(path, "lib", "site-packages");
   std::replace(path.begin(), path.end(), '\\', '/');
   file_spec.GetDirectory().SetString(path.c_str());
   return true;
 }

lldb/trunk/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp

unsigned ClangExpressionParser::Parse(DiagnosticManager &diagnostic_manager) {
   const char *expr_text = m_expr.Text();
 
   clang::SourceManager &source_mgr = m_compiler->getSourceManager();
   bool created_main_file = false;
   if (m_compiler->getCodeGenOpts().getDebugInfo() ==
       codegenoptions::FullDebugInfo) {
     int temp_fd = -1;
     llvm::SmallString<PATH_MAX> result_path;
-    FileSpec tmpdir_file_spec;
-    if (HostInfo::GetLLDBPath(lldb::ePathTypeLLDBTempSystemDir,
-                              tmpdir_file_spec)) {
+    if (FileSpec tmpdir_file_spec = HostInfo::GetProcessTempDir()) {
       tmpdir_file_spec.AppendPathComponent("lldb-%%%%%%.expr");
       std::string temp_source_path = tmpdir_file_spec.GetPath();
       llvm::sys::fs::createUniqueFile(temp_source_path, temp_fd, result_path);
     } else {
       llvm::sys::fs::createTemporaryFile("lldb", "expr", temp_fd, result_path);
     }
 
     if (temp_fd != -1) {

lldb/trunk/source/Plugins/ExpressionParser/Clang/ClangHost.cpp

bool lldb_private::ComputeClangDirectory(FileSpec &lldb_shlib_spec,
 
   // Fall back to the Clang resource directory inside the framework.
   raw_path.append("LLDB.framework/Resources/Clang");
   file_spec.SetFile(raw_path.c_str(), true, FileSpec::Style::native);
   return true;
 }
 
 static bool ComputeClangDirectory(FileSpec &file_spec) {
-  FileSpec lldb_file_spec;
-  if (!HostInfo::GetLLDBPath(lldb::ePathTypeLLDBShlibDir, lldb_file_spec))
-    return false;
+  if (FileSpec lldb_file_spec = HostInfo::GetShlibDir())
     return ComputeClangDirectory(lldb_file_spec, file_spec, true);
+  return false;
 }
 #else  // __APPLE__
 
 // All non-Apple posix systems.
 static bool ComputeClangDirectory(FileSpec &file_spec) {
   return DefaultComputeClangDirectory(file_spec);
 }
 #endif // __APPLE__

lldb/trunk/source/Plugins/Platform/MacOSX/PlatformDarwin.cpp

 }
 
 // Return a directory path like /Applications/Xcode.app/Contents/Developer
 const char *PlatformDarwin::GetDeveloperDirectory() {
   std::lock_guard<std::mutex> guard(m_mutex);
   if (m_developer_directory.empty()) {
     bool developer_dir_path_valid = false;
     char developer_dir_path[PATH_MAX];
-    FileSpec temp_file_spec;
 
     // Get the lldb framework's file path, and if it exists, truncate some
     // components to only the developer directory path.
-    if (HostInfo::GetLLDBPath(ePathTypeLLDBShlibDir, temp_file_spec)) {
+    FileSpec temp_file_spec = HostInfo::GetShlibDir();
+    if (temp_file_spec) {
       if (temp_file_spec.GetPath(developer_dir_path,
                                  sizeof(developer_dir_path))) {
         // e.g.
         // /Applications/Xcode.app/Contents/SharedFrameworks/LLDB.framework
         char *shared_frameworks =
             strstr(developer_dir_path, "/SharedFrameworks/LLDB.framework");
         if (shared_frameworks) {
           shared_frameworks[0] = '\0';  // truncate developer_dir_path at this point

lldb/trunk/source/Plugins/Platform/MacOSX/PlatformMacOSX.cpp

ConstString PlatformMacOSX::GetSDKDirectory(lldb_private::Target &target) {
   if (exe_module_sp) {
     ObjectFile *objfile = exe_module_sp->GetObjectFile();
     if (objfile) {
       std::string xcode_contents_path;
       std::string default_xcode_sdk;
       FileSpec fspec;
       uint32_t versions[2];
       if (objfile->GetSDKVersion(versions, sizeof(versions))) {
-        if (HostInfo::GetLLDBPath(ePathTypeLLDBShlibDir, fspec)) {
+        fspec = HostInfo::GetShlibDir();
+        if (fspec) {
           std::string path;
           xcode_contents_path = fspec.GetPath();
           size_t pos = xcode_contents_path.find("/Xcode.app/Contents/");
           if (pos != std::string::npos) {
             // LLDB.framework is inside an Xcode app bundle, we can locate the
             // SDK from here
             xcode_contents_path.erase(pos + strlen("/Xcode.app/Contents/"));
           } else {

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp

if (log)
       log->Printf("GDBRemoteCommunication::%s() gdb-remote stub exe path set "
                   "from environment variable: %s",
                   __FUNCTION__, env_debugserver_path);
   } else
     debugserver_file_spec = g_debugserver_file_spec;
   bool debugserver_exists = debugserver_file_spec.Exists();
   if (!debugserver_exists) {
     // The debugserver binary is in the LLDB.framework/Resources directory.
-    if (HostInfo::GetLLDBPath(ePathTypeSupportExecutableDir,
-                              debugserver_file_spec)) {
+    debugserver_file_spec = HostInfo::GetSupportExeDir();
+    if (debugserver_file_spec) {
       debugserver_file_spec.AppendPathComponent(DEBUGSERVER_BASENAME);
       debugserver_exists = debugserver_file_spec.Exists();
       if (debugserver_exists) {
         if (log)
           log->Printf(
               "GDBRemoteCommunication::%s() found gdb-remote stub exe '%s'",
               __FUNCTION__, debugserver_file_spec.GetPath().c_str());
 

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.cpp

const FileSpec &GDBRemoteCommunicationServerPlatform::GetDomainSocketDir() {
   static llvm::once_flag g_once_flag;
 
   llvm::call_once(g_once_flag, []() {
     const char *domainsocket_dir_env =
         ::getenv("LLDB_DEBUGSERVER_DOMAINSOCKET_DIR");
     if (domainsocket_dir_env != nullptr)
       g_domainsocket_dir = FileSpec(domainsocket_dir_env, false);
     else
-      HostInfo::GetLLDBPath(ePathTypeLLDBTempSystemDir, g_domainsocket_dir);
+      g_domainsocket_dir = HostInfo::GetProcessTempDir();
   });
 
   return g_domainsocket_dir;
 }
 
 FileSpec
 GDBRemoteCommunicationServerPlatform::GetDomainSocketPath(const char *prefix) {
   llvm::SmallString<PATH_MAX> socket_path;

lldb/trunk/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp

if (g_swig_init_callback)
     g_swig_init_callback();
 
   // Update the path python uses to search for modules to include the current
   // directory.
 
   PyRun_SimpleString("import sys");
   AddToSysPath(AddLocation::End, ".");
 
-  FileSpec file_spec;
   // Don't denormalize paths when calling file_spec.GetPath().  On platforms
   // that use a backslash as the path separator, this will result in executing
   // python code containing paths with unescaped backslashes.  But Python also
   // accepts forward slashes, so to make life easier we just use that.
-  if (HostInfo::GetLLDBPath(ePathTypePythonDir, file_spec))
+  if (FileSpec file_spec = HostInfo::GetPythonDir())
     AddToSysPath(AddLocation::Beginning, file_spec.GetPath(false));
-  if (HostInfo::GetLLDBPath(ePathTypeLLDBShlibDir, file_spec))
+  if (FileSpec file_spec = HostInfo::GetShlibDir())
     AddToSysPath(AddLocation::Beginning, file_spec.GetPath(false));
 
   PyRun_SimpleString("sys.dont_write_bytecode = 1; import "
                      "lldb.embedded_interpreter; from "
                      "lldb.embedded_interpreter import run_python_interpreter; "
                      "from lldb.embedded_interpreter import run_one_line");
 }
 

lldb/trunk/unittests/Target/ModuleCacheTest.cpp

static FileSpec GetSysrootView(FileSpec spec, const char *hostname) {
   spec.AppendPathComponent(module_name);
   return spec;
 }
 
 void ModuleCacheTest::SetUpTestCase() {
   HostInfo::Initialize();
   ObjectFileELF::Initialize();
 
-  FileSpec tmpdir_spec;
-  HostInfo::GetLLDBPath(lldb::ePathTypeLLDBTempSystemDir, s_cache_dir);
+  s_cache_dir = HostInfo::GetProcessTempDir();
   s_test_executable = GetInputFilePath(module_name);
 }
 
 void ModuleCacheTest::TearDownTestCase() {
   ObjectFileELF::Terminate();
   HostInfo::Terminate();
 }