Patchwork gdb/testsuite: Allow for failure to read some memory addresses

login
register
mail settings
Submitter Andrew Burgess
Date July 4, 2018, 6:13 p.m.
Message ID <20180704181302.5364-1-andrew.burgess@embecosm.com>
Download mbox | patch
Permalink /patch/28239/
State New
Headers show

Comments

Andrew Burgess - July 4, 2018, 6:13 p.m.
In the gdb.base/examine-backward.exp test script, we check to see if
address zero is readable, and then read memory first forward from
address zero, and then backward from address zero.

The problem is, being able to read address zero does not guarantee
that you'll be able to read from the other end of the address space,
and the test probably shouldn't assume that is the case.

This patch extends the success conditions so that, even if GDB fails
to read memory, so long as the error message indicates that GDB was
trying to access the correct location, then we consider this a pass.
The test is, I think, trying to show that GDB can compute the correct
address when going backward from zero, being able to access the memory
at that address is secondary.

One further change is that, when we examined the memory at address
zero, the regexp used to match the address expected that the zero
address would have two '0' digits as the least significant digits.  As
GDB strips leading zeros from addresses this was causing the test to
fail.  I've reduced the zero address to a single 0 digit.

gdb/testsuite/ChangeLog:

	* gdb.base/examine-backward.exp: Be more forgiving of failures to
	read some addresses.  Update zero address pattern.
---
 gdb/testsuite/ChangeLog                     |  5 ++++
 gdb/testsuite/gdb.base/examine-backward.exp | 42 ++++++++++++++++++++++++-----
 2 files changed, 40 insertions(+), 7 deletions(-)
Simon Marchi - July 7, 2018, 2:14 a.m.
On 2018-07-04 02:13 PM, Andrew Burgess wrote:
> In the gdb.base/examine-backward.exp test script, we check to see if
> address zero is readable, and then read memory first forward from
> address zero, and then backward from address zero.
> 
> The problem is, being able to read address zero does not guarantee
> that you'll be able to read from the other end of the address space,
> and the test probably shouldn't assume that is the case.
> 
> This patch extends the success conditions so that, even if GDB fails
> to read memory, so long as the error message indicates that GDB was
> trying to access the correct location, then we consider this a pass.
> The test is, I think, trying to show that GDB can compute the correct
> address when going backward from zero, being able to access the memory
> at that address is secondary.
> 
> One further change is that, when we examined the memory at address
> zero, the regexp used to match the address expected that the zero
> address would have two '0' digits as the least significant digits.  As
> GDB strips leading zeros from addresses this was causing the test to
> fail.  I've reduced the zero address to a single 0 digit.

Hi Andrew,

This probably means that we could run the test even if address 0 is not readable?
On x86_64, I get:

(gdb) x/3b 0
0x0:	Cannot access memory at address 0x0
(gdb) x/-6b
0xfffffffffffffffb:	Cannot access memory at address 0xfffffffffffffffb

It's not the exact same result as if address 0 is readable (since we didn't
get to read all three bytes in the first command), but it still reaches
the goal of the test.

> +	set test "examine 6 bytes backward"
> +	gdb_test_multiple "x/-6x" "$test" {
> +	    -re "0x\[0-9a-f\]+fd.*:${byte}${byte}${byte}${byte}${byte}${byte}.*\[\r\n\]*$gdb_prompt $" {
> +		pass $test
> +	    }
> +	    -re "0x\[0-9a-f\]+fd.*:\tCannot access memory at address 0x\[0-9a-f\]+fd.*\[\r\n\]*$gdb_prompt $" {
> +		# We test that we can read zero, but that's no
> +		# guarantee that we can read from the other end of the
> +		# address space.  If we get an error about trying to
> +		# read from the expected address then we count that as
> +		# a pass, GDB did try to read the correct location.
> +		pass $test
> +	    }
> +	    -re "$gdb_prompt $" {
> +		fail $test
> +	    }

Is the last stanza necessary?  From what I remember, if it doesn't match
any other one, it will already fail the test.

Simon

Patch

diff --git a/gdb/testsuite/gdb.base/examine-backward.exp b/gdb/testsuite/gdb.base/examine-backward.exp
index be80b841aa..a47e3507c3 100644
--- a/gdb/testsuite/gdb.base/examine-backward.exp
+++ b/gdb/testsuite/gdb.base/examine-backward.exp
@@ -83,18 +83,46 @@  with_test_prefix "memory page boundary" {
 }
 
 with_test_prefix "address zero boundary" {
+    global gdb_prompt
+
     if {[is_address_zero_readable]} {
         set address_zero "0x0"
         set byte "\t0x\[0-9a-f\]+"
         gdb_test "x/3xb ${address_zero}" \
-            "0x\[0-9a-f\]+00.*:${byte}${byte}${byte}" \
+            "0x\[0-9a-f\]*0.*:${byte}${byte}${byte}" \
             "examine 3 bytes forward from ${address_zero}"
-        gdb_test "x/-6x" \
-            "0x\[0-9a-f\]+fd.*:${byte}${byte}${byte}${byte}${byte}${byte}" \
-            "examine 6 bytes backward"
-        gdb_test "x/-3x ${address_zero}" \
-            "0x\[0-9a-f\]+fd.*:${byte}${byte}${byte}" \
-            "examine 3 bytes backward from ${address_zero}"
+
+	set test "examine 6 bytes backward"
+	gdb_test_multiple "x/-6x" "$test" {
+	    -re "0x\[0-9a-f\]+fd.*:${byte}${byte}${byte}${byte}${byte}${byte}.*\[\r\n\]*$gdb_prompt $" {
+		pass $test
+	    }
+	    -re "0x\[0-9a-f\]+fd.*:\tCannot access memory at address 0x\[0-9a-f\]+fd.*\[\r\n\]*$gdb_prompt $" {
+		# We test that we can read zero, but that's no
+		# guarantee that we can read from the other end of the
+		# address space.  If we get an error about trying to
+		# read from the expected address then we count that as
+		# a pass, GDB did try to read the correct location.
+		pass $test
+	    }
+	    -re "$gdb_prompt $" {
+		fail $test
+	    }
+	}
+
+	set test "examine 3 bytes backward from ${address_zero}"
+	gdb_test_multiple "x/-3x ${address_zero}" "$test" {
+	    -re "0x\[0-9a-f\]+fd.*:${byte}${byte}${byte}${byte}${byte}${byte}.*\[\r\n\]*$gdb_prompt $" {
+		pass $test
+	    }
+	    -re "0x\[0-9a-f\]+fd.*:\tCannot access memory at address 0x\[0-9a-f\]+fd.*\[\r\n\]*$gdb_prompt $" {
+		# See previous test for why this is a pass.
+		pass $test
+	    }
+	    -re "$gdb_prompt $" {
+		fail $test
+	    }
+	}
     }
 }