CoCalc -- timesoftfloat.c

GitHub Repository: freebsd/freebsd-src
Path: blob/main/lib/libc/softfloat/timesoftfloat.c
³⁹⁴⁷⁶ views
1
/* $NetBSD: timesoftfloat.c,v 1.1 2000/06/06 08:15:11 bjh21 Exp $ */
2

3
/*
4
===============================================================================
5

6
This C source file is part of the SoftFloat IEC/IEEE Floating-point
7
Arithmetic Package, Release 2a.
8

9
Written by John R. Hauser.  This work was made possible in part by the
10
International Computer Science Institute, located at Suite 600, 1947 Center
11
Street, Berkeley, California 94704.  Funding was partially provided by the
12
National Science Foundation under grant MIP-9311980.  The original version
13
of this code was written as part of a project to build a fixed-point vector
14
processor in collaboration with the University of California at Berkeley,
15
overseen by Profs. Nelson Morgan and John Wawrzynek.  More information
16
is available through the Web page `http://HTTP.CS.Berkeley.EDU/~jhauser/
17
arithmetic/SoftFloat.html'.
18

19
THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE.  Although reasonable effort
20
has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT
21
TIMES RESULT IN INCORRECT BEHAVIOR.  USE OF THIS SOFTWARE IS RESTRICTED TO
22
PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY
23
AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE.
24

25
Derivative works are acceptable, even for commercial purposes, so long as
26
(1) they include prominent notice that the work is derivative, and (2) they
27
include prominent notice akin to these four paragraphs for those parts of
28
this code that are retained.
29

30
===============================================================================
31
*/
32

33
#include <stdlib.h>
34
#include <stdarg.h>
35
#include <string.h>
36
#include <stdio.h>
37
#include <time.h>
38
#include "milieu.h"
39
#include "softfloat.h"
40

41
enum {
42
    minIterations = 1000
43
};
44

45
static void fail( const char *message, ... )
46
{
47
    va_list varArgs;
48

49
    fputs( "timesoftfloat: ", stderr );
50
    va_start( varArgs, message );
51
    vfprintf( stderr, message, varArgs );
52
    va_end( varArgs );
53
    fputs( ".\n", stderr );
54
    exit( EXIT_FAILURE );
55

56
}
57

58
static char *functionName;
59
static char *roundingPrecisionName, *roundingModeName, *tininessModeName;
60

61
static void reportTime( int32 count, long clocks )
62
{
63

64
    printf(
65
        "%8.1f kops/s: %s",
66
        ( count / ( ( (float) clocks ) / CLOCKS_PER_SEC ) ) / 1000,
67
        functionName
68
    );
69
    if ( roundingModeName ) {
70
        if ( roundingPrecisionName ) {
71
            fputs( ", precision ", stdout );
72
            fputs( roundingPrecisionName, stdout );
73
        }
74
        fputs( ", rounding ", stdout );
75
        fputs( roundingModeName, stdout );
76
        if ( tininessModeName ) {
77
            fputs( ", tininess ", stdout );
78
            fputs( tininessModeName, stdout );
79
            fputs( " rounding", stdout );
80
        }
81
    }
82
    fputc( '\n', stdout );
83

84
}
85

86
enum {
87
    numInputs_int32 = 32
88
};
89

90
static const int32 inputs_int32[ numInputs_int32 ] = {
91
    0xFFFFBB79, 0x405CF80F, 0x00000000, 0xFFFFFD04,
92
    0xFFF20002, 0x0C8EF795, 0xF00011FF, 0x000006CA,
93
    0x00009BFE, 0xFF4862E3, 0x9FFFEFFE, 0xFFFFFFB7,
94
    0x0BFF7FFF, 0x0000F37A, 0x0011DFFE, 0x00000006,
95
    0xFFF02006, 0xFFFFF7D1, 0x10200003, 0xDE8DF765,
96
    0x00003E02, 0x000019E8, 0x0008FFFE, 0xFFFFFB5C,
97
    0xFFDF7FFE, 0x07C42FBF, 0x0FFFE3FF, 0x040B9F13,
98
    0xBFFFFFF8, 0x0001BF56, 0x000017F6, 0x000A908A
99
};
100

101
static void time_a_int32_z_float32( float32 function( int32 ) )
102
{
103
    clock_t startClock, endClock;
104
    int32 count, i;
105
    int8 inputNum;
106

107
    count = 0;
108
    inputNum = 0;
109
    startClock = clock();
110
    do {
111
        for ( i = minIterations; i; --i ) {
112
            function( inputs_int32[ inputNum ] );
113
            inputNum = ( inputNum + 1 ) & ( numInputs_int32 - 1 );
114
        }
115
        count += minIterations;
116
    } while ( clock() - startClock < CLOCKS_PER_SEC );
117
    inputNum = 0;
118
    startClock = clock();
119
    for ( i = count; i; --i ) {
120
        function( inputs_int32[ inputNum ] );
121
        inputNum = ( inputNum + 1 ) & ( numInputs_int32 - 1 );
122
    }
123
    endClock = clock();
124
    reportTime( count, endClock - startClock );
125

126
}
127

128
static void time_a_int32_z_float64( float64 function( int32 ) )
129
{
130
    clock_t startClock, endClock;
131
    int32 count, i;
132
    int8 inputNum;
133

134
    count = 0;
135
    inputNum = 0;
136
    startClock = clock();
137
    do {
138
        for ( i = minIterations; i; --i ) {
139
            function( inputs_int32[ inputNum ] );
140
            inputNum = ( inputNum + 1 ) & ( numInputs_int32 - 1 );
141
        }
142
        count += minIterations;
143
    } while ( clock() - startClock < CLOCKS_PER_SEC );
144
    inputNum = 0;
145
    startClock = clock();
146
    for ( i = count; i; --i ) {
147
        function( inputs_int32[ inputNum ] );
148
        inputNum = ( inputNum + 1 ) & ( numInputs_int32 - 1 );
149
    }
150
    endClock = clock();
151
    reportTime( count, endClock - startClock );
152

153
}
154

155
#ifdef FLOATX80
156

157
static void time_a_int32_z_floatx80( floatx80 function( int32 ) )
158
{
159
    clock_t startClock, endClock;
160
    int32 count, i;
161
    int8 inputNum;
162

163
    count = 0;
164
    inputNum = 0;
165
    startClock = clock();
166
    do {
167
        for ( i = minIterations; i; --i ) {
168
            function( inputs_int32[ inputNum ] );
169
            inputNum = ( inputNum + 1 ) & ( numInputs_int32 - 1 );
170
        }
171
        count += minIterations;
172
    } while ( clock() - startClock < CLOCKS_PER_SEC );
173
    inputNum = 0;
174
    startClock = clock();
175
    for ( i = count; i; --i ) {
176
        function( inputs_int32[ inputNum ] );
177
        inputNum = ( inputNum + 1 ) & ( numInputs_int32 - 1 );
178
    }
179
    endClock = clock();
180
    reportTime( count, endClock - startClock );
181

182
}
183

184
#endif
185

186
#ifdef FLOAT128
187

188
static void time_a_int32_z_float128( float128 function( int32 ) )
189
{
190
    clock_t startClock, endClock;
191
    int32 count, i;
192
    int8 inputNum;
193

194
    count = 0;
195
    inputNum = 0;
196
    startClock = clock();
197
    do {
198
        for ( i = minIterations; i; --i ) {
199
            function( inputs_int32[ inputNum ] );
200
            inputNum = ( inputNum + 1 ) & ( numInputs_int32 - 1 );
201
        }
202
        count += minIterations;
203
    } while ( clock() - startClock < CLOCKS_PER_SEC );
204
    inputNum = 0;
205
    startClock = clock();
206
    for ( i = count; i; --i ) {
207
        function( inputs_int32[ inputNum ] );
208
        inputNum = ( inputNum + 1 ) & ( numInputs_int32 - 1 );
209
    }
210
    endClock = clock();
211
    reportTime( count, endClock - startClock );
212

213
}
214

215
#endif
216

217
enum {
218
    numInputs_int64 = 32
219
};
220

221
static const int64 inputs_int64[ numInputs_int64 ] = {
222
    LIT64( 0xFBFFC3FFFFFFFFFF ),
223
    LIT64( 0x0000000003C589BC ),
224
    LIT64( 0x00000000400013FE ),
225
    LIT64( 0x0000000000186171 ),
226
    LIT64( 0xFFFFFFFFFFFEFBFA ),
227
    LIT64( 0xFFFFFD79E6DFFC73 ),
228
    LIT64( 0x0000000010001DFF ),
229
    LIT64( 0xDD1A0F0C78513710 ),
230
    LIT64( 0xFFFF83FFFFFEFFFE ),
231
    LIT64( 0x00756EBD1AD0C1C7 ),
232
    LIT64( 0x0003FDFFFFFFFFBE ),
233
    LIT64( 0x0007D0FB2C2CA951 ),
234
    LIT64( 0x0007FC0007FFFFFE ),
235
    LIT64( 0x0000001F942B18BB ),
236
    LIT64( 0x0000080101FFFFFE ),
237
    LIT64( 0xFFFFFFFFFFFF0978 ),
238
    LIT64( 0x000000000008BFFF ),
239
    LIT64( 0x0000000006F5AF08 ),
240
    LIT64( 0xFFDEFF7FFFFFFFFE ),
241
    LIT64( 0x0000000000000003 ),
242
    LIT64( 0x3FFFFFFFFF80007D ),
243
    LIT64( 0x0000000000000078 ),
244
    LIT64( 0xFFF80000007FDFFD ),
245
    LIT64( 0x1BBC775B78016AB0 ),
246
    LIT64( 0xFFF9001FFFFFFFFE ),
247
    LIT64( 0xFFFD4767AB98E43F ),
248
    LIT64( 0xFFFFFEFFFE00001E ),
249
    LIT64( 0xFFFFFFFFFFF04EFD ),
250
    LIT64( 0x07FFFFFFFFFFF7FF ),
251
    LIT64( 0xFFFC9EAA38F89050 ),
252
    LIT64( 0x00000020FBFFFFFE ),
253
    LIT64( 0x0000099AE6455357 )
254
};
255

256
static void time_a_int64_z_float32( float32 function( int64 ) )
257
{
258
    clock_t startClock, endClock;
259
    int32 count, i;
260
    int8 inputNum;
261

262
    count = 0;
263
    inputNum = 0;
264
    startClock = clock();
265
    do {
266
        for ( i = minIterations; i; --i ) {
267
            function( inputs_int64[ inputNum ] );
268
            inputNum = ( inputNum + 1 ) & ( numInputs_int64 - 1 );
269
        }
270
        count += minIterations;
271
    } while ( clock() - startClock < CLOCKS_PER_SEC );
272
    inputNum = 0;
273
    startClock = clock();
274
    for ( i = count; i; --i ) {
275
        function( inputs_int64[ inputNum ] );
276
        inputNum = ( inputNum + 1 ) & ( numInputs_int64 - 1 );
277
    }
278
    endClock = clock();
279
    reportTime( count, endClock - startClock );
280

281
}
282

283
static void time_a_int64_z_float64( float64 function( int64 ) )
284
{
285
    clock_t startClock, endClock;
286
    int32 count, i;
287
    int8 inputNum;
288

289
    count = 0;
290
    inputNum = 0;
291
    startClock = clock();
292
    do {
293
        for ( i = minIterations; i; --i ) {
294
            function( inputs_int64[ inputNum ] );
295
            inputNum = ( inputNum + 1 ) & ( numInputs_int64 - 1 );
296
        }
297
        count += minIterations;
298
    } while ( clock() - startClock < CLOCKS_PER_SEC );
299
    inputNum = 0;
300
    startClock = clock();
301
    for ( i = count; i; --i ) {
302
        function( inputs_int64[ inputNum ] );
303
        inputNum = ( inputNum + 1 ) & ( numInputs_int64 - 1 );
304
    }
305
    endClock = clock();
306
    reportTime( count, endClock - startClock );
307

308
}
309

310
#ifdef FLOATX80
311

312
static void time_a_int64_z_floatx80( floatx80 function( int64 ) )
313
{
314
    clock_t startClock, endClock;
315
    int32 count, i;
316
    int8 inputNum;
317

318
    count = 0;
319
    inputNum = 0;
320
    startClock = clock();
321
    do {
322
        for ( i = minIterations; i; --i ) {
323
            function( inputs_int64[ inputNum ] );
324
            inputNum = ( inputNum + 1 ) & ( numInputs_int64 - 1 );
325
        }
326
        count += minIterations;
327
    } while ( clock() - startClock < CLOCKS_PER_SEC );
328
    inputNum = 0;
329
    startClock = clock();
330
    for ( i = count; i; --i ) {
331
        function( inputs_int64[ inputNum ] );
332
        inputNum = ( inputNum + 1 ) & ( numInputs_int64 - 1 );
333
    }
334
    endClock = clock();
335
    reportTime( count, endClock - startClock );
336

337
}
338

339
#endif
340

341
#ifdef FLOAT128
342

343
static void time_a_int64_z_float128( float128 function( int64 ) )
344
{
345
    clock_t startClock, endClock;
346
    int32 count, i;
347
    int8 inputNum;
348

349
    count = 0;
350
    inputNum = 0;
351
    startClock = clock();
352
    do {
353
        for ( i = minIterations; i; --i ) {
354
            function( inputs_int64[ inputNum ] );
355
            inputNum = ( inputNum + 1 ) & ( numInputs_int64 - 1 );
356
        }
357
        count += minIterations;
358
    } while ( clock() - startClock < CLOCKS_PER_SEC );
359
    inputNum = 0;
360
    startClock = clock();
361
    for ( i = count; i; --i ) {
362
        function( inputs_int64[ inputNum ] );
363
        inputNum = ( inputNum + 1 ) & ( numInputs_int64 - 1 );
364
    }
365
    endClock = clock();
366
    reportTime( count, endClock - startClock );
367

368
}
369

370
#endif
371

372
enum {
373
    numInputs_float32 = 32
374
};
375

376
static const float32 inputs_float32[ numInputs_float32 ] = {
377
    0x4EFA0000, 0xC1D0B328, 0x80000000, 0x3E69A31E,
378
    0xAF803EFF, 0x3F800000, 0x17BF8000, 0xE74A301A,
379
    0x4E010003, 0x7EE3C75D, 0xBD803FE0, 0xBFFEFF00,
380
    0x7981F800, 0x431FFFFC, 0xC100C000, 0x3D87EFFF,
381
    0x4103FEFE, 0xBC000007, 0xBF01F7FF, 0x4E6C6B5C,
382
    0xC187FFFE, 0xC58B9F13, 0x4F88007F, 0xDF004007,
383
    0xB7FFD7FE, 0x7E8001FB, 0x46EFFBFF, 0x31C10000,
384
    0xDB428661, 0x33F89B1F, 0xA3BFEFFF, 0x537BFFBE
385
};
386

