MatCat.OpenSource/8sa1-binutils-gdb
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Removed as of the gdb-1999-07-12 snapshot.

Browse Source
This commit is contained in:
Jason Molenda 1999-07-12 11:23:01 +00:00
parent 43e526b9b4
commit 4476592ff9
2 changed files with 0 additions and 668 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

351
gdb/testsuite/gdb.base/callfuncs2.c
View File

@ -1,351 +0,0 @@
/* Support program for testing gdb's ability to call functions
in an inferior which doesn't itself call malloc, pass appropriate
arguments to those functions, and get the returned result. */
#ifdef NO_PROTOTYPES
#define PARAMS(paramlist) ()
#else
#define PARAMS(paramlist) paramlist
#endif
# include <string.h>
char char_val1 = 'a';
char char_val2 = 'b';
short short_val1 = 10;
short short_val2 = -23;
int int_val1 = 87;
int int_val2 = -26;
long long_val1 = 789;
long long_val2 = -321;
float float_val1 = 3.14159;
float float_val2 = -2.3765;
double double_val1 = 45.654;
double double_val2 = -67.66;
#define DELTA (0.001)
char *string_val1 = (char *)"string 1";
char *string_val2 = (char *)"string 2";
char char_array_val1[] = "carray 1";
char char_array_val2[] = "carray 2";
struct struct1 {
char c;
short s;
int i;
long l;
float f;
double d;
char a[4];
} struct_val1 = { 'x', 87, 76, 51, 2.1234, 9.876, "foo" };
/* Some functions that can be passed as arguments to other test
functions, or called directly. */
#ifdef PROTOTYPES
int add (int a, int b)
#else
int add (a, b) int a, b;
#endif
{
return (a + b);
}
#ifdef PROTOTYPES
int doubleit (int a)
#else
int doubleit (a)
int a;
#endif
{
return (a + a);
}
int (*func_val1) PARAMS((int,int)) = add;
int (*func_val2) PARAMS((int)) = doubleit;
/* An enumeration and functions that test for specific values. */
enum enumtype { enumval1, enumval2, enumval3 };
enum enumtype enum_val1 = enumval1;
enum enumtype enum_val2 = enumval2;
enum enumtype enum_val3 = enumval3;
#ifdef PROTOTYPES
int t_enum_value1 (enum enumtype enum_arg)
#else
t_enum_value1 (enum_arg)
enum enumtype enum_arg;
#endif
{
return (enum_arg == enum_val1);
}
#ifdef PROTOTYPES
int t_enum_value2 (enum enumtype enum_arg)
#else
t_enum_value2 (enum_arg)
enum enumtype enum_arg;
#endif
{
return (enum_arg == enum_val2);
}
#ifdef PROTOTYPES
int t_enum_value3 (enum enumtype enum_arg)
#else
t_enum_value3 (enum_arg)
enum enumtype enum_arg;
#endif
{
return (enum_arg == enum_val3);
}
/* A function that takes a vector of integers (along with an explicit
count) and returns their sum. */
#ifdef PROTOTYPES
int sum_args (int argc, int argv[])
#else
int sum_args (argc, argv)
int argc;
int argv[];
#endif
{
int sumval = 0;
int idx;
for (idx = 0; idx < argc; idx++)
{
sumval += argv[idx];
}
return (sumval);
}
/* Test that we can call functions that take structs and return
members from that struct */
#ifdef PROTOTYPES
char t_structs_c (struct struct1 tstruct) { return (tstruct.c); }
short t_structs_s (struct struct1 tstruct) { return (tstruct.s); }
int t_structs_i (struct struct1 tstruct) { return (tstruct.i); }
long t_structs_l (struct struct1 tstruct) { return (tstruct.l); }
float t_structs_f (struct struct1 tstruct) { return (tstruct.f); }
double t_structs_d (struct struct1 tstruct) { return (tstruct.d); }
char *t_structs_a (struct struct1 tstruct) { return (tstruct.a); }
#else
char t_structs_c (tstruct) struct struct1 tstruct; { return (tstruct.c); }
short t_structs_s (tstruct) struct struct1 tstruct; { return (tstruct.s); }
int t_structs_i (tstruct) struct struct1 tstruct; { return (tstruct.i); }
long t_structs_l (tstruct) struct struct1 tstruct; { return (tstruct.l); }
float t_structs_f (tstruct) struct struct1 tstruct; { return (tstruct.f); }
double t_structs_d (tstruct) struct struct1 tstruct; { return (tstruct.d); }
char *t_structs_a (tstruct) struct struct1 tstruct; { return (tstruct.a); }
#endif
/* Test that calling functions works if there are a lot of arguments. */
#ifdef PROTOTYPES
int sum10 (int i0, int i1, int i2, int i3, int i4, int i5, int i6, int i7, int i8, int i9)
#else
int
sum10 (i0, i1, i2, i3, i4, i5, i6, i7, i8, i9)
int i0, i1, i2, i3, i4, i5, i6, i7, i8, i9;
#endif
{
return i0 + i1 + i2 + i3 + i4 + i5 + i6 + i7 + i8 + i9;
}
/* Gotta have a main to be able to generate a linked, runnable
executable, and also provide a useful place to set a breakpoint. */
#ifdef PROTOTYPES
int main()
#else
main ()
#endif
{
#ifdef usestubs
set_debug_traps();
breakpoint();
#endif
t_structs_c(struct_val1);
return 0;
}
/* Functions that expect specific values to be passed and return
either 0 or 1, depending upon whether the values were
passed incorrectly or correctly, respectively. */
#ifdef PROTOTYPES
int t_char_values (char char_arg1, char char_arg2)
#else
int t_char_values (char_arg1, char_arg2)
char char_arg1, char_arg2;
#endif
{
return ((char_arg1 == char_val1) && (char_arg2 == char_val2));
}
int
#ifdef PROTOTYPES
t_small_values (char arg1, short arg2, int arg3, char arg4, short arg5,
char arg6, short arg7, int arg8, short arg9, short arg10)
#else
t_small_values (arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
char arg1;
short arg2;
int arg3;
char arg4;
short arg5;
char arg6;
short arg7;
int arg8;
short arg9;
short arg10;
#endif
{
return arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10;
}
#ifdef PROTOTYPES
int t_short_values (short short_arg1, short short_arg2)
#else
int t_short_values (short_arg1, short_arg2)
short short_arg1, short_arg2;
#endif
{
return ((short_arg1 == short_val1) && (short_arg2 == short_val2));
}
#ifdef PROTOTYPES
int t_int_values (int int_arg1, int int_arg2)
#else
int t_int_values (int_arg1, int_arg2)
int int_arg1, int_arg2;
#endif
{
return ((int_arg1 == int_val1) && (int_arg2 == int_val2));
}
#ifdef PROTOTYPES
int t_long_values (long long_arg1, long long_arg2)
#else
int t_long_values (long_arg1, long_arg2)
long long_arg1, long_arg2;
#endif
{
return ((long_arg1 == long_val1) && (long_arg2 == long_val2));
}
#ifdef PROTOTYPES
int t_float_values (float float_arg1, float float_arg2)
#else
int t_float_values (float_arg1, float_arg2)
float float_arg1, float_arg2;
#endif
{
return ((float_arg1 - float_val1) < DELTA
&& (float_arg1 - float_val1) > -DELTA
&& (float_arg2 - float_val2) < DELTA
&& (float_arg2 - float_val2) > -DELTA);
}
int
#ifdef PROTOTYPES
t_float_values2 (float float_arg1, float float_arg2)
#else
/* In this case we are just duplicating t_float_values, but that is the
easiest way to deal with either ANSI or non-ANSI. */
t_float_values2 (float_arg1, float_arg2)
float float_arg1, float_arg2;
#endif
{
return ((float_arg1 - float_val1) < DELTA
&& (float_arg1 - float_val1) > -DELTA
&& (float_arg2 - float_val2) < DELTA
&& (float_arg2 - float_val2) > -DELTA);
}
#ifdef PROTOTYPES
int t_double_values (double double_arg1, double double_arg2)
#else
int t_double_values (double_arg1, double_arg2)
double double_arg1, double_arg2;
#endif
{
return ((double_arg1 - double_val1) < DELTA
&& (double_arg1 - double_val1) > -DELTA
&& (double_arg2 - double_val2) < DELTA
&& (double_arg2 - double_val2) > -DELTA);
}
#ifdef PROTOTYPES
int t_string_values (char *string_arg1, char *string_arg2)
#else
int t_string_values (string_arg1, string_arg2)
char *string_arg1, *string_arg2;
#endif
{
return (!strcmp (string_arg1, string_val1) &&
!strcmp (string_arg2, string_val2));
}
#ifdef PROTOTYPES
int t_char_array_values (char char_array_arg1[], char char_array_arg2[])
#else
int t_char_array_values (char_array_arg1, char_array_arg2)
char char_array_arg1[], char_array_arg2[];
#endif
{
return (!strcmp (char_array_arg1, char_array_val1) &&
!strcmp (char_array_arg2, char_array_val2));
}
/* This used to simply compare the function pointer arguments with
known values for func_val1 and func_val2. Doing so is valid ANSI
code, but on some machines (RS6000, HPPA, others?) it may fail when
called directly by GDB.
In a nutshell, it's not possible for GDB to determine when the address
of a function or the address of the function's stub/trampoline should
be passed.
So, to avoid GDB lossage in the common case, we perform calls through the
various function pointers and compare the return values. For the HPPA
at least, this allows the common case to work.
If one wants to try something more complicated, pass the address of
a function accepting a "double" as one of its first 4 arguments. Call
that function indirectly through the function pointer. This would fail
on the HPPA. */
#ifdef PROTOTYPES
int t_func_values (int (*func_arg1)(int, int), int (*func_arg2)(int))
#else
int t_func_values (func_arg1, func_arg2)
int (*func_arg1) PARAMS ((int, int));
int (*func_arg2) PARAMS ((int));
#endif
{
return ((*func_arg1) (5,5) == (*func_val1) (5,5)
&& (*func_arg2) (6) == (*func_val2) (6));
}
#ifdef PROTOTYPES
int t_call_add (int (*func_arg1)(int, int), int a, int b)
#else
int t_call_add (func_arg1, a, b)
int (*func_arg1) PARAMS ((int, int));
int a, b;
#endif
{
return ((*func_arg1)(a, b));
}

317
gdb/testsuite/gdb.base/callfuncs2.exp
View File

@ -1,317 +0,0 @@
# Copyright (C) 1997, 1998 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
# This file was written by Fred Fish. (fnf@cygnus.com)
# SAME tests as in callfns.exp but here the inferior program does not call malloc.
if $tracelevel then {
strace $tracelevel
}
set prms_id 0
set bug_id 0
set testfile "callfuncs2"
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."
}
# Create and source the file that provides information about the compiler
# used to compile the test case.
if [get_compiler_info ${binfile}] {
return -1;
}
if {$hp_aCC_compiler} {
set prototypes 1
} else {
set prototypes 0
}
# The a29k can't call functions, so don't even bother with this test.
if [target_info exists gdb,cannot_call_functions] {
setup_xfail "*-*-*" 2416
fail "This target can not call functions"
continue
}
# Set the current language to C. This counts as a test. If it
# fails, then we skip the other tests.
proc set_lang_c {} {
global gdb_prompt
send_gdb "set language c\n"
gdb_expect {
-re ".*$gdb_prompt $" {}
timeout { fail "set language c (timeout)" ; return 0 }
}
send_gdb "show language\n"
gdb_expect {
-re ".* source language is \"c\".*$gdb_prompt $" {
pass "set language to \"c\""
return 1
}
-re ".*$gdb_prompt $" {
fail "setting language to \"c\""
return 0
}
timeout {
fail "can't show language (timeout)"
return 0
}
}
}
# FIXME: Before calling this proc, we should probably verify that
# we can call inferior functions and get a valid integral value
# returned.
# Note that it is OK to check for 0 or 1 as the returned values, because C
# specifies that the numeric value of a relational or logical expression
# (computed in the inferior) is 1 for true and 0 for false.
proc do_function_calls {} {
global prototypes
global gcc_compiled
# We need to up this because this can be really slow on some boards.
set timeout 60;
gdb_test "p t_char_values(0,0)" " = 0"
gdb_test "p t_char_values('a','b')" " = 1"
gdb_test "p t_char_values(char_val1,char_val2)" " = 1"
gdb_test "p t_char_values('a',char_val2)" " = 1"
gdb_test "p t_char_values(char_val1,'b')" " = 1"
gdb_test "p t_short_values(0,0)" " = 0"
gdb_test "p t_short_values(10,-23)" " = 1"
gdb_test "p t_short_values(short_val1,short_val2)" " = 1"
gdb_test "p t_short_values(10,short_val2)" " = 1"
gdb_test "p t_short_values(short_val1,-23)" " = 1"
gdb_test "p t_int_values(0,0)" " = 0"
gdb_test "p t_int_values(87,-26)" " = 1"
gdb_test "p t_int_values(int_val1,int_val2)" " = 1"
gdb_test "p t_int_values(87,int_val2)" " = 1"
gdb_test "p t_int_values(int_val1,-26)" " = 1"
gdb_test "p t_long_values(0,0)" " = 0"
gdb_test "p t_long_values(789,-321)" " = 1"
gdb_test "p t_long_values(long_val1,long_val2)" " = 1"
gdb_test "p t_long_values(789,long_val2)" " = 1"
gdb_test "p t_long_values(long_val1,-321)" " = 1"
if ![target_info exists gdb,skip_float_tests] {
gdb_test "p t_float_values(0.0,0.0)" " = 0"
# These next four tests fail on the mn10300.
# The first value is passed in regs, the other in memory.
# Gcc emits different stabs for the two parameters; the first is
# claimed to be a float, the second a double.
# dbxout.c in gcc claims this is the desired behavior.
setup_xfail "mn10300-*-*" "hppa*-*-*11*"
gdb_test "p t_float_values(3.14159,-2.3765)" " = 1"
setup_xfail "mn10300-*-*" "hppa*-*-*11*"
gdb_test "p t_float_values(float_val1,float_val2)" " = 1"
setup_xfail "mn10300-*-*" "hppa*-*-*11*"
gdb_test "p t_float_values(3.14159,float_val2)" " = 1"
setup_xfail "mn10300-*-*" "hppa*-*-*11*"
gdb_test "p t_float_values(float_val1,-2.3765)" " = 1"
# Test passing of arguments which might not be widened.
gdb_test "p t_float_values2(0.0,0.0)" " = 0"
# Although PR 5318 mentions SunOS specifically, this seems
# to be a generic problem on quite a few platforms.
if $prototypes then {
setup_xfail "sparc-*-*" "mips*-*-*" 5318
if {!$gcc_compiled} then {
setup_xfail "alpha-dec-osf2*" "i*86-*-sysv4*" 5318
}
}
gdb_test "p t_float_values2(3.14159,float_val2)" " = 1"
gdb_test "p t_small_values(1,2,3,4,5,6,7,8,9,10)" " = 55"
gdb_test "p t_double_values(0.0,0.0)" " = 0"
gdb_test "p t_double_values(45.654,-67.66)" " = 1"
gdb_test "p t_double_values(double_val1,double_val2)" " = 1"
gdb_test "p t_double_values(45.654,double_val2)" " = 1"
gdb_test "p t_double_values(double_val1,-67.66)" " = 1"
}
gdb_test "p t_string_values(string_val2,string_val1)" " = 0"
gdb_test "p t_string_values(string_val1,string_val2)" " = 1"
gdb_test "p t_string_values(\"string 1\",\"string 2\")" " = 1"
gdb_test "p t_string_values(\"string 1\",string_val2)" " = 1"
gdb_test "p t_string_values(string_val1,\"string 2\")" " = 1"
gdb_test "p t_char_array_values(char_array_val2,char_array_val1)" " = 0"
gdb_test "p t_char_array_values(char_array_val1,char_array_val2)" " = 1"
gdb_test "p t_char_array_values(\"carray 1\",\"carray 2\")" " = 1"
gdb_test "p t_char_array_values(\"carray 1\",char_array_val2)" " = 1"
gdb_test "p t_char_array_values(char_array_val1,\"carray 2\")" " = 1"
gdb_test "p doubleit(4)" " = 8"
gdb_test "p add(4,5)" " = 9"
gdb_test "p t_func_values(func_val2,func_val1)" " = 0"
gdb_test "p t_func_values(func_val1,func_val2)" " = 1"
# On the rs6000, we need to pass the address of the trampoline routine,
# not the address of add itself. I don't know how to go from add to
# the address of the trampoline. Similar problems exist on the HPPA,
# and in fact can present an unsolvable problem as the stubs may not
# even exist in the user's program. We've slightly recoded t_func_values
# to avoid such problems in the common case. This may or may not help
# the RS6000.
setup_xfail "rs6000*-*-*"
setup_xfail "powerpc*-*-*"
if {!$gcc_compiled && [istarget hppa*-*-hpux*]} then {
send_gdb "p t_func_values(add,func_val2)\n"
gdb_expect {
-re "You cannot.*ignored.*" {pass "p t_func_values(add,func_val2)"}
-re "Program received signal SIGBUS, Bus error.*" {
if [istarget hppa*-*-hpux*] {
pass "p t_func_values(add,func_val2)"
} else {
fail "p t_func_values(add,func_val2)"
}
}
}
} else {
gdb_test "p t_func_values(add,func_val2)" " = 1"
}
setup_xfail "rs6000*-*-*"
setup_xfail "powerpc*-*-*"
if {!$gcc_compiled && [istarget hppa*-*-hpux*]} then {
send_gdb "p t_func_values(func_val1,doubleit)\n"
gdb_expect {
-re "You cannot.*ignored.*" {pass "p t_func_values(func_val1,doubleit)"}
-re "Program received signal SIGBUS, Bus error.*" {
if [istarget hppa*-*-hpux*] {
pass "p t_func_values(func_val1,doubleit)"
} else {
fail "p t_func_values(func_val1,doubleit)"
}
}
}
} else {
gdb_test "p t_func_values(func_val1,doubleit)" " = 1"
}
gdb_test "p t_call_add(func_val1,3,4)" " = 7"
setup_xfail "rs6000*-*-*"
setup_xfail "powerpc*-*-*"
if {!$gcc_compiled && [istarget hppa*-*-hpux*]} then {
send_gdb "p t_call_add(add,3,4)\n"
gdb_expect {
-re "You cannot.*ignored.*" {pass "p t_call_add(add,3,4)"}
-re "Program received signal SIGBUS, Bus error.*" {
if [istarget hppa*-*-hpux*] {
pass "p t_call_add(add,3,4)"
} else {
fail "p t_call_add(add,3,4)"
}
}
}
} else {
gdb_test "p t_call_add(add,3,4)" " = 7"
}
gdb_test "p t_enum_value1(enumval1)" " = 1"
gdb_test "p t_enum_value1(enum_val1)" " = 1"
gdb_test "p t_enum_value1(enum_val2)" " = 0"
gdb_test "p t_enum_value2(enumval2)" " = 1"
gdb_test "p t_enum_value2(enum_val2)" " = 1"
gdb_test "p t_enum_value2(enum_val1)" " = 0"
gdb_test "p sum_args(1,{2})" " = 2"
gdb_test "p sum_args(2,{2,3})" " = 5"
gdb_test "p sum_args(3,{2,3,4})" " = 9"
gdb_test "p sum_args(4,{2,3,4,5})" " = 14"
gdb_test "p sum10 (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)" " = 55"
gdb_test "p t_structs_c(struct_val1)" "= 120 'x'" \
"call inferior func with struct - returns char"
gdb_test "p t_structs_s(struct_val1)" "= 87" \
"call inferior func with struct - returns short"
gdb_test "p t_structs_i(struct_val1)" "= 76" \
"call inferior func with struct - returns int"
gdb_test "p t_structs_l(struct_val1)" "= 51" \
"call inferior func with struct - returns long"
setup_xfail "i*86-*-*"
gdb_test "p t_structs_f(struct_val1)" "= 2.12.*" \
"call inferior func with struct - returns float"
setup_xfail "i*86-*-*"
gdb_test "p t_structs_d(struct_val1)" "= 9.87.*" \
"call inferior func with struct - returns double"
gdb_test "p t_structs_a(struct_val1)" "= (.unsigned char .. )?\"foo\"" \
"call inferior func with struct - returns char *"
}
# Start with a fresh gdb.
gdb_exit
gdb_start
gdb_reinitialize_dir $srcdir/$subdir
gdb_load ${binfile}
gdb_test "set print sevenbit-strings" ""
gdb_test "set print address off" ""
gdb_test "set width 0" ""
if { $hp_aCC_compiler } {
# Do not set language explicitly to 'C'. This will cause aCC
# tests to fail because promotion rules are different. Just let
# the language be set to the default.
if { ![runto_main] } {
gdb_suppress_tests;
}
gdb_test "set overload-resolution 0" ".*"
} else {
if { ![set_lang_c] } {
gdb_suppress_tests;
} else {
if { ![runto_main] } {
gdb_suppress_tests;
}
}
}
gdb_test "next" ".*"
do_function_calls
return 0