RFA: test GDB's ability to print prototyped function types

[Jim Blandy <jimb at zwingli dot cygnus dot com>]

These will xfail under current GCC's using STABS, and pass using Dwarf2.

2002-02-09  Jim Blandy  <jimb@redhat.com>

	* gdb.base/ptype.exp, gdb.base/ptype.c: Add tests for printing
	types of pointers to prototyped functions.

Index: gdb/testsuite/gdb.base/ptype.c
===================================================================
RCS file: /cvs/src/src/gdb/testsuite/gdb.base/ptype.c,v
retrieving revision 1.1.1.3
diff -c -r1.1.1.3 ptype.c
*** gdb/testsuite/gdb.base/ptype.c	2000/01/06 03:06:51	1.1.1.3
--- gdb/testsuite/gdb.base/ptype.c	2002/02/09 20:02:05
***************
*** 226,231 ****
--- 226,259 ----
     in the executable, at least for AIX xlc.  */
  enum misordered v_misordered = three;
  
+ /**** Pointers to functions *******/
+ 
+ typedef int (*func_type) (int (*) (int, float), float);
+ double (*old_fptr) ();
+ double (*new_fptr) (void);
+ int (*fptr) (int, float);
+ int *(*fptr2) (int (*) (int, float), float);
+ int (*xptr) (int (*) (), int (*) (void), int);
+ int (*(*ffptr) (char)) (short);
+ int (*(*(*fffptr) (char)) (short)) (long);
+ 
+ /* Here are the sort of stabs we expect to see for the above:
+ 
+    .stabs "func_type:t(0,100)=*(0,101)=g(0,1)(0,102)=*(0,103)=g(0,1)(0,1)(0,14)#(0,14)#",128,0,234,0
+    .stabs "old_fptr:G(0,110)=*(0,111)=f(0,15)",32,0,231,0
+    .stabs "new_fptr:G(0,120)=*(0,121)=g(0,15)(0,122)=(0,122)#",32,0,232,0
+    .stabs "fptr:G(0,130)=*(0,103)#",32,0,233,0
+    .stabs "fptr2:G(0,140)=*(0,141)=g(0,142)=*(0,1)(0,102)(0,14)#",32,0,235,0
+    .stabs "xptr:G(0,150)=*(0,151)=g(0,1)(0,152)=*(0,153)=f(0,1)(0,154)=*(0,155)=g(0,1)(0,122)#(0,1)#",32,0,236,0
+    .stabs "ffptr:G(0,160)=*(0,161)=g(0,162)=*(0,163)=g(0,1)(0,8)#(0,2)#",32,0,237,0\
+    .stabs "fffptr:G(0,170)=*(0,171)=g(0,172)=*(0,173)=g(0,174)=*(0,175)=g(0,1)(0,3)#(0,8)#(0,2)#",32,0,237,0
+ 
+    Most of these use Sun's extension for prototyped function types ---
+    the 'g' type descriptor.  As of around 9 Feb 2002, GCC didn't emit
+    those, but GDB can read them, so the related tests in ptype.exp
+    will all xfail.  */
+ 
+ 
  /***********/
  
  int main ()
Index: gdb/testsuite/gdb.base/ptype.exp
===================================================================
RCS file: /cvs/src/src/gdb/testsuite/gdb.base/ptype.exp,v
retrieving revision 1.3
diff -c -r1.3 ptype.exp
*** gdb/testsuite/gdb.base/ptype.exp	2002/01/06 14:42:39	1.3
--- gdb/testsuite/gdb.base/ptype.exp	2002/02/09 20:02:05
***************
*** 533,538 ****
--- 533,590 ----
  
  gdb_test "ptype nested_su.inner_union_instance" "type = union ${outer}inner_union \{.*\[\r\n\]    int inner_union_int;.*\[\r\n\]    (long|long int|int) inner_union_long;.*\[\r\n\]\}.*" "ptype nested union" 
  
+ 
+ get_debug_format
+ 
+ # Print the type of the identifier ID, and check the response:
+ # - Expect to see PROTOTYPED as the type.  PROTOTYPED is not a regular
+ #   expression; it's a literal string.
+ # - If we instead see the unprototyped type PLAIN, and we're using STABS
+ #   generated by GCC, that's an xfail; as of 9 Feb 2002, GCC never emits
+ #   prototyped function types in STABS.  Like PROTOTYPED, PLAIN is a
+ #   literal string, not a regular expression.
+ # - Otherwise, it's a failure.
+ proc ptype_maybe_prototyped { id prototyped plain } {
+     global gdb_prompt
+     global gcc_compiled
+ 
+     # Turn `prototyped' and `plain', which are literal strings, into
+     # regular expressions by quoting any special characters they contain.
+     regsub -all "\[\]\[*()\]" $prototyped "\\\\&" prototyped
+     regsub -all "\[\]\[*()\]" $plain "\\\\&" plain
+ 
+     send_gdb "ptype $id\n"
+     gdb_expect {
+         -re "type = $prototyped\[\r\n\]+$gdb_prompt $" {
+             pass "ptype $id"
+         }
+         -re "type = $plain\[\r\n\]+$gdb_prompt $" {
+             if {$gcc_compiled} { setup_xfail_format "stabs" }
+             fail "ptype $id (compiler doesn't emit prototyped types)"
+         }
+         -re "$gdb_prompt $" {
+             fail "ptype $id"
+         }
+         timeout {
+             fail "ptype $id (timeout)"
+         }
+     }
+ }
+ 
+ ptype_maybe_prototyped "func_type" "int (*)(int (*)(int, float), float)" \
+                                    "int (*)()"
+ ptype_maybe_prototyped "old_fptr" "double (*)()" "double (*)()"
+ ptype_maybe_prototyped "new_fptr" "double (*)(void)" "double (*)()"
+ ptype_maybe_prototyped "fptr" "int (*)(int, float)" "int (*)()"
+ ptype_maybe_prototyped "fptr2" "int *(*)(int (*)(int, float), float)" \
+                                "int *(*)()"
+ ptype_maybe_prototyped "xptr" "int (*)(int (*)(), int (*)(void), int)" \
+                               "int (*)()"
+ ptype_maybe_prototyped "ffptr" "int (*(*)(char))(short int)" \
+                                "int (*(*)())()"
+ ptype_maybe_prototyped "fffptr" "int (*(*(*)(char))(short int))(long int)" \
+                                 "int (*(*(*)())())()"
+ 
  # Test printing type of string constants and array constants, but
  # requires a running process.  These call malloc, and can take a long
  # time to execute over a slow serial link, so increase the timeout.