[NFC] Improve FileSpec internal APIs and usage in preparation for adding caching of resolved/absolute.

[clayborg]

Summary

Resubmission of https://reviews.llvm.org/D130309 with the 2 patches that fixed the linux buildbot, and new windows fixes.

The FileSpec APIs allow users to modify instance variables directly by getting a non const reference to the directory and filename instance variables. This makes it impossible to control all of the times the FileSpec object is modified so we can clear cached member variables like m_resolved and with an upcoming patch caching if the file is relative or absolute. This patch modifies the APIs of FileSpec so no one can modify the directory or filename instance variables directly by adding set accessors and by removing the get accessors that are non const.

Many clients were using FileSpec::GetCString(...) which returned a unique C string from a ConstString'ified version of the result of GetPath() which returned a std::string. This caused many locations to use this convenient function incorrectly and could cause many strings to be added to the constant string pool that didn't need to. Most clients were converted to using FileSpec::GetPath().c_str() when possible. Other clients were modified to use the newly renamed version of this function which returns an actualy ConstString:

ConstString FileSpec::GetPathAsConstString(bool denormalize = true) const;

This avoids the issue where people were getting an already uniqued "const char *" that came from a ConstString only to put the "const char *" back into a "ConstString" object. By returning the ConstString instead of a "const char *" clients can be more efficient with the result.

The patch:

• Removes the non const GetDirectory() and GetFilename() get accessors
• Adds set accessors to replace the above functions: SetDirectory() and SetFilename().
• Adds ClearDirectory() and ClearFilename() to replace usage of the FileSpec::GetDirectory().Clear()/FileSpec::GetFilename().Clear() call sites
• Fixed all incorrect usage of FileSpec::GetCString() to use FileSpec::GetPath().c_str() where appropriate, and updated other call sites that wanted a ConstString to use the newly returned ConstString appropriately and efficiently.

[clayborg]

Can anyone with windows access try applying this patch and seeing if things build? Any help to avoid having Buildbot issues would be great

[clayborg]

Ping. This was accepted before but I had Buildbot issues. Those should all be resolved in this updated patch after a revert.

[smeenai]

In D130549#3683423, @clayborg wrote:

Ping. This was accepted before but I had Buildbot issues. Those should all be resolved in this updated patch after a revert.

Sorry for the delay. I can confirm this builds correctly for Windows now.

[clayborg]

In D130549#3683617, @smeenai wrote:

In D130549#3683423, @clayborg wrote:

Ping. This was accepted before but I had Buildbot issues. Those should all be resolved in this updated patch after a revert.

Sorry for the delay. I can confirm this builds correctly for Windows now.

Great! Can someone accept the patch?

[clayborg]

FYI: I have built this on mac and on my linux machine, so I know both mac and linux build, and we know windows builds now too

[smeenai]

FWIW, I've usually seen people just recommit directly instead of going through another review. Accepting this since it was already reviewed last time and the only changes are buildbot fixes.

lldb/include/lldb/Utility/FileSpec.h

public:
   /// delimiter, and the filename.
   ///
   /// \param[in] s
   ///     The stream to which to dump the object description.
   void Dump(llvm::raw_ostream &s) const;
 
   Style GetPathStyle() const;
 
-  /// Directory string get accessor.
-  ///
-  /// \return
-  ///     A reference to the directory string object.
-  ConstString &GetDirectory();
-
   /// Directory string const get accessor.
   ///
   /// \return
   ///     A const reference to the directory string object.
-  ConstString GetDirectory() const;
+  const ConstString &GetDirectory() const { return m_directory; }
 
-  /// Filename string get accessor.
+  /// Directory string set accessor.
   ///
-  /// \return
-  ///     A reference to the filename string object.
-  ConstString &GetFilename();
+  /// \param[in] directory
+  ///     The value to replace the directory with.
+  void SetDirectory(ConstString directory);
+  void SetDirectory(llvm::StringRef directory);
+
+  /// Clear the directory in this object.
+  void ClearDirectory();
+
 
   /// Filename string const get accessor.
   ///
   /// \return
   ///     A const reference to the filename string object.
-  ConstString GetFilename() const;
+  const ConstString &GetFilename() const { return m_filename; }
+
+  /// Filename string set accessor.
+  ///
+  /// \param[in] filename
+  ///     The const string to replace the directory with.
+  void SetFilename(ConstString filename);
+  void SetFilename(llvm::StringRef filename);
+
+  /// Clear the filename in this object.
+  void ClearFilename();
 
   /// Returns true if the filespec represents an implementation source file
   /// (files with a ".c", ".cpp", ".m", ".mm" (many more) extension).
   ///
   /// \return
   ///     \b true if the filespec represents an implementation source
   ///     file, \b false otherwise.
   bool IsSourceImplementationFile() const;
public:
   ///
   /// Extract the directory and path into a std::string, which is returned.
   ///
   /// \return
   ///     Returns a std::string with the directory and filename
   ///     concatenated.
   std::string GetPath(bool denormalize = true) const;
 
-  const char *GetCString(bool denormalize = true) const;
+  /// Get the full path as a ConstString.
+  ///
+  /// This method should only be used when you need a ConstString or the
+  /// const char * from a ConstString to ensure permanent lifetime of C string.
+  /// Anyone needing the path temporarily should use the GetPath() method that
+  /// returns a std:string.
+  ConstString GetPathAsConstString(bool denormalize = true) const;
 
   /// Extract the full path to the file.
   ///
   /// Extract the directory and path into an llvm::SmallVectorImpl<>
   void GetPath(llvm::SmallVectorImpl<char> &path,
                bool denormalize = true) const;
 
   /// Extract the extension of the file.

lldb/source/API/SBFileSpec.cpp

