[11/11] Update test cases that work with minimal encodings

Message ID 20200408175452.30637-12-tromey@adacore.com
State New
Headers show
Series
  • Variant part support, plus more
Related show

Commit Message

Tom Tromey April 8, 2020, 5:54 p.m.
Some test cases already work fine with minimal encodings (in some
cases perhaps due to the variant parts series) This patch updates
these tests as appropriate.

gdb/testsuite/ChangeLog
2020-04-08  Tom Tromey  <tromey@adacore.com>

	* gdb.ada/frame_arg_lang.exp: Run with multiple -fgnat-encodings
	values.
	* gdb.ada/funcall_ref.exp: Run with multiple -fgnat-encodings
	values.  Update test for minimal encodings.
	* gdb.ada/lang_switch.exp: Update test for minimal encodings.
	* gdb.ada/var_rec_arr.exp: Run with multiple -fgnat-encodings
	values.  Update test for minimal encodings.
---
 gdb/testsuite/ChangeLog                  | 10 +++
 gdb/testsuite/gdb.ada/frame_arg_lang.exp | 93 +++++++++++++---------
 gdb/testsuite/gdb.ada/funcall_ref.exp    | 98 +++++++++++++++---------
 gdb/testsuite/gdb.ada/lang_switch.exp    |  5 +-
 gdb/testsuite/gdb.ada/packed_tagged.exp  | 46 ++++++++++-
 gdb/testsuite/gdb.ada/var_rec_arr.exp    | 73 +++++++++++-------
 6 files changed, 221 insertions(+), 104 deletions(-)

-- 
2.21.1

Comments

Tom de Vries April 28, 2020, 6:38 a.m. | #1
On 08-04-2020 19:54, Tom Tromey wrote:
> -    gdb_test "ptype x" \

> +    gdb_test_multiple "print x" "" {

> +	-re -wrap $pass_re {

> +	    pass $gdb_test_name

> +	}

> +	-re -wrap $kfail_re {

> +	    if {$scenario == "minimal"} {

> +		setup_kfail "gnat compiler bug" *-*-*

> +	    }

> +	    fail $gdb_test_name

> +	}

> +    }


The wording "gnat compiler bug" suggest that this is an xfail (a problem
in the environment), not a kfail (a problem in the tool, in other words,
gdb).

Thanks,
- Tom
Tom Tromey April 28, 2020, 3:35 p.m. | #2
>>>>> "Tom" == Tom de Vries <tdevries@suse.de> writes:


Tom> On 08-04-2020 19:54, Tom Tromey wrote:
>> -    gdb_test "ptype x" \

>> +    gdb_test_multiple "print x" "" {

>> +	-re -wrap $pass_re {

>> +	    pass $gdb_test_name

>> +	}

>> +	-re -wrap $kfail_re {

>> +	    if {$scenario == "minimal"} {

>> +		setup_kfail "gnat compiler bug" *-*-*

>> +	    }

>> +	    fail $gdb_test_name

>> +	}

>> +    }


Tom> The wording "gnat compiler bug" suggest that this is an xfail (a problem
Tom> in the environment), not a kfail (a problem in the tool, in other words,
Tom> gdb).

I can change it.  I never really get the point of this xfail/kfail difference.

Tom
Tom de Vries April 30, 2020, 6:45 a.m. | #3
On 28-04-2020 17:35, Tom Tromey wrote:
>>>>>> "Tom" == Tom de Vries <tdevries@suse.de> writes:

> 

> Tom> On 08-04-2020 19:54, Tom Tromey wrote:

>>> -    gdb_test "ptype x" \

>>> +    gdb_test_multiple "print x" "" {

>>> +	-re -wrap $pass_re {

>>> +	    pass $gdb_test_name

>>> +	}

>>> +	-re -wrap $kfail_re {

>>> +	    if {$scenario == "minimal"} {

>>> +		setup_kfail "gnat compiler bug" *-*-*

>>> +	    }

>>> +	    fail $gdb_test_name

>>> +	}

>>> +    }

> 

> Tom> The wording "gnat compiler bug" suggest that this is an xfail (a problem

> Tom> in the environment), not a kfail (a problem in the tool, in other words,

> Tom> gdb).

> 

> I can change it.  I never really get the point of this xfail/kfail difference.

> 


Well, AFAIU, typically a gdb developer will try to drive down FAILs and
KFAILs in the gdb testsuite, but cannot do anything about XFAILs.

