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
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
|
/* { dg-do run { target { fixed_point } } } */
/* { dg-options "-std=gnu99" } */
/* Check basic arithmetic ops for ARM fixed-point/saturating operation support.
Not target-independent since we make various assumptions about precision and
magnitudes of various types. */
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <stdfix.h>
#define TEST(TYPE, OP, NAME, SUFFIX) \
TYPE NAME##SUFFIX (TYPE A, TYPE B) \
{ \
return A OP B; \
}
#define VARIANTS(TYPE, OP, NAME) \
TEST (short TYPE, OP, NAME, _short); \
TEST (TYPE, OP, NAME, _regular); \
TEST (long TYPE, OP, NAME, _long); \
TEST (_Sat short TYPE, OP, NAME, _sat_short); \
TEST (_Sat TYPE, OP, NAME, _sat_regular); \
TEST (_Sat long TYPE, OP, NAME, _sat_long); \
TEST (unsigned short TYPE, OP, NAME, _uns_short); \
TEST (unsigned TYPE, OP, NAME, _uns_regular); \
TEST (unsigned long TYPE, OP, NAME, _uns_long); \
TEST (unsigned _Sat short TYPE, OP, NAME, _uns_sat_short); \
TEST (unsigned _Sat TYPE, OP, NAME, _uns_sat_regular); \
TEST (unsigned _Sat long TYPE, OP, NAME, _uns_sat_long)
VARIANTS (_Fract, +, plus_fract);
VARIANTS (_Accum, +, plus_accum);
VARIANTS (_Fract, -, minus_fract);
VARIANTS (_Accum, -, minus_accum);
VARIANTS (_Fract, *, mult_fract);
VARIANTS (_Accum, *, mult_accum);
VARIANTS (_Accum, /, div_accum);
/* Inputs for signed add, multiply fractional tests. */
short _Fract sf_a = 0.9hr;
short _Fract sf_b = -0.8hr;
_Fract f_a = 0.9r;
_Fract f_b = -0.8r;
long _Fract lf_a = 0.9lr;
long _Fract lf_b = -0.8lr;
/* Inputs for signed subtract fractional tests. */
short _Fract sf_c = 0.7hr;
short _Fract sf_d = 0.9hr;
_Fract f_c = 0.7r;
_Fract f_d = 0.9r;
long _Fract lf_c = 0.7lr;
long _Fract lf_d = 0.9lr;
/* Inputs for unsigned add, subtract, multiply fractional tests. */
unsigned short _Fract usf_a = 0.4uhr;
unsigned short _Fract usf_b = 0.3uhr;
unsigned _Fract uf_a = 0.4ur;
unsigned _Fract uf_b = 0.3ur;
unsigned long _Fract ulf_a = 0.4ulr;
unsigned long _Fract ulf_b = 0.3ulr;
/* Inputs for saturating signed add tests. */
short _Sat _Fract sf_e = 0.8hr;
short _Sat _Fract sf_f = 0.8hr;
_Sat _Fract f_e = 0.8r;
_Sat _Fract f_f = 0.8r;
long _Sat _Fract lf_e = 0.8r;
long _Sat _Fract lf_f = 0.8r;
short _Sat _Fract sf_g = -0.8hr;
short _Sat _Fract sf_h = -0.8hr;
_Sat _Fract f_g = -0.8r;
_Sat _Fract f_h = -0.8r;
long _Sat _Fract lf_g = -0.8r;
long _Sat _Fract lf_h = -0.8r;
/* Inputs for saturating unsigned subtract tests. */
unsigned short _Sat _Fract usf_c = 0.3uhr;
unsigned short _Sat _Fract usf_d = 0.4uhr;
unsigned _Sat _Fract uf_c = 0.3ur;
unsigned _Sat _Fract uf_d = 0.4ur;
unsigned long _Sat _Fract ulf_c = 0.3ulr;
unsigned long _Sat _Fract ulf_d = 0.4ulr;
/* Inputs for signed accumulator tests. */
short _Accum sa_a = 1.25hk;
short _Accum sa_b = -1.5hk;
_Accum a_a = 100.25k;
_Accum a_b = -100.5k;
long _Accum la_a = 1000.25lk;
long _Accum la_b = -1000.5lk;
/* Inputs for unsigned accumulator tests. */
unsigned short _Accum usa_a = 2.5uhk;
unsigned short _Accum usa_b = 1.75uhk;
unsigned _Accum ua_a = 255.5uk;
unsigned _Accum ua_b = 170.25uk;
unsigned long _Accum ula_a = 1550.5ulk;
unsigned long _Accum ula_b = 999.5ulk;
/* Inputs for signed saturating accumulator tests. */
short _Sat _Accum sa_c = 240.0hk;
short _Sat _Accum sa_d = 250.0hk;
short _Sat _Accum sa_e = -240.0hk;
short _Sat _Accum sa_f = -250.0hk;
short _Sat _Accum sa_g = 0.5hk;
_Sat _Accum a_c = 65000.0k;
_Sat _Accum a_d = 20000.0k;
_Sat _Accum a_e = -65000.0k;
_Sat _Accum a_f = -20000.0k;
_Sat _Accum a_g = 0.5k;
long _Sat _Accum la_c = 3472883712.0lk;
long _Sat _Accum la_d = 3456106496.0lk;
long _Sat _Accum la_e = -3472883712.0lk;
long _Sat _Accum la_f = -3456106496.0lk;
long _Sat _Accum la_g = 0.5lk;
/* Inputs for unsigned saturating accumulator tests. */
unsigned short _Sat _Accum usa_c = 250.0uhk;
unsigned short _Sat _Accum usa_d = 240.0uhk;
unsigned short _Sat _Accum usa_e = 0.5uhk;
unsigned _Sat _Accum ua_c = 65000.0uk;
unsigned _Sat _Accum ua_d = 20000.0uk;
unsigned _Sat _Accum ua_e = 0.5uk;
unsigned long _Sat _Accum ula_c = 3472883712.0ulk;
unsigned long _Sat _Accum ula_d = 3456106496.0ulk;
unsigned long _Sat _Accum ula_e = 0.5ulk;
#define CHECK(FN, EXP) do { \
if (fabs ((float) (FN) - (EXP)) > 0.05) \
{ \
fprintf (stderr, "result for " #FN " (as float): %f\n", (double) (FN));\
abort (); \
} \
} while (0)
#define CHECK_EXACT(FN, EXP) do { \
if ((FN) != (EXP)) \
{ \
fprintf (stderr, "result for " #FN " (as float): %f, should be %f\n", \
(double) (FN), (double) (EXP)); \
abort (); \
} \
} while (0)
int
main (int argc, char *argv[])
{
/* Fract/fract operations, non-saturating. */
CHECK (plus_fract_short (sf_a, sf_b), 0.1);
CHECK (plus_fract_regular (f_a, f_b), 0.1);
CHECK (plus_fract_long (lf_a, lf_b), 0.1);
CHECK (plus_fract_uns_short (usf_a, usf_b), 0.7);
CHECK (plus_fract_uns_regular (uf_a, uf_b), 0.7);
CHECK (plus_fract_uns_long (ulf_a, ulf_b), 0.7);
CHECK (minus_fract_short (sf_c, sf_d), -0.2);
CHECK (minus_fract_regular (f_c, f_d), -0.2);
CHECK (minus_fract_long (lf_c, lf_d), -0.2);
CHECK (minus_fract_uns_short (usf_a, usf_b), 0.1);
CHECK (minus_fract_uns_regular (uf_a, uf_b), 0.1);
CHECK (minus_fract_uns_long (ulf_a, ulf_b), 0.1);
CHECK (mult_fract_short (sf_a, sf_b), -0.72);
CHECK (mult_fract_regular (f_a, f_b), -0.72);
CHECK (mult_fract_long (lf_a, lf_b), -0.72);
CHECK (mult_fract_uns_short (usf_a, usf_b), 0.12);
CHECK (mult_fract_uns_regular (uf_a, uf_b), 0.12);
CHECK (mult_fract_uns_long (ulf_a, ulf_b), 0.12);
/* Fract/fract operations, saturating. */
CHECK (plus_fract_sat_short (sf_e, sf_f), 1.0);
CHECK (plus_fract_sat_regular (f_e, f_f), 1.0);
CHECK (plus_fract_sat_long (lf_e, lf_f), 1.0);
CHECK (plus_fract_sat_short (sf_g, sf_h), -1.0);
CHECK (plus_fract_sat_regular (f_g, f_h), -1.0);
CHECK (plus_fract_sat_long (lf_g, lf_h), -1.0);
CHECK (plus_fract_uns_sat_short (sf_e, sf_f), 1.0);
CHECK (plus_fract_uns_sat_regular (f_e, f_f), 1.0);
CHECK (plus_fract_uns_sat_long (lf_e, lf_f), 1.0);
CHECK (plus_fract_sat_short (sf_a, sf_b), 0.1);
CHECK (plus_fract_sat_regular (f_a, f_b), 0.1);
CHECK (plus_fract_sat_long (lf_a, lf_b), 0.1);
CHECK (plus_fract_uns_sat_short (usf_a, usf_b), 0.7);
CHECK (plus_fract_uns_sat_regular (uf_a, uf_b), 0.7);
CHECK (plus_fract_uns_sat_long (ulf_a, ulf_b), 0.7);
CHECK (minus_fract_uns_sat_short (usf_c, usf_d), 0.0);
CHECK (minus_fract_uns_sat_regular (uf_c, uf_d), 0.0);
CHECK (minus_fract_uns_sat_short (ulf_c, ulf_d), 0.0);
CHECK (minus_fract_sat_short (sf_c, sf_d), -0.2);
CHECK (minus_fract_sat_regular (f_c, f_d), -0.2);
CHECK (minus_fract_sat_long (lf_c, lf_d), -0.2);
/* Accum/accum operations, non-saturating. */
CHECK (plus_accum_short (sa_a, sa_b), -0.25);
CHECK (plus_accum_regular (a_a, a_b), -0.25);
CHECK (plus_accum_long (la_a, la_b), -0.25);
CHECK (minus_accum_short (sa_a, sa_b), 2.75);
CHECK (minus_accum_regular (a_a, a_b), 200.75);
CHECK (minus_accum_long (la_a, la_b), 2000.75);
CHECK (mult_accum_short (sa_a, sa_b), -1.875);
CHECK (mult_accum_regular (a_a, a_b), -10075.125);
CHECK (mult_accum_long (la_a, la_b), -1000750.125);
CHECK (div_accum_short (sa_a, sa_b), -1.25/1.5);
CHECK (div_accum_regular (a_a, a_b), -100.25/100.5);
CHECK (div_accum_long (la_a, la_b), -1000.25/1000.5);
/* Unsigned accum/accum operations, non-saturating. */
CHECK (plus_accum_uns_short (usa_a, usa_b), 4.25);
CHECK (plus_accum_uns_regular (ua_a, ua_b), 425.75);
CHECK (plus_accum_uns_long (ula_a, ula_b), 2550.0);
CHECK (minus_accum_uns_short (usa_a, usa_b), 0.75);
CHECK (minus_accum_uns_regular (ua_a, ua_b), 85.25);
CHECK (minus_accum_uns_long (ula_a, ula_b), 551.0);
CHECK (mult_accum_uns_short (usa_a, usa_b), 4.375);
CHECK (mult_accum_uns_regular (ua_a, ua_b), 43498.875);
CHECK (mult_accum_uns_long (ula_a, ula_b), 1549724.75);
CHECK (div_accum_uns_short (usa_a, usa_b), 2.5/1.75);
CHECK (div_accum_uns_regular (ua_a, ua_b), 255.5/170.25);
CHECK (div_accum_uns_long (ula_a, ula_b), 1550.5/999.5);
/* Signed accum/accum operations, saturating. */
CHECK_EXACT (plus_accum_sat_short (sa_c, sa_d), SACCUM_MAX);
CHECK_EXACT (plus_accum_sat_short (sa_e, sa_f), SACCUM_MIN);
CHECK_EXACT (plus_accum_sat_regular (a_c, a_d), ACCUM_MAX);
CHECK_EXACT (plus_accum_sat_regular (a_e, a_f), ACCUM_MIN);
CHECK_EXACT (plus_accum_sat_long (la_c, la_d), LACCUM_MAX);
CHECK_EXACT (plus_accum_sat_long (la_e, la_f), LACCUM_MIN);
CHECK_EXACT (minus_accum_sat_short (sa_e, sa_d), SACCUM_MIN);
CHECK_EXACT (minus_accum_sat_short (sa_c, sa_f), SACCUM_MAX);
CHECK_EXACT (minus_accum_sat_regular (a_e, a_d), ACCUM_MIN);
CHECK_EXACT (minus_accum_sat_regular (a_c, a_f), ACCUM_MAX);
CHECK_EXACT (minus_accum_sat_long (la_e, la_d), LACCUM_MIN);
CHECK_EXACT (minus_accum_sat_long (la_c, la_f), LACCUM_MAX);
CHECK_EXACT (mult_accum_sat_short (sa_c, sa_d), SACCUM_MAX);
CHECK_EXACT (mult_accum_sat_short (sa_c, sa_e), SACCUM_MIN);
CHECK_EXACT (mult_accum_sat_regular (a_c, a_d), ACCUM_MAX);
CHECK_EXACT (mult_accum_sat_regular (a_c, a_e), ACCUM_MIN);
CHECK_EXACT (mult_accum_sat_long (la_c, la_d), LACCUM_MAX);
CHECK_EXACT (mult_accum_sat_long (la_c, la_e), LACCUM_MIN);
CHECK_EXACT (div_accum_sat_short (sa_d, sa_g), SACCUM_MAX);
CHECK_EXACT (div_accum_sat_short (sa_e, sa_g), SACCUM_MIN);
CHECK_EXACT (div_accum_sat_regular (a_c, a_g), ACCUM_MAX);
CHECK_EXACT (div_accum_sat_regular (a_e, a_g), ACCUM_MIN);
CHECK_EXACT (div_accum_sat_long (la_d, la_g), LACCUM_MAX);
CHECK_EXACT (div_accum_sat_long (la_e, la_g), LACCUM_MIN);
/* Unsigned accum/accum operations, saturating. */
CHECK_EXACT (plus_accum_uns_sat_short (usa_c, usa_d), USACCUM_MAX);
CHECK_EXACT (plus_accum_uns_sat_regular (ua_c, ua_d), UACCUM_MAX);
CHECK_EXACT (plus_accum_uns_sat_long (ula_c, ula_d), ULACCUM_MAX);
CHECK_EXACT (minus_accum_uns_sat_short (usa_d, usa_c), 0uhk);
CHECK_EXACT (minus_accum_uns_sat_regular (ua_d, ua_c), 0uk);
CHECK_EXACT (minus_accum_uns_sat_long (ula_d, ula_c), 0ulk);
CHECK_EXACT (mult_accum_uns_sat_short (usa_c, usa_d), USACCUM_MAX);
CHECK_EXACT (mult_accum_uns_sat_regular (ua_c, ua_d), UACCUM_MAX);
CHECK_EXACT (mult_accum_uns_sat_long (ula_c, ula_d), ULACCUM_MAX);
CHECK_EXACT (div_accum_uns_sat_short (usa_c, usa_e), USACCUM_MAX);
CHECK_EXACT (div_accum_uns_sat_regular (ua_c, ua_e), UACCUM_MAX);
CHECK_EXACT (div_accum_uns_sat_long (ula_c, ula_e), ULACCUM_MAX);
return 0;
}
|