const char *SBFileSpec::GetFilename() const {
 
   return m_opaque_up->GetFilename().AsCString();
 }
 
 const char *SBFileSpec::GetDirectory() const {
   LLDB_INSTRUMENT_VA(this);
 
   FileSpec directory{*m_opaque_up};
-  directory.GetFilename().Clear();
-  return directory.GetCString();
+  directory.ClearFilename();
+  return directory.GetPathAsConstString().GetCString();
 }
 
 void SBFileSpec::SetFilename(const char *filename) {
   LLDB_INSTRUMENT_VA(this, filename);
 
   if (filename && filename[0])
-    m_opaque_up->GetFilename().SetCString(filename);
+    m_opaque_up->SetFilename(filename);
   else
-    m_opaque_up->GetFilename().Clear();
+    m_opaque_up->ClearFilename();
 }
 
 void SBFileSpec::SetDirectory(const char *directory) {
   LLDB_INSTRUMENT_VA(this, directory);
 
   if (directory && directory[0])
-    m_opaque_up->GetDirectory().SetCString(directory);
+    m_opaque_up->SetDirectory(directory);
   else
-    m_opaque_up->GetDirectory().Clear();
+    m_opaque_up->ClearDirectory();
 }
 
 uint32_t SBFileSpec::GetPath(char *dst_path, size_t dst_len) const {
   LLDB_INSTRUMENT_VA(this, dst_path, dst_len);
 
   uint32_t result = m_opaque_up->GetPath(dst_path, dst_len);
 
   if (result == 0 && dst_path && dst_len > 0)

lldb/source/API/SBLaunchInfo.cpp

void SBLaunchInfo::Clear() {
   LLDB_INSTRUMENT_VA(this);
 
   m_opaque_sp->Clear();
 }
 
 const char *SBLaunchInfo::GetWorkingDirectory() const {
   LLDB_INSTRUMENT_VA(this);
 
-  return m_opaque_sp->GetWorkingDirectory().GetCString();
+  return m_opaque_sp->GetWorkingDirectory().GetPathAsConstString().AsCString();
 }
 
 void SBLaunchInfo::SetWorkingDirectory(const char *working_dir) {
   LLDB_INSTRUMENT_VA(this, working_dir);
 
   m_opaque_sp->SetWorkingDirectory(FileSpec(working_dir));
 }
 

lldb/source/API/SBPlatform.cpp

void SBPlatform::SetSP(const lldb::PlatformSP &platform_sp) {
   m_opaque_sp = platform_sp;
 }
 
 const char *SBPlatform::GetWorkingDirectory() {
   LLDB_INSTRUMENT_VA(this);
 
   PlatformSP platform_sp(GetSP());
   if (platform_sp)
-    return platform_sp->GetWorkingDirectory().GetCString();
+    return platform_sp->GetWorkingDirectory().GetPathAsConstString().AsCString();
   return nullptr;
 }
 
 bool SBPlatform::SetWorkingDirectory(const char *path) {
   LLDB_INSTRUMENT_VA(this, path);
 
   PlatformSP platform_sp(GetSP());
   if (platform_sp) {

 SBError SBPlatform::Run(SBPlatformShellCommand &shell_command) {
   LLDB_INSTRUMENT_VA(this, shell_command);
   return ExecuteConnected(
       [&](const lldb::PlatformSP &platform_sp) {
         const char *command = shell_command.GetCommand();
         if (!command)
           return Status("invalid shell command (empty)");
 
-        const char *working_dir = shell_command.GetWorkingDirectory();
-        if (working_dir == nullptr) {
-          working_dir = platform_sp->GetWorkingDirectory().GetCString();
-          if (working_dir)
-            shell_command.SetWorkingDirectory(working_dir);
+        if (shell_command.GetWorkingDirectory() == nullptr) {
+          std::string platform_working_dir =
+              platform_sp->GetWorkingDirectory().GetPath();
+          if (!platform_working_dir.empty())
+            shell_command.SetWorkingDirectory(platform_working_dir.c_str());
         }
         return platform_sp->RunShellCommand(
-            shell_command.m_opaque_ptr->m_shell, command, FileSpec(working_dir),
+            shell_command.m_opaque_ptr->m_shell, command,
+            FileSpec(shell_command.GetWorkingDirectory()),
             &shell_command.m_opaque_ptr->m_status,
             &shell_command.m_opaque_ptr->m_signo,
             &shell_command.m_opaque_ptr->m_output,
             shell_command.m_opaque_ptr->m_timeout);
       });
 }
 
 SBError SBPlatform::Launch(SBLaunchInfo &launch_info) {

lldb/source/API/SBReproducer.cpp

if (auto generator = r.GetGenerator()) {
     return true;
   }
   return false;
 }
 
 const char *SBReproducer::GetPath() {
   LLDB_INSTRUMENT()
   ConstString path;
-  auto &r = Reproducer::Instance();
   if (FileSpec reproducer_path = Reproducer::Instance().GetReproducerPath())
-    path = ConstString(r.GetReproducerPath().GetCString());
+    path = ConstString(reproducer_path.GetPathAsConstString());
   return path.GetCString();
 }
 
 void SBReproducer::SetWorkingDirectory(const char *path) {
   LLDB_INSTRUMENT_VA(path)
   if (auto *g = lldb_private::repro::Reproducer::Instance().GetGenerator()) {
     auto &wp = g->GetOrCreate<repro::WorkingDirectoryProvider>();
     wp.SetDirectory(path);
     auto &fp = g->GetOrCreate<repro::FileProvider>();
     fp.RecordInterestingDirectory(wp.GetDirectory());
   }
 }

lldb/source/Breakpoint/BreakpointResolverFileLine.cpp

Searcher::CallbackReturn BreakpointResolverFileLine::SearchCallback(
   const llvm::Optional<uint16_t> column = m_location_spec.GetColumn();
 
   // We'll create a new SourceLocationSpec that can take into account the
   // relative path case, and we'll use it to resolve the symbol context
   // of the CUs.
   FileSpec search_file_spec = m_location_spec.GetFileSpec();
   const bool is_relative = search_file_spec.IsRelative();
   if (is_relative)
-    search_file_spec.GetDirectory().Clear();
+    search_file_spec.ClearDirectory();
   SourceLocationSpec search_location_spec(
       search_file_spec, m_location_spec.GetLine().value_or(0),
       m_location_spec.GetColumn(), m_location_spec.GetCheckInlines(),
       m_location_spec.GetExactMatch());
 
   const size_t num_comp_units = context.module_sp->GetNumCompileUnits();
   for (size_t i = 0; i < num_comp_units; i++) {
     CompUnitSP cu_sp(context.module_sp->GetCompileUnitAtIndex(i));

lldb/source/Commands/CommandObjectLog.cpp

bool DoExecute(Args &args, CommandReturnObject &result) override {
     if (m_options.log_file) {
       const File::OpenOptions flags = File::eOpenOptionWriteOnly |
                                       File::eOpenOptionCanCreate |
                                       File::eOpenOptionTruncate;
       llvm::Expected<FileUP> file = FileSystem::Instance().Open(
           m_options.log_file, flags, lldb::eFilePermissionsFileDefault, false);
       if (!file) {
         result.AppendErrorWithFormat("Unable to open log file '%s': %s",
-                                     m_options.log_file.GetCString(),
+                                     m_options.log_file.GetPath().c_str(),
                                      llvm::toString(file.takeError()).c_str());
         return false;
       }
       stream_up = std::make_unique<llvm::raw_fd_ostream>(
           (*file)->GetDescriptor(), /*shouldClose=*/true);
     } else {
       stream_up = std::make_unique<llvm::raw_fd_ostream>(
           GetDebugger().GetOutputFile().GetDescriptor(), /*shouldClose=*/false);

lldb/source/Commands/CommandObjectTarget.cpp

if (argc == 1 || core_file || remote_file) {
         ModuleSP module_sp =
             target_sp->GetOrCreateModule(main_module_spec, true /* notify */);
         if (module_sp)
           module_sp->SetPlatformFileSpec(remote_file);
       }
 
       if (core_file) {
         FileSpec core_file_dir;
-        core_file_dir.GetDirectory() = core_file.GetDirectory();
+        core_file_dir.SetDirectory(core_file.GetDirectory());
         target_sp->AppendExecutableSearchPaths(core_file_dir);
 
         ProcessSP process_sp(target_sp->CreateProcess(
             GetDebugger().GetListener(), llvm::StringRef(), &core_file, false));
 
         if (process_sp) {
           // Seems weird that we Launch a core file, but that is what we
           // do!
if (!symbol_fspec) {
       return false;
     }
 
     char symfile_path[PATH_MAX];
     symbol_fspec.GetPath(symfile_path, sizeof(symfile_path));
 
     if (!module_spec.GetUUID().IsValid()) {
       if (!module_spec.GetFileSpec() && !module_spec.GetPlatformFileSpec())
-        module_spec.GetFileSpec().GetFilename() = symbol_fspec.GetFilename();
+        module_spec.GetFileSpec().SetFilename(symbol_fspec.GetFilename());
     }
 
     // Now module_spec represents a symbol file for a module that might exist
     // in the current target.  Let's find possible matches.
     ModuleList matching_modules;
 
     // First extract all module specs from the symbol file
     lldb_private::ModuleSpecList symfile_module_specs;
while (matching_modules.IsEmpty()) {
       if (!filename_no_extension)
         break;
 
       // Check if there was no extension to strip and the basename is the same
       if (filename_no_extension == module_spec.GetFileSpec().GetFilename())
         break;
 
       // Replace basename with one fewer extension
-      module_spec.GetFileSpec().GetFilename() = filename_no_extension;
+      module_spec.GetFileSpec().SetFilename(filename_no_extension);
       target->GetImages().FindModules(module_spec, matching_modules);
     }
 
     if (matching_modules.GetSize() > 1) {
       result.AppendErrorWithFormat("multiple modules match symbol file '%s', "
                                    "use the --uuid option to resolve the "
                                    "ambiguity.\n",
                                    symfile_path);

lldb/source/Core/Debugger.cpp

std::string str =
       lldb_private::ansi::FormatAnsiTerminalCodes(new_prompt, GetUseColor());
   if (str.length())
     new_prompt = str;
   GetCommandInterpreter().UpdatePrompt(new_prompt);
 }
 
 llvm::StringRef Debugger::GetReproducerPath() const {
   auto &r = repro::Reproducer::Instance();
-  return r.GetReproducerPath().GetCString();
+  return r.GetReproducerPath().GetPathAsConstString().AsCString();
 }
 
 const FormatEntity::Entry *Debugger::GetThreadFormat() const {
   const uint32_t idx = ePropertyThreadFormat;
   return m_collection_sp->GetPropertyAtIndexAsFormatEntity(nullptr, idx);
 }
 
 const FormatEntity::Entry *Debugger::GetThreadStopFormat() const {

lldb/source/Core/IOHandlerCursesGUI.cpp

public:
 
   void SetCoreFile(TargetSP target_sp) {
     if (!m_core_file_field->IsSpecified())
       return;
 
     FileSpec core_file_spec = m_core_file_field->GetResolvedFileSpec();
 
     FileSpec core_file_directory_spec;
-    core_file_directory_spec.GetDirectory() = core_file_spec.GetDirectory();
+    core_file_directory_spec.SetDirectory(core_file_spec.GetDirectory());
     target_sp->AppendExecutableSearchPaths(core_file_directory_spec);
 
     ProcessSP process_sp(target_sp->CreateProcess(
         m_debugger.GetListener(), llvm::StringRef(), &core_file_spec, false));
 
     if (!process_sp) {
       SetError("Unable to find process plug-in for core file!");
       return;

lldb/source/Expression/FunctionCaller.cpp

bool FunctionCaller::WriteFunctionWrapper(
   }
 
   if (m_parser->GetGenerateDebugInfo()) {
     lldb::ModuleSP jit_module_sp(m_execution_unit_sp->GetJITModule());
 
     if (jit_module_sp) {
       ConstString const_func_name(FunctionName());
       FileSpec jit_file;
-      jit_file.GetFilename() = const_func_name;
+      jit_file.SetFilename(const_func_name);
       jit_module_sp->SetFileSpecAndObjectName(jit_file, ConstString());
       m_jit_module_wp = jit_module_sp;
-      process->GetTarget().GetImages().Append(jit_module_sp, 
+      process->GetTarget().GetImages().Append(jit_module_sp,
                                               true /* notify */);
     }
   }
   if (process && m_jit_start_addr)
     m_jit_process_wp = process->shared_from_this();
 
   m_JITted = true;
 

lldb/source/Expression/REPL.cpp

lldb::REPLSP REPL::Create(Status &err, lldb::LanguageType language,
 
   return ret;
 }
 
 std::string REPL::GetSourcePath() {
   ConstString file_basename = GetSourceFileBasename();
   FileSpec tmpdir_file_spec = HostInfo::GetProcessTempDir();
   if (tmpdir_file_spec) {
-    tmpdir_file_spec.GetFilename() = file_basename;
+    tmpdir_file_spec.SetFilename(file_basename);
     m_repl_source_path = tmpdir_file_spec.GetPath();
   } else {
     tmpdir_file_spec = FileSpec("/tmp");
     tmpdir_file_spec.AppendPathComponent(file_basename.GetStringRef());
   }
 
   return tmpdir_file_spec.GetPath();
 }

lldb/source/Host/common/FileAction.cpp

 
 void FileAction::Clear() {
   m_action = eFileActionNone;
   m_fd = -1;
   m_arg = -1;
   m_file_spec.Clear();
 }
 
-llvm::StringRef FileAction::GetPath() const { return m_file_spec.GetCString(); }
+llvm::StringRef FileAction::GetPath() const {
+  return m_file_spec.GetPathAsConstString().AsCString();
+}
 
 const FileSpec &FileAction::GetFileSpec() const { return m_file_spec; }
 
 bool FileAction::Open(int fd, const FileSpec &file_spec, bool read,
                       bool write) {
   if ((read || write) && fd >= 0 && file_spec) {
     m_action = eFileActionOpen;
     m_fd = fd;
void FileAction::Dump(Stream &stream) const {
   case eFileActionDuplicate:
     stream.Printf("duplicate fd %d to %d", m_fd, m_arg);
     break;
   case eFileActionNone:
     stream.PutCString("no action");
     break;
   case eFileActionOpen:
     stream.Printf("open fd %d with '%s', OFLAGS = 0x%x", m_fd,
-                  m_file_spec.GetCString(), m_arg);
+                  m_file_spec.GetPath().c_str(), m_arg);
     break;
   }
 }

lldb/source/Host/common/FileSystem.cpp

void FileSystem::Resolve(FileSpec &file_spec) {
   SmallString<128> path;
   file_spec.GetPath(path);
 
   // Resolve the path.
   Resolve(path);
 
   // Update the FileSpec with the resolved path.
   if (file_spec.GetFilename().IsEmpty())
-    file_spec.GetDirectory().SetString(path);
+    file_spec.SetDirectory(path);
   else
     file_spec.SetPath(path);
   file_spec.SetIsResolved(true);
 }
 
 template <typename T>
 static std::unique_ptr<T> GetMemoryBuffer(const llvm::Twine &path,
                                           uint64_t size, uint64_t offset,

lldb/source/Host/common/HostInfoBase.cpp

LLDB_LOGF(log,
               "lib path",
               __FUNCTION__);
     return false;
   }
 
   raw_path = (parent_path + dir).str();
   LLDB_LOGF(log, "HostInfo::%s() derived the path as: %s", __FUNCTION__,
             raw_path.c_str());
-  file_spec.GetDirectory().SetString(raw_path);
+  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.
 
   FileSpec lldb_file_spec(Host::GetModuleFileSpecForHostAddress(
       reinterpret_cast<void *>(HostInfoBase::ComputeSharedLibraryDirectory)));
 
   if (g_shlib_dir_helper)
     g_shlib_dir_helper(lldb_file_spec);
 
   // Remove the filename so that this FileSpec only represents the directory.
-  file_spec.GetDirectory() = lldb_file_spec.GetDirectory();
+  file_spec.SetDirectory(lldb_file_spec.GetDirectory());
 
   return (bool)file_spec.GetDirectory();
 }
 
 bool HostInfoBase::ComputeSupportExeDirectory(FileSpec &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())};
   temp_file_spec.AppendPathComponent(pid_str);
   if (llvm::sys::fs::create_directory(temp_file_spec.GetPath()))
     return false;
 
-  file_spec.GetDirectory().SetCString(temp_file_spec.GetCString());
+  file_spec.SetDirectory(temp_file_spec.GetPathAsConstString());
   return true;
 }
 
 bool HostInfoBase::ComputeTempFileBaseDirectory(FileSpec &file_spec) {
   llvm::SmallVector<char, 16> tmpdir;
   llvm::sys::path::system_temp_directory(/*ErasedOnReboot*/ true, tmpdir);
   file_spec = FileSpec(std::string(tmpdir.data(), tmpdir.size()));
   FileSystem::Instance().Resolve(file_spec);
   return true;
 }
 
 bool HostInfoBase::ComputeGlobalTempFileDirectory(FileSpec &file_spec) {
   file_spec.Clear();
 
   FileSpec temp_file_spec;
   if (!HostInfo::ComputeTempFileBaseDirectory(temp_file_spec))
     return false;
 
   temp_file_spec.AppendPathComponent("lldb");
   if (llvm::sys::fs::create_directory(temp_file_spec.GetPath()))
     return false;
 
-  file_spec.GetDirectory().SetCString(temp_file_spec.GetCString());
+  file_spec.SetDirectory(temp_file_spec.GetPathAsConstString());
   return true;
 }
 
 bool HostInfoBase::ComputeHeaderDirectory(FileSpec &file_spec) {
   // TODO(zturner): Figure out how to compute the header directory for all
   // platforms.
   return false;
 }

lldb/source/Host/linux/HostInfoLinux.cpp

FileSpec HostInfoLinux::GetProgramFileSpec() {
 
   return g_program_filespec;
 }
 
 bool HostInfoLinux::ComputeSupportExeDirectory(FileSpec &file_spec) {
   if (HostInfoPosix::ComputeSupportExeDirectory(file_spec) &&
       file_spec.IsAbsolute() && FileSystem::Instance().Exists(file_spec))
     return true;
-  file_spec.GetDirectory() = GetProgramFileSpec().GetDirectory();
+  file_spec.SetDirectory(GetProgramFileSpec().GetDirectory());
   return !file_spec.GetDirectory().IsEmpty();
 }
 
 bool HostInfoLinux::ComputeSystemPluginsDirectory(FileSpec &file_spec) {
   FileSpec temp_file("/usr/lib" LLDB_LIBDIR_SUFFIX "/lldb/plugins");
   FileSystem::Instance().Resolve(temp_file);
-  file_spec.GetDirectory().SetCString(temp_file.GetPath().c_str());
+  file_spec.SetDirectory(temp_file.GetPath());
   return true;
 }
 
 bool HostInfoLinux::ComputeUserPluginsDirectory(FileSpec &file_spec) {
   // XDG Base Directory Specification
   // http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html If
   // XDG_DATA_HOME exists, use that, otherwise use ~/.local/share/lldb.
   const char *xdg_data_home = getenv("XDG_DATA_HOME");
   if (xdg_data_home && xdg_data_home[0]) {
     std::string user_plugin_dir(xdg_data_home);
     user_plugin_dir += "/lldb";
-    file_spec.GetDirectory().SetCString(user_plugin_dir.c_str());
+    file_spec.SetDirectory(user_plugin_dir.c_str());
   } else
-    file_spec.GetDirectory().SetCString("~/.local/share/lldb");
+    file_spec.SetDirectory("~/.local/share/lldb");
   return true;
 }
 
 void HostInfoLinux::ComputeHostArchitectureSupport(ArchSpec &arch_32,
                                                    ArchSpec &arch_64) {
   HostInfoPosix::ComputeHostArchitectureSupport(arch_32, arch_64);
 
   const char *distribution_id = GetDistributionId().data();

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

LaunchInNewTerminalWithAppleScript(const char *exe_path,
 
   StreamString command;
   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");
+  darwin_debug_file_spec.SetFilename("darwin-debug");
 
   if (!FileSystem::Instance().Exists(darwin_debug_file_spec)) {
     error.SetErrorStringWithFormat(
         "the 'darwin-debug' executable doesn't exists at '%s'",
         darwin_debug_file_spec.GetPath().c_str());
     return error;
   }
 
   char launcher_path[PATH_MAX];
   darwin_debug_file_spec.GetPath(launcher_path, sizeof(launcher_path));
 
   const ArchSpec &arch_spec = launch_info.GetArchitecture();
   // Only set the architecture if it is valid and if it isn't Haswell (x86_64h).
   if (arch_spec.IsValid() &&
       arch_spec.GetCore() != ArchSpec::eCore_x86_64_x86_64h)
     command.Printf("arch -arch %s ", arch_spec.GetArchitectureName());
 
   command.Printf(R"(\"%s\" --unix-socket=%s)", launcher_path, unix_socket_name);
 
   if (arch_spec.IsValid())
     command.Printf(" --arch=%s", arch_spec.GetArchitectureName());
 
   FileSpec working_dir{launch_info.GetWorkingDirectory()};
   if (working_dir)
-    command.Printf(R"( --working-dir \"%s\")", working_dir.GetCString());
+    command.Printf(R"( --working-dir \"%s\")", working_dir.GetPath().c_str());
   else {
     char cwd[PATH_MAX];
     if (getcwd(cwd, PATH_MAX))
       command.Printf(R"( --working-dir \"%s\")", cwd);
   }
 
   if (launch_info.GetFlags().Test(eLaunchFlagDisableASLR))
     command.PutCString(" --disable-aslr");
if (argv == NULL) {
     tmp_argv[0] = exe_path;
     tmp_argv[1] = NULL;
     argv = const_cast<char *const *>(tmp_argv);
   }
 
   FileSpec working_dir{launch_info.GetWorkingDirectory()};
   if (working_dir) {
     // Set the working directory on this thread only
-    if (__pthread_chdir(working_dir.GetCString()) < 0) {
+    std::string working_dir_path = working_dir.GetPath();
+    if (__pthread_chdir(working_dir_path.c_str()) < 0) {
       if (errno == ENOENT) {
         error.SetErrorStringWithFormat("No such file or directory: %s",
-                                       working_dir.GetCString());
+                                       working_dir_path.c_str());
       } else if (errno == ENOTDIR) {
         error.SetErrorStringWithFormat("Path doesn't name a directory: %s",
-                                       working_dir.GetCString());
+                                       working_dir_path.c_str());
       } else {
         error.SetErrorStringWithFormat("An unknown error occurred when "
                                        "changing directory for process "
                                        "execution.");
       }
       return error;
     }
   }

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

#endif
     if (dir_realpath) {
       raw_path = dir_realpath;
       free(dir_realpath);
     } else {
       raw_path = support_dir_spec.GetPath();
     }
   }
 
-  file_spec.GetDirectory().SetString(
-      llvm::StringRef(raw_path.c_str(), raw_path.size()));
+  file_spec.SetDirectory(raw_path);
   return (bool)file_spec.GetDirectory();
 }
 
 bool HostInfoMacOSX::ComputeHeaderDirectory(FileSpec &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()));
+  file_spec.SetDirectory(raw_path);
   return true;
 }
 
 bool HostInfoMacOSX::ComputeSystemPluginsDirectory(FileSpec &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;
 
   framework_pos += strlen("LLDB.framework");
   raw_path.resize(framework_pos);
   raw_path.append("/Resources/PlugIns");
-  file_spec.GetDirectory().SetString(
-      llvm::StringRef(raw_path.c_str(), raw_path.size()));
+  file_spec.SetDirectory(raw_path);
   return true;
 }
 
 bool HostInfoMacOSX::ComputeUserPluginsDirectory(FileSpec &file_spec) {
   FileSpec temp_file("~/Library/Application Support/LLDB/PlugIns");
   FileSystem::Instance().Resolve(temp_file);
-  file_spec.GetDirectory().SetCString(temp_file.GetPath().c_str());
+  file_spec.SetDirectory(temp_file.GetPathAsConstString());
   return true;
 }
 
 void HostInfoMacOSX::ComputeHostArchitectureSupport(ArchSpec &arch_32,
                                                     ArchSpec &arch_64) {
   // All apple systems support 32 bit execution.
   uint32_t cputype, cpusubtype;
   uint32_t is_64_bit_capable = false;
#if defined(__i386__) || defined(__x86_64__)
         cpusubtype32 = CPU_SUBTYPE_I386_ALL;
 #elif defined(__arm__) || defined(__arm64__) || defined(__aarch64__)
       if (cputype == CPU_TYPE_ARM || cputype == CPU_TYPE_ARM64)
         cpusubtype32 = CPU_SUBTYPE_ARM_V7S;
 #endif
       arch_32.SetArchitecture(eArchTypeMachO, cputype & ~(CPU_ARCH_MASK),
                               cpusubtype32);
 
-      if (cputype == CPU_TYPE_ARM || 
-          cputype == CPU_TYPE_ARM64 || 
+      if (cputype == CPU_TYPE_ARM ||
+          cputype == CPU_TYPE_ARM64 ||
           cputype == CPU_TYPE_ARM64_32) {
 // When running on a watch or tv, report the host os correctly
 #if defined(TARGET_OS_TV) && TARGET_OS_TV == 1
         arch_32.GetTriple().setOS(llvm::Triple::TvOS);
         arch_64.GetTriple().setOS(llvm::Triple::TvOS);
 #elif defined(TARGET_OS_BRIDGE) && TARGET_OS_BRIDGE == 1
         arch_32.GetTriple().setOS(llvm::Triple::BridgeOS);
         arch_64.GetTriple().setOS(llvm::Triple::BridgeOS);

lldb/source/Host/posix/FileSystemPosix.cpp

 
 using namespace lldb;
 using namespace lldb_private;
 
 const char *FileSystem::DEV_NULL = "/dev/null";
 
 Status FileSystem::Symlink(const FileSpec &src, const FileSpec &dst) {
   Status error;
-  if (::symlink(dst.GetCString(), src.GetCString()) == -1)
+  if (::symlink(dst.GetPath().c_str(), src.GetPath().c_str()) == -1)
     error.SetErrorToErrno();
   return error;
 }
 
 Status FileSystem::Readlink(const FileSpec &src, FileSpec &dst) {
   Status error;
   char buf[PATH_MAX];
   ssize_t count = ::readlink(src.GetPath().c_str(), buf, sizeof(buf) - 1);
   if (count < 0)
     error.SetErrorToErrno();
   else {
     buf[count] = '\0'; // Success
     dst.SetFile(buf, FileSpec::Style::native);
   }
   return error;
 }
 
 Status FileSystem::ResolveSymbolicLink(const FileSpec &src, FileSpec &dst) {
   char resolved_path[PATH_MAX];
   if (!src.GetPath(resolved_path, sizeof(resolved_path))) {
-    return Status("Couldn't get the canonical path for %s", src.GetCString());
+    return Status("Couldn't get the canonical path for %s",
+                  src.GetPath().c_str());
   }
 
   char real_path[PATH_MAX + 1];
   if (realpath(resolved_path, real_path) == nullptr) {
     Status err;
     err.SetErrorToErrno();
     return err;
   }

lldb/source/Host/posix/HostInfoPosix.cpp

 }
 
 bool HostInfoPosix::ComputeSupportExeDirectory(FileSpec &file_spec) {
   return ComputePathRelativeToLibrary(file_spec, "/bin");
 }
 
 bool HostInfoPosix::ComputeHeaderDirectory(FileSpec &file_spec) {
   FileSpec temp_file("/opt/local/include/lldb");
-  file_spec.GetDirectory().SetCString(temp_file.GetPath().c_str());
+  file_spec.SetDirectory(temp_file.GetPath());
   return true;
 }
 
 bool HostInfoPosix::GetEnvironmentVar(const std::string &var_name,
                                       std::string &var) {
   if (const char *pvar = ::getenv(var_name.c_str())) {
     var = std::string(pvar);
     return true;
   }
   return false;
 }

lldb/source/Host/windows/FileSystem.cpp

 const char *FileSystem::DEV_NULL = "nul";
 
 const char *FileSystem::PATH_CONVERSION_ERROR =
     "Error converting path between UTF-8 and native encoding";
 
 Status FileSystem::Symlink(const FileSpec &src, const FileSpec &dst) {
   Status error;
   std::wstring wsrc, wdst;
-  if (!llvm::ConvertUTF8toWide(src.GetCString(), wsrc) ||
-      !llvm::ConvertUTF8toWide(dst.GetCString(), wdst))
+  if (!llvm::ConvertUTF8toWide(src.GetPath(), wsrc) ||
+      !llvm::ConvertUTF8toWide(dst.GetPath(), wdst))
     error.SetErrorString(PATH_CONVERSION_ERROR);
   if (error.Fail())
     return error;
   DWORD attrib = ::GetFileAttributesW(wdst.c_str());
   if (attrib == INVALID_FILE_ATTRIBUTES) {
     error.SetError(::GetLastError(), lldb::eErrorTypeWin32);
     return error;
   }
   bool is_directory = !!(attrib & FILE_ATTRIBUTE_DIRECTORY);
   DWORD flag = is_directory ? SYMBOLIC_LINK_FLAG_DIRECTORY : 0;
   BOOL result = ::CreateSymbolicLinkW(wsrc.c_str(), wdst.c_str(), flag);
   if (!result)
     error.SetError(::GetLastError(), lldb::eErrorTypeWin32);
   return error;
 }
 
 Status FileSystem::Readlink(const FileSpec &src, FileSpec &dst) {
   Status error;
   std::wstring wsrc;
-  if (!llvm::ConvertUTF8toWide(src.GetCString(), wsrc)) {
+  if (!llvm::ConvertUTF8toWide(src.GetPath(), wsrc)) {
     error.SetErrorString(PATH_CONVERSION_ERROR);
     return error;
   }
 
   HANDLE h = ::CreateFileW(wsrc.c_str(), GENERIC_READ,
                            FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
                            OPEN_EXISTING, FILE_FLAG_OPEN_REPARSE_POINT, NULL);
   if (h == INVALID_HANDLE_VALUE) {

lldb/source/Host/windows/ProcessLauncherWindows.cpp

ProcessLauncherWindows::LaunchProcess(const ProcessLaunchInfo &launch_info,
   env_block = environment.data();
 
   executable = launch_info.GetExecutableFile().GetPath();
   std::wstring wcommandLine;
   GetFlattenedWindowsCommandString(launch_info.GetArguments(), wcommandLine);
 
   std::wstring wexecutable, wworkingDirectory;
   llvm::ConvertUTF8toWide(executable, wexecutable);
-  llvm::ConvertUTF8toWide(launch_info.GetWorkingDirectory().GetCString(),
+  llvm::ConvertUTF8toWide(launch_info.GetWorkingDirectory().GetPath(),
                           wworkingDirectory);
   // If the command line is empty, it's best to pass a null pointer to tell
   // CreateProcessW to use the executable name as the command line.  If the
   // command line is not empty, its contents may be modified by CreateProcessW.
   WCHAR *pwcommandLine = wcommandLine.empty() ? nullptr : &wcommandLine[0];
 
   BOOL result = ::CreateProcessW(
       wexecutable.c_str(), pwcommandLine, NULL, NULL, TRUE, flags, env_block,

lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderDarwin.cpp

if (image_object_file) {
               // so check to see what the segment name is and pass "false" so
               // we don't warn of overlapping "Section" objects, and "true" for
               // all other sections.
               const bool warn_multiple =
                   section_sp->GetName() != g_section_name_LINKEDIT;
 
               changed = m_process->GetTarget().SetSectionLoadAddress(
                   section_sp, new_section_load_addr, warn_multiple);
-            } 
+            }
           }
         }
 
         // If the loaded the file (it changed) and we have segments that are
         // not readable or writeable, add them to the invalid memory region
         // cache for the process. This will typically only be the __PAGEZERO
         // segment in the main executable. We might be able to apply this more
         // generally to more sections that have no protections in the future,
void DynamicLoaderDarwin::UpdateSpecialBinariesFromNewImageInfos(
   Target &target = m_process->GetTarget();
   Log *log = GetLog(LLDBLog::DynamicLoader);
   ConstString g_dyld_sim_filename("dyld_sim");
 
   ArchSpec target_arch = target.GetArchitecture();
   const size_t image_infos_size = image_infos.size();
   for (size_t i = 0; i < image_infos_size; i++) {
     if (image_infos[i].header.filetype == llvm::MachO::MH_DYLINKER) {
-      // In a "simulator" process we will have two dyld modules -- 
-      // a "dyld" that we want to keep track of, and a "dyld_sim" which 
+      // In a "simulator" process we will have two dyld modules --
+      // a "dyld" that we want to keep track of, and a "dyld_sim" which
       // we don't need to keep track of here.  dyld_sim will have a non-macosx
       // OS.
       if (target_arch.GetTriple().getEnvironment() == llvm::Triple::Simulator &&
           image_infos[i].os_type != llvm::Triple::OSType::MacOSX) {
         continue;
       }
 
       dyld_idx = i;
-    } 
+    }
     if (image_infos[i].header.filetype == llvm::MachO::MH_EXECUTE) {
       exe_idx = i;
     }
   }
 
   // Set the target executable if we haven't found one so far.
   if (exe_idx != UINT32_MAX && !target.GetExecutableModule()) {
     const bool can_create = true;
if (image_module_sp) {
                                    image_infos[idx].GetArchitecture());
             module_spec.GetObjectName() = commpage_dbstr;
             ModuleSP commpage_image_module_sp(
                 target_images.FindFirstModule(module_spec));
             if (!commpage_image_module_sp) {
               module_spec.SetObjectOffset(objfile->GetFileOffset() +
                                           commpage_section->GetFileOffset());
               module_spec.SetObjectSize(objfile->GetByteSize());
-              commpage_image_module_sp = target.GetOrCreateModule(module_spec, 
+              commpage_image_module_sp = target.GetOrCreateModule(module_spec,
                                                                true /* notify */);
               if (!commpage_image_module_sp ||
                   commpage_image_module_sp->GetObjectFile() == nullptr) {
                 commpage_image_module_sp = m_process->ReadModuleFromMemory(
                     image_infos[idx].file_spec, image_infos[idx].address);
                 // Always load a memory image right away in the target in case
                 // we end up trying to read the symbol table from memory... The
                 // __LINKEDIT will need to be mapped so we can figure out where

 
 }
 
 lldb::ModuleSP DynamicLoaderDarwin::GetPThreadLibraryModule() {
   ModuleSP module_sp = m_libpthread_module_wp.lock();
   if (!module_sp) {
     SymbolContextList sc_list;
     ModuleSpec module_spec;
-    module_spec.GetFileSpec().GetFilename().SetCString(
-        "libsystem_pthread.dylib");
+    module_spec.GetFileSpec().SetFilename("libsystem_pthread.dylib");
     ModuleList module_list;
     m_process->GetTarget().GetImages().FindModules(module_spec, module_list);
     if (!module_list.IsEmpty()) {
       if (module_list.GetSize() == 1) {
         module_sp = module_list.GetModuleAtIndex(0);
         if (module_sp)
           m_libpthread_module_wp = module_sp;
       }

lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DYLDRendezvous.cpp

 
 void DYLDRendezvous::UpdateExecutablePath() {
   if (m_process) {
     Log *log = GetLog(LLDBLog::DynamicLoader);
     Module *exe_mod = m_process->GetTarget().GetExecutableModulePointer();
     if (exe_mod) {
       m_exe_file_spec = exe_mod->GetPlatformFileSpec();
       LLDB_LOGF(log, "DYLDRendezvous::%s exe module executable path set: '%s'",
-                __FUNCTION__, m_exe_file_spec.GetCString());
+                __FUNCTION__, m_exe_file_spec.GetPath().c_str());
     } else {
       LLDB_LOGF(log,
                 "DYLDRendezvous::%s cannot cache exe module path: null "
                 "executable module pointer",
                 __FUNCTION__);
     }
   }
 }
void DYLDRendezvous::DumpToLog(Log *log) const {
 
   iterator I = begin();
   iterator E = end();
 
   if (I != E)
     log->PutCString("DYLDRendezvous SOEntries:");
 
   for (int i = 1; I != E; ++I, ++i) {
-    LLDB_LOGF(log, "\n   SOEntry [%d] %s", i, I->file_spec.GetCString());
+    LLDB_LOGF(log, "\n   SOEntry [%d] %s", i, I->file_spec.GetPath().c_str());
     LLDB_LOGF(log, "      Base : %" PRIx64, I->base_addr);
     LLDB_LOGF(log, "      Path : %" PRIx64, I->path_addr);
     LLDB_LOGF(log, "      Dyn  : %" PRIx64, I->dyn_addr);
     LLDB_LOGF(log, "      Next : %" PRIx64, I->next);
     LLDB_LOGF(log, "      Prev : %" PRIx64, I->prev);
   }
 }

lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp

if (module_sp.get()) {
       LLDB_LOG(log, "LoadAllCurrentModules loading module: {0}",
                I->file_spec.GetFilename());
       module_list.Append(module_sp);
     } else {
       Log *log = GetLog(LLDBLog::DynamicLoader);
       LLDB_LOGF(
           log,
           "DynamicLoaderPOSIXDYLD::%s failed loading module %s at 0x%" PRIx64,
-          __FUNCTION__, I->file_spec.GetCString(), I->base_addr);
+          __FUNCTION__, I->file_spec.GetPath().c_str(), I->base_addr);
     }
   }
 
   m_process->GetTarget().ModulesDidLoad(module_list);
   m_initial_modules_added = true;
 }
 
 addr_t DynamicLoaderPOSIXDYLD::ComputeLoadOffset() {

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp

case eSymbolTypeReExported: {
         ModuleSP reexport_module_sp;
         ModuleSpec reexport_module_spec;
         reexport_module_spec.GetPlatformFileSpec() =
             sym_ctx.symbol->GetReExportedSymbolSharedLibrary();
         if (reexport_module_spec.GetPlatformFileSpec()) {
           reexport_module_sp =
               target.GetImages().FindFirstModule(reexport_module_spec);
           if (!reexport_module_sp) {
-            reexport_module_spec.GetPlatformFileSpec().GetDirectory().Clear();
+            reexport_module_spec.GetPlatformFileSpec().ClearDirectory();
             reexport_module_sp =
                 target.GetImages().FindFirstModule(reexport_module_spec);
           }
         }
         symbol_load_addr = GetSymbolAddress(
             target, process, sym_ctx.symbol->GetReExportedSymbolName(),
             symbol_type, reexport_module_sp.get());
       }

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

for (const auto &Suffix : kResourceDirSuffixes) {
     llvm::SmallString<32> relative_path(Suffix);
     llvm::sys::path::native(relative_path);
     llvm::sys::path::append(clang_dir, relative_path);
     if (!verify || VerifyClangPath(clang_dir)) {
       LLDB_LOG(log,
                "DefaultComputeClangResourceDir: Setting ClangResourceDir "
                "to \"{0}\", verify = {1}",
                clang_dir.str(), verify ? "true" : "false");
-      file_spec.GetDirectory().SetString(clang_dir);
+      file_spec.SetDirectory(clang_dir);
       FileSystem::Instance().Resolve(file_spec);
       return true;
     }
   }
 
   return false;
 }
 
#else
   if (parent != r_end && *parent == "SharedFrameworks") {
     // This is the top-level LLDB in the Xcode.app bundle.
     // E.g., "Xcode.app/Contents/SharedFrameworks/LLDB.framework/Versions/A"
     raw_path.resize(parent - r_end);
     llvm::sys::path::append(clang_path, raw_path,
                             "Developer/Toolchains/XcodeDefault.xctoolchain",
                             swift_clang_resource_dir);
     if (!verify || VerifyClangPath(clang_path)) {
-      file_spec.GetDirectory().SetString(clang_path.c_str());
+      file_spec.SetDirectory(clang_path);
       FileSystem::Instance().Resolve(file_spec);
       return true;
     }
   } else if (parent != r_end && *parent == "PrivateFrameworks" &&
              std::distance(parent, r_end) > 2) {
     ++parent;
     ++parent;
     if (*parent == "System") {
       // This is LLDB inside an Xcode toolchain.
       // E.g., "Xcode.app/Contents/Developer/Toolchains/"               \
       //       "My.xctoolchain/System/Library/PrivateFrameworks/LLDB.framework"
       raw_path.resize(parent - r_end);
       llvm::sys::path::append(clang_path, raw_path, swift_clang_resource_dir);
       if (!verify || VerifyClangPath(clang_path)) {
-        file_spec.GetDirectory().SetString(clang_path.c_str());
+        file_spec.SetDirectory(clang_path);
         FileSystem::Instance().Resolve(file_spec);
         return true;
       }
     }
   }
 
   // Fall back to the Clang resource directory inside the framework.
   raw_path = lldb_shlib_spec.GetPath();
   raw_path.resize(rev_it - r_end);
   raw_path.append("LLDB.framework/Resources/Clang");
-  file_spec.GetDirectory().SetString(raw_path.c_str());
+  file_spec.SetDirectory(raw_path);
   FileSystem::Instance().Resolve(file_spec);
   return true;
 #endif // __APPLE__
 }
 
 FileSpec lldb_private::GetClangResourceDir() {
   static FileSpec g_cached_resource_dir;
   static llvm::once_flag g_once_flag;

lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.cpp

bool ClangUserExpression::Parse(DiagnosticManager &diagnostic_manager,
   }
 
   if (generate_debug_info) {
     lldb::ModuleSP jit_module_sp(m_execution_unit_sp->GetJITModule());
 
     if (jit_module_sp) {
       ConstString const_func_name(FunctionName());
       FileSpec jit_file;
-      jit_file.GetFilename() = const_func_name;
+      jit_file.SetFilename(const_func_name);
       jit_module_sp->SetFileSpecAndObjectName(jit_file, ConstString());
       m_jit_module_wp = jit_module_sp;
       target->GetImages().Append(jit_module_sp);
     }
   }
 
   if (process && m_jit_start_addr != LLDB_INVALID_ADDRESS)
     m_jit_process_wp = lldb::ProcessWP(process->shared_from_this());

lldb/source/Plugins/ExpressionParser/Clang/ClangUtilityFunction.cpp

bool ClangUtilityFunction::Install(DiagnosticManager &diagnostic_manager,
   if (m_jit_start_addr != LLDB_INVALID_ADDRESS) {
     m_jit_process_wp = process->shared_from_this();
     if (parser.GetGenerateDebugInfo()) {
       lldb::ModuleSP jit_module_sp(m_execution_unit_sp->GetJITModule());
 
       if (jit_module_sp) {
         ConstString const_func_name(FunctionName());
         FileSpec jit_file;
-        jit_file.GetFilename() = const_func_name;
+        jit_file.SetFilename(const_func_name);
         jit_module_sp->SetFileSpecAndObjectName(jit_file, ConstString());
         m_jit_module_wp = jit_module_sp;
         target->GetImages().Append(jit_module_sp);
       }
     }
   }
 
   DeclMap()->DidParse();

lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp

empirical_type<uint32_t>
       type_vec_size; // Vector size of each data point, e.g '4' for uchar4
   empirical_type<uint32_t> field_count; // Number of Subelements
   empirical_type<uint32_t> datum_size;  // Size of a single Element with padding
   empirical_type<uint32_t> padding;     // Number of padding bytes
   empirical_type<uint32_t>
       array_size;        // Number of items in array, only needed for structs
   ConstString type_name; // Name of type, only needed for structs
 
-  static ConstString 
+  static ConstString
   GetFallbackStructName(); // Print this as the type name of a struct Element
                            // If we can't resolve the actual struct name
 
   bool ShouldRefresh() const {
     const bool valid_ptr = element_ptr.isValid() && *element_ptr.get() != 0x0;
     const bool valid_type =
         type.isValid() && type_vec_size.isValid() && type_kind.isValid();
     return !valid_ptr || !valid_type || !datum_size.isValid();
for (const auto &reduction : module_desc->m_reductions) {
           bool new_bp;
           if (!SkipPrologue(module, address)) {
             LLDB_LOGF(log, "%s: Error trying to skip prologue", __FUNCTION__);
           }
           breakpoint_sp->AddLocation(address, &new_bp);
           LLDB_LOGF(log, "%s: %s reduction breakpoint on %s in %s",
                     __FUNCTION__, new_bp ? "new" : "existing",
                     kernel_name.GetCString(),
-                    address.GetModule()->GetFileSpec().GetCString());
+                    address.GetModule()->GetFileSpec().GetPath().c_str());
         }
       }
     }
   }
   return eCallbackReturnContinue;
 }
 
 Searcher::CallbackReturn RSScriptGroupBreakpointResolver::SearchCallback(
if (!buffer)
     return false;
 
   // split rs.info. contents into lines
   llvm::SmallVector<llvm::StringRef, 128> info_lines;
   {
     const llvm::StringRef raw_rs_info((const char *)buffer->GetBytes());
     raw_rs_info.split(info_lines, '\n');
     LLDB_LOGF(log, "'.rs.info symbol for '%s':\n%s",
-              m_module->GetFileSpec().GetCString(), raw_rs_info.str().c_str());
+              m_module->GetFileSpec().GetPath().c_str(),
+              raw_rs_info.str().c_str());
   }
 
   enum {
     eExportVar,
     eExportForEach,
     eExportReduce,
     ePragma,
     eBuildChecksum,

lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp

for (i = 0; i < m_header.ncmds; ++i) {
     case LC_LOAD_UPWARD_DYLIB: {
       uint32_t name_offset = cmd_offset + m_data.GetU32(&offset);
       const char *path = m_data.PeekCStr(name_offset);
       if (path) {
         FileSpec file_spec(path);
         // Strip the path if there is @rpath, @executable, etc so we just use
         // the basename
         if (path[0] == '@')
-          file_spec.GetDirectory().Clear();
+          file_spec.ClearDirectory();
 
         if (lc.cmd == LC_REEXPORT_DYLIB) {
           m_reexported_dylibs.AppendIfUnique(file_spec);
         }
 
         dylib_files.Append(file_spec);
       }
     } break;

lldb/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp

if (llvm::Error e = entry.getName(dll_name)) {
       continue;
     }
 
     // At this moment we only have the base name of the DLL. The full path can
     // only be seen after the dynamic loading.  Our best guess is Try to get it
     // with the help of the object file's directory.
     llvm::SmallString<128> dll_fullpath;
     FileSpec dll_specs(dll_name);
-    dll_specs.GetDirectory().SetString(m_file.GetDirectory().GetCString());
+    dll_specs.SetDirectory(m_file.GetDirectory());
 
     if (!llvm::sys::fs::real_path(dll_specs.GetPath(), dll_fullpath))
       m_deps_filespec->EmplaceBack(dll_fullpath);
     else {
       // Known DLLs or DLL not found in the object file directory.
       m_deps_filespec->EmplaceBack(dll_name);
     }
   }

lldb/source/Plugins/ObjectFile/PECOFF/WindowsMiniDump.cpp

 bool SaveMiniDump(const lldb::ProcessSP &process_sp,
                   const lldb_private::FileSpec &outfile,
                   lldb_private::Status &error) {
   if (!process_sp)
     return false;
 #ifdef _WIN32
   HANDLE process_handle = ::OpenProcess(
       PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, process_sp->GetID());
-  const std::string file_name = outfile.GetCString();
+  const std::string file_name = outfile.GetPath();
   std::wstring wide_name;
   wide_name.resize(file_name.size() + 1);
   char *result_ptr = reinterpret_cast<char *>(&wide_name[0]);
   const llvm::UTF8 *error_ptr = nullptr;
   if (!llvm::ConvertUTF8toWide(sizeof(wchar_t), file_name, result_ptr,
                                error_ptr)) {
     error.SetErrorString("cannot convert file name");
     return false;

lldb/source/Plugins/Platform/Android/PlatformAndroid.cpp

 Status PlatformAndroid::GetFile(const FileSpec &source,
                                 const FileSpec &destination) {
   if (IsHost() || !m_remote_platform_sp)
     return PlatformLinux::GetFile(source, destination);
 
   FileSpec source_spec(source.GetPath(false), FileSpec::Style::posix);
   if (source_spec.IsRelative())
     source_spec = GetRemoteWorkingDirectory().CopyByAppendingPathComponent(
-        source_spec.GetCString(false));
+        source_spec.GetPathAsConstString(false).GetStringRef());
 
   Status error;
   auto sync_service = GetSyncService(error);
   if (error.Fail())
     return error;
 
   uint32_t mode = 0, size = 0, mtime = 0;
   error = sync_service->Stat(source_spec, mode, size, mtime);
   if (error.Fail())
     return error;
 
   if (mode != 0)
     return sync_service->PullFile(source_spec, destination);
 
-  auto source_file = source_spec.GetCString(false);
+  std::string source_file = source_spec.GetPath(false);
 
   Log *log = GetLog(LLDBLog::Platform);
   LLDB_LOGF(log, "Got mode == 0 on '%s': try to get file via 'shell cat'",
-            source_file);
+            source_file.c_str());
 
-  if (strchr(source_file, '\'') != nullptr)
+  if (strchr(source_file.c_str(), '\'') != nullptr)
     return Status("Doesn't support single-quotes in filenames");
 
   // mode == 0 can signify that adbd cannot access the file due security
   // constraints - try "cat ..." as a fallback.
   AdbClient adb(m_device_id);
 
   char cmd[PATH_MAX];
-  snprintf(cmd, sizeof(cmd), "cat '%s'", source_file);
+  snprintf(cmd, sizeof(cmd), "cat '%s'", source_file.c_str());
 
   return adb.ShellToFile(cmd, minutes(1), destination);
 }
 
 Status PlatformAndroid::PutFile(const FileSpec &source,
                                 const FileSpec &destination, uint32_t uid,
                                 uint32_t gid) {
   if (IsHost() || !m_remote_platform_sp)
     return PlatformLinux::PutFile(source, destination, uid, gid);
 
   FileSpec destination_spec(destination.GetPath(false), FileSpec::Style::posix);
   if (destination_spec.IsRelative())
     destination_spec = GetRemoteWorkingDirectory().CopyByAppendingPathComponent(
-        destination_spec.GetCString(false));
+        destination_spec.GetPath(false));
 
   // TODO: Set correct uid and gid on remote file.
   Status error;
   auto sync_service = GetSyncService(error);
   if (error.Fail())
     return error;
   return sync_service->PushFile(source, destination_spec);
 }
Status PlatformAndroid::DownloadSymbolFile(const lldb::ModuleSP &module_sp,
   });
 
   FileSpec symfile_platform_filespec(tmpdir);
   symfile_platform_filespec.AppendPathComponent("symbolized.oat");
 
   // Execute oatdump on the remote device to generate a file with symtab
   StreamString command;
   command.Printf("oatdump --symbolize=%s --output=%s",
-                 module_sp->GetPlatformFileSpec().GetCString(false),
-                 symfile_platform_filespec.GetCString(false));
+                 module_sp->GetPlatformFileSpec().GetPath(false).c_str(),
+                 symfile_platform_filespec.GetPath(false).c_str());
   error = adb.Shell(command.GetData(), minutes(1), nullptr);
   if (error.Fail())
     return Status("Oatdump failed: %s", error.AsCString());
 
   // Download the symbolfile from the remote device
   return GetFile(symfile_platform_filespec, dst_file_spec);
 }
 

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

static Status ExceptionMaskValidator(const char *string, void *unused) {
   llvm::SmallVector<llvm::StringRef> candidates;
   str_ref.split(candidates, '|');
   for (auto candidate : candidates) {
     if (!(candidate == "EXC_BAD_ACCESS"
           || candidate == "EXC_BAD_INSTRUCTION"
           || candidate == "EXC_ARITHMETIC"
           || candidate == "EXC_RESOURCE"
           || candidate == "EXC_GUARD")) {
-      error.SetErrorStringWithFormat("invalid exception type: '%s'", 
+      error.SetErrorStringWithFormat("invalid exception type: '%s'",
           candidate.str().c_str());
       return error;
     }
   }
   return {};
 }
 
 /// Destructor.
public:
   const char *GetIgnoredExceptions() const {
     const uint32_t idx = ePropertyIgnoredExceptions;
     const OptionValueString *option_value =
         m_collection_sp->GetPropertyAtIndexAsOptionValueString(nullptr, false,
                                                                idx);
     assert(option_value);
     return option_value->GetCurrentValue();
   }
-    
   OptionValueString *GetIgnoredExceptionValue() {
     const uint32_t idx = ePropertyIgnoredExceptions;
     OptionValueString *option_value =
         m_collection_sp->GetPropertyAtIndexAsOptionValueString(nullptr, false,
                                                                idx);
     assert(option_value);
     return option_value;
   }
PluginManager::CreateSettingForPlatformPlugin(
         is_global_setting);
     OptionValueString *value = GetGlobalProperties().GetIgnoredExceptionValue();
     value->SetValidator(ExceptionMaskValidator);
   }
 }
 
 Args
 PlatformDarwin::GetExtraStartupCommands() {
-  std::string ignored_exceptions 
+  std::string ignored_exceptions
       = GetGlobalProperties().GetIgnoredExceptions();
   if (ignored_exceptions.empty())
     return {};
   Args ret_args;
   std::string packet = "QSetIgnoredExceptions:";
   packet.append(ignored_exceptions);
   ret_args.AppendArgument(packet);
   return ret_args;
if (module_spec) {
 
               // If we didn't find the python file, then keep stripping the
               // extensions and try again
               ConstString filename_no_extension(
                   module_spec.GetFileNameStrippingExtension());
               if (module_spec.GetFilename() == filename_no_extension)
                 break;
 
-              module_spec.GetFilename() = filename_no_extension;
+              module_spec.SetFilename(filename_no_extension);
             }
           }
         }
       }
     }
   }
   return file_list;
 }
llvm::call_once(g_once_flag, []() {
     FileSpec xcode_contents_dir = HostInfo::GetXcodeContentsDirectory();
     if (xcode_contents_dir) {
       FileSpec xcode_lldb_resources = xcode_contents_dir;
       xcode_lldb_resources.AppendPathComponent("SharedFrameworks");
       xcode_lldb_resources.AppendPathComponent("LLDB.framework");
       xcode_lldb_resources.AppendPathComponent("Resources");
       if (FileSystem::Instance().Exists(xcode_lldb_resources)) {
         FileSpec dir;
-        dir.GetDirectory().SetCString(xcode_lldb_resources.GetPath().c_str());
+        dir.SetDirectory(xcode_lldb_resources.GetPathAsConstString());
         g_executable_dirs.push_back(dir);
       }
     }
     // Xcode might not be installed so we also check for the Command Line Tools.
     FileSpec command_line_tools_dir = GetCommandLineToolsLibraryPath();
     if (command_line_tools_dir) {
       FileSpec cmd_line_lldb_resources = command_line_tools_dir;
       cmd_line_lldb_resources.AppendPathComponent("PrivateFrameworks");
       cmd_line_lldb_resources.AppendPathComponent("LLDB.framework");
       cmd_line_lldb_resources.AppendPathComponent("Resources");
       if (FileSystem::Instance().Exists(cmd_line_lldb_resources)) {
         FileSpec dir;
-        dir.GetDirectory().SetCString(
-            cmd_line_lldb_resources.GetPath().c_str());
+        dir.SetDirectory(cmd_line_lldb_resources.GetPathAsConstString());
         g_executable_dirs.push_back(dir);
       }
     }
   });
 
   // Now search the global list of executable directories for the executable we
   // are looking for
   for (const auto &executable_dir : g_executable_dirs) {
     FileSpec executable_file;
-    executable_file.GetDirectory() = executable_dir.GetDirectory();
-    executable_file.GetFilename().SetCString(basename);
+    executable_file.SetDirectory(executable_dir.GetDirectory());
+    executable_file.SetFilename(basename);
     if (FileSystem::Instance().Exists(executable_file))
       return executable_file;
   }
 
   return FileSpec();
 }
 
 lldb_private::Status

lldb/source/Plugins/Platform/MacOSX/PlatformDarwinKernel.cpp

 //    /dir/dir/foo.kext.dSYM
 //    /dir/dir/foo.kext/Contents/MacOS/foo.dSYM
 //    /dir/dir/foo.kext/foo.dSYM
 bool PlatformDarwinKernel::KextHasdSYMSibling(
     const FileSpec &kext_bundle_filepath) {
   FileSpec dsym_fspec = kext_bundle_filepath;
   std::string filename = dsym_fspec.GetFilename().AsCString();
   filename += ".dSYM";
-  dsym_fspec.GetFilename() = ConstString(filename);
+  dsym_fspec.SetFilename(filename);
   if (FileSystem::Instance().IsDirectory(dsym_fspec)) {
     return true;
   }
   // Should probably get the CFBundleExecutable here or call
   // CFBundleCopyExecutableURL
 
   // Look for a deep bundle foramt
   ConstString executable_name =

 
 // Given a FileSpec of /dir/dir/mach.development.t7004 Return true if a dSYM
 // exists next to it:
 //    /dir/dir/mach.development.t7004.dSYM
 bool PlatformDarwinKernel::KernelHasdSYMSibling(const FileSpec &kernel_binary) {
   FileSpec kernel_dsym = kernel_binary;
   std::string filename = kernel_binary.GetFilename().AsCString();
   filename += ".dSYM";
-  kernel_dsym.GetFilename() = ConstString(filename);
+  kernel_dsym.SetFilename(filename);
   return FileSystem::Instance().IsDirectory(kernel_dsym);
 }
 
 // Given a FileSpec of /dir/dir/mach.development.t7004.dSYM
 // Return true if only the dSYM exists, no binary next to it.
 //    /dir/dir/mach.development.t7004.dSYM
 //    but no
 //    /dir/dir/mach.development.t7004
 bool PlatformDarwinKernel::KerneldSYMHasNoSiblingBinary(
     const FileSpec &kernel_dsym) {
   static ConstString g_dsym_suffix = ConstString(".dSYM");
   std::string possible_path = kernel_dsym.GetPath();
   if (kernel_dsym.GetFileNameExtension() != g_dsym_suffix)
     return false;
 
   FileSpec binary_filespec = kernel_dsym;
   // Chop off the '.dSYM' extension on the filename
-  binary_filespec.GetFilename() =
-      binary_filespec.GetFileNameStrippingExtension();
+  binary_filespec.SetFilename(binary_filespec.GetFileNameStrippingExtension());
 
   // Is there a binary next to this this?  Then return false.
   if (FileSystem::Instance().Exists(binary_filespec))
     return false;
 
   // If we have at least one binary in the DWARF subdir, then
   // this is a properly formed dSYM and it has no binary next
   // to it.

lldb/source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.cpp

 
 FileSpec PlatformRemoteGDBServer::GetRemoteWorkingDirectory() {
   if (IsConnected()) {
     Log *log = GetLog(LLDBLog::Platform);
     FileSpec working_dir;
     if (m_gdb_client_up->GetWorkingDir(working_dir) && log)
       LLDB_LOGF(log,
                 "PlatformRemoteGDBServer::GetRemoteWorkingDirectory() -> '%s'",
-                working_dir.GetCString());
+                working_dir.GetPath().c_str());
     return working_dir;
   } else {
     return Platform::GetRemoteWorkingDirectory();
   }
 }
 
 bool PlatformRemoteGDBServer::SetRemoteWorkingDirectory(
     const FileSpec &working_dir) {
   if (IsConnected()) {
     // Clear the working directory it case it doesn't get set correctly. This
     // will for use to re-read it
     Log *log = GetLog(LLDBLog::Platform);
     LLDB_LOGF(log, "PlatformRemoteGDBServer::SetRemoteWorkingDirectory('%s')",
-              working_dir.GetCString());
+              working_dir.GetPath().c_str());
     return m_gdb_client_up->SetWorkingDir(working_dir) == 0;
   } else
     return Platform::SetRemoteWorkingDirectory(working_dir);
 }
 
 bool PlatformRemoteGDBServer::IsConnected() const {
   if (m_gdb_client_up) {
     assert(m_gdb_client_up->IsConnected());
Status PlatformRemoteGDBServer::MakeDirectory(const FileSpec &file_spec,
                                               uint32_t mode) {
   if (!IsConnected())
     return Status("Not connected.");
   Status error = m_gdb_client_up->MakeDirectory(file_spec, mode);
   Log *log = GetLog(LLDBLog::Platform);
   LLDB_LOGF(log,
             "PlatformRemoteGDBServer::MakeDirectory(path='%s', mode=%o) "
             "error = %u (%s)",
-            file_spec.GetCString(), mode, error.GetError(), error.AsCString());
+            file_spec.GetPath().c_str(), mode, error.GetError(),
+            error.AsCString());
   return error;
 }
 
 Status PlatformRemoteGDBServer::GetFilePermissions(const FileSpec &file_spec,
                                                    uint32_t &file_permissions) {
   if (!IsConnected())
     return Status("Not connected.");
   Status error =
       m_gdb_client_up->GetFilePermissions(file_spec, file_permissions);
   Log *log = GetLog(LLDBLog::Platform);
   LLDB_LOGF(log,
             "PlatformRemoteGDBServer::GetFilePermissions(path='%s', "
             "file_permissions=%o) error = %u (%s)",
-            file_spec.GetCString(), file_permissions, error.GetError(),
+            file_spec.GetPath().c_str(), file_permissions, error.GetError(),
             error.AsCString());
   return error;
 }
 
 Status PlatformRemoteGDBServer::SetFilePermissions(const FileSpec &file_spec,
                                                    uint32_t file_permissions) {
   if (!IsConnected())
     return Status("Not connected.");
   Status error =
       m_gdb_client_up->SetFilePermissions(file_spec, file_permissions);
   Log *log = GetLog(LLDBLog::Platform);
   LLDB_LOGF(log,
             "PlatformRemoteGDBServer::SetFilePermissions(path='%s', "
             "file_permissions=%o) error = %u (%s)",
-            file_spec.GetCString(), file_permissions, error.GetError(),
+            file_spec.GetPath().c_str(), file_permissions, error.GetError(),
             error.AsCString());
   return error;
 }
 
 lldb::user_id_t PlatformRemoteGDBServer::OpenFile(const FileSpec &file_spec,
                                                   File::OpenOptions flags,
                                                   uint32_t mode,
                                                   Status &error) {

 {
   if (!IsConnected())
     return Status("Not connected.");
   Status error = m_gdb_client_up->CreateSymlink(src, dst);
   Log *log = GetLog(LLDBLog::Platform);
   LLDB_LOGF(log,
             "PlatformRemoteGDBServer::CreateSymlink(src='%s', dst='%s') "
             "error = %u (%s)",
-            src.GetCString(), dst.GetCString(), error.GetError(),
+            src.GetPath().c_str(), dst.GetPath().c_str(), error.GetError(),
             error.AsCString());
   return error;
 }
 
 Status PlatformRemoteGDBServer::Unlink(const FileSpec &file_spec) {
   if (!IsConnected())
     return Status("Not connected.");
   Status error = m_gdb_client_up->Unlink(file_spec);
   Log *log = GetLog(LLDBLog::Platform);
   LLDB_LOGF(log, "PlatformRemoteGDBServer::Unlink(path='%s') error = %u (%s)",
-            file_spec.GetCString(), error.GetError(), error.AsCString());
+            file_spec.GetPath().c_str(), error.GetError(), error.AsCString());
   return error;
 }
 
 bool PlatformRemoteGDBServer::GetFileExists(const FileSpec &file_spec) {
   if (IsConnected())
     return m_gdb_client_up->GetFileExists(file_spec);
   return false;
 }

lldb/source/Plugins/Process/Windows/Common/NativeProcessWindows.cpp

Status NativeProcessWindows::GetLoadedModuleFileSpec(const char *module_path,
   FileSystem::Instance().Resolve(module_file_spec);
   for (auto &it : m_loaded_modules) {
     if (it.first == module_file_spec) {
       file_spec = it.first;
       return Status();
     }
   }
   return Status("Module (%s) not found in process %" PRIu64 "!",
-                module_file_spec.GetCString(), GetID());
+                module_file_spec.GetPath().c_str(), GetID());
 }
 
 Status
 NativeProcessWindows::GetFileLoadAddress(const llvm::StringRef &file_name,
                                          lldb::addr_t &load_addr) {
   Status error = CacheLoadedModules();
   if (error.Fail())
     return error;
 
   load_addr = LLDB_INVALID_ADDRESS;
   FileSpec file_spec(file_name);
   FileSystem::Instance().Resolve(file_spec);
   for (auto &it : m_loaded_modules) {
     if (it.first == file_spec) {
       load_addr = it.second;
       return Status();
     }
   }
   return Status("Can't get loaded address of file (%s) in process %" PRIu64 "!",
-                file_spec.GetCString(), GetID());
+                file_spec.GetPath().c_str(), GetID());
 }
 
 void NativeProcessWindows::OnExitProcess(uint32_t exit_code) {
   Log *log = GetLog(WindowsLog::Process);
   LLDB_LOG(log, "Process {0} exited with code {1}", GetID(), exit_code);
 
   ProcessDebugger::OnExitProcess(exit_code);
 

lldb/source/Plugins/Process/Windows/Common/ProcessDebugger.cpp

Status ProcessDebugger::LaunchProcess(ProcessLaunchInfo &launch_info,
   Status result;
 
   FileSpec working_dir = launch_info.GetWorkingDirectory();
   namespace fs = llvm::sys::fs;
   if (working_dir) {
     FileSystem::Instance().Resolve(working_dir);
     if (!FileSystem::Instance().IsDirectory(working_dir)) {
       result.SetErrorStringWithFormat("No such file or directory: %s",
-                                      working_dir.GetCString());
+                                      working_dir.GetPath().c_str());
       return result;
     }
   }
 
   if (!launch_info.GetFlags().Test(eLaunchFlagDebug)) {
     StreamString stream;
     stream.Printf("ProcessDebugger unable to launch '%s'.  ProcessDebugger can "
                   "only be used for debug launches.",

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerCommon.cpp

GDBRemoteCommunicationServerCommon::Handle_qModuleInfo(
   response.PutChar(';');
 
   const auto &module_arch = matched_module_spec.GetArchitecture();
   response.PutCString("triple:");
   response.PutStringAsRawHex8(module_arch.GetTriple().getTriple());
   response.PutChar(';');
 
   response.PutCString("file_path:");
-  response.PutStringAsRawHex8(matched_module_spec.GetFileSpec().GetCString());
+  response.PutStringAsRawHex8(
+        matched_module_spec.GetFileSpec().GetPath().c_str());
   response.PutChar(';');
   response.PutCString("file_offset:");
   response.PutHex64(file_offset);
   response.PutChar(';');
   response.PutCString("file_size:");
   response.PutHex64(file_size);
   response.PutChar(';');
 

 void GDBRemoteCommunicationServerCommon::CreateProcessInfoResponse(
     const ProcessInstanceInfo &proc_info, StreamString &response) {
   response.Printf(
       "pid:%" PRIu64 ";ppid:%" PRIu64 ";uid:%i;gid:%i;euid:%i;egid:%i;",
       proc_info.GetProcessID(), proc_info.GetParentProcessID(),
       proc_info.GetUserID(), proc_info.GetGroupID(),
       proc_info.GetEffectiveUserID(), proc_info.GetEffectiveGroupID());
   response.PutCString("name:");
-  response.PutStringAsRawHex8(proc_info.GetExecutableFile().GetCString());
+  response.PutStringAsRawHex8(proc_info.GetExecutableFile().GetPath().c_str());
 
   response.PutChar(';');
   response.PutCString("args:");
   response.PutStringAsRawHex8(proc_info.GetArg0());
   for (auto &arg : proc_info.GetArguments()) {
     response.PutChar('-');
     response.PutStringAsRawHex8(arg.ref());
   }

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp

 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_qGetWorkingDir(
     StringExtractorGDBRemote &packet) {
   FileSpec working_dir{m_process_launch_info.GetWorkingDirectory()};
   if (working_dir) {
     StreamString response;
-    response.PutStringAsRawHex8(working_dir.GetCString());
+    response.PutStringAsRawHex8(working_dir.GetPath().c_str());
     return SendPacketNoLock(response.GetString());
   }
 
   return SendErrorResponse(14);
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_QThreadSuffixSupported(

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

 GDBRemoteCommunicationServerPlatform::GetDomainSocketPath(const char *prefix) {
   llvm::SmallString<128> socket_path;
   llvm::SmallString<128> socket_name(
       (llvm::StringRef(prefix) + ".%%%%%%").str());
 
   FileSpec socket_path_spec(GetDomainSocketDir());
   socket_path_spec.AppendPathComponent(socket_name.c_str());
 
-  llvm::sys::fs::createUniqueFile(socket_path_spec.GetCString(), socket_path);
+  llvm::sys::fs::createUniqueFile(socket_path_spec.GetPath().c_str(),
+                                  socket_path);
   return FileSpec(socket_path.c_str());
 }
 
 void GDBRemoteCommunicationServerPlatform::SetPortOffset(uint16_t port_offset) {
   m_port_offset = port_offset;
 }
 
 void GDBRemoteCommunicationServerPlatform::SetPendingGdbServer(
     lldb::pid_t pid, uint16_t port, const std::string &socket_name) {
   m_pending_gdb_server.pid = pid;
   m_pending_gdb_server.port = port;
   m_pending_gdb_server.socket_name = socket_name;
 }

lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

Status ProcessGDBRemote::DoLaunch(lldb_private::Module *exe_module,
   }
 
   if (log) {
     if (stdin_file_spec || stdout_file_spec || stderr_file_spec)
       LLDB_LOGF(log,
                 "ProcessGDBRemote::%s provided with STDIO paths via "
                 "launch_info: stdin=%s, stdout=%s, stderr=%s",
                 __FUNCTION__,
-                stdin_file_spec ? stdin_file_spec.GetCString() : "<null>",
-                stdout_file_spec ? stdout_file_spec.GetCString() : "<null>",
-                stderr_file_spec ? stderr_file_spec.GetCString() : "<null>");
+                stdin_file_spec ? stdin_file_spec.GetPath().c_str() : "<null>",
+                stdout_file_spec ? stdout_file_spec.GetPath().c_str() : "<null>",
+                stderr_file_spec ? stderr_file_spec.GetPath().c_str() : "<null>");
     else
       LLDB_LOGF(log,
                 "ProcessGDBRemote::%s no STDIO paths given via launch_info",
                 __FUNCTION__);
   }
 
   const bool disable_stdio = (launch_flags & eLaunchFlagDisableSTDIO) != 0;
   if (stdin_file_spec || disable_stdio) {
if (disable_stdio) {
           stderr_file_spec = secondary_name;
       }
       LLDB_LOGF(
           log,
           "ProcessGDBRemote::%s adjusted STDIO paths for local platform "
           "(IsHost() is true) using secondary: stdin=%s, stdout=%s, "
           "stderr=%s",
           __FUNCTION__,
-          stdin_file_spec ? stdin_file_spec.GetCString() : "<null>",
-          stdout_file_spec ? stdout_file_spec.GetCString() : "<null>",
-          stderr_file_spec ? stderr_file_spec.GetCString() : "<null>");
+          stdin_file_spec ? stdin_file_spec.GetPath().c_str() : "<null>",
+          stdout_file_spec ? stdout_file_spec.GetPath().c_str() : "<null>",
+          stderr_file_spec ? stderr_file_spec.GetPath().c_str() : "<null>");
     }
 
     LLDB_LOGF(log,
               "ProcessGDBRemote::%s final STDIO paths after all "
               "adjustments: stdin=%s, stdout=%s, stderr=%s",
               __FUNCTION__,
-              stdin_file_spec ? stdin_file_spec.GetCString() : "<null>",
-              stdout_file_spec ? stdout_file_spec.GetCString() : "<null>",
-              stderr_file_spec ? stderr_file_spec.GetCString() : "<null>");
+              stdin_file_spec ? stdin_file_spec.GetPath().c_str() : "<null>",
+              stdout_file_spec ? stdout_file_spec.GetPath().c_str() : "<null>",
+              stderr_file_spec ? stderr_file_spec.GetPath().c_str() : "<null>");
 
     if (stdin_file_spec)
       m_gdb_comm.SetSTDIN(stdin_file_spec);
     if (stdout_file_spec)
       m_gdb_comm.SetSTDOUT(stdout_file_spec);
     if (stderr_file_spec)
       m_gdb_comm.SetSTDERR(stderr_file_spec);
 
Status ProcessGDBRemote::ConnectToDebugserver(llvm::StringRef connect_url) {
   // First dispatch any commands from the platform:
   auto handle_cmds = [&] (const Args &args) ->  void {
     for (const Args::ArgEntry &entry : args) {
       StringExtractorGDBRemote response;
       m_gdb_comm.SendPacketAndWaitForResponse(
           entry.c_str(), response);
     }
   };
-  
   PlatformSP platform_sp = GetTarget().GetPlatform();
   if (platform_sp) {
     handle_cmds(platform_sp->GetExtraStartupCommands());
   }
-  
   // Then dispatch any process commands:
   handle_cmds(GetExtraStartupCommands());
 
   return error;
 }
 
 void ProcessGDBRemote::DidLaunchOrAttach(ArchSpec &process_arch) {
   Log *log = GetLog(GDBRLog::Process);

lldb/source/Plugins/Process/minidump/ProcessMinidump.cpp

if (module_sp) {
       // without specifying the UUID, then again without specifying the
       // directory if that fails.  This will allow us to find modules with
       // partial matches or hash UUIDs in user-provided sysroots or search
       // directories (target.exec-search-paths).
       ModuleSpec partial_module_spec = module_spec;
       partial_module_spec.GetUUID().Clear();
       module_sp = GetOrCreateModule(uuid, name, partial_module_spec);
       if (!module_sp) {
-        partial_module_spec.GetFileSpec().GetDirectory().Clear();
+        partial_module_spec.GetFileSpec().ClearDirectory();
         module_sp = GetOrCreateModule(uuid, name, partial_module_spec);
       }
     }
     if (module_sp) {
       // Watch out for place holder modules that have different paths, but the
       // same UUID. If the base address is different, create a new module. If
       // we don't then we will end up setting the load address of a different
       // PlaceholderObjectFile and an assertion will fire.

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

void ScriptInterpreterPython::ComputePythonDir(
     llvm::SmallVectorImpl<char> &path) {
   // 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
   // x86_64, or bin on Windows).
   llvm::sys::path::remove_filename(path);
   llvm::sys::path::append(path, LLDB_PYTHON_RELATIVE_LIBDIR);
 
 #if defined(_WIN32)
-  // This will be injected directly through FileSpec.GetDirectory().SetString(),
+  // This will be injected directly through FileSpec.SetDirectory(),
   // so we need to normalize manually.
   std::replace(path.begin(), path.end(), '\\', '/');
 #endif
 }
 
 FileSpec ScriptInterpreterPython::GetPythonDir() {
   static FileSpec g_spec = []() {
     FileSpec spec = HostInfo::GetShlibDir();
     if (!spec)
       return FileSpec();
     llvm::SmallString<64> path;
     spec.GetPath(path);
 
 #if defined(__APPLE__)
     ComputePythonDirForApple(path);
 #else
     ComputePythonDir(path);
 #endif
-    spec.GetDirectory().SetString(path);
+    spec.SetDirectory(path);
     return spec;
   }();
   return g_spec;
 }
 
 static const char GetInterpreterInfoScript[] = R"(
 import os
 import sys

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

if (offset == DW_INVALID_OFFSET)
     return false;
 
   ElapsedTime elapsed(m_parse_time);
   llvm::DWARFDebugLine::Prologue prologue;
   if (!ParseLLVMLineTablePrologue(m_context, prologue, offset,
                                   dwarf_cu.GetOffset()))
     return false;
 
+  std::string comp_dir = dwarf_cu.GetCompilationDirectory().GetPath();
   support_files = ParseSupportFilesFromPrologue(
-      module, prologue, dwarf_cu.GetPathStyle(),
-      dwarf_cu.GetCompilationDirectory().GetCString());
-
+      module, prologue, dwarf_cu.GetPathStyle(), comp_dir);
   return true;
 }
 
 FileSpec SymbolFileDWARF::GetFile(DWARFUnit &unit, size_t file_idx) {
   if (auto *dwarf_cu = llvm::dyn_cast<DWARFCompileUnit>(&unit)) {
     if (CompileUnit *lldb_cu = GetCompUnitForDWARFCompUnit(*dwarf_cu))
       return lldb_cu->GetSupportFiles().GetFileSpecAtIndex(file_idx);
     return FileSpec();

lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

loadMatchingPDBFile(std::string exe_path, llvm::BumpPtrAllocator &allocator) {
   }
 
   // If the file doesn't exist, perhaps the path specified at build time
   // doesn't match the PDB's current location, so check the location of the
   // executable.
   if (!FileSystem::Instance().Exists(pdb_file)) {
     const auto exe_dir = FileSpec(exe_path).CopyByRemovingLastPathComponent();
     const auto pdb_name = FileSpec(pdb_file).GetFilename().GetCString();
-    pdb_file = exe_dir.CopyByAppendingPathComponent(pdb_name).GetCString();
+    pdb_file = exe_dir.CopyByAppendingPathComponent(pdb_name).GetPathAsConstString().GetStringRef();
   }
 
   // If the file is not a PDB or if it doesn't have a matching GUID, fail.
   auto pdb = ObjectFilePDB::loadPDBFile(std::string(pdb_file), allocator);
   if (!pdb)
     return nullptr;
 
   auto expected_info = pdb->getPDBInfoStream();

lldb/source/Symbol/Symbol.cpp

Symbol *Symbol::ResolveReExportedSymbolInModuleSpec(
   ModuleSP module_sp;
   if (module_spec.GetFileSpec()) {
     // Try searching for the module file spec first using the full path
     module_sp = target.GetImages().FindFirstModule(module_spec);
     if (!module_sp) {
       // Next try and find the module by basename in case environment variables
       // or other runtime trickery causes shared libraries to be loaded from
       // alternate paths
-      module_spec.GetFileSpec().GetDirectory().Clear();
+      module_spec.GetFileSpec().ClearDirectory();
       module_sp = target.GetImages().FindFirstModule(module_spec);
     }
   }
 
   if (module_sp) {
     // There should not be cycles in the reexport list, but we don't want to
     // crash if there are so make sure we haven't seen this before:
     if (!seen_modules.AppendIfNeeded(module_sp))

lldb/source/Symbol/SymbolContext.cpp

for (uint32_t i = 0; i < matches; ++i) {
               ModuleSP reexport_module_sp;
               ModuleSpec reexport_module_spec;
               reexport_module_spec.GetPlatformFileSpec() =
                   symbol->GetReExportedSymbolSharedLibrary();
               if (reexport_module_spec.GetPlatformFileSpec()) {
                 reexport_module_sp =
                     target.GetImages().FindFirstModule(reexport_module_spec);
                 if (!reexport_module_sp) {
-                  reexport_module_spec.GetPlatformFileSpec()
-                      .GetDirectory()
-                      .Clear();
+                  reexport_module_spec.GetPlatformFileSpec().ClearDirectory();
                   reexport_module_sp =
                       target.GetImages().FindFirstModule(reexport_module_spec);
                 }
               }
               // Don't allow us to try and resolve a re-exported symbol if it
               // is the same as the current symbol
               if (name == symbol->GetReExportedSymbolName() &&
                   module == reexport_module_sp.get())

lldb/source/Target/Platform.cpp

if (is_connected)
       strm.Printf("  Hostname: %s\n", GetHostname());
     strm.Printf(" Connected: %s\n", is_connected ? "yes" : "no");
   }
 
   if (GetSDKRootDirectory()) {
     strm.Format("   Sysroot: {0}\n", GetSDKRootDirectory());
   }
   if (GetWorkingDirectory()) {
-    strm.Printf("WorkingDir: %s\n", GetWorkingDirectory().GetCString());
+    strm.Printf("WorkingDir: %s\n", GetWorkingDirectory().GetPath().c_str());
   }
   if (!IsConnected())
     return;
 
   std::string specific_info(GetPlatformSpecificConnectionInformation());
 
   if (!specific_info.empty())
     strm.Printf("Platform-specific connection: %s\n", specific_info.c_str());
case fs::file_type::socket_file:
     // we have no way to copy pipes and sockets - ignore them and continue
     return FileSystem::eEnumerateDirectoryResultNext;
     break;
 
   case fs::file_type::directory_file: {
     // make the new directory and get in there
     FileSpec dst_dir = rc_baton->dst;
     if (!dst_dir.GetFilename())
-      dst_dir.GetFilename() = src.GetLastPathComponent();
+      dst_dir.SetFilename(src.GetLastPathComponent());
     Status error = rc_baton->platform_ptr->MakeDirectory(
         dst_dir, lldb::eFilePermissionsDirectoryDefault);
     if (error.Fail()) {
       rc_baton->error.SetErrorStringWithFormat(
-          "unable to setup directory %s on remote end", dst_dir.GetCString());
+          "unable to setup directory %s on remote end",
+          dst_dir.GetPath().c_str());
       return FileSystem::eEnumerateDirectoryResultQuit; // got an error, bail out
     }
 
     // now recurse
     std::string src_dir_path(src.GetPath());
 
     // Make a filespec that only fills in the directory of a FileSpec so when
     // we enumerate we can quickly fill in the filename for dst copies
     FileSpec recurse_dst;
-    recurse_dst.GetDirectory().SetCString(dst_dir.GetPath().c_str());
+    recurse_dst.SetDirectory(dst_dir.GetPathAsConstString());
     RecurseCopyBaton rc_baton2 = {recurse_dst, rc_baton->platform_ptr,
                                   Status()};
     FileSystem::Instance().EnumerateDirectory(src_dir_path, true, true, true,
                                               RecurseCopy_Callback, &rc_baton2);
     if (rc_baton2.error.Fail()) {
       rc_baton->error.SetErrorString(rc_baton2.error.AsCString());
       return FileSystem::eEnumerateDirectoryResultQuit; // got an error, bail out
     }
     return FileSystem::eEnumerateDirectoryResultNext;
   } break;
 
   case fs::file_type::symlink_file: {
     // copy the file and keep going
     FileSpec dst_file = rc_baton->dst;
     if (!dst_file.GetFilename())
-      dst_file.GetFilename() = src.GetFilename();
+      dst_file.SetFilename(src.GetFilename());
 
     FileSpec src_resolved;
 
     rc_baton->error = FileSystem::Instance().Readlink(src, src_resolved);
 
     if (rc_baton->error.Fail())
       return FileSystem::eEnumerateDirectoryResultQuit; // got an error, bail out
 
     rc_baton->error =
         rc_baton->platform_ptr->CreateSymlink(dst_file, src_resolved);
 
     if (rc_baton->error.Fail())
       return FileSystem::eEnumerateDirectoryResultQuit; // got an error, bail out
 
     return FileSystem::eEnumerateDirectoryResultNext;
   } break;
 
   case fs::file_type::regular_file: {
     // copy the file and keep going
     FileSpec dst_file = rc_baton->dst;
     if (!dst_file.GetFilename())
-      dst_file.GetFilename() = src.GetFilename();
+      dst_file.SetFilename(src.GetFilename());
     Status err = rc_baton->platform_ptr->PutFile(src, dst_file);
     if (err.Fail()) {
       rc_baton->error.SetErrorString(err.AsCString());
       return FileSystem::eEnumerateDirectoryResultQuit; // got an error, bail out
     }
     return FileSystem::eEnumerateDirectoryResultNext;
   } break;
 
Status Platform::Install(const FileSpec &src, const FileSpec &dst) {
   Status error;
 
   Log *log = GetLog(LLDBLog::Platform);
   LLDB_LOGF(log, "Platform::Install (src='%s', dst='%s')",
             src.GetPath().c_str(), dst.GetPath().c_str());
   FileSpec fixed_dst(dst);
 
   if (!fixed_dst.GetFilename())
-    fixed_dst.GetFilename() = src.GetFilename();
+    fixed_dst.SetFilename(src.GetFilename());
 
   FileSpec working_dir = GetWorkingDirectory();
 
   if (dst) {
     if (dst.GetDirectory()) {
       const char first_dst_dir_char = dst.GetDirectory().GetCString()[0];
       if (first_dst_dir_char == '/' || first_dst_dir_char == '\\') {
-        fixed_dst.GetDirectory() = dst.GetDirectory();
+        fixed_dst.SetDirectory(dst.GetDirectory());
       }
       // If the fixed destination file doesn't have a directory yet, then we
       // must have a relative path. We will resolve this relative path against
       // the platform's working directory
       if (!fixed_dst.GetDirectory()) {
         FileSpec relative_spec;
         std::string path;
         if (working_dir) {
           relative_spec = working_dir;
           relative_spec.AppendPathComponent(dst.GetPath());
-          fixed_dst.GetDirectory() = relative_spec.GetDirectory();
+          fixed_dst.SetDirectory(relative_spec.GetDirectory());
         } else {
           error.SetErrorStringWithFormat(
               "platform working directory must be valid for relative path '%s'",
               dst.GetPath().c_str());
           return error;
         }
       }
     } else {
       if (working_dir) {
-        fixed_dst.GetDirectory().SetCString(working_dir.GetCString());
+        fixed_dst.SetDirectory(working_dir.GetPathAsConstString());
       } else {
         error.SetErrorStringWithFormat(
             "platform working directory must be valid for relative path '%s'",
             dst.GetPath().c_str());
         return error;
       }
     }
   } else {
     if (working_dir) {
-      fixed_dst.GetDirectory().SetCString(working_dir.GetCString());
+      fixed_dst.SetDirectory(working_dir.GetPathAsConstString());
     } else {
       error.SetErrorStringWithFormat("platform working directory must be valid "
                                      "when destination directory is empty");
       return error;
     }
   }
 
   LLDB_LOGF(log, "Platform::Install (src='%s', dst='%s') fixed_dst='%s'",
case fs::file_type::directory_file: {
       uint32_t permissions = FileSystem::Instance().GetPermissions(src);
       if (permissions == 0)
         permissions = eFilePermissionsDirectoryDefault;
       error = MakeDirectory(fixed_dst, permissions);
       if (error.Success()) {
         // Make a filespec that only fills in the directory of a FileSpec so
         // when we enumerate we can quickly fill in the filename for dst copies
         FileSpec recurse_dst;
-        recurse_dst.GetDirectory().SetCString(fixed_dst.GetCString());
+        recurse_dst.SetDirectory(fixed_dst.GetPathAsConstString());
         std::string src_dir_path(src.GetPath());
         RecurseCopyBaton baton = {recurse_dst, this, Status()};
         FileSystem::Instance().EnumerateDirectory(
             src_dir_path, true, true, true, RecurseCopy_Callback, &baton);
         return baton.error;
       }
     } break;
 

 
 ConstString Platform::GetFullNameForDylib(ConstString basename) {
   return basename;
 }
 
 bool Platform::SetRemoteWorkingDirectory(const FileSpec &working_dir) {
   Log *log = GetLog(LLDBLog::Platform);
   LLDB_LOGF(log, "Platform::SetRemoteWorkingDirectory('%s')",
-            working_dir.GetCString());
+            working_dir.GetPath().c_str());
   m_working_dir = working_dir;
   return true;
 }
 
 bool Platform::SetOSVersion(llvm::VersionTuple version) {
   if (IsHost()) {
     // We don't need anyone setting the OS version for the host platform, we
     // should be able to figure it out by calling HostInfo::GetOSVersion(...).

lldb/source/Target/Target.cpp

: TargetProperties(this),
       m_is_dummy_target(is_dummy_target),
       m_frame_recognizer_manager_up(
           std::make_unique<StackFrameRecognizerManager>()) {
   SetEventName(eBroadcastBitBreakpointChanged, "breakpoint-changed");
   SetEventName(eBroadcastBitModulesLoaded, "modules-loaded");
   SetEventName(eBroadcastBitModulesUnloaded, "modules-unloaded");
   SetEventName(eBroadcastBitWatchpointChanged, "watchpoint-changed");
   SetEventName(eBroadcastBitSymbolsLoaded, "symbols-loaded");
-  
   CheckInWithManager();
 
   LLDB_LOG(GetLog(LLDBLog::Object), "{0} Target::Target()",
            static_cast<void *>(this));
   if (target_arch.IsValid()) {
     LLDB_LOG(GetLog(LLDBLog::Target),
              "Target::Target created with architecture {0} ({1})",
              target_arch.GetArchitectureName(),
llvm::SmallVector<ModuleSP, 1>
         old_modules; // This will get filled in if we have a new version
                      // of the library
     bool did_create_module = false;
     FileSpecList search_paths = GetExecutableSearchPaths();
     // If there are image search path entries, try to use them first to acquire
     // a suitable image.
     if (m_image_search_paths.GetSize()) {
       ModuleSpec transformed_spec(module_spec);
+      ConstString transformed_dir;
       if (m_image_search_paths.RemapPath(
-              module_spec.GetFileSpec().GetDirectory(),
-              transformed_spec.GetFileSpec().GetDirectory())) {
-        transformed_spec.GetFileSpec().GetFilename() =
-            module_spec.GetFileSpec().GetFilename();
+              module_spec.GetFileSpec().GetDirectory(), transformed_dir)) {
+        transformed_spec.GetFileSpec().SetDirectory(transformed_dir);
+        transformed_spec.GetFileSpec().SetFilename(
+              module_spec.GetFileSpec().GetFilename());
         error = ModuleList::GetSharedModule(transformed_spec, module_sp,
                                             &search_paths, &old_modules,
                                             &did_create_module);
       }
     }
 
     if (!module_sp) {
       // If we have a UUID, we can check our global shared module list in case
Status Target::Attach(ProcessAttachInfo &attach_info, Stream *stream) {
   }
 
   const ModuleSP old_exec_module_sp = GetExecutableModule();
 
   // If no process info was specified, then use the target executable name as
   // the process to attach to by default
   if (!attach_info.ProcessInfoSpecified()) {
     if (old_exec_module_sp)
-      attach_info.GetExecutableFile().GetFilename() =
-          old_exec_module_sp->GetPlatformFileSpec().GetFilename();
+      attach_info.GetExecutableFile().SetFilename(
+            old_exec_module_sp->GetPlatformFileSpec().GetFilename());
 
     if (!attach_info.ProcessInfoSpecified()) {
       return Status("no process specified, create a target with a file, or "
                     "specify the --pid or --name");
     }
   }
 
   const auto platform_sp =
if (info.GetFlags().Test(eLaunchFlagDisableSTDIO)) {
       if (default_to_use_pty) {
         llvm::Error Err = info.SetUpPtyRedirection();
         LLDB_LOG_ERROR(log, std::move(Err), "SetUpPtyRedirection failed: {0}");
       }
     }
   }
 }
 
-void Target::AddDummySignal(llvm::StringRef name, LazyBool pass, LazyBool notify, 
+void Target::AddDummySignal(llvm::StringRef name, LazyBool pass, LazyBool notify,
                             LazyBool stop) {
     if (name.empty())
       return;
     // Don't add a signal if all the actions are trivial:
     if (pass == eLazyBoolCalculate && notify == eLazyBoolCalculate
         && stop == eLazyBoolCalculate)
       return;
 
     auto& elem = m_dummy_signals[name];
     elem.pass = pass;
     elem.notify = notify;
     elem.stop = stop;
 }
 
-bool Target::UpdateSignalFromDummy(UnixSignalsSP signals_sp, 
+bool Target::UpdateSignalFromDummy(UnixSignalsSP signals_sp,
                                           const DummySignalElement &elem) {
   if (!signals_sp)
     return false;
 
-  int32_t signo 
+  int32_t signo
       = signals_sp->GetSignalNumberFromName(elem.first().str().c_str());
   if (signo == LLDB_INVALID_SIGNAL_NUMBER)
     return false;
-    
   if (elem.second.pass == eLazyBoolYes)
     signals_sp->SetShouldSuppress(signo, false);
   else if (elem.second.pass == eLazyBoolNo)
     signals_sp->SetShouldSuppress(signo, true);
-  
   if (elem.second.notify == eLazyBoolYes)
     signals_sp->SetShouldNotify(signo, true);
   else if (elem.second.notify == eLazyBoolNo)
     signals_sp->SetShouldNotify(signo, false);
-  
   if (elem.second.stop == eLazyBoolYes)
     signals_sp->SetShouldStop(signo, true);
   else if (elem.second.stop == eLazyBoolNo)
     signals_sp->SetShouldStop(signo, false);
-  return true;  
+  return true;
 }
 
-bool Target::ResetSignalFromDummy(UnixSignalsSP signals_sp, 
+bool Target::ResetSignalFromDummy(UnixSignalsSP signals_sp,
                                           const DummySignalElement &elem) {
   if (!signals_sp)
     return false;
-  int32_t signo 
+  int32_t signo
       = signals_sp->GetSignalNumberFromName(elem.first().str().c_str());
   if (signo == LLDB_INVALID_SIGNAL_NUMBER)
     return false;
   bool do_pass = elem.second.pass != eLazyBoolCalculate;
   bool do_stop = elem.second.stop != eLazyBoolCalculate;
   bool do_notify = elem.second.notify != eLazyBoolCalculate;
   signals_sp->ResetSignal(signo, do_stop, do_notify, do_pass);
   return true;
 }
 
-void Target::UpdateSignalsFromDummy(UnixSignalsSP signals_sp, 
+void Target::UpdateSignalsFromDummy(UnixSignalsSP signals_sp,
                                     StreamSP warning_stream_sp) {
   if (!signals_sp)
     return;
 
   for (const auto &elem : m_dummy_signals) {
     if (!UpdateSignalFromDummy(signals_sp, elem))
-      warning_stream_sp->Printf("Target signal '%s' not found in process\n", 
+      warning_stream_sp->Printf("Target signal '%s' not found in process\n",
           elem.first().str().c_str());
   }
 }
 
 void Target::ClearDummySignals(Args &signal_names) {
   ProcessSP process_sp = GetProcessSP();
   // The simplest case, delete them all with no process to update.
   if (signal_names.GetArgumentCount() == 0 && !process_sp) {
if (signals_sp)
       ResetSignalFromDummy(signals_sp, *elem);
     m_dummy_signals.erase(elem);
   }
 }
 
 void Target::PrintDummySignals(Stream &strm, Args &signal_args) {
   strm.Printf("NAME         PASS     STOP     NOTIFY\n");
   strm.Printf("===========  =======  =======  =======\n");
-  
   auto str_for_lazy = [] (LazyBool lazy) -> const char * {
     switch (lazy) {
       case eLazyBoolCalculate: return "not set";
       case eLazyBoolYes: return "true   ";
       case eLazyBoolNo: return "false  ";
     }
     llvm_unreachable("Fully covered switch above!");
   };

lldb/source/Target/TargetList.cpp

if (user_exe_path_is_bundle && resolved_bundle_exe_path[0]) {
       target_sp->SetArg0(resolved_bundle_exe_path);
     } else {
       // Use resolved path
       target_sp->SetArg0(file.GetPath().c_str());
     }
   }
   if (file.GetDirectory()) {
     FileSpec file_dir;
-    file_dir.GetDirectory() = file.GetDirectory();
+    file_dir.SetDirectory(file.GetDirectory());
     target_sp->AppendExecutableSearchPaths(file_dir);
   }
 
   // Now prime this from the dummy target:
   target_sp->PrimeFromDummyTarget(debugger.GetDummyTarget());
 
   return error;
 }

lldb/source/Target/Trace.cpp

 
 llvm::Error Trace::OnDataFileRead(FileSpec file,
                                   OnBinaryDataReadCallback callback) {
   ErrorOr<std::unique_ptr<MemoryBuffer>> trace_or_error =
       MemoryBuffer::getFile(file.GetPath());
   if (std::error_code err = trace_or_error.getError())
     return createStringError(
         inconvertibleErrorCode(), "Failed fetching trace-related file %s. %s",
-        file.GetCString(), toString(errorCodeToError(err)).c_str());
+        file.GetPath().c_str(), toString(errorCodeToError(err)).c_str());
 
   MemoryBuffer &data = **trace_or_error;
   ArrayRef<uint8_t> array_ref(
       reinterpret_cast<const uint8_t *>(data.getBufferStart()),
       data.getBufferSize());
   return callback(array_ref);
 }
 

lldb/source/Utility/FileSpec.cpp

void FileSpec::Dump(llvm::raw_ostream &s) const {
   s << path;
   char path_separator = GetPreferredPathSeparator(m_style);
   if (!m_filename && !path.empty() && path.back() != path_separator)
     s << path_separator;
 }
 
 FileSpec::Style FileSpec::GetPathStyle() const { return m_style; }
 
-// Directory string get accessor.
-ConstString &FileSpec::GetDirectory() { return m_directory; }
+void FileSpec::SetDirectory(ConstString directory) {
+  m_directory = directory;
+}
+
+void FileSpec::SetDirectory(llvm::StringRef directory) {
+  m_directory = ConstString(directory);
+}
+
+void FileSpec::SetFilename(ConstString filename) {
+  m_filename = filename;
+}
 
-// Directory string const get accessor.
-ConstString FileSpec::GetDirectory() const { return m_directory; }
+void FileSpec::SetFilename(llvm::StringRef filename) {
+  m_filename = ConstString(filename);
+}
 
-// Filename string get accessor.
-ConstString &FileSpec::GetFilename() { return m_filename; }
+void FileSpec::ClearFilename() {
+  m_filename.Clear();
+}
 
-// Filename string const get accessor.
-ConstString FileSpec::GetFilename() const { return m_filename; }
+void FileSpec::ClearDirectory() {
+  m_directory.Clear();
+}
 
 // Extract the directory and path into a fixed buffer. This is needed as the
 // directory and path are stored in separate string values.
 size_t FileSpec::GetPath(char *path, size_t path_max_len,
                          bool denormalize) const {
   if (!path)
     return 0;
 
   std::string result = GetPath(denormalize);
   ::snprintf(path, path_max_len, "%s", result.c_str());
   return std::min(path_max_len - 1, result.length());
 }
 
 std::string FileSpec::GetPath(bool denormalize) const {
   llvm::SmallString<64> result;
   GetPath(result, denormalize);
   return static_cast<std::string>(result);
 }
 
-const char *FileSpec::GetCString(bool denormalize) const {
-  return ConstString{GetPath(denormalize)}.AsCString(nullptr);
+ConstString FileSpec::GetPathAsConstString(bool denormalize) const {
+  return ConstString{GetPath(denormalize)};
 }
 
 void FileSpec::GetPath(llvm::SmallVectorImpl<char> &path,
                        bool denormalize) const {
   path.append(m_directory.GetStringRef().begin(),
               m_directory.GetStringRef().end());
   // Since the path was normalized and all paths use '/' when stored in these
   // objects, we don't need to look for the actual syntax specific path
bool FileSpec::IsSourceImplementationFile() const {
   return g_source_file_regex.Execute(extension.GetStringRef());
 }
 
 bool FileSpec::IsRelative() const {
   return !IsAbsolute();
 }
 
 bool FileSpec::IsAbsolute() const {
-  llvm::SmallString<64> current_path;
   GetPath(current_path, false);
 
   // Early return if the path is empty.
   if (current_path.empty())
     return false;
 
   // We consider paths starting with ~ to be absolute.
   if (current_path[0] == '~')

lldb/tools/lldb-server/lldb-platform.cpp

 }
 
 static Status save_socket_id_to_file(const std::string &socket_id,
                                      const FileSpec &file_spec) {
   FileSpec temp_file_spec(file_spec.GetDirectory().GetStringRef());
   Status error(llvm::sys::fs::create_directory(temp_file_spec.GetPath()));
   if (error.Fail())
     return Status("Failed to create directory %s: %s",
-                  temp_file_spec.GetCString(), error.AsCString());
+                  temp_file_spec.GetPath().c_str(), error.AsCString());
 
   llvm::SmallString<64> temp_file_path;
   temp_file_spec.AppendPathComponent("port-file.%%%%%%");
   temp_file_path = temp_file_spec.GetPath();
 
   Status status;
   if (auto Err =
           handleErrors(llvm::writeFileAtomically(

lldb/tools/lldb-test/lldb-test.cpp

if (opts::object::SectionDependentModules) {
       // A non-empty section list ensures a valid object file.
       auto Obj = ModulePtr->GetObjectFile();
       FileSpecList Files;
       auto Count = Obj->GetDependentModules(Files);
       Printer.formatLine("Showing {0} dependent module(s)", Count);
       for (size_t I = 0; I < Files.GetSize(); ++I) {
         AutoIndent Indent(Printer, 2);
         Printer.formatLine("Name: {0}",
-                           Files.GetFileSpecAtIndex(I).GetCString());
+                           Files.GetFileSpecAtIndex(I).GetPath());
       }
       Printer.NewLine();
     }
   }
   return HadErrors;
 }
 
 bool opts::irmemorymap::evalMalloc(StringRef Line,

lldb/unittests/Target/FindFileTest.cpp

public:
   }
 };
 } // namespace
 
 static void TestFileFindings(const PathMappingList &map,
                              llvm::ArrayRef<Matches> matches,
                              llvm::ArrayRef<FileSpec> fails) {
   for (const auto &fail : fails) {
-    SCOPED_TRACE(fail.GetCString());
+    SCOPED_TRACE(fail.GetPath().c_str());
     EXPECT_FALSE(map.FindFile(fail));
   }
 
   for (const auto &match : matches) {
     SCOPED_TRACE(match.original.GetPath() + " -> " + match.remapped);
     llvm::Optional<FileSpec> remapped;
 
     EXPECT_TRUE(bool(remapped = map.FindFile(match.original)));

lldb/unittests/Target/ModuleCacheTest.cpp

 void ModuleCacheTest::SetUp() {
   s_cache_dir = HostInfo::GetProcessTempDir();
   s_test_executable = GetInputFilePath(module_name);
 }
 
 static void VerifyDiskState(const FileSpec &cache_dir, const char *hostname) {
   FileSpec uuid_view = GetUuidView(cache_dir);
   EXPECT_TRUE(FileSystem::Instance().Exists(uuid_view))
-      << "uuid_view is: " << uuid_view.GetCString();
+      << "uuid_view is: " << uuid_view.GetPath();
   EXPECT_EQ(module_size, FileSystem::Instance().GetByteSize(uuid_view));
 
   FileSpec sysroot_view = GetSysrootView(cache_dir, hostname);
   EXPECT_TRUE(FileSystem::Instance().Exists(sysroot_view))
-      << "sysroot_view is: " << sysroot_view.GetCString();
+      << "sysroot_view is: " << sysroot_view.GetPath();
   EXPECT_EQ(module_size, FileSystem::Instance().GetByteSize(sysroot_view));
 }
 
 void ModuleCacheTest::TryGetAndPut(const FileSpec &cache_dir,
                                    const char *hostname, bool expect_download) {
   ModuleCache mc;
   ModuleSpec module_spec;
   module_spec.GetFileSpec() = GetDummyRemotePath();
   module_spec.GetUUID().SetFromStringRef(module_uuid);
   module_spec.SetObjectSize(module_size);
   ModuleSP module_sp;
   bool did_create;
   bool download_called = false;
 
   Status error = mc.GetAndPut(
       cache_dir, hostname, module_spec,
       [&download_called, this](const ModuleSpec &module_spec,
                                const FileSpec &tmp_download_file_spec) {
         download_called = true;
-        EXPECT_STREQ(GetDummyRemotePath().GetCString(),
-                     module_spec.GetFileSpec().GetCString());
+        EXPECT_STREQ(GetDummyRemotePath().GetPath().c_str(),
+                     module_spec.GetFileSpec().GetPath().c_str());
         std::error_code ec = llvm::sys::fs::copy_file(
-            s_test_executable, tmp_download_file_spec.GetCString());
+            s_test_executable, tmp_download_file_spec.GetPath());
         EXPECT_FALSE(ec);
         return Status();
       },
       [](const ModuleSP &module_sp, const FileSpec &tmp_download_file_spec) {
         return Status("Not supported.");
       },
       module_sp, &did_create);
   EXPECT_EQ(expect_download, download_called);
 
   EXPECT_TRUE(error.Success()) << "Error was: " << error.AsCString();
   EXPECT_TRUE(did_create);
   ASSERT_TRUE(bool(module_sp));
 
   SymbolContextList sc_list;
   module_sp->FindFunctionSymbols(ConstString("boom"), eFunctionNameTypeFull,
                                  sc_list);
   EXPECT_EQ(1u, sc_list.GetSize());
-  EXPECT_STREQ(GetDummyRemotePath().GetCString(),
-               module_sp->GetPlatformFileSpec().GetCString());
+  EXPECT_STREQ(GetDummyRemotePath().GetPath().c_str(),
+               module_sp->GetPlatformFileSpec().GetPath().c_str());
   EXPECT_STREQ(module_uuid, module_sp->GetUUID().GetAsString().c_str());
 }
 
 TEST_F(ModuleCacheTest, GetAndPut) {
   FileSpec test_cache_dir = s_cache_dir;
   test_cache_dir.AppendPathComponent("GetAndPut");
 
   const bool expect_download = true;
   TryGetAndPut(test_cache_dir, dummy_hostname, expect_download);
   VerifyDiskState(test_cache_dir, dummy_hostname);
 }
 
 TEST_F(ModuleCacheTest, GetAndPutUuidExists) {
   FileSpec test_cache_dir = s_cache_dir;
   test_cache_dir.AppendPathComponent("GetAndPutUuidExists");
 
   FileSpec uuid_view = GetUuidView(test_cache_dir);
   std::error_code ec =
       llvm::sys::fs::create_directories(uuid_view.GetDirectory().GetCString());
   ASSERT_FALSE(ec);
-  ec = llvm::sys::fs::copy_file(s_test_executable, uuid_view.GetCString());
+  ec = llvm::sys::fs::copy_file(s_test_executable, uuid_view.GetPath().c_str());
   ASSERT_FALSE(ec);
 
   const bool expect_download = false;
   TryGetAndPut(test_cache_dir, dummy_hostname, expect_download);
   VerifyDiskState(test_cache_dir, dummy_hostname);
 }
 
 TEST_F(ModuleCacheTest, GetAndPutStrangeHostname) {
   FileSpec test_cache_dir = s_cache_dir;
   test_cache_dir.AppendPathComponent("GetAndPutStrangeHostname");
 
   const bool expect_download = true;
   TryGetAndPut(test_cache_dir, "tab\tcolon:asterisk*", expect_download);
   VerifyDiskState(test_cache_dir, "tab_colon_asterisk_");
 }

lldb/unittests/Utility/FileSpecTest.cpp

 }
 
 static FileSpec WindowsSpec(llvm::StringRef path) {
   return FileSpec(path, FileSpec::Style::windows);
 }
 
 TEST(FileSpecTest, FileAndDirectoryComponents) {
   FileSpec fs_posix("/foo/bar", FileSpec::Style::posix);
-  EXPECT_STREQ("/foo/bar", fs_posix.GetCString());
+  EXPECT_STREQ("/foo/bar", fs_posix.GetPath().c_str());
   EXPECT_STREQ("/foo", fs_posix.GetDirectory().GetCString());
   EXPECT_STREQ("bar", fs_posix.GetFilename().GetCString());
 
   FileSpec fs_windows("F:\\bar", FileSpec::Style::windows);
-  EXPECT_STREQ("F:\\bar", fs_windows.GetCString());
-  // EXPECT_STREQ("F:\\", fs_windows.GetDirectory().GetCString()); // It returns
+  EXPECT_STREQ("F:\\bar", fs_windows.GetPath().c_str());
+  // EXPECT_STREQ("F:\\", fs_windows.GetDirectory().GetPath().c_str()); // It returns
   // "F:/"
   EXPECT_STREQ("bar", fs_windows.GetFilename().GetCString());
 
   FileSpec fs_posix_root("/", FileSpec::Style::posix);
-  EXPECT_STREQ("/", fs_posix_root.GetCString());
+  EXPECT_STREQ("/", fs_posix_root.GetPath().c_str());
   EXPECT_EQ(nullptr, fs_posix_root.GetDirectory().GetCString());
   EXPECT_STREQ("/", fs_posix_root.GetFilename().GetCString());
 
   FileSpec fs_net_drive("//net", FileSpec::Style::posix);
-  EXPECT_STREQ("//net", fs_net_drive.GetCString());
+  EXPECT_STREQ("//net", fs_net_drive.GetPath().c_str());
   EXPECT_EQ(nullptr, fs_net_drive.GetDirectory().GetCString());
   EXPECT_STREQ("//net", fs_net_drive.GetFilename().GetCString());
 
   FileSpec fs_net_root("//net/", FileSpec::Style::posix);
-  EXPECT_STREQ("//net/", fs_net_root.GetCString());
+  EXPECT_STREQ("//net/", fs_net_root.GetPath().c_str());
   EXPECT_STREQ("//net", fs_net_root.GetDirectory().GetCString());
   EXPECT_STREQ("/", fs_net_root.GetFilename().GetCString());
 
   FileSpec fs_windows_drive("F:", FileSpec::Style::windows);
-  EXPECT_STREQ("F:", fs_windows_drive.GetCString());
+  EXPECT_STREQ("F:", fs_windows_drive.GetPath().c_str());
   EXPECT_EQ(nullptr, fs_windows_drive.GetDirectory().GetCString());
   EXPECT_STREQ("F:", fs_windows_drive.GetFilename().GetCString());
 
   FileSpec fs_windows_root("F:\\", FileSpec::Style::windows);
-  EXPECT_STREQ("F:\\", fs_windows_root.GetCString());
+  EXPECT_STREQ("F:\\", fs_windows_root.GetPath().c_str());
   EXPECT_STREQ("F:", fs_windows_root.GetDirectory().GetCString());
   // EXPECT_STREQ("\\", fs_windows_root.GetFilename().GetCString()); // It
   // returns "/"
 
   FileSpec fs_posix_long("/foo/bar/baz", FileSpec::Style::posix);
-  EXPECT_STREQ("/foo/bar/baz", fs_posix_long.GetCString());
+  EXPECT_STREQ("/foo/bar/baz", fs_posix_long.GetPath().c_str());
   EXPECT_STREQ("/foo/bar", fs_posix_long.GetDirectory().GetCString());
   EXPECT_STREQ("baz", fs_posix_long.GetFilename().GetCString());
 
   FileSpec fs_windows_long("F:\\bar\\baz", FileSpec::Style::windows);
-  EXPECT_STREQ("F:\\bar\\baz", fs_windows_long.GetCString());
+  EXPECT_STREQ("F:\\bar\\baz", fs_windows_long.GetPath().c_str());
   // EXPECT_STREQ("F:\\bar", fs_windows_long.GetDirectory().GetCString()); // It
   // returns "F:/bar"
   EXPECT_STREQ("baz", fs_windows_long.GetFilename().GetCString());
 
   FileSpec fs_posix_trailing_slash("/foo/bar/", FileSpec::Style::posix);
-  EXPECT_STREQ("/foo/bar", fs_posix_trailing_slash.GetCString());
+  EXPECT_STREQ("/foo/bar", fs_posix_trailing_slash.GetPath().c_str());
   EXPECT_STREQ("/foo", fs_posix_trailing_slash.GetDirectory().GetCString());
   EXPECT_STREQ("bar", fs_posix_trailing_slash.GetFilename().GetCString());
 
   FileSpec fs_windows_trailing_slash("F:\\bar\\", FileSpec::Style::windows);
-  EXPECT_STREQ("F:\\bar", fs_windows_trailing_slash.GetCString());
+  EXPECT_STREQ("F:\\bar", fs_windows_trailing_slash.GetPath().c_str());
   EXPECT_STREQ("bar", fs_windows_trailing_slash.GetFilename().GetCString());
 }
 
 TEST(FileSpecTest, AppendPathComponent) {
   FileSpec fs_posix("/foo", FileSpec::Style::posix);
   fs_posix.AppendPathComponent("bar");
-  EXPECT_STREQ("/foo/bar", fs_posix.GetCString());
+  EXPECT_STREQ("/foo/bar", fs_posix.GetPath().c_str());
   EXPECT_STREQ("/foo", fs_posix.GetDirectory().GetCString());
   EXPECT_STREQ("bar", fs_posix.GetFilename().GetCString());
 
   FileSpec fs_posix_2("/foo", FileSpec::Style::posix);
   fs_posix_2.AppendPathComponent("//bar/baz");
-  EXPECT_STREQ("/foo/bar/baz", fs_posix_2.GetCString());
+  EXPECT_STREQ("/foo/bar/baz", fs_posix_2.GetPath().c_str());
   EXPECT_STREQ("/foo/bar", fs_posix_2.GetDirectory().GetCString());
   EXPECT_STREQ("baz", fs_posix_2.GetFilename().GetCString());
 
   FileSpec fs_windows("F:\\bar", FileSpec::Style::windows);
   fs_windows.AppendPathComponent("baz");
-  EXPECT_STREQ("F:\\bar\\baz", fs_windows.GetCString());
+  EXPECT_STREQ("F:\\bar\\baz", fs_windows.GetPath().c_str());
   // EXPECT_STREQ("F:\\bar", fs_windows.GetDirectory().GetCString()); // It
   // returns "F:/bar"
   EXPECT_STREQ("baz", fs_windows.GetFilename().GetCString());
 
   FileSpec fs_posix_root("/", FileSpec::Style::posix);
   fs_posix_root.AppendPathComponent("bar");
-  EXPECT_STREQ("/bar", fs_posix_root.GetCString());
+  EXPECT_STREQ("/bar", fs_posix_root.GetPath().c_str());
   EXPECT_STREQ("/", fs_posix_root.GetDirectory().GetCString());
   EXPECT_STREQ("bar", fs_posix_root.GetFilename().GetCString());
 
   FileSpec fs_windows_root("F:\\", FileSpec::Style::windows);
   fs_windows_root.AppendPathComponent("bar");
-  EXPECT_STREQ("F:\\bar", fs_windows_root.GetCString());
+  EXPECT_STREQ("F:\\bar", fs_windows_root.GetPath().c_str());
   // EXPECT_STREQ("F:\\", fs_windows_root.GetDirectory().GetCString()); // It
   // returns "F:/"
   EXPECT_STREQ("bar", fs_windows_root.GetFilename().GetCString());
 }
 
 TEST(FileSpecTest, CopyByAppendingPathComponent) {
   FileSpec fs = PosixSpec("/foo").CopyByAppendingPathComponent("bar");
-  EXPECT_STREQ("/foo/bar", fs.GetCString());
+  EXPECT_STREQ("/foo/bar", fs.GetPath().c_str());
   EXPECT_STREQ("/foo", fs.GetDirectory().GetCString());
   EXPECT_STREQ("bar", fs.GetFilename().GetCString());
 }
 
 TEST(FileSpecTest, PrependPathComponent) {
   FileSpec fs_posix("foo", FileSpec::Style::posix);
   fs_posix.PrependPathComponent("/bar");
-  EXPECT_STREQ("/bar/foo", fs_posix.GetCString());
+  EXPECT_STREQ("/bar/foo", fs_posix.GetPath().c_str());
 
   FileSpec fs_posix_2("foo/bar", FileSpec::Style::posix);
   fs_posix_2.PrependPathComponent("/baz");
-  EXPECT_STREQ("/baz/foo/bar", fs_posix_2.GetCString());
+  EXPECT_STREQ("/baz/foo/bar", fs_posix_2.GetPath().c_str());
 
   FileSpec fs_windows("baz", FileSpec::Style::windows);
   fs_windows.PrependPathComponent("F:\\bar");
-  EXPECT_STREQ("F:\\bar\\baz", fs_windows.GetCString());
+  EXPECT_STREQ("F:\\bar\\baz", fs_windows.GetPath().c_str());
 
   FileSpec fs_posix_root("bar", FileSpec::Style::posix);
   fs_posix_root.PrependPathComponent("/");
-  EXPECT_STREQ("/bar", fs_posix_root.GetCString());
+  EXPECT_STREQ("/bar", fs_posix_root.GetPath().c_str());
 
   FileSpec fs_windows_root("bar", FileSpec::Style::windows);
   fs_windows_root.PrependPathComponent("F:\\");
-  EXPECT_STREQ("F:\\bar", fs_windows_root.GetCString());
+  EXPECT_STREQ("F:\\bar", fs_windows_root.GetPath().c_str());
 }
 
 TEST(FileSpecTest, EqualSeparator) {
   EXPECT_EQ(WindowsSpec("C:\\foo\\bar"), WindowsSpec("C:/foo/bar"));
 }
 
 TEST(FileSpecTest, EqualDotsWindows) {
   std::pair<const char *, const char *> tests[] = {
TEST(FileSpecTest, IsRelative) {
   for (const auto &path: is_relative) {
     SCOPED_TRACE(path);
     EXPECT_TRUE(PosixSpec(path).IsRelative());
   }
 }
 
 TEST(FileSpecTest, RemoveLastPathComponent) {
   FileSpec fs_posix("/foo/bar/baz", FileSpec::Style::posix);
-  EXPECT_STREQ("/foo/bar/baz", fs_posix.GetCString());
+  EXPECT_STREQ("/foo/bar/baz", fs_posix.GetPath().c_str());
   EXPECT_TRUE(fs_posix.RemoveLastPathComponent());
-  EXPECT_STREQ("/foo/bar", fs_posix.GetCString());
+  EXPECT_STREQ("/foo/bar", fs_posix.GetPath().c_str());
   EXPECT_TRUE(fs_posix.RemoveLastPathComponent());
-  EXPECT_STREQ("/foo", fs_posix.GetCString());
+  EXPECT_STREQ("/foo", fs_posix.GetPath().c_str());
   EXPECT_TRUE(fs_posix.RemoveLastPathComponent());
-  EXPECT_STREQ("/", fs_posix.GetCString());
+  EXPECT_STREQ("/", fs_posix.GetPath().c_str());
   EXPECT_FALSE(fs_posix.RemoveLastPathComponent());
-  EXPECT_STREQ("/", fs_posix.GetCString());
+  EXPECT_STREQ("/", fs_posix.GetPath().c_str());
 
   FileSpec fs_posix_relative("./foo/bar/baz", FileSpec::Style::posix);
-  EXPECT_STREQ("foo/bar/baz", fs_posix_relative.GetCString());
+  EXPECT_STREQ("foo/bar/baz", fs_posix_relative.GetPath().c_str());
   EXPECT_TRUE(fs_posix_relative.RemoveLastPathComponent());
-  EXPECT_STREQ("foo/bar", fs_posix_relative.GetCString());
+  EXPECT_STREQ("foo/bar", fs_posix_relative.GetPath().c_str());
   EXPECT_TRUE(fs_posix_relative.RemoveLastPathComponent());
-  EXPECT_STREQ("foo", fs_posix_relative.GetCString());
+  EXPECT_STREQ("foo", fs_posix_relative.GetPath().c_str());
   EXPECT_FALSE(fs_posix_relative.RemoveLastPathComponent());
-  EXPECT_STREQ("foo", fs_posix_relative.GetCString());
+  EXPECT_STREQ("foo", fs_posix_relative.GetPath().c_str());
 
   FileSpec fs_posix_relative2("./", FileSpec::Style::posix);
-  EXPECT_STREQ(".", fs_posix_relative2.GetCString());
+  EXPECT_STREQ(".", fs_posix_relative2.GetPath().c_str());
   EXPECT_FALSE(fs_posix_relative2.RemoveLastPathComponent());
-  EXPECT_STREQ(".", fs_posix_relative2.GetCString());
+  EXPECT_STREQ(".", fs_posix_relative2.GetPath().c_str());
   EXPECT_FALSE(fs_posix_relative.RemoveLastPathComponent());
-  EXPECT_STREQ(".", fs_posix_relative2.GetCString());
+  EXPECT_STREQ(".", fs_posix_relative2.GetPath().c_str());
 
   FileSpec fs_windows("C:\\foo\\bar\\baz", FileSpec::Style::windows);
-  EXPECT_STREQ("C:\\foo\\bar\\baz", fs_windows.GetCString());
+  EXPECT_STREQ("C:\\foo\\bar\\baz", fs_windows.GetPath().c_str());
   EXPECT_TRUE(fs_windows.RemoveLastPathComponent());
-  EXPECT_STREQ("C:\\foo\\bar", fs_windows.GetCString());
+  EXPECT_STREQ("C:\\foo\\bar", fs_windows.GetPath().c_str());
   EXPECT_TRUE(fs_windows.RemoveLastPathComponent());
-  EXPECT_STREQ("C:\\foo", fs_windows.GetCString());
+  EXPECT_STREQ("C:\\foo", fs_windows.GetPath().c_str());
   EXPECT_TRUE(fs_windows.RemoveLastPathComponent());
-  EXPECT_STREQ("C:\\", fs_windows.GetCString());
+  EXPECT_STREQ("C:\\", fs_windows.GetPath().c_str());
   EXPECT_TRUE(fs_windows.RemoveLastPathComponent());
-  EXPECT_STREQ("C:", fs_windows.GetCString());
+  EXPECT_STREQ("C:", fs_windows.GetPath().c_str());
   EXPECT_FALSE(fs_windows.RemoveLastPathComponent());
-  EXPECT_STREQ("C:", fs_windows.GetCString());
+  EXPECT_STREQ("C:", fs_windows.GetPath().c_str());
 }
 
 TEST(FileSpecTest, Equal) {
   auto Eq = [](const char *a, const char *b, bool full) {
     return FileSpec::Equal(PosixSpec(a), PosixSpec(b), full);
   };
   EXPECT_TRUE(Eq("/foo/bar", "/foo/bar", true));
   EXPECT_TRUE(Eq("/foo/bar", "/foo/bar", false));