This is the mail archive of the
gdb-patches@sources.redhat.com
mailing list for the GDB project.
Re: [RFC] XFAIL bigcore.exp on some GNU/Linux targets
- From: Daniel Jacobowitz <drow at false dot org>
- To: gdb-patches at sources dot redhat dot com
- Date: Mon, 10 May 2004 12:49:08 -0400
- Subject: Re: [RFC] XFAIL bigcore.exp on some GNU/Linux targets
- References: <20040417214254.GA14000@nevyn.them.org> <40855D55.7000708@gnu.org> <20040421145951.GB4980@nevyn.them.org>
On Wed, Apr 21, 2004 at 10:59:51AM -0400, Daniel Jacobowitz wrote:
> On Tue, Apr 20, 2004 at 01:26:45PM -0400, Andrew Cagney wrote:
> > Why not ask the program the heap size? it's in total_allocated, just
> > make that a static.
>
> Duh. I'll update the patch to do that before I check it in.
Done like so; checked in. This replaces one PASS and two FAILs on an
unpatched i386-linux target with a single XFAIL.
--
Daniel Jacobowitz
2004-05-10 Daniel Jacobowitz <dan@debian.org>
PR external/1568
* gdb.base/bigcore.exp: Check the size of the dumped core file.
XFAIL if it is smaller than bytes_allocated.
* gdb.base/bigcore.c (bytes_allocated): Make static and unsigned.
(main): Make chunks_allocated unsigned. Correct comment.
Index: bigcore.exp
===================================================================
RCS file: /cvs/src/src/gdb/testsuite/gdb.base/bigcore.exp,v
retrieving revision 1.5
diff -u -p -r1.5 bigcore.exp
--- bigcore.exp 9 Apr 2004 13:37:38 -0000 1.5
+++ bigcore.exp 10 May 2004 16:27:24 -0000
@@ -105,9 +105,30 @@ gdb_test "tbreak $print_core_line"
gdb_test continue ".*print_string.*"
gdb_test next ".*0 = 0.*"
+# Check that the corefile is plausibly large enough. We're trying to
+# detect the case where the operating system has truncated the file
+# just before signed wraparound. TCL, unfortunately, has a similar
+# problem - so use catch. It can handle the "bad" size but not necessarily
+# the "good" one. And we must use GDB for the comparison, similarly.
+
+if {[catch {file size $corefile} core_size] == 0} {
+ set core_ok 0
+ gdb_test_multiple "print bytes_allocated < $core_size" "check core size" {
+ -re " = 1\r\n$gdb_prompt $" {
+ pass "check core size"
+ set core_ok 1
+ }
+ -re " = 0\r\n$gdb_prompt $" {
+ xfail "check core size (system does not support large corefiles)"
+ }
+ }
+ if {$core_ok == 0} {
+ return 0
+ }
+}
+
# Traverse part of bigcore's linked list of memory chunks (forward or
-# backward), saving each chunk's address. I don't know why but
-# expect_out didn't work with gdb_test_multiple.
+# backward), saving each chunk's address.
proc extract_heap { dir } {
global gdb_prompt
@@ -115,8 +136,7 @@ proc extract_heap { dir } {
set heap ""
set test "extract ${dir} heap"
set lim 0
- send_gdb "print heap.${dir}\n"
- gdb_expect {
+ gdb_test_multiple "print heap.${dir}" "$test" {
-re " = \\(struct list \\*\\) 0x0.*$gdb_prompt $" {
pass "$test"
}
Index: bigcore.c
===================================================================
RCS file: /cvs/src/src/gdb/testsuite/gdb.base/bigcore.c,v
retrieving revision 1.2
diff -u -p -r1.2 bigcore.c
--- bigcore.c 16 Feb 2004 18:49:09 -0000 1.2
+++ bigcore.c 10 May 2004 16:27:24 -0000
@@ -117,6 +117,8 @@ struct list
static struct list dummy;
static struct list heap = { &dummy, &dummy };
+static unsigned long bytes_allocated;
+
int
main ()
{
@@ -151,14 +153,13 @@ main ()
each section. The linking ensures that some, but not all, the
memory is allocated. NB: Some kernels handle this efficiently -
only allocating and writing out referenced pages leaving holes in
- the file for unreferend pages - while others handle this poorly -
- writing out all pages including those that wern't referenced. */
+ the file for unmodified pages - while others handle this poorly -
+ writing out all pages including those that weren't modified. */
print_string ("Alocating the entire heap ...\n");
{
size_t chunk_size;
- long bytes_allocated = 0;
- long chunks_allocated = 0;
+ unsigned long chunks_allocated = 0;
/* Create a linked list of memory chunks. Start with
MAX_CHUNK_SIZE blocks of memory and then try allocating smaller
and smaller amounts until all (well at least most) memory has