FreeChainXenon/binutils-gdb
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Make gdb.base/parse_number.exp test all architectures

Browse source 
There are some subtle differences between architectures, like the size
of a "long" type, and this isn't currently accounted for in
gdb.base/parse_number.exp.

For example, on aarch64 a long type is 8 bytes, whereas a long type is
4 bytes for x86_64.  This causes the following FAIL's:

 FAIL: gdb.base/parse_number.exp: lang=asm: ptype 0xffffffffffffffff
 FAIL: gdb.base/parse_number.exp: lang=auto: ptype 0xffffffffffffffff
 FAIL: gdb.base/parse_number.exp: lang=c: ptype 0xffffffffffffffff
 FAIL: gdb.base/parse_number.exp: lang=c++: ptype 0xffffffffffffffff
 FAIL: gdb.base/parse_number.exp: lang=fortran: p/x 0xffffffffffffffff
 FAIL: gdb.base/parse_number.exp: lang=fortran: ptype 0xffffffffffffffff
 FAIL: gdb.base/parse_number.exp: lang=go: ptype 0xffffffffffffffff
 FAIL: gdb.base/parse_number.exp: lang=local: ptype 0xffffffffffffffff
 FAIL: gdb.base/parse_number.exp: lang=minimal: ptype 0xffffffffffffffff
 FAIL: gdb.base/parse_number.exp: lang=objective-c: ptype 0xffffffffffffffff
 FAIL: gdb.base/parse_number.exp: lang=opencl: ptype 0xffffffffffffffff
 FAIL: gdb.base/parse_number.exp: lang=pascal: ptype 0xffffffffffffffff

There are some fortran-specific divergences as well, where 32-bit
architectures show "unsigned int" for both 32-bit and 64-bit integers
and 64-bit architectures show "unsigned int" and "unsigned long" for
32-bit and 64-bit integers.

There might be a bug that 32-bit fortran truncates 64-bit values to
32-bit, given "p/x 0xffffffffffffffff" returns "0xffffffff".

Here's what we get for aarch64:

 (gdb) ptype 0xffffffff
 type = unsigned int
 (gdb) ptype 0xffffffffffffffff
 type = unsigned long
 (gdb) p sizeof (0xffffffff)
 $1 = 4
 (gdb) p sizeof (0xffffffffffffffff)
 quit
 $2 = 8
 (gdb) ptype 0xffffffff
 type = unsigned int
 (gdb) ptype 0xffffffffffffffff
 type = unsigned long

And for arm:

 (gdb) ptype 0xffffffff
 type = unsigned int
 (gdb) ptype 0xffffffffffffffff
 quit
 type = unsigned long long
 (gdb) p sizeof (0xffffffff)
 quit
 $1 = 4
 (gdb) p sizeof (0xffffffffffffffff)
 quit
 $2 = 8
 (gdb) ptype 0xffffffff
 type = unsigned int
 (gdb) ptype 0xffffffffffffffff
 type = unsigned long

This patch...

* Makes the testcase iterate over all architectures, thus covering all
  the different combinations of types/sizes every time.

* Adjusts the expected values and types based on the sizes of long
  long, long and int.

A particularly curious architecture is s12z, which has 32-bit long
long, and thus no way to represent 64-bit integers in C-like
languages.

Co-Authored-By: Luis Machado <luis.machado@arm.com>
Change-Id: Ifc0ccd33e7fd3c7585112ff6bebe7d266136768b
This commit is contained in:
Pedro Alves 2022-04-27 11:08:03 +01:00
parent 801eb70f9a
commit 5b758627a1
1 changed files with 63 additions and 11 deletions
Download patch file Download diff file Expand all files Collapse all files

74
gdb/testsuite/gdb.base/parse_number.exp
View file

@ -17,37 +17,89 @@
# around parsing large 64-bit numbers, hitting undefined behavior, and
# thus crashing a GDB built with UBSan. This testcase goes over all
# languages exercising printing the max 64-bit number, making sure
# that GDB doesn't crash.
# that GDB doesn't crash. ARCH is the architecture to test with.
proc test_parse_numbers {} {
clean_restart
proc test_parse_numbers {arch} {
set arch_re [string_to_regexp $arch]
gdb_test "set architecture $arch" "The target architecture is set to \"$arch_re\"."
set all_languages [get_set_option_choices "set language"]
foreach_with_prefix lang $all_languages {
gdb_test_no_output "set language c"
# Types have different sizes depending on the architecture.
# Figure out type sizes before matching patterns in the upcoming
# tests.
set sizeof_long_long [get_sizeof "long long" -1]
set sizeof_long [get_sizeof "long" -1]
set sizeof_int [get_sizeof "int" -1]
if {$sizeof_long_long == 8 && $sizeof_long == 8} {
set 8B_type "unsigned long"
set fortran_type "unsigned long"
set fortran_value "0xffffffffffffffff"
} elseif {$sizeof_long_long == 8 && $sizeof_long == 4 && $sizeof_int == 4} {
set 8B_type "unsigned long long"
set fortran_type "unsigned int"
set fortran_value "0xffffffff"
} elseif {$sizeof_long == 4 && $sizeof_int == 2} {
set 8B_type "unsigned long long"
set fortran_type "unsigned long"
set fortran_value "0xffffffff"
} else {
error "missing case for long long = $sizeof_long_long, long = $sizeof_long, int = $sizeof_int"
}
foreach_with_prefix lang $::all_languages {
gdb_test_no_output "set language $lang"
set val "0xffffffffffffffff"
if {$lang == "fortran"} {
gdb_test "p/x $val" " = 0xffffffff"
gdb_test "ptype $val" " = unsigned int"
gdb_test "p/x $val" " = $fortran_value"
gdb_test "ptype $val" " = $fortran_type"
} elseif {$lang == "modula-2"} {
gdb_test "p/x 0FFFFFFFFFFFFFFFFH" "Overflow on numeric constant\\."
} elseif {$lang == "unknown"} {
gdb_test "p/x $val" \
"expression parsing not implemented for language \"Unknown\""
} else {
gdb_test "p/x $val" " = $val"
# D and Rust define their own built-in 64-bit types, and
# are thus always able to parse/print 64-bit values.
if {$sizeof_long_long == 4 && $lang != "d" && $lang != "rust"} {
set out "0xffffffff"
} else {
set out $val
}
gdb_test "p/x $val" " = $out"
if {$lang == "ada"} {
gdb_test "ptype $val" " = <8-byte integer>"
if {$sizeof_long_long == 4} {
gdb_test "ptype $val" " = <4-byte integer>"
} else {
gdb_test "ptype $val" " = <8-byte integer>"
}
} elseif {$lang == "d"} {
gdb_test "ptype $val" " = ulong"
} elseif {$lang == "rust"} {
gdb_test "ptype $val" " = i64"
} else {
gdb_test "ptype $val" " = unsigned long long"
gdb_test "ptype $val" " = $8B_type"
}
}
}
}
test_parse_numbers
clean_restart
gdb_test_no_output "set max-completions unlimited"
set supported_archs [get_set_option_choices "set architecture"]
# There should be at least one more than "auto".
gdb_assert {[llength $supported_archs] > 1} "at least one architecture"
set all_languages [get_set_option_choices "set language"]
foreach_with_prefix arch $supported_archs {
if {$arch == "auto"} {
continue
}
test_parse_numbers $arch
}