gdb/testsuite/gdb.base/cvexpr.exp

#   Copyright (C) 2001-2025 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/>.

# Written by Michael Snyder, Red Hat, Inc., 9/20/2001

# This file is part of the gdb testsuite
# Tests for type expressions using const and volatile keywords.

standard_testfile .c

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

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

    clean_restart
    gdb_test_no_output "set always-read-ctf on"
    gdb_load $binfile

    gdb_test_no_output "set print sevenbit-strings"
    gdb_test_no_output "set print address off"
    gdb_test_no_output "set width 0"

    set ws  "\[ \t\]*"

    #
    # Test casting a scalar to const
    #

    gdb_test "whatis (const char) v_char" \
	"type = const char" \
	"cast to const char"
    gdb_test "whatis (const signed char) v_signed_char" \
	"type = const signed char" \
	"cast to const signed char"
    gdb_test "whatis (const unsigned char) v_unsigned_char" \
	"type = const (unsigned char|char)" \
	"cast to const unsigned char"
    gdb_test "whatis (const short) v_short" \
	"type = const (short|short int)" \
	"cast to const short"
    gdb_test "whatis (const signed short) v_signed_short" \
	"type = const (short|short int|signed short|signed short int)" \
	"cast to const signed short"
    gdb_test "whatis (const unsigned short) v_unsigned_short" \
	"type = const (unsigned short|short unsigned int)" \
	"cast to const unsigned short"
    gdb_test "whatis (const int) v_int" \
	"type = const int" \
	"cast to const int"
    gdb_test "whatis (const signed int) v_signed_int" \
	"type = const (signed int|int)" \
	"cast to const signed int"
    gdb_test "whatis (const unsigned int) v_unsigned_int" \
	"type = const unsigned int" \
	"cast to const unsigned int"
    gdb_test "whatis (const long) v_long" \
	"type = const (long|long int)" \
	"cast to const long"
    gdb_test "whatis (const signed long) v_signed_long" \
	"type = const (signed |)long( int|)" \
	"cast to const signed long"
    gdb_test "whatis (const unsigned long) v_unsigned_long" \
	"type = const (unsigned long|long unsigned int)" \
	"cast to const unsigned long"
    gdb_test "whatis (const long long) v_long_long" \
	"type = const long long( int|)" \
	"cast to const long long"
    gdb_test "whatis (const signed long long) v_signed_long_long" \
	"type = const (signed |)long long( int|)" \
	"cast to const signed long long"
    gdb_test "whatis (const unsigned long long) v_unsigned_long_long" \
	"type = const (unsigned long long|long long unsigned int)" \
	"cast to const unsigned long long"
    gdb_test "whatis (const float) v_float" \
	"type = const float" \
	"cast to const float"
    gdb_test "whatis (const double) v_double" \
	"type = const double" \
	"cast to const double"

    #
    # Test casting a scalar to volatile
    #

    gdb_test "whatis (volatile char) v_char" \
	"type = volatile char" \
	"cast to volatile char"
    gdb_test "whatis (volatile signed char) v_signed_char" \
	"type = volatile signed char" \
	"cast to volatile signed char"
    gdb_test "whatis (volatile unsigned char) v_unsigned_char" \
	"type = volatile (unsigned char|char)" \
	"cast to volatile unsigned char"
    gdb_test "whatis (volatile short) v_short" \
	"type = volatile (short|short int)" \
	"cast to volatile short"
    gdb_test "whatis (volatile signed short) v_signed_short" \
	"type = volatile (short|short int|signed short|signed short int)" \
	"cast to volatile signed short"
    gdb_test "whatis (volatile unsigned short) v_unsigned_short" \
	"type = volatile (unsigned short|short unsigned int)" \
	"cast to volatile unsigned short"
    gdb_test "whatis (volatile int) v_int" \
	"type = volatile int" \
	"cast to volatile int"
    gdb_test "whatis (volatile signed int) v_signed_int" \
	"type = volatile (signed int|int)" \
	"cast to volatile signed int"
    gdb_test "whatis (volatile unsigned int) v_unsigned_int" \
	"type = volatile unsigned int" \
	"cast to volatile unsigned int"
    gdb_test "whatis (volatile long) v_long" \
	"type = volatile (long|long int)" \
	"cast to volatile long"
    gdb_test "whatis (volatile signed long) v_signed_long" \
	"type = volatile (signed |)long( int|)" \
	"cast to volatile signed long"
    gdb_test "whatis (volatile unsigned long) v_unsigned_long" \
	"type = volatile (unsigned long|long unsigned int)" \
	"cast to volatile unsigned long"
    gdb_test "whatis (volatile long long) v_long_long" \
	"type = volatile long long( int|)" \
	"cast to volatile long long"
    gdb_test "whatis (volatile signed long long) v_signed_long_long" \
	"type = volatile (signed |)long long( int|)" \
	"cast to volatile signed long long"
    gdb_test "whatis (volatile unsigned long long) v_unsigned_long_long" \
	"type = volatile (unsigned long long|long long unsigned int)" \
	"cast to volatile unsigned long long"
    gdb_test "whatis (volatile float) v_float" \
	"type = volatile float" \
	"cast to volatile float"
    gdb_test "whatis (volatile double) v_double" \
	"type = volatile double" \
	"cast to volatile double"

    #
    # Combine const and volatile
    #

    gdb_test "whatis (const volatile int) v_int" \
	"type = const volatile int" \
	"cast to const volatile int"
    gdb_test "whatis (volatile const int) v_int" \
	"type = const volatile int" \
	"cast to volatile const int"
    gdb_test "whatis (const int volatile) v_int" \
	"type = const volatile int" \
	"cast to const int volatile"
    gdb_test "whatis (volatile int const) v_int" \
	"type = const volatile int" \
	"cast to volatile int const"
    gdb_test "whatis (int const volatile) v_int" \
	"type = const volatile int" \
	"cast to int const volatile"
    gdb_test "whatis (int volatile const) v_int" \
	"type = const volatile int" \
	"cast to int volatile const"

    gdb_test "whatis (const volatile int *) v_int_pointer" \
	"type = const volatile int${ws}\\*" \
	"cast to const volatile int *"
    gdb_test "whatis (volatile const int *) v_int_pointer" \
	"type = const volatile int${ws}\\*" \
	"cast to volatile const int *"
    gdb_test "whatis (const int volatile *) v_int_pointer" \
	"type = const volatile int${ws}\\*" \
	"cast to const int volatile *"
    gdb_test "whatis (volatile int const *) v_int_pointer" \
	"type = const volatile int${ws}\\*" \
	"cast to volatile int const *"
    gdb_test "whatis (int const volatile *) v_int_pointer" \
	"type = const volatile int${ws}\\*" \
	"cast to int const volatile *"
    gdb_test "whatis (int volatile const *) v_int_pointer" \
	"type = const volatile int${ws}\\*" \
	"cast to int volatile const *"
    gdb_test "whatis (int * const volatile) v_int_pointer" \
	"type = int${ws}\\*${ws}const volatile" \
	"cast to int * const volatile"
    gdb_test "whatis (int * volatile const) v_int_pointer" \
	"type = int${ws}\\*${ws}const volatile" \
	"cast to int * volatile const"


    #
    # Put 'signed' and 'unsigned' before const/volatile
    #

    #gdb_test "whatis (signed const char) v_signed_char" \
	#	"type = const char" \
	#	"cast to signed const char"
    #gdb_test "whatis (unsigned const char) v_unsigned_char" \
	#	"type = const (unsigned char|char)" \
	#	"cast to unsigned const char"
    #gdb_test "whatis (signed const short) v_signed_short" \
	#	"type = const (short|short int|signed short|signed short int)" \
	#	"cast to signed const short"
    #gdb_test "whatis (unsigned const short) v_unsigned_short" \
	#	"type = const (unsigned short|short unsigned int)" \
	#	"cast to unsigned const short"
    #gdb_test "whatis (signed const int) v_signed_int" \
	#	"type = const (signed int|int)" \
	#	"cast to signed const int"
    #gdb_test "whatis (unsigned const int) v_unsigned_int" \
	#	"type = const unsigned int" \
	#	"cast to unsigned const int"
    #gdb_test "whatis (signed const long) v_signed_long" \
	#	"type = const (signed |)long( int|)" \
	#	"cast to signed const long"
    #gdb_test "whatis (unsigned const long) v_unsigned_long" \
	#	"type = const (unsigned long|long unsigned int)" \
	#	"cast to unsigned const long"
    #gdb_test "whatis (signed const long long) v_signed_long_long" \
	#	"type = const (signed |)long long( int|)" \
	#	"cast to signed const long long"
    #gdb_test "whatis (unsigned const long long) v_unsigned_long_long" \
	#	"type = const (unsigned long long|long long unsigned int)" \
	#	"cast to const unsigned long long"

    #gdb_test "whatis (signed volatile char) v_signed_char" \
	#	"type = volatile char" \
	#	"cast to signed volatile char"
    #gdb_test "whatis (unsigned volatile char) v_unsigned_char" \
	#	"type = volatile (unsigned char|char)" \
	#	"cast to unsigned volatile char"
    #gdb_test "whatis (signed volatile short) v_signed_short" \
	#	"type = volatile (short|short int|signed short|signed short int)" \
	#	"cast to signed volatile short"
    #gdb_test "whatis (unsigned volatile short) v_unsigned_short" \
	#	"type = volatile (unsigned short|short unsigned int)" \
	#	"cast to unsigned volatile short"
    #gdb_test "whatis (signed volatile int) v_signed_int" \
	#	"type = volatile (signed int|int)" \
	#	"cast to signed volatile int"
    #gdb_test "whatis (unsigned volatile int) v_unsigned_int" \
	#	"type = volatile unsigned int" \
	#	"cast to unsigned volatile int"
    #gdb_test "whatis (signed volatile long) v_signed_long" \
	#	"type = volatile (signed |)long( int|)" \
	#	"cast to signed volatile long"
    #gdb_test "whatis (unsigned volatile long) v_unsigned_long" \
	#	"type = volatile (unsigned long|long unsigned int)" \
	#	"cast to unsigned volatile long"
    #gdb_test "whatis (signed volatile long long) v_signed_long_long" \
	#	"type = volatile (signed |)long long( int|)" \
	#	"cast to signed volatile long long"
    #gdb_test "whatis (unsigned volatile long long) v_unsigned_long_long" \
	#	"type = volatile (unsigned long long|long long unsigned int)" \
	#	"cast to unsigned volatile long long"

    #
    # Now put the 'const' and 'volatile' keywords after the base type.
    #

    gdb_test "whatis (char const) v_char" \
	"type = const char" \
	"cast to char const"
    gdb_test "whatis (signed char const) v_signed_char" \
	"type = const signed char" \
	"cast to signed char const"
    gdb_test "whatis (unsigned char const) v_unsigned_char" \
	"type = const (unsigned char|char)" \
	"cast to unsigned char const"
    gdb_test "whatis (short const) v_short" \
	"type = const (short|short int)" \
	"cast to short const"
    gdb_test "whatis (signed short const) v_signed_short" \
	"type = const (short|short int|signed short|signed short int)" \
	"cast to signed short const"
    gdb_test "whatis (unsigned short const) v_unsigned_short" \
	"type = const (unsigned short|short unsigned int)" \
	"cast to unsigned short const"
    gdb_test "whatis (int const) v_int" \
	"type = const int" \
	"cast to int const"
    gdb_test "whatis (signed int const) v_signed_int" \
	"type = const (signed int|int)" \
	"cast to signed int const"
    gdb_test "whatis (unsigned int const) v_unsigned_int" \
	"type = const unsigned int" \
	"cast to unsigned int const"
    gdb_test "whatis (long const) v_long" \
	"type = const (long|long int)" \
	"cast to long const"
    gdb_test "whatis (signed long const) v_signed_long" \
	"type = const (signed |)long( int|)" \
	"cast to signed long const"
    gdb_test "whatis (unsigned long const) v_unsigned_long" \
	"type = const (unsigned long|long unsigned int)" \
	"cast to unsigned long const"
    gdb_test "whatis (long long const) v_long_long" \
	"type = const long long( int|)" \
	"cast to long long const"
    gdb_test "whatis (signed long long const) v_signed_long_long" \
	"type = const (signed |)long long( int|)" \
	"cast to signed long long const"
    gdb_test "whatis (unsigned long long const) v_unsigned_long_long" \
	"type = const (unsigned long long|long long unsigned int)" \
	"cast to unsigned long long const"
    gdb_test "whatis (float const) v_float" \
	"type = const float" \
	"cast to float const"
    gdb_test "whatis (double const) v_double" \
	"type = const double" \
	"cast to double const"

    gdb_test "whatis (char volatile) v_char" \
	"type = volatile char" \
	"cast to char volatile"
    gdb_test "whatis (signed char volatile) v_signed_char" \
	"type = volatile signed char" \
	"cast to signed char volatile"
    gdb_test "whatis (unsigned char volatile) v_unsigned_char" \
	"type = volatile (unsigned char|char)" \
	"cast to unsigned char volatile"
    gdb_test "whatis (short volatile) v_short" \
	"type = volatile (short|short int)" \
	"cast to short volatile"
    gdb_test "whatis (signed short volatile) v_signed_short" \
	"type = volatile (short|short int|signed short|signed short int)" \
	"cast to signed short volatile"
    gdb_test "whatis (unsigned short volatile) v_unsigned_short" \
	"type = volatile (unsigned short|short unsigned int)" \
	"cast to unsigned short volatile"
    gdb_test "whatis (int volatile) v_int" \
	"type = volatile int" \
	"cast to int volatile"
    gdb_test "whatis (signed int volatile) v_signed_int" \
	"type = volatile (signed int|int)" \
	"cast to signed int volatile"
    gdb_test "whatis (unsigned int volatile) v_unsigned_int" \
	"type = volatile unsigned int" \
	"cast to unsigned int volatile"
    gdb_test "whatis (long volatile) v_long" \
	"type = volatile (long|long int)" \
	"cast to long volatile"
    gdb_test "whatis (signed long volatile) v_signed_long" \
	"type = volatile (signed |)long( int|)" \
	"cast to signed long volatile"
    gdb_test "whatis (unsigned long volatile) v_unsigned_long" \
	"type = volatile (unsigned long|long unsigned int)" \
	"cast to unsigned long volatile"
    gdb_test "whatis (long long volatile) v_long_long" \
	"type = volatile long long( int|)" \
	"cast to long long volatile"
    gdb_test "whatis (signed long long volatile) v_signed_long_long" \
	"type = volatile (signed |)long long( int|)" \
	"cast to signed long long volatile"
    gdb_test "whatis (unsigned long long volatile) v_unsigned_long_long" \
	"type = volatile (unsigned long long|long long unsigned int)" \
	"cast to unsigned long long volatile"
    gdb_test "whatis (float volatile) v_float" \
	"type = volatile float" \
	"cast to float volatile"
    gdb_test "whatis (double volatile) v_double" \
	"type = volatile double" \
	"cast to double volatile"

    #
    # enums
    #

    gdb_test "whatis (const enum misordered) v_misordered" \
	"type = const enum misordered" \
	"cast to const enum misordered"
    gdb_test "whatis (enum misordered const) v_misordered" \
	"type = const enum misordered" \
	"cast to enum misordered const"
    gdb_test "whatis (volatile enum misordered) v_misordered" \
	"type = volatile enum misordered" \
	"cast to volatile enum misordered"
    gdb_test "whatis (enum misordered volatile) v_misordered" \
	"type = volatile enum misordered" \
	"cast to enum misordered volatile"

    #
    # Pointers
    #

    gdb_test "whatis (const int *) v_int_pointer" \
	"type = const int${ws}\\*" \
	"cast to const int *"
    gdb_test "whatis (int const *) v_int_pointer" \
	"type = const int${ws}\\*" \
	"cast to int const *"
    gdb_test "whatis (int * const) v_int_pointer" \
	"type = int \\*${ws}const" \
	"cast to int * const"
    gdb_test "whatis (const int * const) v_int_pointer" \
	"type = const int${ws}\\*${ws}const" \
	"cast to const int * const"
    gdb_test "whatis (int const * const) v_int_pointer" \
	"type = const int${ws}\\*${ws}const" \
	"cast to int const * const"

    gdb_test "whatis (const int **) v_int_pointer_pointer" \
	"type = const int${ws}\\*${ws}\\*" \
	"cast to const int **"
    gdb_test "whatis (int const **) v_int_pointer_pointer" \
	"type = const int${ws}\\*${ws}\\*" \
	"cast to int const **"
    gdb_test "whatis (int ** const) v_int_pointer_pointer" \
	"type = int \\*${ws}\\*${ws}const" \
	"cast to int ** const"
    gdb_test "whatis (const int * const *) v_int_pointer_pointer" \
	"type = const int${ws}\\*${ws}const${ws}\\*" \
	"cast to const int * const *"
    gdb_test "whatis (int const * const *) v_int_pointer_pointer" \
	"type = const int${ws}\\*${ws}const${ws}\\*" \
	"cast to int const * const *"
    gdb_test "whatis (const int * const * const) v_int_pointer_pointer" \
	"type = const int${ws}\\*${ws}const${ws}\\*${ws}const" \
	"cast to const int * const * const"
    gdb_test "whatis (int const * const * const) v_int_pointer_pointer" \
	"type = const int${ws}\\*${ws}const${ws}\\*${ws}const" \
	"cast to int const * const * const"

    #
    # Arrays TODO
    #

    #
    # Pointers to arrays, arrays of pointers TODO
    #

    #
    # Structs and Unions
    #

    gdb_test "whatis (const struct t_struct) v_struct1" \
	"type = const struct t_struct" \
	"cast to const struct t_struct"
    gdb_test "whatis (const union t_union) v_union" \
	"type = const union t_union" \
	"cast to const union t_union"
    gdb_test "whatis (struct t_struct const) v_struct1" \
	"type = const struct t_struct" \
	"cast to struct t_struct const"
    gdb_test "whatis (union t_union const) v_union" \
	"type = const union t_union" \
	"cast to union t_union const"
    gdb_test "whatis (const struct t_struct *) &v_struct1" \
	"type = const struct t_struct${ws}\\*" \
	"cast to const struct t_struct *"
    gdb_test "whatis (const union t_union *) &v_union" \
	"type = const union t_union${ws}\\*" \
	"cast to const union t_union *"
    gdb_test "whatis (struct t_struct const *) &v_struct1" \
	"type = const struct t_struct${ws}\\*" \
	"cast to struct t_struct const *"
    gdb_test "whatis (union t_union const *) &v_union" \
	"type = const union t_union${ws}\\*" \
	"cast to union t_union const *"
    gdb_test "whatis (struct t_struct * const) &v_struct1" \
	"type = struct t_struct${ws}\\*${ws}const" \
	"cast to struct t_struct * const"
    gdb_test "whatis (union t_union * const) &v_union" \
	"type = union t_union${ws}\\*${ws}const" \
	"cast to union t_union * const"
    gdb_test "whatis (const struct t_struct * const) &v_struct1" \
	"type = const struct t_struct${ws}\\*${ws}const" \
	"cast to const struct t_struct * const"
    gdb_test "whatis (const union t_union * const) &v_union" \
	"type = const union t_union${ws}\\*${ws}const" \
	"cast to const union t_union * const"
    gdb_test "whatis (struct t_struct const * const) &v_struct1" \
	"type = const struct t_struct${ws}\\*${ws}const" \
	"cast to struct t_struct const * const"
    gdb_test "whatis (union t_union const * const) &v_union" \
	"type = const union t_union${ws}\\*${ws}const" \
	"cast to union t_union const * const"

    #
    # Function pointers TODO
    #
}

set ctf_opts {}
lappend ctf_opts additional_flags=-gctf

# Build up the set of debug formats for which we will run this test.
set specs { {dwarf {debug}} }
if {[allow_ctf_tests]} {
    lappend specs [list ctf $ctf_opts]
}

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

# These tests don't rely on the debug format.
with_test_prefix nodebug {
    if { [prepare_for_testing "failed to prepare" $testfile $srcfile {nodebug}] } {
	return 0
    }

    gdb_test "ptype _Atomic int" "type = _Atomic int"
    gdb_test "ptype int * restrict" "type = int \\* restrict"

    # C++ does not have "restrict".
    gdb_test_no_output "set lang c++"
    with_test_prefix c++ {
	gdb_test "ptype int * restrict" "A syntax error in expression.*"

	# There is a GCC extension for __restrict__, though.
	gdb_test "ptype int * __restrict__" "type = int \\* __restrict__"
    }
}