From patchwork Tue Nov 19 00:47:07 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Simon Marchi (Code Review)" X-Patchwork-Id: 36022 Received: (qmail 130251 invoked by alias); 19 Nov 2019 00:47:56 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Delivered-To: mailing list gdb-patches@sourceware.org Received: (qmail 130185 invoked by uid 89); 19 Nov 2019 00:47:55 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-20.4 required=5.0 tests=AWL, BAYES_00, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, KAM_SHORT, UNSUBSCRIBE_BODY autolearn=ham version=3.3.1 spammy= X-HELO: mx1.osci.io Received: from polly.osci.io (HELO mx1.osci.io) (8.43.85.229) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Tue, 19 Nov 2019 00:47:44 +0000 Received: by mx1.osci.io (Postfix, from userid 994) id E541220373; Mon, 18 Nov 2019 19:47:42 -0500 (EST) Received: from gnutoolchain-gerrit.osci.io (gnutoolchain-gerrit.osci.io [8.43.85.239]) by mx1.osci.io (Postfix) with ESMTP id 9FA2920959; Mon, 18 Nov 2019 19:47:11 -0500 (EST) Received: from localhost (localhost [127.0.0.1]) by gnutoolchain-gerrit.osci.io (Postfix) with ESMTP id 541BC2816F; Mon, 18 Nov 2019 19:47:11 -0500 (EST) X-Gerrit-PatchSet: 4 Date: Mon, 18 Nov 2019 19:47:07 -0500 From: "Sourceware to Gerrit sync (Code Review)" To: Andrew Burgess , Tom Tromey , Simon Marchi , gdb-patches@sourceware.org Auto-Submitted: auto-generated X-Gerrit-MessageType: newpatchset Subject: [pushed] gdb/testsuite: Merge whatis.exp and ctf-whatis.exp X-Gerrit-Change-Id: I09e11c70f197b79d2b1e0ae8c86a21c622be6c51 X-Gerrit-Change-Number: 123 X-Gerrit-ChangeURL: X-Gerrit-Commit: 0b8dbf3f1c359e26b25ce0e48634c83befd60994 In-Reply-To: References: Reply-To: noreply@gnutoolchain-gerrit.osci.io, simon.marchi@polymtl.ca, tromey@sourceware.org, andrew.burgess@embecosm.com, gdb-patches@sourceware.org MIME-Version: 1.0 Content-Disposition: inline User-Agent: Gerrit/3.0.3-79-g83ff7f88f1 Message-Id: <20191119004711.541BC2816F@gnutoolchain-gerrit.osci.io> The original change was created by Andrew Burgess. Change URL: https://gnutoolchain-gerrit.osci.io/r/c/binutils-gdb/+/123 ...................................................................... gdb/testsuite: Merge whatis.exp and ctf-whatis.exp The recently added gdb.base/ctf-whatis.exp test is a slightly modified version of gdb.base/whatis.exp, with a few tests removed, and the source compiled with different compiler options. This patch merges the two tests together into a single test script. I tested using a version of GCC with CTF support added. gdb/testsuite/ChangeLog: * gdb.base/ctf-whatis.c: Delete. * gdb.base/ctf-whatis.exp: Delete. * gdb.base/whatis.exp: Rewrite to compile as both dwarf and ctf. Change-Id: I09e11c70f197b79d2b1e0ae8c86a21c622be6c51 --- M gdb/testsuite/ChangeLog D gdb/testsuite/gdb.base/ctf-whatis.c D gdb/testsuite/gdb.base/ctf-whatis.exp M gdb/testsuite/gdb.base/whatis.exp 4 files changed, 518 insertions(+), 1,191 deletions(-) diff --git a/gdb/testsuite/ChangeLog b/gdb/testsuite/ChangeLog index d45aece..806389c 100644 --- a/gdb/testsuite/ChangeLog +++ b/gdb/testsuite/ChangeLog @@ -1,5 +1,11 @@ 2019-11-19 Andrew Burgess + * gdb.base/ctf-whatis.c: Delete. + * gdb.base/ctf-whatis.exp: Delete. + * gdb.base/whatis.exp: Rewrite to compile as both dwarf and ctf. + +2019-11-19 Andrew Burgess + * gdb.base/ctf-cvexpr.exp: Delete. * gdb.base/cvexpr.exp: Rewrite to compile as both dwarf and ctf. diff --git a/gdb/testsuite/gdb.base/ctf-whatis.c b/gdb/testsuite/gdb.base/ctf-whatis.c deleted file mode 100644 index 548dcbb..0000000 --- a/gdb/testsuite/gdb.base/ctf-whatis.c +++ /dev/null @@ -1,282 +0,0 @@ -/* This test program is part of GDB, the GNU debugger. - - Copyright 2019 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 . */ - -/* - * Test file with lots of different types, for testing the - * "whatis" command on CTF data. It's derived from whatis.c. - */ - -/* - * First the basic C types. - */ - -char v_char; -signed char v_signed_char; -unsigned char v_unsigned_char; - -short v_short; -signed short v_signed_short; -unsigned short v_unsigned_short; - -int v_int; -signed int v_signed_int; -unsigned int v_unsigned_int; - -long v_long; -signed long v_signed_long; -unsigned long v_unsigned_long; - -#ifndef NO_LONG_LONG -long long v_long_long; -signed long long v_signed_long_long; -unsigned long long v_unsigned_long_long; -#endif - -float v_float; -double v_double; - -/* - * Now some derived types, which are arrays, functions-returning, - * pointers, structures, unions, and enumerations. - */ - -/**** arrays *******/ - -char v_char_array[2]; -signed char v_signed_char_array[2]; -unsigned char v_unsigned_char_array[2]; - -short v_short_array[2]; -signed short v_signed_short_array[2]; -unsigned short v_unsigned_short_array[2]; - -int v_int_array[2]; -signed int v_signed_int_array[2]; -unsigned int v_unsigned_int_array[2]; - -long v_long_array[2]; -signed long v_signed_long_array[2]; -unsigned long v_unsigned_long_array[2]; - -#ifndef NO_LONG_LONG -long long v_long_long_array[2]; -signed long long v_signed_long_long_array[2]; -unsigned long long v_unsigned_long_long_array[2]; -#endif - -float v_float_array[2]; -double v_double_array[2]; - -/**** pointers *******/ - -/* Make sure they still print as pointer to foo even there is a typedef - for that type. Test this not just for char *, which might be - a special case kludge in GDB (Unix system include files like to define - caddr_t), but for a variety of types. */ -typedef char *char_addr; -char_addr a_char_addr; -typedef unsigned short *ushort_addr; -ushort_addr a_ushort_addr; -typedef signed long *slong_addr; -slong_addr a_slong_addr; -#ifndef NO_LONG_LONG -typedef signed long long *slong_long_addr; -slong_long_addr a_slong_long_addr; -#endif - -char *v_char_pointer; -signed char *v_signed_char_pointer; -unsigned char *v_unsigned_char_pointer; - -short *v_short_pointer; -signed short *v_signed_short_pointer; -unsigned short *v_unsigned_short_pointer; - -int *v_int_pointer; -signed int *v_signed_int_pointer; -unsigned int *v_unsigned_int_pointer; - -long *v_long_pointer; -signed long *v_signed_long_pointer; -unsigned long *v_unsigned_long_pointer; - -#ifndef NO_LONG_LONG -long long *v_long_long_pointer; -signed long long *v_signed_long_long_pointer; -unsigned long long *v_unsigned_long_long_pointer; -#endif - -float *v_float_pointer; -double *v_double_pointer; - -/**** structs *******/ - -struct t_struct { - char v_char_member; - short v_short_member; - int v_int_member; - long v_long_member; -#ifndef NO_LONG_LONG - long long v_long_long_member; -#endif - float v_float_member; - double v_double_member; -} v_struct1, *v_struct_ptr1; - -struct { - char v_char_member; - short v_short_member; - int v_int_member; - long v_long_member; -#ifndef NO_LONG_LONG - long long v_long_long_member; -#endif - float v_float_member; - double v_double_member; -} v_struct2, *v_struct_ptr2; - -/**** unions *******/ - -union t_union { - char v_char_member; - short v_short_member; - int v_int_member; - long v_long_member; -#ifndef NO_LONG_LONG - long long v_long_long_member; -#endif - float v_float_member; - double v_double_member; -} v_union, *v_union_ptr; - -union { - char v_char_member; - short v_short_member; - int v_int_member; - long v_long_member; -#ifndef NO_LONG_LONG - long long v_long_long_member; -#endif - float v_float_member; - double v_double_member; -} v_union2, *v_union_ptr2; - -/**** Some misc more complicated things *******/ - -struct outer_struct { - int outer_int; - struct inner_struct { - int inner_int; - long inner_long; - }inner_struct_instance; - union inner_union { - int inner_union_int; - long inner_union_long; - }inner_union_instance; - long outer_long; -} nested_su; - -/***********/ - -int main () -{ - /* Some linkers (e.g. on AIX) remove unreferenced variables, - so make sure to reference them. */ - v_char = 0; - v_signed_char = 1; - v_unsigned_char = 2; - - v_short = 3; - v_signed_short = 4; - v_unsigned_short = 5; - - v_int = 6; - v_signed_int = 7; - v_unsigned_int = 8; - - v_long = 9; - v_signed_long = 10; - v_unsigned_long = 11; - -#ifndef NO_LONG_LONG - v_long_long = 12; - v_signed_long_long = 13; - v_unsigned_long_long = 14; -#endif - - v_float = 100.0; - v_double = 200.0; - - - v_char_array[0] = v_char; - v_signed_char_array[0] = v_signed_char; - v_unsigned_char_array[0] = v_unsigned_char; - - v_short_array[0] = v_short; - v_signed_short_array[0] = v_signed_short; - v_unsigned_short_array[0] = v_unsigned_short; - - v_int_array[0] = v_int; - v_signed_int_array[0] = v_signed_int; - v_unsigned_int_array[0] = v_unsigned_int; - - v_long_array[0] = v_long; - v_signed_long_array[0] = v_signed_long; - v_unsigned_long_array[0] = v_unsigned_long; - -#ifndef NO_LONG_LONG - v_long_long_array[0] = v_long_long; - v_signed_long_long_array[0] = v_signed_long_long; - v_unsigned_long_long_array[0] = v_unsigned_long_long; -#endif - - v_float_array[0] = v_float; - v_double_array[0] = v_double; - - v_char_pointer = &v_char; - v_signed_char_pointer = &v_signed_char; - v_unsigned_char_pointer = &v_unsigned_char; - - v_short_pointer = &v_short; - v_signed_short_pointer = &v_signed_short; - v_unsigned_short_pointer = &v_unsigned_short; - - v_int_pointer = &v_int; - v_signed_int_pointer = &v_signed_int; - v_unsigned_int_pointer = &v_unsigned_int; - - v_long_pointer = &v_long; - v_signed_long_pointer = &v_signed_long; - v_unsigned_long_pointer = &v_unsigned_long; - -#ifndef NO_LONG_LONG - v_long_long_pointer = &v_long_long; - v_signed_long_long_pointer = &v_signed_long_long; - v_unsigned_long_long_pointer = &v_unsigned_long_long; -#endif - - v_float_pointer = &v_float; - v_double_pointer = &v_double; - - v_union2.v_short_member = v_union.v_short_member; - - v_struct1.v_char_member = 0; - v_struct2.v_char_member = 0; - - nested_su.outer_int = 0; - return 0; -} diff --git a/gdb/testsuite/gdb.base/ctf-whatis.exp b/gdb/testsuite/gdb.base/ctf-whatis.exp deleted file mode 100644 index 626aecb..0000000 --- a/gdb/testsuite/gdb.base/ctf-whatis.exp +++ /dev/null @@ -1,414 +0,0 @@ -# Copyright 2019 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 . - -# This file is a subset of whatis.exp written by Rob Savoye. (rob@cygnus.com) - -if [skip_ctf_tests] { - unsupported "no ctf debug format support" - return 0 -} - -standard_testfile .c - -# Using `-gt` generates full-fledged CTF debug information. -set opts "additional_flags=-gt" -if { [prepare_for_testing "failed to prepare" ${testfile} \ - [list $srcfile] [list $opts nowarnings]] } { - return 0 -} - -# Create and source the file that provides information about the compiler -# used to compile the test case. -if [get_compiler_info] { - return -1 -} - -# Start with a fresh gdb. - -clean_restart $binfile - -# 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*" - } -} - -# -# 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 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_struct_ptr1" \ - "type = struct t_struct \\*" - -gdb_test "whatis &v_struct_ptr1" \ - "type = struct t_struct \\*\\*" - -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_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 union t_union" \ - "type = union t_union" \ - "whatis named union using type name" - -gdb_test "whatis v_union_ptr" \ - "type = union t_union \\*" - -gdb_test "whatis &v_union_ptr" \ - "type = union t_union \\*\\*" - -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_ptr->v_char_member)" \ - "type = char \\*" - -gdb_test "whatis &(v_union_ptr2->v_char_member)" \ - "type = char \\*" - -# 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" - -# Using stabs we will mark these functions as prototyped. This -# is harmless but causes an extra VOID to be printed. -set void "(void|)" - -# 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" diff --git a/gdb/testsuite/gdb.base/whatis.exp b/gdb/testsuite/gdb.base/whatis.exp index 70836ca..1ef606e 100644 --- a/gdb/testsuite/gdb.base/whatis.exp +++ b/gdb/testsuite/gdb.base/whatis.exp @@ -27,21 +27,6 @@ standard_testfile .c -if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable $exec_opts] != "" } { - untested "failed to compile" - return -1 -} - -# Create and source the file that provides information about the compiler -# used to compile the test case. -if [get_compiler_info] { - return -1 -} - -# Start with a fresh gdb. - -clean_restart $binfile - # 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. @@ -55,531 +40,563 @@ } } -# -# 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. -# +# 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 -gdb_test "whatis v_char" \ - "type = (unsigned char|char)" \ - "whatis char" + set binfile [standard_output_file ${dir}/${testfile}] + if { [prepare_for_testing "failed to prepare" ${binfile} \ + [list $srcfile] $options] } { + return 0 + } -gdb_test "whatis v_signed_char" \ - "type = (signed char|char)" \ - "whatis signed char" + clean_restart ${binfile} -gdb_test "whatis v_unsigned_char" \ - "type = unsigned char" \ - "whatis unsigned char" + # + # 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_short" \ - "type = (short|short int)" \ - "whatis short" + gdb_test "whatis v_char" \ + "type = (unsigned char|char)" \ + "whatis char" -gdb_test "whatis v_signed_short" \ - "type = (short|short int|signed short|signed short int)" \ - "whatis signed short" + gdb_test "whatis v_signed_char" \ + "type = (signed char|char)" \ + "whatis signed char" -gdb_test "whatis v_unsigned_short" \ - "type = (unsigned short|short unsigned int)" \ - "whatis unsigned short" + gdb_test "whatis v_unsigned_char" \ + "type = unsigned char" \ + "whatis unsigned char" -gdb_test "whatis v_int" \ - "type = int" \ - "whatis int" + gdb_test "whatis v_short" \ + "type = (short|short int)" \ + "whatis short" -gdb_test "whatis v_signed_int" \ - "type = (signed |)int" \ - "whatis signed int" + gdb_test "whatis v_signed_short" \ + "type = (short|short int|signed short|signed short int)" \ + "whatis signed short" -gdb_test "whatis v_unsigned_int" \ - "type = unsigned int" \ - "whatis unsigned int" + gdb_test "whatis v_unsigned_short" \ + "type = (unsigned short|short unsigned int)" \ + "whatis unsigned short" -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" + gdb_test "whatis v_int" \ + "type = int" \ + "whatis 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_signed_long" \ - "type = (signed |)(long|long int)" \ - "whatis signed long" + gdb_test "whatis v_signed_int" \ + "type = (signed |)int" \ + "whatis signed int" -setup_xfail_on_long_vs_int -gdb_test "whatis v_unsigned_long" \ - "type = (unsigned long|long unsigned int)" \ - "whatis unsigned long" + 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" -} + 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_float" \ + "type = float" \ + "whatis float" -gdb_test "whatis v_double" \ - "type = double" \ - "whatis double" + 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" + # 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_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_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_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_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_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_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_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" + 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" + # 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_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\\\]" \ + gdb_test "whatis v_unsigned_long_array" \ + "type = (unsigned (int|long|long int)|long unsigned int) \\\[2\\\]" \ "whatis unsigned long array" -} -gdb_test "whatis v_float_array" \ - "type = float \\\[2\\\]" \ - "whatis float 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_double_array" \ - "type = double \\\[2\\\]" \ - "whatis double 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 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" + # test whatis command with structure types -gdb_test "whatis v_signed_char_pointer" \ - "type = (unsigned |signed |)char \\*" \ - "whatis signed char pointer" + # 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 v_unsigned_char_pointer" \ - "type = unsigned char \\*" \ - "whatis unsigned char pointer" + gdb_test "whatis struct t_struct" \ + "type = struct t_struct" \ + "whatis named structure using type name" -gdb_test "whatis v_short_pointer" \ - "type = (short|short int) \\*" \ - "whatis short pointer" + gdb_test "whatis struct t_struct *" \ + "type = struct t_struct \\*" \ + "whatis named structure using type name and pointer" -gdb_test "whatis v_signed_short_pointer" \ - "type = (signed |)(short|short int) \\*" \ - "whatis signed short pointer" + gdb_test "whatis struct t_struct &" \ + "type = struct t_struct &" \ + "whatis named structure using type name and reference" + } -gdb_test "whatis v_unsigned_short_pointer" \ - "type = (unsigned short|short unsigned int) \\*" \ - "whatis unsigned short pointer" + # Now with an expression argument. -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" \ + gdb_test "whatis v_struct1" \ "type = struct t_struct" \ - "whatis named structure using type name" + "whatis named structure" - gdb_test "whatis struct t_struct *" \ - "type = struct t_struct \\*" \ - "whatis named structure using type name and pointer" + gdb_test "whatis v_struct2" \ + "type = struct \{\.\.\.\}" \ + "whatis unnamed structure" - gdb_test "whatis struct t_struct &" \ - "type = struct t_struct &" \ - "whatis named structure using type name and reference" + 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" } -# 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 \\*" - - -# 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" +# 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"}} } -# 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" +# Setup and run the test for each debug format. +foreach testspec $specs { + set prefix [lindex $testspec 0] + set opts [lindex $testspec 1] -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" - -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" + with_test_prefix $prefix { + remote_exec host "mkdir -p [standard_output_file ${prefix}]" + do_test $prefix $opts + } +}