This is the mail archive of the
mailing list for the GDB project.
Re: [PATCH] Delegate to target_ops->beneath to read cache lines
- From: Pedro Alves <palves at redhat dot com>
- To: Yao Qi <yao at codesourcery dot com>
- Cc: gdb-patches at sourceware dot org
- Date: Wed, 27 Nov 2013 13:49:43 +0000
- Subject: Re: [PATCH] Delegate to target_ops->beneath to read cache lines
- Authentication-results: sourceware.org; auth=none
- References: <1385554824-7159-1-git-send-email-yao at codesourcery dot com>
On 11/27/2013 12:20 PM, Yao Qi wrote:
> GDB on x86_64-linux is unable to disassemble on core-file target.
> $ ./gdb ./testsuite/gdb.base/corefile
> (gdb) core-file ./testsuite/gdb.base/corefile.core
> (gdb) disassemble main
> Dump of assembler code for function main:
> 0x0000000000400976 <+0>: Cannot access memory at address 0x400976
> However, it works if we turn code-cache off.
> (gdb) set code-cache off
> (gdb) disassemble main,+4
> Dump of assembler code from 0x400976 to 0x40097a:
> 0x0000000000400976 <main+0>: push %rbp
> 0x0000000000400977 <main+1>: mov %rsp,%rbp
> End of assembler dump.
> When code-cache is off, GDB will iterate target_ops from top and call
> to_xfer_partial. When current_target is "core", it will call
> to_xfer_partial of target "exec", which reads the contents for
> disassemble. However, dcache doesn't have such mechanism, and that is
> the cause for the error.
This points out that we end up caching core and exec code, which
isn't really necessary. We could limit it to has_all_memory targets,
I think. Not sure if that'd complicate things.
> This patch adds something similar in dcache_read_line to go through
> target_ops from top to bottom, and call to_xfer_partial.
> The original code uses TARGET_OBJECT_RAW_MEMORY, which is replaced
> by TARGET_OBJECT_MEMORY in target_xfer_partial,
> enum target_object raw_object = object;
> /* If this is a raw memory transfer, request the normal
> memory object from other layers. */
> if (raw_object == TARGET_OBJECT_RAW_MEMORY)
> raw_object = TARGET_OBJECT_MEMORY;
> so we can use TARGET_OBJECT_MEMORY here. Regression tested on
The dcache is the sole user of TARGET_OBJECT_RAW_MEMORY. This shows
that if we want to code from lower targets too, then this sole user also
wants to do the top to bottom delegation that memory_xfer_partial_1 does.
So this can all be done within target.c. Factor out the
memory_xfer_partial_1 top to bottom memory read code to a separate
raw_memory_xfer_partial function (despite the name, it'd request
TARGET_OBJECT_MEMORY from the targets), and make target_xfer_partial
call that for TARGET_OBJECT_RAW_MEMORY:
target_xfer_partial (struct target_ops *ops,
enum target_object object, const char *annex,
void *readbuf, const void *writebuf,
ULONGEST offset, LONGEST len)
/* If this is a memory transfer, let the memory-specific code
have a look at it instead. Memory transfers are more
if (object == TARGET_OBJECT_MEMORY || object == TARGET_OBJECT_STACK_MEMORY
|| object == TARGET_OBJECT_CODE_MEMORY)
retval = memory_xfer_partial (ops, object, readbuf,
writebuf, offset, len);
else if (object == TARGET_OBJECT_RAW_MEMORY)
/* Request the normal memory object from other layers. */
retval = raw_memory_xfer_partial (ops, readbuf, writebuf, offset, len);
retval = ops->to_xfer_partial (ops, raw_object, annex, readbuf,
writebuf, offset, len);
Then dcache.c doesn't need to change, and doesn't need to inline that
top to bottom dance.