aboutsummaryrefslogtreecommitdiff
path: root/gdb
diff options
context:
space:
mode:
Diffstat (limited to 'gdb')
-rw-r--r--gdb/ChangeLog5
-rw-r--r--gdb/testsuite/ChangeLog8
-rw-r--r--gdb/testsuite/gdb.trace/unavailable.cc22
-rw-r--r--gdb/testsuite/gdb.trace/unavailable.exp12
-rw-r--r--gdb/tracepoint.c11
5 files changed, 52 insertions, 6 deletions
diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index d690e50..f7099b4 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,5 +1,10 @@
2011-02-14 Pedro Alves <pedro@codesourcery.com>
+ * tracepoint.c (memrange_sortmerge): Don't merge ranges that are
+ almost but not quite adjacent.
+
+2011-02-14 Pedro Alves <pedro@codesourcery.com>
+
* value.h (value_entirely_available): Declare.
* value.c (value_entirely_available): New function.
* c-valprint.c (c_value_print): Don't try fetching the pointer's
diff --git a/gdb/testsuite/ChangeLog b/gdb/testsuite/ChangeLog
index d2b877b..0fab274 100644
--- a/gdb/testsuite/ChangeLog
+++ b/gdb/testsuite/ChangeLog
@@ -1,5 +1,13 @@
2011-02-14 Pedro Alves <pedro@codesourcery.com>
+ * gdb.trace/unavailable.cc (a, b, c): New globals.
+ (main): Set and clear them.
+ * gdb.trace/unavailable.exp (gdb_collect_globals_test): Collect
+ `a' and `c', and check that `b' isn't collected, although `a' and
+ `c' are.
+
+2011-02-14 Pedro Alves <pedro@codesourcery.com>
+
* gdb.trace/unavailable.cc (struct Virtual): New.
(virtualp): New global pointer.
* gdb.trace/unavailable.exp (gdb_collect_globals_test): Test
diff --git a/gdb/testsuite/gdb.trace/unavailable.cc b/gdb/testsuite/gdb.trace/unavailable.cc
index 718e0f7..7b4a2b2 100644
--- a/gdb/testsuite/gdb.trace/unavailable.cc
+++ b/gdb/testsuite/gdb.trace/unavailable.cc
@@ -71,6 +71,25 @@ struct tuple
struct tuple tarray[8];
+/* Test for overcollection. GDB used to merge memory ranges to
+ collect if they were close enough --- say, collect `a' and 'c'
+ below, and you'd get 'b' as well. This had been presumably done to
+ cater for some target's inefficient trace buffer layout, but it is
+ really not GDB's business to assume how the target manages its
+ buffer. If the target wants to overcollect, that's okay, since it
+ knows what is and what isn't safe to touch (think memory mapped
+ registers), and knows it's buffer layout.
+
+ The test assumes these three variables are laid out consecutively
+ in memory. Unfortunately, we can't use an array instead, since the
+ agent expression generator does not even do constant folding,
+ meaning that anything that's more complicated than collecting a
+ global will generate an agent expression action to evaluate on the
+ target, instead of a simple "collect memory" action. */
+int a;
+int b;
+int c;
+
/* Random tests. */
struct StructA
@@ -185,6 +204,7 @@ main (int argc, char **argv, char **envp)
memcpy (g_string_unavail, g_const_string, sizeof (g_const_string));
memcpy (g_string_partial, g_const_string, sizeof (g_const_string));
g_string_p = g_const_string;
+ a = 1; b = 2; c = 3;
/* Call test functions, so they can be traced and data collected. */
i = 0;
@@ -212,6 +232,8 @@ main (int argc, char **argv, char **envp)
memset (g_string_partial, 0, sizeof (g_string_partial));
g_string_p = NULL;
+ a = b = c = 0;
+
g_int = 0;
g_structref.clear ();
diff --git a/gdb/testsuite/gdb.trace/unavailable.exp b/gdb/testsuite/gdb.trace/unavailable.exp
index aa87cfb..8ec6343 100644
--- a/gdb/testsuite/gdb.trace/unavailable.exp
+++ b/gdb/testsuite/gdb.trace/unavailable.exp
@@ -92,6 +92,9 @@ proc gdb_collect_globals_test { } {
"collect struct_b.struct_a.array\[2\]" "^$" \
"collect struct_b.struct_a.array\[100\]" "^$" \
\
+ "collect a" "^$" \
+ "collect c" "^$" \
+ \
"collect tarray\[0\].a" "^$" \
"collect tarray\[1\].a" "^$" \
"collect tarray\[3\].a" "^$" \
@@ -145,6 +148,15 @@ proc gdb_collect_globals_test { } {
gdb_test "print /x struct_b.struct_a.array\[2\]" " = 0xaaaaaaaa"
+ # Check the target doesn't overcollect. GDB used to merge memory
+ # ranges to collect if they were close enough (collecting the hole
+ # as well), but does not do that anymore. It's plausible that a
+ # target may do this on its end, but as of this writing, no known
+ # target does it.
+ gdb_test "print {a, b, c}" \
+ " = \\{1, <unavailable>, 3\\}" \
+ "No overcollect of almost but not quite adjacent memory ranges"
+
# Check <unavailable> isn't confused with 0 in array element repetitions
gdb_test_no_output "set print repeat 1"
diff --git a/gdb/tracepoint.c b/gdb/tracepoint.c
index 498f47c..3eae937 100644
--- a/gdb/tracepoint.c
+++ b/gdb/tracepoint.c
@@ -841,13 +841,12 @@ memrange_sortmerge (struct collection_list *memranges)
{
for (a = 0, b = 1; b < memranges->next_memrange; b++)
{
- if (memranges->list[a].type == memranges->list[b].type &&
- memranges->list[b].start - memranges->list[a].end <=
- MAX_REGISTER_SIZE)
+ /* If memrange b overlaps or is adjacent to memrange a,
+ merge them. */
+ if (memranges->list[a].type == memranges->list[b].type
+ && memranges->list[b].start <= memranges->list[a].end)
{
- /* memrange b starts before memrange a ends; merge them. */
- if (memranges->list[b].end > memranges->list[a].end)
- memranges->list[a].end = memranges->list[b].end;
+ memranges->list[a].end = memranges->list[b].end;
continue; /* next b, same a */
}
a++; /* next a */