387
static void time_a_float32_z_int32( int32 function( float32 ) )
388
{
389
    clock_t startClock, endClock;
390
    int32 count, i;
391
    int8 inputNum;
392

393
    count = 0;
394
    inputNum = 0;
395
    startClock = clock();
396
    do {
397
        for ( i = minIterations; i; --i ) {
398
            function( inputs_float32[ inputNum ] );
399
            inputNum = ( inputNum + 1 ) & ( numInputs_float32 - 1 );
400
        }
401
        count += minIterations;
402
    } while ( clock() - startClock < CLOCKS_PER_SEC );
403
    inputNum = 0;
404
    startClock = clock();
405
    for ( i = count; i; --i ) {
406
        function( inputs_float32[ inputNum ] );
407
        inputNum = ( inputNum + 1 ) & ( numInputs_float32 - 1 );
408
    }
409
    endClock = clock();
410
    reportTime( count, endClock - startClock );
411

412
}
413

414
static void time_a_float32_z_int64( int64 function( float32 ) )
415
{
416
    clock_t startClock, endClock;
417
    int32 count, i;
418
    int8 inputNum;
419

420
    count = 0;
421
    inputNum = 0;
422
    startClock = clock();
423
    do {
424
        for ( i = minIterations; i; --i ) {
425
            function( inputs_float32[ inputNum ] );
426
            inputNum = ( inputNum + 1 ) & ( numInputs_float32 - 1 );
427
        }
428
        count += minIterations;
429
    } while ( clock() - startClock < CLOCKS_PER_SEC );
430
    inputNum = 0;
431
    startClock = clock();
432
    for ( i = count; i; --i ) {
433
        function( inputs_float32[ inputNum ] );
434
        inputNum = ( inputNum + 1 ) & ( numInputs_float32 - 1 );
435
    }
436
    endClock = clock();
437
    reportTime( count, endClock - startClock );
438

439
}
440

441
static void time_a_float32_z_float64( float64 function( float32 ) )
442
{
443
    clock_t startClock, endClock;
444
    int32 count, i;
445
    int8 inputNum;
446

447
    count = 0;
448
    inputNum = 0;
449
    startClock = clock();
450
    do {
451
        for ( i = minIterations; i; --i ) {
452
            function( inputs_float32[ inputNum ] );
453
            inputNum = ( inputNum + 1 ) & ( numInputs_float32 - 1 );
454
        }
455
        count += minIterations;
456
    } while ( clock() - startClock < CLOCKS_PER_SEC );
457
    inputNum = 0;
458
    startClock = clock();
459
    for ( i = count; i; --i ) {
460
        function( inputs_float32[ inputNum ] );
461
        inputNum = ( inputNum + 1 ) & ( numInputs_float32 - 1 );
462
    }
463
    endClock = clock();
464
    reportTime( count, endClock - startClock );
465

466
}
467

468
#ifdef FLOATX80
469

470
static void time_a_float32_z_floatx80( floatx80 function( float32 ) )
471
{
472
    clock_t startClock, endClock;
473
    int32 count, i;
474
    int8 inputNum;
475

476
    count = 0;
477
    inputNum = 0;
478
    startClock = clock();
479
    do {
480
        for ( i = minIterations; i; --i ) {
481
            function( inputs_float32[ inputNum ] );
482
            inputNum = ( inputNum + 1 ) & ( numInputs_float32 - 1 );
483
        }
484
        count += minIterations;
485
    } while ( clock() - startClock < CLOCKS_PER_SEC );
486
    inputNum = 0;
487
    startClock = clock();
488
    for ( i = count; i; --i ) {
489
        function( inputs_float32[ inputNum ] );
490
        inputNum = ( inputNum + 1 ) & ( numInputs_float32 - 1 );
491
    }
492
    endClock = clock();
493
    reportTime( count, endClock - startClock );
494

495
}
496

497
#endif
498

499
#ifdef FLOAT128
500

501
static void time_a_float32_z_float128( float128 function( float32 ) )
502
{
503
    clock_t startClock, endClock;
504
    int32 count, i;
505
    int8 inputNum;
506

507
    count = 0;
508
    inputNum = 0;
509
    startClock = clock();
510
    do {
511
        for ( i = minIterations; i; --i ) {
512
            function( inputs_float32[ inputNum ] );
513
            inputNum = ( inputNum + 1 ) & ( numInputs_float32 - 1 );
514
        }
515
        count += minIterations;
516
    } while ( clock() - startClock < CLOCKS_PER_SEC );
517
    inputNum = 0;
518
    startClock = clock();
519
    for ( i = count; i; --i ) {
520
        function( inputs_float32[ inputNum ] );
521
        inputNum = ( inputNum + 1 ) & ( numInputs_float32 - 1 );
522
    }
523
    endClock = clock();
524
    reportTime( count, endClock - startClock );
525

526
}
527

528
#endif
529

530
static void time_az_float32( float32 function( float32 ) )
531
{
532
    clock_t startClock, endClock;
533
    int32 count, i;
534
    int8 inputNum;
535

536
    count = 0;
537
    inputNum = 0;
538
    startClock = clock();
539
    do {
540
        for ( i = minIterations; i; --i ) {
541
            function( inputs_float32[ inputNum ] );
542
            inputNum = ( inputNum + 1 ) & ( numInputs_float32 - 1 );
543
        }
544
        count += minIterations;
545
    } while ( clock() - startClock < CLOCKS_PER_SEC );
546
    inputNum = 0;
547
    startClock = clock();
548
    for ( i = count; i; --i ) {
549
        function( inputs_float32[ inputNum ] );
550
        inputNum = ( inputNum + 1 ) & ( numInputs_float32 - 1 );
551
    }
552
    endClock = clock();
553
    reportTime( count, endClock - startClock );
554

555
}
556

557
static void time_ab_float32_z_flag( flag function( float32, float32 ) )
558
{
559
    clock_t startClock, endClock;
560
    int32 count, i;
561
    int8 inputNumA, inputNumB;
562

563
    count = 0;
564
    inputNumA = 0;
565
    inputNumB = 0;
566
    startClock = clock();
567
    do {
568
        for ( i = minIterations; i; --i ) {
569
            function(
570
                inputs_float32[ inputNumA ], inputs_float32[ inputNumB ] );
571
            inputNumA = ( inputNumA + 1 ) & ( numInputs_float32 - 1 );
572
            if ( inputNumA == 0 ) ++inputNumB;
573
            inputNumB = ( inputNumB + 1 ) & ( numInputs_float32 - 1 );
574
        }
575
        count += minIterations;
576
    } while ( clock() - startClock < CLOCKS_PER_SEC );
577
    inputNumA = 0;
578
    inputNumB = 0;
579
    startClock = clock();
580
    for ( i = count; i; --i ) {
581
            function(
582
                inputs_float32[ inputNumA ], inputs_float32[ inputNumB ] );
583
        inputNumA = ( inputNumA + 1 ) & ( numInputs_float32 - 1 );
584
        if ( inputNumA == 0 ) ++inputNumB;
585
        inputNumB = ( inputNumB + 1 ) & ( numInputs_float32 - 1 );
586
    }
587
    endClock = clock();
588
    reportTime( count, endClock - startClock );
589

590
}
591

592
static void time_abz_float32( float32 function( float32, float32 ) )
593
{
594
    clock_t startClock, endClock;
595
    int32 count, i;
596
    int8 inputNumA, inputNumB;
597

598
    count = 0;
599
    inputNumA = 0;
600
    inputNumB = 0;
601
    startClock = clock();
602
    do {
603
        for ( i = minIterations; i; --i ) {
604
            function(
605
                inputs_float32[ inputNumA ], inputs_float32[ inputNumB ] );
606
            inputNumA = ( inputNumA + 1 ) & ( numInputs_float32 - 1 );
607
            if ( inputNumA == 0 ) ++inputNumB;
608
            inputNumB = ( inputNumB + 1 ) & ( numInputs_float32 - 1 );
609
        }
610
        count += minIterations;
611
    } while ( clock() - startClock < CLOCKS_PER_SEC );
612
    inputNumA = 0;
613
    inputNumB = 0;
614
    startClock = clock();
615
    for ( i = count; i; --i ) {
616
            function(
617
                inputs_float32[ inputNumA ], inputs_float32[ inputNumB ] );
618
        inputNumA = ( inputNumA + 1 ) & ( numInputs_float32 - 1 );
619
        if ( inputNumA == 0 ) ++inputNumB;
620
        inputNumB = ( inputNumB + 1 ) & ( numInputs_float32 - 1 );
621
    }
622
    endClock = clock();
623
    reportTime( count, endClock - startClock );
624

625
}
626

627
static const float32 inputs_float32_pos[ numInputs_float32 ] = {
628
    0x4EFA0000, 0x41D0B328, 0x00000000, 0x3E69A31E,
629
    0x2F803EFF, 0x3F800000, 0x17BF8000, 0x674A301A,
630
    0x4E010003, 0x7EE3C75D, 0x3D803FE0, 0x3FFEFF00,
631
    0x7981F800, 0x431FFFFC, 0x4100C000, 0x3D87EFFF,
632
    0x4103FEFE, 0x3C000007, 0x3F01F7FF, 0x4E6C6B5C,
633
    0x4187FFFE, 0x458B9F13, 0x4F88007F, 0x5F004007,
634
    0x37FFD7FE, 0x7E8001FB, 0x46EFFBFF, 0x31C10000,
635
    0x5B428661, 0x33F89B1F, 0x23BFEFFF, 0x537BFFBE
636
};
637

638
static void time_az_float32_pos( float32 function( float32 ) )
639
{
640
    clock_t startClock, endClock;
641
    int32 count, i;
642
    int8 inputNum;
643

644
    count = 0;
645
    inputNum = 0;
646
    startClock = clock();
647
    do {
648
        for ( i = minIterations; i; --i ) {
649
            function( inputs_float32_pos[ inputNum ] );
650
            inputNum = ( inputNum + 1 ) & ( numInputs_float32 - 1 );
651
        }
652
        count += minIterations;
653
    } while ( clock() - startClock < CLOCKS_PER_SEC );
654
    inputNum = 0;
655
    startClock = clock();
656
    for ( i = count; i; --i ) {
657
        function( inputs_float32_pos[ inputNum ] );
658
        inputNum = ( inputNum + 1 ) & ( numInputs_float32 - 1 );
659
    }
660
    endClock = clock();
661
    reportTime( count, endClock - startClock );
662

663
}
664

665
enum {
666
    numInputs_float64 = 32
667
};
668

669
static const float64 inputs_float64[ numInputs_float64 ] = {
670
    LIT64( 0x422FFFC008000000 ),
671
    LIT64( 0xB7E0000480000000 ),
672
    LIT64( 0xF3FD2546120B7935 ),
673
    LIT64( 0x3FF0000000000000 ),
674
    LIT64( 0xCE07F766F09588D6 ),
675
    LIT64( 0x8000000000000000 ),
676
    LIT64( 0x3FCE000400000000 ),
677
    LIT64( 0x8313B60F0032BED8 ),
678
    LIT64( 0xC1EFFFFFC0002000 ),
679
    LIT64( 0x3FB3C75D224F2B0F ),
680
    LIT64( 0x7FD00000004000FF ),
681
    LIT64( 0xA12FFF8000001FFF ),
682
    LIT64( 0x3EE0000000FE0000 ),
683
    LIT64( 0x0010000080000004 ),
684
    LIT64( 0x41CFFFFE00000020 ),
685
    LIT64( 0x40303FFFFFFFFFFD ),
686
    LIT64( 0x3FD000003FEFFFFF ),
687
    LIT64( 0xBFD0000010000000 ),
688
    LIT64( 0xB7FC6B5C16CA55CF ),
689
    LIT64( 0x413EEB940B9D1301 ),
690
    LIT64( 0xC7E00200001FFFFF ),
691
    LIT64( 0x47F00021FFFFFFFE ),
692
    LIT64( 0xBFFFFFFFF80000FF ),
693
    LIT64( 0xC07FFFFFE00FFFFF ),
694
    LIT64( 0x001497A63740C5E8 ),
695
    LIT64( 0xC4BFFFE0001FFFFF ),
696
    LIT64( 0x96FFDFFEFFFFFFFF ),
697
    LIT64( 0x403FC000000001FE ),
698
    LIT64( 0xFFD00000000001F6 ),
699
    LIT64( 0x0640400002000000 ),
700
    LIT64( 0x479CEE1E4F789FE0 ),
701
    LIT64( 0xC237FFFFFFFFFDFE )
702
};
703

704
static void time_a_float64_z_int32( int32 function( float64 ) )
705
{
706
    clock_t startClock, endClock;
707
    int32 count, i;
708
    int8 inputNum;
709

710
    count = 0;
711
    inputNum = 0;
712
    startClock = clock();
713
    do {
714
        for ( i = minIterations; i; --i ) {
715
            function( inputs_float64[ inputNum ] );
716
            inputNum = ( inputNum + 1 ) & ( numInputs_float64 - 1 );
717
        }
718
        count += minIterations;
719
    } while ( clock() - startClock < CLOCKS_PER_SEC );
720
    inputNum = 0;
721
    startClock = clock();
722
    for ( i = count; i; --i ) {
723
        function( inputs_float64[ inputNum ] );
724
        inputNum = ( inputNum + 1 ) & ( numInputs_float64 - 1 );
725
    }
726
    endClock = clock();
727
    reportTime( count, endClock - startClock );
728

729
}
730

731
static void time_a_float64_z_int64( int64 function( float64 ) )
732
{
733
    clock_t startClock, endClock;
734
    int32 count, i;
735
    int8 inputNum;
736

737
    count = 0;
738
    inputNum = 0;
739
    startClock = clock();
740
    do {
741
        for ( i = minIterations; i; --i ) {
742
            function( inputs_float64[ inputNum ] );
743
            inputNum = ( inputNum + 1 ) & ( numInputs_float64 - 1 );
744
        }
745
        count += minIterations;
746
    } while ( clock() - startClock < CLOCKS_PER_SEC );
747
    inputNum = 0;
748
    startClock = clock();
749
    for ( i = count; i; --i ) {
750
        function( inputs_float64[ inputNum ] );
751
        inputNum = ( inputNum + 1 ) & ( numInputs_float64 - 1 );
752
    }
753
    endClock = clock();
754
    reportTime( count, endClock - startClock );
755

756
}
757

