fpu_branches.c revision 436e89c602e787e7a27dd6624b09beed41a0da8a 
1#include <stdio.h>
2
3#define MAX_ARR 24
4
5const float fs_f[] = {
6   0,         456.25,   3,          -1,
7   1384.5,    -7.25,    1000000000, -5786.5,
8   1752,      0.015625, 0.03125,    -248562.75,
9   -45786.5,  456,      34.03125,   45786.75,
10   1752065,   107,      -45667.25,  -7,
11   -347856.5, 356047.5, -1.0,       23.0625
12};
13
14const float ft_f[] = {
15   -4578.5, 456.25,   34.03125, 4578.75,
16   175,     107,      -456.25,  -7.25,
17   -3478.5, 356.5,    -1.0,     23.0625,
18   0,       456.25,   3,        -1,
19   1384.5,  -7,       100,      -5786.5,
20   1752,    0.015625, 0.03125,  -248562.75
21};
22
23const double fs_d[] = {
24   0,         456.25,   3,          -1,
25   1384.5,    -7.25,    1000000000, -5786.5,
26   1752,      0.015625, 0.03125,    -248562.75,
27   -45786.5,  456,      34.03125,   45786.75,
28   1752065,   107,      -45667.25,  -7,
29   -347856.5, 356047.5, -1.0,       23.0625
30};
31
32const double ft_d[] = {
33   -45786.5,  456.25,   34.03125,   45786.75,
34   1752065,   107,      -45667.25,  -7.25,
35   -347856.5, 356047.5, -1.0,       23.0625,
36   0,         456.25,   3,          -1,
37   1384.5,    -7,       1000000000, -5786.5,
38   1752,      0.015625, 0.03125,    -248562.75
39};
40
41/* Conditional macros.*/
42#define TESTINST1s(instruction, RDval)               \
43{                                                    \
44   float outf = 0;                                   \
45   __asm__ __volatile__(                             \
46      ".set        noreorder"                "\n\t"  \
47      "mov.s       $f0, %1"                  "\n\t"  \
48      "mov.s       $f2, %2"                  "\n\t"  \
49      "c.eq.s      $f0, $f2"                 "\n\t"  \
50      instruction" end"instruction"s"#RDval  "\n\t"  \
51      "nop"                                  "\n\t"  \
52      "add.s       $f0, $f0, $f2"            "\n\t"  \
53      "end"instruction"s"#RDval":"           "\n\t"  \
54      "mov.s       %0,  $f0"                 "\n\t"  \
55      ".set        reorder"                  "\n\t"  \
56      : "=f" (outf)                                  \
57      : "f" (fs_f[i]) , "f" (ft_f[i])                \
58      : "$f0", "$f2"                                 \
59   );                                                \
60   printf("%s, c.eq.s   out=%f, fs=%f, ft=%f\n",     \
61          instruction, outf, fs_f[i], ft_f[i]);      \
62}
63
64#define TESTINST1d(instruction, RDval)               \
65{                                                    \
66   double outd = 0;                                  \
67   __asm__ __volatile__(                             \
68      ".set        noreorder"                "\n\t"  \
69      "mov.d       $f0, %1"                  "\n\t"  \
70      "mov.d       $f2, %2"                  "\n\t"  \
71      "c.eq.d      $f0, $f2"                 "\n\t"  \
72      instruction" end"instruction"d"#RDval  "\n\t"  \
73      "nop"                                  "\n\t"  \
74      "add.d       $f0, $f0, $f2"            "\n\t"  \
75      "end"instruction"d"#RDval":"           "\n\t"  \
76      "mov.d       %0,  $f0"                 "\n\t"  \
77      ".set        reorder"                  "\n\t"  \
78      : "=f" (outd)                                  \
79      : "f" (fs_d[i]) , "f" (ft_d[i])                \
80      : "$f0", "$f1", "$f2", "$f3"                   \
81   );                                                \
82   printf("%s, c.eq.d   out=%f, fs=%f, ft=%f\n",     \
83          instruction, outd, fs_d[i], ft_d[i]);      \
84}
85
86#define TESTINST2s(instruction, RDval)               \
87{                                                    \
88   float outf = 0;                                   \
89   __asm__ __volatile__(                             \
90      ".set        noreorder"                "\n\t"  \
91      "mov.s       $f0, %1"                  "\n\t"  \
92      "mov.s       $f2, %2"                  "\n\t"  \
93      "c.eq.s      $f0, $f2"                 "\n\t"  \
94      instruction" end"instruction"s"#RDval  "\n\t"  \
95      "add.s       $f0, $f0, $f2"            "\n\t"  \
96      "end"instruction"s"#RDval":"           "\n\t"  \
97      "mov.s       %0, $f0"                  "\n\t"  \
98      ".set        reorder"                  "\n\t"  \
99      : "=f" (outf)                                  \
100      : "f" (fs_f[i]) , "f" (ft_f[i])                \
101      : "$f0", "$f2"                                 \
102   );                                                \
103   printf("%s, c.eq.s   out=%f, fs=%f, ft=%f\n",     \
104          instruction, outf, fs_f[i], ft_f[i]);      \
105}
106
107#define TESTINST2d(instruction, RDval)               \
108{                                                    \
109   double outd = 0;                                  \
110   __asm__ __volatile__(                             \
111      ".set        noreorder"                "\n\t"  \
112      "mov.d       $f0, %1"                  "\n\t"  \
113      "mov.d       $f2, %2"                  "\n\t"  \
114      "c.eq.d      $f0, $f2"                 "\n\t"  \
115      instruction" end"instruction"d"#RDval  "\n\t"  \
116      "add.d       $f0, $f0, $f2"            "\n\t"  \
117      "end"instruction"d"#RDval":"           "\n\t"  \
118      "mov.d       %0,  $f0"                 "\n\t"  \
119      ".set        reorder"                  "\n\t"  \
120      : "=f" (outd)                                  \
121      : "f" (fs_d[i]) , "f" (ft_d[i])                \
122      : "$f0", "$f1", "$f2", "$f3"                   \
123   );                                                \
124   printf("%s, c.eq.d   out=%f, fs=%f, ft=%f\n",     \
125          instruction, outd, fs_d[i], ft_d[i]);      \
126}
127
128#define TESTINST_CONDs(instruction, RDval)       \
129{                                                \
130   float outf = 0;                               \
131   __asm__ __volatile__(                         \
132      ".set        noreorder"         "\n\t"     \
133      "mov.s       $f0, %1"           "\n\t"     \
134      "mov.s       $f2, %2"           "\n\t"     \
135      instruction" $f0, $f2"          "\n\t"     \
136      "bc1f end"instruction"s"#RDval  "\n\t"     \
137      "nop"                           "\n\t"     \
138      "add.s       $f0, $f0, $f2"     "\n\t"     \
139      "end"instruction"s"#RDval":"    "\n\t"     \
140      "mov.s       %0,  $f0"          "\n\t"     \
141      ".set        reorder"           "\n\t"     \
142      : "=f" (outf)                              \
143      : "f" (fs_f[i]) , "f" (ft_f[i])            \
144      : "$f0", "$f1", "$f2"                      \
145   );                                            \
146   printf("%s, bc1f   out=%f, fs=%f, ft=%f\n",   \
147          instruction, outf, fs_f[i], ft_f[i]);  \
148}
149
150#define TESTINST_CONDd(instruction, RDval)       \
151{                                                \
152   double outd = 0;                              \
153   __asm__ __volatile__(                         \
154      ".set        noreorder"         "\n\t"     \
155      "mov.d       $f0, %1"           "\n\t"     \
156      "mov.d       $f2, %2"           "\n\t"     \
157      instruction" $f0, $f2"          "\n\t"     \
158      "bc1f end"instruction"d"#RDval  "\n\t"     \
159      "nop"                           "\n\t"     \
160      "add.d       $f0, $f0, $f2"     "\n\t"     \
161      "end"instruction"d"#RDval":"    "\n\t"     \
162      "mov.d       %0,  $f0"          "\n\t"     \
163      ".set        reorder"           "\n\t"     \
164      : "=f" (outd)                              \
165      : "f" (fs_d[i]) , "f" (ft_d[i])            \
166      : "$f0", "$f1", "$f2", "$f2"               \
167   );                                            \
168   printf("%s, bc1f   out=%f, fs=%f, ft=%f\n",   \
169          instruction, outd, fs_d[i], ft_d[i]);  \
170}
171
172int main()
173{
174   int i = 0;
175
176   printf("--- BC1F ---  if fs != ft then " \
177          "out = fs else out = fs + ft\n");
178   for (i = 0; i < MAX_ARR; i++) {
179      TESTINST1s("bc1f", i);
180      TESTINST1d("bc1f", i);
181   }
182
183   printf("--- BC1T ---  if fs == ft then " \
184          "out = fs else out = fs + ft\n");
185   for (i = 0; i < MAX_ARR; i++) {
186      TESTINST1s("bc1t", i);
187      TESTINST1d("bc1t", i);
188   }
189
190   printf("--- BC1FL ---  if fs == ft then " \
191          "out = ft else out = fs + ft\n");
192   for (i = 0; i < MAX_ARR; i++) {
193      TESTINST2s("bc1fl", i);
194      TESTINST2d("bc1fl", i);
195   }
196
197   printf("--- BC1TL ---  if fs != ft then " \
198          "out = fs else out = fs + ft\n");
199   for (i = 0; i < MAX_ARR; i++) {
200      TESTINST2s("bc1tl", i);
201      TESTINST2d("bc1tl", i);
202   }
203
204   printf("--- C.F.S/D ---  if false then " \
205          "out = fs + ft else out = fs\n");
206   for (i = 0; i < MAX_ARR; i++) {
207      TESTINST_CONDs("c.f.s", i);
208      TESTINST_CONDd("c.f.d", i);
209   }
210
211   printf("--- C.UN.S/D ---  if unordered(fs, ft) then " \
212          "out = fs + ft else out = fs\n");
213   for (i = 0; i < MAX_ARR; i++) {
214      TESTINST_CONDs("c.un.s", i);
215      TESTINST_CONDd("c.un.d", i);
216   }
217
218   printf("--- C.EQ.S/D ---  if fs == ft then " \
219          "out = fs + ft else out = fs\n");
220   for (i = 0; i < MAX_ARR; i++) {
221      TESTINST_CONDs("c.eq.s", i);
222      TESTINST_CONDd("c.eq.d", i);
223   }
224
225   printf("--- C.UEQ.S/D ---  if (unordered(fs, ft) or (fs == ft)) then " \
226          "out = fs + ft else out = fs\n");
227   for (i = 0; i < MAX_ARR; i++) {
228      TESTINST_CONDs("c.ueq.s", i);
229      TESTINST_CONDd("c.ueq.d", i);
230   }
231
232   printf("--- C.OLT.S/D ---  if (ordered(fs, ft) or (fs < ft)) then " \
233          "out = fs + ft else out = fs\n");
234   for (i = 0; i < MAX_ARR; i++) {
235      TESTINST_CONDs("c.olt.s", i);
236      TESTINST_CONDd("c.olt.d", i);
237   }
238
239   printf("--- C.ULT.S/D ---  if (unordered(fs, ft) or (fs < ft)) then " \
240          "out = fs + ft else out = fs\n");
241   for (i = 0; i < MAX_ARR; i++) {
242      TESTINST_CONDs("c.ult.s", i);
243      TESTINST_CONDd("c.ult.d", i);
244   }
245
246   printf("--- C.OLE.S/D ---  if (ordered(fs, ft) or (fs <= ft)) then " \
247          "out = fs + ft else out = fs\n");
248   for (i = 0; i < MAX_ARR; i++) {
249      TESTINST_CONDs("c.ole.s", i);
250      TESTINST_CONDd("c.ole.d", i);
251   }
252
253   printf("--- C.ULE.S/D ---  if (unordered(fs, ft) or (fs <= ft)) then " \
254          "out = fs + ft else out = fs\n");
255   for (i = 0; i < MAX_ARR; i++) {
256      TESTINST_CONDs("c.ule.s", i);
257      TESTINST_CONDd("c.ule.d", i);
258   }
259
260   printf("--- C.SF.S/D ---  if signaling false then " \
261          "out = fs + ft else out = fs\n");
262   for (i = 0; i < MAX_ARR; i++) {
263      TESTINST_CONDs("c.sf.s", i);
264      TESTINST_CONDd("c.sf.d", i);
265   }
266
267   printf("--- C.NGLE.S/D --- if not ((fs > ft) or (fs <= ft)) then " \
268          "out = fs + ft else out = fs\n");
269   for (i = 0; i < MAX_ARR; i++) {
270      TESTINST_CONDs("c.ngle.s", i);
271      TESTINST_CONDd("c.ngle.d", i);
272   }
273
274   printf("--- C.SEQ.S/D ---  if signaling equal then " \
275          "out = fs + ft else out = fs\n");
276   for (i = 0; i < MAX_ARR; i++) {
277      TESTINST_CONDs("c.seq.s", i);
278      TESTINST_CONDd("c.seq.d", i);
279   }
280
281   printf("--- C.NGL.S/D ---  if not ((fs > ft) or (fs < ft)) then " \
282          "out = fs + ft else out = fs\n");
283   for (i = 0; i < MAX_ARR; i++) {
284      TESTINST_CONDs("c.ngl.s", i);
285      TESTINST_CONDd("c.ngl.d", i);
286   }
287
288   printf("--- C.LT.S/D ---  if fs < ft then " \
289          "out = fs + ft else out = fs\n");
290   for (i = 0; i < MAX_ARR; i++) {
291      TESTINST_CONDs("c.lt.s", i);
292      TESTINST_CONDd("c.lt.d", i);
293   }
294
295   printf("--- C.NGE.S/D ---  if not (fs >= ft) then " \
296          "out = fs + ft else out = fs\n");
297   for (i = 0; i < MAX_ARR; i++) {
298      TESTINST_CONDs("c.nge.s", i);
299      TESTINST_CONDd("c.nge.d", i);
300   }
301
302   printf("--- C.LE.S/D ---  if fs <= ft then " \
303          "out = fs + ft else out = fs\n");
304   for (i = 0; i < MAX_ARR; i++) {
305      TESTINST_CONDs("c.le.s", i);
306      TESTINST_CONDd("c.le.d", i);
307   }
308
309   printf("--- C.NGT.S/D ---  if not (fs > ft) then " \
310          "out = fs + ft else out = fs\n");
311   for (i = 0; i < MAX_ARR; i++) {
312      TESTINST_CONDs("c.ngt.s", i);
313      TESTINST_CONDd("c.ngt.d", i);
314   }
315   return 0;
316}
317
318