[PATCH v3 24/24] Add memory tagging testcases

[Simon Marchi]

On 2020-11-09 12:04 p.m., Luis Machado via Gdb-patches wrote:
> +# Targets that don't support memory tagging should not execute the
> +# runtime memory tagging tests.
> +if {![supports_memtag]} {
> +    untested "memory tagging unsupported"

Use unsupported?

https://www.gnu.org/software/dejagnu/manual/unsupported-procedure.html

> +    return -1
> +}
> +
> +gdb_breakpoint "access_memory"
> +
> +if [gdb_continue "access_memory"] {
> +    fail "could not run to tagged memory test function"

gdb_continue will already produce a FAIL, so no need to use another one here.

> +    return -1
> +}
> +
> +# Fetch a known pointer to an area mapped with PROT_MTE.
> +set tagged_ptr_symbol "tagged_ptr"
> +set tagged_ptr_addr [get_hexadecimal_valueof $tagged_ptr_symbol -1]
> +
> +if {$tagged_ptr_addr == -1} {
> +    untested "unexpected pointer or tag value"

If that happens, that would be an expected error in the test that should be
fixed, right?  If so, I'd suggest using "unresolved".  We should be able to
get that value, if we can't something is wrong (it's not just a matter of
something being unsupported).

> +    return -1
> +}
> +
> +# Fetch a known pointer to an area not mapped with PROT_MTE.
> +set untagged_ptr_symbol "untagged_ptr"
> +set untagged_ptr_addr [get_hexadecimal_valueof $untagged_ptr_symbol -1]
> +
> +if {$untagged_ptr_addr == -1} {
> +    untested "unexpected pointer or tag value"

Same here.

> +with_test_prefix "symbolic" {
> +    # Test inspecting an allocation tag from a pointer to a memory area that
> +    # is not mapped with PROT_MTE.
> +    set msg "Address ${untagged_ptr_addr} not in a region mapped with a memory tagging flag\."
> +    gdb_test "mtag showatag ${untagged_ptr_symbol}" $msg \
> +	     "mtag showatag with an untagged address"
> +
> +    gdb_test "mtag setatag ${untagged_ptr_symbol} 0 00" $msg \
> +	     "mtag setatag with an untagged address"
> +
> +    # Test setting and showing the logical tags for a literal address.
> +    for {set i 0} {$i < 32} {incr i} {
> +	set addr_tagged 0
> +
> +	with_test_prefix "tag ${i}" {
> +	    set addr_tagged [get_tagged_ptr $i ${tagged_ptr_addr}]
> +	    gdb_test_no_output "set variable ${tagged_ptr_symbol} = ${addr_tagged}" \
> +			       "update value of symbol ${tagged_ptr_symbol}"
> +	}
> +
> +	set tag_hexnz [get_hex_tag [expr $i % 16]]
> +	gdb_test "mtag showltag ${tagged_ptr_symbol}" \
> +		 " = 0x${tag_hexnz}" \
> +		 "showltag with tag ${i}"
> +
> +	set tag_hexnn [get_tag_nn $i]
> +	gdb_test "mtag withltag ${tagged_ptr_symbol} ${tag_hexnn}" \
> +		 " = \\(void \\*\\) ${addr_tagged}" \
> +		 "withltag with tag ${i}"
> +    }
> +
> +    # Reset the tagged ptr to its original value
> +    gdb_test_no_output "set variable ${tagged_ptr_symbol} = ${tagged_ptr_addr}" \
> +		       "reset ${tagged_ptr_symbol} to ${tagged_ptr_addr}"
> +
> +    set setatag_msg "Allocation tag\\(s\\) updated successfully\."
> +    # Test setting and showing the allocation tags.
> +    for {set i 0} {$i < 32} {incr i} {
> +
> +	set tag_hexnn [get_tag_nn $i]
> +	gdb_test "mtag setatag ${tagged_ptr_symbol} 0 ${tag_hexnn}" \
> +		 $setatag_msg \
> +		 "setatag with tag ${i}"
> +
> +	set tag_hexnz [get_hex_tag [expr $i % 16]]
> +	gdb_test "mtag showatag ${tagged_ptr_symbol}" " = 0x${tag_hexnz}" \
> +		 "showatag with tag ${i}"
> +    }
> +
> +    # Test tag mismatches.
> +    with_test_prefix "tag mismatches" {
> +	for {set i 0} {$i < 32} {incr i} {
> +
> +	    # Set the allocation tag to a known value (0).
> +	    set tag_hexnn [get_tag_nn $i]
> +	    gdb_test "mtag setatag ${tagged_ptr_symbol} 0 ${tag_hexnn}" \
> +		     $setatag_msg \
> +		     "setatag with tag ${i}"
> +
> +	    set atag_hexnz [get_hex_tag [expr $i % 16]]
> +
> +	    # Validate that the logical tag matches the allocation tag.
> +	    with_test_prefix "tag ${i}" {
> +		set addr_tagged [get_tagged_ptr $i ${tagged_ptr_addr}]
> +	    }
> +
> +	    with_test_prefix "tag ${i}" {
> +		gdb_test_no_output "set variable ${tagged_ptr_symbol} = ${addr_tagged}" \
> +				   "set ${tagged_ptr_symbol} to a matching logical tag"
> +	    }
> +
> +	    gdb_test "mtag check ${tagged_ptr_symbol}" \
> +		     "Memory tags for address $hex match \\(0x${atag_hexnz}\\)\." \
> +		     "check match with tag ${i}"
> +
> +	    # Get a pointer with the logical tag that does not match the
> +	    # allocation tag.
> +	    set ltag [expr $i + 1]
> +	    with_test_prefix "fetch mismatch tag ${i}" {
> +		set addr_tagged [get_tagged_ptr $ltag ${tagged_ptr_addr}]
> +	    }
> +
> +	    with_test_prefix "tag ${i}" {
> +		gdb_test_no_output "set variable ${tagged_ptr_symbol} = ${addr_tagged}" \
> +				   "set ${tagged_ptr_symbol} to a mismatching logical tag"
> +	    }
> +
> +	    # Validate that the logical tag does not match the allocation
> +	    # tag.
> +	    set ltag_hexnz [get_hex_tag [expr [expr $i + 1]% 16]]
> +	    gdb_test "mtag check ${tagged_ptr_symbol}" \
> +		     "Logical tag \\(0x${ltag_hexnz}\\) does not match the allocation tag \\(0x${atag_hexnz}\\) for address $hex\." \
> +		     "check mismatch with tag ${i}"
> +	}
> +    # Reset the tagged ptr to its original value
> +    gdb_test_no_output "set variable ${tagged_ptr_symbol} = ${tagged_ptr_addr}" \
> +		       "reset ${tagged_ptr_symbol} to ${tagged_ptr_addr}"

The indentation is off here.

> diff --git a/gdb/testsuite/lib/gdb.exp b/gdb/testsuite/lib/gdb.exp
> index 55154db6a5..347704ce0a 100644
> --- a/gdb/testsuite/lib/gdb.exp
> +++ b/gdb/testsuite/lib/gdb.exp
> @@ -2679,6 +2679,22 @@ proc supports_get_siginfo_type {} {
>      }
>  }
>  
> +# Return 1 if memory tagging is supported at runtime, otherwise return 0.
> +
> +proc supports_memtag {} {

Should this use gdb_caching_proc?

Simon