758
static void time_a_float64_z_float32( float32 function( float64 ) )
759
{
760
    clock_t startClock, endClock;
761
    int32 count, i;
762
    int8 inputNum;
763

764
    count = 0;
765
    inputNum = 0;
766
    startClock = clock();
767
    do {
768
        for ( i = minIterations; i; --i ) {
769
            function( inputs_float64[ inputNum ] );
770
            inputNum = ( inputNum + 1 ) & ( numInputs_float64 - 1 );
771
        }
772
        count += minIterations;
773
    } while ( clock() - startClock < CLOCKS_PER_SEC );
774
    inputNum = 0;
775
    startClock = clock();
776
    for ( i = count; i; --i ) {
777
        function( inputs_float64[ inputNum ] );
778
        inputNum = ( inputNum + 1 ) & ( numInputs_float64 - 1 );
779
    }
780
    endClock = clock();
781
    reportTime( count, endClock - startClock );
782

783
}
784

785
#ifdef FLOATX80
786

787
static void time_a_float64_z_floatx80( floatx80 function( float64 ) )
788
{
789
    clock_t startClock, endClock;
790
    int32 count, i;
791
    int8 inputNum;
792

793
    count = 0;
794
    inputNum = 0;
795
    startClock = clock();
796
    do {
797
        for ( i = minIterations; i; --i ) {
798
            function( inputs_float64[ inputNum ] );
799
            inputNum = ( inputNum + 1 ) & ( numInputs_float64 - 1 );
800
        }
801
        count += minIterations;
802
    } while ( clock() - startClock < CLOCKS_PER_SEC );
803
    inputNum = 0;
804
    startClock = clock();
805
    for ( i = count; i; --i ) {
806
        function( inputs_float64[ inputNum ] );
807
        inputNum = ( inputNum + 1 ) & ( numInputs_float64 - 1 );
808
    }
809
    endClock = clock();
810
    reportTime( count, endClock - startClock );
811

812
}
813

814
#endif
815

816
#ifdef FLOAT128
817

818
static void time_a_float64_z_float128( float128 function( float64 ) )
819
{
820
    clock_t startClock, endClock;
821
    int32 count, i;
822
    int8 inputNum;
823

824
    count = 0;
825
    inputNum = 0;
826
    startClock = clock();
827
    do {
828
        for ( i = minIterations; i; --i ) {
829
            function( inputs_float64[ inputNum ] );
830
            inputNum = ( inputNum + 1 ) & ( numInputs_float64 - 1 );
831
        }
832
        count += minIterations;
833
    } while ( clock() - startClock < CLOCKS_PER_SEC );
834
    inputNum = 0;
835
    startClock = clock();
836
    for ( i = count; i; --i ) {
837
        function( inputs_float64[ inputNum ] );
838
        inputNum = ( inputNum + 1 ) & ( numInputs_float64 - 1 );
839
    }
840
    endClock = clock();
841
    reportTime( count, endClock - startClock );
842

843
}
844

845
#endif
846

847
static void time_az_float64( float64 function( float64 ) )
848
{
849
    clock_t startClock, endClock;
850
    int32 count, i;
851
    int8 inputNum;
852

853
    count = 0;
854
    inputNum = 0;
855
    startClock = clock();
856
    do {
857
        for ( i = minIterations; i; --i ) {
858
            function( inputs_float64[ inputNum ] );
859
            inputNum = ( inputNum + 1 ) & ( numInputs_float64 - 1 );
860
        }
861
        count += minIterations;
862
    } while ( clock() - startClock < CLOCKS_PER_SEC );
863
    inputNum = 0;
864
    startClock = clock();
865
    for ( i = count; i; --i ) {
866
        function( inputs_float64[ inputNum ] );
867
        inputNum = ( inputNum + 1 ) & ( numInputs_float64 - 1 );
868
    }
869
    endClock = clock();
870
    reportTime( count, endClock - startClock );
871

872
}
873

874
static void time_ab_float64_z_flag( flag function( float64, float64 ) )
875
{
876
    clock_t startClock, endClock;
877
    int32 count, i;
878
    int8 inputNumA, inputNumB;
879

880
    count = 0;
881
    inputNumA = 0;
882
    inputNumB = 0;
883
    startClock = clock();
884
    do {
885
        for ( i = minIterations; i; --i ) {
886
            function(
887
                inputs_float64[ inputNumA ], inputs_float64[ inputNumB ] );
888
            inputNumA = ( inputNumA + 1 ) & ( numInputs_float64 - 1 );
889
            if ( inputNumA == 0 ) ++inputNumB;
890
            inputNumB = ( inputNumB + 1 ) & ( numInputs_float64 - 1 );
891
        }
892
        count += minIterations;
893
    } while ( clock() - startClock < CLOCKS_PER_SEC );
894
    inputNumA = 0;
895
    inputNumB = 0;
896
    startClock = clock();
897
    for ( i = count; i; --i ) {
898
            function(
899
                inputs_float64[ inputNumA ], inputs_float64[ inputNumB ] );
900
        inputNumA = ( inputNumA + 1 ) & ( numInputs_float64 - 1 );
901
        if ( inputNumA == 0 ) ++inputNumB;
902
        inputNumB = ( inputNumB + 1 ) & ( numInputs_float64 - 1 );
903
    }
904
    endClock = clock();
905
    reportTime( count, endClock - startClock );
906

907
}
908

909
static void time_abz_float64( float64 function( float64, float64 ) )
910
{
911
    clock_t startClock, endClock;
912
    int32 count, i;
913
    int8 inputNumA, inputNumB;
914

915
    count = 0;
916
    inputNumA = 0;
917
    inputNumB = 0;
918
    startClock = clock();
919
    do {
920
        for ( i = minIterations; i; --i ) {
921
            function(
922
                inputs_float64[ inputNumA ], inputs_float64[ inputNumB ] );
923
            inputNumA = ( inputNumA + 1 ) & ( numInputs_float64 - 1 );
924
            if ( inputNumA == 0 ) ++inputNumB;
925
            inputNumB = ( inputNumB + 1 ) & ( numInputs_float64 - 1 );
926
        }
927
        count += minIterations;
928
    } while ( clock() - startClock < CLOCKS_PER_SEC );
929
    inputNumA = 0;
930
    inputNumB = 0;
931
    startClock = clock();
932
    for ( i = count; i; --i ) {
933
            function(
934
                inputs_float64[ inputNumA ], inputs_float64[ inputNumB ] );
935
        inputNumA = ( inputNumA + 1 ) & ( numInputs_float64 - 1 );
936
        if ( inputNumA == 0 ) ++inputNumB;
937
        inputNumB = ( inputNumB + 1 ) & ( numInputs_float64 - 1 );
938
    }
939
    endClock = clock();
940
    reportTime( count, endClock - startClock );
941

942
}
943

944
static const float64 inputs_float64_pos[ numInputs_float64 ] = {
945
    LIT64( 0x422FFFC008000000 ),
946
    LIT64( 0x37E0000480000000 ),
947
    LIT64( 0x73FD2546120B7935 ),
948
    LIT64( 0x3FF0000000000000 ),
949
    LIT64( 0x4E07F766F09588D6 ),
950
    LIT64( 0x0000000000000000 ),
951
    LIT64( 0x3FCE000400000000 ),
952
    LIT64( 0x0313B60F0032BED8 ),
953
    LIT64( 0x41EFFFFFC0002000 ),
954
    LIT64( 0x3FB3C75D224F2B0F ),
955
    LIT64( 0x7FD00000004000FF ),
956
    LIT64( 0x212FFF8000001FFF ),
957
    LIT64( 0x3EE0000000FE0000 ),
958
    LIT64( 0x0010000080000004 ),
959
    LIT64( 0x41CFFFFE00000020 ),
960
    LIT64( 0x40303FFFFFFFFFFD ),
961
    LIT64( 0x3FD000003FEFFFFF ),
962
    LIT64( 0x3FD0000010000000 ),
963
    LIT64( 0x37FC6B5C16CA55CF ),
964
    LIT64( 0x413EEB940B9D1301 ),
965
    LIT64( 0x47E00200001FFFFF ),
966
    LIT64( 0x47F00021FFFFFFFE ),
967
    LIT64( 0x3FFFFFFFF80000FF ),
968
    LIT64( 0x407FFFFFE00FFFFF ),
969
    LIT64( 0x001497A63740C5E8 ),
970
    LIT64( 0x44BFFFE0001FFFFF ),
971
    LIT64( 0x16FFDFFEFFFFFFFF ),
972
    LIT64( 0x403FC000000001FE ),
973
    LIT64( 0x7FD00000000001F6 ),
974
    LIT64( 0x0640400002000000 ),
975
    LIT64( 0x479CEE1E4F789FE0 ),
976
    LIT64( 0x4237FFFFFFFFFDFE )
977
};
978

979
static void time_az_float64_pos( float64 function( float64 ) )
980
{
981
    clock_t startClock, endClock;
982
    int32 count, i;
983
    int8 inputNum;
984

985
    count = 0;
986
    inputNum = 0;
987
    startClock = clock();
988
    do {
989
        for ( i = minIterations; i; --i ) {
990
            function( inputs_float64_pos[ inputNum ] );
991
            inputNum = ( inputNum + 1 ) & ( numInputs_float64 - 1 );
992
        }
993
        count += minIterations;
994
    } while ( clock() - startClock < CLOCKS_PER_SEC );
995
    inputNum = 0;
996
    startClock = clock();
997
    for ( i = count; i; --i ) {
998
        function( inputs_float64_pos[ inputNum ] );
999
        inputNum = ( inputNum + 1 ) & ( numInputs_float64 - 1 );
1000
    }
1001
    endClock = clock();
1002
    reportTime( count, endClock - startClock );
1003

1004
}
1005

1006
#ifdef FLOATX80
1007

1008
enum {
1009
    numInputs_floatx80 = 32
1010
};
1011

1012
static const struct {
1013
    bits16 high;
1014
    bits64 low;
1015
} inputs_floatx80[ numInputs_floatx80 ] = {
1016
    { 0xC03F, LIT64( 0xA9BE15A19C1E8B62 ) },
1017
    { 0x8000, LIT64( 0x0000000000000000 ) },
1018
    { 0x75A8, LIT64( 0xE59591E4788957A5 ) },
1019
    { 0xBFFF, LIT64( 0xFFF0000000000040 ) },
1020
    { 0x0CD8, LIT64( 0xFC000000000007FE ) },
1021
    { 0x43BA, LIT64( 0x99A4000000000000 ) },
1022
    { 0x3FFF, LIT64( 0x8000000000000000 ) },
1023
    { 0x4081, LIT64( 0x94FBF1BCEB5545F0 ) },
1024
    { 0x403E, LIT64( 0xFFF0000000002000 ) },
1025
    { 0x3FFE, LIT64( 0xC860E3C75D224F28 ) },
1026
    { 0x407E, LIT64( 0xFC00000FFFFFFFFE ) },
1027
    { 0x737A, LIT64( 0x800000007FFDFFFE ) },
1028
    { 0x4044, LIT64( 0xFFFFFF80000FFFFF ) },
1029
    { 0xBBFE, LIT64( 0x8000040000001FFE ) },
1030
    { 0xC002, LIT64( 0xFF80000000000020 ) },
1031
    { 0xDE8D, LIT64( 0xFFFFFFFFFFE00004 ) },
1032
    { 0xC004, LIT64( 0x8000000000003FFB ) },
1033
    { 0x407F, LIT64( 0x800000000003FFFE ) },
1034
    { 0xC000, LIT64( 0xA459EE6A5C16CA55 ) },
1035
    { 0x8003, LIT64( 0xC42CBF7399AEEB94 ) },
1036
    { 0xBF7F, LIT64( 0xF800000000000006 ) },
1037
    { 0xC07F, LIT64( 0xBF56BE8871F28FEA ) },
1038
    { 0xC07E, LIT64( 0xFFFF77FFFFFFFFFE ) },
1039
    { 0xADC9, LIT64( 0x8000000FFFFFFFDE ) },
1040
    { 0xC001, LIT64( 0xEFF7FFFFFFFFFFFF ) },
1041
    { 0x4001, LIT64( 0xBE84F30125C497A6 ) },
1042
    { 0xC06B, LIT64( 0xEFFFFFFFFFFFFFFF ) },
1043
    { 0x4080, LIT64( 0xFFFFFFFFBFFFFFFF ) },
1044
    { 0x87E9, LIT64( 0x81FFFFFFFFFFFBFF ) },
1045
    { 0xA63F, LIT64( 0x801FFFFFFEFFFFFE ) },
1046
    { 0x403C, LIT64( 0x801FFFFFFFF7FFFF ) },
1047
    { 0x4018, LIT64( 0x8000000000080003 ) }
1048
};
1049

1050
static void time_a_floatx80_z_int32( int32 function( floatx80 ) )
1051
{
1052
    clock_t startClock, endClock;
1053
    int32 count, i;
1054
    int8 inputNum;
1055
    floatx80 a;
1056

1057
    count = 0;
1058
    inputNum = 0;
1059
    startClock = clock();
1060
    do {
1061
        for ( i = minIterations; i; --i ) {
1062
            a.low = inputs_floatx80[ inputNum ].low;
1063
            a.high = inputs_floatx80[ inputNum ].high;
1064
            function( a );
1065
            inputNum = ( inputNum + 1 ) & ( numInputs_floatx80 - 1 );
1066
        }
1067
        count += minIterations;
1068
    } while ( clock() - startClock < CLOCKS_PER_SEC );
1069
    inputNum = 0;
1070
    startClock = clock();
1071
    for ( i = count; i; --i ) {
1072
        a.low = inputs_floatx80[ inputNum ].low;
1073
        a.high = inputs_floatx80[ inputNum ].high;
1074
        function( a );
1075
        inputNum = ( inputNum + 1 ) & ( numInputs_floatx80 - 1 );
1076
    }
1077
    endClock = clock();
1078
    reportTime( count, endClock - startClock );
1079

1080
}
1081

1082
static void time_a_floatx80_z_int64( int64 function( floatx80 ) )
1083
{
1084
    clock_t startClock, endClock;
1085
    int32 count, i;
1086
    int8 inputNum;
1087
    floatx80 a;
1088

1089
    count = 0;
1090
    inputNum = 0;
1091
    startClock = clock();
1092
    do {
1093
        for ( i = minIterations; i; --i ) {
1094
            a.low = inputs_floatx80[ inputNum ].low;
1095
            a.high = inputs_floatx80[ inputNum ].high;
1096
            function( a );
1097
            inputNum = ( inputNum + 1 ) & ( numInputs_floatx80 - 1 );
1098
        }
1099
        count += minIterations;
1100
    } while ( clock() - startClock < CLOCKS_PER_SEC );
1101
    inputNum = 0;
1102
    startClock = clock();
1103
    for ( i = count; i; --i ) {
1104
        a.low = inputs_floatx80[ inputNum ].low;
1105
        a.high = inputs_floatx80[ inputNum ].high;
1106
        function( a );
1107
        inputNum = ( inputNum + 1 ) & ( numInputs_floatx80 - 1 );
1108
    }
1109
    endClock = clock();
1110
    reportTime( count, endClock - startClock );
1111

1112
}
1113

