1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
|
/* This testcase is part of GDB, the GNU debugger.
Copyright 2008, 2009, 2010, 2011 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/>. */
/* Test gdb's "return" command in reverse. */
int void_test = 0;
int main_test = 0;
char char_returnval = '1';
short short_returnval = 1;
int int_returnval = 1;
long long_returnval = 1;
long long long_long_returnval = 1;
float float_returnval = 1;
double double_returnval = 1;
union {
char char_testval;
short short_testval;
int int_testval;
long long_testval;
long long long_long_testval;
float float_testval;
double double_testval;
char ffff[80];
} testval;
void void_func ()
{
void_test = 1; /* VOID FUNC */
}
char char_func ()
{
return char_returnval; /* CHAR FUNC */
}
short short_func ()
{
return short_returnval; /* SHORT FUNC */
}
int int_func ()
{
return int_returnval; /* INT FUNC */
}
long long_func ()
{
return long_returnval; /* LONG FUNC */
}
long long long_long_func ()
{
return long_long_returnval; /* LONG LONG FUNC */
}
float float_func ()
{
return float_returnval; /* FLOAT FUNC */
}
double double_func ()
{
return double_returnval; /* DOUBLE FUNC */
}
int main (int argc, char **argv)
{
char char_resultval;
short short_resultval;
int int_resultval;
long long_resultval;
long long long_long_resultval;
float float_resultval;
double double_resultval;
int i;
/* A "test load" that will insure that the function really returns
a ${type} (as opposed to just a truncated or part of a ${type}). */
for (i = 0; i < sizeof (testval.ffff); i++)
testval.ffff[i] = 0xff;
void_func (); /* call to void_func */
char_resultval = char_func (); /* void_checkpoint */
short_resultval = short_func (); /* char_checkpoint */
int_resultval = int_func (); /* short_checkpoint */
long_resultval = long_func (); /* int_checkpoint */
long_long_resultval = long_long_func (); /* long_checkpoint */
/* On machines using IEEE floating point, the test pattern of all
1-bits established above turns out to be a floating-point NaN
("Not a Number"). According to the IEEE rules, NaN's aren't even
equal to themselves. This can lead to stupid conversations with
GDB like:
(gdb) p testval.float_testval == testval.float_testval
$7 = 0
(gdb)
This is the correct answer, but it's not the sort of thing
return2.exp wants to see. So to make things work the way they
ought, we'll set aside the `union' cleverness and initialize the
test values explicitly here. These values have interesting bits
throughout the value, so we'll still detect truncated values. */
testval.float_testval = 2.7182818284590452354;/* long_long_checkpoint */
float_resultval = float_func ();
testval.double_testval = 3.14159265358979323846; /* float_checkpoint */
double_resultval = double_func ();
main_test = 1; /* double_checkpoint */
return 0;
} /* end of main */
|
