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

[Andrew Burgess <aburgess at sourceware dot org>]

https://sourceware.org/git/gitweb.cgi?p=binutils-gdb.git;h=c8ad9b9a31aa3e6039567fc1f152dd454c946d5f

commit c8ad9b9a31aa3e6039567fc1f152dd454c946d5f
Author: Andrew Burgess <andrew.burgess@embecosm.com>
Date:   Fri Feb 2 15:51:31 2018 +0000

    gdb/testsuite: Allow for failure to read some memory addresses
    
    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 updates the test script so that even if address zero is
    known non-readable, we still run the tests, the tests in question are
    mostly about, can GDB calculate the correct address to read from, we
    can confirm this even if the final read ultimately fails.  We also no
    longer assume that if address zero is readable, then the other end of
    the address space will be readable.
    
    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: Still run tests around address
    	0x0, even if address 0x0 is not readable.  Update the pattern for
    	matching address 0x0 in expected output.

Diff:
---
 gdb/testsuite/ChangeLog                     |  6 +++
 gdb/testsuite/gdb.base/examine-backward.exp | 68 ++++++++++++++++++++++++-----
 2 files changed, 62 insertions(+), 12 deletions(-)

diff --git a/gdb/testsuite/ChangeLog b/gdb/testsuite/ChangeLog
index d908b85..1ba373d 100644
--- a/gdb/testsuite/ChangeLog
+++ b/gdb/testsuite/ChangeLog
@@ -1,3 +1,9 @@
+2018-07-09  Andrew Burgess  <andrew.burgess@embecosm.com>
+
+	* gdb.base/examine-backward.exp: Still run tests around address
+	0x0, even if address 0x0 is not readable.  Update the pattern for
+	matching address 0x0 in expected output.
+
 2018-07-06  Andrew Burgess  <andrew.burgess@embecosm.com>
 
 	* gdb.base/share-env-with-gdbserver.c (main): Add call to
diff --git a/gdb/testsuite/gdb.base/examine-backward.exp b/gdb/testsuite/gdb.base/examine-backward.exp
index be80b84..60e8e25 100644
--- a/gdb/testsuite/gdb.base/examine-backward.exp
+++ b/gdb/testsuite/gdb.base/examine-backward.exp
@@ -83,18 +83,62 @@ with_test_prefix "memory page boundary" {
 }
 
 with_test_prefix "address zero boundary" {
-    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}" \
-            "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}"
+    global gdb_prompt
+
+    set address_zero "0x0"
+    set byte "\t0x\[0-9a-f\]+"
+
+    set test "examine 3 bytes forward from ${address_zero}"
+    gdb_test_multiple "x/3xb ${address_zero}" "$test" {
+	-re "0x\[0-9a-f\]*0.*:${byte}${byte}${byte}\[\r\n\]*$gdb_prompt $" {
+	    pass $test
+	}
+	-re "0x\[0-9a-f\]*0.*:\tCannot access memory at address 0x\[0-9a-f\]*0\[\r\n\]*$gdb_prompt $" {
+	    # If we failed to read address 0 then this is fine, so
+	    # long as we're not expecting to be able to read from
+	    # address 0.
+	    if {![is_address_zero_readable]} {
+		# The next test assumes that the last address examined
+		# would be 0x2.  As we just failed to read address 0x0
+		# things are going to go wrong unless we now tell GDB
+		# to examine address 0x2.  We assume here that if we
+		# can't read 0x0 we can't read 0x2 either.
+		gdb_test "x/3xb 0x2" "Cannot access memory at address 0x\[0-9a-f\]*2" \
+		    "set last examined address to 0x2"
+		pass $test
+	    } else {
+		fail $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 may, or may not have managed to read from address 0x0
+	    # in the previous test, however, being able to read 0x0 is
+	    # 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, and this test
+	    # is (mostly) about does GDB calculate the correct address
+	    # when wrapping around.
+	    pass $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
+	}
     }
 }