1114
static void time_a_floatx80_z_float32( float32 function( floatx80 ) )
1115
{
1116
    clock_t startClock, endClock;
1117
    int32 count, i;
1118
    int8 inputNum;
1119
    floatx80 a;
1120

1121
    count = 0;
1122
    inputNum = 0;
1123
    startClock = clock();
1124
    do {
1125
        for ( i = minIterations; i; --i ) {
1126
            a.low = inputs_floatx80[ inputNum ].low;
1127
            a.high = inputs_floatx80[ inputNum ].high;
1128
            function( a );
1129
            inputNum = ( inputNum + 1 ) & ( numInputs_floatx80 - 1 );
1130
        }
1131
        count += minIterations;
1132
    } while ( clock() - startClock < CLOCKS_PER_SEC );
1133
    inputNum = 0;
1134
    startClock = clock();
1135
    for ( i = count; i; --i ) {
1136
        a.low = inputs_floatx80[ inputNum ].low;
1137
        a.high = inputs_floatx80[ inputNum ].high;
1138
        function( a );
1139
        inputNum = ( inputNum + 1 ) & ( numInputs_floatx80 - 1 );
1140
    }
1141
    endClock = clock();
1142
    reportTime( count, endClock - startClock );
1143

1144
}
1145

1146
static void time_a_floatx80_z_float64( float64 function( floatx80 ) )
1147
{
1148
    clock_t startClock, endClock;
1149
    int32 count, i;
1150
    int8 inputNum;
1151
    floatx80 a;
1152

1153
    count = 0;
1154
    inputNum = 0;
1155
    startClock = clock();
1156
    do {
1157
        for ( i = minIterations; i; --i ) {
1158
            a.low = inputs_floatx80[ inputNum ].low;
1159
            a.high = inputs_floatx80[ inputNum ].high;
1160
            function( a );
1161
            inputNum = ( inputNum + 1 ) & ( numInputs_floatx80 - 1 );
1162
        }
1163
        count += minIterations;
1164
    } while ( clock() - startClock < CLOCKS_PER_SEC );
1165
    inputNum = 0;
1166
    startClock = clock();
1167
    for ( i = count; i; --i ) {
1168
        a.low = inputs_floatx80[ inputNum ].low;
1169
        a.high = inputs_floatx80[ inputNum ].high;
1170
        function( a );
1171
        inputNum = ( inputNum + 1 ) & ( numInputs_floatx80 - 1 );
1172
    }
1173
    endClock = clock();
1174
    reportTime( count, endClock - startClock );
1175

1176
}
1177

1178
#ifdef FLOAT128
1179

1180
static void time_a_floatx80_z_float128( float128 function( floatx80 ) )
1181
{
1182
    clock_t startClock, endClock;
1183
    int32 count, i;
1184
    int8 inputNum;
1185
    floatx80 a;
1186

1187
    count = 0;
1188
    inputNum = 0;
1189
    startClock = clock();
1190
    do {
1191
        for ( i = minIterations; i; --i ) {
1192
            a.low = inputs_floatx80[ inputNum ].low;
1193
            a.high = inputs_floatx80[ inputNum ].high;
1194
            function( a );
1195
            inputNum = ( inputNum + 1 ) & ( numInputs_floatx80 - 1 );
1196
        }
1197
        count += minIterations;
1198
    } while ( clock() - startClock < CLOCKS_PER_SEC );
1199
    inputNum = 0;
1200
    startClock = clock();
1201
    for ( i = count; i; --i ) {
1202
        a.low = inputs_floatx80[ inputNum ].low;
1203
        a.high = inputs_floatx80[ inputNum ].high;
1204
        function( a );
1205
        inputNum = ( inputNum + 1 ) & ( numInputs_floatx80 - 1 );
1206
    }
1207
    endClock = clock();
1208
    reportTime( count, endClock - startClock );
1209

1210
}
1211

1212
#endif
1213

1214
static void time_az_floatx80( floatx80 function( floatx80 ) )
1215
{
1216
    clock_t startClock, endClock;
1217
    int32 count, i;
1218
    int8 inputNum;
1219
    floatx80 a;
1220

1221
    count = 0;
1222
    inputNum = 0;
1223
    startClock = clock();
1224
    do {
1225
        for ( i = minIterations; i; --i ) {
1226
            a.low = inputs_floatx80[ inputNum ].low;
1227
            a.high = inputs_floatx80[ inputNum ].high;
1228
            function( a );
1229
            inputNum = ( inputNum + 1 ) & ( numInputs_floatx80 - 1 );
1230
        }
1231
        count += minIterations;
1232
    } while ( clock() - startClock < CLOCKS_PER_SEC );
1233
    inputNum = 0;
1234
    startClock = clock();
1235
    for ( i = count; i; --i ) {
1236
        a.low = inputs_floatx80[ inputNum ].low;
1237
        a.high = inputs_floatx80[ inputNum ].high;
1238
        function( a );
1239
        inputNum = ( inputNum + 1 ) & ( numInputs_floatx80 - 1 );
1240
    }
1241
    endClock = clock();
1242
    reportTime( count, endClock - startClock );
1243

1244
}
1245

1246
static void time_ab_floatx80_z_flag( flag function( floatx80, floatx80 ) )
1247
{
1248
    clock_t startClock, endClock;
1249
    int32 count, i;
1250
    int8 inputNumA, inputNumB;
1251
    floatx80 a, b;
1252

1253
    count = 0;
1254
    inputNumA = 0;
1255
    inputNumB = 0;
1256
    startClock = clock();
1257
    do {
1258
        for ( i = minIterations; i; --i ) {
1259
            a.low = inputs_floatx80[ inputNumA ].low;
1260
            a.high = inputs_floatx80[ inputNumA ].high;
1261
            b.low = inputs_floatx80[ inputNumB ].low;
1262
            b.high = inputs_floatx80[ inputNumB ].high;
1263
            function( a, b );
1264
            inputNumA = ( inputNumA + 1 ) & ( numInputs_floatx80 - 1 );
1265
            if ( inputNumA == 0 ) ++inputNumB;
1266
            inputNumB = ( inputNumB + 1 ) & ( numInputs_floatx80 - 1 );
1267
        }
1268
        count += minIterations;
1269
    } while ( clock() - startClock < CLOCKS_PER_SEC );
1270
    inputNumA = 0;
1271
    inputNumB = 0;
1272
    startClock = clock();
1273
    for ( i = count; i; --i ) {
1274
        a.low = inputs_floatx80[ inputNumA ].low;
1275
        a.high = inputs_floatx80[ inputNumA ].high;
1276
        b.low = inputs_floatx80[ inputNumB ].low;
1277
        b.high = inputs_floatx80[ inputNumB ].high;
1278
        function( a, b );
1279
        inputNumA = ( inputNumA + 1 ) & ( numInputs_floatx80 - 1 );
1280
        if ( inputNumA == 0 ) ++inputNumB;
1281
        inputNumB = ( inputNumB + 1 ) & ( numInputs_floatx80 - 1 );
1282
    }
1283
    endClock = clock();
1284
    reportTime( count, endClock - startClock );
1285

1286
}
1287

1288
static void time_abz_floatx80( floatx80 function( floatx80, floatx80 ) )
1289
{
1290
    clock_t startClock, endClock;
1291
    int32 count, i;
1292
    int8 inputNumA, inputNumB;
1293
    floatx80 a, b;
1294

1295
    count = 0;
1296
    inputNumA = 0;
1297
    inputNumB = 0;
1298
    startClock = clock();
1299
    do {
1300
        for ( i = minIterations; i; --i ) {
1301
            a.low = inputs_floatx80[ inputNumA ].low;
1302
            a.high = inputs_floatx80[ inputNumA ].high;
1303
            b.low = inputs_floatx80[ inputNumB ].low;
1304
            b.high = inputs_floatx80[ inputNumB ].high;
1305
            function( a, b );
1306
            inputNumA = ( inputNumA + 1 ) & ( numInputs_floatx80 - 1 );
1307
            if ( inputNumA == 0 ) ++inputNumB;
1308
            inputNumB = ( inputNumB + 1 ) & ( numInputs_floatx80 - 1 );
1309
        }
1310
        count += minIterations;
1311
    } while ( clock() - startClock < CLOCKS_PER_SEC );
1312
    inputNumA = 0;
1313
    inputNumB = 0;
1314
    startClock = clock();
1315
    for ( i = count; i; --i ) {
1316
        a.low = inputs_floatx80[ inputNumA ].low;
1317
        a.high = inputs_floatx80[ inputNumA ].high;
1318
        b.low = inputs_floatx80[ inputNumB ].low;
1319
        b.high = inputs_floatx80[ inputNumB ].high;
1320
        function( a, b );
1321
        inputNumA = ( inputNumA + 1 ) & ( numInputs_floatx80 - 1 );
1322
        if ( inputNumA == 0 ) ++inputNumB;
1323
        inputNumB = ( inputNumB + 1 ) & ( numInputs_floatx80 - 1 );
1324
    }
1325
    endClock = clock();
1326
    reportTime( count, endClock - startClock );
1327

1328
}
1329

1330
static const struct {
1331
    bits16 high;
1332
    bits64 low;
1333
} inputs_floatx80_pos[ numInputs_floatx80 ] = {
1334
    { 0x403F, LIT64( 0xA9BE15A19C1E8B62 ) },
1335
    { 0x0000, LIT64( 0x0000000000000000 ) },
1336
    { 0x75A8, LIT64( 0xE59591E4788957A5 ) },
1337
    { 0x3FFF, LIT64( 0xFFF0000000000040 ) },
1338
    { 0x0CD8, LIT64( 0xFC000000000007FE ) },
1339
    { 0x43BA, LIT64( 0x99A4000000000000 ) },
1340
    { 0x3FFF, LIT64( 0x8000000000000000 ) },
1341
    { 0x4081, LIT64( 0x94FBF1BCEB5545F0 ) },
1342
    { 0x403E, LIT64( 0xFFF0000000002000 ) },
1343
    { 0x3FFE, LIT64( 0xC860E3C75D224F28 ) },
1344
    { 0x407E, LIT64( 0xFC00000FFFFFFFFE ) },
1345
    { 0x737A, LIT64( 0x800000007FFDFFFE ) },
1346
    { 0x4044, LIT64( 0xFFFFFF80000FFFFF ) },
1347
    { 0x3BFE, LIT64( 0x8000040000001FFE ) },
1348
    { 0x4002, LIT64( 0xFF80000000000020 ) },
1349
    { 0x5E8D, LIT64( 0xFFFFFFFFFFE00004 ) },
1350
    { 0x4004, LIT64( 0x8000000000003FFB ) },
1351
    { 0x407F, LIT64( 0x800000000003FFFE ) },
1352
    { 0x4000, LIT64( 0xA459EE6A5C16CA55 ) },
1353
    { 0x0003, LIT64( 0xC42CBF7399AEEB94 ) },
1354
    { 0x3F7F, LIT64( 0xF800000000000006 ) },
1355
    { 0x407F, LIT64( 0xBF56BE8871F28FEA ) },
1356
    { 0x407E, LIT64( 0xFFFF77FFFFFFFFFE ) },
1357
    { 0x2DC9, LIT64( 0x8000000FFFFFFFDE ) },
1358
    { 0x4001, LIT64( 0xEFF7FFFFFFFFFFFF ) },
1359
    { 0x4001, LIT64( 0xBE84F30125C497A6 ) },
1360
    { 0x406B, LIT64( 0xEFFFFFFFFFFFFFFF ) },
1361
    { 0x4080, LIT64( 0xFFFFFFFFBFFFFFFF ) },
1362
    { 0x07E9, LIT64( 0x81FFFFFFFFFFFBFF ) },
1363
    { 0x263F, LIT64( 0x801FFFFFFEFFFFFE ) },
1364
    { 0x403C, LIT64( 0x801FFFFFFFF7FFFF ) },
1365
    { 0x4018, LIT64( 0x8000000000080003 ) }
1366
};
1367

1368
static void time_az_floatx80_pos( floatx80 function( floatx80 ) )
1369
{
1370
    clock_t startClock, endClock;
1371
    int32 count, i;
1372
    int8 inputNum;
1373
    floatx80 a;
1374

1375
    count = 0;
1376
    inputNum = 0;
1377
    startClock = clock();
1378
    do {
1379
        for ( i = minIterations; i; --i ) {
1380
            a.low = inputs_floatx80_pos[ inputNum ].low;
1381
            a.high = inputs_floatx80_pos[ inputNum ].high;
1382
            function( a );
1383
            inputNum = ( inputNum + 1 ) & ( numInputs_floatx80 - 1 );
1384
        }
1385
        count += minIterations;
1386
    } while ( clock() - startClock < CLOCKS_PER_SEC );
1387
    inputNum = 0;
1388
    startClock = clock();
1389
    for ( i = count; i; --i ) {
1390
        a.low = inputs_floatx80_pos[ inputNum ].low;
1391
        a.high = inputs_floatx80_pos[ inputNum ].high;
1392
        function( a );
1393
        inputNum = ( inputNum + 1 ) & ( numInputs_floatx80 - 1 );
1394
    }
1395
    endClock = clock();
1396
    reportTime( count, endClock - startClock );
1397

1398
}
1399

1400
#endif
1401

1402
#ifdef FLOAT128
1403

1404
enum {
1405
    numInputs_float128 = 32
1406
};
1407

