[lldb] Make ReadCStringFromMemory default to read from the file-cache.

[aprantl]

force_live_memory=false means use the file cache iff:

• the address has a Section
• the section is read-only

Otherwise it reads from memory.

Based on that this looks safe to me.

lldb/include/lldb/Target/Target.h

public:
   // section, then read from the file cache
   // 2 - if there is a process, then read from memory
   // 3 - if there is no process, then read from the file cache
   size_t ReadMemory(const Address &addr, void *dst, size_t dst_len,
                     Status &error, bool force_live_memory = false,
                     lldb::addr_t *load_addr_ptr = nullptr);
 
   size_t ReadCStringFromMemory(const Address &addr, std::string &out_str,
-                               Status &error);
+                               Status &error, bool force_live_memory = false);
 
   size_t ReadCStringFromMemory(const Address &addr, char *dst,
-                               size_t dst_max_len, Status &result_error);
+                               size_t dst_max_len, Status &result_error,
+                               bool force_live_memory = false);
 
   /// Read a NULL terminated string from memory
   ///
   /// This function will read a cache page at a time until a NULL string
   /// terminator is found. It will stop reading if an aligned sequence of NULL
   /// termination \a type_width bytes is not found before reading \a
   /// cstr_max_len bytes.  The results are always guaranteed to be NULL
   /// terminated, and that no more than (max_bytes - type_width) bytes will be

lldb/source/Target/Target.cpp

if (!file_cache_read_buffer && resolved_addr.IsSectionOffset()) {
     // If we didn't already try and read from the object file cache, then try
     // it after failing to read from the process.
     return ReadMemoryFromFileCache(resolved_addr, dst, dst_len, error);
   }
   return 0;
 }
 
 size_t Target::ReadCStringFromMemory(const Address &addr, std::string &out_str,
-                                     Status &error) {
+                                     Status &error, bool force_live_memory) {
   char buf[256];
   out_str.clear();
   addr_t curr_addr = addr.GetLoadAddress(this);
   Address address(addr);
   while (true) {
-    size_t length = ReadCStringFromMemory(address, buf, sizeof(buf), error);
+    size_t length = ReadCStringFromMemory(address, buf, sizeof(buf), error,
+                                          force_live_memory);
     if (length == 0)
       break;
     out_str.append(buf, length);
     // If we got "length - 1" bytes, we didn't get the whole C string, we need
     // to read some more characters
     if (length == sizeof(buf) - 1)
       curr_addr += length;
     else
       break;
     address = Address(curr_addr);
   }
   return out_str.size();
 }
 
 size_t Target::ReadCStringFromMemory(const Address &addr, char *dst,
-                                     size_t dst_max_len, Status &result_error) {
+                                     size_t dst_max_len, Status &result_error,
+                                     bool force_live_memory) {
   size_t total_cstr_len = 0;
   if (dst && dst_max_len) {
     result_error.Clear();
     // NULL out everything just to be safe
     memset(dst, 0, dst_max_len);
     Status error;
     addr_t curr_addr = addr.GetLoadAddress(this);
     Address address(addr);
 
     // We could call m_process_sp->GetMemoryCacheLineSize() but I don't think
     // this really needs to be tied to the memory cache subsystem's cache line
     // size, so leave this as a fixed constant.
     const size_t cache_line_size = 512;
 
     size_t bytes_left = dst_max_len - 1;
     char *curr_dst = dst;
 
     while (bytes_left > 0) {
       addr_t cache_line_bytes_left =
           cache_line_size - (curr_addr % cache_line_size);
       addr_t bytes_to_read =
           std::min<addr_t>(bytes_left, cache_line_bytes_left);
-      size_t bytes_read =
-          ReadMemory(address, curr_dst, bytes_to_read, error, true);
+      size_t bytes_read = ReadMemory(address, curr_dst, bytes_to_read, error,
+                                     force_live_memory);
 
       if (bytes_read == 0) {
         result_error = error;
         dst[total_cstr_len] = '\0';
         break;
       }
       const size_t len = strlen(curr_dst);