This is the mail archive of the gdb-patches@sourceware.org mailing list for the GDB project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

[RFA] Sort overload menu (decode_line_2)


Hi,

While working on my linespec rewrite, I've noticed the (implicit) assumption that decode_line_2 outputs the overload menu in code order. While this assumption has worked for quite some time, this causes problems for the linespec rewrite, which could alter this implicit ordering.

This patch alphabetically sorts the output of decode_line_2, which I happen to think is easier for the user to read, too.

I've updated the two affected tests, method2.exp and olvdbreak.exp, to compute the correct menu, enforcing an explicit order on it.

In addition, I have taken the opportunity to update these tests to use prepare_for_testing and eliminate some other Tcl insanity. I apologize for smashing two unrelated things into one patch, but the changes are rather trivial. I was there, it bothered me. I fixed it.

Keith

ChangeLog
2012-02-28  Keith Seitz  <keiths@redhat.com>

	* linespec.c (decode_line_2): Sort the list of methods
	alphabetically before presenting the user with a selection
	menu.

testsuite/ChangeLog
2012-02-28  Keith Seitz  <keiths@redhat.com>

	* gdb.cp/method2.exp: Output of overload menu is now
	alphabetized.  Update tests for "break A::method".
	Use prepare_for_testing.
	* gdb.cp/ovldbreak.exp: Use prepare_for_testing.
	Update syntax of arcane "if" statement.
	Use gdb_get_line_number instead of hard-coding them.
	Overload menu is alphabetized: rewrite to accommodate.
	Unset variables LINE and TYPES which are used in other tests.
	Similarly, compute the output of "info break".
	Update the breakpoint table after all breakpoints are deleted.
	(continue_to_bp_overloaded): Rename ACTUALS to ARGUMENT and
	compute ACTUALS and the method body based on parameters.
	Update expected output accordingly.
	* gdb.cp/ovldbreak.exp (foo::overload1arg): Reformat and add
	unique comments to allow the use of gdb_get_line_number.
diff --git a/gdb/linespec.c b/gdb/linespec.c
index 94e8ef6..c2057cf 100644
--- a/gdb/linespec.c
+++ b/gdb/linespec.c
@@ -650,6 +650,11 @@ decode_line_2 (struct linespec_state *self,
       return;
     }
 
+  /* Sort the list of method names alphabetically.  */
+  qsort (VEC_address (const_char_ptr, item_names),
+	 VEC_length (const_char_ptr, item_names),
+	 sizeof (const_char_ptr), compare_strings);
+
   printf_unfiltered (_("[0] cancel\n[1] all\n"));
   for (i = 0; VEC_iterate (const_char_ptr, item_names, i, iter); ++i)
     printf_unfiltered ("[%d] %s\n", i + 2, iter);
diff --git a/gdb/testsuite/gdb.cp/method2.exp b/gdb/testsuite/gdb.cp/method2.exp
index f44381f..42c5452 100644
--- a/gdb/testsuite/gdb.cp/method2.exp
+++ b/gdb/testsuite/gdb.cp/method2.exp
@@ -21,24 +21,15 @@
 if { [skip_cplus_tests] } { continue }
 
 set testfile "method2"
-set srcfile ${testfile}.cc
-set binfile ${objdir}/${subdir}/${testfile}
+set srcfile $testfile.cc
+set binfile $objdir/$subdir/$testfile
 