1408
static const struct {
1409
    bits64 high, low;
1410
} inputs_float128[ numInputs_float128 ] = {
1411
    { LIT64( 0x3FDA200000100000 ), LIT64( 0x0000000000000000 ) },
1412
    { LIT64( 0x3FFF000000000000 ), LIT64( 0x0000000000000000 ) },
1413
    { LIT64( 0x85F14776190C8306 ), LIT64( 0xD8715F4E3D54BB92 ) },
1414
    { LIT64( 0xF2B00000007FFFFF ), LIT64( 0xFFFFFFFFFFF7FFFF ) },
1415
    { LIT64( 0x8000000000000000 ), LIT64( 0x0000000000000000 ) },
1416
    { LIT64( 0xBFFFFFFFFFE00000 ), LIT64( 0x0000008000000000 ) },
1417
    { LIT64( 0x407F1719CE722F3E ), LIT64( 0xDA6B3FE5FF29425B ) },
1418
    { LIT64( 0x43FFFF8000000000 ), LIT64( 0x0000000000400000 ) },
1419
    { LIT64( 0x401E000000000100 ), LIT64( 0x0000000000002000 ) },
1420
    { LIT64( 0x3FFED71DACDA8E47 ), LIT64( 0x4860E3C75D224F28 ) },
1421
    { LIT64( 0xBF7ECFC1E90647D1 ), LIT64( 0x7A124FE55623EE44 ) },
1422
    { LIT64( 0x0DF7007FFFFFFFFF ), LIT64( 0xFFFFFFFFEFFFFFFF ) },
1423
    { LIT64( 0x3FE5FFEFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFEFFF ) },
1424
    { LIT64( 0x403FFFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFBFE ) },
1425
    { LIT64( 0xBFFB2FBF7399AFEB ), LIT64( 0xA459EE6A5C16CA55 ) },
1426
    { LIT64( 0xBDB8FFFFFFFFFFFC ), LIT64( 0x0000000000000400 ) },
1427
    { LIT64( 0x3FC8FFDFFFFFFFFF ), LIT64( 0xFFFFFFFFF0000000 ) },
1428
    { LIT64( 0x3FFBFFFFFFDFFFFF ), LIT64( 0xFFF8000000000000 ) },
1429
    { LIT64( 0x407043C11737BE84 ), LIT64( 0xDDD58212ADC937F4 ) },
1430
    { LIT64( 0x8001000000000000 ), LIT64( 0x0000001000000001 ) },
1431
    { LIT64( 0xC036FFFFFFFFFFFF ), LIT64( 0xFE40000000000000 ) },
1432
    { LIT64( 0x4002FFFFFE000002 ), LIT64( 0x0000000000000000 ) },
1433
    { LIT64( 0x4000C3FEDE897773 ), LIT64( 0x326AC4FD8EFBE6DC ) },
1434
    { LIT64( 0xBFFF0000000FFFFF ), LIT64( 0xFFFFFE0000000000 ) },
1435
    { LIT64( 0x62C3E502146E426D ), LIT64( 0x43F3CAA0DC7DF1A0 ) },
1436
    { LIT64( 0xB5CBD32E52BB570E ), LIT64( 0xBCC477CB11C6236C ) },
1437
    { LIT64( 0xE228FFFFFFC00000 ), LIT64( 0x0000000000000000 ) },
1438
    { LIT64( 0x3F80000000000000 ), LIT64( 0x0000000080000008 ) },
1439
    { LIT64( 0xC1AFFFDFFFFFFFFF ), LIT64( 0xFFFC000000000000 ) },
1440
    { LIT64( 0xC96F000000000000 ), LIT64( 0x00000001FFFBFFFF ) },
1441
    { LIT64( 0x3DE09BFE7923A338 ), LIT64( 0xBCC8FBBD7CEC1F4F ) },
1442
    { LIT64( 0x401CFFFFFFFFFFFF ), LIT64( 0xFFFFFFFEFFFFFF80 ) }
1443
};
1444

1445
static void time_a_float128_z_int32( int32 function( float128 ) )
1446
{
1447
    clock_t startClock, endClock;
1448
    int32 count, i;
1449
    int8 inputNum;
1450
    float128 a;
1451

1452
    count = 0;
1453
    inputNum = 0;
1454
    startClock = clock();
1455
    do {
1456
        for ( i = minIterations; i; --i ) {
1457
            a.low = inputs_float128[ inputNum ].low;
1458
            a.high = inputs_float128[ inputNum ].high;
1459
            function( a );
1460
            inputNum = ( inputNum + 1 ) & ( numInputs_float128 - 1 );
1461
        }
1462
        count += minIterations;
1463
    } while ( clock() - startClock < CLOCKS_PER_SEC );
1464
    inputNum = 0;
1465
    startClock = clock();
1466
    for ( i = count; i; --i ) {
1467
        a.low = inputs_float128[ inputNum ].low;
1468
        a.high = inputs_float128[ inputNum ].high;
1469
        function( a );
1470
        inputNum = ( inputNum + 1 ) & ( numInputs_float128 - 1 );
1471
    }
1472
    endClock = clock();
1473
    reportTime( count, endClock - startClock );
1474

1475
}
1476

1477
static void time_a_float128_z_int64( int64 function( float128 ) )
1478
{
1479
    clock_t startClock, endClock;
1480
    int32 count, i;
1481
    int8 inputNum;
1482
    float128 a;
1483

1484
    count = 0;
1485
    inputNum = 0;
1486
    startClock = clock();
1487
    do {
1488
        for ( i = minIterations; i; --i ) {
1489
            a.low = inputs_float128[ inputNum ].low;
1490
            a.high = inputs_float128[ inputNum ].high;
1491
            function( a );
1492
            inputNum = ( inputNum + 1 ) & ( numInputs_float128 - 1 );
1493
        }
1494
        count += minIterations;
1495
    } while ( clock() - startClock < CLOCKS_PER_SEC );
1496
    inputNum = 0;
1497
    startClock = clock();
1498
    for ( i = count; i; --i ) {
1499
        a.low = inputs_float128[ inputNum ].low;
1500
        a.high = inputs_float128[ inputNum ].high;
1501
        function( a );
1502
        inputNum = ( inputNum + 1 ) & ( numInputs_float128 - 1 );
1503
    }
1504
    endClock = clock();
1505
    reportTime( count, endClock - startClock );
1506

1507
}
1508

1509
static void time_a_float128_z_float32( float32 function( float128 ) )
1510
{
1511
    clock_t startClock, endClock;
1512
    int32 count, i;
1513
    int8 inputNum;
1514
    float128 a;
1515

1516
    count = 0;
1517
    inputNum = 0;
1518
    startClock = clock();
1519
    do {
1520
        for ( i = minIterations; i; --i ) {
1521
            a.low = inputs_float128[ inputNum ].low;
1522
            a.high = inputs_float128[ inputNum ].high;
1523
            function( a );
1524
            inputNum = ( inputNum + 1 ) & ( numInputs_float128 - 1 );
1525
        }
1526
        count += minIterations;
1527
    } while ( clock() - startClock < CLOCKS_PER_SEC );
1528
    inputNum = 0;
1529
    startClock = clock();
1530
    for ( i = count; i; --i ) {
1531
        a.low = inputs_float128[ inputNum ].low;
1532
        a.high = inputs_float128[ inputNum ].high;
1533
        function( a );
1534
        inputNum = ( inputNum + 1 ) & ( numInputs_float128 - 1 );
1535
    }
1536
    endClock = clock();
1537
    reportTime( count, endClock - startClock );
1538

1539
}
1540

1541
static void time_a_float128_z_float64( float64 function( float128 ) )
1542
{
1543
    clock_t startClock, endClock;
1544
    int32 count, i;
1545
    int8 inputNum;
1546
    float128 a;
1547

1548
    count = 0;
1549
    inputNum = 0;
1550
    startClock = clock();
1551
    do {
1552
        for ( i = minIterations; i; --i ) {
1553
            a.low = inputs_float128[ inputNum ].low;
1554
            a.high = inputs_float128[ inputNum ].high;
1555
            function( a );
1556
            inputNum = ( inputNum + 1 ) & ( numInputs_float128 - 1 );
1557
        }
1558
        count += minIterations;
1559
    } while ( clock() - startClock < CLOCKS_PER_SEC );
1560
    inputNum = 0;
1561
    startClock = clock();
1562
    for ( i = count; i; --i ) {
1563
        a.low = inputs_float128[ inputNum ].low;
1564
        a.high = inputs_float128[ inputNum ].high;
1565
        function( a );
1566
        inputNum = ( inputNum + 1 ) & ( numInputs_float128 - 1 );
1567
    }
1568
    endClock = clock();
1569
    reportTime( count, endClock - startClock );
1570

1571
}
1572

1573
#ifdef FLOATX80
1574

1575
static void time_a_float128_z_floatx80( floatx80 function( float128 ) )
1576
{
1577
    clock_t startClock, endClock;
1578
    int32 count, i;
1579
    int8 inputNum;
1580
    float128 a;
1581

1582
    count = 0;
1583
    inputNum = 0;
1584
    startClock = clock();
1585
    do {
1586
        for ( i = minIterations; i; --i ) {
1587
            a.low = inputs_float128[ inputNum ].low;
1588
            a.high = inputs_float128[ inputNum ].high;
1589
            function( a );
1590
            inputNum = ( inputNum + 1 ) & ( numInputs_float128 - 1 );
1591
        }
1592
        count += minIterations;
1593
    } while ( clock() - startClock < CLOCKS_PER_SEC );
1594
    inputNum = 0;
1595
    startClock = clock();
1596
    for ( i = count; i; --i ) {
1597
        a.low = inputs_float128[ inputNum ].low;
1598
        a.high = inputs_float128[ inputNum ].high;
1599
        function( a );
1600
        inputNum = ( inputNum + 1 ) & ( numInputs_float128 - 1 );
1601
    }
1602
    endClock = clock();
1603
    reportTime( count, endClock - startClock );
1604

1605
}
1606

1607
#endif
1608

1609
static void time_az_float128( float128 function( float128 ) )
1610
{
1611
    clock_t startClock, endClock;
1612
    int32 count, i;
1613
    int8 inputNum;
1614
    float128 a;
1615

1616
    count = 0;
1617
    inputNum = 0;
1618
    startClock = clock();
1619
    do {
1620
        for ( i = minIterations; i; --i ) {
1621
            a.low = inputs_float128[ inputNum ].low;
1622
            a.high = inputs_float128[ inputNum ].high;
1623
            function( a );
1624
            inputNum = ( inputNum + 1 ) & ( numInputs_float128 - 1 );
1625
        }
1626
        count += minIterations;
1627
    } while ( clock() - startClock < CLOCKS_PER_SEC );
1628
    inputNum = 0;
1629
    startClock = clock();
1630
    for ( i = count; i; --i ) {
1631
        a.low = inputs_float128[ inputNum ].low;
1632
        a.high = inputs_float128[ inputNum ].high;
1633
        function( a );
1634
        inputNum = ( inputNum + 1 ) & ( numInputs_float128 - 1 );
1635
    }
1636
    endClock = clock();
1637
    reportTime( count, endClock - startClock );
1638

1639
}
1640

1641
static void time_ab_float128_z_flag( flag function( float128, float128 ) )
1642
{
1643
    clock_t startClock, endClock;
1644
    int32 count, i;
1645
    int8 inputNumA, inputNumB;
1646
    float128 a, b;
1647

1648
    count = 0;
1649
    inputNumA = 0;
1650
    inputNumB = 0;
1651
    startClock = clock();
1652
    do {
1653
        for ( i = minIterations; i; --i ) {
1654
            a.low = inputs_float128[ inputNumA ].low;
1655
            a.high = inputs_float128[ inputNumA ].high;
1656
            b.low = inputs_float128[ inputNumB ].low;
1657
            b.high = inputs_float128[ inputNumB ].high;
1658
            function( a, b );
1659
            inputNumA = ( inputNumA + 1 ) & ( numInputs_float128 - 1 );
1660
            if ( inputNumA == 0 ) ++inputNumB;
1661
            inputNumB = ( inputNumB + 1 ) & ( numInputs_float128 - 1 );
1662
        }
1663
        count += minIterations;
1664
    } while ( clock() - startClock < CLOCKS_PER_SEC );
1665
    inputNumA = 0;
1666
    inputNumB = 0;
1667
    startClock = clock();
1668
    for ( i = count; i; --i ) {
1669
        a.low = inputs_float128[ inputNumA ].low;
1670
        a.high = inputs_float128[ inputNumA ].high;
1671
        b.low = inputs_float128[ inputNumB ].low;
1672
        b.high = inputs_float128[ inputNumB ].high;
1673
        function( a, b );
1674
        inputNumA = ( inputNumA + 1 ) & ( numInputs_float128 - 1 );
1675
        if ( inputNumA == 0 ) ++inputNumB;
1676
        inputNumB = ( inputNumB + 1 ) & ( numInputs_float128 - 1 );
1677
    }
1678
    endClock = clock();
1679
    reportTime( count, endClock - startClock );
1680

1681
}
1682

1683
static void time_abz_float128( float128 function( float128, float128 ) )
1684
{
1685
    clock_t startClock, endClock;
1686
    int32 count, i;
1687
    int8 inputNumA, inputNumB;
1688
    float128 a, b;
1689

1690
    count = 0;
1691
    inputNumA = 0;
1692
    inputNumB = 0;
1693
    startClock = clock();
1694
    do {
1695
        for ( i = minIterations; i; --i ) {
1696
            a.low = inputs_float128[ inputNumA ].low;
1697
            a.high = inputs_float128[ inputNumA ].high;
1698
            b.low = inputs_float128[ inputNumB ].low;
1699
            b.high = inputs_float128[ inputNumB ].high;
1700
            function( a, b );
1701
            inputNumA = ( inputNumA + 1 ) & ( numInputs_float128 - 1 );
1702
            if ( inputNumA == 0 ) ++inputNumB;
1703
            inputNumB = ( inputNumB + 1 ) & ( numInputs_float128 - 1 );
1704
        }
1705
        count += minIterations;
1706
    } while ( clock() - startClock < CLOCKS_PER_SEC );
1707
    inputNumA = 0;
1708
    inputNumB = 0;
1709
    startClock = clock();
1710
    for ( i = count; i; --i ) {
1711
        a.low = inputs_float128[ inputNumA ].low;
1712
        a.high = inputs_float128[ inputNumA ].high;
1713
        b.low = inputs_float128[ inputNumB ].low;
1714
        b.high = inputs_float128[ inputNumB ].high;
1715
        function( a, b );
1716
        inputNumA = ( inputNumA + 1 ) & ( numInputs_float128 - 1 );
1717
        if ( inputNumA == 0 ) ++inputNumB;
1718
        inputNumB = ( inputNumB + 1 ) & ( numInputs_float128 - 1 );
1719
    }
1720
    endClock = clock();
1721
    reportTime( count, endClock - startClock );
1722

1723
}
1724

1725
static const struct {
1726
    bits64 high, low;
1727
} inputs_float128_pos[ numInputs_float128 ] = {
1728
    { LIT64( 0x3FDA200000100000 ), LIT64( 0x0000000000000000 ) },
1729
    { LIT64( 0x3FFF000000000000 ), LIT64( 0x0000000000000000 ) },
1730
    { LIT64( 0x05F14776190C8306 ), LIT64( 0xD8715F4E3D54BB92 ) },
1731
    { LIT64( 0x72B00000007FFFFF ), LIT64( 0xFFFFFFFFFFF7FFFF ) },
1732
    { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000000000 ) },
