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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
|
#ifndef FLOAT
#define FLOAT double
#endif
/* Like fp-cmp-4.c, but test that the cmove patterns are correct. */
static FLOAT
test_isunordered(FLOAT x, FLOAT y, FLOAT a, FLOAT b)
{
return __builtin_isunordered(x, y) ? a : b;
}
static FLOAT
test_not_isunordered(FLOAT x, FLOAT y, FLOAT a, FLOAT b)
{
return !__builtin_isunordered(x, y) ? a : b;
}
static FLOAT
test_isless(FLOAT x, FLOAT y, FLOAT a, FLOAT b)
{
return __builtin_isless(x, y) ? a : b;
}
static FLOAT
test_not_isless(FLOAT x, FLOAT y, FLOAT a, FLOAT b)
{
return !__builtin_isless(x, y) ? a : b;
}
static FLOAT
test_islessequal(FLOAT x, FLOAT y, FLOAT a, FLOAT b)
{
return __builtin_islessequal(x, y) ? a : b;
}
static FLOAT
test_not_islessequal(FLOAT x, FLOAT y, FLOAT a, FLOAT b)
{
return !__builtin_islessequal(x, y) ? a : b;
}
static FLOAT
test_isgreater(FLOAT x, FLOAT y, FLOAT a, FLOAT b)
{
return __builtin_isgreater(x, y) ? a : b;
}
static FLOAT
test_not_isgreater(FLOAT x, FLOAT y, FLOAT a, FLOAT b)
{
return !__builtin_isgreater(x, y) ? a : b;
}
static FLOAT
test_isgreaterequal(FLOAT x, FLOAT y, FLOAT a, FLOAT b)
{
return __builtin_isgreaterequal(x, y) ? a : b;
}
static FLOAT
test_not_isgreaterequal(FLOAT x, FLOAT y, FLOAT a, FLOAT b)
{
return !__builtin_isgreaterequal(x, y) ? a : b;
}
static FLOAT
test_islessgreater(FLOAT x, FLOAT y, FLOAT a, FLOAT b)
{
return __builtin_islessgreater(x, y) ? a : b;
}
static FLOAT
test_not_islessgreater(FLOAT x, FLOAT y, FLOAT a, FLOAT b)
{
return !__builtin_islessgreater(x, y) ? a : b;
}
static void
one_test(FLOAT x, FLOAT y, int expected,
FLOAT (*pos) (FLOAT, FLOAT, FLOAT, FLOAT),
FLOAT (*neg) (FLOAT, FLOAT, FLOAT, FLOAT))
{
if (((*pos)(x, y, 1.0, 2.0) == 1.0) != expected)
abort ();
if (((*neg)(x, y, 3.0, 4.0) == 4.0) != expected)
abort ();
}
#define NAN (0.0 / 0.0)
#define INF (1.0 / 0.0)
int
main()
{
struct try
{
FLOAT x, y;
int result[6];
};
static struct try const data[] =
{
{ NAN, NAN, { 1, 0, 0, 0, 0, 0 } },
{ 0.0, NAN, { 1, 0, 0, 0, 0, 0 } },
{ NAN, 0.0, { 1, 0, 0, 0, 0, 0 } },
{ 0.0, 0.0, { 0, 0, 1, 0, 1, 0 } },
{ 1.0, 2.0, { 0, 1, 1, 0, 0, 1 } },
{ 2.0, 1.0, { 0, 0, 0, 1, 1, 1 } },
{ INF, 0.0, { 0, 0, 0, 1, 1, 1 } },
{ 1.0, INF, { 0, 1, 1, 0, 0, 1 } },
{ INF, INF, { 0, 0, 1, 0, 1, 0 } },
{ 0.0, -INF, { 0, 0, 0, 1, 1, 1 } },
{ -INF, 1.0, { 0, 1, 1, 0, 0, 1 } },
{ -INF, -INF, { 0, 0, 1, 0, 1, 0 } },
{ INF, -INF, { 0, 0, 0, 1, 1, 1 } },
{ -INF, INF, { 0, 1, 1, 0, 0, 1 } },
};
struct test
{
FLOAT (*pos)(FLOAT, FLOAT, FLOAT, FLOAT);
FLOAT (*neg)(FLOAT, FLOAT, FLOAT, FLOAT);
};
static struct test const tests[] =
{
{ test_isunordered, test_not_isunordered },
{ test_isless, test_not_isless },
{ test_islessequal, test_not_islessequal },
{ test_isgreater, test_not_isgreater },
{ test_isgreaterequal, test_not_isgreaterequal },
{ test_islessgreater, test_not_islessgreater }
};
const int n = sizeof(data) / sizeof(data[0]);
int i, j;
for (i = 0; i < n; ++i)
for (j = 0; j < 6; ++j)
one_test (data[i].x, data[i].y, data[i].result[j],
tests[j].pos, tests[j].neg);
exit (0);
}
|
