gdb/testsuite/gdb.base/whatis.exp - binutils-gdb - Git at Google

 # Copyright 1988-2021 Free Software Foundation, Inc.

 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 3 of the License, or
 # (at your option) any later version.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.

 # This file was written by Rob Savoye. (rob@cygnus.com)

 #
 # test running programs
 #

 if [target_info exists no_long_long] {
     set exec_opts [list debug additional_flags=-DNO_LONG_LONG]
 } else {
     set exec_opts [list debug]
 }

 standard_testfile .c

 # Define a procedure to set up an xfail for all targets that put out a
 # `long' type as an `int' type.
 # Sun cc has this problem.
 # It was said that COFF targets can not distinguish int from long either.

 proc setup_xfail_on_long_vs_int {} {
     global gcc_compiled

     if {!$gcc_compiled} {
 	setup_xfail "*-sun-sunos4*" "i*86-sequent-bsd*"
     }
 }

 # Compile the test using OPTIONS into a sub-directory DIR, and then
 # run the test.
 proc do_test {dir options} {
     global srcfile testfile gcc_compiled

     set binfile [standard_output_file ${dir}/${testfile}]
     if { [prepare_for_testing "failed to prepare" ${binfile} \
 	      [list $srcfile] $options] } {
 	return 0
     }

     #
     # Test whatis command with basic C types
     #
     # The name printed now (as of 23 May 1993) is whatever name the compiler
     # uses in the stabs.  So we need to deal with names both from gcc and
     # native compilers.
     #

     gdb_test "whatis v_char" \
 	"type = (unsigned char|char)" \
 	"whatis char"

     gdb_test "whatis v_signed_char" \
 	"type = (signed char|char)" \
 	"whatis signed char"

     gdb_test "whatis v_unsigned_char" \
 	"type = unsigned char" \
 	"whatis unsigned char"

     gdb_test "whatis v_short" \
 	"type = (short|short int)" \
 	"whatis short"

     gdb_test "whatis v_signed_short" \
 	"type = (short|short int|signed short|signed short int)" \
 	"whatis signed short"

     gdb_test "whatis v_unsigned_short" \
 	"type = (unsigned short|short unsigned int)" \
 	"whatis unsigned short"

     gdb_test "whatis v_int" \
 	"type = int" \
 	"whatis int"

     gdb_test "whatis v_signed_int" \
 	"type = (signed |)int" \
 	"whatis signed int"

     gdb_test "whatis v_unsigned_int" \
 	"type = unsigned int" \
 	"whatis unsigned int"

     setup_xfail_on_long_vs_int
     # AIX xlc gets this wrong and unsigned long right.  Go figure.
     if {!$gcc_compiled} then {setup_xfail "rs6000-*-aix*"}
     gdb_test "whatis v_long" \
 	"type = (long|long int)" \
 	"whatis long"

     setup_xfail_on_long_vs_int
     # AIX xlc gets this wrong and unsigned long right.  Go figure.
     if {!$gcc_compiled} then {setup_xfail "rs6000-*-aix*"}
     gdb_test "whatis v_signed_long" \
 	"type = (signed |)(long|long int)" \
 	"whatis signed long"

     setup_xfail_on_long_vs_int
     gdb_test "whatis v_unsigned_long" \
 	"type = (unsigned long|long unsigned int)" \
 	"whatis unsigned long"


     if ![target_info exists no_long_long] {
 	gdb_test "whatis v_unsigned_long_long" \
 	    "type = (unsigned long long|long long unsigned int)" \
 	    "whatis unsigned long long"
     }

     gdb_test "whatis v_float" \
 	"type = float" \
 	"whatis float"

     gdb_test "whatis v_double" \
 	"type = double" \
 	"whatis double"


     # test whatis command with arrays
     #
     # We already tested whether char prints as "char", so here we accept
     # "unsigned char", "signed char", and other perversions.  No need for more
     # than one xfail for the same thing.
     gdb_test "whatis v_char_array" \
 	"type = (signed |unsigned |)char \\\[2\\\]" \
 	"whatis char array"

     gdb_test "whatis v_signed_char_array" \
 	"type = (signed |unsigned |)char \\\[2\\\]" \
 	"whatis signed char array"

     gdb_test "whatis v_unsigned_char_array" \
 	"type = unsigned char \\\[2\\\]" \
 	"whatis unsigned char array"

     gdb_test "whatis v_short_array" \
 	"type = (short|short int) \\\[2\\\]" \
 	"whatis short array"

     gdb_test "whatis v_signed_short_array" \
 	"type = (signed |)(short|short int) \\\[2\\\]" \
 	"whatis signed short array"

     gdb_test "whatis v_unsigned_short_array" \
 	"type = (unsigned short|short unsigned int) \\\[2\\\]" \
 	"whatis unsigned short array"

     gdb_test "whatis v_int_array" \
 	"type = int \\\[2\\\]" \
 	"whatis int array"

     gdb_test "whatis v_signed_int_array" \
 	"type = (signed |)int \\\[2\\\]" \
 	"whatis signed int array"

     gdb_test "whatis v_unsigned_int_array" \
 	"type = unsigned int \\\[2\\\]" \
 	"whatis unsigned int array"

     # We already tested whether long prints as long, so here we accept int
     # No need for more than one xfail for the same thing.
     gdb_test "whatis v_long_array" \
 	"type = (int|long|long int) \\\[2\\\]" \
 	"whatis long array"

     gdb_test "whatis v_signed_long_array" \
 	"type = (signed |)(int|long|long int) \\\[2\\\]" \
 	"whatis signed long array"

     gdb_test "whatis v_unsigned_long_array" \
 	"type = (unsigned (int|long|long int)|long unsigned int) \\\[2\\\]" \
 	"whatis unsigned long array"

     if ![target_info exists no_long_long] {
 	gdb_test "whatis v_unsigned_long_long_array" \
 	    "type = (unsigned long long|long long unsigned int) \\\[2\\\]" \
 	    "whatis unsigned long long array"
     }

     gdb_test "whatis v_float_array" \
 	"type = float \\\[2\\\]" \
 	"whatis float array"

     gdb_test "whatis v_double_array" \
 	"type = double \\\[2\\\]" \
 	"whatis double array"

     # test whatis command with pointers
     #
     # We already tested whether char prints as char, so accept various perversions
     # here.  We especially want to make sure we test that it doesn't print as
     # caddr_t.
     gdb_test "whatis v_char_pointer" \
 	"type = (unsigned |signed |)char \\*" \
 	"whatis char pointer"

     gdb_test "whatis v_signed_char_pointer" \
 	"type = (unsigned |signed |)char \\*" \
 	"whatis signed char pointer"

     gdb_test "whatis v_unsigned_char_pointer" \
 	"type = unsigned char \\*" \
 	"whatis unsigned char pointer"

     gdb_test "whatis v_short_pointer" \
 	"type = (short|short int) \\*" \
 	"whatis short pointer"

     gdb_test "whatis v_signed_short_pointer" \
 	"type = (signed |)(short|short int) \\*" \
 	"whatis signed short pointer"

     gdb_test "whatis v_unsigned_short_pointer" \
 	"type = (unsigned short|short unsigned int) \\*" \
 	"whatis unsigned short pointer"

     gdb_test "whatis v_int_pointer" \
 	"type = int \\*" \
 	"whatis int pointer"

     gdb_test "whatis v_signed_int_pointer" \
 	"type = (signed |)int \\*" \
 	"whatis signed int pointer"

     gdb_test "whatis v_unsigned_int_pointer" \
 	"type = unsigned int \\*" \
 	"whatis unsigned int pointer"

     # We already tested whether long prints as long, so here we accept int
     gdb_test "whatis v_long_pointer" \
 	"type = (long|int|long int) \\*" \
 	"whatis long pointer"

     gdb_test "whatis v_signed_long_pointer" \
 	"type = (signed |)(long|int|long int) \\*" \
 	"whatis signed long pointer"

     gdb_test "whatis v_unsigned_long_pointer" \
 	"type = (unsigned (int|long|long int)|long unsigned int) \\*" \
 	"whatis unsigned long pointer"

     if ![target_info exists no_long_long] {
 	gdb_test "whatis v_long_long_pointer" \
 	    "type = long long(| int) \\*" \
 	    "whatis long long pointer"

 	gdb_test "whatis v_signed_long_long_pointer" \
 	    "type = (signed |)long long(| int) \\*" \
 	    "whatis signed long long pointer"

 	gdb_test "whatis v_unsigned_long_long_pointer" \
 	    "type = (unsigned long long|long long unsigned int) \\*" \
 	    "whatis unsigned long long pointer"
     }

     gdb_test "whatis v_float_pointer" \
 	"type = float \\*" \
 	"whatis float pointer"

     gdb_test "whatis v_double_pointer" \
 	"type = double \\*" \
 	"whatis double pointer"


     # test whatis command with structure types

     # First with a type argument, with both "set print object" set to "on"
     # and "off", ending with "off" for the following tests.
     foreach_with_prefix print_object {"on" "off"} {
 	gdb_test_no_output "set print object $print_object"

 	gdb_test "whatis struct t_struct" \
 	    "type = struct t_struct" \
 	    "whatis named structure using type name"

 	gdb_test "whatis struct t_struct *" \
 	    "type = struct t_struct \\*" \
 	    "whatis named structure using type name and pointer"

 	gdb_test "whatis struct t_struct &" \
 	    "type = struct t_struct &" \
 	    "whatis named structure using type name and reference"
     }

     # Now with an expression argument.

     gdb_test "whatis v_struct1" \
 	"type = struct t_struct" \
 	"whatis named structure"

     gdb_test "whatis v_struct2" \
 	"type = struct \{\.\.\.\}" \
 	"whatis unnamed structure"

     gdb_test "whatis &v_struct1" \
 	"type = struct t_struct \\*"

     gdb_test "whatis &v_struct2" \
 	"type = struct {\\.\\.\\.} \\*"

     gdb_test "whatis v_struct_ptr1" \
 	"type = struct t_struct \\*"

     gdb_test "whatis v_struct_ptr2" \
 	"type = struct {\\.\\.\\.} \\*"

     gdb_test "whatis &v_struct_ptr1" \
 	"type = struct t_struct \\*\\*"

     gdb_test "whatis &v_struct_ptr2" \
 	"type = struct {\\.\\.\\.} \\*\\*"

     gdb_test "whatis v_struct1.v_char_member" \
 	"type = char"

     gdb_test "whatis v_struct2.v_char_member" \
 	"type = char"

     gdb_test "whatis v_struct_ptr1->v_char_member" \
 	"type = char"

     gdb_test "whatis v_struct_ptr2->v_char_member" \
 	"type = char"

     gdb_test "whatis &(v_struct1.v_char_member)" \
 	"type = char \\*"

     gdb_test "whatis &(v_struct2.v_char_member)" \
 	"type = char \\*"

     gdb_test "whatis &(v_struct_ptr1->v_char_member)" \
 	"type = char \\*"

     gdb_test "whatis &(v_struct_ptr2->v_char_member)" \
 	"type = char \\*"

     # test whatis command with union types
     gdb_test "whatis v_union" \
 	"type = union t_union" \
 	"whatis named union"

     gdb_test "whatis union t_union" \
 	"type = union t_union" \
 	"whatis named union using type name"

     gdb_test "whatis v_union2" \
 	"type = union \{\.\.\.\}" \
 	"whatis unnamed union"

     gdb_test "whatis &v_union" \
 	"type = union t_union \\*"

     gdb_test "whatis &v_union2" \
 	"type = union {\\.\\.\\.} \\*"

     gdb_test "whatis v_union_ptr" \
 	"type = union t_union \\*"

     gdb_test "whatis v_union_ptr2" \
 	"type = union {\\.\\.\\.} \\*"

     gdb_test "whatis &v_union_ptr" \
 	"type = union t_union \\*\\*"

     gdb_test "whatis &v_union_ptr2" \
 	"type = union {\\.\\.\\.} \\*\\*"

     gdb_test "whatis v_union.v_char_member" \
 	"type = char"

     gdb_test "whatis v_union2.v_char_member" \
 	"type = char"

     gdb_test "whatis v_union_ptr->v_char_member" \
 	"type = char"

     gdb_test "whatis v_union_ptr2->v_char_member" \
 	"type = char"

     gdb_test "whatis &(v_union.v_char_member)" \
 	"type = char \\*"

     gdb_test "whatis &(v_union2.v_char_member)" \
 	"type = char \\*"

     gdb_test "whatis &(v_union_ptr->v_char_member)" \
 	"type = char \\*"

     gdb_test "whatis &(v_union_ptr2->v_char_member)" \
 	"type = char \\*"

     if { $dir == "dwarf" } {
 	# Using stabs we will mark these functions as prototyped.  This
 	# is harmless but causes an extra VOID to be printed.
 	set void "(void|)"

 	# test whatis command with functions return type
 	gdb_test "whatis v_char_func" \
 	    "type = (signed |unsigned |)char \\($void\\)" \
 	    "whatis char function"

 	gdb_test "whatis v_signed_char_func" \
 	    "type = (signed |unsigned |)char \\($void\\)" \
 	    "whatis signed char function"

 	gdb_test "whatis v_unsigned_char_func" \
 	    "type = unsigned char \\($void\\)"	\
 	    "whatis unsigned char function"

 	gdb_test "whatis v_short_func" \
 	    "type = short (int |)\\($void\\)" \
 	    "whatis short function"

 	gdb_test "whatis v_signed_short_func" \
 	    "type = (signed |)short (int |)\\($void\\)" \
 	    "whatis signed short function"

 	gdb_test "whatis v_unsigned_short_func" \
 	    "type = (unsigned short|short unsigned int) \\($void\\)" \
 	    "whatis unsigned short function"

 	gdb_test "whatis v_int_func" \
 	    "type = int \\($void\\)" \
 	    "whatis int function"

 	gdb_test "whatis v_signed_int_func" \
 	    "type = (signed |)int \\($void\\)" \
 	    "whatis signed int function"

 	gdb_test "whatis v_unsigned_int_func" \
 	    "type = unsigned int \\($void\\)" \
 	    "whatis unsigned int function"

 	gdb_test "whatis v_long_func" \
 	    "type = (long|int|long int) \\($void\\)" \
 	    "whatis long function"

 	gdb_test "whatis v_signed_long_func" \
 	    "type = (signed |)(int|long|long int) \\($void\\)" \
 	    "whatis signed long function"

 	gdb_test "whatis v_unsigned_long_func" \
 	    "type = (unsigned (int|long|long int)|long unsigned int) \\($void\\)" \
 	    "whatis unsigned long function"

 	if ![target_info exists no_long_long] {
 	    gdb_test "whatis v_long_long_func" \
 		"type = long long(| int) \\($void\\)" \
 		"whatis long long function"

 	    gdb_test "whatis v_signed_long_long_func" \
 		"type = (signed |)long long(| int) \\($void\\)" \
 		"whatis signed long long function"

 	    gdb_test "whatis v_unsigned_long_long_func" \
 		"type = (unsigned long long(| int)|long long unsigned int) \\($void\\)" \
 		"whatis unsigned long long function"
 	}

 	# Sun /bin/cc calls this a function returning double.
 	if {!$gcc_compiled} then {setup_xfail "*-sun-sunos4*"}
 	gdb_test "whatis v_float_func" \
 	    "type = float \\($void\\)" \
 	    "whatis float function"

 	gdb_test "whatis v_double_func" \
 	    "type = double \\($void\\)" \
 	    "whatis double function" \
 	}

     # test whatis command with some misc complicated types
     gdb_test "whatis s_link" \
 	"type = struct link \\*" \
 	"whatis complicated structure"

     gdb_test "whatis u_link" \
 	"type = union tu_link" \
 	"whatis complicated union"


     # test whatis command with enumerations
     gdb_test "whatis clunker" \
 	"type = enum cars" \
 	"whatis enumeration"

     gdb_test "whatis enum cars" \
 	"type = enum cars" \
 	"whatis enumeration using type name"


     # test whatis command with nested struct and union
     gdb_test "whatis nested_su" \
 	"type = struct outer_struct" \
 	"whatis outer structure"

     gdb_test "whatis nested_su.outer_int" \
 	"type = int" \
 	"whatis outer structure member"

     gdb_test "whatis nested_su.inner_struct_instance" \
 	"type = struct inner_struct" \
 	"whatis inner structure"

     gdb_test "whatis nested_su.inner_struct_instance.inner_int" \
 	"type = int" \
 	"whatis inner structure member"

     gdb_test "whatis nested_su.inner_union_instance" \
 	"type = union inner_union" \
 	"whatis inner union"

     gdb_test "whatis nested_su.inner_union_instance.inner_union_int" \
 	"type = int" \
 	"whatis inner union member"

     # test whatis command with typedefs

     gdb_test "whatis char_addr" \
 	"type = char \\*" \
 	"whatis using typedef type name"

     if { $dir == "dwarf" } {
 	gdb_test "whatis a_char_addr" \
 	    "type = char_addr" \
 	    "whatis applied to variable defined by typedef"
     }

     # Regression tests for PR 9514.

     gdb_test "whatis void (**)()" \
 	"type = void \\(\\*\\*\\)\\(\\)" \
 	"whatis applied to pointer to pointer to function"

     gdb_test "whatis void (** const)()" \
 	"type = void \\(\\*\\* const\\)\\(\\)" \
 	"whatis applied to const pointer to pointer to function"

     gdb_test "whatis void (* const *)()" \
 	"type = void \\(\\* const \\*\\)\\(\\)" \
 	"whatis applied to pointer to const pointer to function"

     gdb_test "whatis int *(*)()" \
 	"type = int \\*\\(\\*\\)\\(\\)" \
 	"whatis applied to pointer to function returning pointer to int"

     gdb_test "whatis int *(**)()" \
 	"type = int \\*\\(\\*\\*\\)\\(\\)" \
 	"whatis applied to pointer to pointer to function returning pointer to int"

     gdb_test "whatis char (*(*)())\[23\]" \
 	"type = char \\(\\*\\(\\*\\)\\(\\)\\)\\\[23\\\]" \
 	"whatis applied to pointer to function returning pointer to array"

     gdb_test "whatis int (*)(int, int)" \
 	"type = int \\(\\*\\)\\(int, int\\)" \
 	"whatis applied to pointer to function taking int,int and returning int"

     gdb_test "whatis int (*)(const int *, ...)" \
 	"type = int \\(\\*\\)\\(const int \\*, \\.\\.\\.\\)" \
 	"whatis applied to pointer to function taking const int ptr and varargs and returning int"

     gdb_test "whatis int (*)(void, int, int)" \
 	"parameter types following 'void'" \
 	"whatis applied to function with types trailing 'void'"

     gdb_test "whatis int (*)(int, void, int)" \
 	"'void' invalid as parameter type" \
 	"whatis applied to function with 'void' parameter type"
 }

 # Build up the set of debug formats for which we will run this test.
 set specs { {dwarf {debug}} }
 if ![skip_ctf_tests] {
     lappend specs {ctf {"additional_flags=-gt"}}
 }

 # Setup and run the test for each debug format.
 foreach testspec $specs {
     set prefix [lindex $testspec 0]
     set opts [lindex $testspec 1]

     with_test_prefix $prefix {
 	remote_exec host "mkdir -p [standard_output_file ${prefix}]"
 	do_test $prefix $opts
     }
 }
	# Copyright 1988-2021 Free Software Foundation, Inc.

	# This program is free software; you can redistribute it and/or modify
	# it under the terms of the GNU General Public License as published by
	# the Free Software Foundation; either version 3 of the License, or
	# (at your option) any later version.
	#
	# This program is distributed in the hope that it will be useful,
	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	# GNU General Public License for more details.
	#
	# You should have received a copy of the GNU General Public License
	# along with this program. If not, see <http://www.gnu.org/licenses/>.

	# This file was written by Rob Savoye. (rob@cygnus.com)

	#
	# test running programs
	#

	if [target_info exists no_long_long] {
	set exec_opts [list debug additional_flags=-DNO_LONG_LONG]
	} else {
	set exec_opts [list debug]
	}

	standard_testfile .c

	# Define a procedure to set up an xfail for all targets that put out a
	# `long' type as an `int' type.
	# Sun cc has this problem.
	# It was said that COFF targets can not distinguish int from long either.

	proc setup_xfail_on_long_vs_int {} {
	global gcc_compiled

	if {!$gcc_compiled} {
	setup_xfail "-sun-sunos4" "i86-sequent-bsd"
	}
	}

	# Compile the test using OPTIONS into a sub-directory DIR, and then
	# run the test.
	proc do_test {dir options} {
	global srcfile testfile gcc_compiled

	set binfile [standard_output_file ${dir}/${testfile}]
	if { [prepare_for_testing "failed to prepare" ${binfile} \
	[list $srcfile] $options] } {
	return 0
	}

	#
	# Test whatis command with basic C types
	#
	# The name printed now (as of 23 May 1993) is whatever name the compiler
	# uses in the stabs. So we need to deal with names both from gcc and
	# native compilers.
	#

	gdb_test "whatis v_char" \
	"type = (unsigned char\|char)" \
	"whatis char"

	gdb_test "whatis v_signed_char" \
	"type = (signed char\|char)" \
	"whatis signed char"

	gdb_test "whatis v_unsigned_char" \
	"type = unsigned char" \
	"whatis unsigned char"

	gdb_test "whatis v_short" \
	"type = (short\|short int)" \
	"whatis short"

	gdb_test "whatis v_signed_short" \
	"type = (short\|short int\|signed short\|signed short int)" \
	"whatis signed short"

	gdb_test "whatis v_unsigned_short" \
	"type = (unsigned short\|short unsigned int)" \
	"whatis unsigned short"

	gdb_test "whatis v_int" \
	"type = int" \
	"whatis int"

	gdb_test "whatis v_signed_int" \
	"type = (signed \|)int" \
	"whatis signed int"

	gdb_test "whatis v_unsigned_int" \
	"type = unsigned int" \
	"whatis unsigned int"

	setup_xfail_on_long_vs_int
	# AIX xlc gets this wrong and unsigned long right. Go figure.
	if {!$gcc_compiled} then {setup_xfail "rs6000--aix"}
	gdb_test "whatis v_long" \
	"type = (long\|long int)" \
	"whatis long"

	setup_xfail_on_long_vs_int
	# AIX xlc gets this wrong and unsigned long right. Go figure.
	if {!$gcc_compiled} then {setup_xfail "rs6000--aix"}
	gdb_test "whatis v_signed_long" \
	"type = (signed \|)(long\|long int)" \
	"whatis signed long"

	setup_xfail_on_long_vs_int
	gdb_test "whatis v_unsigned_long" \
	"type = (unsigned long\|long unsigned int)" \
	"whatis unsigned long"


	if ![target_info exists no_long_long] {
	gdb_test "whatis v_unsigned_long_long" \
	"type = (unsigned long long\|long long unsigned int)" \
	"whatis unsigned long long"
	}

	gdb_test "whatis v_float" \
	"type = float" \
	"whatis float"

	gdb_test "whatis v_double" \
	"type = double" \
	"whatis double"


	# test whatis command with arrays
	#
	# We already tested whether char prints as "char", so here we accept
	# "unsigned char", "signed char", and other perversions. No need for more
	# than one xfail for the same thing.
	gdb_test "whatis v_char_array" \
	"type = (signed \|unsigned \|)char \\\[2\\\]" \
	"whatis char array"

	gdb_test "whatis v_signed_char_array" \
	"type = (signed \|unsigned \|)char \\\[2\\\]" \
	"whatis signed char array"

	gdb_test "whatis v_unsigned_char_array" \
	"type = unsigned char \\\[2\\\]" \
	"whatis unsigned char array"

	gdb_test "whatis v_short_array" \
	"type = (short\|short int) \\\[2\\\]" \
	"whatis short array"

	gdb_test "whatis v_signed_short_array" \
	"type = (signed \|)(short\|short int) \\\[2\\\]" \
	"whatis signed short array"

	gdb_test "whatis v_unsigned_short_array" \
	"type = (unsigned short\|short unsigned int) \\\[2\\\]" \
	"whatis unsigned short array"

	gdb_test "whatis v_int_array" \
	"type = int \\\[2\\\]" \
	"whatis int array"

	gdb_test "whatis v_signed_int_array" \
	"type = (signed \|)int \\\[2\\\]" \
	"whatis signed int array"

	gdb_test "whatis v_unsigned_int_array" \
	"type = unsigned int \\\[2\\\]" \
	"whatis unsigned int array"

	# We already tested whether long prints as long, so here we accept int
	# No need for more than one xfail for the same thing.
	gdb_test "whatis v_long_array" \
	"type = (int\|long\|long int) \\\[2\\\]" \
	"whatis long array"

	gdb_test "whatis v_signed_long_array" \
	"type = (signed \|)(int\|long\|long int) \\\[2\\\]" \
	"whatis signed long array"

	gdb_test "whatis v_unsigned_long_array" \
	"type = (unsigned (int\|long\|long int)\|long unsigned int) \\\[2\\\]" \
	"whatis unsigned long array"

	if ![target_info exists no_long_long] {
	gdb_test "whatis v_unsigned_long_long_array" \
	"type = (unsigned long long\|long long unsigned int) \\\[2\\\]" \
	"whatis unsigned long long array"
	}

	gdb_test "whatis v_float_array" \
	"type = float \\\[2\\\]" \
	"whatis float array"

	gdb_test "whatis v_double_array" \
	"type = double \\\[2\\\]" \
	"whatis double array"

	# test whatis command with pointers
	#
	# We already tested whether char prints as char, so accept various perversions
	# here. We especially want to make sure we test that it doesn't print as
	# caddr_t.
	gdb_test "whatis v_char_pointer" \
	"type = (unsigned \|signed \|)char \\*" \
	"whatis char pointer"

	gdb_test "whatis v_signed_char_pointer" \
	"type = (unsigned \|signed \|)char \\*" \
	"whatis signed char pointer"

	gdb_test "whatis v_unsigned_char_pointer" \
	"type = unsigned char \\*" \
	"whatis unsigned char pointer"

	gdb_test "whatis v_short_pointer" \
	"type = (short\|short int) \\*" \
	"whatis short pointer"

	gdb_test "whatis v_signed_short_pointer" \
	"type = (signed \|)(short\|short int) \\*" \
	"whatis signed short pointer"

	gdb_test "whatis v_unsigned_short_pointer" \
	"type = (unsigned short\|short unsigned int) \\*" \
	"whatis unsigned short pointer"

	gdb_test "whatis v_int_pointer" \
	"type = int \\*" \
	"whatis int pointer"

	gdb_test "whatis v_signed_int_pointer" \
	"type = (signed \|)int \\*" \
	"whatis signed int pointer"

	gdb_test "whatis v_unsigned_int_pointer" \
	"type = unsigned int \\*" \
	"whatis unsigned int pointer"

	# We already tested whether long prints as long, so here we accept int
	gdb_test "whatis v_long_pointer" \
	"type = (long\|int\|long int) \\*" \
	"whatis long pointer"

	gdb_test "whatis v_signed_long_pointer" \
	"type = (signed \|)(long\|int\|long int) \\*" \
	"whatis signed long pointer"

	gdb_test "whatis v_unsigned_long_pointer" \
	"type = (unsigned (int\|long\|long int)\|long unsigned int) \\*" \
	"whatis unsigned long pointer"

	if ![target_info exists no_long_long] {
	gdb_test "whatis v_long_long_pointer" \
	"type = long long(\| int) \\*" \
	"whatis long long pointer"

	gdb_test "whatis v_signed_long_long_pointer" \
	"type = (signed \|)long long(\| int) \\*" \
	"whatis signed long long pointer"

	gdb_test "whatis v_unsigned_long_long_pointer" \
	"type = (unsigned long long\|long long unsigned int) \\*" \
	"whatis unsigned long long pointer"
	}

	gdb_test "whatis v_float_pointer" \
	"type = float \\*" \
	"whatis float pointer"

	gdb_test "whatis v_double_pointer" \
	"type = double \\*" \
	"whatis double pointer"


	# test whatis command with structure types

	# First with a type argument, with both "set print object" set to "on"
	# and "off", ending with "off" for the following tests.
	foreach_with_prefix print_object {"on" "off"} {
	gdb_test_no_output "set print object $print_object"

	gdb_test "whatis struct t_struct" \
	"type = struct t_struct" \
	"whatis named structure using type name"

	gdb_test "whatis struct t_struct *" \
	"type = struct t_struct \\*" \
	"whatis named structure using type name and pointer"

	gdb_test "whatis struct t_struct &" \
	"type = struct t_struct &" \
	"whatis named structure using type name and reference"
	}

	# Now with an expression argument.

	gdb_test "whatis v_struct1" \
	"type = struct t_struct" \
	"whatis named structure"

	gdb_test "whatis v_struct2" \
	"type = struct \{\.\.\.\}" \
	"whatis unnamed structure"

	gdb_test "whatis &v_struct1" \
	"type = struct t_struct \\*"

	gdb_test "whatis &v_struct2" \
	"type = struct {\\.\\.\\.} \\*"

	gdb_test "whatis v_struct_ptr1" \
	"type = struct t_struct \\*"

	gdb_test "whatis v_struct_ptr2" \
	"type = struct {\\.\\.\\.} \\*"

	gdb_test "whatis &v_struct_ptr1" \
	"type = struct t_struct \\\\"

	gdb_test "whatis &v_struct_ptr2" \
	"type = struct {\\.\\.\\.} \\\\"

	gdb_test "whatis v_struct1.v_char_member" \
	"type = char"

	gdb_test "whatis v_struct2.v_char_member" \
	"type = char"

	gdb_test "whatis v_struct_ptr1->v_char_member" \
	"type = char"

	gdb_test "whatis v_struct_ptr2->v_char_member" \
	"type = char"

	gdb_test "whatis &(v_struct1.v_char_member)" \
	"type = char \\*"

	gdb_test "whatis &(v_struct2.v_char_member)" \
	"type = char \\*"

	gdb_test "whatis &(v_struct_ptr1->v_char_member)" \
	"type = char \\*"

	gdb_test "whatis &(v_struct_ptr2->v_char_member)" \
	"type = char \\*"

	# test whatis command with union types
	gdb_test "whatis v_union" \
	"type = union t_union" \
	"whatis named union"

	gdb_test "whatis union t_union" \
	"type = union t_union" \
	"whatis named union using type name"

	gdb_test "whatis v_union2" \
	"type = union \{\.\.\.\}" \
	"whatis unnamed union"

	gdb_test "whatis &v_union" \
	"type = union t_union \\*"

	gdb_test "whatis &v_union2" \
	"type = union {\\.\\.\\.} \\*"

	gdb_test "whatis v_union_ptr" \
	"type = union t_union \\*"

	gdb_test "whatis v_union_ptr2" \
	"type = union {\\.\\.\\.} \\*"

	gdb_test "whatis &v_union_ptr" \
	"type = union t_union \\\\"

	gdb_test "whatis &v_union_ptr2" \
	"type = union {\\.\\.\\.} \\\\"

	gdb_test "whatis v_union.v_char_member" \
	"type = char"

	gdb_test "whatis v_union2.v_char_member" \
	"type = char"

	gdb_test "whatis v_union_ptr->v_char_member" \
	"type = char"

	gdb_test "whatis v_union_ptr2->v_char_member" \
	"type = char"

	gdb_test "whatis &(v_union.v_char_member)" \
	"type = char \\*"

	gdb_test "whatis &(v_union2.v_char_member)" \
	"type = char \\*"

	gdb_test "whatis &(v_union_ptr->v_char_member)" \
	"type = char \\*"

	gdb_test "whatis &(v_union_ptr2->v_char_member)" \
	"type = char \\*"

	if { $dir == "dwarf" } {
	# Using stabs we will mark these functions as prototyped. This
	# is harmless but causes an extra VOID to be printed.
	set void "(void\|)"

	# test whatis command with functions return type
	gdb_test "whatis v_char_func" \
	"type = (signed \|unsigned \|)char \\($void\\)" \
	"whatis char function"

	gdb_test "whatis v_signed_char_func" \
	"type = (signed \|unsigned \|)char \\($void\\)" \
	"whatis signed char function"

	gdb_test "whatis v_unsigned_char_func" \
	"type = unsigned char \\($void\\)" \
	"whatis unsigned char function"

	gdb_test "whatis v_short_func" \
	"type = short (int \|)\\($void\\)" \
	"whatis short function"

	gdb_test "whatis v_signed_short_func" \
	"type = (signed \|)short (int \|)\\($void\\)" \
	"whatis signed short function"

	gdb_test "whatis v_unsigned_short_func" \
	"type = (unsigned short\|short unsigned int) \\($void\\)" \
	"whatis unsigned short function"

	gdb_test "whatis v_int_func" \
	"type = int \\($void\\)" \
	"whatis int function"

	gdb_test "whatis v_signed_int_func" \
	"type = (signed \|)int \\($void\\)" \
	"whatis signed int function"

	gdb_test "whatis v_unsigned_int_func" \
	"type = unsigned int \\($void\\)" \
	"whatis unsigned int function"

	gdb_test "whatis v_long_func" \
	"type = (long\|int\|long int) \\($void\\)" \
	"whatis long function"

	gdb_test "whatis v_signed_long_func" \
	"type = (signed \|)(int\|long\|long int) \\($void\\)" \
	"whatis signed long function"

	gdb_test "whatis v_unsigned_long_func" \
	"type = (unsigned (int\|long\|long int)\|long unsigned int) \\($void\\)" \
	"whatis unsigned long function"

	if ![target_info exists no_long_long] {
	gdb_test "whatis v_long_long_func" \
	"type = long long(\| int) \\($void\\)" \
	"whatis long long function"

	gdb_test "whatis v_signed_long_long_func" \
	"type = (signed \|)long long(\| int) \\($void\\)" \
	"whatis signed long long function"

	gdb_test "whatis v_unsigned_long_long_func" \
	"type = (unsigned long long(\| int)\|long long unsigned int) \\($void\\)" \
	"whatis unsigned long long function"
	}

	# Sun /bin/cc calls this a function returning double.
	if {!$gcc_compiled} then {setup_xfail "-sun-sunos4"}
	gdb_test "whatis v_float_func" \
	"type = float \\($void\\)" \
	"whatis float function"

	gdb_test "whatis v_double_func" \
	"type = double \\($void\\)" \
	"whatis double function" \
	}

	# test whatis command with some misc complicated types
	gdb_test "whatis s_link" \
	"type = struct link \\*" \
	"whatis complicated structure"

	gdb_test "whatis u_link" \
	"type = union tu_link" \
	"whatis complicated union"


	# test whatis command with enumerations
	gdb_test "whatis clunker" \
	"type = enum cars" \
	"whatis enumeration"

	gdb_test "whatis enum cars" \
	"type = enum cars" \
	"whatis enumeration using type name"


	# test whatis command with nested struct and union
	gdb_test "whatis nested_su" \
	"type = struct outer_struct" \
	"whatis outer structure"

	gdb_test "whatis nested_su.outer_int" \
	"type = int" \
	"whatis outer structure member"

	gdb_test "whatis nested_su.inner_struct_instance" \
	"type = struct inner_struct" \
	"whatis inner structure"

	gdb_test "whatis nested_su.inner_struct_instance.inner_int" \
	"type = int" \
	"whatis inner structure member"

	gdb_test "whatis nested_su.inner_union_instance" \
	"type = union inner_union" \
	"whatis inner union"

	gdb_test "whatis nested_su.inner_union_instance.inner_union_int" \
	"type = int" \
	"whatis inner union member"

	# test whatis command with typedefs

	gdb_test "whatis char_addr" \
	"type = char \\*" \
	"whatis using typedef type name"

	if { $dir == "dwarf" } {
	gdb_test "whatis a_char_addr" \
	"type = char_addr" \
	"whatis applied to variable defined by typedef"
	}

	# Regression tests for PR 9514.

	gdb_test "whatis void (**)()" \
	"type = void \\(\\\\\\)\\(\\)" \
	"whatis applied to pointer to pointer to function"

	gdb_test "whatis void (** const)()" \
	"type = void \\(\\\\ const\\)\\(\\)" \
	"whatis applied to const pointer to pointer to function"

	gdb_test "whatis void (* const *)()" \
	"type = void \\(\\* const \\*\\)\\(\\)" \
	"whatis applied to pointer to const pointer to function"

	gdb_test "whatis int ()()" \
	"type = int \\\\(\\\\)\\(\\)" \
	"whatis applied to pointer to function returning pointer to int"

	gdb_test "whatis int (*)()" \
	"type = int \\\\(\\\\*\\)\\(\\)" \
	"whatis applied to pointer to pointer to function returning pointer to int"

	gdb_test "whatis char (()())\[23\]" \
	"type = char \\(\\\\(\\\\)\\(\\)\\)\\\[23\\\]" \
	"whatis applied to pointer to function returning pointer to array"

	gdb_test "whatis int (*)(int, int)" \
	"type = int \\(\\*\\)\\(int, int\\)" \
	"whatis applied to pointer to function taking int,int and returning int"

	gdb_test "whatis int ()(const int , ...)" \
	"type = int \\(\\\\)\\(const int \\, \\.\\.\\.\\)" \
	"whatis applied to pointer to function taking const int ptr and varargs and returning int"

	gdb_test "whatis int (*)(void, int, int)" \
	"parameter types following 'void'" \
	"whatis applied to function with types trailing 'void'"

	gdb_test "whatis int (*)(int, void, int)" \
	"'void' invalid as parameter type" \
	"whatis applied to function with 'void' parameter type"
	}

	# Build up the set of debug formats for which we will run this test.
	set specs { {dwarf {debug}} }
	if ![skip_ctf_tests] {
	lappend specs {ctf {"additional_flags=-gt"}}
	}

	# Setup and run the test for each debug format.
	foreach testspec $specs {
	set prefix [lindex $testspec 0]
	set opts [lindex $testspec 1]

	with_test_prefix $prefix {
	remote_exec host "mkdir -p [standard_output_file ${prefix}]"
	do_test $prefix $opts
	}
	}