1733
    { LIT64( 0x3FFFFFFFFFE00000 ), LIT64( 0x0000008000000000 ) },
1734
    { LIT64( 0x407F1719CE722F3E ), LIT64( 0xDA6B3FE5FF29425B ) },
1735
    { LIT64( 0x43FFFF8000000000 ), LIT64( 0x0000000000400000 ) },
1736
    { LIT64( 0x401E000000000100 ), LIT64( 0x0000000000002000 ) },
1737
    { LIT64( 0x3FFED71DACDA8E47 ), LIT64( 0x4860E3C75D224F28 ) },
1738
    { LIT64( 0x3F7ECFC1E90647D1 ), LIT64( 0x7A124FE55623EE44 ) },
1739
    { LIT64( 0x0DF7007FFFFFFFFF ), LIT64( 0xFFFFFFFFEFFFFFFF ) },
1740
    { LIT64( 0x3FE5FFEFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFEFFF ) },
1741
    { LIT64( 0x403FFFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFBFE ) },
1742
    { LIT64( 0x3FFB2FBF7399AFEB ), LIT64( 0xA459EE6A5C16CA55 ) },
1743
    { LIT64( 0x3DB8FFFFFFFFFFFC ), LIT64( 0x0000000000000400 ) },
1744
    { LIT64( 0x3FC8FFDFFFFFFFFF ), LIT64( 0xFFFFFFFFF0000000 ) },
1745
    { LIT64( 0x3FFBFFFFFFDFFFFF ), LIT64( 0xFFF8000000000000 ) },
1746
    { LIT64( 0x407043C11737BE84 ), LIT64( 0xDDD58212ADC937F4 ) },
1747
    { LIT64( 0x0001000000000000 ), LIT64( 0x0000001000000001 ) },
1748
    { LIT64( 0x4036FFFFFFFFFFFF ), LIT64( 0xFE40000000000000 ) },
1749
    { LIT64( 0x4002FFFFFE000002 ), LIT64( 0x0000000000000000 ) },
1750
    { LIT64( 0x4000C3FEDE897773 ), LIT64( 0x326AC4FD8EFBE6DC ) },
1751
    { LIT64( 0x3FFF0000000FFFFF ), LIT64( 0xFFFFFE0000000000 ) },
1752
    { LIT64( 0x62C3E502146E426D ), LIT64( 0x43F3CAA0DC7DF1A0 ) },
1753
    { LIT64( 0x35CBD32E52BB570E ), LIT64( 0xBCC477CB11C6236C ) },
1754
    { LIT64( 0x6228FFFFFFC00000 ), LIT64( 0x0000000000000000 ) },
1755
    { LIT64( 0x3F80000000000000 ), LIT64( 0x0000000080000008 ) },
1756
    { LIT64( 0x41AFFFDFFFFFFFFF ), LIT64( 0xFFFC000000000000 ) },
1757
    { LIT64( 0x496F000000000000 ), LIT64( 0x00000001FFFBFFFF ) },
1758
    { LIT64( 0x3DE09BFE7923A338 ), LIT64( 0xBCC8FBBD7CEC1F4F ) },
1759
    { LIT64( 0x401CFFFFFFFFFFFF ), LIT64( 0xFFFFFFFEFFFFFF80 ) }
1760
};
1761

1762
static void time_az_float128_pos( float128 function( float128 ) )
1763
{
1764
    clock_t startClock, endClock;
1765
    int32 count, i;
1766
    int8 inputNum;
1767
    float128 a;
1768

1769
    count = 0;
1770
    inputNum = 0;
1771
    startClock = clock();
1772
    do {
1773
        for ( i = minIterations; i; --i ) {
1774
            a.low = inputs_float128_pos[ inputNum ].low;
1775
            a.high = inputs_float128_pos[ inputNum ].high;
1776
            function( a );
1777
            inputNum = ( inputNum + 1 ) & ( numInputs_float128 - 1 );
1778
        }
1779
        count += minIterations;
1780
    } while ( clock() - startClock < CLOCKS_PER_SEC );
1781
    inputNum = 0;
1782
    startClock = clock();
1783
    for ( i = count; i; --i ) {
1784
        a.low = inputs_float128_pos[ inputNum ].low;
1785
        a.high = inputs_float128_pos[ inputNum ].high;
1786
        function( a );
1787
        inputNum = ( inputNum + 1 ) & ( numInputs_float128 - 1 );
1788
    }
1789
    endClock = clock();
1790
    reportTime( count, endClock - startClock );
1791

1792
}
1793

1794
#endif
1795

1796
enum {
1797
    INT32_TO_FLOAT32 = 1,
1798
    INT32_TO_FLOAT64,
1799
#ifdef FLOATX80
1800
    INT32_TO_FLOATX80,
1801
#endif
1802
#ifdef FLOAT128
1803
    INT32_TO_FLOAT128,
1804
#endif
1805
    INT64_TO_FLOAT32,
1806
    INT64_TO_FLOAT64,
1807
#ifdef FLOATX80
1808
    INT64_TO_FLOATX80,
1809
#endif
1810
#ifdef FLOAT128
1811
    INT64_TO_FLOAT128,
1812
#endif
1813
    FLOAT32_TO_INT32,
1814
    FLOAT32_TO_INT32_ROUND_TO_ZERO,
1815
    FLOAT32_TO_INT64,
1816
    FLOAT32_TO_INT64_ROUND_TO_ZERO,
1817
    FLOAT32_TO_FLOAT64,
1818
#ifdef FLOATX80
1819
    FLOAT32_TO_FLOATX80,
1820
#endif
1821
#ifdef FLOAT128
1822
    FLOAT32_TO_FLOAT128,
1823
#endif
1824
    FLOAT32_ROUND_TO_INT,
1825
    FLOAT32_ADD,
1826
    FLOAT32_SUB,
1827
    FLOAT32_MUL,
1828
    FLOAT32_DIV,
1829
    FLOAT32_REM,
1830
    FLOAT32_SQRT,
1831
    FLOAT32_EQ,
1832
    FLOAT32_LE,
1833
    FLOAT32_LT,
1834
    FLOAT32_EQ_SIGNALING,
1835
    FLOAT32_LE_QUIET,
1836
    FLOAT32_LT_QUIET,
1837
    FLOAT64_TO_INT32,
1838
    FLOAT64_TO_INT32_ROUND_TO_ZERO,
1839
    FLOAT64_TO_INT64,
1840
    FLOAT64_TO_INT64_ROUND_TO_ZERO,
1841
    FLOAT64_TO_FLOAT32,
1842
#ifdef FLOATX80
1843
    FLOAT64_TO_FLOATX80,
1844
#endif
1845
#ifdef FLOAT128
1846
    FLOAT64_TO_FLOAT128,
1847
#endif
1848
    FLOAT64_ROUND_TO_INT,
1849
    FLOAT64_ADD,
1850
    FLOAT64_SUB,
1851
    FLOAT64_MUL,
1852
    FLOAT64_DIV,
1853
    FLOAT64_REM,
1854
    FLOAT64_SQRT,
1855
    FLOAT64_EQ,
1856
    FLOAT64_LE,
1857
    FLOAT64_LT,
1858
    FLOAT64_EQ_SIGNALING,
1859
    FLOAT64_LE_QUIET,
1860
    FLOAT64_LT_QUIET,
1861
#ifdef FLOATX80
1862
    FLOATX80_TO_INT32,
1863
    FLOATX80_TO_INT32_ROUND_TO_ZERO,
1864
    FLOATX80_TO_INT64,
1865
    FLOATX80_TO_INT64_ROUND_TO_ZERO,
1866
    FLOATX80_TO_FLOAT32,
1867
    FLOATX80_TO_FLOAT64,
1868
#ifdef FLOAT128
1869
    FLOATX80_TO_FLOAT128,
1870
#endif
1871
    FLOATX80_ROUND_TO_INT,
1872
    FLOATX80_ADD,
1873
    FLOATX80_SUB,
1874
    FLOATX80_MUL,
1875
    FLOATX80_DIV,
1876
    FLOATX80_REM,
1877
    FLOATX80_SQRT,
1878
    FLOATX80_EQ,
1879
    FLOATX80_LE,
1880
    FLOATX80_LT,
1881
    FLOATX80_EQ_SIGNALING,
1882
    FLOATX80_LE_QUIET,
1883
    FLOATX80_LT_QUIET,
1884
#endif
1885
#ifdef FLOAT128
1886
    FLOAT128_TO_INT32,
1887
    FLOAT128_TO_INT32_ROUND_TO_ZERO,
1888
    FLOAT128_TO_INT64,
1889
    FLOAT128_TO_INT64_ROUND_TO_ZERO,
1890
    FLOAT128_TO_FLOAT32,
1891
    FLOAT128_TO_FLOAT64,
1892
#ifdef FLOATX80
1893
    FLOAT128_TO_FLOATX80,
1894
#endif
1895
    FLOAT128_ROUND_TO_INT,
1896
    FLOAT128_ADD,
1897
    FLOAT128_SUB,
1898
    FLOAT128_MUL,
1899
    FLOAT128_DIV,
1900
    FLOAT128_REM,
1901
    FLOAT128_SQRT,
1902
    FLOAT128_EQ,
1903
    FLOAT128_LE,
1904
    FLOAT128_LT,
1905
    FLOAT128_EQ_SIGNALING,
1906
    FLOAT128_LE_QUIET,
1907
    FLOAT128_LT_QUIET,
1908
#endif
1909
    NUM_FUNCTIONS
1910
};
1911

1912
static struct {
1913
    char *name;
1914
    int8 numInputs;
1915
    flag roundingPrecision, roundingMode;
1916
    flag tininessMode, tininessModeAtReducedPrecision;
1917
} functions[ NUM_FUNCTIONS ] = {
1918
    { 0, 0, 0, 0, 0, 0 },
1919
    { "int32_to_float32",                1, FALSE, TRUE,  FALSE, FALSE },
1920
    { "int32_to_float64",                1, FALSE, FALSE, FALSE, FALSE },
1921
#ifdef FLOATX80
1922
    { "int32_to_floatx80",               1, FALSE, FALSE, FALSE, FALSE },
1923
#endif
1924
#ifdef FLOAT128
1925
    { "int32_to_float128",               1, FALSE, FALSE, FALSE, FALSE },
1926
#endif
1927
    { "int64_to_float32",                1, FALSE, TRUE,  FALSE, FALSE },
1928
    { "int64_to_float64",                1, FALSE, TRUE,  FALSE, FALSE },
1929
#ifdef FLOATX80
1930
    { "int64_to_floatx80",               1, FALSE, FALSE, FALSE, FALSE },
1931
#endif
1932
#ifdef FLOAT128
1933
    { "int64_to_float128",               1, FALSE, FALSE, FALSE, FALSE },
1934
#endif
1935
    { "float32_to_int32",                1, FALSE, TRUE,  FALSE, FALSE },
1936
    { "float32_to_int32_round_to_zero",  1, FALSE, FALSE, FALSE, FALSE },
1937
    { "float32_to_int64",                1, FALSE, TRUE,  FALSE, FALSE },
1938
    { "float32_to_int64_round_to_zero",  1, FALSE, FALSE, FALSE, FALSE },
1939
    { "float32_to_float64",              1, FALSE, FALSE, FALSE, FALSE },
1940
#ifdef FLOATX80
1941
    { "float32_to_floatx80",             1, FALSE, FALSE, FALSE, FALSE },
1942
#endif
1943
#ifdef FLOAT128
1944
    { "float32_to_float128",             1, FALSE, FALSE, FALSE, FALSE },
1945
#endif
1946
    { "float32_round_to_int",            1, FALSE, TRUE,  FALSE, FALSE },
1947
    { "float32_add",                     2, FALSE, TRUE,  FALSE, FALSE },
1948
    { "float32_sub",                     2, FALSE, TRUE,  FALSE, FALSE },
1949
    { "float32_mul",                     2, FALSE, TRUE,  TRUE,  FALSE },
1950
    { "float32_div",                     2, FALSE, TRUE,  FALSE, FALSE },
1951
    { "float32_rem",                     2, FALSE, FALSE, FALSE, FALSE },
1952
    { "float32_sqrt",                    1, FALSE, TRUE,  FALSE, FALSE },
1953
    { "float32_eq",                      2, FALSE, FALSE, FALSE, FALSE },
1954
    { "float32_le",                      2, FALSE, FALSE, FALSE, FALSE },
1955
    { "float32_lt",                      2, FALSE, FALSE, FALSE, FALSE },
1956
    { "float32_eq_signaling",            2, FALSE, FALSE, FALSE, FALSE },
1957
    { "float32_le_quiet",                2, FALSE, FALSE, FALSE, FALSE },
1958
    { "float32_lt_quiet",                2, FALSE, FALSE, FALSE, FALSE },
1959
    { "float64_to_int32",                1, FALSE, TRUE,  FALSE, FALSE },
1960
    { "float64_to_int32_round_to_zero",  1, FALSE, FALSE, FALSE, FALSE },
1961
    { "float64_to_int64",                1, FALSE, TRUE,  FALSE, FALSE },
1962
    { "float64_to_int64_round_to_zero",  1, FALSE, FALSE, FALSE, FALSE },
1963
    { "float64_to_float32",              1, FALSE, TRUE,  TRUE,  FALSE },
1964
#ifdef FLOATX80
1965
    { "float64_to_floatx80",             1, FALSE, FALSE, FALSE, FALSE },
1966
#endif
1967
#ifdef FLOAT128
1968
    { "float64_to_float128",             1, FALSE, FALSE, FALSE, FALSE },
1969
#endif
1970
    { "float64_round_to_int",            1, FALSE, TRUE,  FALSE, FALSE },
1971
    { "float64_add",                     2, FALSE, TRUE,  FALSE, FALSE },
1972
    { "float64_sub",                     2, FALSE, TRUE,  FALSE, FALSE },
1973
    { "float64_mul",                     2, FALSE, TRUE,  TRUE,  FALSE },
1974
    { "float64_div",                     2, FALSE, TRUE,  FALSE, FALSE },
1975
    { "float64_rem",                     2, FALSE, FALSE, FALSE, FALSE },
1976
    { "float64_sqrt",                    1, FALSE, TRUE,  FALSE, FALSE },
1977
    { "float64_eq",                      2, FALSE, FALSE, FALSE, FALSE },
1978
    { "float64_le",                      2, FALSE, FALSE, FALSE, FALSE },
1979
    { "float64_lt",                      2, FALSE, FALSE, FALSE, FALSE },
1980
    { "float64_eq_signaling",            2, FALSE, FALSE, FALSE, FALSE },
1981
    { "float64_le_quiet",                2, FALSE, FALSE, FALSE, FALSE },
1982
    { "float64_lt_quiet",                2, FALSE, FALSE, FALSE, FALSE },
1983
#ifdef FLOATX80
1984
    { "floatx80_to_int32",               1, FALSE, TRUE,  FALSE, FALSE },
1985
    { "floatx80_to_int32_round_to_zero", 1, FALSE, FALSE, FALSE, FALSE },
1986
    { "floatx80_to_int64",               1, FALSE, TRUE,  FALSE, FALSE },
1987
    { "floatx80_to_int64_round_to_zero", 1, FALSE, FALSE, FALSE, FALSE },
1988
    { "floatx80_to_float32",             1, FALSE, TRUE,  TRUE,  FALSE },
1989
    { "floatx80_to_float64",             1, FALSE, TRUE,  TRUE,  FALSE },
1990
#ifdef FLOAT128
1991
    { "floatx80_to_float128",            1, FALSE, FALSE, FALSE, FALSE },
1992
#endif
1993
    { "floatx80_round_to_int",           1, FALSE, TRUE,  FALSE, FALSE },
1994
    { "floatx80_add",                    2, TRUE,  TRUE,  FALSE, TRUE  },
1995
    { "floatx80_sub",                    2, TRUE,  TRUE,  FALSE, TRUE  },
1996
    { "floatx80_mul",                    2, TRUE,  TRUE,  TRUE,  TRUE  },
1997
    { "floatx80_div",                    2, TRUE,  TRUE,  FALSE, TRUE  },
1998
    { "floatx80_rem",                    2, FALSE, FALSE, FALSE, FALSE },
1999
    { "floatx80_sqrt",                   1, TRUE,  TRUE,  FALSE, FALSE },
2000
    { "floatx80_eq",                     2, FALSE, FALSE, FALSE, FALSE },
2001
    { "floatx80_le",                     2, FALSE, FALSE, FALSE, FALSE },
2002
    { "floatx80_lt",                     2, FALSE, FALSE, FALSE, FALSE },
2003
    { "floatx80_eq_signaling",           2, FALSE, FALSE, FALSE, FALSE },
2004
    { "floatx80_le_quiet",               2, FALSE, FALSE, FALSE, FALSE },
2005
    { "floatx80_lt_quiet",               2, FALSE, FALSE, FALSE, FALSE },
2006
#endif
2007
#ifdef FLOAT128
2008
    { "float128_to_int32",               1, FALSE, TRUE,  FALSE, FALSE },
2009
    { "float128_to_int32_round_to_zero", 1, FALSE, FALSE, FALSE, FALSE },
2010
    { "float128_to_int64",               1, FALSE, TRUE,  FALSE, FALSE },
2011
    { "float128_to_int64_round_to_zero", 1, FALSE, FALSE, FALSE, FALSE },
2012
    { "float128_to_float32",             1, FALSE, TRUE,  TRUE,  FALSE },
2013
    { "float128_to_float64",             1, FALSE, TRUE,  TRUE,  FALSE },
2014
#ifdef FLOATX80
2015
    { "float128_to_floatx80",            1, FALSE, TRUE,  TRUE,  FALSE },
2016
#endif
2017
    { "float128_round_to_int",           1, FALSE, TRUE,  FALSE, FALSE },
2018
    { "float128_add",                    2, FALSE, TRUE,  FALSE, FALSE },
2019
    { "float128_sub",                    2, FALSE, TRUE,  FALSE, FALSE },
2020
    { "float128_mul",                    2, FALSE, TRUE,  TRUE,  FALSE },
2021
    { "float128_div",                    2, FALSE, TRUE,  FALSE, FALSE },
2022
    { "float128_rem",                    2, FALSE, FALSE, FALSE, FALSE },
2023
    { "float128_sqrt",                   1, FALSE, TRUE,  FALSE, FALSE },
2024
    { "float128_eq",                     2, FALSE, FALSE, FALSE, FALSE },
2025
    { "float128_le",                     2, FALSE, FALSE, FALSE, FALSE },
2026
    { "float128_lt",                     2, FALSE, FALSE, FALSE, FALSE },
2027
    { "float128_eq_signaling",           2, FALSE, FALSE, FALSE, FALSE },
2028
    { "float128_le_quiet",               2, FALSE, FALSE, FALSE, FALSE },
2029
    { "float128_lt_quiet",               2, FALSE, FALSE, FALSE, FALSE },
2030
#endif
2031
};
2032

