Target::ReadMemory read from read-only binary file Section, not memory
Commiting this patch for Augusto Noronha who is getting set
up still.
This patch changes Target::ReadMemory so the default behavior
when a read is in a Section that is read-only is to fetch the
data from the local binary image, instead of reading it from
memory. Update all callers to use their old preferences
(the old prefer_file_cache bool) using the new API; we should
revisit these calls and see if they really intend to read
live memory, or if reading from a read-only Section would be
equivalent and important for performance-sensitive cases.
rdar://30634422
Differential revision: https://reviews.llvm.org/D100338
GitOrigin-RevId: e9fe788d326090cb6155c0dec90b44c932273dd3
diff --git a/include/lldb/Core/Disassembler.h b/include/lldb/Core/Disassembler.h
index 9a694de..0a76f0a 100644
--- a/include/lldb/Core/Disassembler.h
+++ b/include/lldb/Core/Disassembler.h
@@ -394,10 +394,12 @@
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,
@@ -426,7 +428,8 @@
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,
diff --git a/include/lldb/Symbol/Function.h b/include/lldb/Symbol/Function.h
index 300d829..aae5b4a 100644
--- a/include/lldb/Symbol/Function.h
+++ b/include/lldb/Symbol/Function.h
@@ -631,10 +631,10 @@
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 {
diff --git a/include/lldb/Target/Target.h b/include/lldb/Target/Target.h
index 0c2131a..2192133 100644
--- a/include/lldb/Target/Target.h
+++ b/include/lldb/Target/Target.h
@@ -1005,11 +1005,12 @@
// 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,
@@ -1018,18 +1019,19 @@
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();
diff --git a/source/API/SBFunction.cpp b/source/API/SBFunction.cpp
index 9f3cf81..7d81716 100644
--- a/source/API/SBFunction.cpp
+++ b/source/API/SBFunction.cpp
@@ -132,10 +132,10 @@
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);
diff --git a/source/API/SBSymbol.cpp b/source/API/SBSymbol.cpp
index eafc3e6..7b9c900 100644
--- a/source/API/SBSymbol.cpp
+++ b/source/API/SBSymbol.cpp
@@ -132,10 +132,10 @@
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));
}
}
}
diff --git a/source/API/SBTarget.cpp b/source/API/SBTarget.cpp
index ad1ef69..b0b12dc 100644
--- a/source/API/SBTarget.cpp
+++ b/source/API/SBTarget.cpp
@@ -705,7 +705,7 @@
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");
}
@@ -2085,12 +2085,12 @@
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,
diff --git a/source/Commands/CommandObjectMemory.cpp b/source/Commands/CommandObjectMemory.cpp
index a2201c4..19c13c0 100644
--- a/source/Commands/CommandObjectMemory.cpp
+++ b/source/Commands/CommandObjectMemory.cpp
@@ -669,8 +669,8 @@
}
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]) {
diff --git a/source/Core/Address.cpp b/source/Core/Address.cpp
index 9d52f1d..24bb841 100644
--- a/source/Core/Address.cpp
+++ b/source/Core/Address.cpp
@@ -65,9 +65,9 @@
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;
}
diff --git a/source/Core/Disassembler.cpp b/source/Core/Disassembler.cpp
index 3a975d9..60c41e1 100644
--- a/source/Core/Disassembler.cpp
+++ b/source/Core/Disassembler.cpp
@@ -122,7 +122,7 @@
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 {};
@@ -137,7 +137,7 @@
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 {};
@@ -181,9 +181,9 @@
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;
@@ -1036,7 +1036,7 @@
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())
@@ -1052,8 +1052,8 @@
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) {
diff --git a/source/Core/IOHandlerCursesGUI.cpp b/source/Core/IOHandlerCursesGUI.cpp
index a1c9daa..1de83d8 100644
--- a/source/Core/IOHandlerCursesGUI.cpp
+++ b/source/Core/IOHandlerCursesGUI.cpp
@@ -3550,7 +3550,7 @@
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();
diff --git a/source/Core/Value.cpp b/source/Core/Value.cpp
index 7b52ff9..b5af03c 100644
--- a/source/Core/Value.cpp
+++ b/source/Core/Value.cpp
@@ -525,15 +525,10 @@
} 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);
}
diff --git a/source/Core/ValueObject.cpp b/source/Core/ValueObject.cpp
index 1988155..55fc5ff 100644
--- a/source/Core/ValueObject.cpp
+++ b/source/Core/ValueObject.cpp
@@ -721,7 +721,7 @@
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;
diff --git a/source/Expression/IRMemoryMap.cpp b/source/Expression/IRMemoryMap.cpp
index 6b1e4c3..4ae2724 100644
--- a/source/Expression/IRMemoryMap.cpp
+++ b/source/Expression/IRMemoryMap.cpp
@@ -639,7 +639,7 @@
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;
}
diff --git a/source/Plugins/Architecture/Mips/ArchitectureMips.cpp b/source/Plugins/Architecture/Mips/ArchitectureMips.cpp
index 2250896..757c915 100644
--- a/source/Plugins/Architecture/Mips/ArchitectureMips.cpp
+++ b/source/Plugins/Architecture/Mips/ArchitectureMips.cpp
@@ -160,7 +160,6 @@
InstructionList instruction_list;
InstructionSP prev_insn;
- bool prefer_file_cache = true; // Read from file
uint32_t inst_to_choose = 0;
Address addr = resolved_addr;
@@ -171,8 +170,7 @@
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) {
diff --git a/source/Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.cpp b/source/Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.cpp
index fd1916d..575a882 100644
--- a/source/Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.cpp
+++ b/source/Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.cpp
@@ -1093,16 +1093,16 @@
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);
@@ -1373,10 +1373,9 @@
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,
diff --git a/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderDarwin.cpp b/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderDarwin.cpp
index ddf6f12..ac43112 100644
--- a/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderDarwin.cpp
+++ b/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderDarwin.cpp
@@ -1086,7 +1086,7 @@
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);
diff --git a/source/Plugins/DynamicLoader/Windows-DYLD/DynamicLoaderWindowsDYLD.cpp b/source/Plugins/DynamicLoader/Windows-DYLD/DynamicLoaderWindowsDYLD.cpp
index 7f9504b..f0a01ed 100644
--- a/source/Plugins/DynamicLoader/Windows-DYLD/DynamicLoaderWindowsDYLD.cpp
+++ b/source/Plugins/DynamicLoader/Windows-DYLD/DynamicLoaderWindowsDYLD.cpp
@@ -193,7 +193,7 @@
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();
}
diff --git a/source/Plugins/Instruction/MIPS/EmulateInstructionMIPS.cpp b/source/Plugins/Instruction/MIPS/EmulateInstructionMIPS.cpp
index d4cb726..c0ec431 100644
--- a/source/Plugins/Instruction/MIPS/EmulateInstructionMIPS.cpp
+++ b/source/Plugins/Instruction/MIPS/EmulateInstructionMIPS.cpp
@@ -1018,8 +1018,9 @@
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;
diff --git a/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp b/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp
index ae432ac..f30ed42 100644
--- a/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp
+++ b/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp
@@ -859,8 +859,7 @@
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) {
@@ -868,7 +867,7 @@
// 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 =
diff --git a/source/Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.cpp b/source/Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.cpp
index 1bc071c..65947c5 100644
--- a/source/Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.cpp
+++ b/source/Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.cpp
@@ -38,10 +38,10 @@
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;
}
}
diff --git a/source/Plugins/UnwindAssembly/x86/UnwindAssembly-x86.cpp b/source/Plugins/UnwindAssembly/x86/UnwindAssembly-x86.cpp
index fe1275d..402a70c 100644
--- a/source/Plugins/UnwindAssembly/x86/UnwindAssembly-x86.cpp
+++ b/source/Plugins/UnwindAssembly/x86/UnwindAssembly-x86.cpp
@@ -51,12 +51,11 @@
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(
@@ -153,12 +152,11 @@
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(
@@ -185,10 +183,9 @@
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};
@@ -220,12 +217,10 @@
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)) {
diff --git a/source/Symbol/Function.cpp b/source/Symbol/Function.cpp
index 67013f6..0aeb759 100644
--- a/source/Symbol/Function.cpp
+++ b/source/Symbol/Function.cpp
@@ -426,17 +426,16 @@
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) {
diff --git a/source/Symbol/Symbol.cpp b/source/Symbol/Symbol.cpp
index 8d099e0..e6695c5 100644
--- a/source/Symbol/Symbol.cpp
+++ b/source/Symbol/Symbol.cpp
@@ -542,10 +542,9 @@
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();
}
diff --git a/source/Target/Process.cpp b/source/Target/Process.cpp
index 9f39e78..5af8567 100644
--- a/source/Target/Process.cpp
+++ b/source/Target/Process.cpp
@@ -5810,10 +5810,8 @@
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();
diff --git a/source/Target/StackFrame.cpp b/source/Target/StackFrame.cpp
index 5402ba2..cba51d2 100644
--- a/source/Target/StackFrame.cpp
+++ b/source/Target/StackFrame.cpp
@@ -1294,11 +1294,11 @@
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();
@@ -1674,10 +1674,10 @@
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();
diff --git a/source/Target/Target.cpp b/source/Target/Target.cpp
index 3aa1d30..177efa8 100644
--- a/source/Target/Target.cpp
+++ b/source/Target/Target.cpp
@@ -1717,8 +1717,8 @@
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();
@@ -1753,10 +1753,20 @@
if (!resolved_addr.IsValid())
resolved_addr = addr;
- if (prefer_file_cache) {
- bytes_read = ReadMemoryFromFileCache(resolved_addr, dst, dst_len, error);
- if (bytes_read > 0)
- return bytes_read;
+ 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()) {
@@ -1791,17 +1801,10 @@
*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);
@@ -1856,7 +1859,7 @@
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;
@@ -1884,15 +1887,15 @@
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());
@@ -1914,23 +1917,22 @@
}
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 §ion_load_list = GetSectionLoadList();
diff --git a/source/Target/ThreadPlanStepRange.cpp b/source/Target/ThreadPlanStepRange.cpp
index 3c42cd7..896e647 100644
--- a/source/Target/ThreadPlanStepRange.cpp
+++ b/source/Target/ThreadPlanStepRange.cpp
@@ -264,10 +264,9 @@
// 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;
diff --git a/source/Target/Trace.cpp b/source/Target/Trace.cpp
index c2de3da..7f58dbc 100644
--- a/source/Target/Trace.cpp
+++ b/source/Target/Trace.cpp
@@ -200,7 +200,7 @@
// 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;
}
@@ -209,9 +209,9 @@
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;
