[RFA] New test for Harvardized cast expressions.

[Michael Snyder <msnyder at cygnus dot com>]

This is a test to go along with my submission extending the 
cast expression language to allow a cast to be qualified by
address space (code or data).

This test shares the same C source file (cvexpr.c) as the test
for const and volatile cast expressions (recently submitted as well).

For convenience, I will attach that file to this submission.

2001-11-14  Michael Snyder  <msnyder@redhat.com>

	* gdb.base/code-exprs.exp: New file.  Tests use of the "@code"
	qualifier in a type cast expression, to designate an address
	in the instruction space (Harvard architecture).

#   Copyright (C) 2001 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 2 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, write to the Free Software
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  

# Please email any bugs, comments, and/or additions to this file to:
# bug-gdb@prep.ai.mit.edu

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

# This file is part of the gdb testsuite
# Tests for type expressions using the new "@code" and "@data" modifiers.

if $tracelevel then {
        strace $tracelevel
        }

#
# test running programs
#
set prms_id 0
set bug_id 0

set testfile "cvexpr"
set srcfile ${testfile}.c
set binfile ${objdir}/${subdir}/${testfile}

if  { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
     gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail."
}

gdb_exit
gdb_start
gdb_reinitialize_dir $srcdir/$subdir
gdb_load ${binfile}

if [target_info exists gdb_stub] {
    gdb_step_for_stub;
}

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

set ws  "\[ \t\]*"

#
# Test casting a scalar to const
#

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

#
# Test casting a scalar to @data
#

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

#
# Now put the '@code' and '@data' keywords after the base type.
#

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

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

#
# enums
#

gdb_test "whatis (@code enum misordered) v_misordered" \
	"type = @code enum misordered" \
	"(@code enum misordered)"
gdb_test "whatis (enum misordered @code) v_misordered" \
	"type = @code enum misordered" \
	"(enum misordered @code)"
gdb_test "whatis (@data enum misordered) v_misordered" \
	"type = @data enum misordered" \
	"(@data enum misordered)"
gdb_test "whatis (enum misordered @data) v_misordered" \
	"type = @data enum misordered" \
	"(enum misordered @data)"

# 
# Pointers
#

gdb_test "whatis (@code int *) v_int_pointer" \
	"type = @code int${ws}\\*" \
	"(@code int *)"
gdb_test "whatis (int @code *) v_int_pointer" \
	"type = @code int${ws}\\*" \
	"(int @code *)"
gdb_test "whatis (int * @code) v_int_pointer" \
	"type = int \\*${ws}@code" \
	"(int * @code)"
gdb_test "whatis (@code int * @code) v_int_pointer" \
	"type = @code int${ws}\\*${ws}@code" \
	"(@code int * @code)"
gdb_test "whatis (int @code * @code) v_int_pointer" \
	"type = @code int${ws}\\*${ws}@code" \
	"(int @code * @code)"

gdb_test "whatis (@code int **) v_int_pointer_pointer" \
	"type = @code int${ws}\\*${ws}\\*" \
	"(@code int **)"
gdb_test "whatis (int @code **) v_int_pointer_pointer" \
	"type = @code int${ws}\\*${ws}\\*" \
	"(int @code **)"
gdb_test "whatis (int ** @code) v_int_pointer_pointer" \
	"type = int \\*${ws}\\*${ws}@code" \
	"(int ** @code)"
gdb_test "whatis (@code int * @code *) v_int_pointer_pointer" \
	"type = @code int${ws}\\*${ws}@code${ws}\\*" \
	"(@code int * @code *)"
gdb_test "whatis (int @code * @code *) v_int_pointer_pointer" \
	"type = @code int${ws}\\*${ws}@code${ws}\\*" \
	"(int @code * @code *)"
gdb_test "whatis (@code int * @code * @code) v_int_pointer_pointer" \
	"type = @code int${ws}\\*${ws}@code${ws}\\*${ws}@code" \
	"(@code int * @code * @code)"
gdb_test "whatis (int @code * @code * @code) v_int_pointer_pointer" \
	"type = @code int${ws}\\*${ws}@code${ws}\\*${ws}@code" \
	"(int @code * @code * @code)"

#
# Arrays TODO
#

#
# Pointers to arrays, arrays of pointers TODO
#

#
# Structs and Unions
#

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

#
# Function pointers TODO
#


/* Copyright (C) 2001 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 2 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, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

   Please email any bugs, comments, and/or additions to this file to:
   bug-gdb@prep.ai.mit.edu  */


/*
 * Initial set of typed variables borrowed from ptype.c
 */

#if !defined (__STDC__) && !defined (_AIX)
#define signed  /**/
#endif

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;

long long	   v_long_long;
signed long long   v_signed_long_long;
unsigned long long v_unsigned_long_long;

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];

float		v_float_array[2];
double		v_double_array[2];

/* PR 3742 */
typedef char t_char_array[];

/**** pointers *******/

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;

float		*v_float_pointer;
double		*v_double_pointer;

char		**v_char_pointer_pointer;
signed char	**v_signed_char_pointer_pointer;
unsigned char	**v_unsigned_char_pointer_pointer;