2033
enum {
2034
    ROUND_NEAREST_EVEN = 1,
2035
    ROUND_TO_ZERO,
2036
    ROUND_DOWN,
2037
    ROUND_UP,
2038
    NUM_ROUNDINGMODES
2039
};
2040
enum {
2041
    TININESS_BEFORE_ROUNDING = 1,
2042
    TININESS_AFTER_ROUNDING,
2043
    NUM_TININESSMODES
2044
};
2045

2046
static void
2047
 timeFunctionVariety(
2048
     uint8 functionCode,
2049
     int8 roundingPrecision,
2050
     int8 roundingMode,
2051
     int8 tininessMode
2052
 )
2053
{
2054
    uint8 roundingCode;
2055
    int8 tininessCode;
2056

2057
    functionName = functions[ functionCode ].name;
2058
    if ( roundingPrecision == 32 ) {
2059
        roundingPrecisionName = "32";
2060
    }
2061
    else if ( roundingPrecision == 64 ) {
2062
        roundingPrecisionName = "64";
2063
    }
2064
    else if ( roundingPrecision == 80 ) {
2065
        roundingPrecisionName = "80";
2066
    }
2067
    else {
2068
        roundingPrecisionName = NULL;
2069
    }
2070
#ifdef FLOATX80
2071
    floatx80_rounding_precision = roundingPrecision;
2072
#endif
2073
    switch ( roundingMode ) {
2074
     case 0:
2075
        roundingModeName = NULL;
2076
        roundingCode = float_round_nearest_even;
2077
        break;
2078
     case ROUND_NEAREST_EVEN:
2079
        roundingModeName = "nearest_even";
2080
        roundingCode = float_round_nearest_even;
2081
        break;
2082
     case ROUND_TO_ZERO:
2083
        roundingModeName = "to_zero";
2084
        roundingCode = float_round_to_zero;
2085
        break;
2086
     case ROUND_DOWN:
2087
        roundingModeName = "down";
2088
        roundingCode = float_round_down;
2089
        break;
2090
     case ROUND_UP:
2091
        roundingModeName = "up";
2092
        roundingCode = float_round_up;
2093
        break;
2094
    }
2095
    float_rounding_mode = roundingCode;
2096
    switch ( tininessMode ) {
2097
     case 0:
2098
        tininessModeName = NULL;
2099
        tininessCode = float_tininess_after_rounding;
2100
        break;
2101
     case TININESS_BEFORE_ROUNDING:
2102
        tininessModeName = "before";
2103
        tininessCode = float_tininess_before_rounding;
2104
        break;
2105
     case TININESS_AFTER_ROUNDING:
2106
        tininessModeName = "after";
2107
        tininessCode = float_tininess_after_rounding;
2108
        break;
2109
    }
2110
    float_detect_tininess = tininessCode;
2111
    switch ( functionCode ) {
2112
     case INT32_TO_FLOAT32:
2113
        time_a_int32_z_float32( int32_to_float32 );
2114
        break;
2115
     case INT32_TO_FLOAT64:
2116
        time_a_int32_z_float64( int32_to_float64 );
2117
        break;
2118
#ifdef FLOATX80
2119
     case INT32_TO_FLOATX80:
2120
        time_a_int32_z_floatx80( int32_to_floatx80 );
2121
        break;
2122
#endif
2123
#ifdef FLOAT128
2124
     case INT32_TO_FLOAT128:
2125
        time_a_int32_z_float128( int32_to_float128 );
2126
        break;
2127
#endif
2128
     case INT64_TO_FLOAT32:
2129
        time_a_int64_z_float32( int64_to_float32 );
2130
        break;
2131
     case INT64_TO_FLOAT64:
2132
        time_a_int64_z_float64( int64_to_float64 );
2133
        break;
2134
#ifdef FLOATX80
2135
     case INT64_TO_FLOATX80:
2136
        time_a_int64_z_floatx80( int64_to_floatx80 );
2137
        break;
2138
#endif
2139
#ifdef FLOAT128
2140
     case INT64_TO_FLOAT128:
2141
        time_a_int64_z_float128( int64_to_float128 );
2142
        break;
2143
#endif
2144
     case FLOAT32_TO_INT32:
2145
        time_a_float32_z_int32( float32_to_int32 );
2146
        break;
2147
     case FLOAT32_TO_INT32_ROUND_TO_ZERO:
2148
        time_a_float32_z_int32( float32_to_int32_round_to_zero );
2149
        break;
2150
     case FLOAT32_TO_INT64:
2151
        time_a_float32_z_int64( float32_to_int64 );
2152
        break;
2153
     case FLOAT32_TO_INT64_ROUND_TO_ZERO:
2154
        time_a_float32_z_int64( float32_to_int64_round_to_zero );
2155
        break;
2156
     case FLOAT32_TO_FLOAT64:
2157
        time_a_float32_z_float64( float32_to_float64 );
2158
        break;
2159
#ifdef FLOATX80
2160
     case FLOAT32_TO_FLOATX80:
2161
        time_a_float32_z_floatx80( float32_to_floatx80 );
2162
        break;
2163
#endif
2164
#ifdef FLOAT128
2165
     case FLOAT32_TO_FLOAT128:
2166
        time_a_float32_z_float128( float32_to_float128 );
2167
        break;
2168
#endif
2169
     case FLOAT32_ROUND_TO_INT:
2170
        time_az_float32( float32_round_to_int );
2171
        break;
2172
     case FLOAT32_ADD:
2173
        time_abz_float32( float32_add );
2174
        break;
2175
     case FLOAT32_SUB:
2176
        time_abz_float32( float32_sub );
2177
        break;
2178
     case FLOAT32_MUL:
2179
        time_abz_float32( float32_mul );
2180
        break;
2181
     case FLOAT32_DIV:
2182
        time_abz_float32( float32_div );
2183
        break;
2184
     case FLOAT32_REM:
2185
        time_abz_float32( float32_rem );
2186
        break;
2187
     case FLOAT32_SQRT:
2188
        time_az_float32_pos( float32_sqrt );
2189
        break;
2190
     case FLOAT32_EQ:
2191
        time_ab_float32_z_flag( float32_eq );
2192
        break;
2193
     case FLOAT32_LE:
2194
        time_ab_float32_z_flag( float32_le );
2195
        break;
2196
     case FLOAT32_LT:
2197
        time_ab_float32_z_flag( float32_lt );
2198
        break;
2199
     case FLOAT32_EQ_SIGNALING:
2200
        time_ab_float32_z_flag( float32_eq_signaling );
2201
        break;
2202
     case FLOAT32_LE_QUIET:
2203
        time_ab_float32_z_flag( float32_le_quiet );
2204
        break;
2205
     case FLOAT32_LT_QUIET:
2206
        time_ab_float32_z_flag( float32_lt_quiet );
2207
        break;
2208
     case FLOAT64_TO_INT32:
2209
        time_a_float64_z_int32( float64_to_int32 );
2210
        break;
2211
     case FLOAT64_TO_INT32_ROUND_TO_ZERO:
2212
        time_a_float64_z_int32( float64_to_int32_round_to_zero );
2213
        break;
2214
     case FLOAT64_TO_INT64:
2215
        time_a_float64_z_int64( float64_to_int64 );
2216
        break;
2217
     case FLOAT64_TO_INT64_ROUND_TO_ZERO:
2218
        time_a_float64_z_int64( float64_to_int64_round_to_zero );
2219
        break;
2220
     case FLOAT64_TO_FLOAT32:
2221
        time_a_float64_z_float32( float64_to_float32 );
2222
        break;
2223
#ifdef FLOATX80
2224
     case FLOAT64_TO_FLOATX80:
2225
        time_a_float64_z_floatx80( float64_to_floatx80 );
2226
        break;
2227
#endif
2228
#ifdef FLOAT128
2229
     case FLOAT64_TO_FLOAT128:
2230
        time_a_float64_z_float128( float64_to_float128 );
2231
        break;
2232
#endif
2233
     case FLOAT64_ROUND_TO_INT:
2234
        time_az_float64( float64_round_to_int );
2235
        break;
2236
     case FLOAT64_ADD:
2237
        time_abz_float64( float64_add );
2238
        break;
2239
     case FLOAT64_SUB:
2240
        time_abz_float64( float64_sub );
2241
        break;
2242
     case FLOAT64_MUL:
2243
        time_abz_float64( float64_mul );
2244
        break;
2245
     case FLOAT64_DIV:
2246
        time_abz_float64( float64_div );
2247
        break;
2248
     case FLOAT64_REM:
2249
        time_abz_float64( float64_rem );
2250
        break;
2251
     case FLOAT64_SQRT:
2252
        time_az_float64_pos( float64_sqrt );
2253
        break;
2254
     case FLOAT64_EQ:
2255
        time_ab_float64_z_flag( float64_eq );
2256
        break;
2257
     case FLOAT64_LE:
2258
        time_ab_float64_z_flag( float64_le );
2259
        break;
2260
     case FLOAT64_LT:
2261
        time_ab_float64_z_flag( float64_lt );
2262
        break;
2263
     case FLOAT64_EQ_SIGNALING:
2264
        time_ab_float64_z_flag( float64_eq_signaling );
2265
        break;
2266
     case FLOAT64_LE_QUIET:
2267
        time_ab_float64_z_flag( float64_le_quiet );
2268
        break;
2269
     case FLOAT64_LT_QUIET:
2270
        time_ab_float64_z_flag( float64_lt_quiet );
2271
        break;
2272
#ifdef FLOATX80
2273
     case FLOATX80_TO_INT32:
2274
        time_a_floatx80_z_int32( floatx80_to_int32 );
2275
        break;
2276
     case FLOATX80_TO_INT32_ROUND_TO_ZERO:
2277
        time_a_floatx80_z_int32( floatx80_to_int32_round_to_zero );
2278
        break;
2279
     case FLOATX80_TO_INT64:
2280
        time_a_floatx80_z_int64( floatx80_to_int64 );
2281
        break;
2282
     case FLOATX80_TO_INT64_ROUND_TO_ZERO:
2283
        time_a_floatx80_z_int64( floatx80_to_int64_round_to_zero );
2284
        break;
2285
     case FLOATX80_TO_FLOAT32:
2286
        time_a_floatx80_z_float32( floatx80_to_float32 );
2287
        break;
2288
     case FLOATX80_TO_FLOAT64:
2289
        time_a_floatx80_z_float64( floatx80_to_float64 );
2290
        break;
2291
#ifdef FLOAT128
2292
     case FLOATX80_TO_FLOAT128:
2293
        time_a_floatx80_z_float128( floatx80_to_float128 );
2294
        break;
2295
#endif
2296
     case FLOATX80_ROUND_TO_INT:
2297
        time_az_floatx80( floatx80_round_to_int );
2298
        break;
2299
     case FLOATX80_ADD:
2300
        time_abz_floatx80( floatx80_add );
2301
        break;
2302
     case FLOATX80_SUB:
2303
        time_abz_floatx80( floatx80_sub );
2304
        break;
2305
     case FLOATX80_MUL:
2306
        time_abz_floatx80( floatx80_mul );
2307
        break;
2308
     case FLOATX80_DIV:
2309
        time_abz_floatx80( floatx80_div );
2310
        break;
2311
     case FLOATX80_REM:
2312
        time_abz_floatx80( floatx80_rem );
2313
        break;
2314
     case FLOATX80_SQRT:
2315
        time_az_floatx80_pos( floatx80_sqrt );
2316
        break;
2317
     case FLOATX80_EQ:
2318
        time_ab_floatx80_z_flag( floatx80_eq );
2319
        break;
2320
     case FLOATX80_LE:
2321
        time_ab_floatx80_z_flag( floatx80_le );
2322
        break;
2323
     case FLOATX80_LT:
2324
        time_ab_floatx80_z_flag( floatx80_lt );
2325
        break;
2326
     case FLOATX80_EQ_SIGNALING:
2327
        time_ab_floatx80_z_flag( floatx80_eq_signaling );
2328
        break;
2329
     case FLOATX80_LE_QUIET:
2330
        time_ab_floatx80_z_flag( floatx80_le_quiet );
2331
        break;
2332
     case FLOATX80_LT_QUIET:
2333
        time_ab_floatx80_z_flag( floatx80_lt_quiet );
2334
        break;
2335
#endif
2336
#ifdef FLOAT128
2337
     case FLOAT128_TO_INT32:
2338
        time_a_float128_z_int32( float128_to_int32 );
2339
        break;
2340
     case FLOAT128_TO_INT32_ROUND_TO_ZERO:
2341
        time_a_float128_z_int32( float128_to_int32_round_to_zero );
2342
        break;
2343
     case FLOAT128_TO_INT64:
2344
        time_a_float128_z_int64( float128_to_int64 );
2345
        break;
2346
     case FLOAT128_TO_INT64_ROUND_TO_ZERO:
2347
        time_a_float128_z_int64( float128_to_int64_round_to_zero );
2348
        break;
2349
     case FLOAT128_TO_FLOAT32:
2350
        time_a_float128_z_float32( float128_to_float32 );
2351
        break;
2352
     case FLOAT128_TO_FLOAT64:
2353
        time_a_float128_z_float64( float128_to_float64 );
2354
        break;
2355
#ifdef FLOATX80
2356
     case FLOAT128_TO_FLOATX80:
2357
        time_a_float128_z_floatx80( float128_to_floatx80 );
2358
        break;
2359
#endif
2360
     case FLOAT128_ROUND_TO_INT:
2361
        time_az_float128( float128_round_to_int );
2362
        break;
2363
     case FLOAT128_ADD:
2364
        time_abz_float128( float128_add );
2365
        break;
2366
     case FLOAT128_SUB:
2367
        time_abz_float128( float128_sub );
2368
        break;
2369
     case FLOAT128_MUL:
2370
        time_abz_float128( float128_mul );
2371
        break;
2372
     case FLOAT128_DIV:
2373
        time_abz_float128( float128_div );
2374
        break;
2375
     case FLOAT128_REM:
2376
        time_abz_float128( float128_rem );
2377
        break;
2378
     case FLOAT128_SQRT:
2379
        time_az_float128_pos( float128_sqrt );
2380
        break;
2381
     case FLOAT128_EQ:
2382
        time_ab_float128_z_flag( float128_eq );
2383
        break;
2384
     case FLOAT128_LE:
2385
        time_ab_float128_z_flag( float128_le );
2386
        break;
2387
     case FLOAT128_LT:
2388
        time_ab_float128_z_flag( float128_lt );
2389
        break;
2390
     case FLOAT128_EQ_SIGNALING:
2391
        time_ab_float128_z_flag( float128_eq_signaling );
2392
        break;
2393
     case FLOAT128_LE_QUIET:
2394
        time_ab_float128_z_flag( float128_le_quiet );
2395
        break;
2396
     case FLOAT128_LT_QUIET:
2397
        time_ab_float128_z_flag( float128_lt_quiet );
2398
        break;
2399
#endif
2400
    }
2401

2402
}
2403

