timesoftfloat.c revision 297790 
1/* $NetBSD: timesoftfloat.c,v 1.1 2000/06/06 08:15:11 bjh21 Exp $ */
2
3/*
4===============================================================================
5
6This C source file is part of the SoftFloat IEC/IEEE Floating-point
7Arithmetic Package, Release 2a.
8
9Written by John R. Hauser.  This work was made possible in part by the
10International Computer Science Institute, located at Suite 600, 1947 Center
11Street, Berkeley, California 94704.  Funding was partially provided by the
12National Science Foundation under grant MIP-9311980.  The original version
13of this code was written as part of a project to build a fixed-point vector
14processor in collaboration with the University of California at Berkeley,
15overseen by Profs. Nelson Morgan and John Wawrzynek.  More information
16is available through the Web page `http://HTTP.CS.Berkeley.EDU/~jhauser/
17arithmetic/SoftFloat.html'.
18
19THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE.  Although reasonable effort
20has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT
21TIMES RESULT IN INCORRECT BEHAVIOR.  USE OF THIS SOFTWARE IS RESTRICTED TO
22PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY
23AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE.
24
25Derivative works are acceptable, even for commercial purposes, so long as
26(1) they include prominent notice that the work is derivative, and (2) they
27include prominent notice akin to these four paragraphs for those parts of
28this code that are retained.
29
30===============================================================================
31*/
32
33#include <sys/cdefs.h>
34__FBSDID("$FreeBSD: head/lib/libc/softfloat/timesoftfloat.c 297790 2016-04-10 19:33:58Z pfg $");
35
36#include <stdlib.h>
37#include <stdarg.h>
38#include <string.h>
39#include <stdio.h>
40#include <time.h>
41#include "milieu.h"
42#include "softfloat.h"
43
44enum {
45    minIterations = 1000
46};
47
48static void fail( const char *message, ... )
49{
50    va_list varArgs;
51
52    fputs( "timesoftfloat: ", stderr );
53    va_start( varArgs, message );
54    vfprintf( stderr, message, varArgs );
55    va_end( varArgs );
56    fputs( ".\n", stderr );
57    exit( EXIT_FAILURE );
58
59}
60
61static char *functionName;
62static char *roundingPrecisionName, *roundingModeName, *tininessModeName;
63
64static void reportTime( int32 count, long clocks )
65{
66
67    printf(
68        "%8.1f kops/s: %s",
69        ( count / ( ( (float) clocks ) / CLOCKS_PER_SEC ) ) / 1000,
70        functionName
71    );
72    if ( roundingModeName ) {
73        if ( roundingPrecisionName ) {
74            fputs( ", precision ", stdout );
75            fputs( roundingPrecisionName, stdout );
76        }
77        fputs( ", rounding ", stdout );
78        fputs( roundingModeName, stdout );
79        if ( tininessModeName ) {
80            fputs( ", tininess ", stdout );
81            fputs( tininessModeName, stdout );
82            fputs( " rounding", stdout );
83        }
84    }
85    fputc( '\n', stdout );
86
87}
88
89enum {
90    numInputs_int32 = 32
91};
92
93static const int32 inputs_int32[ numInputs_int32 ] = {
94    0xFFFFBB79, 0x405CF80F, 0x00000000, 0xFFFFFD04,
95    0xFFF20002, 0x0C8EF795, 0xF00011FF, 0x000006CA,
96    0x00009BFE, 0xFF4862E3, 0x9FFFEFFE, 0xFFFFFFB7,
97    0x0BFF7FFF, 0x0000F37A, 0x0011DFFE, 0x00000006,
98    0xFFF02006, 0xFFFFF7D1, 0x10200003, 0xDE8DF765,
99    0x00003E02, 0x000019E8, 0x0008FFFE, 0xFFFFFB5C,
100    0xFFDF7FFE, 0x07C42FBF, 0x0FFFE3FF, 0x040B9F13,
101    0xBFFFFFF8, 0x0001BF56, 0x000017F6, 0x000A908A
102};
103
104static void time_a_int32_z_float32( float32 function( int32 ) )
105{
106    clock_t startClock, endClock;
107    int32 count, i;
108    int8 inputNum;
109
110    count = 0;
111    inputNum = 0;
112    startClock = clock();
113    do {
114        for ( i = minIterations; i; --i ) {
115            function( inputs_int32[ inputNum ] );
116            inputNum = ( inputNum + 1 ) & ( numInputs_int32 - 1 );
117        }
118        count += minIterations;
119    } while ( clock() - startClock < CLOCKS_PER_SEC );
120    inputNum = 0;
121    startClock = clock();
122    for ( i = count; i; --i ) {
123        function( inputs_int32[ inputNum ] );
124        inputNum = ( inputNum + 1 ) & ( numInputs_int32 - 1 );
125    }
126    endClock = clock();
127    reportTime( count, endClock - startClock );
128
129}
130
131static void time_a_int32_z_float64( float64 function( int32 ) )
132{
133    clock_t startClock, endClock;
134    int32 count, i;
135    int8 inputNum;
136
137    count = 0;
138    inputNum = 0;
139    startClock = clock();
140    do {
141        for ( i = minIterations; i; --i ) {
142            function( inputs_int32[ inputNum ] );
143            inputNum = ( inputNum + 1 ) & ( numInputs_int32 - 1 );
144        }
145        count += minIterations;
146    } while ( clock() - startClock < CLOCKS_PER_SEC );
147    inputNum = 0;
148    startClock = clock();
149    for ( i = count; i; --i ) {
150        function( inputs_int32[ inputNum ] );
151        inputNum = ( inputNum + 1 ) & ( numInputs_int32 - 1 );
152    }
153    endClock = clock();
154    reportTime( count, endClock - startClock );
155
156}
157
158#ifdef FLOATX80
159
160static void time_a_int32_z_floatx80( floatx80 function( int32 ) )
161{
162    clock_t startClock, endClock;
163    int32 count, i;
164    int8 inputNum;
165
166    count = 0;
167    inputNum = 0;
168    startClock = clock();
169    do {
170        for ( i = minIterations; i; --i ) {
171            function( inputs_int32[ inputNum ] );
172            inputNum = ( inputNum + 1 ) & ( numInputs_int32 - 1 );
173        }
174        count += minIterations;
175    } while ( clock() - startClock < CLOCKS_PER_SEC );
176    inputNum = 0;
177    startClock = clock();
178    for ( i = count; i; --i ) {
179        function( inputs_int32[ inputNum ] );
180        inputNum = ( inputNum + 1 ) & ( numInputs_int32 - 1 );
181    }
182    endClock = clock();
183    reportTime( count, endClock - startClock );
184
185}
186
187#endif
188
189#ifdef FLOAT128
190
191static void time_a_int32_z_float128( float128 function( int32 ) )
192{
193    clock_t startClock, endClock;
194    int32 count, i;
195    int8 inputNum;
196
197    count = 0;
198    inputNum = 0;
199    startClock = clock();
200    do {
201        for ( i = minIterations; i; --i ) {
202            function( inputs_int32[ inputNum ] );
203            inputNum = ( inputNum + 1 ) & ( numInputs_int32 - 1 );
204        }
205        count += minIterations;
206    } while ( clock() - startClock < CLOCKS_PER_SEC );
207    inputNum = 0;
208    startClock = clock();
209    for ( i = count; i; --i ) {
210        function( inputs_int32[ inputNum ] );
211        inputNum = ( inputNum + 1 ) & ( numInputs_int32 - 1 );
212    }
213    endClock = clock();
214    reportTime( count, endClock - startClock );
215
216}
217
218#endif
219
220enum {
221    numInputs_int64 = 32
222};
223
224static const int64 inputs_int64[ numInputs_int64 ] = {
225    LIT64( 0xFBFFC3FFFFFFFFFF ),
226    LIT64( 0x0000000003C589BC ),
227    LIT64( 0x00000000400013FE ),
228    LIT64( 0x0000000000186171 ),
229    LIT64( 0xFFFFFFFFFFFEFBFA ),
230    LIT64( 0xFFFFFD79E6DFFC73 ),
231    LIT64( 0x0000000010001DFF ),
232    LIT64( 0xDD1A0F0C78513710 ),
233    LIT64( 0xFFFF83FFFFFEFFFE ),
234    LIT64( 0x00756EBD1AD0C1C7 ),
235    LIT64( 0x0003FDFFFFFFFFBE ),
236    LIT64( 0x0007D0FB2C2CA951 ),
237    LIT64( 0x0007FC0007FFFFFE ),
238    LIT64( 0x0000001F942B18BB ),
239    LIT64( 0x0000080101FFFFFE ),
240    LIT64( 0xFFFFFFFFFFFF0978 ),
241    LIT64( 0x000000000008BFFF ),
242    LIT64( 0x0000000006F5AF08 ),
243    LIT64( 0xFFDEFF7FFFFFFFFE ),
244    LIT64( 0x0000000000000003 ),
245    LIT64( 0x3FFFFFFFFF80007D ),
246    LIT64( 0x0000000000000078 ),
247    LIT64( 0xFFF80000007FDFFD ),
248    LIT64( 0x1BBC775B78016AB0 ),
249    LIT64( 0xFFF9001FFFFFFFFE ),
250    LIT64( 0xFFFD4767AB98E43F ),
251    LIT64( 0xFFFFFEFFFE00001E ),
252    LIT64( 0xFFFFFFFFFFF04EFD ),
253    LIT64( 0x07FFFFFFFFFFF7FF ),
254    LIT64( 0xFFFC9EAA38F89050 ),
255    LIT64( 0x00000020FBFFFFFE ),
256    LIT64( 0x0000099AE6455357 )
257};
258
259static void time_a_int64_z_float32( float32 function( int64 ) )
260{
261    clock_t startClock, endClock;
262    int32 count, i;
263    int8 inputNum;
264
265    count = 0;
266    inputNum = 0;
267    startClock = clock();
268    do {
269        for ( i = minIterations; i; --i ) {
270            function( inputs_int64[ inputNum ] );
271            inputNum = ( inputNum + 1 ) & ( numInputs_int64 - 1 );
272        }
273        count += minIterations;
274    } while ( clock() - startClock < CLOCKS_PER_SEC );
275    inputNum = 0;
276    startClock = clock();
277    for ( i = count; i; --i ) {
278        function( inputs_int64[ inputNum ] );
279        inputNum = ( inputNum + 1 ) & ( numInputs_int64 - 1 );
280    }
281    endClock = clock();
282    reportTime( count, endClock - startClock );
283
284}
285
286static void time_a_int64_z_float64( float64 function( int64 ) )
287{
288    clock_t startClock, endClock;
289    int32 count, i;
290    int8 inputNum;
291
292    count = 0;
293    inputNum = 0;
294    startClock = clock();
295    do {
296        for ( i = minIterations; i; --i ) {
297            function( inputs_int64[ inputNum ] );
298            inputNum = ( inputNum + 1 ) & ( numInputs_int64 - 1 );
299        }
300        count += minIterations;
301    } while ( clock() - startClock < CLOCKS_PER_SEC );
302    inputNum = 0;
303    startClock = clock();
304    for ( i = count; i; --i ) {
305        function( inputs_int64[ inputNum ] );
306        inputNum = ( inputNum + 1 ) & ( numInputs_int64 - 1 );
307    }
308    endClock = clock();
309    reportTime( count, endClock - startClock );
310
311}
312
313#ifdef FLOATX80
314
315static void time_a_int64_z_floatx80( floatx80 function( int64 ) )
316{
317    clock_t startClock, endClock;
318    int32 count, i;
319    int8 inputNum;
320
321    count = 0;
322    inputNum = 0;
323    startClock = clock();
324    do {
325        for ( i = minIterations; i; --i ) {
326            function( inputs_int64[ inputNum ] );
327            inputNum = ( inputNum + 1 ) & ( numInputs_int64 - 1 );
328        }
329        count += minIterations;
330    } while ( clock() - startClock < CLOCKS_PER_SEC );
331    inputNum = 0;
332    startClock = clock();
333    for ( i = count; i; --i ) {
334        function( inputs_int64[ inputNum ] );
335        inputNum = ( inputNum + 1 ) & ( numInputs_int64 - 1 );
336    }
337    endClock = clock();
338    reportTime( count, endClock - startClock );
339
340}
341
342#endif
343
344#ifdef FLOAT128
345
346static void time_a_int64_z_float128( float128 function( int64 ) )
347{
348    clock_t startClock, endClock;
349    int32 count, i;
350    int8 inputNum;
351
352    count = 0;
353    inputNum = 0;
354    startClock = clock();
355    do {
356        for ( i = minIterations; i; --i ) {
357            function( inputs_int64[ inputNum ] );
358            inputNum = ( inputNum + 1 ) & ( numInputs_int64 - 1 );
359        }
360        count += minIterations;
361    } while ( clock() - startClock < CLOCKS_PER_SEC );
362    inputNum = 0;
363    startClock = clock();
364    for ( i = count; i; --i ) {
365        function( inputs_int64[ inputNum ] );
366        inputNum = ( inputNum + 1 ) & ( numInputs_int64 - 1 );
367    }
368    endClock = clock();
369    reportTime( count, endClock - startClock );
370
371}
372
373#endif
374
375enum {
376    numInputs_float32 = 32
377};
378
379static const float32 inputs_float32[ numInputs_float32 ] = {
380    0x4EFA0000, 0xC1D0B328, 0x80000000, 0x3E69A31E,
381    0xAF803EFF, 0x3F800000, 0x17BF8000, 0xE74A301A,
382    0x4E010003, 0x7EE3C75D, 0xBD803FE0, 0xBFFEFF00,
383    0x7981F800, 0x431FFFFC, 0xC100C000, 0x3D87EFFF,
384    0x4103FEFE, 0xBC000007, 0xBF01F7FF, 0x4E6C6B5C,
385    0xC187FFFE, 0xC58B9F13, 0x4F88007F, 0xDF004007,
386    0xB7FFD7FE, 0x7E8001FB, 0x46EFFBFF, 0x31C10000,
387    0xDB428661, 0x33F89B1F, 0xA3BFEFFF, 0x537BFFBE
388};
389
390static void time_a_float32_z_int32( int32 function( float32 ) )
391{
392    clock_t startClock, endClock;
393    int32 count, i;
394    int8 inputNum;
395
396    count = 0;
397    inputNum = 0;
398    startClock = clock();
399    do {
400        for ( i = minIterations; i; --i ) {
401            function( inputs_float32[ inputNum ] );
402            inputNum = ( inputNum + 1 ) & ( numInputs_float32 - 1 );
403        }
404        count += minIterations;
405    } while ( clock() - startClock < CLOCKS_PER_SEC );
406    inputNum = 0;
407    startClock = clock();
408    for ( i = count; i; --i ) {
409        function( inputs_float32[ inputNum ] );
410        inputNum = ( inputNum + 1 ) & ( numInputs_float32 - 1 );
411    }
412    endClock = clock();
413    reportTime( count, endClock - startClock );
414
415}
416
417static void time_a_float32_z_int64( int64 function( float32 ) )
418{
419    clock_t startClock, endClock;
420    int32 count, i;
421    int8 inputNum;
422
423    count = 0;
424    inputNum = 0;
425    startClock = clock();
426    do {
427        for ( i = minIterations; i; --i ) {
428            function( inputs_float32[ inputNum ] );
429            inputNum = ( inputNum + 1 ) & ( numInputs_float32 - 1 );
430        }
431        count += minIterations;
432    } while ( clock() - startClock < CLOCKS_PER_SEC );
433    inputNum = 0;
434    startClock = clock();
435    for ( i = count; i; --i ) {
436        function( inputs_float32[ inputNum ] );
437        inputNum = ( inputNum + 1 ) & ( numInputs_float32 - 1 );
438    }
439    endClock = clock();
440    reportTime( count, endClock - startClock );
441
442}
443
444static void time_a_float32_z_float64( float64 function( float32 ) )
445{
446    clock_t startClock, endClock;
447    int32 count, i;
448    int8 inputNum;
449
450    count = 0;
451    inputNum = 0;
452    startClock = clock();
453    do {
454        for ( i = minIterations; i; --i ) {
455            function( inputs_float32[ inputNum ] );
456            inputNum = ( inputNum + 1 ) & ( numInputs_float32 - 1 );
457        }
458        count += minIterations;
459    } while ( clock() - startClock < CLOCKS_PER_SEC );
460    inputNum = 0;
461    startClock = clock();
462    for ( i = count; i; --i ) {
463        function( inputs_float32[ inputNum ] );
464        inputNum = ( inputNum + 1 ) & ( numInputs_float32 - 1 );
465    }
466    endClock = clock();
467    reportTime( count, endClock - startClock );
468
469}
470
471#ifdef FLOATX80
472
473static void time_a_float32_z_floatx80( floatx80 function( float32 ) )
474{
475    clock_t startClock, endClock;
476    int32 count, i;
477    int8 inputNum;
478
479    count = 0;
480    inputNum = 0;
481    startClock = clock();
482    do {
483        for ( i = minIterations; i; --i ) {
484            function( inputs_float32[ inputNum ] );
485            inputNum = ( inputNum + 1 ) & ( numInputs_float32 - 1 );
486        }
487        count += minIterations;
488    } while ( clock() - startClock < CLOCKS_PER_SEC );
489    inputNum = 0;
490    startClock = clock();
491    for ( i = count; i; --i ) {
492        function( inputs_float32[ inputNum ] );
493        inputNum = ( inputNum + 1 ) & ( numInputs_float32 - 1 );
494    }
495    endClock = clock();
496    reportTime( count, endClock - startClock );
497
498}
499
500#endif
501
502#ifdef FLOAT128
503
504static void time_a_float32_z_float128( float128 function( float32 ) )
505{
506    clock_t startClock, endClock;
507    int32 count, i;
508    int8 inputNum;
509
510    count = 0;
511    inputNum = 0;
512    startClock = clock();
513    do {
514        for ( i = minIterations; i; --i ) {
515            function( inputs_float32[ inputNum ] );
516            inputNum = ( inputNum + 1 ) & ( numInputs_float32 - 1 );
517        }
518        count += minIterations;
519    } while ( clock() - startClock < CLOCKS_PER_SEC );
520    inputNum = 0;
521    startClock = clock();
522    for ( i = count; i; --i ) {
523        function( inputs_float32[ inputNum ] );
524        inputNum = ( inputNum + 1 ) & ( numInputs_float32 - 1 );
525    }
526    endClock = clock();
527    reportTime( count, endClock - startClock );
528
529}
530
531#endif
532
533static void time_az_float32( float32 function( float32 ) )
534{
535    clock_t startClock, endClock;
536    int32 count, i;
537    int8 inputNum;
538
539    count = 0;
540    inputNum = 0;
541    startClock = clock();
542    do {
543        for ( i = minIterations; i; --i ) {
544            function( inputs_float32[ inputNum ] );
545            inputNum = ( inputNum + 1 ) & ( numInputs_float32 - 1 );
546        }
547        count += minIterations;
548    } while ( clock() - startClock < CLOCKS_PER_SEC );
549    inputNum = 0;
550    startClock = clock();
551    for ( i = count; i; --i ) {
552        function( inputs_float32[ inputNum ] );
553        inputNum = ( inputNum + 1 ) & ( numInputs_float32 - 1 );
554    }
555    endClock = clock();
556    reportTime( count, endClock - startClock );
557
558}
559
560static void time_ab_float32_z_flag( flag function( float32, float32 ) )
561{
562    clock_t startClock, endClock;
563    int32 count, i;
564    int8 inputNumA, inputNumB;
565
566    count = 0;
567    inputNumA = 0;
568    inputNumB = 0;
569    startClock = clock();
570    do {
571        for ( i = minIterations; i; --i ) {
572            function(
573                inputs_float32[ inputNumA ], inputs_float32[ inputNumB ] );
574            inputNumA = ( inputNumA + 1 ) & ( numInputs_float32 - 1 );
575            if ( inputNumA == 0 ) ++inputNumB;
576            inputNumB = ( inputNumB + 1 ) & ( numInputs_float32 - 1 );
577        }
578        count += minIterations;
579    } while ( clock() - startClock < CLOCKS_PER_SEC );
580    inputNumA = 0;
581    inputNumB = 0;
582    startClock = clock();
583    for ( i = count; i; --i ) {
584            function(
585                inputs_float32[ inputNumA ], inputs_float32[ inputNumB ] );
586        inputNumA = ( inputNumA + 1 ) & ( numInputs_float32 - 1 );
587        if ( inputNumA == 0 ) ++inputNumB;
588        inputNumB = ( inputNumB + 1 ) & ( numInputs_float32 - 1 );
589    }
590    endClock = clock();
591    reportTime( count, endClock - startClock );
592
593}
594
595static void time_abz_float32( float32 function( float32, float32 ) )
596{
597    clock_t startClock, endClock;
598    int32 count, i;
599    int8 inputNumA, inputNumB;
600
601    count = 0;
602    inputNumA = 0;
603    inputNumB = 0;
604    startClock = clock();
605    do {
606        for ( i = minIterations; i; --i ) {
607            function(
608                inputs_float32[ inputNumA ], inputs_float32[ inputNumB ] );
609            inputNumA = ( inputNumA + 1 ) & ( numInputs_float32 - 1 );
610            if ( inputNumA == 0 ) ++inputNumB;
611            inputNumB = ( inputNumB + 1 ) & ( numInputs_float32 - 1 );
612        }
613        count += minIterations;
614    } while ( clock() - startClock < CLOCKS_PER_SEC );
615    inputNumA = 0;
616    inputNumB = 0;
617    startClock = clock();
618    for ( i = count; i; --i ) {
619            function(
620                inputs_float32[ inputNumA ], inputs_float32[ inputNumB ] );
621        inputNumA = ( inputNumA + 1 ) & ( numInputs_float32 - 1 );
622        if ( inputNumA == 0 ) ++inputNumB;
623        inputNumB = ( inputNumB + 1 ) & ( numInputs_float32 - 1 );
624    }
625    endClock = clock();
626    reportTime( count, endClock - startClock );
627
628}
629
630static const float32 inputs_float32_pos[ numInputs_float32 ] = {
631    0x4EFA0000, 0x41D0B328, 0x00000000, 0x3E69A31E,
632    0x2F803EFF, 0x3F800000, 0x17BF8000, 0x674A301A,
633    0x4E010003, 0x7EE3C75D, 0x3D803FE0, 0x3FFEFF00,
634    0x7981F800, 0x431FFFFC, 0x4100C000, 0x3D87EFFF,
635    0x4103FEFE, 0x3C000007, 0x3F01F7FF, 0x4E6C6B5C,
636    0x4187FFFE, 0x458B9F13, 0x4F88007F, 0x5F004007,
637    0x37FFD7FE, 0x7E8001FB, 0x46EFFBFF, 0x31C10000,
638    0x5B428661, 0x33F89B1F, 0x23BFEFFF, 0x537BFFBE
639};
640
641static void time_az_float32_pos( float32 function( float32 ) )
642{
643    clock_t startClock, endClock;
644    int32 count, i;
645    int8 inputNum;
646
647    count = 0;
648    inputNum = 0;
649    startClock = clock();
650    do {
651        for ( i = minIterations; i; --i ) {
652            function( inputs_float32_pos[ inputNum ] );
653            inputNum = ( inputNum + 1 ) & ( numInputs_float32 - 1 );
654        }
655        count += minIterations;
656    } while ( clock() - startClock < CLOCKS_PER_SEC );
657    inputNum = 0;
658    startClock = clock();
659    for ( i = count; i; --i ) {
660        function( inputs_float32_pos[ inputNum ] );
661        inputNum = ( inputNum + 1 ) & ( numInputs_float32 - 1 );
662    }
663    endClock = clock();
664    reportTime( count, endClock - startClock );
665
666}
667
668enum {
669    numInputs_float64 = 32
670};
671
672static const float64 inputs_float64[ numInputs_float64 ] = {
673    LIT64( 0x422FFFC008000000 ),
674    LIT64( 0xB7E0000480000000 ),
675    LIT64( 0xF3FD2546120B7935 ),
676    LIT64( 0x3FF0000000000000 ),
677    LIT64( 0xCE07F766F09588D6 ),
678    LIT64( 0x8000000000000000 ),
679    LIT64( 0x3FCE000400000000 ),
680    LIT64( 0x8313B60F0032BED8 ),
681    LIT64( 0xC1EFFFFFC0002000 ),
682    LIT64( 0x3FB3C75D224F2B0F ),
683    LIT64( 0x7FD00000004000FF ),
684    LIT64( 0xA12FFF8000001FFF ),
685    LIT64( 0x3EE0000000FE0000 ),
686    LIT64( 0x0010000080000004 ),
687    LIT64( 0x41CFFFFE00000020 ),
688    LIT64( 0x40303FFFFFFFFFFD ),
689    LIT64( 0x3FD000003FEFFFFF ),
690    LIT64( 0xBFD0000010000000 ),
691    LIT64( 0xB7FC6B5C16CA55CF ),
692    LIT64( 0x413EEB940B9D1301 ),
693    LIT64( 0xC7E00200001FFFFF ),
694    LIT64( 0x47F00021FFFFFFFE ),
695    LIT64( 0xBFFFFFFFF80000FF ),
696    LIT64( 0xC07FFFFFE00FFFFF ),
697    LIT64( 0x001497A63740C5E8 ),
698    LIT64( 0xC4BFFFE0001FFFFF ),
699    LIT64( 0x96FFDFFEFFFFFFFF ),
700    LIT64( 0x403FC000000001FE ),
701    LIT64( 0xFFD00000000001F6 ),
702    LIT64( 0x0640400002000000 ),
703    LIT64( 0x479CEE1E4F789FE0 ),
704    LIT64( 0xC237FFFFFFFFFDFE )
705};
706
707static void time_a_float64_z_int32( int32 function( float64 ) )
708{
709    clock_t startClock, endClock;
710    int32 count, i;
711    int8 inputNum;
712
713    count = 0;
714    inputNum = 0;
715    startClock = clock();
716    do {
717        for ( i = minIterations; i; --i ) {
718            function( inputs_float64[ inputNum ] );
719            inputNum = ( inputNum + 1 ) & ( numInputs_float64 - 1 );
720        }
721        count += minIterations;
722    } while ( clock() - startClock < CLOCKS_PER_SEC );
723    inputNum = 0;
724    startClock = clock();
725    for ( i = count; i; --i ) {
726        function( inputs_float64[ inputNum ] );
727        inputNum = ( inputNum + 1 ) & ( numInputs_float64 - 1 );
728    }
729    endClock = clock();
730    reportTime( count, endClock - startClock );
731
732}
733
734static void time_a_float64_z_int64( int64 function( float64 ) )
735{
736    clock_t startClock, endClock;
737    int32 count, i;
738    int8 inputNum;
739
740    count = 0;
741    inputNum = 0;
742    startClock = clock();
743    do {
744        for ( i = minIterations; i; --i ) {
745            function( inputs_float64[ inputNum ] );
746            inputNum = ( inputNum + 1 ) & ( numInputs_float64 - 1 );
747        }
748        count += minIterations;
749    } while ( clock() - startClock < CLOCKS_PER_SEC );
750    inputNum = 0;
751    startClock = clock();
752    for ( i = count; i; --i ) {
753        function( inputs_float64[ inputNum ] );
754        inputNum = ( inputNum + 1 ) & ( numInputs_float64 - 1 );
755    }
756    endClock = clock();
757    reportTime( count, endClock - startClock );
758
759}
760
761static void time_a_float64_z_float32( float32 function( float64 ) )
762{
763    clock_t startClock, endClock;
764    int32 count, i;
765    int8 inputNum;
766
767    count = 0;
768    inputNum = 0;
769    startClock = clock();
770    do {
771        for ( i = minIterations; i; --i ) {
772            function( inputs_float64[ inputNum ] );
773            inputNum = ( inputNum + 1 ) & ( numInputs_float64 - 1 );
774        }
775        count += minIterations;
776    } while ( clock() - startClock < CLOCKS_PER_SEC );
777    inputNum = 0;
778    startClock = clock();
779    for ( i = count; i; --i ) {
780        function( inputs_float64[ inputNum ] );
781        inputNum = ( inputNum + 1 ) & ( numInputs_float64 - 1 );
782    }
783    endClock = clock();
784    reportTime( count, endClock - startClock );
785
786}
787
788#ifdef FLOATX80
789
790static void time_a_float64_z_floatx80( floatx80 function( float64 ) )
791{
792    clock_t startClock, endClock;
793    int32 count, i;
794    int8 inputNum;
795
796    count = 0;
797    inputNum = 0;
798    startClock = clock();
799    do {
800        for ( i = minIterations; i; --i ) {
801            function( inputs_float64[ inputNum ] );
802            inputNum = ( inputNum + 1 ) & ( numInputs_float64 - 1 );
803        }
804        count += minIterations;
805    } while ( clock() - startClock < CLOCKS_PER_SEC );
806    inputNum = 0;
807    startClock = clock();
808    for ( i = count; i; --i ) {
809        function( inputs_float64[ inputNum ] );
810        inputNum = ( inputNum + 1 ) & ( numInputs_float64 - 1 );
811    }
812    endClock = clock();
813    reportTime( count, endClock - startClock );
814
815}
816
817#endif
818
819#ifdef FLOAT128
820
821static void time_a_float64_z_float128( float128 function( float64 ) )
822{
823    clock_t startClock, endClock;
824    int32 count, i;
825    int8 inputNum;
826
827    count = 0;
828    inputNum = 0;
829    startClock = clock();
830    do {
831        for ( i = minIterations; i; --i ) {
832            function( inputs_float64[ inputNum ] );
833            inputNum = ( inputNum + 1 ) & ( numInputs_float64 - 1 );
834        }
835        count += minIterations;
836    } while ( clock() - startClock < CLOCKS_PER_SEC );
837    inputNum = 0;
838    startClock = clock();
839    for ( i = count; i; --i ) {
840        function( inputs_float64[ inputNum ] );
841        inputNum = ( inputNum + 1 ) & ( numInputs_float64 - 1 );
842    }
843    endClock = clock();
844    reportTime( count, endClock - startClock );
845
846}
847
848#endif
849
850static void time_az_float64( float64 function( float64 ) )
851{
852    clock_t startClock, endClock;
853    int32 count, i;
854    int8 inputNum;
855
856    count = 0;
857    inputNum = 0;
858    startClock = clock();
859    do {
860        for ( i = minIterations; i; --i ) {
861            function( inputs_float64[ inputNum ] );
862            inputNum = ( inputNum + 1 ) & ( numInputs_float64 - 1 );
863        }
864        count += minIterations;
865    } while ( clock() - startClock < CLOCKS_PER_SEC );
866    inputNum = 0;
867    startClock = clock();
868    for ( i = count; i; --i ) {
869        function( inputs_float64[ inputNum ] );
870        inputNum = ( inputNum + 1 ) & ( numInputs_float64 - 1 );
871    }
872    endClock = clock();
873    reportTime( count, endClock - startClock );
874
875}
876
877static void time_ab_float64_z_flag( flag function( float64, float64 ) )
878{
879    clock_t startClock, endClock;
880    int32 count, i;
881    int8 inputNumA, inputNumB;
882
883    count = 0;
884    inputNumA = 0;
885    inputNumB = 0;
886    startClock = clock();
887    do {
888        for ( i = minIterations; i; --i ) {
889            function(
890                inputs_float64[ inputNumA ], inputs_float64[ inputNumB ] );
891            inputNumA = ( inputNumA + 1 ) & ( numInputs_float64 - 1 );
892            if ( inputNumA == 0 ) ++inputNumB;
893            inputNumB = ( inputNumB + 1 ) & ( numInputs_float64 - 1 );
894        }
895        count += minIterations;
896    } while ( clock() - startClock < CLOCKS_PER_SEC );
897    inputNumA = 0;
898    inputNumB = 0;
899    startClock = clock();
900    for ( i = count; i; --i ) {
901            function(
902                inputs_float64[ inputNumA ], inputs_float64[ inputNumB ] );
903        inputNumA = ( inputNumA + 1 ) & ( numInputs_float64 - 1 );
904        if ( inputNumA == 0 ) ++inputNumB;
905        inputNumB = ( inputNumB + 1 ) & ( numInputs_float64 - 1 );
906    }
907    endClock = clock();
908    reportTime( count, endClock - startClock );
909
910}
911
912static void time_abz_float64( float64 function( float64, float64 ) )
913{
914    clock_t startClock, endClock;
915    int32 count, i;
916    int8 inputNumA, inputNumB;
917
918    count = 0;
919    inputNumA = 0;
920    inputNumB = 0;
921    startClock = clock();
922    do {
923        for ( i = minIterations; i; --i ) {
924            function(
925                inputs_float64[ inputNumA ], inputs_float64[ inputNumB ] );
926            inputNumA = ( inputNumA + 1 ) & ( numInputs_float64 - 1 );
927            if ( inputNumA == 0 ) ++inputNumB;
928            inputNumB = ( inputNumB + 1 ) & ( numInputs_float64 - 1 );
929        }
930        count += minIterations;
931    } while ( clock() - startClock < CLOCKS_PER_SEC );
932    inputNumA = 0;
933    inputNumB = 0;
934    startClock = clock();
935    for ( i = count; i; --i ) {
936            function(
937                inputs_float64[ inputNumA ], inputs_float64[ inputNumB ] );
938        inputNumA = ( inputNumA + 1 ) & ( numInputs_float64 - 1 );
939        if ( inputNumA == 0 ) ++inputNumB;
940        inputNumB = ( inputNumB + 1 ) & ( numInputs_float64 - 1 );
941    }
942    endClock = clock();
943    reportTime( count, endClock - startClock );
944
945}
946
947static const float64 inputs_float64_pos[ numInputs_float64 ] = {
948    LIT64( 0x422FFFC008000000 ),
949    LIT64( 0x37E0000480000000 ),
950    LIT64( 0x73FD2546120B7935 ),
951    LIT64( 0x3FF0000000000000 ),
952    LIT64( 0x4E07F766F09588D6 ),
953    LIT64( 0x0000000000000000 ),
954    LIT64( 0x3FCE000400000000 ),
955    LIT64( 0x0313B60F0032BED8 ),
956    LIT64( 0x41EFFFFFC0002000 ),
957    LIT64( 0x3FB3C75D224F2B0F ),
958    LIT64( 0x7FD00000004000FF ),
959    LIT64( 0x212FFF8000001FFF ),
960    LIT64( 0x3EE0000000FE0000 ),
961    LIT64( 0x0010000080000004 ),
962    LIT64( 0x41CFFFFE00000020 ),
963    LIT64( 0x40303FFFFFFFFFFD ),
964    LIT64( 0x3FD000003FEFFFFF ),
965    LIT64( 0x3FD0000010000000 ),
966    LIT64( 0x37FC6B5C16CA55CF ),
967    LIT64( 0x413EEB940B9D1301 ),
968    LIT64( 0x47E00200001FFFFF ),
969    LIT64( 0x47F00021FFFFFFFE ),
970    LIT64( 0x3FFFFFFFF80000FF ),
971    LIT64( 0x407FFFFFE00FFFFF ),
972    LIT64( 0x001497A63740C5E8 ),
973    LIT64( 0x44BFFFE0001FFFFF ),
974    LIT64( 0x16FFDFFEFFFFFFFF ),
975    LIT64( 0x403FC000000001FE ),
976    LIT64( 0x7FD00000000001F6 ),
977    LIT64( 0x0640400002000000 ),
978    LIT64( 0x479CEE1E4F789FE0 ),
979    LIT64( 0x4237FFFFFFFFFDFE )
980};
981
982static void time_az_float64_pos( float64 function( float64 ) )
983{
984    clock_t startClock, endClock;
985    int32 count, i;
986    int8 inputNum;
987
988    count = 0;
989    inputNum = 0;
990    startClock = clock();
991    do {
992        for ( i = minIterations; i; --i ) {
993            function( inputs_float64_pos[ inputNum ] );
994            inputNum = ( inputNum + 1 ) & ( numInputs_float64 - 1 );
995        }
996        count += minIterations;
997    } while ( clock() - startClock < CLOCKS_PER_SEC );
998    inputNum = 0;
999    startClock = clock();
1000    for ( i = count; i; --i ) {
1001        function( inputs_float64_pos[ inputNum ] );
1002        inputNum = ( inputNum + 1 ) & ( numInputs_float64 - 1 );
1003    }
1004    endClock = clock();
1005    reportTime( count, endClock - startClock );
1006
1007}
1008
1009#ifdef FLOATX80
1010
1011enum {
1012    numInputs_floatx80 = 32
1013};
1014
1015static const struct {
1016    bits16 high;
1017    bits64 low;
1018} inputs_floatx80[ numInputs_floatx80 ] = {
1019    { 0xC03F, LIT64( 0xA9BE15A19C1E8B62 ) },
1020    { 0x8000, LIT64( 0x0000000000000000 ) },
1021    { 0x75A8, LIT64( 0xE59591E4788957A5 ) },
1022    { 0xBFFF, LIT64( 0xFFF0000000000040 ) },
1023    { 0x0CD8, LIT64( 0xFC000000000007FE ) },
1024    { 0x43BA, LIT64( 0x99A4000000000000 ) },
1025    { 0x3FFF, LIT64( 0x8000000000000000 ) },
1026    { 0x4081, LIT64( 0x94FBF1BCEB5545F0 ) },
1027    { 0x403E, LIT64( 0xFFF0000000002000 ) },
1028    { 0x3FFE, LIT64( 0xC860E3C75D224F28 ) },
1029    { 0x407E, LIT64( 0xFC00000FFFFFFFFE ) },
1030    { 0x737A, LIT64( 0x800000007FFDFFFE ) },
1031    { 0x4044, LIT64( 0xFFFFFF80000FFFFF ) },
1032    { 0xBBFE, LIT64( 0x8000040000001FFE ) },
1033    { 0xC002, LIT64( 0xFF80000000000020 ) },
1034    { 0xDE8D, LIT64( 0xFFFFFFFFFFE00004 ) },
1035    { 0xC004, LIT64( 0x8000000000003FFB ) },
1036    { 0x407F, LIT64( 0x800000000003FFFE ) },
1037    { 0xC000, LIT64( 0xA459EE6A5C16CA55 ) },
1038    { 0x8003, LIT64( 0xC42CBF7399AEEB94 ) },
1039    { 0xBF7F, LIT64( 0xF800000000000006 ) },
1040    { 0xC07F, LIT64( 0xBF56BE8871F28FEA ) },
1041    { 0xC07E, LIT64( 0xFFFF77FFFFFFFFFE ) },
1042    { 0xADC9, LIT64( 0x8000000FFFFFFFDE ) },
1043    { 0xC001, LIT64( 0xEFF7FFFFFFFFFFFF ) },
1044    { 0x4001, LIT64( 0xBE84F30125C497A6 ) },
1045    { 0xC06B, LIT64( 0xEFFFFFFFFFFFFFFF ) },
1046    { 0x4080, LIT64( 0xFFFFFFFFBFFFFFFF ) },
1047    { 0x87E9, LIT64( 0x81FFFFFFFFFFFBFF ) },
1048    { 0xA63F, LIT64( 0x801FFFFFFEFFFFFE ) },
1049    { 0x403C, LIT64( 0x801FFFFFFFF7FFFF ) },
1050    { 0x4018, LIT64( 0x8000000000080003 ) }
1051};
1052
1053static void time_a_floatx80_z_int32( int32 function( floatx80 ) )
1054{
1055    clock_t startClock, endClock;
1056    int32 count, i;
1057    int8 inputNum;
1058    floatx80 a;
1059
1060    count = 0;
1061    inputNum = 0;
1062    startClock = clock();
1063    do {
1064        for ( i = minIterations; i; --i ) {
1065            a.low = inputs_floatx80[ inputNum ].low;
1066            a.high = inputs_floatx80[ inputNum ].high;
1067            function( a );
1068            inputNum = ( inputNum + 1 ) & ( numInputs_floatx80 - 1 );
1069        }
1070        count += minIterations;
1071    } while ( clock() - startClock < CLOCKS_PER_SEC );
1072    inputNum = 0;
1073    startClock = clock();
1074    for ( i = count; i; --i ) {
1075        a.low = inputs_floatx80[ inputNum ].low;
1076        a.high = inputs_floatx80[ inputNum ].high;
1077        function( a );
1078        inputNum = ( inputNum + 1 ) & ( numInputs_floatx80 - 1 );
1079    }
1080    endClock = clock();
1081    reportTime( count, endClock - startClock );
1082
1083}
1084
1085static void time_a_floatx80_z_int64( int64 function( floatx80 ) )
1086{
1087    clock_t startClock, endClock;
1088    int32 count, i;
1089    int8 inputNum;
1090    floatx80 a;
1091
1092    count = 0;
1093    inputNum = 0;
1094    startClock = clock();
1095    do {
1096        for ( i = minIterations; i; --i ) {
1097            a.low = inputs_floatx80[ inputNum ].low;
1098            a.high = inputs_floatx80[ inputNum ].high;
1099            function( a );
1100            inputNum = ( inputNum + 1 ) & ( numInputs_floatx80 - 1 );
1101        }
1102        count += minIterations;
1103    } while ( clock() - startClock < CLOCKS_PER_SEC );
1104    inputNum = 0;
1105    startClock = clock();
1106    for ( i = count; i; --i ) {
1107        a.low = inputs_floatx80[ inputNum ].low;
1108        a.high = inputs_floatx80[ inputNum ].high;
1109        function( a );
1110        inputNum = ( inputNum + 1 ) & ( numInputs_floatx80 - 1 );
1111    }
1112    endClock = clock();
1113    reportTime( count, endClock - startClock );
1114
1115}
1116
1117static void time_a_floatx80_z_float32( float32 function( floatx80 ) )
1118{
1119    clock_t startClock, endClock;
1120    int32 count, i;
1121    int8 inputNum;
1122    floatx80 a;
1123
1124    count = 0;
1125    inputNum = 0;
1126    startClock = clock();
1127    do {
1128        for ( i = minIterations; i; --i ) {
1129            a.low = inputs_floatx80[ inputNum ].low;
1130            a.high = inputs_floatx80[ inputNum ].high;
1131            function( a );
1132            inputNum = ( inputNum + 1 ) & ( numInputs_floatx80 - 1 );
1133        }
1134        count += minIterations;
1135    } while ( clock() - startClock < CLOCKS_PER_SEC );
1136    inputNum = 0;
1137    startClock = clock();
1138    for ( i = count; i; --i ) {
1139        a.low = inputs_floatx80[ inputNum ].low;
1140        a.high = inputs_floatx80[ inputNum ].high;
1141        function( a );
1142        inputNum = ( inputNum + 1 ) & ( numInputs_floatx80 - 1 );
1143    }
1144    endClock = clock();
1145    reportTime( count, endClock - startClock );
1146
1147}
1148
1149static void time_a_floatx80_z_float64( float64 function( floatx80 ) )
1150{
1151    clock_t startClock, endClock;
1152    int32 count, i;
1153    int8 inputNum;
1154    floatx80 a;
1155
1156    count = 0;
1157    inputNum = 0;
1158    startClock = clock();
1159    do {
1160        for ( i = minIterations; i; --i ) {
1161            a.low = inputs_floatx80[ inputNum ].low;
1162            a.high = inputs_floatx80[ inputNum ].high;
1163            function( a );
1164            inputNum = ( inputNum + 1 ) & ( numInputs_floatx80 - 1 );
1165        }
1166        count += minIterations;
1167    } while ( clock() - startClock < CLOCKS_PER_SEC );
1168    inputNum = 0;
1169    startClock = clock();
1170    for ( i = count; i; --i ) {
1171        a.low = inputs_floatx80[ inputNum ].low;
1172        a.high = inputs_floatx80[ inputNum ].high;
1173        function( a );
1174        inputNum = ( inputNum + 1 ) & ( numInputs_floatx80 - 1 );
1175    }
1176    endClock = clock();
1177    reportTime( count, endClock - startClock );
1178
1179}
1180
1181#ifdef FLOAT128
1182
1183static void time_a_floatx80_z_float128( float128 function( floatx80 ) )
1184{
1185    clock_t startClock, endClock;
1186    int32 count, i;
1187    int8 inputNum;
1188    floatx80 a;
1189
1190    count = 0;
1191    inputNum = 0;
1192    startClock = clock();
1193    do {
1194        for ( i = minIterations; i; --i ) {
1195            a.low = inputs_floatx80[ inputNum ].low;
1196            a.high = inputs_floatx80[ inputNum ].high;
1197            function( a );
1198            inputNum = ( inputNum + 1 ) & ( numInputs_floatx80 - 1 );
1199        }
1200        count += minIterations;
1201    } while ( clock() - startClock < CLOCKS_PER_SEC );
1202    inputNum = 0;
1203    startClock = clock();
1204    for ( i = count; i; --i ) {
1205        a.low = inputs_floatx80[ inputNum ].low;
1206        a.high = inputs_floatx80[ inputNum ].high;
1207        function( a );
1208        inputNum = ( inputNum + 1 ) & ( numInputs_floatx80 - 1 );
1209    }
1210    endClock = clock();
1211    reportTime( count, endClock - startClock );
1212
1213}
1214
1215#endif
1216
1217static void time_az_floatx80( floatx80 function( floatx80 ) )
1218{
1219    clock_t startClock, endClock;
1220    int32 count, i;
1221    int8 inputNum;
1222    floatx80 a;
1223
1224    count = 0;
1225    inputNum = 0;
1226    startClock = clock();
1227    do {
1228        for ( i = minIterations; i; --i ) {
1229            a.low = inputs_floatx80[ inputNum ].low;
1230            a.high = inputs_floatx80[ inputNum ].high;
1231            function( a );
1232            inputNum = ( inputNum + 1 ) & ( numInputs_floatx80 - 1 );
1233        }
1234        count += minIterations;
1235    } while ( clock() - startClock < CLOCKS_PER_SEC );
1236    inputNum = 0;
1237    startClock = clock();
1238    for ( i = count; i; --i ) {
1239        a.low = inputs_floatx80[ inputNum ].low;
1240        a.high = inputs_floatx80[ inputNum ].high;
1241        function( a );
1242        inputNum = ( inputNum + 1 ) & ( numInputs_floatx80 - 1 );
1243    }
1244    endClock = clock();
1245    reportTime( count, endClock - startClock );
1246
1247}
1248
1249static void time_ab_floatx80_z_flag( flag function( floatx80, floatx80 ) )
1250{
1251    clock_t startClock, endClock;
1252    int32 count, i;
1253    int8 inputNumA, inputNumB;
1254    floatx80 a, b;
1255
1256    count = 0;
1257    inputNumA = 0;
1258    inputNumB = 0;
1259    startClock = clock();
1260    do {
1261        for ( i = minIterations; i; --i ) {
1262            a.low = inputs_floatx80[ inputNumA ].low;
1263            a.high = inputs_floatx80[ inputNumA ].high;
1264            b.low = inputs_floatx80[ inputNumB ].low;
1265            b.high = inputs_floatx80[ inputNumB ].high;
1266            function( a, b );
1267            inputNumA = ( inputNumA + 1 ) & ( numInputs_floatx80 - 1 );
1268            if ( inputNumA == 0 ) ++inputNumB;
1269            inputNumB = ( inputNumB + 1 ) & ( numInputs_floatx80 - 1 );
1270        }
1271        count += minIterations;
1272    } while ( clock() - startClock < CLOCKS_PER_SEC );
1273    inputNumA = 0;
1274    inputNumB = 0;
1275    startClock = clock();
1276    for ( i = count; i; --i ) {
1277        a.low = inputs_floatx80[ inputNumA ].low;
1278        a.high = inputs_floatx80[ inputNumA ].high;
1279        b.low = inputs_floatx80[ inputNumB ].low;
1280        b.high = inputs_floatx80[ inputNumB ].high;
1281        function( a, b );
1282        inputNumA = ( inputNumA + 1 ) & ( numInputs_floatx80 - 1 );
1283        if ( inputNumA == 0 ) ++inputNumB;
1284        inputNumB = ( inputNumB + 1 ) & ( numInputs_floatx80 - 1 );
1285    }
1286    endClock = clock();
1287    reportTime( count, endClock - startClock );
1288
1289}
1290
1291static void time_abz_floatx80( floatx80 function( floatx80, floatx80 ) )
1292{
1293    clock_t startClock, endClock;
1294    int32 count, i;
1295    int8 inputNumA, inputNumB;
1296    floatx80 a, b;
1297
1298    count = 0;
1299    inputNumA = 0;
1300    inputNumB = 0;
1301    startClock = clock();
1302    do {
1303        for ( i = minIterations; i; --i ) {
1304            a.low = inputs_floatx80[ inputNumA ].low;
1305            a.high = inputs_floatx80[ inputNumA ].high;
1306            b.low = inputs_floatx80[ inputNumB ].low;
1307            b.high = inputs_floatx80[ inputNumB ].high;
1308            function( a, b );
1309            inputNumA = ( inputNumA + 1 ) & ( numInputs_floatx80 - 1 );
1310            if ( inputNumA == 0 ) ++inputNumB;
1311            inputNumB = ( inputNumB + 1 ) & ( numInputs_floatx80 - 1 );
1312        }
1313        count += minIterations;
1314    } while ( clock() - startClock < CLOCKS_PER_SEC );
1315    inputNumA = 0;
1316    inputNumB = 0;
1317    startClock = clock();
1318    for ( i = count; i; --i ) {
1319        a.low = inputs_floatx80[ inputNumA ].low;
1320        a.high = inputs_floatx80[ inputNumA ].high;
1321        b.low = inputs_floatx80[ inputNumB ].low;
1322        b.high = inputs_floatx80[ inputNumB ].high;
1323        function( a, b );
1324        inputNumA = ( inputNumA + 1 ) & ( numInputs_floatx80 - 1 );
1325        if ( inputNumA == 0 ) ++inputNumB;
1326        inputNumB = ( inputNumB + 1 ) & ( numInputs_floatx80 - 1 );
1327    }
1328    endClock = clock();
1329    reportTime( count, endClock - startClock );
1330
1331}
1332
1333static const struct {
1334    bits16 high;
1335    bits64 low;
1336} inputs_floatx80_pos[ numInputs_floatx80 ] = {
1337    { 0x403F, LIT64( 0xA9BE15A19C1E8B62 ) },
1338    { 0x0000, LIT64( 0x0000000000000000 ) },
1339    { 0x75A8, LIT64( 0xE59591E4788957A5 ) },
1340    { 0x3FFF, LIT64( 0xFFF0000000000040 ) },
1341    { 0x0CD8, LIT64( 0xFC000000000007FE ) },
1342    { 0x43BA, LIT64( 0x99A4000000000000 ) },
1343    { 0x3FFF, LIT64( 0x8000000000000000 ) },
1344    { 0x4081, LIT64( 0x94FBF1BCEB5545F0 ) },
1345    { 0x403E, LIT64( 0xFFF0000000002000 ) },
1346    { 0x3FFE, LIT64( 0xC860E3C75D224F28 ) },
1347    { 0x407E, LIT64( 0xFC00000FFFFFFFFE ) },
1348    { 0x737A, LIT64( 0x800000007FFDFFFE ) },
1349    { 0x4044, LIT64( 0xFFFFFF80000FFFFF ) },
1350    { 0x3BFE, LIT64( 0x8000040000001FFE ) },
1351    { 0x4002, LIT64( 0xFF80000000000020 ) },
1352    { 0x5E8D, LIT64( 0xFFFFFFFFFFE00004 ) },
1353    { 0x4004, LIT64( 0x8000000000003FFB ) },
1354    { 0x407F, LIT64( 0x800000000003FFFE ) },
1355    { 0x4000, LIT64( 0xA459EE6A5C16CA55 ) },
1356    { 0x0003, LIT64( 0xC42CBF7399AEEB94 ) },
1357    { 0x3F7F, LIT64( 0xF800000000000006 ) },
1358    { 0x407F, LIT64( 0xBF56BE8871F28FEA ) },
1359    { 0x407E, LIT64( 0xFFFF77FFFFFFFFFE ) },
1360    { 0x2DC9, LIT64( 0x8000000FFFFFFFDE ) },
1361    { 0x4001, LIT64( 0xEFF7FFFFFFFFFFFF ) },
1362    { 0x4001, LIT64( 0xBE84F30125C497A6 ) },
1363    { 0x406B, LIT64( 0xEFFFFFFFFFFFFFFF ) },
1364    { 0x4080, LIT64( 0xFFFFFFFFBFFFFFFF ) },
1365    { 0x07E9, LIT64( 0x81FFFFFFFFFFFBFF ) },
1366    { 0x263F, LIT64( 0x801FFFFFFEFFFFFE ) },
1367    { 0x403C, LIT64( 0x801FFFFFFFF7FFFF ) },
1368    { 0x4018, LIT64( 0x8000000000080003 ) }
1369};
1370
1371static void time_az_floatx80_pos( floatx80 function( floatx80 ) )
1372{
1373    clock_t startClock, endClock;
1374    int32 count, i;
1375    int8 inputNum;
1376    floatx80 a;
1377
1378    count = 0;
1379    inputNum = 0;
1380    startClock = clock();
1381    do {
1382        for ( i = minIterations; i; --i ) {
1383            a.low = inputs_floatx80_pos[ inputNum ].low;
1384            a.high = inputs_floatx80_pos[ inputNum ].high;
1385            function( a );
1386            inputNum = ( inputNum + 1 ) & ( numInputs_floatx80 - 1 );
1387        }
1388        count += minIterations;
1389    } while ( clock() - startClock < CLOCKS_PER_SEC );
1390    inputNum = 0;
1391    startClock = clock();
1392    for ( i = count; i; --i ) {
1393        a.low = inputs_floatx80_pos[ inputNum ].low;
1394        a.high = inputs_floatx80_pos[ inputNum ].high;
1395        function( a );
1396        inputNum = ( inputNum + 1 ) & ( numInputs_floatx80 - 1 );
1397    }
1398    endClock = clock();
1399    reportTime( count, endClock - startClock );
1400
1401}
1402
1403#endif
1404
1405#ifdef FLOAT128
1406
1407enum {
1408    numInputs_float128 = 32
1409};
1410
1411static const struct {
1412    bits64 high, low;
1413} inputs_float128[ numInputs_float128 ] = {
1414    { LIT64( 0x3FDA200000100000 ), LIT64( 0x0000000000000000 ) },
1415    { LIT64( 0x3FFF000000000000 ), LIT64( 0x0000000000000000 ) },
1416    { LIT64( 0x85F14776190C8306 ), LIT64( 0xD8715F4E3D54BB92 ) },
1417    { LIT64( 0xF2B00000007FFFFF ), LIT64( 0xFFFFFFFFFFF7FFFF ) },
1418    { LIT64( 0x8000000000000000 ), LIT64( 0x0000000000000000 ) },
1419    { LIT64( 0xBFFFFFFFFFE00000 ), LIT64( 0x0000008000000000 ) },
1420    { LIT64( 0x407F1719CE722F3E ), LIT64( 0xDA6B3FE5FF29425B ) },
1421    { LIT64( 0x43FFFF8000000000 ), LIT64( 0x0000000000400000 ) },
1422    { LIT64( 0x401E000000000100 ), LIT64( 0x0000000000002000 ) },
1423    { LIT64( 0x3FFED71DACDA8E47 ), LIT64( 0x4860E3C75D224F28 ) },
1424    { LIT64( 0xBF7ECFC1E90647D1 ), LIT64( 0x7A124FE55623EE44 ) },
1425    { LIT64( 0x0DF7007FFFFFFFFF ), LIT64( 0xFFFFFFFFEFFFFFFF ) },
1426    { LIT64( 0x3FE5FFEFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFEFFF ) },
1427    { LIT64( 0x403FFFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFBFE ) },
1428    { LIT64( 0xBFFB2FBF7399AFEB ), LIT64( 0xA459EE6A5C16CA55 ) },
1429    { LIT64( 0xBDB8FFFFFFFFFFFC ), LIT64( 0x0000000000000400 ) },
1430    { LIT64( 0x3FC8FFDFFFFFFFFF ), LIT64( 0xFFFFFFFFF0000000 ) },
1431    { LIT64( 0x3FFBFFFFFFDFFFFF ), LIT64( 0xFFF8000000000000 ) },
1432    { LIT64( 0x407043C11737BE84 ), LIT64( 0xDDD58212ADC937F4 ) },
1433    { LIT64( 0x8001000000000000 ), LIT64( 0x0000001000000001 ) },
1434    { LIT64( 0xC036FFFFFFFFFFFF ), LIT64( 0xFE40000000000000 ) },
1435    { LIT64( 0x4002FFFFFE000002 ), LIT64( 0x0000000000000000 ) },
1436    { LIT64( 0x4000C3FEDE897773 ), LIT64( 0x326AC4FD8EFBE6DC ) },
1437    { LIT64( 0xBFFF0000000FFFFF ), LIT64( 0xFFFFFE0000000000 ) },
1438    { LIT64( 0x62C3E502146E426D ), LIT64( 0x43F3CAA0DC7DF1A0 ) },
1439    { LIT64( 0xB5CBD32E52BB570E ), LIT64( 0xBCC477CB11C6236C ) },
1440    { LIT64( 0xE228FFFFFFC00000 ), LIT64( 0x0000000000000000 ) },
1441    { LIT64( 0x3F80000000000000 ), LIT64( 0x0000000080000008 ) },
1442    { LIT64( 0xC1AFFFDFFFFFFFFF ), LIT64( 0xFFFC000000000000 ) },
1443    { LIT64( 0xC96F000000000000 ), LIT64( 0x00000001FFFBFFFF ) },
1444    { LIT64( 0x3DE09BFE7923A338 ), LIT64( 0xBCC8FBBD7CEC1F4F ) },
1445    { LIT64( 0x401CFFFFFFFFFFFF ), LIT64( 0xFFFFFFFEFFFFFF80 ) }
1446};
1447
1448static void time_a_float128_z_int32( int32 function( float128 ) )
1449{
1450    clock_t startClock, endClock;
1451    int32 count, i;
1452    int8 inputNum;
1453    float128 a;
1454
1455    count = 0;
1456    inputNum = 0;
1457    startClock = clock();
1458    do {
1459        for ( i = minIterations; i; --i ) {
1460            a.low = inputs_float128[ inputNum ].low;
1461            a.high = inputs_float128[ inputNum ].high;
1462            function( a );
1463            inputNum = ( inputNum + 1 ) & ( numInputs_float128 - 1 );
1464        }
1465        count += minIterations;
1466    } while ( clock() - startClock < CLOCKS_PER_SEC );
1467    inputNum = 0;
1468    startClock = clock();
1469    for ( i = count; i; --i ) {
1470        a.low = inputs_float128[ inputNum ].low;
1471        a.high = inputs_float128[ inputNum ].high;
1472        function( a );
1473        inputNum = ( inputNum + 1 ) & ( numInputs_float128 - 1 );
1474    }
1475    endClock = clock();
1476    reportTime( count, endClock - startClock );
1477
1478}
1479
1480static void time_a_float128_z_int64( int64 function( float128 ) )
1481{
1482    clock_t startClock, endClock;
1483    int32 count, i;
1484    int8 inputNum;
1485    float128 a;
1486
1487    count = 0;
1488    inputNum = 0;
1489    startClock = clock();
1490    do {
1491        for ( i = minIterations; i; --i ) {
1492            a.low = inputs_float128[ inputNum ].low;
1493            a.high = inputs_float128[ inputNum ].high;
1494            function( a );
1495            inputNum = ( inputNum + 1 ) & ( numInputs_float128 - 1 );
1496        }
1497        count += minIterations;
1498    } while ( clock() - startClock < CLOCKS_PER_SEC );
1499    inputNum = 0;
1500    startClock = clock();
1501    for ( i = count; i; --i ) {
1502        a.low = inputs_float128[ inputNum ].low;
1503        a.high = inputs_float128[ inputNum ].high;
1504        function( a );
1505        inputNum = ( inputNum + 1 ) & ( numInputs_float128 - 1 );
1506    }
1507    endClock = clock();
1508    reportTime( count, endClock - startClock );
1509
1510}
1511
1512static void time_a_float128_z_float32( float32 function( float128 ) )
1513{
1514    clock_t startClock, endClock;
1515    int32 count, i;
1516    int8 inputNum;
1517    float128 a;
1518
1519    count = 0;
1520    inputNum = 0;
1521    startClock = clock();
1522    do {
1523        for ( i = minIterations; i; --i ) {
1524            a.low = inputs_float128[ inputNum ].low;
1525            a.high = inputs_float128[ inputNum ].high;
1526            function( a );
1527            inputNum = ( inputNum + 1 ) & ( numInputs_float128 - 1 );
1528        }
1529        count += minIterations;
1530    } while ( clock() - startClock < CLOCKS_PER_SEC );
1531    inputNum = 0;
1532    startClock = clock();
1533    for ( i = count; i; --i ) {
1534        a.low = inputs_float128[ inputNum ].low;
1535        a.high = inputs_float128[ inputNum ].high;
1536        function( a );
1537        inputNum = ( inputNum + 1 ) & ( numInputs_float128 - 1 );
1538    }
1539    endClock = clock();
1540    reportTime( count, endClock - startClock );
1541
1542}
1543
1544static void time_a_float128_z_float64( float64 function( float128 ) )
1545{
1546    clock_t startClock, endClock;
1547    int32 count, i;
1548    int8 inputNum;
1549    float128 a;
1550
1551    count = 0;
1552    inputNum = 0;
1553    startClock = clock();
1554    do {
1555        for ( i = minIterations; i; --i ) {
1556            a.low = inputs_float128[ inputNum ].low;
1557            a.high = inputs_float128[ inputNum ].high;
1558            function( a );
1559            inputNum = ( inputNum + 1 ) & ( numInputs_float128 - 1 );
1560        }
1561        count += minIterations;
1562    } while ( clock() - startClock < CLOCKS_PER_SEC );
1563    inputNum = 0;
1564    startClock = clock();
1565    for ( i = count; i; --i ) {
1566        a.low = inputs_float128[ inputNum ].low;
1567        a.high = inputs_float128[ inputNum ].high;
1568        function( a );
1569        inputNum = ( inputNum + 1 ) & ( numInputs_float128 - 1 );
1570    }
1571    endClock = clock();
1572    reportTime( count, endClock - startClock );
1573
1574}
1575
1576#ifdef FLOATX80
1577
1578static void time_a_float128_z_floatx80( floatx80 function( float128 ) )
1579{
1580    clock_t startClock, endClock;
1581    int32 count, i;
1582    int8 inputNum;
1583    float128 a;
1584
1585    count = 0;
1586    inputNum = 0;
1587    startClock = clock();
1588    do {
1589        for ( i = minIterations; i; --i ) {
1590            a.low = inputs_float128[ inputNum ].low;
1591            a.high = inputs_float128[ inputNum ].high;
1592            function( a );
1593            inputNum = ( inputNum + 1 ) & ( numInputs_float128 - 1 );
1594        }
1595        count += minIterations;
1596    } while ( clock() - startClock < CLOCKS_PER_SEC );
1597    inputNum = 0;
1598    startClock = clock();
1599    for ( i = count; i; --i ) {
1600        a.low = inputs_float128[ inputNum ].low;
1601        a.high = inputs_float128[ inputNum ].high;
1602        function( a );
1603        inputNum = ( inputNum + 1 ) & ( numInputs_float128 - 1 );
1604    }
1605    endClock = clock();
1606    reportTime( count, endClock - startClock );
1607
1608}
1609
1610#endif
1611
1612static void time_az_float128( float128 function( float128 ) )
1613{
1614    clock_t startClock, endClock;
1615    int32 count, i;
1616    int8 inputNum;
1617    float128 a;
1618
1619    count = 0;
1620    inputNum = 0;
1621    startClock = clock();
1622    do {
1623        for ( i = minIterations; i; --i ) {
1624            a.low = inputs_float128[ inputNum ].low;
1625            a.high = inputs_float128[ inputNum ].high;
1626            function( a );
1627            inputNum = ( inputNum + 1 ) & ( numInputs_float128 - 1 );
1628        }
1629        count += minIterations;
1630    } while ( clock() - startClock < CLOCKS_PER_SEC );
1631    inputNum = 0;
1632    startClock = clock();
1633    for ( i = count; i; --i ) {
1634        a.low = inputs_float128[ inputNum ].low;
1635        a.high = inputs_float128[ inputNum ].high;
1636        function( a );
1637        inputNum = ( inputNum + 1 ) & ( numInputs_float128 - 1 );
1638    }
1639    endClock = clock();
1640    reportTime( count, endClock - startClock );
1641
1642}
1643
1644static void time_ab_float128_z_flag( flag function( float128, float128 ) )
1645{
1646    clock_t startClock, endClock;
1647    int32 count, i;
1648    int8 inputNumA, inputNumB;
1649    float128 a, b;
1650
1651    count = 0;
1652    inputNumA = 0;
1653    inputNumB = 0;
1654    startClock = clock();
1655    do {
1656        for ( i = minIterations; i; --i ) {
1657            a.low = inputs_float128[ inputNumA ].low;
1658            a.high = inputs_float128[ inputNumA ].high;
1659            b.low = inputs_float128[ inputNumB ].low;
1660            b.high = inputs_float128[ inputNumB ].high;
1661            function( a, b );
1662            inputNumA = ( inputNumA + 1 ) & ( numInputs_float128 - 1 );
1663            if ( inputNumA == 0 ) ++inputNumB;
1664            inputNumB = ( inputNumB + 1 ) & ( numInputs_float128 - 1 );
1665        }
1666        count += minIterations;
1667    } while ( clock() - startClock < CLOCKS_PER_SEC );
1668    inputNumA = 0;
1669    inputNumB = 0;
1670    startClock = clock();
1671    for ( i = count; i; --i ) {
1672        a.low = inputs_float128[ inputNumA ].low;
1673        a.high = inputs_float128[ inputNumA ].high;
1674        b.low = inputs_float128[ inputNumB ].low;
1675        b.high = inputs_float128[ inputNumB ].high;
1676        function( a, b );
1677        inputNumA = ( inputNumA + 1 ) & ( numInputs_float128 - 1 );
1678        if ( inputNumA == 0 ) ++inputNumB;
1679        inputNumB = ( inputNumB + 1 ) & ( numInputs_float128 - 1 );
1680    }
1681    endClock = clock();
1682    reportTime( count, endClock - startClock );
1683
1684}
1685
1686static void time_abz_float128( float128 function( float128, float128 ) )
1687{
1688    clock_t startClock, endClock;
1689    int32 count, i;
1690    int8 inputNumA, inputNumB;
1691    float128 a, b;
1692
1693    count = 0;
1694    inputNumA = 0;
1695    inputNumB = 0;
1696    startClock = clock();
1697    do {
1698        for ( i = minIterations; i; --i ) {
1699            a.low = inputs_float128[ inputNumA ].low;
1700            a.high = inputs_float128[ inputNumA ].high;
1701            b.low = inputs_float128[ inputNumB ].low;
1702            b.high = inputs_float128[ inputNumB ].high;
1703            function( a, b );
1704            inputNumA = ( inputNumA + 1 ) & ( numInputs_float128 - 1 );
1705            if ( inputNumA == 0 ) ++inputNumB;
1706            inputNumB = ( inputNumB + 1 ) & ( numInputs_float128 - 1 );
1707        }
1708        count += minIterations;
1709    } while ( clock() - startClock < CLOCKS_PER_SEC );
1710    inputNumA = 0;
1711    inputNumB = 0;
1712    startClock = clock();
1713    for ( i = count; i; --i ) {
1714        a.low = inputs_float128[ inputNumA ].low;
1715        a.high = inputs_float128[ inputNumA ].high;
1716        b.low = inputs_float128[ inputNumB ].low;
1717        b.high = inputs_float128[ inputNumB ].high;
1718        function( a, b );
1719        inputNumA = ( inputNumA + 1 ) & ( numInputs_float128 - 1 );
1720        if ( inputNumA == 0 ) ++inputNumB;
1721        inputNumB = ( inputNumB + 1 ) & ( numInputs_float128 - 1 );
1722    }
1723    endClock = clock();
1724    reportTime( count, endClock - startClock );
1725
1726}
1727
1728static const struct {
1729    bits64 high, low;
1730} inputs_float128_pos[ numInputs_float128 ] = {
1731    { LIT64( 0x3FDA200000100000 ), LIT64( 0x0000000000000000 ) },
1732    { LIT64( 0x3FFF000000000000 ), LIT64( 0x0000000000000000 ) },
1733    { LIT64( 0x05F14776190C8306 ), LIT64( 0xD8715F4E3D54BB92 ) },
1734    { LIT64( 0x72B00000007FFFFF ), LIT64( 0xFFFFFFFFFFF7FFFF ) },
1735    { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000000000 ) },
1736    { LIT64( 0x3FFFFFFFFFE00000 ), LIT64( 0x0000008000000000 ) },
1737    { LIT64( 0x407F1719CE722F3E ), LIT64( 0xDA6B3FE5FF29425B ) },
1738    { LIT64( 0x43FFFF8000000000 ), LIT64( 0x0000000000400000 ) },
1739    { LIT64( 0x401E000000000100 ), LIT64( 0x0000000000002000 ) },
1740    { LIT64( 0x3FFED71DACDA8E47 ), LIT64( 0x4860E3C75D224F28 ) },
1741    { LIT64( 0x3F7ECFC1E90647D1 ), LIT64( 0x7A124FE55623EE44 ) },
1742    { LIT64( 0x0DF7007FFFFFFFFF ), LIT64( 0xFFFFFFFFEFFFFFFF ) },
1743    { LIT64( 0x3FE5FFEFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFEFFF ) },
1744    { LIT64( 0x403FFFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFBFE ) },
1745    { LIT64( 0x3FFB2FBF7399AFEB ), LIT64( 0xA459EE6A5C16CA55 ) },
1746    { LIT64( 0x3DB8FFFFFFFFFFFC ), LIT64( 0x0000000000000400 ) },
1747    { LIT64( 0x3FC8FFDFFFFFFFFF ), LIT64( 0xFFFFFFFFF0000000 ) },
1748    { LIT64( 0x3FFBFFFFFFDFFFFF ), LIT64( 0xFFF8000000000000 ) },
1749    { LIT64( 0x407043C11737BE84 ), LIT64( 0xDDD58212ADC937F4 ) },
1750    { LIT64( 0x0001000000000000 ), LIT64( 0x0000001000000001 ) },
1751    { LIT64( 0x4036FFFFFFFFFFFF ), LIT64( 0xFE40000000000000 ) },
1752    { LIT64( 0x4002FFFFFE000002 ), LIT64( 0x0000000000000000 ) },
1753    { LIT64( 0x4000C3FEDE897773 ), LIT64( 0x326AC4FD8EFBE6DC ) },
1754    { LIT64( 0x3FFF0000000FFFFF ), LIT64( 0xFFFFFE0000000000 ) },
1755    { LIT64( 0x62C3E502146E426D ), LIT64( 0x43F3CAA0DC7DF1A0 ) },
1756    { LIT64( 0x35CBD32E52BB570E ), LIT64( 0xBCC477CB11C6236C ) },
1757    { LIT64( 0x6228FFFFFFC00000 ), LIT64( 0x0000000000000000 ) },
1758    { LIT64( 0x3F80000000000000 ), LIT64( 0x0000000080000008 ) },
1759    { LIT64( 0x41AFFFDFFFFFFFFF ), LIT64( 0xFFFC000000000000 ) },
1760    { LIT64( 0x496F000000000000 ), LIT64( 0x00000001FFFBFFFF ) },
1761    { LIT64( 0x3DE09BFE7923A338 ), LIT64( 0xBCC8FBBD7CEC1F4F ) },
1762    { LIT64( 0x401CFFFFFFFFFFFF ), LIT64( 0xFFFFFFFEFFFFFF80 ) }
1763};
1764
1765static void time_az_float128_pos( float128 function( float128 ) )
1766{
1767    clock_t startClock, endClock;
1768    int32 count, i;
1769    int8 inputNum;
1770    float128 a;
1771
1772    count = 0;
1773    inputNum = 0;
1774    startClock = clock();
1775    do {
1776        for ( i = minIterations; i; --i ) {
1777            a.low = inputs_float128_pos[ inputNum ].low;
1778            a.high = inputs_float128_pos[ inputNum ].high;
1779            function( a );
1780            inputNum = ( inputNum + 1 ) & ( numInputs_float128 - 1 );
1781        }
1782        count += minIterations;
1783    } while ( clock() - startClock < CLOCKS_PER_SEC );
1784    inputNum = 0;
1785    startClock = clock();
1786    for ( i = count; i; --i ) {
1787        a.low = inputs_float128_pos[ inputNum ].low;
1788        a.high = inputs_float128_pos[ inputNum ].high;
1789        function( a );
1790        inputNum = ( inputNum + 1 ) & ( numInputs_float128 - 1 );
1791    }
1792    endClock = clock();
1793    reportTime( count, endClock - startClock );
1794
1795}
1796
1797#endif
1798
1799enum {
1800    INT32_TO_FLOAT32 = 1,
1801    INT32_TO_FLOAT64,
1802#ifdef FLOATX80
1803    INT32_TO_FLOATX80,
1804#endif
1805#ifdef FLOAT128
1806    INT32_TO_FLOAT128,
1807#endif
1808    INT64_TO_FLOAT32,
1809    INT64_TO_FLOAT64,
1810#ifdef FLOATX80
1811    INT64_TO_FLOATX80,
1812#endif
1813#ifdef FLOAT128
1814    INT64_TO_FLOAT128,
1815#endif
1816    FLOAT32_TO_INT32,
1817    FLOAT32_TO_INT32_ROUND_TO_ZERO,
1818    FLOAT32_TO_INT64,
1819    FLOAT32_TO_INT64_ROUND_TO_ZERO,
1820    FLOAT32_TO_FLOAT64,
1821#ifdef FLOATX80
1822    FLOAT32_TO_FLOATX80,
1823#endif
1824#ifdef FLOAT128
1825    FLOAT32_TO_FLOAT128,
1826#endif
1827    FLOAT32_ROUND_TO_INT,
1828    FLOAT32_ADD,
1829    FLOAT32_SUB,
1830    FLOAT32_MUL,
1831    FLOAT32_DIV,
1832    FLOAT32_REM,
1833    FLOAT32_SQRT,
1834    FLOAT32_EQ,
1835    FLOAT32_LE,
1836    FLOAT32_LT,
1837    FLOAT32_EQ_SIGNALING,
1838    FLOAT32_LE_QUIET,
1839    FLOAT32_LT_QUIET,
1840    FLOAT64_TO_INT32,
1841    FLOAT64_TO_INT32_ROUND_TO_ZERO,
1842    FLOAT64_TO_INT64,
1843    FLOAT64_TO_INT64_ROUND_TO_ZERO,
1844    FLOAT64_TO_FLOAT32,
1845#ifdef FLOATX80
1846    FLOAT64_TO_FLOATX80,
1847#endif
1848#ifdef FLOAT128
1849    FLOAT64_TO_FLOAT128,
1850#endif
1851    FLOAT64_ROUND_TO_INT,
1852    FLOAT64_ADD,
1853    FLOAT64_SUB,
1854    FLOAT64_MUL,
1855    FLOAT64_DIV,
1856    FLOAT64_REM,
1857    FLOAT64_SQRT,
1858    FLOAT64_EQ,
1859    FLOAT64_LE,
1860    FLOAT64_LT,
1861    FLOAT64_EQ_SIGNALING,
1862    FLOAT64_LE_QUIET,
1863    FLOAT64_LT_QUIET,
1864#ifdef FLOATX80
1865    FLOATX80_TO_INT32,
1866    FLOATX80_TO_INT32_ROUND_TO_ZERO,
1867    FLOATX80_TO_INT64,
1868    FLOATX80_TO_INT64_ROUND_TO_ZERO,
1869    FLOATX80_TO_FLOAT32,
1870    FLOATX80_TO_FLOAT64,
1871#ifdef FLOAT128
1872    FLOATX80_TO_FLOAT128,
1873#endif
1874    FLOATX80_ROUND_TO_INT,
1875    FLOATX80_ADD,
1876    FLOATX80_SUB,
1877    FLOATX80_MUL,
1878    FLOATX80_DIV,
1879    FLOATX80_REM,
1880    FLOATX80_SQRT,
1881    FLOATX80_EQ,
1882    FLOATX80_LE,
1883    FLOATX80_LT,
1884    FLOATX80_EQ_SIGNALING,
1885    FLOATX80_LE_QUIET,
1886    FLOATX80_LT_QUIET,
1887#endif
1888#ifdef FLOAT128
1889    FLOAT128_TO_INT32,
1890    FLOAT128_TO_INT32_ROUND_TO_ZERO,
1891    FLOAT128_TO_INT64,
1892    FLOAT128_TO_INT64_ROUND_TO_ZERO,
1893    FLOAT128_TO_FLOAT32,
1894    FLOAT128_TO_FLOAT64,
1895#ifdef FLOATX80
1896    FLOAT128_TO_FLOATX80,
1897#endif
1898    FLOAT128_ROUND_TO_INT,
1899    FLOAT128_ADD,
1900    FLOAT128_SUB,
1901    FLOAT128_MUL,
1902    FLOAT128_DIV,
1903    FLOAT128_REM,
1904    FLOAT128_SQRT,
1905    FLOAT128_EQ,
1906    FLOAT128_LE,
1907    FLOAT128_LT,
1908    FLOAT128_EQ_SIGNALING,
1909    FLOAT128_LE_QUIET,
1910    FLOAT128_LT_QUIET,
1911#endif
1912    NUM_FUNCTIONS
1913};
1914
1915static struct {
1916    char *name;
1917    int8 numInputs;
1918    flag roundingPrecision, roundingMode;
1919    flag tininessMode, tininessModeAtReducedPrecision;
1920} functions[ NUM_FUNCTIONS ] = {
1921    { 0, 0, 0, 0, 0, 0 },
1922    { "int32_to_float32",                1, FALSE, TRUE,  FALSE, FALSE },
1923    { "int32_to_float64",                1, FALSE, FALSE, FALSE, FALSE },
1924#ifdef FLOATX80
1925    { "int32_to_floatx80",               1, FALSE, FALSE, FALSE, FALSE },
1926#endif
1927#ifdef FLOAT128
1928    { "int32_to_float128",               1, FALSE, FALSE, FALSE, FALSE },
1929#endif
1930    { "int64_to_float32",                1, FALSE, TRUE,  FALSE, FALSE },
1931    { "int64_to_float64",                1, FALSE, TRUE,  FALSE, FALSE },
1932#ifdef FLOATX80
1933    { "int64_to_floatx80",               1, FALSE, FALSE, FALSE, FALSE },
1934#endif
1935#ifdef FLOAT128
1936    { "int64_to_float128",               1, FALSE, FALSE, FALSE, FALSE },
1937#endif
1938    { "float32_to_int32",                1, FALSE, TRUE,  FALSE, FALSE },
1939    { "float32_to_int32_round_to_zero",  1, FALSE, FALSE, FALSE, FALSE },
1940    { "float32_to_int64",                1, FALSE, TRUE,  FALSE, FALSE },
1941    { "float32_to_int64_round_to_zero",  1, FALSE, FALSE, FALSE, FALSE },
1942    { "float32_to_float64",              1, FALSE, FALSE, FALSE, FALSE },
1943#ifdef FLOATX80
1944    { "float32_to_floatx80",             1, FALSE, FALSE, FALSE, FALSE },
1945#endif
1946#ifdef FLOAT128
1947    { "float32_to_float128",             1, FALSE, FALSE, FALSE, FALSE },
1948#endif
1949    { "float32_round_to_int",            1, FALSE, TRUE,  FALSE, FALSE },
1950    { "float32_add",                     2, FALSE, TRUE,  FALSE, FALSE },
1951    { "float32_sub",                     2, FALSE, TRUE,  FALSE, FALSE },
1952    { "float32_mul",                     2, FALSE, TRUE,  TRUE,  FALSE },
1953    { "float32_div",                     2, FALSE, TRUE,  FALSE, FALSE },
1954    { "float32_rem",                     2, FALSE, FALSE, FALSE, FALSE },
1955    { "float32_sqrt",                    1, FALSE, TRUE,  FALSE, FALSE },
1956    { "float32_eq",                      2, FALSE, FALSE, FALSE, FALSE },
1957    { "float32_le",                      2, FALSE, FALSE, FALSE, FALSE },
1958    { "float32_lt",                      2, FALSE, FALSE, FALSE, FALSE },
1959    { "float32_eq_signaling",            2, FALSE, FALSE, FALSE, FALSE },
1960    { "float32_le_quiet",                2, FALSE, FALSE, FALSE, FALSE },
1961    { "float32_lt_quiet",                2, FALSE, FALSE, FALSE, FALSE },
1962    { "float64_to_int32",                1, FALSE, TRUE,  FALSE, FALSE },
1963    { "float64_to_int32_round_to_zero",  1, FALSE, FALSE, FALSE, FALSE },
1964    { "float64_to_int64",                1, FALSE, TRUE,  FALSE, FALSE },
1965    { "float64_to_int64_round_to_zero",  1, FALSE, FALSE, FALSE, FALSE },
1966    { "float64_to_float32",              1, FALSE, TRUE,  TRUE,  FALSE },
1967#ifdef FLOATX80
1968    { "float64_to_floatx80",             1, FALSE, FALSE, FALSE, FALSE },
1969#endif
1970#ifdef FLOAT128
1971    { "float64_to_float128",             1, FALSE, FALSE, FALSE, FALSE },
1972#endif
1973    { "float64_round_to_int",            1, FALSE, TRUE,  FALSE, FALSE },
1974    { "float64_add",                     2, FALSE, TRUE,  FALSE, FALSE },
1975    { "float64_sub",                     2, FALSE, TRUE,  FALSE, FALSE },
1976    { "float64_mul",                     2, FALSE, TRUE,  TRUE,  FALSE },
1977    { "float64_div",                     2, FALSE, TRUE,  FALSE, FALSE },
1978    { "float64_rem",                     2, FALSE, FALSE, FALSE, FALSE },
1979    { "float64_sqrt",                    1, FALSE, TRUE,  FALSE, FALSE },
1980    { "float64_eq",                      2, FALSE, FALSE, FALSE, FALSE },
1981    { "float64_le",                      2, FALSE, FALSE, FALSE, FALSE },
1982    { "float64_lt",                      2, FALSE, FALSE, FALSE, FALSE },
1983    { "float64_eq_signaling",            2, FALSE, FALSE, FALSE, FALSE },
1984    { "float64_le_quiet",                2, FALSE, FALSE, FALSE, FALSE },
1985    { "float64_lt_quiet",                2, FALSE, FALSE, FALSE, FALSE },
1986#ifdef FLOATX80
1987    { "floatx80_to_int32",               1, FALSE, TRUE,  FALSE, FALSE },
1988    { "floatx80_to_int32_round_to_zero", 1, FALSE, FALSE, FALSE, FALSE },
1989    { "floatx80_to_int64",               1, FALSE, TRUE,  FALSE, FALSE },
1990    { "floatx80_to_int64_round_to_zero", 1, FALSE, FALSE, FALSE, FALSE },
1991    { "floatx80_to_float32",             1, FALSE, TRUE,  TRUE,  FALSE },
1992    { "floatx80_to_float64",             1, FALSE, TRUE,  TRUE,  FALSE },
1993#ifdef FLOAT128
1994    { "floatx80_to_float128",            1, FALSE, FALSE, FALSE, FALSE },
1995#endif
1996    { "floatx80_round_to_int",           1, FALSE, TRUE,  FALSE, FALSE },
1997    { "floatx80_add",                    2, TRUE,  TRUE,  FALSE, TRUE  },
1998    { "floatx80_sub",                    2, TRUE,  TRUE,  FALSE, TRUE  },
1999    { "floatx80_mul",                    2, TRUE,  TRUE,  TRUE,  TRUE  },
2000    { "floatx80_div",                    2, TRUE,  TRUE,  FALSE, TRUE  },
2001    { "floatx80_rem",                    2, FALSE, FALSE, FALSE, FALSE },
2002    { "floatx80_sqrt",                   1, TRUE,  TRUE,  FALSE, FALSE },
2003    { "floatx80_eq",                     2, FALSE, FALSE, FALSE, FALSE },
2004    { "floatx80_le",                     2, FALSE, FALSE, FALSE, FALSE },
2005    { "floatx80_lt",                     2, FALSE, FALSE, FALSE, FALSE },
2006    { "floatx80_eq_signaling",           2, FALSE, FALSE, FALSE, FALSE },
2007    { "floatx80_le_quiet",               2, FALSE, FALSE, FALSE, FALSE },
2008    { "floatx80_lt_quiet",               2, FALSE, FALSE, FALSE, FALSE },
2009#endif
2010#ifdef FLOAT128
2011    { "float128_to_int32",               1, FALSE, TRUE,  FALSE, FALSE },
2012    { "float128_to_int32_round_to_zero", 1, FALSE, FALSE, FALSE, FALSE },
2013    { "float128_to_int64",               1, FALSE, TRUE,  FALSE, FALSE },
2014    { "float128_to_int64_round_to_zero", 1, FALSE, FALSE, FALSE, FALSE },
2015    { "float128_to_float32",             1, FALSE, TRUE,  TRUE,  FALSE },
2016    { "float128_to_float64",             1, FALSE, TRUE,  TRUE,  FALSE },
2017#ifdef FLOATX80
2018    { "float128_to_floatx80",            1, FALSE, TRUE,  TRUE,  FALSE },
2019#endif
2020    { "float128_round_to_int",           1, FALSE, TRUE,  FALSE, FALSE },
2021    { "float128_add",                    2, FALSE, TRUE,  FALSE, FALSE },
2022    { "float128_sub",                    2, FALSE, TRUE,  FALSE, FALSE },
2023    { "float128_mul",                    2, FALSE, TRUE,  TRUE,  FALSE },
2024    { "float128_div",                    2, FALSE, TRUE,  FALSE, FALSE },
2025    { "float128_rem",                    2, FALSE, FALSE, FALSE, FALSE },
2026    { "float128_sqrt",                   1, FALSE, TRUE,  FALSE, FALSE },
2027    { "float128_eq",                     2, FALSE, FALSE, FALSE, FALSE },
2028    { "float128_le",                     2, FALSE, FALSE, FALSE, FALSE },
2029    { "float128_lt",                     2, FALSE, FALSE, FALSE, FALSE },
2030    { "float128_eq_signaling",           2, FALSE, FALSE, FALSE, FALSE },
2031    { "float128_le_quiet",               2, FALSE, FALSE, FALSE, FALSE },
2032    { "float128_lt_quiet",               2, FALSE, FALSE, FALSE, FALSE },
2033#endif
2034};
2035
2036enum {
2037    ROUND_NEAREST_EVEN = 1,
2038    ROUND_TO_ZERO,
2039    ROUND_DOWN,
2040    ROUND_UP,
2041    NUM_ROUNDINGMODES
2042};
2043enum {
2044    TININESS_BEFORE_ROUNDING = 1,
2045    TININESS_AFTER_ROUNDING,
2046    NUM_TININESSMODES
2047};
2048
2049static void
2050 timeFunctionVariety(
2051     uint8 functionCode,
2052     int8 roundingPrecision,
2053     int8 roundingMode,
2054     int8 tininessMode
2055 )
2056{
2057    uint8 roundingCode;
2058    int8 tininessCode;
2059
2060    functionName = functions[ functionCode ].name;
2061    if ( roundingPrecision == 32 ) {
2062        roundingPrecisionName = "32";
2063    }
2064    else if ( roundingPrecision == 64 ) {
2065        roundingPrecisionName = "64";
2066    }
2067    else if ( roundingPrecision == 80 ) {
2068        roundingPrecisionName = "80";
2069    }
2070    else {
2071        roundingPrecisionName = NULL;
2072    }
2073#ifdef FLOATX80
2074    floatx80_rounding_precision = roundingPrecision;
2075#endif
2076    switch ( roundingMode ) {
2077     case 0:
2078        roundingModeName = NULL;
2079        roundingCode = float_round_nearest_even;
2080        break;
2081     case ROUND_NEAREST_EVEN:
2082        roundingModeName = "nearest_even";
2083        roundingCode = float_round_nearest_even;
2084        break;
2085     case ROUND_TO_ZERO:
2086        roundingModeName = "to_zero";
2087        roundingCode = float_round_to_zero;
2088        break;
2089     case ROUND_DOWN:
2090        roundingModeName = "down";
2091        roundingCode = float_round_down;
2092        break;
2093     case ROUND_UP:
2094        roundingModeName = "up";
2095        roundingCode = float_round_up;
2096        break;
2097    }
2098    float_rounding_mode = roundingCode;
2099    switch ( tininessMode ) {
2100     case 0:
2101        tininessModeName = NULL;
2102        tininessCode = float_tininess_after_rounding;
2103        break;
2104     case TININESS_BEFORE_ROUNDING:
2105        tininessModeName = "before";
2106        tininessCode = float_tininess_before_rounding;
2107        break;
2108     case TININESS_AFTER_ROUNDING:
2109        tininessModeName = "after";
2110        tininessCode = float_tininess_after_rounding;
2111        break;
2112    }
2113    float_detect_tininess = tininessCode;
2114    switch ( functionCode ) {
2115     case INT32_TO_FLOAT32:
2116        time_a_int32_z_float32( int32_to_float32 );
2117        break;
2118     case INT32_TO_FLOAT64:
2119        time_a_int32_z_float64( int32_to_float64 );
2120        break;
2121#ifdef FLOATX80
2122     case INT32_TO_FLOATX80:
2123        time_a_int32_z_floatx80( int32_to_floatx80 );
2124        break;
2125#endif
2126#ifdef FLOAT128
2127     case INT32_TO_FLOAT128:
2128        time_a_int32_z_float128( int32_to_float128 );
2129        break;
2130#endif
2131     case INT64_TO_FLOAT32:
2132        time_a_int64_z_float32( int64_to_float32 );
2133        break;
2134     case INT64_TO_FLOAT64:
2135        time_a_int64_z_float64( int64_to_float64 );
2136        break;
2137#ifdef FLOATX80
2138     case INT64_TO_FLOATX80:
2139        time_a_int64_z_floatx80( int64_to_floatx80 );
2140        break;
2141#endif
2142#ifdef FLOAT128
2143     case INT64_TO_FLOAT128:
2144        time_a_int64_z_float128( int64_to_float128 );
2145        break;
2146#endif
2147     case FLOAT32_TO_INT32:
2148        time_a_float32_z_int32( float32_to_int32 );
2149        break;
2150     case FLOAT32_TO_INT32_ROUND_TO_ZERO:
2151        time_a_float32_z_int32( float32_to_int32_round_to_zero );
2152        break;
2153     case FLOAT32_TO_INT64:
2154        time_a_float32_z_int64( float32_to_int64 );
2155        break;
2156     case FLOAT32_TO_INT64_ROUND_TO_ZERO:
2157        time_a_float32_z_int64( float32_to_int64_round_to_zero );
2158        break;
2159     case FLOAT32_TO_FLOAT64:
2160        time_a_float32_z_float64( float32_to_float64 );
2161        break;
2162#ifdef FLOATX80
2163     case FLOAT32_TO_FLOATX80:
2164        time_a_float32_z_floatx80( float32_to_floatx80 );
2165        break;
2166#endif
2167#ifdef FLOAT128
2168     case FLOAT32_TO_FLOAT128:
2169        time_a_float32_z_float128( float32_to_float128 );
2170        break;
2171#endif
2172     case FLOAT32_ROUND_TO_INT:
2173        time_az_float32( float32_round_to_int );
2174        break;
2175     case FLOAT32_ADD:
2176        time_abz_float32( float32_add );
2177        break;
2178     case FLOAT32_SUB:
2179        time_abz_float32( float32_sub );
2180        break;
2181     case FLOAT32_MUL:
2182        time_abz_float32( float32_mul );
2183        break;
2184     case FLOAT32_DIV:
2185        time_abz_float32( float32_div );
2186        break;
2187     case FLOAT32_REM:
2188        time_abz_float32( float32_rem );
2189        break;
2190     case FLOAT32_SQRT:
2191        time_az_float32_pos( float32_sqrt );
2192        break;
2193     case FLOAT32_EQ:
2194        time_ab_float32_z_flag( float32_eq );
2195        break;
2196     case FLOAT32_LE:
2197        time_ab_float32_z_flag( float32_le );
2198        break;
2199     case FLOAT32_LT:
2200        time_ab_float32_z_flag( float32_lt );
2201        break;
2202     case FLOAT32_EQ_SIGNALING:
2203        time_ab_float32_z_flag( float32_eq_signaling );
2204        break;
2205     case FLOAT32_LE_QUIET:
2206        time_ab_float32_z_flag( float32_le_quiet );
2207        break;
2208     case FLOAT32_LT_QUIET:
2209        time_ab_float32_z_flag( float32_lt_quiet );
2210        break;
2211     case FLOAT64_TO_INT32:
2212        time_a_float64_z_int32( float64_to_int32 );
2213        break;
2214     case FLOAT64_TO_INT32_ROUND_TO_ZERO:
2215        time_a_float64_z_int32( float64_to_int32_round_to_zero );
2216        break;
2217     case FLOAT64_TO_INT64:
2218        time_a_float64_z_int64( float64_to_int64 );
2219        break;
2220     case FLOAT64_TO_INT64_ROUND_TO_ZERO:
2221        time_a_float64_z_int64( float64_to_int64_round_to_zero );
2222        break;
2223     case FLOAT64_TO_FLOAT32:
2224        time_a_float64_z_float32( float64_to_float32 );
2225        break;
2226#ifdef FLOATX80
2227     case FLOAT64_TO_FLOATX80:
2228        time_a_float64_z_floatx80( float64_to_floatx80 );
2229        break;
2230#endif
2231#ifdef FLOAT128
2232     case FLOAT64_TO_FLOAT128:
2233        time_a_float64_z_float128( float64_to_float128 );
2234        break;
2235#endif
2236     case FLOAT64_ROUND_TO_INT:
2237        time_az_float64( float64_round_to_int );
2238        break;
2239     case FLOAT64_ADD:
2240        time_abz_float64( float64_add );
2241        break;
2242     case FLOAT64_SUB:
2243        time_abz_float64( float64_sub );
2244        break;
2245     case FLOAT64_MUL:
2246        time_abz_float64( float64_mul );
2247        break;
2248     case FLOAT64_DIV:
2249        time_abz_float64( float64_div );
2250        break;
2251     case FLOAT64_REM:
2252        time_abz_float64( float64_rem );
2253        break;
2254     case FLOAT64_SQRT:
2255        time_az_float64_pos( float64_sqrt );
2256        break;
2257     case FLOAT64_EQ:
2258        time_ab_float64_z_flag( float64_eq );
2259        break;
2260     case FLOAT64_LE:
2261        time_ab_float64_z_flag( float64_le );
2262        break;
2263     case FLOAT64_LT:
2264        time_ab_float64_z_flag( float64_lt );
2265        break;
2266     case FLOAT64_EQ_SIGNALING:
2267        time_ab_float64_z_flag( float64_eq_signaling );
2268        break;
2269     case FLOAT64_LE_QUIET:
2270        time_ab_float64_z_flag( float64_le_quiet );
2271        break;
2272     case FLOAT64_LT_QUIET:
2273        time_ab_float64_z_flag( float64_lt_quiet );
2274        break;
2275#ifdef FLOATX80
2276     case FLOATX80_TO_INT32:
2277        time_a_floatx80_z_int32( floatx80_to_int32 );
2278        break;
2279     case FLOATX80_TO_INT32_ROUND_TO_ZERO:
2280        time_a_floatx80_z_int32( floatx80_to_int32_round_to_zero );
2281        break;
2282     case FLOATX80_TO_INT64:
2283        time_a_floatx80_z_int64( floatx80_to_int64 );
2284        break;
2285     case FLOATX80_TO_INT64_ROUND_TO_ZERO:
2286        time_a_floatx80_z_int64( floatx80_to_int64_round_to_zero );
2287        break;
2288     case FLOATX80_TO_FLOAT32:
2289        time_a_floatx80_z_float32( floatx80_to_float32 );
2290        break;
2291     case FLOATX80_TO_FLOAT64:
2292        time_a_floatx80_z_float64( floatx80_to_float64 );
2293        break;
2294#ifdef FLOAT128
2295     case FLOATX80_TO_FLOAT128:
2296        time_a_floatx80_z_float128( floatx80_to_float128 );
2297        break;
2298#endif
2299     case FLOATX80_ROUND_TO_INT:
2300        time_az_floatx80( floatx80_round_to_int );
2301        break;
2302     case FLOATX80_ADD:
2303        time_abz_floatx80( floatx80_add );
2304        break;
2305     case FLOATX80_SUB:
2306        time_abz_floatx80( floatx80_sub );
2307        break;
2308     case FLOATX80_MUL:
2309        time_abz_floatx80( floatx80_mul );
2310        break;
2311     case FLOATX80_DIV:
2312        time_abz_floatx80( floatx80_div );
2313        break;
2314     case FLOATX80_REM:
2315        time_abz_floatx80( floatx80_rem );
2316        break;
2317     case FLOATX80_SQRT:
2318        time_az_floatx80_pos( floatx80_sqrt );
2319        break;
2320     case FLOATX80_EQ:
2321        time_ab_floatx80_z_flag( floatx80_eq );
2322        break;
2323     case FLOATX80_LE:
2324        time_ab_floatx80_z_flag( floatx80_le );
2325        break;
2326     case FLOATX80_LT:
2327        time_ab_floatx80_z_flag( floatx80_lt );
2328        break;
2329     case FLOATX80_EQ_SIGNALING:
2330        time_ab_floatx80_z_flag( floatx80_eq_signaling );
2331        break;
2332     case FLOATX80_LE_QUIET:
2333        time_ab_floatx80_z_flag( floatx80_le_quiet );
2334        break;
2335     case FLOATX80_LT_QUIET:
2336        time_ab_floatx80_z_flag( floatx80_lt_quiet );
2337        break;
2338#endif
2339#ifdef FLOAT128
2340     case FLOAT128_TO_INT32:
2341        time_a_float128_z_int32( float128_to_int32 );
2342        break;
2343     case FLOAT128_TO_INT32_ROUND_TO_ZERO:
2344        time_a_float128_z_int32( float128_to_int32_round_to_zero );
2345        break;
2346     case FLOAT128_TO_INT64:
2347        time_a_float128_z_int64( float128_to_int64 );
2348        break;
2349     case FLOAT128_TO_INT64_ROUND_TO_ZERO:
2350        time_a_float128_z_int64( float128_to_int64_round_to_zero );
2351        break;
2352     case FLOAT128_TO_FLOAT32:
2353        time_a_float128_z_float32( float128_to_float32 );
2354        break;
2355     case FLOAT128_TO_FLOAT64:
2356        time_a_float128_z_float64( float128_to_float64 );
2357        break;
2358#ifdef FLOATX80
2359     case FLOAT128_TO_FLOATX80:
2360        time_a_float128_z_floatx80( float128_to_floatx80 );
2361        break;
2362#endif
2363     case FLOAT128_ROUND_TO_INT:
2364        time_az_float128( float128_round_to_int );
2365        break;
2366     case FLOAT128_ADD:
2367        time_abz_float128( float128_add );
2368        break;
2369     case FLOAT128_SUB:
2370        time_abz_float128( float128_sub );
2371        break;
2372     case FLOAT128_MUL:
2373        time_abz_float128( float128_mul );
2374        break;
2375     case FLOAT128_DIV:
2376        time_abz_float128( float128_div );
2377        break;
2378     case FLOAT128_REM:
2379        time_abz_float128( float128_rem );
2380        break;
2381     case FLOAT128_SQRT:
2382        time_az_float128_pos( float128_sqrt );
2383        break;
2384     case FLOAT128_EQ:
2385        time_ab_float128_z_flag( float128_eq );
2386        break;
2387     case FLOAT128_LE:
2388        time_ab_float128_z_flag( float128_le );
2389        break;
2390     case FLOAT128_LT:
2391        time_ab_float128_z_flag( float128_lt );
2392        break;
2393     case FLOAT128_EQ_SIGNALING:
2394        time_ab_float128_z_flag( float128_eq_signaling );
2395        break;
2396     case FLOAT128_LE_QUIET:
2397        time_ab_float128_z_flag( float128_le_quiet );
2398        break;
2399     case FLOAT128_LT_QUIET:
2400        time_ab_float128_z_flag( float128_lt_quiet );
2401        break;
2402#endif
2403    }
2404
2405}
2406
2407static void
2408 timeFunction(
2409     uint8 functionCode,
2410     int8 roundingPrecisionIn,
2411     int8 roundingModeIn,
2412     int8 tininessModeIn
2413 )
2414{
2415    int8 roundingPrecision, roundingMode, tininessMode;
2416
2417    roundingPrecision = 32;
2418    for (;;) {
2419        if ( ! functions[ functionCode ].roundingPrecision ) {
2420            roundingPrecision = 0;
2421        }
2422        else if ( roundingPrecisionIn ) {
2423            roundingPrecision = roundingPrecisionIn;
2424        }
2425        for ( roundingMode = 1;
2426              roundingMode < NUM_ROUNDINGMODES;
2427              ++roundingMode
2428            ) {
2429            if ( ! functions[ functionCode ].roundingMode ) {
2430                roundingMode = 0;
2431            }
2432            else if ( roundingModeIn ) {
2433                roundingMode = roundingModeIn;
2434            }
2435            for ( tininessMode = 1;
2436                  tininessMode < NUM_TININESSMODES;
2437                  ++tininessMode
2438                ) {
2439                if (    ( roundingPrecision == 32 )
2440                     || ( roundingPrecision == 64 ) ) {
2441                    if ( ! functions[ functionCode ]
2442                               .tininessModeAtReducedPrecision
2443                       ) {
2444                        tininessMode = 0;
2445                    }
2446                    else if ( tininessModeIn ) {
2447                        tininessMode = tininessModeIn;
2448                    }
2449                }
2450                else {
2451                    if ( ! functions[ functionCode ].tininessMode ) {
2452                        tininessMode = 0;
2453                    }
2454                    else if ( tininessModeIn ) {
2455                        tininessMode = tininessModeIn;
2456                    }
2457                }
2458                timeFunctionVariety(
2459                    functionCode, roundingPrecision, roundingMode, tininessMode
2460                );
2461                if ( tininessModeIn || ! tininessMode ) break;
2462            }
2463            if ( roundingModeIn || ! roundingMode ) break;
2464        }
2465        if ( roundingPrecisionIn || ! roundingPrecision ) break;
2466        if ( roundingPrecision == 80 ) {
2467            break;
2468        }
2469        else if ( roundingPrecision == 64 ) {
2470            roundingPrecision = 80;
2471        }
2472        else if ( roundingPrecision == 32 ) {
2473            roundingPrecision = 64;
2474        }
2475    }
2476
2477}
2478
2479main( int argc, char **argv )
2480{
2481    char *argPtr;
2482    flag functionArgument;
2483    uint8 functionCode;
2484    int8 operands, roundingPrecision, roundingMode, tininessMode;
2485
2486    if ( argc <= 1 ) goto writeHelpMessage;
2487    functionArgument = FALSE;
2488    functionCode = 0;
2489    operands = 0;
2490    roundingPrecision = 0;
2491    roundingMode = 0;
2492    tininessMode = 0;
2493    --argc;
2494    ++argv;
2495    while ( argc && ( argPtr = argv[ 0 ] ) ) {
2496        if ( argPtr[ 0 ] == '-' ) ++argPtr;
2497        if ( strcmp( argPtr, "help" ) == 0 ) {
2498 writeHelpMessage:
2499            fputs(
2500"timesoftfloat [<option>...] <function>\n"
2501"  <option>:  (* is default)\n"
2502"    -help            --Write this message and exit.\n"
2503#ifdef FLOATX80
2504"    -precision32     --Only time rounding precision equivalent to float32.\n"
2505"    -precision64     --Only time rounding precision equivalent to float64.\n"
2506"    -precision80     --Only time maximum rounding precision.\n"
2507#endif
2508"    -nearesteven     --Only time rounding to nearest/even.\n"
2509"    -tozero          --Only time rounding to zero.\n"
2510"    -down            --Only time rounding down.\n"
2511"    -up              --Only time rounding up.\n"
2512"    -tininessbefore  --Only time underflow tininess before rounding.\n"
2513"    -tininessafter   --Only time underflow tininess after rounding.\n"
2514"  <function>:\n"
2515"    int32_to_<float>                 <float>_add   <float>_eq\n"
2516"    <float>_to_int32                 <float>_sub   <float>_le\n"
2517"    <float>_to_int32_round_to_zero   <float>_mul   <float>_lt\n"
2518"    int64_to_<float>                 <float>_div   <float>_eq_signaling\n"
2519"    <float>_to_int64                 <float>_rem   <float>_le_quiet\n"
2520"    <float>_to_int64_round_to_zero                 <float>_lt_quiet\n"
2521"    <float>_to_<float>\n"
2522"    <float>_round_to_int\n"
2523"    <float>_sqrt\n"
2524"    -all1            --All 1-operand functions.\n"
2525"    -all2            --All 2-operand functions.\n"
2526"    -all             --All functions.\n"
2527"  <float>:\n"
2528"    float32          --Single precision.\n"
2529"    float64          --Double precision.\n"
2530#ifdef FLOATX80
2531"    floatx80         --Extended double precision.\n"
2532#endif
2533#ifdef FLOAT128
2534"    float128         --Quadruple precision.\n"
2535#endif
2536                ,
2537                stdout
2538            );
2539            return EXIT_SUCCESS;
2540        }
2541#ifdef FLOATX80
2542        else if ( strcmp( argPtr, "precision32" ) == 0 ) {
2543            roundingPrecision = 32;
2544        }
2545        else if ( strcmp( argPtr, "precision64" ) == 0 ) {
2546            roundingPrecision = 64;
2547        }
2548        else if ( strcmp( argPtr, "precision80" ) == 0 ) {
2549            roundingPrecision = 80;
2550        }
2551#endif
2552        else if (    ( strcmp( argPtr, "nearesteven" ) == 0 )
2553                  || ( strcmp( argPtr, "nearest_even" ) == 0 ) ) {
2554            roundingMode = ROUND_NEAREST_EVEN;
2555        }
2556        else if (    ( strcmp( argPtr, "tozero" ) == 0 )
2557                  || ( strcmp( argPtr, "to_zero" ) == 0 ) ) {
2558            roundingMode = ROUND_TO_ZERO;
2559        }
2560        else if ( strcmp( argPtr, "down" ) == 0 ) {
2561            roundingMode = ROUND_DOWN;
2562        }
2563        else if ( strcmp( argPtr, "up" ) == 0 ) {
2564            roundingMode = ROUND_UP;
2565        }
2566        else if ( strcmp( argPtr, "tininessbefore" ) == 0 ) {
2567            tininessMode = TININESS_BEFORE_ROUNDING;
2568        }
2569        else if ( strcmp( argPtr, "tininessafter" ) == 0 ) {
2570            tininessMode = TININESS_AFTER_ROUNDING;
2571        }
2572        else if ( strcmp( argPtr, "all1" ) == 0 ) {
2573            functionArgument = TRUE;
2574            functionCode = 0;
2575            operands = 1;
2576        }
2577        else if ( strcmp( argPtr, "all2" ) == 0 ) {
2578            functionArgument = TRUE;
2579            functionCode = 0;
2580            operands = 2;
2581        }
2582        else if ( strcmp( argPtr, "all" ) == 0 ) {
2583            functionArgument = TRUE;
2584            functionCode = 0;
2585            operands = 0;
2586        }
2587        else {
2588            for ( functionCode = 1;
2589                  functionCode < NUM_FUNCTIONS;
2590                  ++functionCode
2591                ) {
2592                if ( strcmp( argPtr, functions[ functionCode ].name ) == 0 ) {
2593                    break;
2594                }
2595            }
2596            if ( functionCode == NUM_FUNCTIONS ) {
2597                fail( "Invalid option or function `%s'", argv[ 0 ] );
2598            }
2599            functionArgument = TRUE;
2600        }
2601        --argc;
2602        ++argv;
2603    }
2604    if ( ! functionArgument ) fail( "Function argument required" );
2605    if ( functionCode ) {
2606        timeFunction(
2607            functionCode, roundingPrecision, roundingMode, tininessMode );
2608    }
2609    else if ( operands == 1 ) {
2610        for ( functionCode = 1; functionCode < NUM_FUNCTIONS; ++functionCode
2611            ) {
2612            if ( functions[ functionCode ].numInputs == 1 ) {
2613                timeFunction(
2614                    functionCode, roundingPrecision, roundingMode, tininessMode
2615                );
2616            }
2617        }
2618    }
2619    else if ( operands == 2 ) {
2620        for ( functionCode = 1; functionCode < NUM_FUNCTIONS; ++functionCode
2621            ) {
2622            if ( functions[ functionCode ].numInputs == 2 ) {
2623                timeFunction(
2624                    functionCode, roundingPrecision, roundingMode, tininessMode
2625                );
2626            }
2627        }
2628    }
2629    else {
2630        for ( functionCode = 1; functionCode < NUM_FUNCTIONS; ++functionCode
2631            ) {
2632            timeFunction(
2633                functionCode, roundingPrecision, roundingMode, tininessMode );
2634        }
2635    }
2636    return EXIT_SUCCESS;
2637
2638}
2639
2640