-if  { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug c++}] != "" } {
+if  {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
      untested method2.exp
      return -1
 }
 
-if [get_compiler_info $binfile "c++"] {
-  return -1
-}
-
-gdb_exit
-gdb_start
-gdb_reinitialize_dir $srcdir/$subdir
-gdb_load ${binfile}
-
-if ![runto_main] then {
+if {![runto_main]} {
     perror "couldn't run to breakpoint"
     continue
 }
@@ -50,8 +41,21 @@ proc test_break { lang } {
 	"" \
 	"setting language $lang"
 
+    # Menu items should be alphabetical
+    set ovlds [lsort {"" "int" "A*"}]
+    set items {"cancel" "all"}
+    foreach ovld $ovlds {
+      lappend items "A::method($ovld)"
+    }
+    set menu_items {}
+    set idx 0
+    foreach item $items {
+      lappend menu_items ".$idx. .*[string_to_regexp $item]"
+      incr idx
+    }
+    set expect [join $menu_items {.*[\r\n]*}]
     gdb_test_multiple "break A::method" "breaking in method ($lang)" {
-	-re ".0. cancel.*\[\r\n\]*.1. all.*\[\r\n\]*.2. .*:A::method\\(A\\*\\)\[\r\n\]*.3. .*:A::method\\(int\\)\[\r\n\]*.4. .*:A::method\\(\\)\[\r\n\]*> $" {
+      -re $expect {
 	    gdb_test "0" \
 		"canceled" \
 		"breaking in method ($lang)"
diff --git a/gdb/testsuite/gdb.cp/ovldbreak.cc b/gdb/testsuite/gdb.cp/ovldbreak.cc
index 832b0fa..c3cc069 100644
--- a/gdb/testsuite/gdb.cp/ovldbreak.cc
+++ b/gdb/testsuite/gdb.cp/ovldbreak.cc
@@ -103,18 +103,41 @@ foo::~foo ()                       {}
 
 /* Some functions to test overloading by varying one argument type. */
 
-int foo::overload1arg (void)                {  return 1; }
-int foo::overload1arg (char arg)            { arg = 0; return 2;}
-int foo::overload1arg (signed char arg)     { arg = 0; return 3;}
-int foo::overload1arg (unsigned char arg)   { arg = 0; return 4;}
-int foo::overload1arg (short arg)           { arg = 0; return 5;}
-int foo::overload1arg (unsigned short arg)  { arg = 0; return 6;}
-int foo::overload1arg (int arg)             { arg = 0; return 7;}
-int foo::overload1arg (unsigned int arg)    { arg = 0; return 8;}
-int foo::overload1arg (long arg)            { arg = 0; return 9;}
-int foo::overload1arg (unsigned long arg)   { arg = 0; return 10;}
-int foo::overload1arg (float arg)           { arg = 0; return 11;}
-int foo::overload1arg (double arg)          { arg = 0; return 12;}
+int foo::overload1arg (void)
+{ return 1; } /* fo1 void */
+
+int foo::overload1arg (char arg)
+{ arg = 0; return 2; } /* fo1 char */
+
+int foo::overload1arg (signed char arg)
+{ arg = 0; return 3; } /* fo1 signed_char */
+
+int foo::overload1arg (unsigned char arg)
+{ arg = 0; return 4; } /* fo1 unsigned_char */
+
+int foo::overload1arg (short arg)
+{ arg = 0; return 5; } /* fo1 short_int */
+
+int foo::overload1arg (unsigned short arg)
+{ arg = 0; return 6; } /* fo1 unsigned_short_int */
+
+int foo::overload1arg (int arg)
+{ arg = 0; return 7; } /* fo1 int */
+
+int foo::overload1arg (unsigned int arg)
+{ arg = 0; return 8; } /* fo1 unsigned_int */
+
+int foo::overload1arg (long arg)
+{ arg = 0; return 9; } /* fo1 long_int */
+
+int foo::overload1arg (unsigned long arg)
+{ arg = 0; return 10; } /* fo1 unsigned_long_int */
+
+int foo::overload1arg (float arg)
+{ arg = 0; return 11; } /* fo1 float */
+
+int foo::overload1arg (double arg)
+{ arg = 0; return 12; } /* fo1 double */
 
 
 /* Some functions to test overloading by varying argument count. */
diff --git a/gdb/testsuite/gdb.cp/ovldbreak.exp b/gdb/testsuite/gdb.cp/ovldbreak.exp
index b719224..833dbce 100644
--- a/gdb/testsuite/gdb.cp/ovldbreak.exp
+++ b/gdb/testsuite/gdb.cp/ovldbreak.exp
@@ -32,28 +32,21 @@ set timeout 15
 if { [skip_cplus_tests] } { continue }
 
 set testfile "ovldbreak"
-set srcfile ${testfile}.cc
-set binfile ${objdir}/${subdir}/${testfile}
+set srcfile $testfile.cc
+set binfile $objdir/$subdir/$testfile
 
-if  { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug c++}] != "" } {
-     untested ovldbreak.exp
-     return -1
+if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+    untested ovldbreak.exp
+    return -1
 }
 
-gdb_exit
-gdb_start
-gdb_reinitialize_dir $srcdir/$subdir
-gdb_load ${binfile}
-
 # set it up at a breakpoint so we can play with the variable values
 #
-if ![runto_main] then {
+if {![runto_main]} {
     perror "couldn't run to breakpoint"
     continue
 }
 
-
-
 # When I ask gdb to set a breakpoint on an overloaded function,
 # gdb gives me a choice menu.  I might get stuck in that choice menu
 # (for example, if C++ name mangling is not working properly).
@@ -120,68 +113,114 @@ proc set_bp_overloaded {name expectedmenu mychoice bpnumber linenumber} {
     }
 }
 
-# This is the expected menu for overload1arg.
+# Compute the expected menu for overload1arg.
 # Note the arg type variations for void and integer types.
 # This accommodates different versions of g++.
 
-set    menu_overload1arg "\\\[0\\\] cancel\r\n"
-append menu_overload1arg "\\\[1\\\] all\r\n"
-append menu_overload1arg "\\\[2\\\] .*$srcfile:foo::overload1arg\\(double\\)\r\n"
-append menu_overload1arg "\\\[3\\\] .*$srcfile:foo::overload1arg\\(float\\)\r\n"
-append menu_overload1arg "\\\[4\\\] .*$srcfile:foo::overload1arg\\((unsigned long|long unsigned)( int)?\\)\r\n"
-append menu_overload1arg "\\\[5\\\] .*$srcfile:foo::overload1arg\\(long( int)?\\)\r\n"
-append menu_overload1arg "\\\[6\\\] .*$srcfile:foo::overload1arg\\((unsigned int|unsigned)\\)\r\n"
-append menu_overload1arg "\\\[7\\\] .*$srcfile:foo::overload1arg\\(int\\)\r\n"
-append menu_overload1arg "\\\[8\\\] .*$srcfile:foo::overload1arg\\((unsigned short|short unsigned)( int)?\\)\r\n"
-append menu_overload1arg "\\\[9\\\] .*$srcfile:foo::overload1arg\\(short( int)?\\)\r\n"
-append menu_overload1arg "\\\[10\\\] .*$srcfile:foo::overload1arg\\(unsigned char\\)\r\n"
-append menu_overload1arg "\\\[11\\\] .*$srcfile:foo::overload1arg\\(signed char\\)\r\n"
-append menu_overload1arg "\\\[12\\\] .*$srcfile:foo::overload1arg\\(char\\)\r\n"
-append menu_overload1arg "\\\[13\\\] .*$srcfile:foo::overload1arg\\((void|)\\)\r\n"
-append menu_overload1arg "> $"
+# Probe for the real types.  This will do some unnecessary checking
+# for some simple types (like "int"), but it's just easier to loop
+# over all_types instead of calling out just the exceptions.
+# This list /must/ remain in the same order that the methods are
+# called in the source code.  Otherwise the order in which breakpoints
+# are hit (tested below) will be incorrect.
+set all_types [list void char signed_char unsigned_char short_int \
+		   unsigned_short_int int unsigned_int long_int \
+		   unsigned_long_int float double]
+
+# ARGUMENTS is an array that will map from synthetic type to argument
+# expressions in the source code, which is of the form "arg = $decimal".
+# ARGUMENTS stores this decimal number.
+array set arguments {
+  void ""
+  char 2
+  signed_char 3
+  unsigned_char 4
+  short_int 5
+  unsigned_short_int 6
+  int 7
+  unsigned_int 8
+  long_int 9
+  unsigned_long_int 10
+  float 100(.0)?
+  double 200(.0)?
+}
+
+unset -nocomplain line types
+foreach type $all_types {
+  # TYPES is an array that maps the synthetic names in ALL_TYPES
+  # to the real type used in the debugger.  These will be checked
+  # below and changed if the debugger thinks they are different from
+  # their default values.
+  set types($type) [join [split $type "_"] " "]
+
+  # LINE is an array that will map from synthetic type to line number.
+  # in the source code.
+  set line($type) [gdb_get_line_number "fo1 $type"]
+
+  # Probe for the actual type.
+  send_gdb "print &foo::overload1arg($types($type))\n"
+  gdb_expect {
+    -re ".*\<foo::.*\>.*$gdb_prompt $" {
+      regexp {<.*>} $expect_out(0,string) func
+      regexp {\(.*\)} $func real_type
+
+      # Store the real type into TYPES.
+      set types($type) [string trim $real_type {()}]
+
+      # Create an inverse mapping of the actual type to the synthetic type.
+      set type_map("$types($type)") $type
+      pass "detect $type"
+    }
+    default { fail "detect $type" }
+    timeout { fail "detect $type (timeout)" }
+  }
+}
+
+# This is a list of the actual overloaded method arugments.
+set overloads {}
+foreach type $all_types {
+  lappend overloads $types($type)
+}
+
+# Sort this list alphabetically.
+set overloads [lsort $overloads]
+
+# Create the menu list.
+set items {"cancel" "all"}
+foreach ovld $overloads {
+  lappend items "$srcfile:foo::overload1arg\\($ovld\\)"
+}
+set menu_items {}
+set idx 0
+foreach item $items {
+  lappend menu_items ".$idx. .*$item"
+  incr idx
+}
+set menu_overload1arg [join $menu_items {[\r\n]*}]
+append menu_overload1arg {[\r\n]*> $}
 
 # Set multiple-symbols to "ask", to allow us to test the use
 # of the multiple-choice menu when breaking on an overloaded method.
 gdb_test_no_output "set multiple-symbols ask"
 
 # Set breakpoints on foo::overload1arg, one by one.
-
-set_bp_overloaded "foo::overload1arg" "$menu_overload1arg" 12    2 107
-set_bp_overloaded "foo::overload1arg" "$menu_overload1arg" 11    3 108
-set_bp_overloaded "foo::overload1arg" "$menu_overload1arg" 10    4 109
-set_bp_overloaded "foo::overload1arg" "$menu_overload1arg"  9    5 110
-set_bp_overloaded "foo::overload1arg" "$menu_overload1arg"  8    6 111
-set_bp_overloaded "foo::overload1arg" "$menu_overload1arg"  7    7 112
-set_bp_overloaded "foo::overload1arg" "$menu_overload1arg"  6    8 113
-set_bp_overloaded "foo::overload1arg" "$menu_overload1arg"  5    9 114
-set_bp_overloaded "foo::overload1arg" "$menu_overload1arg"  4   10 115
-set_bp_overloaded "foo::overload1arg" "$menu_overload1arg"  3   11 116
-set_bp_overloaded "foo::overload1arg" "$menu_overload1arg"  2   12 117
-set_bp_overloaded "foo::overload1arg" "$menu_overload1arg" 13   13 106
-
-
+set bpnum 1
+set method "foo::overload1arg"
+for {set idx 0} {$idx < [llength $overloads]} {incr idx} {
+  set type [lindex $overloads $idx]
+  set_bp_overloaded $method $menu_overload1arg \
+      [expr {$idx + 2}] [incr bpnum] $line($type_map("$type"))
+}
 
 # Verify the breakpoints.
-
-gdb_test "info break" \
-    "Num     Type\[\t \]+Disp Enb Address\[\t \]+What.*
-\[0-9\]+\[\t \]+breakpoint     keep y\[\t \]+$hex\[\t \]+in main(\\((|void)\\))? at.*$srcfile:49\r
-\[\t \]+breakpoint already hit 1 time\r
-\[0-9\]+\[\t \]+breakpoint     keep y\[\t \]+$hex\[\t \]+in foo::overload1arg\\(char\\) at.*$srcfile:107\r
-\[0-9\]+\[\t \]+breakpoint     keep y\[\t \]+$hex\[\t \]+in foo::overload1arg\\(signed char\\) at.*$srcfile:108\r
-\[0-9\]+\[\t \]+breakpoint     keep y\[\t \]+$hex\[\t \]+in foo::overload1arg\\(unsigned char\\) at.*$srcfile:109\r
-\[0-9\]+\[\t \]+breakpoint     keep y\[\t \]+$hex\[\t \]+in foo::overload1arg\\(short( int)?\\) at.*$srcfile:110\r
-\[0-9\]+\[\t \]+breakpoint     keep y\[\t \]+$hex\[\t \]+in foo::overload1arg\\((unsigned short|short unsigned)( int)?\\) at.*$srcfile:111\r
-\[0-9\]+\[\t \]+breakpoint     keep y\[\t \]+$hex\[\t \]+in foo::overload1arg\\(int\\) at.*$srcfile:112\r
-\[0-9\]+\[\t \]+breakpoint     keep y\[\t \]+$hex\[\t \]+in foo::overload1arg\\((unsigned|unsigned int)\\) at.*$srcfile:113\r
-\[0-9\]+\[\t \]+breakpoint     keep y\[\t \]+$hex\[\t \]+in foo::overload1arg\\(long( int)?\\) at.*$srcfile:114\r
-\[0-9\]+\[\t \]+breakpoint     keep y\[\t \]+$hex\[\t \]+in foo::overload1arg\\((unsigned long|long unsigned)( int)?\\) at.*$srcfile:115\r
-\[0-9\]+\[\t \]+breakpoint     keep y\[\t \]+$hex\[\t \]+in foo::overload1arg\\(float\\) at.*$srcfile:116\r
-\[0-9\]+\[\t \]+breakpoint     keep y\[\t \]+$hex\[\t \]+in foo::overload1arg\\(double\\) at.*$srcfile:117\r
-\[0-9\]+\[\t \]+breakpoint     keep y\[\t \]+$hex\[\t \]+in foo::overload1arg\\((void|)\\) at.*$srcfile:106" \
-    "breakpoint info (after setting one-by-one)"
-
-
+set bptable "Num     Type\[\t \]+Disp Enb Address\[\t \]+What.*"
+append bptable "\[0-9\]+\[\t \]+breakpoint     keep y\[\t \]+$hex\[\t \]+in main(\\((|void)\\))? at.*$srcfile:49\[\r\n\]+"
+append bptable "\[\t \]+breakpoint already hit 1 time\[\r\n\]+"
+foreach ovld $overloads {
+  append bptable  [format "\[0-9\]+\[\t \]+breakpoint     keep y\[\t \]+$hex\[\t \]+in foo::overload1arg\\(%s\\) at.*$srcfile:%d\[\r\n\]+" $ovld \
+		       $line($type_map("$ovld"))]
+}
+gdb_test "info break" $bptable "breakpoint info (after setting one-by-one)"
 
 # Test choice "cancel".
 # This is copy-and-paste from set_bp_overloaded.
@@ -221,25 +260,7 @@ gdb_expect {
     }
 }
 
-gdb_test "info break" \
-    "Num     Type\[\t \]+Disp Enb Address\[\t \]+What.*
-\[0-9\]+\[\t \]+breakpoint     keep y\[\t \]+$hex\[\t \]+in main(\\((|void)\\))? at.*$srcfile:49\r
-\[\t \]+breakpoint already hit 1 time\r
-\[0-9\]+\[\t \]+breakpoint     keep y\[\t \]+$hex\[\t \]+in foo::overload1arg\\(char\\) at.*$srcfile:107\r
-\[0-9\]+\[\t \]+breakpoint     keep y\[\t \]+$hex\[\t \]+in foo::overload1arg\\(signed char\\) at.*$srcfile:108\r
-\[0-9\]+\[\t \]+breakpoint     keep y\[\t \]+$hex\[\t \]+in foo::overload1arg\\(unsigned char\\) at.*$srcfile:109\r
-\[0-9\]+\[\t \]+breakpoint     keep y\[\t \]+$hex\[\t \]+in foo::overload1arg\\(short( int)?\\) at.*$srcfile:110\r
-\[0-9\]+\[\t \]+breakpoint     keep y\[\t \]+$hex\[\t \]+in foo::overload1arg\\((unsigned short|short unsigned)( int)?\\) at.*$srcfile:111\r
-\[0-9\]+\[\t \]+breakpoint     keep y\[\t \]+$hex\[\t \]+in foo::overload1arg\\(int\\) at.*$srcfile:112\r
-\[0-9\]+\[\t \]+breakpoint     keep y\[\t \]+$hex\[\t \]+in foo::overload1arg\\((unsigned|unsigned int)\\) at.*$srcfile:113\r
-\[0-9\]+\[\t \]+breakpoint     keep y\[\t \]+$hex\[\t \]+in foo::overload1arg\\(long( int)?\\) at.*$srcfile:114\r
-\[0-9\]+\[\t \]+breakpoint     keep y\[\t \]+$hex\[\t \]+in foo::overload1arg\\((unsigned long|long unsigned)( int)?\\) at.*$srcfile:115\r
-\[0-9\]+\[\t \]+breakpoint     keep y\[\t \]+$hex\[\t \]+in foo::overload1arg\\(float\\) at.*$srcfile:116\r
-\[0-9\]+\[\t \]+breakpoint     keep y\[\t \]+$hex\[\t \]+in foo::overload1arg\\(double\\) at.*$srcfile:117\r
-\[0-9\]+\[\t \]+breakpoint     keep y\[\t \]+$hex\[\t \]+in foo::overload1arg\\((void|)\\) at.*$srcfile:106" \
-    "breakpoint info (after cancel)"
-
-
+gdb_test "info break" $bptable "breakpoint info (after cancel)"
 
 # Delete these breakpoints.
 
@@ -303,64 +324,85 @@ gdb_expect {
 gdb_test "info break" \
     "Num     Type\[\t \]+Disp Enb Address\[\t \]+What.*
 \[0-9\]+\[\t \]+breakpoint     keep y\[\t \]+<MULTIPLE>\[\t \]*\r
-\[0-9\]+.1\[\t \]+y\[\t \]+$hex\[\t \]+in foo::overload1arg\\(double\\) at.*$srcfile:117\r
-\[0-9\]+.2\[\t \]+y\[\t \]+$hex\[\t \]+in foo::overload1arg\\(float\\) at.*$srcfile:116\r
-\[0-9\]+.3\[\t \]+y\[\t \]+$hex\[\t \]+in foo::overload1arg\\((unsigned long|long unsigned)( int)?\\) at.*$srcfile:115\r
-\[0-9\]+.4\[\t \]+y\[\t \]+$hex\[\t \]+in foo::overload1arg\\(long( int)?\\) at.*$srcfile:114\r
-\[0-9\]+.5\[\t \]+y\[\t \]+$hex\[\t \]+in foo::overload1arg\\((unsigned|unsigned int)\\) at.*$srcfile:113\r
-\[0-9\]+.6\[\t \]+y\[\t \]+$hex\[\t \]+in foo::overload1arg\\(int\\) at.*$srcfile:112\r
-\[0-9\]+.7\[\t \]+y\[\t \]+$hex\[\t \]+in foo::overload1arg\\((unsigned short|short unsigned)( int)?\\) at.*$srcfile:111\r
-\[0-9\]+.8\[\t \]+y\[\t \]+$hex\[\t \]+in foo::overload1arg\\(short( int)?\\) at.*$srcfile:110\r
-\[0-9\]+.9\[\t \]+y\[\t \]+$hex\[\t \]+in foo::overload1arg\\(unsigned char\\) at.*$srcfile:109\r
-\[0-9\]+.10\[\t \]+y\[\t \]+$hex\[\t \]+in foo::overload1arg\\(signed char\\) at.*$srcfile:108\r
-\[0-9\]+.11\[\t \]+y\[\t \]+$hex\[\t \]+in foo::overload1arg\\(char\\) at.*$srcfile:107\r
-\[0-9\]+.12\[\t \]+y\[\t \]+$hex\[\t \]+in foo::overload1arg\\((void|)\\) at.*$srcfile:106" \
+\[0-9\]+.1\[\t \]+y\[\t \]+$hex\[\t \]+in foo::overload1arg\\(double\\) at.*$srcfile:140\r
+\[0-9\]+.2\[\t \]+y\[\t \]+$hex\[\t \]+in foo::overload1arg\\(float\\) at.*$srcfile:137\r
+\[0-9\]+.3\[\t \]+y\[\t \]+$hex\[\t \]+in foo::overload1arg\\((unsigned long|long unsigned)( int)?\\) at.*$srcfile:134\r
+\[0-9\]+.4\[\t \]+y\[\t \]+$hex\[\t \]+in foo::overload1arg\\(long( int)?\\) at.*$srcfile:131\r
+\[0-9\]+.5\[\t \]+y\[\t \]+$hex\[\t \]+in foo::overload1arg\\((unsigned|unsigned int)\\) at.*$srcfile:128\r
+\[0-9\]+.6\[\t \]+y\[\t \]+$hex\[\t \]+in foo::overload1arg\\(int\\) at.*$srcfile:125\r
+\[0-9\]+.7\[\t \]+y\[\t \]+$hex\[\t \]+in foo::overload1arg\\((unsigned short|short unsigned)( int)?\\) at.*$srcfile:122\r
+\[0-9\]+.8\[\t \]+y\[\t \]+$hex\[\t \]+in foo::overload1arg\\(short( int)?\\) at.*$srcfile:119\r
+\[0-9\]+.9\[\t \]+y\[\t \]+$hex\[\t \]+in foo::overload1arg\\(unsigned char\\) at.*$srcfile:116\r
+\[0-9\]+.10\[\t \]+y\[\t \]+$hex\[\t \]+in foo::overload1arg\\(signed char\\) at.*$srcfile:113\r
+\[0-9\]+.11\[\t \]+y\[\t \]+$hex\[\t \]+in foo::overload1arg\\(char\\) at.*$srcfile:110\r
+\[0-9\]+.12\[\t \]+y\[\t \]+$hex\[\t \]+in foo::overload1arg\\((void|)\\) at.*$srcfile:107" \
     "breakpoint info (after setting on all)"
 
 
-
 # Run through each breakpoint.
+proc continue_to_bp_overloaded {bpnumber might_fail line argtype argument} {
+    global gdb_prompt hex decimal srcfile
+
+    if {$argument == ""} {
+      set actuals ""
+    } else {
+      set actuals "arg=$argument"
+      if {[regexp {char} $argtype]} {
+	append actuals " \\'\\\\00$argument\\'"
+      }
+    }
 
-# NOTE: carlton/2003-02-03: I'm seeing failures on some of the tests,
-# with the wrong arg being printed out.  Michael Chastain sees
-# failures at times, too, albeit fewer than I do.
-
-proc continue_to_bp_overloaded {might_kfail bpnumber argtype actuals} {
-    global gdb_prompt hex decimal srcfile 
+    if {[string match $argtype "void"]} {
+      set body "return $decimal;"
+    } else {
+      set body "arg = 0; return $decimal;"
+    }
 
     send_gdb "continue\n"
     gdb_expect {
-	-re "Continuing.\r\n\r\nBreakpoint ${bpnumber}, foo::overload1arg \\(this=${hex}(, )?${actuals}\\) at.*${srcfile}:${decimal}\r\n${decimal}\[\t \]+int foo::overload1arg \\(${argtype}( arg)?\\).*\r\n.*$gdb_prompt $" {
-	    pass "continue to bp overloaded : ${argtype}"
-	}
-	-re "Continuing.\r\n\r\nBreakpoint ${bpnumber}, foo::overload1arg \\(this=${hex}, arg=.*\\) at.*${srcfile}:${decimal}\r\n${decimal}\[\t \]+int foo::overload1arg \\(${argtype}( arg)?\\).*\r\n.*$gdb_prompt $" {
-	    if $might_kfail {
-		kfail "gdb/1025" "continue to bp overloaded : ${argtype}"
-	    } else {
-		fail "continue to bp overloaded : ${argtype}"
-	    }
-	}
+        -re "Continuing.\r\n\r\nBreakpoint $bpnumber, foo::overload1arg \\(this=${hex}(, )?$actuals\\) at .*$srcfile:$line\r\n$decimal\[\t \]+{ $body }.*$gdb_prompt $" {
+            pass "continue to bp overloaded : $argtype"
+        }
+
+        -re "Continuing.\r\n\r\nBreakpoint $bpnumber, foo::overload1arg \\(this=${hex}, arg=.*\\) at .*$srcfile:$line\r\n$decimal\[\t \]+{ $body }.*$gdb_prompt $" {
+            if $might_kfail {
+                kfail "c++/8130" "continue to bp overloaded : $argtype"
+            } else {
+                fail "continue to bp overloaded : $argtype"
+            }
+        }
+
         -re ".*$gdb_prompt $" {
-	    fail "continue to bp overloaded : ${argtype}" 
-	}
+	    fail "continue to bp overloaded : $argtype"
+        }
+
         timeout {
-	    fail "continue to bp overloaded : ${argtype} (timeout)"
-	}
+	    fail "continue to bp overloaded : $argtype (timeout)"
+        }
     }
 }
 
-continue_to_bp_overloaded 0 14 "(void|)" ""
-continue_to_bp_overloaded 1 14 "char" "arg=2 \\'\\\\002\\'"
-continue_to_bp_overloaded 1 14 "signed char" "arg=3 \\'\\\\003\\'"
-continue_to_bp_overloaded 1 14 "unsigned char" "arg=4 \\'\\\\004\\'"
-continue_to_bp_overloaded 1 14 "short" "arg=5"
-continue_to_bp_overloaded 1 14 "unsigned short" "arg=6"
-continue_to_bp_overloaded 0 14 "int" "arg=7"
-continue_to_bp_overloaded 0 14 "(unsigned|unsigned int)" "arg=8"
-continue_to_bp_overloaded 0 14 "long" "arg=9"
-continue_to_bp_overloaded 0 14 "unsigned long" "arg=10"
-continue_to_bp_overloaded 0 14 "float" "arg=100"
-continue_to_bp_overloaded 1 14 "double" "arg=200"
+# An array which describes which of these methods might be expected
+# to kfail on GCC 2.95. See C++/8210.
+array set might_fail {
+  void 0
+  char 1
+  signed_char 1
+  unsigned_char 1
+  short_int 1
+  unsigned_short_int 1
+  int 0
+  unsigned_int 0
+  long_int 0
+  unsigned_long_int 0
+  float 0
+  double 1
+}
+
+foreach type $all_types {
+  continue_to_bp_overloaded 14 $might_fail($type) $line($type) \
+      $type $arguments($type)
+}
 
 # Test breaking on an overloaded function when multiple-symbols
 # is set to "cancel"
@@ -376,4 +418,5 @@ gdb_test "break foo::foofunc" \
 
 # That's all, folks.
 
+unset -nocomplain line types
 gdb_continue_to_end "finish program"

Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]