[PATCH] gdb/testsuite: Allow for failure to read some memory addresses

[Andrew Burgess <andrew dot burgess at embecosm dot com>]

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, I assume that this test was
originally written for a target that inserts address flags into the most
significant part of the address, and so, the address zero, would appear
like: '0x<FLAGS>00000000' or similar.  On targets without address flags,
reading address zero just prints the address as '0x0'.  I've tweaked the
address pattern so either case should now pass.

gdb/testsuite/ChangeLog:

	* gdb.base/examine-backward.exp: Be more forgiving of failures to
	read some addresses.
---
 gdb/testsuite/ChangeLog                     |  5 ++++
 gdb/testsuite/gdb.base/examine-backward.exp | 42 ++++++++++++++++++++++++-----
 2 files changed, 40 insertions(+), 7 deletions(-)

diff --git a/gdb/testsuite/gdb.base/examine-backward.exp b/gdb/testsuite/gdb.base/examine-backward.exp
index be80b841aa8..548e72cc5cb 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
+	    }
+	}
     }
 }
 
-- 
2.12.2