IMO the naming does not help.  I've sent out an RFC to add aliases
gdbfail/envfail (
https://sourceware.org/pipermail/gdb-patches/2020-April/168102.html ).

Thanks,
- Tom

Patch

diff --git a/gdb/testsuite/gdb.ada/frame_arg_lang.exp b/gdb/testsuite/gdb.ada/frame_arg_lang.exp
index 92baf7dfa10..dc08d261334 100644
--- a/gdb/testsuite/gdb.ada/frame_arg_lang.exp
+++ b/gdb/testsuite/gdb.ada/frame_arg_lang.exp
@@ -21,53 +21,70 @@  set csrcfile ${srcdir}/${subdir}/${testdir}/${cfile}.c
 set cobject [standard_output_file ${cfile}.o]
 
 gdb_compile "${csrcfile}" "${cobject}" object [list debug]
-if {[gdb_compile_ada "${srcfile}" "${binfile}" executable [list debug additional_flags=-largs additional_flags=${cobject} additional_flags=-margs]] != "" } {
-  return -1
-}
 
-clean_restart ${testfile}
+# Note we don't test the "none" (no -fgnat-encodings option) scenario
+# here, because "all" and "minimal" cover the cases, and this way we
+# don't have to update the test when gnat changes its default.
+foreach_with_prefix scenario {all minimal} {
+    set flags [list debug additional_flags=-largs \
+		   additional_flags=${cobject} \
+		   additional_flags=-margs \
+		   additional_flags=-fgnat-encodings=$scenario]
+
+    if {[gdb_compile_ada "${srcfile}" "${binfile}" executable $flags] != ""} {
+	return -1
+    }
 
-set bp_location [gdb_get_line_number "STOP" ${testdir}/foo.c]
-runto "foo.c:$bp_location"
+    clean_restart ${testfile}
 
-gdb_test_no_output "set print frame-arguments all"
+    set bp_location [gdb_get_line_number "STOP" ${testdir}/foo.c]
+    runto "foo.c:$bp_location"
 
-# Here is the scenario:
-#  - Once stopped in a C function, with language_mode set to auto, print
-#    backtrace, we should see the Ada frame arguments printed using Ada
-#    syntax.
-#  - Set language to C, then check that printing backtrace shows the Ada
-#    frame arguments using C syntax.
-#  - Set language back to auto, check language mode value, then print
-#    backtrace, we should see Ada frame arguments printed using Ada C
-#    syntax.
+    gdb_test_no_output "set print frame-arguments all"
 
-gdb_test "show lang" \
-         "The current source language is \"auto; currently c\"." \
-         "show language when set to 'auto; c'"
+    # Here is the scenario:
+    #  - Once stopped in a C function, with language_mode set to auto, print
+    #    backtrace, we should see the Ada frame arguments printed using Ada
+    #    syntax.
+    #  - Set language to C, then check that printing backtrace shows the Ada
+    #    frame arguments using C syntax.
+    #  - Set language back to auto, check language mode value, then print
+    #    backtrace, we should see Ada frame arguments printed using Ada C
+    #    syntax.
 
-gdb_test "bt" \
-         "#1  $hex in pck\\.call_me \\(s=\"test\"\\).*" \
-         "backtrace with auto: c"
+    gdb_test "show lang" \
+	"The current source language is \"auto; currently c\"." \
+	"show language when set to 'auto; c'"
 
-gdb_test_no_output "set language c" \
-                   "Set current source language to \"manual; currently c\"."
+    gdb_test "bt" \
+	"#1  $hex in pck\\.call_me \\(s=\"test\"\\).*" \
+	"backtrace with auto: c"
 
-gdb_test "show lang" \
-         "The current source language is \"c\"." \
-         "show language when set to 'c'"
+    gdb_test_no_output "set language c" \
+	"Set current source language to \"manual; currently c\"."
 
-gdb_test "bt" \
-         "#1  $hex in pck\\.call_me \\(s={P_ARRAY = $hex, P_BOUNDS = $hex}\\).*" \
-         "backtrace with language forced to 'c'"
+    gdb_test "show lang" \
+	"The current source language is \"c\"." \
+	"show language when set to 'c'"
 
-gdb_test_no_output "set language auto" \
-                   "Set current source language to \"auto; currently c\"."
+    # With -fgnat-encodings=minimal, this works properly in C as well.
+    if {$scenario == "minimal"} {
+	set expected "\"test\""
+    } else {
+	set expected "{P_ARRAY = $hex, P_BOUNDS = $hex}"
+    }
+    gdb_test "bt" \
+	"#1  $hex in pck\\.call_me \\(s=$expected\\).*" \
+	"backtrace with language forced to 'c'"
 
-gdb_test "show lang" \
-         "The current source language is \"auto; currently c\"." \
-         "show language when set back to 'auto; c'"
+    gdb_test_no_output "set language auto" \
+	"Set current source language to \"auto; currently c\"."
 
-gdb_test "bt" \
-         "#1  $hex in pck\\.call_me \\(s=\"test\"\\).*" \
-         "backtrace with language back to 'auto; c'"
+    gdb_test "show lang" \
+	"The current source language is \"auto; currently c\"." \
+	"show language when set back to 'auto; c'"
+
+    gdb_test "bt" \
+	"#1  $hex in pck\\.call_me \\(s=\"test\"\\).*" \
+	"backtrace with language back to 'auto; c'"
+}
diff --git a/gdb/testsuite/gdb.ada/funcall_ref.exp b/gdb/testsuite/gdb.ada/funcall_ref.exp
index 02664f6ad32..e260e908643 100644
--- a/gdb/testsuite/gdb.ada/funcall_ref.exp
+++ b/gdb/testsuite/gdb.ada/funcall_ref.exp
@@ -17,43 +17,71 @@  load_lib "ada.exp"
 
 standard_ada_testfile foo
 
-if {[gdb_compile_ada "${srcfile}" "${binfile}" executable \
-                     [list debug]] != "" } {
-  return -1
-}
+# Note we don't test the "none" (no -fgnat-encodings option) scenario
+# here, because "all" and "minimal" cover the cases, and this way we
+# don't have to update the test when gnat changes its default.
+foreach_with_prefix scenario {all minimal} {
+    set flags [list debug additional_flags=-fgnat-encodings=$scenario]
 
-clean_restart ${testfile}
-
-set bp_location [gdb_get_line_number "STOP" ${testdir}/foo.adb]
-runto "foo.adb:$bp_location"
-
-# Test printing and type-printing of a discriminated record that a function
-# returns by reference.
-
-# Currently, GCC describes such functions as returning pointers (instead of
-# references).
-set pass_re [multi_line "type = <ref> record" \
-		 "    n: natural;" \
-		 "    s: access array \\(1 \\.\\. n\\) of character;" \
-		 "end record"]
-set unsupported_re [multi_line "type = access record" \
-		 "    n: natural;" \
-		 "    s: access array \\(1 \\.\\. n\\) of character;" \
-		 "end record"]
-set supported 1
-gdb_test_multiple "ptype get (\"Hello world!\")" "" {
-    -re -wrap $pass_re {
-	pass $gdb_test_name
+    if {[gdb_compile_ada "${srcfile}" "${binfile}" executable $flags] != ""} {
+	return -1
     }
-    -re -wrap $unsupported_re {
-	unsupported $gdb_test_name
-	set supported 0
+
+    clean_restart ${testfile}
+
+    set bp_location [gdb_get_line_number "STOP" ${testdir}/foo.adb]
+    runto "foo.adb:$bp_location"
+
+    # Test printing and type-printing of a discriminated record that a function
+    # returns by reference.
+
+    # Currently, GCC describes such functions as returning pointers (instead of
+    # references).
+    set pass_re [multi_line "type = <ref> record" \
+		     "    n: natural;" \
+		     "    s: access array \\(1 \\.\\. n\\) of character;" \
+		     "end record"]
+    # With DWARF we get debuginfo that could in theory show "1..n" for
+    # the range:
+    #     <3><1230>: Abbrev Number: 15 (DW_TAG_member)
+    #     <1231>   DW_AT_name        : n
+    # ...
+    #  <4><1257>: Abbrev Number: 18 (DW_TAG_subrange_type)
+    #     <1258>   DW_AT_type        : <0x126e>
+    #     <125c>   DW_AT_upper_bound : <0x1230>
+    # However, we don't currently record the needed information in the
+    # location batons.  In the meantime, we accept and kfail the
+    # compromise output.
+    set dwarf_kfail_re [multi_line "type = <ref> record" \
+			    "    n: natural;" \
+			    "    s: array \\(<>\\) of character;" \
+			    "end record"]
+    set unsupported_re [multi_line "type = access record" \
+			    "    n: natural;" \
+			    "    s: access array \\(1 \\.\\. n\\) of character;" \
+			    "end record"]
+    set supported 1
+    gdb_test_multiple "ptype get (\"Hello world!\")" "" {
+	-re -wrap $pass_re {
+	    pass $gdb_test_name
+	}
+	-re -wrap $dwarf_kfail_re {
+	    if {$scenario == "minimal"} {
+		setup_kfail "symbolic names in location batons" *-*-*
+	    }
+	    fail $gdb_test_name
+	    set supported 0
+	}
+	-re -wrap $unsupported_re {
+	    unsupported $gdb_test_name
+	    set supported 0
+	}
     }
-}
 
-if { $supported == 0 } {
-    return 0
-}
+    if { $supported == 0 } {
+	return 0
+    }
 
-gdb_test "p get (\"Hello world!\")" \
-    "= \\(n => 12, s => \"Hello world!\"\\)"
+    gdb_test "p get (\"Hello world!\")" \
+	"= \\(n => 12, s => \"Hello world!\"\\)"
+}
diff --git a/gdb/testsuite/gdb.ada/lang_switch.exp b/gdb/testsuite/gdb.ada/lang_switch.exp
index 006cae05913..7d9bd617504 100644
--- a/gdb/testsuite/gdb.ada/lang_switch.exp
+++ b/gdb/testsuite/gdb.ada/lang_switch.exp
@@ -41,6 +41,9 @@  gdb_test "bt" \
 # Now, make sure that the language doesn't get automatically switched
 # if the current language is not "auto".
 gdb_test "set lang c"
+# This gives different output with -fgnat-encodings=minimal and
+# -fgnat-encodings=all, but since we don't care so much about the
+# precise details here, we just accept anything.
 gdb_test "bt" \
-         ".*#1.*lang_switch\\.ada_procedure\\s*\\(msg=(@$hex: +)?{.*\\).*" \
+         ".*#1.*lang_switch\\.ada_procedure\\s*\\(msg=(@$hex: +)?.*\\).*" \
          "backtrace with lang set to C"
diff --git a/gdb/testsuite/gdb.ada/packed_tagged.exp b/gdb/testsuite/gdb.ada/packed_tagged.exp
index 72ae29c08d4..d6ee8454c5a 100644
--- a/gdb/testsuite/gdb.ada/packed_tagged.exp
+++ b/gdb/testsuite/gdb.ada/packed_tagged.exp
@@ -17,7 +17,10 @@  load_lib "ada.exp"
 
 standard_ada_testfile comp_bug
 
-foreach_with_prefix scenario {none all minimal} {
+# Note we don't test the "none" (no -fgnat-encodings option) scenario
+# here, because "all" and "minimal" cover the cases, and this way we
+# don't have to update the test when gnat changes its default.
+foreach_with_prefix scenario {all minimal} {
     set flags {debug}
     if {$scenario != "none"} {
 	lappend flags additional_flags=-fgnat-encodings=$scenario
@@ -32,10 +35,25 @@  foreach_with_prefix scenario {none all minimal} {
     set bp_location [gdb_get_line_number "STOP" ${testdir}/comp_bug.adb]
     runto "comp_bug.adb:$bp_location"
 
-    gdb_test "print x" \
+    set pass_re \
 	"= \\(exists => true, value => 10\\)"
+    # There is a compiler bug that causes this output.
+    set kfail_re \
+	"= \\(exists => true\\)"
 
-    gdb_test "ptype x" \
+    gdb_test_multiple "print x" "" {
+	-re -wrap $pass_re {
+	    pass $gdb_test_name
+	}
+	-re -wrap $kfail_re {
+	    if {$scenario == "minimal"} {
+		setup_kfail "gnat compiler bug" *-*-*
+	    }
+	    fail $gdb_test_name
+	}
+    }
+
+    set pass_re \
 	[multi_line "type = record" \
 	     "    exists: (boolean|range false \\.\\. true);" \
 	     "    case exists is" \
@@ -44,4 +62,26 @@  foreach_with_prefix scenario {none all minimal} {
 	     "        when others => null;" \
 	     "    end case;" \
 	     "end record" ]
+    # There is a compiler bug that causes this output.
+    set kfail_re \
+	[multi_line "type = record" \
+	     "    exists: (boolean|range false \\.\\. true);" \
+	     "    case \\? is" \
+	     "        when others =>" \
+	     "            value: range 0 \\.\\. 255;" \
+	     "        when others => null;" \
+	     "    end case;" \
+	     "end record" ]
+
+    gdb_test_multiple "ptype x" "" {
+	-re -wrap $pass_re {
+	    pass $gdb_test_name
+	}
+	-re -wrap $kfail_re {
+	    if {$scenario == "minimal"} {
+		setup_kfail "gnat compiler bug" *-*-*
+	    }
+	    fail $gdb_test_name
+	}
+    }
 }
diff --git a/gdb/testsuite/gdb.ada/var_rec_arr.exp b/gdb/testsuite/gdb.ada/var_rec_arr.exp
index 146ad5e8dc0..80ec32616a9 100644
--- a/gdb/testsuite/gdb.ada/var_rec_arr.exp
+++ b/gdb/testsuite/gdb.ada/var_rec_arr.exp
@@ -17,41 +17,60 @@  load_lib "ada.exp"
 
 standard_ada_testfile foo_na09_042
 
-if {[gdb_compile_ada "${srcfile}" "${binfile}" executable [list debug]] != "" } {
-  return -1
-}
+# Note we don't test the "none" (no -fgnat-encodings option) scenario
+# here, because "all" and "minimal" cover the cases, and this way we
+# don't have to update the test when gnat changes its default.
+foreach_with_prefix scenario {all minimal} {
+    set flags [list debug additional_flags=-fgnat-encodings=$scenario]
+
+    if {[gdb_compile_ada "${srcfile}" "${binfile}" executable $flags] != ""} {
+	return -1
+    }
 
-clean_restart ${testfile}
+    clean_restart ${testfile}
 
-set bp_location [gdb_get_line_number "STOP" ${testdir}/foo_na09_042.adb]
-runto "foo_na09_042.adb:$bp_location"
+    set bp_location [gdb_get_line_number "STOP" ${testdir}/foo_na09_042.adb]
+    runto "foo_na09_042.adb:$bp_location"
 
-gdb_test "print a1" \
-         " = \\(\\(i => 0, s => \"\"\\), \\(i => 1, s => \"A\"\\), \\(i => 2, s => \"AB\"\\)\\)"
+    gdb_test "print a1" \
+	" = \\(\\(i => 0, s => \"\"\\), \\(i => 1, s => \"A\"\\), \\(i => 2, s => \"AB\"\\)\\)"
 
-gdb_test "print a1(1)" \
-         " = \\(i => 0, s => \"\"\\)"
+    gdb_test "print a1(1)" \
+	" = \\(i => 0, s => \"\"\\)"
 
-gdb_test "print a1(2)" \
-         " = \\(i => 1, s => \"A\"\\)"
+    gdb_test "print a1(2)" \
+	" = \\(i => 1, s => \"A\"\\)"
 
-gdb_test "print a1(3)" \
-         " = \\(i => 2, s => \"AB\"\\)"
+    gdb_test "print a1(3)" \
+	" = \\(i => 2, s => \"AB\"\\)"
 
-gdb_test "print a2" \
-         " = \\(\\(i => 2, s => \"AB\"\\), \\(i => 1, s => \"A\"\\), \\(i => 0, s => \"\"\\)\\)"
+    gdb_test "print a2" \
+	" = \\(\\(i => 2, s => \"AB\"\\), \\(i => 1, s => \"A\"\\), \\(i => 0, s => \"\"\\)\\)"
 
-gdb_test "print a2(1)" \
-         " = \\(i => 2, s => \"AB\"\\)"
+    gdb_test "print a2(1)" \
+	" = \\(i => 2, s => \"AB\"\\)"
 
-gdb_test "print a2(2)" \
-         " = \\(i => 1, s => \"A\"\\)"
+    gdb_test "print a2(2)" \
+	" = \\(i => 1, s => \"A\"\\)"
 
-gdb_test "print a2(3)" \
-         " = \\(i => 0, s => \"\"\\)"
+    gdb_test "print a2(3)" \
+	" = \\(i => 0, s => \"\"\\)"
 
-gdb_test "ptype a1(1)" \
-         [multi_line "type = record" \
-                     "    i: pck\\.small_type;" \
-                     "    s: access array \\((<>|1 \\.\\. i)\\) of character;" \
-                     "end record"]
+    # Note that the "access" is only printed when the gnat encodings
+    # are used.  This is due to how the encodings work -- the type
+    # doesn't actually have the "access", and so here the DWARF
+    # encoding is more correct.
+    if {$scenario == "all"} {
+	set ex [multi_line "type = record" \
+		    "    i: pck\\.small_type;" \
+		    "    s: access array \\((<>|1 \\.\\. i)\\) of character;" \
+		    "end record"]
+    } else {
+	set ex [multi_line "type = record" \
+		    "    i: pck\\.small_type;" \
+		    "    s: array \\((<>|1 \\.\\. i)\\) of character;" \
+		    "end record"]
+    }
+
+    gdb_test "ptype a1(1)" $ex
+}