short		**v_short_pointer_pointer;
signed short	**v_signed_short_pointer_pointer;
unsigned short	**v_unsigned_short_pointer_pointer;

int		**v_int_pointer_pointer;
signed int	**v_signed_int_pointer_pointer;
unsigned int	**v_unsigned_int_pointer_pointer;

long		**v_long_pointer_pointer;
signed long	**v_signed_long_pointer_pointer;
unsigned long	**v_unsigned_long_pointer_pointer;

float		**v_float_pointer_pointer;
double		**v_double_pointer_pointer;

/**** pointers to arrays, arrays of pointers *******/

char		*v_char_array_pointer[2];
signed char	*v_signed_char_array_pointer[2];
unsigned char	*v_unsigned_char_array_pointer[2];

short		*v_short_array_pointer[2];
signed short	*v_signed_short_array_pointer[2];
unsigned short	*v_unsigned_short_array_pointer[2];

int		*v_int_array_pointer[2];
signed int	*v_signed_int_array_pointer[2];
unsigned int	*v_unsigned_int_array_pointer[2];

long		*v_long_array_pointer[2];
signed long	*v_signed_long_array_pointer[2];
unsigned long	*v_unsigned_long_array_pointer[2];

float		*v_float_array_pointer[2];
double		*v_double_array_pointer[2];

char		(*v_char_pointer_array)[2];
signed char	(*v_signed_char_pointer_array)[2];
unsigned char	(*v_unsigned_char_pointer_array)[2];

short		(*v_short_pointer_array)[2];
signed short	(*v_signed_short_pointer_array)[2];
unsigned short	(*v_unsigned_short_pointer_array)[2];

int		(*v_int_pointer_array)[2];
signed int	(*v_signed_int_pointer_array)[2];
unsigned int	(*v_unsigned_int_pointer_array)[2];

long		(*v_long_pointer_array)[2];
signed long	(*v_signed_long_pointer_array)[2];
unsigned long	(*v_unsigned_long_pointer_array)[2];

float		(*v_float_pointer_array)[2];
double		(*v_double_pointer_array)[2];


/**** structs *******/

struct t_struct {
    char	v_char_member;
    short	v_short_member;
    int		v_int_member;
    long	v_long_member;
    float	v_float_member;
    double	v_double_member;
} v_struct1;

struct t_struct *v_t_struct_p;

struct {
    char	v_char_member;
    short	v_short_member;
    int		v_int_member;
    long	v_long_member;
    float	v_float_member;
    double	v_double_member;
} v_struct2;

/* typedef'd struct without a tag.  */
typedef struct {
  double v_double_member;
  int v_int_member;
} t_struct3;
/* GCC seems to want a variable of this type, or else it won't put out
   a symbol.  */
t_struct3 v_struct3;

/**** unions *******/

union t_union {
    char	v_char_member;
    short	v_short_member;
    int		v_int_member;
    long	v_long_member;
    float	v_float_member;
    double	v_double_member;
} v_union;

union {
    char	v_char_member;
    short	v_short_member;
    int		v_int_member;
    long	v_long_member;
    float	v_float_member;
    double	v_double_member;
} v_union2;

/* typedef'd union without a tag.  */
typedef union {
  double v_double_member;
  int v_int_member;
} t_union3;
/* GCC seems to want a variable of this type, or else it won't put out
   a symbol.  */
t_union3 v_union3;

/**** Enumerations *******/

enum 
/* Work around the bug for compilers which don't put out the right stabs.  */
#if __GNUC__ < 2 && !defined (_AIX)
primary1_tag
#endif
{red1, green1, blue1} primary1;

enum {red, green, blue} primary;
enum colors {yellow, purple, pink} nonprimary;

enum {chevy, ford} clunker;
enum cars {bmw, porsche} sportscar;

#undef FALSE
#undef TRUE
typedef enum {FALSE, TRUE} boolean;
boolean v_boolean;
/*note: aCC has bool type predefined with 'false' and 'true'*/
typedef enum bvals {my_false, my_true} boolean2;
boolean2 v_boolean2;

enum misordered {two = 2, one = 1, zero = 0, three = 3};

/* Seems like we need a variable of this type to get the type to be put
   in the executable, at least for AIX xlc.  */
enum misordered v_misordered = three;

/**** Function pointers *******/

char		(*v_char_func) (int, int*);
signed char	(*v_signed_char_func) (int, int*);
unsigned char	(*v_unsigned_char_func) (int, int*);

short		(*v_short_func) (int, int*);
signed short	(*v_signed_short_func) (int, int*);
unsigned short	(*v_unsigned_short_func) (int, int*);

int		(*v_int_func) (int, int*);
signed int	(*v_signed_int_func) (int, int*);
unsigned int	(*v_unsigned_int_func) (int, int*);

long		(*v_long_func) (int, int*);
signed long	(*v_signed_long_func) (int, int*);
unsigned long	(*v_unsigned_long_func) (int, int*);

long long		(*v_long_long_func) (int, int*);
signed long long	(*v_signed_long_long_func) (int, int*);
unsigned long long	(*v_unsigned_long_long_func) (int, int*);

float		(*v_float_func) (int, int*);
double		(*v_double_func) (int, int*);



int main ()
{
}