2404
static void
2405
 timeFunction(
2406
     uint8 functionCode,
2407
     int8 roundingPrecisionIn,
2408
     int8 roundingModeIn,
2409
     int8 tininessModeIn
2410
 )
2411
{
2412
    int8 roundingPrecision, roundingMode, tininessMode;
2413

2414
    roundingPrecision = 32;
2415
    for (;;) {
2416
        if ( ! functions[ functionCode ].roundingPrecision ) {
2417
            roundingPrecision = 0;
2418
        }
2419
        else if ( roundingPrecisionIn ) {
2420
            roundingPrecision = roundingPrecisionIn;
2421
        }
2422
        for ( roundingMode = 1;
2423
              roundingMode < NUM_ROUNDINGMODES;
2424
              ++roundingMode
2425
            ) {
2426
            if ( ! functions[ functionCode ].roundingMode ) {
2427
                roundingMode = 0;
2428
            }
2429
            else if ( roundingModeIn ) {
2430
                roundingMode = roundingModeIn;
2431
            }
2432
            for ( tininessMode = 1;
2433
                  tininessMode < NUM_TININESSMODES;
2434
                  ++tininessMode
2435
                ) {
2436
                if (    ( roundingPrecision == 32 )
2437
                     || ( roundingPrecision == 64 ) ) {
2438
                    if ( ! functions[ functionCode ]
2439
                               .tininessModeAtReducedPrecision
2440
                       ) {
2441
                        tininessMode = 0;
2442
                    }
2443
                    else if ( tininessModeIn ) {
2444
                        tininessMode = tininessModeIn;
2445
                    }
2446
                }
2447
                else {
2448
                    if ( ! functions[ functionCode ].tininessMode ) {
2449
                        tininessMode = 0;
2450
                    }
2451
                    else if ( tininessModeIn ) {
2452
                        tininessMode = tininessModeIn;
2453
                    }
2454
                }
2455
                timeFunctionVariety(
2456
                    functionCode, roundingPrecision, roundingMode, tininessMode
2457
                );
2458
                if ( tininessModeIn || ! tininessMode ) break;
2459
            }
2460
            if ( roundingModeIn || ! roundingMode ) break;
2461
        }
2462
        if ( roundingPrecisionIn || ! roundingPrecision ) break;
2463
        if ( roundingPrecision == 80 ) {
2464
            break;
2465
        }
2466
        else if ( roundingPrecision == 64 ) {
2467
            roundingPrecision = 80;
2468
        }
2469
        else if ( roundingPrecision == 32 ) {
2470
            roundingPrecision = 64;
2471
        }
2472
    }
2473

2474
}
2475

2476
main( int argc, char **argv )
2477
{
2478
    char *argPtr;
2479
    flag functionArgument;
2480
    uint8 functionCode;
2481
    int8 operands, roundingPrecision, roundingMode, tininessMode;
2482

2483
    if ( argc <= 1 ) goto writeHelpMessage;
2484
    functionArgument = FALSE;
2485
    functionCode = 0;
2486
    operands = 0;
2487
    roundingPrecision = 0;
2488
    roundingMode = 0;
2489
    tininessMode = 0;
2490
    --argc;
2491
    ++argv;
2492
    while ( argc && ( argPtr = argv[ 0 ] ) ) {
2493
        if ( argPtr[ 0 ] == '-' ) ++argPtr;
2494
        if ( strcmp( argPtr, "help" ) == 0 ) {
2495
 writeHelpMessage:
2496
            fputs(
2497
"timesoftfloat [<option>...] <function>\n"
2498
"  <option>:  (* is default)\n"
2499
"    -help            --Write this message and exit.\n"
2500
#ifdef FLOATX80
2501
"    -precision32     --Only time rounding precision equivalent to float32.\n"
2502
"    -precision64     --Only time rounding precision equivalent to float64.\n"
2503
"    -precision80     --Only time maximum rounding precision.\n"
2504
#endif
2505
"    -nearesteven     --Only time rounding to nearest/even.\n"
2506
"    -tozero          --Only time rounding to zero.\n"
2507
"    -down            --Only time rounding down.\n"
2508
"    -up              --Only time rounding up.\n"
2509
"    -tininessbefore  --Only time underflow tininess before rounding.\n"
2510
"    -tininessafter   --Only time underflow tininess after rounding.\n"
2511
"  <function>:\n"
2512
"    int32_to_<float>                 <float>_add   <float>_eq\n"
2513
"    <float>_to_int32                 <float>_sub   <float>_le\n"
2514
"    <float>_to_int32_round_to_zero   <float>_mul   <float>_lt\n"
2515
"    int64_to_<float>                 <float>_div   <float>_eq_signaling\n"
2516
"    <float>_to_int64                 <float>_rem   <float>_le_quiet\n"
2517
"    <float>_to_int64_round_to_zero                 <float>_lt_quiet\n"
2518
"    <float>_to_<float>\n"
2519
"    <float>_round_to_int\n"
2520
"    <float>_sqrt\n"
2521
"    -all1            --All 1-operand functions.\n"
2522
"    -all2            --All 2-operand functions.\n"
2523
"    -all             --All functions.\n"
2524
"  <float>:\n"
2525
"    float32          --Single precision.\n"
2526
"    float64          --Double precision.\n"
2527
#ifdef FLOATX80
2528
"    floatx80         --Extended double precision.\n"
2529
#endif
2530
#ifdef FLOAT128
2531
"    float128         --Quadruple precision.\n"
2532
#endif
2533
                ,
2534
                stdout
2535
            );
2536
            return EXIT_SUCCESS;
2537
        }
2538
#ifdef FLOATX80
2539
        else if ( strcmp( argPtr, "precision32" ) == 0 ) {
2540
            roundingPrecision = 32;
2541
        }
2542
        else if ( strcmp( argPtr, "precision64" ) == 0 ) {
2543
            roundingPrecision = 64;
2544
        }
2545
        else if ( strcmp( argPtr, "precision80" ) == 0 ) {
2546
            roundingPrecision = 80;
2547
        }
2548
#endif
2549
        else if (    ( strcmp( argPtr, "nearesteven" ) == 0 )
2550
                  || ( strcmp( argPtr, "nearest_even" ) == 0 ) ) {
2551
            roundingMode = ROUND_NEAREST_EVEN;
2552
        }
2553
        else if (    ( strcmp( argPtr, "tozero" ) == 0 )
2554
                  || ( strcmp( argPtr, "to_zero" ) == 0 ) ) {
2555
            roundingMode = ROUND_TO_ZERO;
2556
        }
2557
        else if ( strcmp( argPtr, "down" ) == 0 ) {
2558
            roundingMode = ROUND_DOWN;
2559
        }
2560
        else if ( strcmp( argPtr, "up" ) == 0 ) {
2561
            roundingMode = ROUND_UP;
2562
        }
2563
        else if ( strcmp( argPtr, "tininessbefore" ) == 0 ) {
2564
            tininessMode = TININESS_BEFORE_ROUNDING;
2565
        }
2566
        else if ( strcmp( argPtr, "tininessafter" ) == 0 ) {
2567
            tininessMode = TININESS_AFTER_ROUNDING;
2568
        }
2569
        else if ( strcmp( argPtr, "all1" ) == 0 ) {
2570
            functionArgument = TRUE;
2571
            functionCode = 0;
2572
            operands = 1;
2573
        }
2574
        else if ( strcmp( argPtr, "all2" ) == 0 ) {
2575
            functionArgument = TRUE;
2576
            functionCode = 0;
2577
            operands = 2;
2578
        }
2579
        else if ( strcmp( argPtr, "all" ) == 0 ) {
2580
            functionArgument = TRUE;
2581
            functionCode = 0;
2582
            operands = 0;
2583
        }
2584
        else {
2585
            for ( functionCode = 1;
2586
                  functionCode < NUM_FUNCTIONS;
2587
                  ++functionCode 
2588
                ) {
2589
                if ( strcmp( argPtr, functions[ functionCode ].name ) == 0 ) {
2590
                    break;
2591
                }
2592
            }
2593
            if ( functionCode == NUM_FUNCTIONS ) {
2594
                fail( "Invalid option or function `%s'", argv[ 0 ] );
2595
            }
2596
            functionArgument = TRUE;
2597
        }
2598
        --argc;
2599
        ++argv;
2600
    }
2601
    if ( ! functionArgument ) fail( "Function argument required" );
2602
    if ( functionCode ) {
2603
        timeFunction(
2604
            functionCode, roundingPrecision, roundingMode, tininessMode );
2605
    }
2606
    else if ( operands == 1 ) {
2607
        for ( functionCode = 1; functionCode < NUM_FUNCTIONS; ++functionCode
2608
            ) {
2609
            if ( functions[ functionCode ].numInputs == 1 ) {
2610
                timeFunction(
2611
                    functionCode, roundingPrecision, roundingMode, tininessMode
2612
                );
2613
            }
2614
        }
2615
    }
2616
    else if ( operands == 2 ) {
2617
        for ( functionCode = 1; functionCode < NUM_FUNCTIONS; ++functionCode
2618
            ) {
2619
            if ( functions[ functionCode ].numInputs == 2 ) {
2620
                timeFunction(
2621
                    functionCode, roundingPrecision, roundingMode, tininessMode
2622
                );
2623
            }
2624
        }
2625
    }
2626
    else {
2627
        for ( functionCode = 1; functionCode < NUM_FUNCTIONS; ++functionCode
2628
            ) {
2629
            timeFunction(
2630
                functionCode, roundingPrecision, roundingMode, tininessMode );
2631
        }
2632
    }
2633
    return EXIT_SUCCESS;
2634

2635
}
2636

2637

2638
Product

Resources

Company
