Add a setting that enables memory to be read from the file cache instead of process when the section LLDB is reading from is read-only

[aprantl]

lldb/source/Target/TargetProperties.td

180 ↗

(On Diff #336939)

What do you think about FetchReadonlyDataFromFileCache?

@jasonmolenda: Does this description sound better?

Desc<"Prefer reading read-only data from object files on disk. When debugging remotely this can be much faster than fetching memory from the target, but it might miss modifications performed by the operating system at load time.">;

[aprantl]

lldb/source/Target/Target.cpp

1760

With https://lldb.llvm.org/cpp_reference/classlldb__private_1_1Flags.html
you can write this as Flags(permissions).Test(ePermissionsWritable)

[aprantl]

Another question for @jasonmolenda: Do you happen to know if the existing prefer_file_cache mechanism applies relocations?

[jasonmolenda]

In D100338#2684550, @aprantl wrote:

Another question for @jasonmolenda: Do you happen to know if the existing prefer_file_cache mechanism applies relocations?

We can test it to make sure like

% cat >a.c
char *globstr = "hello";
% clang -dynamiclib -o liba.dylib a.c
% cat >b.c
extern char *globstr;
int main() { char *c = globstr; return c[0]; }
% clang -g -o b.out b.c -L. -la
% lldb b.out
(lldb) disass -b -n main
b.out`main:
b.out[0x100003f90] <+0>:  55                    pushq  %rbp
b.out[0x100003f91] <+1>:  48 89 e5              movq   %rsp, %rbp
b.out[0x100003f94] <+4>:  48 8b 05 65 00 00 00  movq   0x65(%rip), %rax          ; (void *)0x0000000000000000

(lldb) br s -n main
(lldb) r
(lldb) disass -b -n main
b.out`main:
    0x100003f90 <+0>:  55                    pushq  %rbp
    0x100003f91 <+1>:  48 89 e5              movq   %rsp, %rbp
    0x100003f94 <+4>:  48 8b 05 65 00 00 00  movq   0x65(%rip), %rax          ; (void *)0x0000000100128000: globstr
    0x100003f9b <+11>: c7 45 fc 00 00 00 00  movl   $0x0, -0x4(%rbp)

(lldb) ima loo -va 0x100003f9b+0x65
      Address: b.out[0x0000000100004000] (b.out.__DATA_CONST.__got + 0)
      Summary: (void *)0x0000000100128000: globstr
       Module: file = "/tmp/b.out", arch = "x86_64"

(lldb) x/gx 0x100003f9b+0x65
0x100004000: 0x0000000100128000

(lldb) tar mod dump sect b.out

  0x00000003 data-ptrs        [0x0000000100004000-0x0000000100004008)  rw-  0x00004000 0x00000008 0x00000006 b.out.__DATA_CONST.__got

This __DATA,got section is marked as rw, so we read it from memory.

[jasonmolenda]

I'm not super convinced on the setting. It seems like something you'd add some people could work around a mistake we've made here.

I think we have two cases:

Someone calls Target::ReadMemory prefer_file_cache=true on a writable section. This is an easy mistake for people to make, they assume prefer_file_cache will only prefer the file cache on read-only Sections.

Someone reads Target::ReadMemory with prefer_file_cache=false on a read-only section. This is *often* a mistake, but there are times where we genuinely want to see raw memory.

Let's think about what the default behavior of Target::ReadMemory should be. The majority use case is that we prefer the file cache if it is a read-only section. It's a performance bug in almost every case to behave differently, I maintain. There are times when we want to show actual raw memory to people. Some naughty programs that manage to modify themselves, we need to see that real naughtiness, not show what the file had and pretend that is what is in memory.

I think Target::ReadMemory should have a force_live_memory argument, not a prefer_file_cache. It could be the final argument with a default value of force_live_memory==false. Almost everyone should let Target::ReadMemory check if this address is in a RO-section, and let it get the data from the file cache if so. If it's not in a RO section, or any section, read from live memory. And have the force_live_memory arg to override this.

This is a larger set of changes though, and I don't mean to sign anyone up for more than they intended. But, just thinking of this from a clean slate, I think that's the better design. Adrian, what do you think?

[jasonmolenda]

Hm, a little more thinking. Target::ReadMemory prefers a file cache if it is available. Process::ReadMemory only uses live memory. But Process::ReadMemory doesn't work when we have run lldb on a file and not run yet. e.g.

% lldb
(lldb) tar cr -d /tmp/b.out
Current executable set to '/tmp/b.out' (x86_64).
(lldb) disass -n main
b.out`main:
b.out[0x100003f90] <+0>:  pushq  %rbp
b.out[0x100003f91] <+1>:  movq   %rsp, %rbp
b.out[0x100003f94] <+4>:  movq   0x65(%rip), %rax          ; (void *)0x0000000000000000
b.out[0x100003f9b] <+11>: movl   $0x0, -0x4(%rbp)

(lldb) ima loo -va 0x100003f9b+0x65
      Address: b.out[0x0000000100004000] (b.out.__DATA_CONST.__got + 0)
      Summary: (void *)0x0000000000000000
       Module: file = "/tmp/b.out", arch = "x86_64"

(lldb) x/gx 0x100003f9b+0x65
0x100004000: 0x0000000000000000
(lldb)

I don't have a Process, so I must be using Target::ReadMemory here. and even though this section is read-write, we don't have any live memory so we're fetching it from the file. So that's an interesting extra wrinkle I didn't remember from Target::ReadMemory.

[jasonmolenda]

Trying to reword my thinking a little more clearly.

Process::ReadMemory - only works when you have a Process. Always reads directly from memory.

Target::ReadMemory - can be used with or without a Process.

1. If force_live_memory == true, will read from memory if there is a Process. Else will read from file, if a Section covers this address.

2. If the address is in a Section that is read-only, read from the file.

3. If the address is in a section that is read-write, read from memory if there is a Process. Else read from the file, if a Section covers this address.

And I would make Target::ReadMemory's force_live_memory argument have a default value of false, because few people intend for this.

I'm open to hearing different opinions on this rethink! eg @clayborg @jingham

[aprantl]

Let's think about what the default behavior of Target::ReadMemory should be. The majority use case is that we prefer the file cache if it is a read-only section. It's a performance bug in almost every case to behave differently, I maintain. There are times when we want to show actual raw memory to people. Some naughty programs that manage to modify themselves, we need to see that real naughtiness, not show what the file had and pretend that is what is in memory.

I think Target::ReadMemory should have a force_live_memory argument, not a prefer_file_cache. It could be the final argument with a default value of force_live_memory==false. Almost everyone should let Target::ReadMemory check if this address is in a RO-section, and let it get the data from the file cache if so. If it's not in a RO section, or any section, read from live memory. And have the force_live_memory arg to override this.

This is a larger set of changes though, and I don't mean to sign anyone up for more than they intended. But, just thinking of this from a clean slate, I think that's the better design. Adrian, what do you think?

Let's try to do the right thing here. I think your suggestions make a lot of sense.

[augusto2112]

Thanks for the input @jasonmolenda. FWIW I also think it's worth implementing this correctly.

Could you help me figure out which callers I should change to force_live_memory though?

Here's a list of everywhere ReadMemory is called:

SBTarget.cpp
    ReadInstructions
    ReadMemory

CommandObjectMemory.cpp
    DoExecute

Address.cpp
    ReadBytes

Disassembler.cpp
    ParseInstructions

Value.cpp
    GetValueAsData

ValueObject.cpp
    GetPointeeData

IRMemoryMap.cpp
    ReadMemory

DynamicLoaderDarwinKernel.cpp
    ReadKextSummaries
    ReadKextSummaryHeader

DynamicLoaderDarwin.cpp
    GetThreadLocalData

EmulateInstructionMIPS.cpp
    SetInstruction

UnwindAssemblyInstEmulation.cpp
    GetNonCallSiteUnwindPlanFromAssembly

UnwindAssembly-x86.cpp
    AugmentUnwindPlanFromCallSite
    FirstNonPrologueInsn
    GetFastUnwindPlan
    GetNonCallSiteUnwindPlanFromAssembly

Target.cpp  
    ReadCStringFromMemory
    ReadScalarIntegerFromMemory

Maybe force live memory only for the functions in DynamicLoaderDarwinKernel.cpp and DynamicLoaderDarwin.cpp?

[jasonmolenda]

I should say, my suggestion of changing Target::ReadMemory is just an opinion, please do feel free to disagree!

I think if you look at the callers, I suspect all (or nearly all) of them are passing prefer_file_cache == true right now, which is the force_live_memory==false default case. Anyone passing prefer_file_cache==false would want to pass force_live_memory==true, and it may be that they are doing this incorrect (you were originally looking at an instance where that was true in swift)

An example where we WANT prefer_file_cache==false aka force_live_memory==true is in CommandObjectMemory.cpp. When people use the memory read command, we want to show them the actual memory contents [*], we don't want to optimize by getting data from a file.

• we still replace breakpoint instructions with the real instruction when reading instructions, iirc.

[augusto2112]

@jasonmolenda actually, most of them are passing prefer_file_cache = false, unfortunately. But they might be doing this because there's they weren't sure if the memory was writable, so this was the safer option. I want to change all the ones we deem safe to force_live_memory = false, which is why I ask which files you think this change would be safe.

[jasonmolenda]

In D100338#2686410, @augusto2112 wrote:

Thanks for the input @jasonmolenda. FWIW I also think it's worth implementing this correctly.

Could you help me figure out which callers I should change to force_live_memory though?

Maybe force live memory only for the functions in DynamicLoaderDarwinKernel.cpp and DynamicLoaderDarwin.cpp?

Taking a quick look at the dynamic loader plugins, DynamicLoaderDarwin is calling ReadMemory in DynamicLoaderDarwin::GetThreadLocalData and I'm pretty sure the thread load storage address it is reading will be in a writable section, so our reimagined Target::ReadMemory will read from memory anyway.

DynamicLoaderDarwinKernel is calling Target::ReadMemory in ReadKextSummaryHeader and ReadKextSummaries -- it needs to read live memory, but

(lldb) ima loo -vs gLoadedKextSummaries
1 symbols match 'gLoadedKextSummaries' in /tmp/dl/mach.development.t8002:
        Address: mach.development.t8002[0x808c66b8] (mach.development.t8002.__DATA.__common + 394936)
(lldb) tar mod dump sect
  0x00000011 zero-fill        [0x0000000080866000-0x00000000808c8294)  rw-  0x00000000 0x00000000 0x00000001 mach.development.t8002.__DATA.__common

they're reading from a writable Section so we would do the right thing.

[augusto2112]

Changed the approach from a target setting to updating Target::ReadMemory to prefer the file cache (if section is read-only)

[augusto2112]

@jasonmolenda I've updated all the function calls to prefer the file cache (except the one you pointed out), but I'm a little worried about this, since I changed a lot of function calls. Maybe I could update the function signature to force_live_memory (and default it to false), but keep all the current calls having the same behavior (by negating whatever was passed previously as prefer_file_cache). What do you think?

[jasonmolenda]

In D100338#2689846, @augusto2112 wrote:

@jasonmolenda I've updated all the function calls to prefer the file cache (except the one you pointed out), but I'm a little worried about this, since I changed a lot of function calls. Maybe I could update the function signature to force_live_memory (and default it to false), but keep all the current calls having the same behavior (by negating whatever was passed previously as prefer_file_cache). What do you think?

I think that's a safe way to approach it. This will make it easier for new callers to do the right thing when they look at the method arguments, and we can go through and audit these more carefully by hand in the future.

[augusto2112]

Updates all calls to ReadMemory to keep the current behavior.

[jasonmolenda]

This looks good, thanks for doing this!

lldb/include/lldb/Core/Disassembler.h

static lldb::DisassemblerSP FindPluginForTarget(const Target &target,
                                                   const char *flavor,
                                                   const char *plugin_name);
 
   struct Limit {
     enum { Bytes, Instructions } kind;
     lldb::addr_t value;
   };
 
-  static lldb::DisassemblerSP
-  DisassembleRange(const ArchSpec &arch, const char *plugin_name,
-                   const char *flavor, Target &target,
-                   const AddressRange &disasm_range, bool prefer_file_cache);
+  static lldb::DisassemblerSP DisassembleRange(const ArchSpec &arch,
+                                               const char *plugin_name,
+                                               const char *flavor,
+                                               Target &target,
+                                               const AddressRange &disasm_range,
+                                               bool force_live_memory = false);
 
   static lldb::DisassemblerSP
   DisassembleBytes(const ArchSpec &arch, const char *plugin_name,
                    const char *flavor, const Address &start, const void *bytes,
                    size_t length, uint32_t max_num_instructions,
                    bool data_from_file);
 
   static bool Disassemble(Debugger &debugger, const ArchSpec &arch,
public:
 
   void PrintInstructions(Debugger &debugger, const ArchSpec &arch,
                          const ExecutionContext &exe_ctx,
                          bool mixed_source_and_assembly,
                          uint32_t num_mixed_context_lines, uint32_t options,
                          Stream &strm);
 
   size_t ParseInstructions(Target &target, Address address, Limit limit,
-                           Stream *error_strm_ptr, bool prefer_file_cache);
+                           Stream *error_strm_ptr,
+                           bool force_live_memory = false);
 
   virtual size_t DecodeInstructions(const Address &base_addr,
                                     const DataExtractor &data,
                                     lldb::offset_t data_offset,
                                     size_t num_instructions, bool append,
                                     bool data_from_file) = 0;
 
   InstructionList &GetInstructionList();

lldb/include/lldb/Symbol/Function.h

public:
   ///
   /// \return
   ///     Returns 'true' if this function is a top-level function,
   ///     'false' otherwise.
   bool IsTopLevelFunction();
 
   lldb::DisassemblerSP GetInstructions(const ExecutionContext &exe_ctx,
                                        const char *flavor,
-                                       bool prefer_file_cache);
+                                       bool force_live_memory = false);
 
   bool GetDisassembly(const ExecutionContext &exe_ctx, const char *flavor,
-                      bool prefer_file_cache, Stream &strm);
+                      Stream &strm, bool force_live_memory = false);
 
 protected:
   enum {
     /// Whether we already tried to calculate the prologue size.
     flagsCalculatedPrologueSize = (1 << 0)
   };
 
   /// The compile unit that owns this function.

lldb/include/lldb/Target/Target.h

public:
 
   // Reading memory through the target allows us to skip going to the process
   // for reading memory if possible and it allows us to try and read from any
   // constant sections in our object files on disk. If you always want live
   // program memory, read straight from the process. If you possibly want to
   // read from const sections in object files, read from the target. This
   // version of ReadMemory will try and read memory from the process if the
   // process is alive. The order is:
-  // 1 - if (prefer_file_cache == true) then read from object file cache
-  // 2 - if there is a valid process, try and read from its memory
-  // 3 - if (prefer_file_cache == false) then read from object file cache
-  size_t ReadMemory(const Address &addr, bool prefer_file_cache, void *dst,
-                    size_t dst_len, Status &error,
+  // 1 - if (force_live_memory == false) and the address falls in a read-only
+  // 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);
 
   size_t ReadCStringFromMemory(const Address &addr, char *dst,
                                size_t dst_max_len, Status &result_error);
 
-  size_t ReadScalarIntegerFromMemory(const Address &addr,
-                                     bool prefer_file_cache, uint32_t byte_size,
+  size_t ReadScalarIntegerFromMemory(const Address &addr, uint32_t byte_size,
                                      bool is_signed, Scalar &scalar,
-                                     Status &error);
+                                     Status &error,
+                                     bool force_live_memory = false);
 
   uint64_t ReadUnsignedIntegerFromMemory(const Address &addr,
-                                         bool prefer_file_cache,
                                          size_t integer_byte_size,
-                                         uint64_t fail_value, Status &error);
+                                         uint64_t fail_value, Status &error,
+                                         bool force_live_memory = false);
 
-  bool ReadPointerFromMemory(const Address &addr, bool prefer_file_cache,
-                             Status &error, Address &pointer_addr);
+  bool ReadPointerFromMemory(const Address &addr, Status &error,
+                             Address &pointer_addr,
+                             bool force_live_memory = false);
 
   SectionLoadList &GetSectionLoadList() {
     return m_section_load_history.GetCurrentSectionLoadList();
   }
 
   static Target *GetTargetFromContexts(const ExecutionContext *exe_ctx_ptr,
                                        const SymbolContext *sc_ptr);
 

lldb/source/API/SBFunction.cpp

SBInstructionList SBFunction::GetInstructions(SBTarget target,
   SBInstructionList sb_instructions;
   if (m_opaque_ptr) {
     TargetSP target_sp(target.GetSP());
     std::unique_lock<std::recursive_mutex> lock;
     ModuleSP module_sp(
         m_opaque_ptr->GetAddressRange().GetBaseAddress().GetModule());
     if (target_sp && module_sp) {
       lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
-      const bool prefer_file_cache = false;
+      const bool force_live_memory = true;
       sb_instructions.SetDisassembler(Disassembler::DisassembleRange(
           module_sp->GetArchitecture(), nullptr, flavor, *target_sp,
-          m_opaque_ptr->GetAddressRange(), prefer_file_cache));
+          m_opaque_ptr->GetAddressRange(), force_live_memory));
     }
   }
   return LLDB_RECORD_RESULT(sb_instructions);
 }
 
 lldb_private::Function *SBFunction::get() { return m_opaque_ptr; }
 
 void SBFunction::reset(lldb_private::Function *lldb_object_ptr) {

lldb/source/API/SBSymbol.cpp

if (m_opaque_ptr) {
     TargetSP target_sp(target.GetSP());
     std::unique_lock<std::recursive_mutex> lock;
     if (target_sp && m_opaque_ptr->ValueIsAddress()) {
       lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
       const Address &symbol_addr = m_opaque_ptr->GetAddressRef();
       ModuleSP module_sp = symbol_addr.GetModule();
       if (module_sp) {
         AddressRange symbol_range(symbol_addr, m_opaque_ptr->GetByteSize());
-        const bool prefer_file_cache = false;
+        const bool force_live_memory = true;
         sb_instructions.SetDisassembler(Disassembler::DisassembleRange(
             module_sp->GetArchitecture(), nullptr, flavor_string, *target_sp,
-            symbol_range, prefer_file_cache));
+            symbol_range, force_live_memory));
       }
     }
   }
   return LLDB_RECORD_RESULT(sb_instructions);
 }
 
 lldb_private::Symbol *SBSymbol::get() { return m_opaque_ptr; }
 

lldb/source/API/SBTarget.cpp

LLDB_RECORD_METHOD(size_t, SBTarget, ReadMemory,
                      addr, buf, size, error);
 
   SBError sb_error;
   size_t bytes_read = 0;
   TargetSP target_sp(GetSP());
   if (target_sp) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
     bytes_read =
-        target_sp->ReadMemory(addr.ref(), false, buf, size, sb_error.ref());
+        target_sp->ReadMemory(addr.ref(), buf, size, sb_error.ref(), true);
   } else {
     sb_error.SetErrorString("invalid target");
   }
 
   return bytes_read;
 }
 
 SBBreakpoint SBTarget::BreakpointCreateByLocation(const char *file,
lldb::SBInstructionList SBTarget::ReadInstructions(lldb::SBAddress base_addr,
 
   TargetSP target_sp(GetSP());
   if (target_sp) {
     Address *addr_ptr = base_addr.get();
 
     if (addr_ptr) {
       DataBufferHeap data(
           target_sp->GetArchitecture().GetMaximumOpcodeByteSize() * count, 0);
-      bool prefer_file_cache = false;
+      bool force_live_memory = true;
       lldb_private::Status error;
       lldb::addr_t load_addr = LLDB_INVALID_ADDRESS;
       const size_t bytes_read =
-          target_sp->ReadMemory(*addr_ptr, prefer_file_cache, data.GetBytes(),
-                                data.GetByteSize(), error, &load_addr);
+          target_sp->ReadMemory(*addr_ptr, data.GetBytes(), data.GetByteSize(),
+                                error, force_live_memory, &load_addr);
       const bool data_from_file = load_addr == LLDB_INVALID_ADDRESS;
       sb_instructions.SetDisassembler(Disassembler::DisassembleBytes(
           target_sp->GetArchitecture(), nullptr, flavor_string, *addr_ptr,
           data.GetBytes(), bytes_read, count, data_from_file));
     }
   }
 
   return LLDB_RECORD_RESULT(sb_instructions);

lldb/source/Commands/CommandObjectMemory.cpp

if (compiler_type.GetOpaqueQualType()) {
             "can't allocate 0x%" PRIx32
             " bytes for the memory read buffer, specify a smaller size to read",
             (uint32_t)total_byte_size);
         result.SetStatus(eReturnStatusFailed);
         return false;
       }
 
       Address address(addr, nullptr);
-      bytes_read = target->ReadMemory(address, false, data_sp->GetBytes(),
-                                      data_sp->GetByteSize(), error);
+      bytes_read = target->ReadMemory(address, data_sp->GetBytes(),
+                                      data_sp->GetByteSize(), error, true);
       if (bytes_read == 0) {
         const char *error_cstr = error.AsCString();
         if (error_cstr && error_cstr[0]) {
           result.AppendError(error_cstr);
         } else {
           result.AppendErrorWithFormat(
               "failed to read memory from 0x%" PRIx64 ".\n", addr);
         }

lldb/source/Core/Address.cpp

 static size_t ReadBytes(ExecutionContextScope *exe_scope,
                         const Address &address, void *dst, size_t dst_len) {
   if (exe_scope == nullptr)
     return 0;
 
   TargetSP target_sp(exe_scope->CalculateTarget());
   if (target_sp) {
     Status error;
-    bool prefer_file_cache = false;
-    return target_sp->ReadMemory(address, prefer_file_cache, dst, dst_len,
-                                 error);
+    bool force_live_memory = true;
+    return target_sp->ReadMemory(address, dst, dst_len, error,
+                                 force_live_memory);
   }
   return 0;
 }
 
 static bool GetByteOrderAndAddressSize(ExecutionContextScope *exe_scope,
                                        const Address &address,
                                        ByteOrder &byte_order,
                                        uint32_t &addr_size) {

lldb/source/Core/Disassembler.cpp

if (!addr.IsSectionOffset()) {
     if (is_resolved && resolved_addr.IsValid())
       return resolved_addr;
   }
   return addr;
 }
 
 lldb::DisassemblerSP Disassembler::DisassembleRange(
     const ArchSpec &arch, const char *plugin_name, const char *flavor,
-    Target &target, const AddressRange &range, bool prefer_file_cache) {
+    Target &target, const AddressRange &range, bool force_live_memory) {
   if (range.GetByteSize() <= 0)
     return {};
 
   if (!range.GetBaseAddress().IsValid())
     return {};
 
   lldb::DisassemblerSP disasm_sp =
       Disassembler::FindPluginForTarget(target, arch, flavor, plugin_name);
 
   if (!disasm_sp)
     return {};
 
   const size_t bytes_disassembled = disasm_sp->ParseInstructions(
       target, range.GetBaseAddress(), {Limit::Bytes, range.GetByteSize()},
-      nullptr, prefer_file_cache);
+      nullptr, force_live_memory);
   if (bytes_disassembled == 0)
     return {};
 
   return disasm_sp;
 }
 
 lldb::DisassemblerSP
 Disassembler::DisassembleBytes(const ArchSpec &arch, const char *plugin_name,
bool Disassembler::Disassemble(Debugger &debugger, const ArchSpec &arch,
   if (!exe_ctx.GetTargetPtr())
     return false;
 
   lldb::DisassemblerSP disasm_sp(Disassembler::FindPluginForTarget(
       exe_ctx.GetTargetRef(), arch, flavor, plugin_name));
   if (!disasm_sp)
     return false;
 
-  const bool prefer_file_cache = false;
+  const bool force_live_memory = true;
   size_t bytes_disassembled = disasm_sp->ParseInstructions(
-      exe_ctx.GetTargetRef(), address, limit, &strm, prefer_file_cache);
+      exe_ctx.GetTargetRef(), address, limit, &strm, force_live_memory);
   if (bytes_disassembled == 0)
     return false;
 
   disasm_sp->PrintInstructions(debugger, arch, exe_ctx,
                                mixed_source_and_assembly,
                                num_mixed_context_lines, options, strm);
   return true;
 }
InstructionList::GetIndexOfInstructionAtLoadAddress(lldb::addr_t load_addr,
                                                     Target &target) {
   Address address;
   address.SetLoadAddress(load_addr, &target);
   return GetIndexOfInstructionAtAddress(address);
 }
 
 size_t Disassembler::ParseInstructions(Target &target, Address start,
                                        Limit limit, Stream *error_strm_ptr,
-                                       bool prefer_file_cache) {
+                                       bool force_live_memory) {
   m_instruction_list.Clear();
 
   if (!start.IsValid())
     return 0;
 
   start = ResolveAddress(target, start);
 
   addr_t byte_size = limit.value;
   if (limit.kind == Limit::Instructions)
     byte_size *= m_arch.GetMaximumOpcodeByteSize();
   auto data_sp = std::make_shared<DataBufferHeap>(byte_size, '\0');
 
   Status error;
   lldb::addr_t load_addr = LLDB_INVALID_ADDRESS;
   const size_t bytes_read =
-      target.ReadMemory(start, prefer_file_cache, data_sp->GetBytes(),
-                        data_sp->GetByteSize(), error, &load_addr);
+      target.ReadMemory(start, data_sp->GetBytes(), data_sp->GetByteSize(),
+                        error, force_live_memory, &load_addr);
   const bool data_from_file = load_addr == LLDB_INVALID_ADDRESS;
 
   if (bytes_read == 0) {
     if (error_strm_ptr) {
       if (const char *error_cstr = error.AsCString())
         error_strm_ptr->Printf("error: %s\n", error_cstr);
     }
     return 0;

lldb/source/Core/IOHandlerCursesGUI.cpp

if (update_location) {
 
         if (!m_file_sp || m_file_sp->GetNumLines() == 0) {
           // Show disassembly
           bool prefer_file_cache = false;
           if (m_sc.function) {
             if (m_disassembly_scope != m_sc.function) {
               m_disassembly_scope = m_sc.function;
               m_disassembly_sp = m_sc.function->GetInstructions(
-                  exe_ctx, nullptr, prefer_file_cache);
+                  exe_ctx, nullptr, !prefer_file_cache);
               if (m_disassembly_sp) {
                 set_selected_line_to_pc = true;
                 m_disassembly_range = m_sc.function->GetAddressRange();
               } else {
                 m_disassembly_range.Clear();
               }
             } else {
               set_selected_line_to_pc = context_changed;

lldb/source/Core/Value.cpp

if (address_type == eAddressTypeHost) {
       if (address == 0) {
         error.SetErrorString("trying to read from host address of 0.");
         return error;
       }
       memcpy(dst, reinterpret_cast<uint8_t *>(address), byte_size);
     } else if ((address_type == eAddressTypeLoad) ||
                (address_type == eAddressTypeFile)) {
       if (file_so_addr.IsValid()) {
-        // We have a file address that we were able to translate into a section
-        // offset address so we might be able to read this from the object
-        // files if we don't have a live process. Lets always try and read from
-        // the process if we have one though since we want to read the actual
-        // value by setting "prefer_file_cache" to false.
-        const bool prefer_file_cache = false;
-        if (exe_ctx->GetTargetRef().ReadMemory(file_so_addr, prefer_file_cache,
-                                               dst, byte_size,
-                                               error) != byte_size) {
+        const bool force_live_memory = true;
+        if (exe_ctx->GetTargetRef().ReadMemory(file_so_addr, dst, byte_size,
+                                               error, force_live_memory) !=
+            byte_size) {
           error.SetErrorStringWithFormat(
               "read memory from 0x%" PRIx64 " failed", (uint64_t)address);
         }
       } else {
         // The execution context might have a NULL process, but it might have a
         // valid process in the exe_ctx->target, so use the
         // ExecutionContext::GetProcess accessor to ensure we get the process
         // if there is one.

lldb/source/Core/ValueObject.cpp

case eAddressTypeFile: {
         addr = addr + offset;
         Address so_addr;
         module_sp->ResolveFileAddress(addr, so_addr);
         ExecutionContext exe_ctx(GetExecutionContextRef());
         Target *target = exe_ctx.GetTargetPtr();
         if (target) {
           heap_buf_ptr->SetByteSize(bytes);
           size_t bytes_read = target->ReadMemory(
-              so_addr, false, heap_buf_ptr->GetBytes(), bytes, error);
+              so_addr, heap_buf_ptr->GetBytes(), bytes, error, true);
           if (error.Success()) {
             data.SetData(data_sp);
             return bytes_read;
           }
         }
       }
     } break;
     case eAddressTypeLoad: {

lldb/source/Expression/IRMemoryMap.cpp

if (process_sp) {
       process_sp->ReadMemory(process_address, bytes, size, error);
       return;
     }
 
     lldb::TargetSP target_sp = m_target_wp.lock();
 
     if (target_sp) {
       Address absolute_address(process_address);
-      target_sp->ReadMemory(absolute_address, false, bytes, size, error);
+      target_sp->ReadMemory(absolute_address, bytes, size, error, true);
       return;
     }
 
     error.SetErrorToGenericError();
     error.SetErrorString("Couldn't read: no allocation contains the target "
                          "range, and neither the process nor the target exist");
     return;
   }

lldb/source/Plugins/Architecture/Mips/ArchitectureMips.cpp

Instruction *ArchitectureMips::GetInstructionAtAddress(
   }
 
   // Create Disassembler Instance
   lldb::DisassemblerSP disasm_sp(
     Disassembler::FindPlugin(m_arch, nullptr, nullptr));
 
   InstructionList instruction_list;
   InstructionSP prev_insn;
-  bool prefer_file_cache = true; // Read from file
   uint32_t inst_to_choose = 0;
 
   Address addr = resolved_addr;
 
   for (uint32_t i = 1; i <= loop_count; i++) {
     // Adjust the address to read from.
     addr.Slide(-2);
     uint32_t insn_size = 0;
 
     disasm_sp->ParseInstructions(target, addr,
-                                 {Disassembler::Limit::Bytes, i * 2}, nullptr,
-                                 prefer_file_cache);
+                                 {Disassembler::Limit::Bytes, i * 2}, nullptr);
 
     uint32_t num_insns = disasm_sp->GetInstructionList().GetSize();
     if (num_insns) {
       prev_insn = disasm_sp->GetInstructionList().GetInstructionAtIndex(0);
       insn_size = prev_insn->GetOpcode().GetByteSize();
       if (i == 1 && insn_size == 2) {
         // This looks like a valid 2-byte instruction (but it could be a part
         // of upper 4 byte instruction).

lldb/source/Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.cpp

if (m_kext_summary_header_ptr_addr.IsValid()) {
     const uint32_t addr_size = m_kernel.GetAddressByteSize();
     const ByteOrder byte_order = m_kernel.GetByteOrder();
     Status error;
     // Read enough bytes for a "OSKextLoadedKextSummaryHeader" structure which
     // is currently 4 uint32_t and a pointer.
     uint8_t buf[24];
     DataExtractor data(buf, sizeof(buf), byte_order, addr_size);
     const size_t count = 4 * sizeof(uint32_t) + addr_size;
-    const bool prefer_file_cache = false;
+    const bool force_live_memory = true;
     if (m_process->GetTarget().ReadPointerFromMemory(
-            m_kext_summary_header_ptr_addr, prefer_file_cache, error,
-            m_kext_summary_header_addr)) {
+            m_kext_summary_header_ptr_addr, error,
+            m_kext_summary_header_addr, force_live_memory)) {
       // We got a valid address for our kext summary header and make sure it
       // isn't NULL
       if (m_kext_summary_header_addr.IsValid() &&
           m_kext_summary_header_addr.GetFileAddress() != 0) {
         const size_t bytes_read = m_process->GetTarget().ReadMemory(
-            m_kext_summary_header_addr, prefer_file_cache, buf, count, error);
+            m_kext_summary_header_addr, buf, count, error, force_live_memory);
         if (bytes_read == count) {
           lldb::offset_t offset = 0;
           m_kext_summary_header.version = data.GetU32(&offset);
           if (m_kext_summary_header.version > 128) {
             Stream &s = m_process->GetTarget().GetDebugger().GetOutputStream();
             s.Printf("WARNING: Unable to read kext summary header, got "
                      "improbable version number %u\n",
                      m_kext_summary_header.version);
uint32_t DynamicLoaderDarwinKernel::ReadKextSummaries(
   const ByteOrder endian = m_kernel.GetByteOrder();
   const uint32_t addr_size = m_kernel.GetAddressByteSize();
 
   image_infos.resize(image_infos_count);
   const size_t count = image_infos.size() * m_kext_summary_header.entry_size;
   DataBufferHeap data(count, 0);
   Status error;
 
-  const bool prefer_file_cache = false;
+  const bool force_live_memory = true;
   const size_t bytes_read = m_process->GetTarget().ReadMemory(
-      kext_summary_addr, prefer_file_cache, data.GetBytes(), data.GetByteSize(),
-      error);
+      kext_summary_addr, data.GetBytes(), data.GetByteSize(), error, force_live_memory);
   if (bytes_read == count) {
 
     DataExtractor extractor(data.GetBytes(), data.GetByteSize(), endian,
                             addr_size);
     uint32_t i = 0;
     for (uint32_t kext_summary_offset = 0;
          i < image_infos.size() &&
          extractor.ValidOffsetForDataOfSize(kext_summary_offset,

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

DynamicLoaderDarwin::GetThreadLocalData(const lldb::ModuleSP module_sp,
   const uint32_t addr_size = m_process->GetAddressByteSize();
   uint8_t buf[sizeof(lldb::addr_t) * 3];
 
   lldb_private::Address tls_addr;
   if (module_sp->ResolveFileAddress(tls_file_addr, tls_addr)) {
     Status error;
     const size_t tsl_data_size = addr_size * 3;
     Target &target = m_process->GetTarget();
-    if (target.ReadMemory(tls_addr, false, buf, tsl_data_size, error) ==
+    if (target.ReadMemory(tls_addr, buf, tsl_data_size, error, true) ==
         tsl_data_size) {
       const ByteOrder byte_order = m_process->GetByteOrder();
       DataExtractor data(buf, sizeof(buf), byte_order, addr_size);
       lldb::offset_t offset = addr_size; // Skip the first pointer
       const lldb::addr_t pthread_key = data.GetAddress(&offset);
       const lldb::addr_t tls_offset = data.GetAddress(&offset);
       if (pthread_key != 0) {
         // First check to see if we have already figured out the location of

lldb/source/Plugins/DynamicLoader/Windows-DYLD/DynamicLoaderWindowsDYLD.cpp

if (arch.GetMachine() != llvm::Triple::x86) {
     return ThreadPlanSP();
   }
 
   uint64_t pc = thread.GetRegisterContext()->GetPC();
   // Max size of an instruction in x86 is 15 bytes.
   AddressRange range(pc, 2 * 15);
 
   DisassemblerSP disassembler_sp = Disassembler::DisassembleRange(
-      arch, nullptr, nullptr, m_process->GetTarget(), range, true);
+      arch, nullptr, nullptr, m_process->GetTarget(), range);
   if (!disassembler_sp) {
     return ThreadPlanSP();
   }
 
   InstructionList *insn_list = &disassembler_sp->GetInstructionList();
   if (insn_list == nullptr) {
     return ThreadPlanSP();
   }

lldb/source/Plugins/Instruction/MIPS/EmulateInstructionMIPS.cpp

if (inst_addr.GetAddressClass() == AddressClass::eCodeAlternateISA) {
 
       uint32_t current_inst_size = insn_opcode.GetByteSize();
       uint8_t buf[sizeof(uint32_t)];
       uint64_t next_inst_addr = (m_addr & (~1ull)) + current_inst_size;
       Address next_addr(next_inst_addr);
 
       const size_t bytes_read =
           target->ReadMemory(next_addr, /* Address of next instruction */
-                             true,      /* prefer_file_cache */
-                             buf, sizeof(uint32_t), error, &load_addr);
+                             buf, sizeof(uint32_t), error, 
+                             false,  /* force_live_memory */
+                             &load_addr);
 
       if (bytes_read == 0)
         return true;
 
       DataExtractor data(buf, sizeof(uint32_t), GetByteOrder(),
                          GetAddressByteSize());
       m_next_inst_size = GetSizeOfInstruction(data, next_inst_addr);
       return true;

lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

else if ((symbol.d_tag == DT_MIPS_RLD_MAP ||
       addr_t dyn_base = dynsym_section_sp->GetLoadBaseAddress(target);
       if (dyn_base == LLDB_INVALID_ADDRESS)
         return Address();
 
       Status error;
       if (symbol.d_tag == DT_MIPS_RLD_MAP) {
         // DT_MIPS_RLD_MAP tag stores an absolute address of the debug pointer.
         Address addr;
-        if (target->ReadPointerFromMemory(dyn_base + offset, false, error,
-                                          addr))
+        if (target->ReadPointerFromMemory(dyn_base + offset, error, addr, true))
           return addr;
       }
       if (symbol.d_tag == DT_MIPS_RLD_MAP_REL) {
         // DT_MIPS_RLD_MAP_REL tag stores the offset to the debug pointer,
         // relative to the address of the tag.
         uint64_t rel_offset;
         rel_offset = target->ReadUnsignedIntegerFromMemory(
-            dyn_base + offset, false, GetAddressByteSize(), UINT64_MAX, error);
+            dyn_base + offset, GetAddressByteSize(), UINT64_MAX, error, true);
         if (error.Success() && rel_offset != UINT64_MAX) {
           Address addr;
           addr_t debug_ptr_address =
               dyn_base + (offset - GetAddressByteSize()) + rel_offset;
           addr.SetOffset(debug_ptr_address);
           return addr;
         }
       }

lldb/source/Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.cpp

 //  UnwindAssemblyInstEmulation method definitions
 
 bool UnwindAssemblyInstEmulation::GetNonCallSiteUnwindPlanFromAssembly(
     AddressRange &range, Thread &thread, UnwindPlan &unwind_plan) {
   std::vector<uint8_t> function_text(range.GetByteSize());
   ProcessSP process_sp(thread.GetProcess());
   if (process_sp) {
     Status error;
-    const bool prefer_file_cache = true;
+    const bool force_live_memory = true;
     if (process_sp->GetTarget().ReadMemory(
-            range.GetBaseAddress(), prefer_file_cache, function_text.data(),
-            range.GetByteSize(), error) != range.GetByteSize()) {
+            range.GetBaseAddress(), function_text.data(), range.GetByteSize(),
+            error, force_live_memory) != range.GetByteSize()) {
       return false;
     }
   }
   return GetNonCallSiteUnwindPlanFromAssembly(
       range, function_text.data(), function_text.size(), unwind_plan);
 }
 
 bool UnwindAssemblyInstEmulation::GetNonCallSiteUnwindPlanFromAssembly(

lldb/source/Plugins/UnwindAssembly/x86/UnwindAssembly-x86.cpp

bool UnwindAssembly_x86::GetNonCallSiteUnwindPlanFromAssembly(
     AddressRange &func, Thread &thread, UnwindPlan &unwind_plan) {
   if (!func.GetBaseAddress().IsValid() || func.GetByteSize() == 0)
     return false;
   if (m_assembly_inspection_engine == nullptr)
     return false;
   ProcessSP process_sp(thread.GetProcess());
   if (process_sp.get() == nullptr)
     return false;
-  const bool prefer_file_cache = true;
   std::vector<uint8_t> function_text(func.GetByteSize());
   Status error;
   if (process_sp->GetTarget().ReadMemory(
-          func.GetBaseAddress(), prefer_file_cache, function_text.data(),
-          func.GetByteSize(), error) == func.GetByteSize()) {
+          func.GetBaseAddress(), function_text.data(), func.GetByteSize(),
+          error) == func.GetByteSize()) {
     RegisterContextSP reg_ctx(thread.GetRegisterContext());
     m_assembly_inspection_engine->Initialize(reg_ctx);
     return m_assembly_inspection_engine->GetNonCallSiteUnwindPlanFromAssembly(
         function_text.data(), func.GetByteSize(), func, unwind_plan);
   }
   return false;
 }
 
if (first_row != last_row &&
     }
   }
 
   if (do_augment_unwindplan) {
     if (!func.GetBaseAddress().IsValid() || func.GetByteSize() == 0)
       return false;
     if (m_assembly_inspection_engine == nullptr)
       return false;
-    const bool prefer_file_cache = true;
     std::vector<uint8_t> function_text(func.GetByteSize());
     Status error;
     if (process_sp->GetTarget().ReadMemory(
-            func.GetBaseAddress(), prefer_file_cache, function_text.data(),
-            func.GetByteSize(), error) == func.GetByteSize()) {
+            func.GetBaseAddress(), function_text.data(), func.GetByteSize(),
+            error) == func.GetByteSize()) {
       RegisterContextSP reg_ctx(thread.GetRegisterContext());
       m_assembly_inspection_engine->Initialize(reg_ctx);
       return m_assembly_inspection_engine->AugmentUnwindPlanFromCallSite(
           function_text.data(), func.GetByteSize(), func, unwind_plan, reg_ctx);
     }
   }
 
   return false;
bool UnwindAssembly_x86::GetFastUnwindPlan(AddressRange &func, Thread &thread,
 
   // We should pull in the ABI architecture default unwind plan and return that
 
   llvm::SmallVector<uint8_t, 4> opcode_data;
 
   ProcessSP process_sp = thread.GetProcess();
   if (process_sp) {
     Target &target(process_sp->GetTarget());
-    const bool prefer_file_cache = true;
     Status error;
-    if (target.ReadMemory(func.GetBaseAddress(), prefer_file_cache,
-                          opcode_data.data(), 4, error) == 4) {
+    if (target.ReadMemory(func.GetBaseAddress(), opcode_data.data(), 4,
+                          error) == 4) {
       uint8_t i386_push_mov[] = {0x55, 0x89, 0xe5};
       uint8_t x86_64_push_mov[] = {0x55, 0x48, 0x89, 0xe5};
 
       if (memcmp(opcode_data.data(), i386_push_mov, sizeof(i386_push_mov)) ==
               0 ||
           memcmp(opcode_data.data(), x86_64_push_mov,
                  sizeof(x86_64_push_mov)) == 0) {
         ABISP abi_sp = process_sp->GetABI();
bool UnwindAssembly_x86::FirstNonPrologueInsn(
 
   Target *target = exe_ctx.GetTargetPtr();
   if (target == nullptr)
     return false;
 
   if (m_assembly_inspection_engine == nullptr)
     return false;
 
-  const bool prefer_file_cache = true;
   std::vector<uint8_t> function_text(func.GetByteSize());
   Status error;
-  if (target->ReadMemory(func.GetBaseAddress(), prefer_file_cache,
-                         function_text.data(), func.GetByteSize(),
-                         error) == func.GetByteSize()) {
+  if (target->ReadMemory(func.GetBaseAddress(), function_text.data(),
+                         func.GetByteSize(), error) == func.GetByteSize()) {
     size_t offset;
     if (m_assembly_inspection_engine->FindFirstNonPrologueInstruction(
             function_text.data(), func.GetByteSize(), offset)) {
       first_non_prologue_insn = func.GetBaseAddress();
       first_non_prologue_insn.Slide(offset);
     }
     return true;
   }

lldb/source/Symbol/Function.cpp

 
 Function *Function::CalculateSymbolContextFunction() { return this; }
 
 lldb::DisassemblerSP Function::GetInstructions(const ExecutionContext &exe_ctx,
                                                const char *flavor,
                                                bool prefer_file_cache) {
   ModuleSP module_sp(GetAddressRange().GetBaseAddress().GetModule());
   if (module_sp && exe_ctx.HasTargetScope()) {
-    const bool prefer_file_cache = false;
     return Disassembler::DisassembleRange(module_sp->GetArchitecture(), nullptr,
                                           flavor, exe_ctx.GetTargetRef(),
-                                          GetAddressRange(), prefer_file_cache);
+                                          GetAddressRange(), !prefer_file_cache);
   }
   return lldb::DisassemblerSP();
 }
 
 bool Function::GetDisassembly(const ExecutionContext &exe_ctx,
-                              const char *flavor, bool prefer_file_cache,
-                              Stream &strm) {
+                              const char *flavor, Stream &strm,
+                              bool prefer_file_cache) {
   lldb::DisassemblerSP disassembler_sp =
       GetInstructions(exe_ctx, flavor, prefer_file_cache);
   if (disassembler_sp) {
     const bool show_address = true;
     const bool show_bytes = false;
     disassembler_sp->GetInstructionList().Dump(&strm, show_address, show_bytes,
                                                &exe_ctx);
     return true;

lldb/source/Symbol/Symbol.cpp

lldb::addr_t Symbol::ResolveCallableAddress(Target &target) const {
   return LLDB_INVALID_ADDRESS;
 }
 
 lldb::DisassemblerSP Symbol::GetInstructions(const ExecutionContext &exe_ctx,
                                              const char *flavor,
                                              bool prefer_file_cache) {
   ModuleSP module_sp(m_addr_range.GetBaseAddress().GetModule());
   if (module_sp && exe_ctx.HasTargetScope()) {
-    const bool prefer_file_cache = false;
     return Disassembler::DisassembleRange(module_sp->GetArchitecture(), nullptr,
                                           flavor, exe_ctx.GetTargetRef(),
-                                          m_addr_range, prefer_file_cache);
+                                          m_addr_range, !prefer_file_cache);
   }
   return lldb::DisassemblerSP();
 }
 
 bool Symbol::GetDisassembly(const ExecutionContext &exe_ctx, const char *flavor,
                             bool prefer_file_cache, Stream &strm) {
   lldb::DisassemblerSP disassembler_sp =
       GetInstructions(exe_ctx, flavor, prefer_file_cache);

lldb/source/Target/Process.cpp

Process::AdvanceAddressToNextBranchInstruction(Address default_stop_addr,
 
   if (!target.GetUseFastStepping())
     return retval;
   if (!default_stop_addr.IsValid())
     return retval;
 
   const char *plugin_name = nullptr;
   const char *flavor = nullptr;
-  const bool prefer_file_cache = true;
   disassembler_sp = Disassembler::DisassembleRange(
-      target.GetArchitecture(), plugin_name, flavor, GetTarget(), range_bounds,
-      prefer_file_cache);
+      target.GetArchitecture(), plugin_name, flavor, GetTarget(), range_bounds);
   if (disassembler_sp)
     insn_list = &disassembler_sp->GetInstructionList();
 
   if (insn_list == nullptr) {
     return retval;
   }
 
   size_t insn_offset =

lldb/source/Target/StackFrame.cpp

lldb::ValueObjectSP StackFrame::GuessValueForAddress(lldb::addr_t addr) {
   const ArchSpec &target_arch = target_sp->GetArchitecture();
 
   AddressRange pc_range;
   pc_range.GetBaseAddress() = GetFrameCodeAddress();
   pc_range.SetByteSize(target_arch.GetMaximumOpcodeByteSize());
 
   const char *plugin_name = nullptr;
   const char *flavor = nullptr;
-  const bool prefer_file_cache = false;
+  const bool force_live_memory = true;
 
   DisassemblerSP disassembler_sp =
       Disassembler::DisassembleRange(target_arch, plugin_name, flavor,
-                                     *target_sp, pc_range, prefer_file_cache);
+                                     *target_sp, pc_range, force_live_memory);
 
   if (!disassembler_sp || !disassembler_sp->GetInstructionList().GetSize()) {
     return ValueObjectSP();
   }
 
   InstructionSP instruction_sp =
       disassembler_sp->GetInstructionList().GetInstructionAtIndex(0);
 
if (GetFrameCodeAddress().GetFileAddress() <
       GetFrameCodeAddress().GetFileAddress() -
               pc_range.GetBaseAddress().GetFileAddress() >=
           pc_range.GetByteSize()) {
     return ValueObjectSP();
   }
 
   const char *plugin_name = nullptr;
   const char *flavor = nullptr;
-  const bool prefer_file_cache = false;
+  const bool force_live_memory = true;
   DisassemblerSP disassembler_sp =
       Disassembler::DisassembleRange(target_arch, plugin_name, flavor,
-                                     *target_sp, pc_range, prefer_file_cache);
+                                     *target_sp, pc_range, force_live_memory);
 
   if (!disassembler_sp || !disassembler_sp->GetInstructionList().GetSize()) {
     return ValueObjectSP();
   }
 
   const bool get_file_globals = false;
   VariableList *variables = GetVariableList(get_file_globals);
 

lldb/source/Target/Target.cpp

if (module_sp) {
       error.SetErrorString("address isn't in a module");
   } else
     error.SetErrorString("address doesn't contain a section that points to a "
                          "section in a object file");
 
   return 0;
 }
 
-size_t Target::ReadMemory(const Address &addr, bool prefer_file_cache,
-                          void *dst, size_t dst_len, Status &error,
+size_t Target::ReadMemory(const Address &addr, void *dst, size_t dst_len,
+                          Status &error, bool force_live_memory,
                           lldb::addr_t *load_addr_ptr) {
   error.Clear();
 
   // if we end up reading this from process memory, we will fill this with the
   // actual load address
   if (load_addr_ptr)
     *load_addr_ptr = LLDB_INVALID_ADDRESS;
 
if (section_load_list.IsEmpty()) {
       load_addr = addr.GetOffset(); // "addr" doesn't have a section, so its
                                     // offset is the load address
       section_load_list.ResolveLoadAddress(load_addr, resolved_addr);
     }
   }
   if (!resolved_addr.IsValid())
     resolved_addr = addr;
 
-  if (prefer_file_cache) {
+  bool is_readonly = false;
+  // Read from file cache if read-only section.
+  if (!force_live_memory && resolved_addr.IsSectionOffset()) {
+    SectionSP section_sp(addr.GetSection());
+    if (section_sp) {
+      auto permissions = Flags(section_sp->GetPermissions());
+      is_readonly = !permissions.Test(ePermissionsWritable) &&
+                    permissions.Test(ePermissionsReadable);
+    }
+    if (is_readonly) {
       bytes_read = ReadMemoryFromFileCache(resolved_addr, dst, dst_len, error);
       if (bytes_read > 0)
         return bytes_read;
     }
+  }
 
   if (ProcessIsValid()) {
     if (load_addr == LLDB_INVALID_ADDRESS)
       load_addr = resolved_addr.GetLoadAddress(this);
 
     if (load_addr == LLDB_INVALID_ADDRESS) {
       ModuleSP addr_module_sp(resolved_addr.GetModule());
       if (addr_module_sp && addr_module_sp->GetFileSpec())
if (load_addr == LLDB_INVALID_ADDRESS) {
                 (uint64_t)bytes_read, (uint64_t)dst_len, load_addr);
         }
       }
       if (bytes_read) {
         if (load_addr_ptr)
           *load_addr_ptr = load_addr;
         return bytes_read;
       }
-      // If the address is not section offset we have an address that doesn't
-      // resolve to any address in any currently loaded shared libraries and we
-      // failed to read memory so there isn't anything more we can do. If it is
-      // section offset, we might be able to read cached memory from the object
-      // file.
-      if (!resolved_addr.IsSectionOffset())
-        return 0;
     }
   }
 
-  if (!prefer_file_cache && resolved_addr.IsSectionOffset()) {
+  if (!is_readonly && 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,
if (dst && dst_max_len) {
     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, false, curr_dst, bytes_to_read, error);
+          ReadMemory(address, curr_dst, bytes_to_read, error, true);
 
       if (bytes_read == 0) {
         result_error = error;
         dst[total_cstr_len] = '\0';
         break;
       }
       const size_t len = strlen(curr_dst);
 
if (dst && dst_max_len) {
     if (dst == nullptr)
       result_error.SetErrorString("invalid arguments");
     else
       result_error.Clear();
   }
   return total_cstr_len;
 }
 
-size_t Target::ReadScalarIntegerFromMemory(const Address &addr,
-                                           bool prefer_file_cache,
-                                           uint32_t byte_size, bool is_signed,
-                                           Scalar &scalar, Status &error) {
+size_t Target::ReadScalarIntegerFromMemory(const Address &addr, uint32_t byte_size,
+                                           bool is_signed, Scalar &scalar,
+                                           Status &error,
+                                           bool force_live_memory) {
   uint64_t uval;
 
   if (byte_size <= sizeof(uval)) {
     size_t bytes_read =
-        ReadMemory(addr, prefer_file_cache, &uval, byte_size, error);
+        ReadMemory(addr, &uval, byte_size, error, force_live_memory);
     if (bytes_read == byte_size) {
       DataExtractor data(&uval, sizeof(uval), m_arch.GetSpec().GetByteOrder(),
                          m_arch.GetSpec().GetAddressByteSize());
       lldb::offset_t offset = 0;
       if (byte_size <= 4)
         scalar = data.GetMaxU32(&offset, byte_size);
       else
         scalar = data.GetMaxU64(&offset, byte_size);
 
       if (is_signed)
         scalar.SignExtend(byte_size * 8);
       return bytes_read;
     }
   } else {
     error.SetErrorStringWithFormat(
         "byte size of %u is too large for integer scalar type", byte_size);
   }
   return 0;
 }
 
 uint64_t Target::ReadUnsignedIntegerFromMemory(const Address &addr,
-                                               bool prefer_file_cache,
                                                size_t integer_byte_size,
-                                               uint64_t fail_value,
-                                               Status &error) {
+                                               uint64_t fail_value, Status &error,
+                                               bool force_live_memory) {
   Scalar scalar;
-  if (ReadScalarIntegerFromMemory(addr, prefer_file_cache, integer_byte_size,
-                                  false, scalar, error))
+  if (ReadScalarIntegerFromMemory(addr, integer_byte_size, false, scalar, error,
+                                  force_live_memory))
     return scalar.ULongLong(fail_value);
   return fail_value;
 }
 
-bool Target::ReadPointerFromMemory(const Address &addr, bool prefer_file_cache,
-                                   Status &error, Address &pointer_addr) {
+bool Target::ReadPointerFromMemory(const Address &addr, Status &error,
+                                   Address &pointer_addr,
+                                   bool force_live_memory) {
   Scalar scalar;
-  if (ReadScalarIntegerFromMemory(addr, prefer_file_cache,
-                                  m_arch.GetSpec().GetAddressByteSize(), false,
-                                  scalar, error)) {
+  if (ReadScalarIntegerFromMemory(addr, m_arch.GetSpec().GetAddressByteSize(),
+                                  false, scalar, error, force_live_memory)) {
     addr_t pointer_vm_addr = scalar.ULongLong(LLDB_INVALID_ADDRESS);
     if (pointer_vm_addr != LLDB_INVALID_ADDRESS) {
       SectionLoadList &section_load_list = GetSectionLoadList();
       if (section_load_list.IsEmpty()) {
         // No sections are loaded, so we must assume we are not running yet and
         // anything we are given is a file address.
         m_images.ResolveFileAddress(pointer_vm_addr, pointer_addr);
       } else {

lldb/source/Target/ThreadPlanStepRange.cpp

if (m_address_ranges[i].ContainsLoadAddress(addr, &GetTarget())) {
       // Some joker added a zero size range to the stepping range...
       if (m_address_ranges[i].GetByteSize() == 0)
         return nullptr;
 
       if (!m_instruction_ranges[i]) {
         // Disassemble the address range given:
         const char *plugin_name = nullptr;
         const char *flavor = nullptr;
-        const bool prefer_file_cache = true;
         m_instruction_ranges[i] = Disassembler::DisassembleRange(
             GetTarget().GetArchitecture(), plugin_name, flavor, GetTarget(),
-            m_address_ranges[i], prefer_file_cache);
+            m_address_ranges[i]);
       }
       if (!m_instruction_ranges[i])
         return nullptr;
       else {
         // Find where we are in the instruction list as well.  If we aren't at
         // an instruction, return nullptr. In this case, we're probably lost,
         // and shouldn't try to do anything fancy.
 

lldb/source/Target/Trace.cpp

DumpInstructionInfo(Stream &s, const SymbolContext &sc,
                     ExecutionContext &exe_ctx, const Address &address) {
   // We first try to use the previous disassembler
   if (TryDumpInstructionInfo(s, prev_disassembler, exe_ctx, address))
     return prev_disassembler;
 
   // Now we try using the current function's disassembler
   if (sc.function) {
     DisassemblerSP disassembler =
-        sc.function->GetInstructions(exe_ctx, nullptr, true);
+        sc.function->GetInstructions(exe_ctx, nullptr);
     if (TryDumpInstructionInfo(s, disassembler, exe_ctx, address))
       return disassembler;
   }
 
   // We fallback to disassembly one instruction
   Target &target = exe_ctx.GetTargetRef();
   const ArchSpec &arch = target.GetArchitecture();
   AddressRange range(address, arch.GetMaximumOpcodeByteSize() * 1);
-  DisassemblerSP disassembler = Disassembler::DisassembleRange(
-      arch, /*plugin_name*/ nullptr,
-      /*flavor*/ nullptr, target, range, /*prefer_file_cache*/ true);
+  DisassemblerSP disassembler =
+      Disassembler::DisassembleRange(arch, /*plugin_name*/ nullptr,
+                                     /*flavor*/ nullptr, target, range);
   if (TryDumpInstructionInfo(s, disassembler, exe_ctx, address))
     return disassembler;
   return nullptr;
 }
 
 void Trace::DumpTraceInstructions(Thread &thread, Stream &s, size_t count,
                                   size_t end_position, bool raw) {
   if (!IsTraced(thread)) {