[lldb][NFCI] Remove use of ConstString from ProcessElfCore

[bulbazord]

Summary

I'm not convinced that it makes sense for the paths to be ConstStrings. We're
going to be putting them into FileSpecs (which are backed by
ConstStrings, for now) but otherwise there's no need to store them as
ConstStrings upfront.

[JDevlieghere]

Looks reasonable

lldb/source/Plugins/Process/elf-core/ProcessElfCore.h

 
 #ifndef LLDB_SOURCE_PLUGINS_PROCESS_ELF_CORE_PROCESSELFCORE_H
 #define LLDB_SOURCE_PLUGINS_PROCESS_ELF_CORE_PROCESSELFCORE_H
 
 #include <list>
 #include <vector>
 
 #include "lldb/Target/PostMortemProcess.h"
-#include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Status.h"
 
 #include "Plugins/ObjectFile/ELF/ELFHeader.h"
 #include "Plugins/Process/elf-core/RegisterUtilities.h"
 
 struct ThreadData;
 
 class ProcessElfCore : public lldb_private::PostMortemProcess {
protected:
 
   bool SupportsMemoryTagging() override { return !m_core_tag_ranges.IsEmpty(); }
 
 private:
   struct NT_FILE_Entry {
     lldb::addr_t start;
     lldb::addr_t end;
     lldb::addr_t file_ofs;
-    lldb_private::ConstString path;
+    std::string path;
   };
 
   // For ProcessElfCore only
   typedef lldb_private::Range<lldb::addr_t, lldb::addr_t> FileRange;
   typedef lldb_private::RangeDataVector<lldb::addr_t, lldb::addr_t, FileRange>
       VMRangeToFileOffset;
   typedef lldb_private::RangeDataVector<lldb::addr_t, lldb::addr_t, uint32_t>
       VMRangeToPermissions;

lldb/source/Plugins/Process/elf-core/ProcessElfCore.cpp

Status ProcessElfCore::DoLoadCore() {
   // Core files are useless without the main executable. See if we can locate
   // the main executable using data we found in the core file notes.
   lldb::ModuleSP exe_module_sp = GetTarget().GetExecutableModule();
   if (!exe_module_sp) {
     // The first entry in the NT_FILE might be our executable
     if (!m_nt_file_entries.empty()) {
       ModuleSpec exe_module_spec;
       exe_module_spec.GetArchitecture() = arch;
-      exe_module_spec.GetFileSpec().SetFile(
-          m_nt_file_entries[0].path.GetCString(), FileSpec::Style::native);
+      exe_module_spec.GetFileSpec().SetFile(m_nt_file_entries[0].path,
+                                            FileSpec::Style::native);
       if (exe_module_spec.GetFileSpec()) {
         exe_module_sp = GetTarget().GetOrCreateModule(exe_module_spec, 
                                                       true /* notify */);
         if (exe_module_sp)
           GetTarget().SetExecutableModule(exe_module_sp, eLoadDependentsNo);
       }
     }
   }
case ELF::NT_FILE: {
         entry.start = note.data.GetAddress(&offset);
         entry.end = note.data.GetAddress(&offset);
         entry.file_ofs = note.data.GetAddress(&offset);
         m_nt_file_entries.push_back(entry);
       }
       for (uint64_t i = 0; i < count; ++i) {
         const char *path = note.data.GetCStr(&offset);
         if (path && path[0])
-          m_nt_file_entries[i].path.SetCString(path);
+          m_nt_file_entries[i].path.assign(path);
       }
       break;
     }
     case ELF::NT_AUXV:
       m_auxv = note.data;
       break;
     default:
       thread_data.notes.push_back(note);