# Copyright 1988-2020 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
    }

    clean_restart ${binfile}

    #
    # 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
    }
}