diff options
author | Stan Shebs <shebs@codesourcery.com> | 1994-06-07 01:57:15 +0000 |
---|---|---|
committer | Stan Shebs <shebs@codesourcery.com> | 1994-06-07 01:57:15 +0000 |
commit | ef44eed173353ff002da6fe92680e40068cd081f (patch) | |
tree | beeeaecb50227b8c1fe964debaf3c8f45bc9ac9a /gdb/testsuite/gdb.base/callfuncs.c | |
parent | 33268150cbbcc90ec13f5603d566537cf4cd569e (diff) | |
download | gdb-ef44eed173353ff002da6fe92680e40068cd081f.zip gdb-ef44eed173353ff002da6fe92680e40068cd081f.tar.gz gdb-ef44eed173353ff002da6fe92680e40068cd081f.tar.bz2 |
Reorganized GDB tests - base
Diffstat (limited to 'gdb/testsuite/gdb.base/callfuncs.c')
-rw-r--r-- | gdb/testsuite/gdb.base/callfuncs.c | 206 |
1 files changed, 206 insertions, 0 deletions
diff --git a/gdb/testsuite/gdb.base/callfuncs.c b/gdb/testsuite/gdb.base/callfuncs.c new file mode 100644 index 0000000..e59db08 --- /dev/null +++ b/gdb/testsuite/gdb.base/callfuncs.c @@ -0,0 +1,206 @@ +/* Support program for testing gdb's ability to call functions + in the inferior, pass appropriate arguments to those functions, + and get the returned result. */ + +#ifdef __STDC__ +#define PARAMS(paramlist) paramlist +#else +#define PARAMS(paramlist) () +#endif + +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 = "string 1"; +char *string_val2 = "string 2"; + +char char_array_val1[] = "carray 1"; +char char_array_val2[] = "carray 2"; + +struct struct1 { + int x; + long y; +} struct_val1 = { 76, 51 }; + +/* Some functions that can be passed as arguments to other test + functions, or called directly. */ + +int add (a, b) +int a, b; +{ + return (a + b); +} + +int doubleit (a) +int a; +{ + 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; + +t_enum_value1 (enum_arg) +enum enumtype enum_arg; +{ + return (enum_arg == enum_val1); +} + +t_enum_value2 (enum_arg) +enum enumtype enum_arg; +{ + return (enum_arg == enum_val2); +} + +t_enum_value3 (enum_arg) +enum enumtype enum_arg; +{ + return (enum_arg == enum_val3); +} + +/* A function that takes a vector of integers (along with an explicit + count) and returns their sum. */ + +int sum_args (argc, argv) +int argc; +int argv[]; +{ + int sumval = 0; + int idx; + + for (idx = 0; idx < argc; idx++) + { + sumval += argv[idx]; + } + return (sumval); +} + +/* Test that calling functions works if there are a lot of arguments. */ +int +sum10 (i0, i1, i2, i3, i4, i5, i6, i7, i8, i9) + int i0, i1, i2, i3, i4, i5, i6, i7, i8, i9; +{ + 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. */ + +main () +{ + malloc(1); +} + +/* 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. */ + +int t_char_values (char_arg1, char_arg2) +char char_arg1, char_arg2; +{ + return ((char_arg1 == char_val1) && (char_arg2 == char_val2)); +} + +int t_short_values (short_arg1, short_arg2) +short short_arg1, short_arg2; +{ + return ((short_arg1 == short_val1) && (short_arg2 == short_val2)); +} + +int t_int_values (int_arg1, int_arg2) +int int_arg1, int_arg2; +{ + return ((int_arg1 == int_val1) && (int_arg2 == int_val2)); +} + +int t_long_values (long_arg1, long_arg2) +long long_arg1, long_arg2; +{ + return ((long_arg1 == long_val1) && (long_arg2 == long_val2)); +} + +int t_float_values (float_arg1, float_arg2) +float float_arg1, float_arg2; +{ + return (((float_arg1 - float_val1) < DELTA) && + ((float_arg2 - float_val2) < DELTA)); +} + +int t_double_values (double_arg1, double_arg2) +double double_arg1, double_arg2; +{ + return (((double_arg1 - double_val1) < DELTA) && + ((double_arg2 - double_val2) < DELTA)); +} + +int t_string_values (string_arg1, string_arg2) +char *string_arg1, *string_arg2; +{ + return (!strcmp (string_arg1, string_val1) && + !strcmp (string_arg2, string_val2)); +} + +int t_char_array_values (char_array_arg1, char_array_arg2) +char char_array_arg1[], char_array_arg2[]; +{ + 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. */ + +int t_func_values (func_arg1, func_arg2) +int (*func_arg1) PARAMS ((int, int)); +int (*func_arg2) PARAMS ((int)); +{ + return ((*func_arg1) (5,5) == (*func_val1) (5,5) + && (*func_arg2) (6) == (*func_val2) (6)); +} + +int t_call_add (func_arg1, a, b) +int (*func_arg1) PARAMS ((int, int)); +int a, b; +{ + return ((*func_arg1)(a, b)); +} |