gdb/testuite/

	* 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.

	gdb/
	* tracepoint.c (memrange_sortmerge): Don't merge ranges that are
	almost but not quite adjacent.

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index d690e5090c1f54f1c61287f9a044074dd8e9ee1b..f7099b4387134ee9b41c0f55c59ac4d44ccc10af 100644 (file)
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,8 @@
+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.

diff --git a/gdb/testsuite/ChangeLog b/gdb/testsuite/ChangeLog
index d2b877b6695dfe722a5cbc69c5fcc67230ab3504..0fab27496cc8ba59bfe69fbcc78053305a14d09a 100644 (file)
--- a/gdb/testsuite/ChangeLog
+++ b/gdb/testsuite/ChangeLog
@@ -1,3 +1,11 @@
+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.

diff --git a/gdb/testsuite/gdb.trace/unavailable.cc b/gdb/testsuite/gdb.trace/unavailable.cc
index 718e0f7b3560b8acc3198fbd92f016fc182e6eae..7b4a2b20be349af0e531e8378190980f03f3e738 100644 (file)
--- 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 aa87cfb09a67d3482e9c69c884179a92b880a5eb..8ec6343344c7e0cdd71dc0ea67fd6d12417e8a30 100644 (file)
--- 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 498f47c12d8ff460fa324e4018f5608bab4c2c50..3eae9376bd04c4a1f9d3df54defe3c5a6b19b4ce 100644 (file)
--- 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 */