1129203Scognet/* $NetBSD: timesoftfloat.c,v 1.1 2000/06/06 08:15:11 bjh21 Exp $ */ 2129203Scognet 3129203Scognet/* 4129203Scognet=============================================================================== 5129203Scognet 6129203ScognetThis C source file is part of the SoftFloat IEC/IEEE Floating-point 7129203ScognetArithmetic Package, Release 2a. 8129203Scognet 9129203ScognetWritten by John R. Hauser. This work was made possible in part by the 10129203ScognetInternational Computer Science Institute, located at Suite 600, 1947 Center 11129203ScognetStreet, Berkeley, California 94704. Funding was partially provided by the 12129203ScognetNational Science Foundation under grant MIP-9311980. The original version 13129203Scognetof this code was written as part of a project to build a fixed-point vector 14129203Scognetprocessor in collaboration with the University of California at Berkeley, 15129203Scognetoverseen by Profs. Nelson Morgan and John Wawrzynek. More information 16129203Scognetis available through the Web page `http://HTTP.CS.Berkeley.EDU/~jhauser/ 17129203Scognetarithmetic/SoftFloat.html'. 18129203Scognet 19129203ScognetTHIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort 20129203Scognethas been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT 21129203ScognetTIMES RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO 22129203ScognetPERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY 23129203ScognetAND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE. 24129203Scognet 25129203ScognetDerivative works are acceptable, even for commercial purposes, so long as 26129203Scognet(1) they include prominent notice that the work is derivative, and (2) they 27129203Scognetinclude prominent notice akin to these four paragraphs for those parts of 28129203Scognetthis code that are retained. 29129203Scognet 30129203Scognet=============================================================================== 31129203Scognet*/ 32129203Scognet 33129203Scognet#include <sys/cdefs.h> 34129203Scognet__FBSDID("$FreeBSD: releng/10.2/lib/libc/softfloat/timesoftfloat.c 129203 2004-05-14 12:13:06Z cognet $"); 35129203Scognet 36129203Scognet#include <stdlib.h> 37129203Scognet#include <stdarg.h> 38129203Scognet#include <string.h> 39129203Scognet#include <stdio.h> 40129203Scognet#include <time.h> 41129203Scognet#include "milieu.h" 42129203Scognet#include "softfloat.h" 43129203Scognet 44129203Scognetenum { 45129203Scognet minIterations = 1000 46129203Scognet}; 47129203Scognet 48129203Scognetstatic void fail( const char *message, ... ) 49129203Scognet{ 50129203Scognet va_list varArgs; 51129203Scognet 52129203Scognet fputs( "timesoftfloat: ", stderr ); 53129203Scognet va_start( varArgs, message ); 54129203Scognet vfprintf( stderr, message, varArgs ); 55129203Scognet va_end( varArgs ); 56129203Scognet fputs( ".\n", stderr ); 57129203Scognet exit( EXIT_FAILURE ); 58129203Scognet 59129203Scognet} 60129203Scognet 61129203Scognetstatic char *functionName; 62129203Scognetstatic char *roundingPrecisionName, *roundingModeName, *tininessModeName; 63129203Scognet 64129203Scognetstatic void reportTime( int32 count, long clocks ) 65129203Scognet{ 66129203Scognet 67129203Scognet printf( 68129203Scognet "%8.1f kops/s: %s", 69129203Scognet ( count / ( ( (float) clocks ) / CLOCKS_PER_SEC ) ) / 1000, 70129203Scognet functionName 71129203Scognet ); 72129203Scognet if ( roundingModeName ) { 73129203Scognet if ( roundingPrecisionName ) { 74129203Scognet fputs( ", precision ", stdout ); 75129203Scognet fputs( roundingPrecisionName, stdout ); 76129203Scognet } 77129203Scognet fputs( ", rounding ", stdout ); 78129203Scognet fputs( roundingModeName, stdout ); 79129203Scognet if ( tininessModeName ) { 80129203Scognet fputs( ", tininess ", stdout ); 81129203Scognet fputs( tininessModeName, stdout ); 82129203Scognet fputs( " rounding", stdout ); 83129203Scognet } 84129203Scognet } 85129203Scognet fputc( '\n', stdout ); 86129203Scognet 87129203Scognet} 88129203Scognet 89129203Scognetenum { 90129203Scognet numInputs_int32 = 32 91129203Scognet}; 92129203Scognet 93129203Scognetstatic const int32 inputs_int32[ numInputs_int32 ] = { 94129203Scognet 0xFFFFBB79, 0x405CF80F, 0x00000000, 0xFFFFFD04, 95129203Scognet 0xFFF20002, 0x0C8EF795, 0xF00011FF, 0x000006CA, 96129203Scognet 0x00009BFE, 0xFF4862E3, 0x9FFFEFFE, 0xFFFFFFB7, 97129203Scognet 0x0BFF7FFF, 0x0000F37A, 0x0011DFFE, 0x00000006, 98129203Scognet 0xFFF02006, 0xFFFFF7D1, 0x10200003, 0xDE8DF765, 99129203Scognet 0x00003E02, 0x000019E8, 0x0008FFFE, 0xFFFFFB5C, 100129203Scognet 0xFFDF7FFE, 0x07C42FBF, 0x0FFFE3FF, 0x040B9F13, 101129203Scognet 0xBFFFFFF8, 0x0001BF56, 0x000017F6, 0x000A908A 102129203Scognet}; 103129203Scognet 104129203Scognetstatic void time_a_int32_z_float32( float32 function( int32 ) ) 105129203Scognet{ 106129203Scognet clock_t startClock, endClock; 107129203Scognet int32 count, i; 108129203Scognet int8 inputNum; 109129203Scognet 110129203Scognet count = 0; 111129203Scognet inputNum = 0; 112129203Scognet startClock = clock(); 113129203Scognet do { 114129203Scognet for ( i = minIterations; i; --i ) { 115129203Scognet function( inputs_int32[ inputNum ] ); 116129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_int32 - 1 ); 117129203Scognet } 118129203Scognet count += minIterations; 119129203Scognet } while ( clock() - startClock < CLOCKS_PER_SEC ); 120129203Scognet inputNum = 0; 121129203Scognet startClock = clock(); 122129203Scognet for ( i = count; i; --i ) { 123129203Scognet function( inputs_int32[ inputNum ] ); 124129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_int32 - 1 ); 125129203Scognet } 126129203Scognet endClock = clock(); 127129203Scognet reportTime( count, endClock - startClock ); 128129203Scognet 129129203Scognet} 130129203Scognet 131129203Scognetstatic void time_a_int32_z_float64( float64 function( int32 ) ) 132129203Scognet{ 133129203Scognet clock_t startClock, endClock; 134129203Scognet int32 count, i; 135129203Scognet int8 inputNum; 136129203Scognet 137129203Scognet count = 0; 138129203Scognet inputNum = 0; 139129203Scognet startClock = clock(); 140129203Scognet do { 141129203Scognet for ( i = minIterations; i; --i ) { 142129203Scognet function( inputs_int32[ inputNum ] ); 143129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_int32 - 1 ); 144129203Scognet } 145129203Scognet count += minIterations; 146129203Scognet } while ( clock() - startClock < CLOCKS_PER_SEC ); 147129203Scognet inputNum = 0; 148129203Scognet startClock = clock(); 149129203Scognet for ( i = count; i; --i ) { 150129203Scognet function( inputs_int32[ inputNum ] ); 151129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_int32 - 1 ); 152129203Scognet } 153129203Scognet endClock = clock(); 154129203Scognet reportTime( count, endClock - startClock ); 155129203Scognet 156129203Scognet} 157129203Scognet 158129203Scognet#ifdef FLOATX80 159129203Scognet 160129203Scognetstatic void time_a_int32_z_floatx80( floatx80 function( int32 ) ) 161129203Scognet{ 162129203Scognet clock_t startClock, endClock; 163129203Scognet int32 count, i; 164129203Scognet int8 inputNum; 165129203Scognet 166129203Scognet count = 0; 167129203Scognet inputNum = 0; 168129203Scognet startClock = clock(); 169129203Scognet do { 170129203Scognet for ( i = minIterations; i; --i ) { 171129203Scognet function( inputs_int32[ inputNum ] ); 172129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_int32 - 1 ); 173129203Scognet } 174129203Scognet count += minIterations; 175129203Scognet } while ( clock() - startClock < CLOCKS_PER_SEC ); 176129203Scognet inputNum = 0; 177129203Scognet startClock = clock(); 178129203Scognet for ( i = count; i; --i ) { 179129203Scognet function( inputs_int32[ inputNum ] ); 180129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_int32 - 1 ); 181129203Scognet } 182129203Scognet endClock = clock(); 183129203Scognet reportTime( count, endClock - startClock ); 184129203Scognet 185129203Scognet} 186129203Scognet 187129203Scognet#endif 188129203Scognet 189129203Scognet#ifdef FLOAT128 190129203Scognet 191129203Scognetstatic void time_a_int32_z_float128( float128 function( int32 ) ) 192129203Scognet{ 193129203Scognet clock_t startClock, endClock; 194129203Scognet int32 count, i; 195129203Scognet int8 inputNum; 196129203Scognet 197129203Scognet count = 0; 198129203Scognet inputNum = 0; 199129203Scognet startClock = clock(); 200129203Scognet do { 201129203Scognet for ( i = minIterations; i; --i ) { 202129203Scognet function( inputs_int32[ inputNum ] ); 203129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_int32 - 1 ); 204129203Scognet } 205129203Scognet count += minIterations; 206129203Scognet } while ( clock() - startClock < CLOCKS_PER_SEC ); 207129203Scognet inputNum = 0; 208129203Scognet startClock = clock(); 209129203Scognet for ( i = count; i; --i ) { 210129203Scognet function( inputs_int32[ inputNum ] ); 211129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_int32 - 1 ); 212129203Scognet } 213129203Scognet endClock = clock(); 214129203Scognet reportTime( count, endClock - startClock ); 215129203Scognet 216129203Scognet} 217129203Scognet 218129203Scognet#endif 219129203Scognet 220129203Scognetenum { 221129203Scognet numInputs_int64 = 32 222129203Scognet}; 223129203Scognet 224129203Scognetstatic const int64 inputs_int64[ numInputs_int64 ] = { 225129203Scognet LIT64( 0xFBFFC3FFFFFFFFFF ), 226129203Scognet LIT64( 0x0000000003C589BC ), 227129203Scognet LIT64( 0x00000000400013FE ), 228129203Scognet LIT64( 0x0000000000186171 ), 229129203Scognet LIT64( 0xFFFFFFFFFFFEFBFA ), 230129203Scognet LIT64( 0xFFFFFD79E6DFFC73 ), 231129203Scognet LIT64( 0x0000000010001DFF ), 232129203Scognet LIT64( 0xDD1A0F0C78513710 ), 233129203Scognet LIT64( 0xFFFF83FFFFFEFFFE ), 234129203Scognet LIT64( 0x00756EBD1AD0C1C7 ), 235129203Scognet LIT64( 0x0003FDFFFFFFFFBE ), 236129203Scognet LIT64( 0x0007D0FB2C2CA951 ), 237129203Scognet LIT64( 0x0007FC0007FFFFFE ), 238129203Scognet LIT64( 0x0000001F942B18BB ), 239129203Scognet LIT64( 0x0000080101FFFFFE ), 240129203Scognet LIT64( 0xFFFFFFFFFFFF0978 ), 241129203Scognet LIT64( 0x000000000008BFFF ), 242129203Scognet LIT64( 0x0000000006F5AF08 ), 243129203Scognet LIT64( 0xFFDEFF7FFFFFFFFE ), 244129203Scognet LIT64( 0x0000000000000003 ), 245129203Scognet LIT64( 0x3FFFFFFFFF80007D ), 246129203Scognet LIT64( 0x0000000000000078 ), 247129203Scognet LIT64( 0xFFF80000007FDFFD ), 248129203Scognet LIT64( 0x1BBC775B78016AB0 ), 249129203Scognet LIT64( 0xFFF9001FFFFFFFFE ), 250129203Scognet LIT64( 0xFFFD4767AB98E43F ), 251129203Scognet LIT64( 0xFFFFFEFFFE00001E ), 252129203Scognet LIT64( 0xFFFFFFFFFFF04EFD ), 253129203Scognet LIT64( 0x07FFFFFFFFFFF7FF ), 254129203Scognet LIT64( 0xFFFC9EAA38F89050 ), 255129203Scognet LIT64( 0x00000020FBFFFFFE ), 256129203Scognet LIT64( 0x0000099AE6455357 ) 257129203Scognet}; 258129203Scognet 259129203Scognetstatic void time_a_int64_z_float32( float32 function( int64 ) ) 260129203Scognet{ 261129203Scognet clock_t startClock, endClock; 262129203Scognet int32 count, i; 263129203Scognet int8 inputNum; 264129203Scognet 265129203Scognet count = 0; 266129203Scognet inputNum = 0; 267129203Scognet startClock = clock(); 268129203Scognet do { 269129203Scognet for ( i = minIterations; i; --i ) { 270129203Scognet function( inputs_int64[ inputNum ] ); 271129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_int64 - 1 ); 272129203Scognet } 273129203Scognet count += minIterations; 274129203Scognet } while ( clock() - startClock < CLOCKS_PER_SEC ); 275129203Scognet inputNum = 0; 276129203Scognet startClock = clock(); 277129203Scognet for ( i = count; i; --i ) { 278129203Scognet function( inputs_int64[ inputNum ] ); 279129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_int64 - 1 ); 280129203Scognet } 281129203Scognet endClock = clock(); 282129203Scognet reportTime( count, endClock - startClock ); 283129203Scognet 284129203Scognet} 285129203Scognet 286129203Scognetstatic void time_a_int64_z_float64( float64 function( int64 ) ) 287129203Scognet{ 288129203Scognet clock_t startClock, endClock; 289129203Scognet int32 count, i; 290129203Scognet int8 inputNum; 291129203Scognet 292129203Scognet count = 0; 293129203Scognet inputNum = 0; 294129203Scognet startClock = clock(); 295129203Scognet do { 296129203Scognet for ( i = minIterations; i; --i ) { 297129203Scognet function( inputs_int64[ inputNum ] ); 298129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_int64 - 1 ); 299129203Scognet } 300129203Scognet count += minIterations; 301129203Scognet } while ( clock() - startClock < CLOCKS_PER_SEC ); 302129203Scognet inputNum = 0; 303129203Scognet startClock = clock(); 304129203Scognet for ( i = count; i; --i ) { 305129203Scognet function( inputs_int64[ inputNum ] ); 306129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_int64 - 1 ); 307129203Scognet } 308129203Scognet endClock = clock(); 309129203Scognet reportTime( count, endClock - startClock ); 310129203Scognet 311129203Scognet} 312129203Scognet 313129203Scognet#ifdef FLOATX80 314129203Scognet 315129203Scognetstatic void time_a_int64_z_floatx80( floatx80 function( int64 ) ) 316129203Scognet{ 317129203Scognet clock_t startClock, endClock; 318129203Scognet int32 count, i; 319129203Scognet int8 inputNum; 320129203Scognet 321129203Scognet count = 0; 322129203Scognet inputNum = 0; 323129203Scognet startClock = clock(); 324129203Scognet do { 325129203Scognet for ( i = minIterations; i; --i ) { 326129203Scognet function( inputs_int64[ inputNum ] ); 327129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_int64 - 1 ); 328129203Scognet } 329129203Scognet count += minIterations; 330129203Scognet } while ( clock() - startClock < CLOCKS_PER_SEC ); 331129203Scognet inputNum = 0; 332129203Scognet startClock = clock(); 333129203Scognet for ( i = count; i; --i ) { 334129203Scognet function( inputs_int64[ inputNum ] ); 335129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_int64 - 1 ); 336129203Scognet } 337129203Scognet endClock = clock(); 338129203Scognet reportTime( count, endClock - startClock ); 339129203Scognet 340129203Scognet} 341129203Scognet 342129203Scognet#endif 343129203Scognet 344129203Scognet#ifdef FLOAT128 345129203Scognet 346129203Scognetstatic void time_a_int64_z_float128( float128 function( int64 ) ) 347129203Scognet{ 348129203Scognet clock_t startClock, endClock; 349129203Scognet int32 count, i; 350129203Scognet int8 inputNum; 351129203Scognet 352129203Scognet count = 0; 353129203Scognet inputNum = 0; 354129203Scognet startClock = clock(); 355129203Scognet do { 356129203Scognet for ( i = minIterations; i; --i ) { 357129203Scognet function( inputs_int64[ inputNum ] ); 358129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_int64 - 1 ); 359129203Scognet } 360129203Scognet count += minIterations; 361129203Scognet } while ( clock() - startClock < CLOCKS_PER_SEC ); 362129203Scognet inputNum = 0; 363129203Scognet startClock = clock(); 364129203Scognet for ( i = count; i; --i ) { 365129203Scognet function( inputs_int64[ inputNum ] ); 366129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_int64 - 1 ); 367129203Scognet } 368129203Scognet endClock = clock(); 369129203Scognet reportTime( count, endClock - startClock ); 370129203Scognet 371129203Scognet} 372129203Scognet 373129203Scognet#endif 374129203Scognet 375129203Scognetenum { 376129203Scognet numInputs_float32 = 32 377129203Scognet}; 378129203Scognet 379129203Scognetstatic const float32 inputs_float32[ numInputs_float32 ] = { 380129203Scognet 0x4EFA0000, 0xC1D0B328, 0x80000000, 0x3E69A31E, 381129203Scognet 0xAF803EFF, 0x3F800000, 0x17BF8000, 0xE74A301A, 382129203Scognet 0x4E010003, 0x7EE3C75D, 0xBD803FE0, 0xBFFEFF00, 383129203Scognet 0x7981F800, 0x431FFFFC, 0xC100C000, 0x3D87EFFF, 384129203Scognet 0x4103FEFE, 0xBC000007, 0xBF01F7FF, 0x4E6C6B5C, 385129203Scognet 0xC187FFFE, 0xC58B9F13, 0x4F88007F, 0xDF004007, 386129203Scognet 0xB7FFD7FE, 0x7E8001FB, 0x46EFFBFF, 0x31C10000, 387129203Scognet 0xDB428661, 0x33F89B1F, 0xA3BFEFFF, 0x537BFFBE 388129203Scognet}; 389129203Scognet 390129203Scognetstatic void time_a_float32_z_int32( int32 function( float32 ) ) 391129203Scognet{ 392129203Scognet clock_t startClock, endClock; 393129203Scognet int32 count, i; 394129203Scognet int8 inputNum; 395129203Scognet 396129203Scognet count = 0; 397129203Scognet inputNum = 0; 398129203Scognet startClock = clock(); 399129203Scognet do { 400129203Scognet for ( i = minIterations; i; --i ) { 401129203Scognet function( inputs_float32[ inputNum ] ); 402129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_float32 - 1 ); 403129203Scognet } 404129203Scognet count += minIterations; 405129203Scognet } while ( clock() - startClock < CLOCKS_PER_SEC ); 406129203Scognet inputNum = 0; 407129203Scognet startClock = clock(); 408129203Scognet for ( i = count; i; --i ) { 409129203Scognet function( inputs_float32[ inputNum ] ); 410129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_float32 - 1 ); 411129203Scognet } 412129203Scognet endClock = clock(); 413129203Scognet reportTime( count, endClock - startClock ); 414129203Scognet 415129203Scognet} 416129203Scognet 417129203Scognetstatic void time_a_float32_z_int64( int64 function( float32 ) ) 418129203Scognet{ 419129203Scognet clock_t startClock, endClock; 420129203Scognet int32 count, i; 421129203Scognet int8 inputNum; 422129203Scognet 423129203Scognet count = 0; 424129203Scognet inputNum = 0; 425129203Scognet startClock = clock(); 426129203Scognet do { 427129203Scognet for ( i = minIterations; i; --i ) { 428129203Scognet function( inputs_float32[ inputNum ] ); 429129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_float32 - 1 ); 430129203Scognet } 431129203Scognet count += minIterations; 432129203Scognet } while ( clock() - startClock < CLOCKS_PER_SEC ); 433129203Scognet inputNum = 0; 434129203Scognet startClock = clock(); 435129203Scognet for ( i = count; i; --i ) { 436129203Scognet function( inputs_float32[ inputNum ] ); 437129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_float32 - 1 ); 438129203Scognet } 439129203Scognet endClock = clock(); 440129203Scognet reportTime( count, endClock - startClock ); 441129203Scognet 442129203Scognet} 443129203Scognet 444129203Scognetstatic void time_a_float32_z_float64( float64 function( float32 ) ) 445129203Scognet{ 446129203Scognet clock_t startClock, endClock; 447129203Scognet int32 count, i; 448129203Scognet int8 inputNum; 449129203Scognet 450129203Scognet count = 0; 451129203Scognet inputNum = 0; 452129203Scognet startClock = clock(); 453129203Scognet do { 454129203Scognet for ( i = minIterations; i; --i ) { 455129203Scognet function( inputs_float32[ inputNum ] ); 456129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_float32 - 1 ); 457129203Scognet } 458129203Scognet count += minIterations; 459129203Scognet } while ( clock() - startClock < CLOCKS_PER_SEC ); 460129203Scognet inputNum = 0; 461129203Scognet startClock = clock(); 462129203Scognet for ( i = count; i; --i ) { 463129203Scognet function( inputs_float32[ inputNum ] ); 464129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_float32 - 1 ); 465129203Scognet } 466129203Scognet endClock = clock(); 467129203Scognet reportTime( count, endClock - startClock ); 468129203Scognet 469129203Scognet} 470129203Scognet 471129203Scognet#ifdef FLOATX80 472129203Scognet 473129203Scognetstatic void time_a_float32_z_floatx80( floatx80 function( float32 ) ) 474129203Scognet{ 475129203Scognet clock_t startClock, endClock; 476129203Scognet int32 count, i; 477129203Scognet int8 inputNum; 478129203Scognet 479129203Scognet count = 0; 480129203Scognet inputNum = 0; 481129203Scognet startClock = clock(); 482129203Scognet do { 483129203Scognet for ( i = minIterations; i; --i ) { 484129203Scognet function( inputs_float32[ inputNum ] ); 485129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_float32 - 1 ); 486129203Scognet } 487129203Scognet count += minIterations; 488129203Scognet } while ( clock() - startClock < CLOCKS_PER_SEC ); 489129203Scognet inputNum = 0; 490129203Scognet startClock = clock(); 491129203Scognet for ( i = count; i; --i ) { 492129203Scognet function( inputs_float32[ inputNum ] ); 493129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_float32 - 1 ); 494129203Scognet } 495129203Scognet endClock = clock(); 496129203Scognet reportTime( count, endClock - startClock ); 497129203Scognet 498129203Scognet} 499129203Scognet 500129203Scognet#endif 501129203Scognet 502129203Scognet#ifdef FLOAT128 503129203Scognet 504129203Scognetstatic void time_a_float32_z_float128( float128 function( float32 ) ) 505129203Scognet{ 506129203Scognet clock_t startClock, endClock; 507129203Scognet int32 count, i; 508129203Scognet int8 inputNum; 509129203Scognet 510129203Scognet count = 0; 511129203Scognet inputNum = 0; 512129203Scognet startClock = clock(); 513129203Scognet do { 514129203Scognet for ( i = minIterations; i; --i ) { 515129203Scognet function( inputs_float32[ inputNum ] ); 516129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_float32 - 1 ); 517129203Scognet } 518129203Scognet count += minIterations; 519129203Scognet } while ( clock() - startClock < CLOCKS_PER_SEC ); 520129203Scognet inputNum = 0; 521129203Scognet startClock = clock(); 522129203Scognet for ( i = count; i; --i ) { 523129203Scognet function( inputs_float32[ inputNum ] ); 524129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_float32 - 1 ); 525129203Scognet } 526129203Scognet endClock = clock(); 527129203Scognet reportTime( count, endClock - startClock ); 528129203Scognet 529129203Scognet} 530129203Scognet 531129203Scognet#endif 532129203Scognet 533129203Scognetstatic void time_az_float32( float32 function( float32 ) ) 534129203Scognet{ 535129203Scognet clock_t startClock, endClock; 536129203Scognet int32 count, i; 537129203Scognet int8 inputNum; 538129203Scognet 539129203Scognet count = 0; 540129203Scognet inputNum = 0; 541129203Scognet startClock = clock(); 542129203Scognet do { 543129203Scognet for ( i = minIterations; i; --i ) { 544129203Scognet function( inputs_float32[ inputNum ] ); 545129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_float32 - 1 ); 546129203Scognet } 547129203Scognet count += minIterations; 548129203Scognet } while ( clock() - startClock < CLOCKS_PER_SEC ); 549129203Scognet inputNum = 0; 550129203Scognet startClock = clock(); 551129203Scognet for ( i = count; i; --i ) { 552129203Scognet function( inputs_float32[ inputNum ] ); 553129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_float32 - 1 ); 554129203Scognet } 555129203Scognet endClock = clock(); 556129203Scognet reportTime( count, endClock - startClock ); 557129203Scognet 558129203Scognet} 559129203Scognet 560129203Scognetstatic void time_ab_float32_z_flag( flag function( float32, float32 ) ) 561129203Scognet{ 562129203Scognet clock_t startClock, endClock; 563129203Scognet int32 count, i; 564129203Scognet int8 inputNumA, inputNumB; 565129203Scognet 566129203Scognet count = 0; 567129203Scognet inputNumA = 0; 568129203Scognet inputNumB = 0; 569129203Scognet startClock = clock(); 570129203Scognet do { 571129203Scognet for ( i = minIterations; i; --i ) { 572129203Scognet function( 573129203Scognet inputs_float32[ inputNumA ], inputs_float32[ inputNumB ] ); 574129203Scognet inputNumA = ( inputNumA + 1 ) & ( numInputs_float32 - 1 ); 575129203Scognet if ( inputNumA == 0 ) ++inputNumB; 576129203Scognet inputNumB = ( inputNumB + 1 ) & ( numInputs_float32 - 1 ); 577129203Scognet } 578129203Scognet count += minIterations; 579129203Scognet } while ( clock() - startClock < CLOCKS_PER_SEC ); 580129203Scognet inputNumA = 0; 581129203Scognet inputNumB = 0; 582129203Scognet startClock = clock(); 583129203Scognet for ( i = count; i; --i ) { 584129203Scognet function( 585129203Scognet inputs_float32[ inputNumA ], inputs_float32[ inputNumB ] ); 586129203Scognet inputNumA = ( inputNumA + 1 ) & ( numInputs_float32 - 1 ); 587129203Scognet if ( inputNumA == 0 ) ++inputNumB; 588129203Scognet inputNumB = ( inputNumB + 1 ) & ( numInputs_float32 - 1 ); 589129203Scognet } 590129203Scognet endClock = clock(); 591129203Scognet reportTime( count, endClock - startClock ); 592129203Scognet 593129203Scognet} 594129203Scognet 595129203Scognetstatic void time_abz_float32( float32 function( float32, float32 ) ) 596129203Scognet{ 597129203Scognet clock_t startClock, endClock; 598129203Scognet int32 count, i; 599129203Scognet int8 inputNumA, inputNumB; 600129203Scognet 601129203Scognet count = 0; 602129203Scognet inputNumA = 0; 603129203Scognet inputNumB = 0; 604129203Scognet startClock = clock(); 605129203Scognet do { 606129203Scognet for ( i = minIterations; i; --i ) { 607129203Scognet function( 608129203Scognet inputs_float32[ inputNumA ], inputs_float32[ inputNumB ] ); 609129203Scognet inputNumA = ( inputNumA + 1 ) & ( numInputs_float32 - 1 ); 610129203Scognet if ( inputNumA == 0 ) ++inputNumB; 611129203Scognet inputNumB = ( inputNumB + 1 ) & ( numInputs_float32 - 1 ); 612129203Scognet } 613129203Scognet count += minIterations; 614129203Scognet } while ( clock() - startClock < CLOCKS_PER_SEC ); 615129203Scognet inputNumA = 0; 616129203Scognet inputNumB = 0; 617129203Scognet startClock = clock(); 618129203Scognet for ( i = count; i; --i ) { 619129203Scognet function( 620129203Scognet inputs_float32[ inputNumA ], inputs_float32[ inputNumB ] ); 621129203Scognet inputNumA = ( inputNumA + 1 ) & ( numInputs_float32 - 1 ); 622129203Scognet if ( inputNumA == 0 ) ++inputNumB; 623129203Scognet inputNumB = ( inputNumB + 1 ) & ( numInputs_float32 - 1 ); 624129203Scognet } 625129203Scognet endClock = clock(); 626129203Scognet reportTime( count, endClock - startClock ); 627129203Scognet 628129203Scognet} 629129203Scognet 630129203Scognetstatic const float32 inputs_float32_pos[ numInputs_float32 ] = { 631129203Scognet 0x4EFA0000, 0x41D0B328, 0x00000000, 0x3E69A31E, 632129203Scognet 0x2F803EFF, 0x3F800000, 0x17BF8000, 0x674A301A, 633129203Scognet 0x4E010003, 0x7EE3C75D, 0x3D803FE0, 0x3FFEFF00, 634129203Scognet 0x7981F800, 0x431FFFFC, 0x4100C000, 0x3D87EFFF, 635129203Scognet 0x4103FEFE, 0x3C000007, 0x3F01F7FF, 0x4E6C6B5C, 636129203Scognet 0x4187FFFE, 0x458B9F13, 0x4F88007F, 0x5F004007, 637129203Scognet 0x37FFD7FE, 0x7E8001FB, 0x46EFFBFF, 0x31C10000, 638129203Scognet 0x5B428661, 0x33F89B1F, 0x23BFEFFF, 0x537BFFBE 639129203Scognet}; 640129203Scognet 641129203Scognetstatic void time_az_float32_pos( float32 function( float32 ) ) 642129203Scognet{ 643129203Scognet clock_t startClock, endClock; 644129203Scognet int32 count, i; 645129203Scognet int8 inputNum; 646129203Scognet 647129203Scognet count = 0; 648129203Scognet inputNum = 0; 649129203Scognet startClock = clock(); 650129203Scognet do { 651129203Scognet for ( i = minIterations; i; --i ) { 652129203Scognet function( inputs_float32_pos[ inputNum ] ); 653129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_float32 - 1 ); 654129203Scognet } 655129203Scognet count += minIterations; 656129203Scognet } while ( clock() - startClock < CLOCKS_PER_SEC ); 657129203Scognet inputNum = 0; 658129203Scognet startClock = clock(); 659129203Scognet for ( i = count; i; --i ) { 660129203Scognet function( inputs_float32_pos[ inputNum ] ); 661129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_float32 - 1 ); 662129203Scognet } 663129203Scognet endClock = clock(); 664129203Scognet reportTime( count, endClock - startClock ); 665129203Scognet 666129203Scognet} 667129203Scognet 668129203Scognetenum { 669129203Scognet numInputs_float64 = 32 670129203Scognet}; 671129203Scognet 672129203Scognetstatic const float64 inputs_float64[ numInputs_float64 ] = { 673129203Scognet LIT64( 0x422FFFC008000000 ), 674129203Scognet LIT64( 0xB7E0000480000000 ), 675129203Scognet LIT64( 0xF3FD2546120B7935 ), 676129203Scognet LIT64( 0x3FF0000000000000 ), 677129203Scognet LIT64( 0xCE07F766F09588D6 ), 678129203Scognet LIT64( 0x8000000000000000 ), 679129203Scognet LIT64( 0x3FCE000400000000 ), 680129203Scognet LIT64( 0x8313B60F0032BED8 ), 681129203Scognet LIT64( 0xC1EFFFFFC0002000 ), 682129203Scognet LIT64( 0x3FB3C75D224F2B0F ), 683129203Scognet LIT64( 0x7FD00000004000FF ), 684129203Scognet LIT64( 0xA12FFF8000001FFF ), 685129203Scognet LIT64( 0x3EE0000000FE0000 ), 686129203Scognet LIT64( 0x0010000080000004 ), 687129203Scognet LIT64( 0x41CFFFFE00000020 ), 688129203Scognet LIT64( 0x40303FFFFFFFFFFD ), 689129203Scognet LIT64( 0x3FD000003FEFFFFF ), 690129203Scognet LIT64( 0xBFD0000010000000 ), 691129203Scognet LIT64( 0xB7FC6B5C16CA55CF ), 692129203Scognet LIT64( 0x413EEB940B9D1301 ), 693129203Scognet LIT64( 0xC7E00200001FFFFF ), 694129203Scognet LIT64( 0x47F00021FFFFFFFE ), 695129203Scognet LIT64( 0xBFFFFFFFF80000FF ), 696129203Scognet LIT64( 0xC07FFFFFE00FFFFF ), 697129203Scognet LIT64( 0x001497A63740C5E8 ), 698129203Scognet LIT64( 0xC4BFFFE0001FFFFF ), 699129203Scognet LIT64( 0x96FFDFFEFFFFFFFF ), 700129203Scognet LIT64( 0x403FC000000001FE ), 701129203Scognet LIT64( 0xFFD00000000001F6 ), 702129203Scognet LIT64( 0x0640400002000000 ), 703129203Scognet LIT64( 0x479CEE1E4F789FE0 ), 704129203Scognet LIT64( 0xC237FFFFFFFFFDFE ) 705129203Scognet}; 706129203Scognet 707129203Scognetstatic void time_a_float64_z_int32( int32 function( float64 ) ) 708129203Scognet{ 709129203Scognet clock_t startClock, endClock; 710129203Scognet int32 count, i; 711129203Scognet int8 inputNum; 712129203Scognet 713129203Scognet count = 0; 714129203Scognet inputNum = 0; 715129203Scognet startClock = clock(); 716129203Scognet do { 717129203Scognet for ( i = minIterations; i; --i ) { 718129203Scognet function( inputs_float64[ inputNum ] ); 719129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_float64 - 1 ); 720129203Scognet } 721129203Scognet count += minIterations; 722129203Scognet } while ( clock() - startClock < CLOCKS_PER_SEC ); 723129203Scognet inputNum = 0; 724129203Scognet startClock = clock(); 725129203Scognet for ( i = count; i; --i ) { 726129203Scognet function( inputs_float64[ inputNum ] ); 727129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_float64 - 1 ); 728129203Scognet } 729129203Scognet endClock = clock(); 730129203Scognet reportTime( count, endClock - startClock ); 731129203Scognet 732129203Scognet} 733129203Scognet 734129203Scognetstatic void time_a_float64_z_int64( int64 function( float64 ) ) 735129203Scognet{ 736129203Scognet clock_t startClock, endClock; 737129203Scognet int32 count, i; 738129203Scognet int8 inputNum; 739129203Scognet 740129203Scognet count = 0; 741129203Scognet inputNum = 0; 742129203Scognet startClock = clock(); 743129203Scognet do { 744129203Scognet for ( i = minIterations; i; --i ) { 745129203Scognet function( inputs_float64[ inputNum ] ); 746129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_float64 - 1 ); 747129203Scognet } 748129203Scognet count += minIterations; 749129203Scognet } while ( clock() - startClock < CLOCKS_PER_SEC ); 750129203Scognet inputNum = 0; 751129203Scognet startClock = clock(); 752129203Scognet for ( i = count; i; --i ) { 753129203Scognet function( inputs_float64[ inputNum ] ); 754129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_float64 - 1 ); 755129203Scognet } 756129203Scognet endClock = clock(); 757129203Scognet reportTime( count, endClock - startClock ); 758129203Scognet 759129203Scognet} 760129203Scognet 761129203Scognetstatic void time_a_float64_z_float32( float32 function( float64 ) ) 762129203Scognet{ 763129203Scognet clock_t startClock, endClock; 764129203Scognet int32 count, i; 765129203Scognet int8 inputNum; 766129203Scognet 767129203Scognet count = 0; 768129203Scognet inputNum = 0; 769129203Scognet startClock = clock(); 770129203Scognet do { 771129203Scognet for ( i = minIterations; i; --i ) { 772129203Scognet function( inputs_float64[ inputNum ] ); 773129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_float64 - 1 ); 774129203Scognet } 775129203Scognet count += minIterations; 776129203Scognet } while ( clock() - startClock < CLOCKS_PER_SEC ); 777129203Scognet inputNum = 0; 778129203Scognet startClock = clock(); 779129203Scognet for ( i = count; i; --i ) { 780129203Scognet function( inputs_float64[ inputNum ] ); 781129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_float64 - 1 ); 782129203Scognet } 783129203Scognet endClock = clock(); 784129203Scognet reportTime( count, endClock - startClock ); 785129203Scognet 786129203Scognet} 787129203Scognet 788129203Scognet#ifdef FLOATX80 789129203Scognet 790129203Scognetstatic void time_a_float64_z_floatx80( floatx80 function( float64 ) ) 791129203Scognet{ 792129203Scognet clock_t startClock, endClock; 793129203Scognet int32 count, i; 794129203Scognet int8 inputNum; 795129203Scognet 796129203Scognet count = 0; 797129203Scognet inputNum = 0; 798129203Scognet startClock = clock(); 799129203Scognet do { 800129203Scognet for ( i = minIterations; i; --i ) { 801129203Scognet function( inputs_float64[ inputNum ] ); 802129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_float64 - 1 ); 803129203Scognet } 804129203Scognet count += minIterations; 805129203Scognet } while ( clock() - startClock < CLOCKS_PER_SEC ); 806129203Scognet inputNum = 0; 807129203Scognet startClock = clock(); 808129203Scognet for ( i = count; i; --i ) { 809129203Scognet function( inputs_float64[ inputNum ] ); 810129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_float64 - 1 ); 811129203Scognet } 812129203Scognet endClock = clock(); 813129203Scognet reportTime( count, endClock - startClock ); 814129203Scognet 815129203Scognet} 816129203Scognet 817129203Scognet#endif 818129203Scognet 819129203Scognet#ifdef FLOAT128 820129203Scognet 821129203Scognetstatic void time_a_float64_z_float128( float128 function( float64 ) ) 822129203Scognet{ 823129203Scognet clock_t startClock, endClock; 824129203Scognet int32 count, i; 825129203Scognet int8 inputNum; 826129203Scognet 827129203Scognet count = 0; 828129203Scognet inputNum = 0; 829129203Scognet startClock = clock(); 830129203Scognet do { 831129203Scognet for ( i = minIterations; i; --i ) { 832129203Scognet function( inputs_float64[ inputNum ] ); 833129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_float64 - 1 ); 834129203Scognet } 835129203Scognet count += minIterations; 836129203Scognet } while ( clock() - startClock < CLOCKS_PER_SEC ); 837129203Scognet inputNum = 0; 838129203Scognet startClock = clock(); 839129203Scognet for ( i = count; i; --i ) { 840129203Scognet function( inputs_float64[ inputNum ] ); 841129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_float64 - 1 ); 842129203Scognet } 843129203Scognet endClock = clock(); 844129203Scognet reportTime( count, endClock - startClock ); 845129203Scognet 846129203Scognet} 847129203Scognet 848129203Scognet#endif 849129203Scognet 850129203Scognetstatic void time_az_float64( float64 function( float64 ) ) 851129203Scognet{ 852129203Scognet clock_t startClock, endClock; 853129203Scognet int32 count, i; 854129203Scognet int8 inputNum; 855129203Scognet 856129203Scognet count = 0; 857129203Scognet inputNum = 0; 858129203Scognet startClock = clock(); 859129203Scognet do { 860129203Scognet for ( i = minIterations; i; --i ) { 861129203Scognet function( inputs_float64[ inputNum ] ); 862129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_float64 - 1 ); 863129203Scognet } 864129203Scognet count += minIterations; 865129203Scognet } while ( clock() - startClock < CLOCKS_PER_SEC ); 866129203Scognet inputNum = 0; 867129203Scognet startClock = clock(); 868129203Scognet for ( i = count; i; --i ) { 869129203Scognet function( inputs_float64[ inputNum ] ); 870129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_float64 - 1 ); 871129203Scognet } 872129203Scognet endClock = clock(); 873129203Scognet reportTime( count, endClock - startClock ); 874129203Scognet 875129203Scognet} 876129203Scognet 877129203Scognetstatic void time_ab_float64_z_flag( flag function( float64, float64 ) ) 878129203Scognet{ 879129203Scognet clock_t startClock, endClock; 880129203Scognet int32 count, i; 881129203Scognet int8 inputNumA, inputNumB; 882129203Scognet 883129203Scognet count = 0; 884129203Scognet inputNumA = 0; 885129203Scognet inputNumB = 0; 886129203Scognet startClock = clock(); 887129203Scognet do { 888129203Scognet for ( i = minIterations; i; --i ) { 889129203Scognet function( 890129203Scognet inputs_float64[ inputNumA ], inputs_float64[ inputNumB ] ); 891129203Scognet inputNumA = ( inputNumA + 1 ) & ( numInputs_float64 - 1 ); 892129203Scognet if ( inputNumA == 0 ) ++inputNumB; 893129203Scognet inputNumB = ( inputNumB + 1 ) & ( numInputs_float64 - 1 ); 894129203Scognet } 895129203Scognet count += minIterations; 896129203Scognet } while ( clock() - startClock < CLOCKS_PER_SEC ); 897129203Scognet inputNumA = 0; 898129203Scognet inputNumB = 0; 899129203Scognet startClock = clock(); 900129203Scognet for ( i = count; i; --i ) { 901129203Scognet function( 902129203Scognet inputs_float64[ inputNumA ], inputs_float64[ inputNumB ] ); 903129203Scognet inputNumA = ( inputNumA + 1 ) & ( numInputs_float64 - 1 ); 904129203Scognet if ( inputNumA == 0 ) ++inputNumB; 905129203Scognet inputNumB = ( inputNumB + 1 ) & ( numInputs_float64 - 1 ); 906129203Scognet } 907129203Scognet endClock = clock(); 908129203Scognet reportTime( count, endClock - startClock ); 909129203Scognet 910129203Scognet} 911129203Scognet 912129203Scognetstatic void time_abz_float64( float64 function( float64, float64 ) ) 913129203Scognet{ 914129203Scognet clock_t startClock, endClock; 915129203Scognet int32 count, i; 916129203Scognet int8 inputNumA, inputNumB; 917129203Scognet 918129203Scognet count = 0; 919129203Scognet inputNumA = 0; 920129203Scognet inputNumB = 0; 921129203Scognet startClock = clock(); 922129203Scognet do { 923129203Scognet for ( i = minIterations; i; --i ) { 924129203Scognet function( 925129203Scognet inputs_float64[ inputNumA ], inputs_float64[ inputNumB ] ); 926129203Scognet inputNumA = ( inputNumA + 1 ) & ( numInputs_float64 - 1 ); 927129203Scognet if ( inputNumA == 0 ) ++inputNumB; 928129203Scognet inputNumB = ( inputNumB + 1 ) & ( numInputs_float64 - 1 ); 929129203Scognet } 930129203Scognet count += minIterations; 931129203Scognet } while ( clock() - startClock < CLOCKS_PER_SEC ); 932129203Scognet inputNumA = 0; 933129203Scognet inputNumB = 0; 934129203Scognet startClock = clock(); 935129203Scognet for ( i = count; i; --i ) { 936129203Scognet function( 937129203Scognet inputs_float64[ inputNumA ], inputs_float64[ inputNumB ] ); 938129203Scognet inputNumA = ( inputNumA + 1 ) & ( numInputs_float64 - 1 ); 939129203Scognet if ( inputNumA == 0 ) ++inputNumB; 940129203Scognet inputNumB = ( inputNumB + 1 ) & ( numInputs_float64 - 1 ); 941129203Scognet } 942129203Scognet endClock = clock(); 943129203Scognet reportTime( count, endClock - startClock ); 944129203Scognet 945129203Scognet} 946129203Scognet 947129203Scognetstatic const float64 inputs_float64_pos[ numInputs_float64 ] = { 948129203Scognet LIT64( 0x422FFFC008000000 ), 949129203Scognet LIT64( 0x37E0000480000000 ), 950129203Scognet LIT64( 0x73FD2546120B7935 ), 951129203Scognet LIT64( 0x3FF0000000000000 ), 952129203Scognet LIT64( 0x4E07F766F09588D6 ), 953129203Scognet LIT64( 0x0000000000000000 ), 954129203Scognet LIT64( 0x3FCE000400000000 ), 955129203Scognet LIT64( 0x0313B60F0032BED8 ), 956129203Scognet LIT64( 0x41EFFFFFC0002000 ), 957129203Scognet LIT64( 0x3FB3C75D224F2B0F ), 958129203Scognet LIT64( 0x7FD00000004000FF ), 959129203Scognet LIT64( 0x212FFF8000001FFF ), 960129203Scognet LIT64( 0x3EE0000000FE0000 ), 961129203Scognet LIT64( 0x0010000080000004 ), 962129203Scognet LIT64( 0x41CFFFFE00000020 ), 963129203Scognet LIT64( 0x40303FFFFFFFFFFD ), 964129203Scognet LIT64( 0x3FD000003FEFFFFF ), 965129203Scognet LIT64( 0x3FD0000010000000 ), 966129203Scognet LIT64( 0x37FC6B5C16CA55CF ), 967129203Scognet LIT64( 0x413EEB940B9D1301 ), 968129203Scognet LIT64( 0x47E00200001FFFFF ), 969129203Scognet LIT64( 0x47F00021FFFFFFFE ), 970129203Scognet LIT64( 0x3FFFFFFFF80000FF ), 971129203Scognet LIT64( 0x407FFFFFE00FFFFF ), 972129203Scognet LIT64( 0x001497A63740C5E8 ), 973129203Scognet LIT64( 0x44BFFFE0001FFFFF ), 974129203Scognet LIT64( 0x16FFDFFEFFFFFFFF ), 975129203Scognet LIT64( 0x403FC000000001FE ), 976129203Scognet LIT64( 0x7FD00000000001F6 ), 977129203Scognet LIT64( 0x0640400002000000 ), 978129203Scognet LIT64( 0x479CEE1E4F789FE0 ), 979129203Scognet LIT64( 0x4237FFFFFFFFFDFE ) 980129203Scognet}; 981129203Scognet 982129203Scognetstatic void time_az_float64_pos( float64 function( float64 ) ) 983129203Scognet{ 984129203Scognet clock_t startClock, endClock; 985129203Scognet int32 count, i; 986129203Scognet int8 inputNum; 987129203Scognet 988129203Scognet count = 0; 989129203Scognet inputNum = 0; 990129203Scognet startClock = clock(); 991129203Scognet do { 992129203Scognet for ( i = minIterations; i; --i ) { 993129203Scognet function( inputs_float64_pos[ inputNum ] ); 994129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_float64 - 1 ); 995129203Scognet } 996129203Scognet count += minIterations; 997129203Scognet } while ( clock() - startClock < CLOCKS_PER_SEC ); 998129203Scognet inputNum = 0; 999129203Scognet startClock = clock(); 1000129203Scognet for ( i = count; i; --i ) { 1001129203Scognet function( inputs_float64_pos[ inputNum ] ); 1002129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_float64 - 1 ); 1003129203Scognet } 1004129203Scognet endClock = clock(); 1005129203Scognet reportTime( count, endClock - startClock ); 1006129203Scognet 1007129203Scognet} 1008129203Scognet 1009129203Scognet#ifdef FLOATX80 1010129203Scognet 1011129203Scognetenum { 1012129203Scognet numInputs_floatx80 = 32 1013129203Scognet}; 1014129203Scognet 1015129203Scognetstatic const struct { 1016129203Scognet bits16 high; 1017129203Scognet bits64 low; 1018129203Scognet} inputs_floatx80[ numInputs_floatx80 ] = { 1019129203Scognet { 0xC03F, LIT64( 0xA9BE15A19C1E8B62 ) }, 1020129203Scognet { 0x8000, LIT64( 0x0000000000000000 ) }, 1021129203Scognet { 0x75A8, LIT64( 0xE59591E4788957A5 ) }, 1022129203Scognet { 0xBFFF, LIT64( 0xFFF0000000000040 ) }, 1023129203Scognet { 0x0CD8, LIT64( 0xFC000000000007FE ) }, 1024129203Scognet { 0x43BA, LIT64( 0x99A4000000000000 ) }, 1025129203Scognet { 0x3FFF, LIT64( 0x8000000000000000 ) }, 1026129203Scognet { 0x4081, LIT64( 0x94FBF1BCEB5545F0 ) }, 1027129203Scognet { 0x403E, LIT64( 0xFFF0000000002000 ) }, 1028129203Scognet { 0x3FFE, LIT64( 0xC860E3C75D224F28 ) }, 1029129203Scognet { 0x407E, LIT64( 0xFC00000FFFFFFFFE ) }, 1030129203Scognet { 0x737A, LIT64( 0x800000007FFDFFFE ) }, 1031129203Scognet { 0x4044, LIT64( 0xFFFFFF80000FFFFF ) }, 1032129203Scognet { 0xBBFE, LIT64( 0x8000040000001FFE ) }, 1033129203Scognet { 0xC002, LIT64( 0xFF80000000000020 ) }, 1034129203Scognet { 0xDE8D, LIT64( 0xFFFFFFFFFFE00004 ) }, 1035129203Scognet { 0xC004, LIT64( 0x8000000000003FFB ) }, 1036129203Scognet { 0x407F, LIT64( 0x800000000003FFFE ) }, 1037129203Scognet { 0xC000, LIT64( 0xA459EE6A5C16CA55 ) }, 1038129203Scognet { 0x8003, LIT64( 0xC42CBF7399AEEB94 ) }, 1039129203Scognet { 0xBF7F, LIT64( 0xF800000000000006 ) }, 1040129203Scognet { 0xC07F, LIT64( 0xBF56BE8871F28FEA ) }, 1041129203Scognet { 0xC07E, LIT64( 0xFFFF77FFFFFFFFFE ) }, 1042129203Scognet { 0xADC9, LIT64( 0x8000000FFFFFFFDE ) }, 1043129203Scognet { 0xC001, LIT64( 0xEFF7FFFFFFFFFFFF ) }, 1044129203Scognet { 0x4001, LIT64( 0xBE84F30125C497A6 ) }, 1045129203Scognet { 0xC06B, LIT64( 0xEFFFFFFFFFFFFFFF ) }, 1046129203Scognet { 0x4080, LIT64( 0xFFFFFFFFBFFFFFFF ) }, 1047129203Scognet { 0x87E9, LIT64( 0x81FFFFFFFFFFFBFF ) }, 1048129203Scognet { 0xA63F, LIT64( 0x801FFFFFFEFFFFFE ) }, 1049129203Scognet { 0x403C, LIT64( 0x801FFFFFFFF7FFFF ) }, 1050129203Scognet { 0x4018, LIT64( 0x8000000000080003 ) } 1051129203Scognet}; 1052129203Scognet 1053129203Scognetstatic void time_a_floatx80_z_int32( int32 function( floatx80 ) ) 1054129203Scognet{ 1055129203Scognet clock_t startClock, endClock; 1056129203Scognet int32 count, i; 1057129203Scognet int8 inputNum; 1058129203Scognet floatx80 a; 1059129203Scognet 1060129203Scognet count = 0; 1061129203Scognet inputNum = 0; 1062129203Scognet startClock = clock(); 1063129203Scognet do { 1064129203Scognet for ( i = minIterations; i; --i ) { 1065129203Scognet a.low = inputs_floatx80[ inputNum ].low; 1066129203Scognet a.high = inputs_floatx80[ inputNum ].high; 1067129203Scognet function( a ); 1068129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_floatx80 - 1 ); 1069129203Scognet } 1070129203Scognet count += minIterations; 1071129203Scognet } while ( clock() - startClock < CLOCKS_PER_SEC ); 1072129203Scognet inputNum = 0; 1073129203Scognet startClock = clock(); 1074129203Scognet for ( i = count; i; --i ) { 1075129203Scognet a.low = inputs_floatx80[ inputNum ].low; 1076129203Scognet a.high = inputs_floatx80[ inputNum ].high; 1077129203Scognet function( a ); 1078129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_floatx80 - 1 ); 1079129203Scognet } 1080129203Scognet endClock = clock(); 1081129203Scognet reportTime( count, endClock - startClock ); 1082129203Scognet 1083129203Scognet} 1084129203Scognet 1085129203Scognetstatic void time_a_floatx80_z_int64( int64 function( floatx80 ) ) 1086129203Scognet{ 1087129203Scognet clock_t startClock, endClock; 1088129203Scognet int32 count, i; 1089129203Scognet int8 inputNum; 1090129203Scognet floatx80 a; 1091129203Scognet 1092129203Scognet count = 0; 1093129203Scognet inputNum = 0; 1094129203Scognet startClock = clock(); 1095129203Scognet do { 1096129203Scognet for ( i = minIterations; i; --i ) { 1097129203Scognet a.low = inputs_floatx80[ inputNum ].low; 1098129203Scognet a.high = inputs_floatx80[ inputNum ].high; 1099129203Scognet function( a ); 1100129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_floatx80 - 1 ); 1101129203Scognet } 1102129203Scognet count += minIterations; 1103129203Scognet } while ( clock() - startClock < CLOCKS_PER_SEC ); 1104129203Scognet inputNum = 0; 1105129203Scognet startClock = clock(); 1106129203Scognet for ( i = count; i; --i ) { 1107129203Scognet a.low = inputs_floatx80[ inputNum ].low; 1108129203Scognet a.high = inputs_floatx80[ inputNum ].high; 1109129203Scognet function( a ); 1110129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_floatx80 - 1 ); 1111129203Scognet } 1112129203Scognet endClock = clock(); 1113129203Scognet reportTime( count, endClock - startClock ); 1114129203Scognet 1115129203Scognet} 1116129203Scognet 1117129203Scognetstatic void time_a_floatx80_z_float32( float32 function( floatx80 ) ) 1118129203Scognet{ 1119129203Scognet clock_t startClock, endClock; 1120129203Scognet int32 count, i; 1121129203Scognet int8 inputNum; 1122129203Scognet floatx80 a; 1123129203Scognet 1124129203Scognet count = 0; 1125129203Scognet inputNum = 0; 1126129203Scognet startClock = clock(); 1127129203Scognet do { 1128129203Scognet for ( i = minIterations; i; --i ) { 1129129203Scognet a.low = inputs_floatx80[ inputNum ].low; 1130129203Scognet a.high = inputs_floatx80[ inputNum ].high; 1131129203Scognet function( a ); 1132129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_floatx80 - 1 ); 1133129203Scognet } 1134129203Scognet count += minIterations; 1135129203Scognet } while ( clock() - startClock < CLOCKS_PER_SEC ); 1136129203Scognet inputNum = 0; 1137129203Scognet startClock = clock(); 1138129203Scognet for ( i = count; i; --i ) { 1139129203Scognet a.low = inputs_floatx80[ inputNum ].low; 1140129203Scognet a.high = inputs_floatx80[ inputNum ].high; 1141129203Scognet function( a ); 1142129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_floatx80 - 1 ); 1143129203Scognet } 1144129203Scognet endClock = clock(); 1145129203Scognet reportTime( count, endClock - startClock ); 1146129203Scognet 1147129203Scognet} 1148129203Scognet 1149129203Scognetstatic void time_a_floatx80_z_float64( float64 function( floatx80 ) ) 1150129203Scognet{ 1151129203Scognet clock_t startClock, endClock; 1152129203Scognet int32 count, i; 1153129203Scognet int8 inputNum; 1154129203Scognet floatx80 a; 1155129203Scognet 1156129203Scognet count = 0; 1157129203Scognet inputNum = 0; 1158129203Scognet startClock = clock(); 1159129203Scognet do { 1160129203Scognet for ( i = minIterations; i; --i ) { 1161129203Scognet a.low = inputs_floatx80[ inputNum ].low; 1162129203Scognet a.high = inputs_floatx80[ inputNum ].high; 1163129203Scognet function( a ); 1164129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_floatx80 - 1 ); 1165129203Scognet } 1166129203Scognet count += minIterations; 1167129203Scognet } while ( clock() - startClock < CLOCKS_PER_SEC ); 1168129203Scognet inputNum = 0; 1169129203Scognet startClock = clock(); 1170129203Scognet for ( i = count; i; --i ) { 1171129203Scognet a.low = inputs_floatx80[ inputNum ].low; 1172129203Scognet a.high = inputs_floatx80[ inputNum ].high; 1173129203Scognet function( a ); 1174129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_floatx80 - 1 ); 1175129203Scognet } 1176129203Scognet endClock = clock(); 1177129203Scognet reportTime( count, endClock - startClock ); 1178129203Scognet 1179129203Scognet} 1180129203Scognet 1181129203Scognet#ifdef FLOAT128 1182129203Scognet 1183129203Scognetstatic void time_a_floatx80_z_float128( float128 function( floatx80 ) ) 1184129203Scognet{ 1185129203Scognet clock_t startClock, endClock; 1186129203Scognet int32 count, i; 1187129203Scognet int8 inputNum; 1188129203Scognet floatx80 a; 1189129203Scognet 1190129203Scognet count = 0; 1191129203Scognet inputNum = 0; 1192129203Scognet startClock = clock(); 1193129203Scognet do { 1194129203Scognet for ( i = minIterations; i; --i ) { 1195129203Scognet a.low = inputs_floatx80[ inputNum ].low; 1196129203Scognet a.high = inputs_floatx80[ inputNum ].high; 1197129203Scognet function( a ); 1198129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_floatx80 - 1 ); 1199129203Scognet } 1200129203Scognet count += minIterations; 1201129203Scognet } while ( clock() - startClock < CLOCKS_PER_SEC ); 1202129203Scognet inputNum = 0; 1203129203Scognet startClock = clock(); 1204129203Scognet for ( i = count; i; --i ) { 1205129203Scognet a.low = inputs_floatx80[ inputNum ].low; 1206129203Scognet a.high = inputs_floatx80[ inputNum ].high; 1207129203Scognet function( a ); 1208129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_floatx80 - 1 ); 1209129203Scognet } 1210129203Scognet endClock = clock(); 1211129203Scognet reportTime( count, endClock - startClock ); 1212129203Scognet 1213129203Scognet} 1214129203Scognet 1215129203Scognet#endif 1216129203Scognet 1217129203Scognetstatic void time_az_floatx80( floatx80 function( floatx80 ) ) 1218129203Scognet{ 1219129203Scognet clock_t startClock, endClock; 1220129203Scognet int32 count, i; 1221129203Scognet int8 inputNum; 1222129203Scognet floatx80 a; 1223129203Scognet 1224129203Scognet count = 0; 1225129203Scognet inputNum = 0; 1226129203Scognet startClock = clock(); 1227129203Scognet do { 1228129203Scognet for ( i = minIterations; i; --i ) { 1229129203Scognet a.low = inputs_floatx80[ inputNum ].low; 1230129203Scognet a.high = inputs_floatx80[ inputNum ].high; 1231129203Scognet function( a ); 1232129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_floatx80 - 1 ); 1233129203Scognet } 1234129203Scognet count += minIterations; 1235129203Scognet } while ( clock() - startClock < CLOCKS_PER_SEC ); 1236129203Scognet inputNum = 0; 1237129203Scognet startClock = clock(); 1238129203Scognet for ( i = count; i; --i ) { 1239129203Scognet a.low = inputs_floatx80[ inputNum ].low; 1240129203Scognet a.high = inputs_floatx80[ inputNum ].high; 1241129203Scognet function( a ); 1242129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_floatx80 - 1 ); 1243129203Scognet } 1244129203Scognet endClock = clock(); 1245129203Scognet reportTime( count, endClock - startClock ); 1246129203Scognet 1247129203Scognet} 1248129203Scognet 1249129203Scognetstatic void time_ab_floatx80_z_flag( flag function( floatx80, floatx80 ) ) 1250129203Scognet{ 1251129203Scognet clock_t startClock, endClock; 1252129203Scognet int32 count, i; 1253129203Scognet int8 inputNumA, inputNumB; 1254129203Scognet floatx80 a, b; 1255129203Scognet 1256129203Scognet count = 0; 1257129203Scognet inputNumA = 0; 1258129203Scognet inputNumB = 0; 1259129203Scognet startClock = clock(); 1260129203Scognet do { 1261129203Scognet for ( i = minIterations; i; --i ) { 1262129203Scognet a.low = inputs_floatx80[ inputNumA ].low; 1263129203Scognet a.high = inputs_floatx80[ inputNumA ].high; 1264129203Scognet b.low = inputs_floatx80[ inputNumB ].low; 1265129203Scognet b.high = inputs_floatx80[ inputNumB ].high; 1266129203Scognet function( a, b ); 1267129203Scognet inputNumA = ( inputNumA + 1 ) & ( numInputs_floatx80 - 1 ); 1268129203Scognet if ( inputNumA == 0 ) ++inputNumB; 1269129203Scognet inputNumB = ( inputNumB + 1 ) & ( numInputs_floatx80 - 1 ); 1270129203Scognet } 1271129203Scognet count += minIterations; 1272129203Scognet } while ( clock() - startClock < CLOCKS_PER_SEC ); 1273129203Scognet inputNumA = 0; 1274129203Scognet inputNumB = 0; 1275129203Scognet startClock = clock(); 1276129203Scognet for ( i = count; i; --i ) { 1277129203Scognet a.low = inputs_floatx80[ inputNumA ].low; 1278129203Scognet a.high = inputs_floatx80[ inputNumA ].high; 1279129203Scognet b.low = inputs_floatx80[ inputNumB ].low; 1280129203Scognet b.high = inputs_floatx80[ inputNumB ].high; 1281129203Scognet function( a, b ); 1282129203Scognet inputNumA = ( inputNumA + 1 ) & ( numInputs_floatx80 - 1 ); 1283129203Scognet if ( inputNumA == 0 ) ++inputNumB; 1284129203Scognet inputNumB = ( inputNumB + 1 ) & ( numInputs_floatx80 - 1 ); 1285129203Scognet } 1286129203Scognet endClock = clock(); 1287129203Scognet reportTime( count, endClock - startClock ); 1288129203Scognet 1289129203Scognet} 1290129203Scognet 1291129203Scognetstatic void time_abz_floatx80( floatx80 function( floatx80, floatx80 ) ) 1292129203Scognet{ 1293129203Scognet clock_t startClock, endClock; 1294129203Scognet int32 count, i; 1295129203Scognet int8 inputNumA, inputNumB; 1296129203Scognet floatx80 a, b; 1297129203Scognet 1298129203Scognet count = 0; 1299129203Scognet inputNumA = 0; 1300129203Scognet inputNumB = 0; 1301129203Scognet startClock = clock(); 1302129203Scognet do { 1303129203Scognet for ( i = minIterations; i; --i ) { 1304129203Scognet a.low = inputs_floatx80[ inputNumA ].low; 1305129203Scognet a.high = inputs_floatx80[ inputNumA ].high; 1306129203Scognet b.low = inputs_floatx80[ inputNumB ].low; 1307129203Scognet b.high = inputs_floatx80[ inputNumB ].high; 1308129203Scognet function( a, b ); 1309129203Scognet inputNumA = ( inputNumA + 1 ) & ( numInputs_floatx80 - 1 ); 1310129203Scognet if ( inputNumA == 0 ) ++inputNumB; 1311129203Scognet inputNumB = ( inputNumB + 1 ) & ( numInputs_floatx80 - 1 ); 1312129203Scognet } 1313129203Scognet count += minIterations; 1314129203Scognet } while ( clock() - startClock < CLOCKS_PER_SEC ); 1315129203Scognet inputNumA = 0; 1316129203Scognet inputNumB = 0; 1317129203Scognet startClock = clock(); 1318129203Scognet for ( i = count; i; --i ) { 1319129203Scognet a.low = inputs_floatx80[ inputNumA ].low; 1320129203Scognet a.high = inputs_floatx80[ inputNumA ].high; 1321129203Scognet b.low = inputs_floatx80[ inputNumB ].low; 1322129203Scognet b.high = inputs_floatx80[ inputNumB ].high; 1323129203Scognet function( a, b ); 1324129203Scognet inputNumA = ( inputNumA + 1 ) & ( numInputs_floatx80 - 1 ); 1325129203Scognet if ( inputNumA == 0 ) ++inputNumB; 1326129203Scognet inputNumB = ( inputNumB + 1 ) & ( numInputs_floatx80 - 1 ); 1327129203Scognet } 1328129203Scognet endClock = clock(); 1329129203Scognet reportTime( count, endClock - startClock ); 1330129203Scognet 1331129203Scognet} 1332129203Scognet 1333129203Scognetstatic const struct { 1334129203Scognet bits16 high; 1335129203Scognet bits64 low; 1336129203Scognet} inputs_floatx80_pos[ numInputs_floatx80 ] = { 1337129203Scognet { 0x403F, LIT64( 0xA9BE15A19C1E8B62 ) }, 1338129203Scognet { 0x0000, LIT64( 0x0000000000000000 ) }, 1339129203Scognet { 0x75A8, LIT64( 0xE59591E4788957A5 ) }, 1340129203Scognet { 0x3FFF, LIT64( 0xFFF0000000000040 ) }, 1341129203Scognet { 0x0CD8, LIT64( 0xFC000000000007FE ) }, 1342129203Scognet { 0x43BA, LIT64( 0x99A4000000000000 ) }, 1343129203Scognet { 0x3FFF, LIT64( 0x8000000000000000 ) }, 1344129203Scognet { 0x4081, LIT64( 0x94FBF1BCEB5545F0 ) }, 1345129203Scognet { 0x403E, LIT64( 0xFFF0000000002000 ) }, 1346129203Scognet { 0x3FFE, LIT64( 0xC860E3C75D224F28 ) }, 1347129203Scognet { 0x407E, LIT64( 0xFC00000FFFFFFFFE ) }, 1348129203Scognet { 0x737A, LIT64( 0x800000007FFDFFFE ) }, 1349129203Scognet { 0x4044, LIT64( 0xFFFFFF80000FFFFF ) }, 1350129203Scognet { 0x3BFE, LIT64( 0x8000040000001FFE ) }, 1351129203Scognet { 0x4002, LIT64( 0xFF80000000000020 ) }, 1352129203Scognet { 0x5E8D, LIT64( 0xFFFFFFFFFFE00004 ) }, 1353129203Scognet { 0x4004, LIT64( 0x8000000000003FFB ) }, 1354129203Scognet { 0x407F, LIT64( 0x800000000003FFFE ) }, 1355129203Scognet { 0x4000, LIT64( 0xA459EE6A5C16CA55 ) }, 1356129203Scognet { 0x0003, LIT64( 0xC42CBF7399AEEB94 ) }, 1357129203Scognet { 0x3F7F, LIT64( 0xF800000000000006 ) }, 1358129203Scognet { 0x407F, LIT64( 0xBF56BE8871F28FEA ) }, 1359129203Scognet { 0x407E, LIT64( 0xFFFF77FFFFFFFFFE ) }, 1360129203Scognet { 0x2DC9, LIT64( 0x8000000FFFFFFFDE ) }, 1361129203Scognet { 0x4001, LIT64( 0xEFF7FFFFFFFFFFFF ) }, 1362129203Scognet { 0x4001, LIT64( 0xBE84F30125C497A6 ) }, 1363129203Scognet { 0x406B, LIT64( 0xEFFFFFFFFFFFFFFF ) }, 1364129203Scognet { 0x4080, LIT64( 0xFFFFFFFFBFFFFFFF ) }, 1365129203Scognet { 0x07E9, LIT64( 0x81FFFFFFFFFFFBFF ) }, 1366129203Scognet { 0x263F, LIT64( 0x801FFFFFFEFFFFFE ) }, 1367129203Scognet { 0x403C, LIT64( 0x801FFFFFFFF7FFFF ) }, 1368129203Scognet { 0x4018, LIT64( 0x8000000000080003 ) } 1369129203Scognet}; 1370129203Scognet 1371129203Scognetstatic void time_az_floatx80_pos( floatx80 function( floatx80 ) ) 1372129203Scognet{ 1373129203Scognet clock_t startClock, endClock; 1374129203Scognet int32 count, i; 1375129203Scognet int8 inputNum; 1376129203Scognet floatx80 a; 1377129203Scognet 1378129203Scognet count = 0; 1379129203Scognet inputNum = 0; 1380129203Scognet startClock = clock(); 1381129203Scognet do { 1382129203Scognet for ( i = minIterations; i; --i ) { 1383129203Scognet a.low = inputs_floatx80_pos[ inputNum ].low; 1384129203Scognet a.high = inputs_floatx80_pos[ inputNum ].high; 1385129203Scognet function( a ); 1386129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_floatx80 - 1 ); 1387129203Scognet } 1388129203Scognet count += minIterations; 1389129203Scognet } while ( clock() - startClock < CLOCKS_PER_SEC ); 1390129203Scognet inputNum = 0; 1391129203Scognet startClock = clock(); 1392129203Scognet for ( i = count; i; --i ) { 1393129203Scognet a.low = inputs_floatx80_pos[ inputNum ].low; 1394129203Scognet a.high = inputs_floatx80_pos[ inputNum ].high; 1395129203Scognet function( a ); 1396129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_floatx80 - 1 ); 1397129203Scognet } 1398129203Scognet endClock = clock(); 1399129203Scognet reportTime( count, endClock - startClock ); 1400129203Scognet 1401129203Scognet} 1402129203Scognet 1403129203Scognet#endif 1404129203Scognet 1405129203Scognet#ifdef FLOAT128 1406129203Scognet 1407129203Scognetenum { 1408129203Scognet numInputs_float128 = 32 1409129203Scognet}; 1410129203Scognet 1411129203Scognetstatic const struct { 1412129203Scognet bits64 high, low; 1413129203Scognet} inputs_float128[ numInputs_float128 ] = { 1414129203Scognet { LIT64( 0x3FDA200000100000 ), LIT64( 0x0000000000000000 ) }, 1415129203Scognet { LIT64( 0x3FFF000000000000 ), LIT64( 0x0000000000000000 ) }, 1416129203Scognet { LIT64( 0x85F14776190C8306 ), LIT64( 0xD8715F4E3D54BB92 ) }, 1417129203Scognet { LIT64( 0xF2B00000007FFFFF ), LIT64( 0xFFFFFFFFFFF7FFFF ) }, 1418129203Scognet { LIT64( 0x8000000000000000 ), LIT64( 0x0000000000000000 ) }, 1419129203Scognet { LIT64( 0xBFFFFFFFFFE00000 ), LIT64( 0x0000008000000000 ) }, 1420129203Scognet { LIT64( 0x407F1719CE722F3E ), LIT64( 0xDA6B3FE5FF29425B ) }, 1421129203Scognet { LIT64( 0x43FFFF8000000000 ), LIT64( 0x0000000000400000 ) }, 1422129203Scognet { LIT64( 0x401E000000000100 ), LIT64( 0x0000000000002000 ) }, 1423129203Scognet { LIT64( 0x3FFED71DACDA8E47 ), LIT64( 0x4860E3C75D224F28 ) }, 1424129203Scognet { LIT64( 0xBF7ECFC1E90647D1 ), LIT64( 0x7A124FE55623EE44 ) }, 1425129203Scognet { LIT64( 0x0DF7007FFFFFFFFF ), LIT64( 0xFFFFFFFFEFFFFFFF ) }, 1426129203Scognet { LIT64( 0x3FE5FFEFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFEFFF ) }, 1427129203Scognet { LIT64( 0x403FFFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFBFE ) }, 1428129203Scognet { LIT64( 0xBFFB2FBF7399AFEB ), LIT64( 0xA459EE6A5C16CA55 ) }, 1429129203Scognet { LIT64( 0xBDB8FFFFFFFFFFFC ), LIT64( 0x0000000000000400 ) }, 1430129203Scognet { LIT64( 0x3FC8FFDFFFFFFFFF ), LIT64( 0xFFFFFFFFF0000000 ) }, 1431129203Scognet { LIT64( 0x3FFBFFFFFFDFFFFF ), LIT64( 0xFFF8000000000000 ) }, 1432129203Scognet { LIT64( 0x407043C11737BE84 ), LIT64( 0xDDD58212ADC937F4 ) }, 1433129203Scognet { LIT64( 0x8001000000000000 ), LIT64( 0x0000001000000001 ) }, 1434129203Scognet { LIT64( 0xC036FFFFFFFFFFFF ), LIT64( 0xFE40000000000000 ) }, 1435129203Scognet { LIT64( 0x4002FFFFFE000002 ), LIT64( 0x0000000000000000 ) }, 1436129203Scognet { LIT64( 0x4000C3FEDE897773 ), LIT64( 0x326AC4FD8EFBE6DC ) }, 1437129203Scognet { LIT64( 0xBFFF0000000FFFFF ), LIT64( 0xFFFFFE0000000000 ) }, 1438129203Scognet { LIT64( 0x62C3E502146E426D ), LIT64( 0x43F3CAA0DC7DF1A0 ) }, 1439129203Scognet { LIT64( 0xB5CBD32E52BB570E ), LIT64( 0xBCC477CB11C6236C ) }, 1440129203Scognet { LIT64( 0xE228FFFFFFC00000 ), LIT64( 0x0000000000000000 ) }, 1441129203Scognet { LIT64( 0x3F80000000000000 ), LIT64( 0x0000000080000008 ) }, 1442129203Scognet { LIT64( 0xC1AFFFDFFFFFFFFF ), LIT64( 0xFFFC000000000000 ) }, 1443129203Scognet { LIT64( 0xC96F000000000000 ), LIT64( 0x00000001FFFBFFFF ) }, 1444129203Scognet { LIT64( 0x3DE09BFE7923A338 ), LIT64( 0xBCC8FBBD7CEC1F4F ) }, 1445129203Scognet { LIT64( 0x401CFFFFFFFFFFFF ), LIT64( 0xFFFFFFFEFFFFFF80 ) } 1446129203Scognet}; 1447129203Scognet 1448129203Scognetstatic void time_a_float128_z_int32( int32 function( float128 ) ) 1449129203Scognet{ 1450129203Scognet clock_t startClock, endClock; 1451129203Scognet int32 count, i; 1452129203Scognet int8 inputNum; 1453129203Scognet float128 a; 1454129203Scognet 1455129203Scognet count = 0; 1456129203Scognet inputNum = 0; 1457129203Scognet startClock = clock(); 1458129203Scognet do { 1459129203Scognet for ( i = minIterations; i; --i ) { 1460129203Scognet a.low = inputs_float128[ inputNum ].low; 1461129203Scognet a.high = inputs_float128[ inputNum ].high; 1462129203Scognet function( a ); 1463129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_float128 - 1 ); 1464129203Scognet } 1465129203Scognet count += minIterations; 1466129203Scognet } while ( clock() - startClock < CLOCKS_PER_SEC ); 1467129203Scognet inputNum = 0; 1468129203Scognet startClock = clock(); 1469129203Scognet for ( i = count; i; --i ) { 1470129203Scognet a.low = inputs_float128[ inputNum ].low; 1471129203Scognet a.high = inputs_float128[ inputNum ].high; 1472129203Scognet function( a ); 1473129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_float128 - 1 ); 1474129203Scognet } 1475129203Scognet endClock = clock(); 1476129203Scognet reportTime( count, endClock - startClock ); 1477129203Scognet 1478129203Scognet} 1479129203Scognet 1480129203Scognetstatic void time_a_float128_z_int64( int64 function( float128 ) ) 1481129203Scognet{ 1482129203Scognet clock_t startClock, endClock; 1483129203Scognet int32 count, i; 1484129203Scognet int8 inputNum; 1485129203Scognet float128 a; 1486129203Scognet 1487129203Scognet count = 0; 1488129203Scognet inputNum = 0; 1489129203Scognet startClock = clock(); 1490129203Scognet do { 1491129203Scognet for ( i = minIterations; i; --i ) { 1492129203Scognet a.low = inputs_float128[ inputNum ].low; 1493129203Scognet a.high = inputs_float128[ inputNum ].high; 1494129203Scognet function( a ); 1495129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_float128 - 1 ); 1496129203Scognet } 1497129203Scognet count += minIterations; 1498129203Scognet } while ( clock() - startClock < CLOCKS_PER_SEC ); 1499129203Scognet inputNum = 0; 1500129203Scognet startClock = clock(); 1501129203Scognet for ( i = count; i; --i ) { 1502129203Scognet a.low = inputs_float128[ inputNum ].low; 1503129203Scognet a.high = inputs_float128[ inputNum ].high; 1504129203Scognet function( a ); 1505129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_float128 - 1 ); 1506129203Scognet } 1507129203Scognet endClock = clock(); 1508129203Scognet reportTime( count, endClock - startClock ); 1509129203Scognet 1510129203Scognet} 1511129203Scognet 1512129203Scognetstatic void time_a_float128_z_float32( float32 function( float128 ) ) 1513129203Scognet{ 1514129203Scognet clock_t startClock, endClock; 1515129203Scognet int32 count, i; 1516129203Scognet int8 inputNum; 1517129203Scognet float128 a; 1518129203Scognet 1519129203Scognet count = 0; 1520129203Scognet inputNum = 0; 1521129203Scognet startClock = clock(); 1522129203Scognet do { 1523129203Scognet for ( i = minIterations; i; --i ) { 1524129203Scognet a.low = inputs_float128[ inputNum ].low; 1525129203Scognet a.high = inputs_float128[ inputNum ].high; 1526129203Scognet function( a ); 1527129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_float128 - 1 ); 1528129203Scognet } 1529129203Scognet count += minIterations; 1530129203Scognet } while ( clock() - startClock < CLOCKS_PER_SEC ); 1531129203Scognet inputNum = 0; 1532129203Scognet startClock = clock(); 1533129203Scognet for ( i = count; i; --i ) { 1534129203Scognet a.low = inputs_float128[ inputNum ].low; 1535129203Scognet a.high = inputs_float128[ inputNum ].high; 1536129203Scognet function( a ); 1537129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_float128 - 1 ); 1538129203Scognet } 1539129203Scognet endClock = clock(); 1540129203Scognet reportTime( count, endClock - startClock ); 1541129203Scognet 1542129203Scognet} 1543129203Scognet 1544129203Scognetstatic void time_a_float128_z_float64( float64 function( float128 ) ) 1545129203Scognet{ 1546129203Scognet clock_t startClock, endClock; 1547129203Scognet int32 count, i; 1548129203Scognet int8 inputNum; 1549129203Scognet float128 a; 1550129203Scognet 1551129203Scognet count = 0; 1552129203Scognet inputNum = 0; 1553129203Scognet startClock = clock(); 1554129203Scognet do { 1555129203Scognet for ( i = minIterations; i; --i ) { 1556129203Scognet a.low = inputs_float128[ inputNum ].low; 1557129203Scognet a.high = inputs_float128[ inputNum ].high; 1558129203Scognet function( a ); 1559129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_float128 - 1 ); 1560129203Scognet } 1561129203Scognet count += minIterations; 1562129203Scognet } while ( clock() - startClock < CLOCKS_PER_SEC ); 1563129203Scognet inputNum = 0; 1564129203Scognet startClock = clock(); 1565129203Scognet for ( i = count; i; --i ) { 1566129203Scognet a.low = inputs_float128[ inputNum ].low; 1567129203Scognet a.high = inputs_float128[ inputNum ].high; 1568129203Scognet function( a ); 1569129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_float128 - 1 ); 1570129203Scognet } 1571129203Scognet endClock = clock(); 1572129203Scognet reportTime( count, endClock - startClock ); 1573129203Scognet 1574129203Scognet} 1575129203Scognet 1576129203Scognet#ifdef FLOATX80 1577129203Scognet 1578129203Scognetstatic void time_a_float128_z_floatx80( floatx80 function( float128 ) ) 1579129203Scognet{ 1580129203Scognet clock_t startClock, endClock; 1581129203Scognet int32 count, i; 1582129203Scognet int8 inputNum; 1583129203Scognet float128 a; 1584129203Scognet 1585129203Scognet count = 0; 1586129203Scognet inputNum = 0; 1587129203Scognet startClock = clock(); 1588129203Scognet do { 1589129203Scognet for ( i = minIterations; i; --i ) { 1590129203Scognet a.low = inputs_float128[ inputNum ].low; 1591129203Scognet a.high = inputs_float128[ inputNum ].high; 1592129203Scognet function( a ); 1593129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_float128 - 1 ); 1594129203Scognet } 1595129203Scognet count += minIterations; 1596129203Scognet } while ( clock() - startClock < CLOCKS_PER_SEC ); 1597129203Scognet inputNum = 0; 1598129203Scognet startClock = clock(); 1599129203Scognet for ( i = count; i; --i ) { 1600129203Scognet a.low = inputs_float128[ inputNum ].low; 1601129203Scognet a.high = inputs_float128[ inputNum ].high; 1602129203Scognet function( a ); 1603129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_float128 - 1 ); 1604129203Scognet } 1605129203Scognet endClock = clock(); 1606129203Scognet reportTime( count, endClock - startClock ); 1607129203Scognet 1608129203Scognet} 1609129203Scognet 1610129203Scognet#endif 1611129203Scognet 1612129203Scognetstatic void time_az_float128( float128 function( float128 ) ) 1613129203Scognet{ 1614129203Scognet clock_t startClock, endClock; 1615129203Scognet int32 count, i; 1616129203Scognet int8 inputNum; 1617129203Scognet float128 a; 1618129203Scognet 1619129203Scognet count = 0; 1620129203Scognet inputNum = 0; 1621129203Scognet startClock = clock(); 1622129203Scognet do { 1623129203Scognet for ( i = minIterations; i; --i ) { 1624129203Scognet a.low = inputs_float128[ inputNum ].low; 1625129203Scognet a.high = inputs_float128[ inputNum ].high; 1626129203Scognet function( a ); 1627129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_float128 - 1 ); 1628129203Scognet } 1629129203Scognet count += minIterations; 1630129203Scognet } while ( clock() - startClock < CLOCKS_PER_SEC ); 1631129203Scognet inputNum = 0; 1632129203Scognet startClock = clock(); 1633129203Scognet for ( i = count; i; --i ) { 1634129203Scognet a.low = inputs_float128[ inputNum ].low; 1635129203Scognet a.high = inputs_float128[ inputNum ].high; 1636129203Scognet function( a ); 1637129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_float128 - 1 ); 1638129203Scognet } 1639129203Scognet endClock = clock(); 1640129203Scognet reportTime( count, endClock - startClock ); 1641129203Scognet 1642129203Scognet} 1643129203Scognet 1644129203Scognetstatic void time_ab_float128_z_flag( flag function( float128, float128 ) ) 1645129203Scognet{ 1646129203Scognet clock_t startClock, endClock; 1647129203Scognet int32 count, i; 1648129203Scognet int8 inputNumA, inputNumB; 1649129203Scognet float128 a, b; 1650129203Scognet 1651129203Scognet count = 0; 1652129203Scognet inputNumA = 0; 1653129203Scognet inputNumB = 0; 1654129203Scognet startClock = clock(); 1655129203Scognet do { 1656129203Scognet for ( i = minIterations; i; --i ) { 1657129203Scognet a.low = inputs_float128[ inputNumA ].low; 1658129203Scognet a.high = inputs_float128[ inputNumA ].high; 1659129203Scognet b.low = inputs_float128[ inputNumB ].low; 1660129203Scognet b.high = inputs_float128[ inputNumB ].high; 1661129203Scognet function( a, b ); 1662129203Scognet inputNumA = ( inputNumA + 1 ) & ( numInputs_float128 - 1 ); 1663129203Scognet if ( inputNumA == 0 ) ++inputNumB; 1664129203Scognet inputNumB = ( inputNumB + 1 ) & ( numInputs_float128 - 1 ); 1665129203Scognet } 1666129203Scognet count += minIterations; 1667129203Scognet } while ( clock() - startClock < CLOCKS_PER_SEC ); 1668129203Scognet inputNumA = 0; 1669129203Scognet inputNumB = 0; 1670129203Scognet startClock = clock(); 1671129203Scognet for ( i = count; i; --i ) { 1672129203Scognet a.low = inputs_float128[ inputNumA ].low; 1673129203Scognet a.high = inputs_float128[ inputNumA ].high; 1674129203Scognet b.low = inputs_float128[ inputNumB ].low; 1675129203Scognet b.high = inputs_float128[ inputNumB ].high; 1676129203Scognet function( a, b ); 1677129203Scognet inputNumA = ( inputNumA + 1 ) & ( numInputs_float128 - 1 ); 1678129203Scognet if ( inputNumA == 0 ) ++inputNumB; 1679129203Scognet inputNumB = ( inputNumB + 1 ) & ( numInputs_float128 - 1 ); 1680129203Scognet } 1681129203Scognet endClock = clock(); 1682129203Scognet reportTime( count, endClock - startClock ); 1683129203Scognet 1684129203Scognet} 1685129203Scognet 1686129203Scognetstatic void time_abz_float128( float128 function( float128, float128 ) ) 1687129203Scognet{ 1688129203Scognet clock_t startClock, endClock; 1689129203Scognet int32 count, i; 1690129203Scognet int8 inputNumA, inputNumB; 1691129203Scognet float128 a, b; 1692129203Scognet 1693129203Scognet count = 0; 1694129203Scognet inputNumA = 0; 1695129203Scognet inputNumB = 0; 1696129203Scognet startClock = clock(); 1697129203Scognet do { 1698129203Scognet for ( i = minIterations; i; --i ) { 1699129203Scognet a.low = inputs_float128[ inputNumA ].low; 1700129203Scognet a.high = inputs_float128[ inputNumA ].high; 1701129203Scognet b.low = inputs_float128[ inputNumB ].low; 1702129203Scognet b.high = inputs_float128[ inputNumB ].high; 1703129203Scognet function( a, b ); 1704129203Scognet inputNumA = ( inputNumA + 1 ) & ( numInputs_float128 - 1 ); 1705129203Scognet if ( inputNumA == 0 ) ++inputNumB; 1706129203Scognet inputNumB = ( inputNumB + 1 ) & ( numInputs_float128 - 1 ); 1707129203Scognet } 1708129203Scognet count += minIterations; 1709129203Scognet } while ( clock() - startClock < CLOCKS_PER_SEC ); 1710129203Scognet inputNumA = 0; 1711129203Scognet inputNumB = 0; 1712129203Scognet startClock = clock(); 1713129203Scognet for ( i = count; i; --i ) { 1714129203Scognet a.low = inputs_float128[ inputNumA ].low; 1715129203Scognet a.high = inputs_float128[ inputNumA ].high; 1716129203Scognet b.low = inputs_float128[ inputNumB ].low; 1717129203Scognet b.high = inputs_float128[ inputNumB ].high; 1718129203Scognet function( a, b ); 1719129203Scognet inputNumA = ( inputNumA + 1 ) & ( numInputs_float128 - 1 ); 1720129203Scognet if ( inputNumA == 0 ) ++inputNumB; 1721129203Scognet inputNumB = ( inputNumB + 1 ) & ( numInputs_float128 - 1 ); 1722129203Scognet } 1723129203Scognet endClock = clock(); 1724129203Scognet reportTime( count, endClock - startClock ); 1725129203Scognet 1726129203Scognet} 1727129203Scognet 1728129203Scognetstatic const struct { 1729129203Scognet bits64 high, low; 1730129203Scognet} inputs_float128_pos[ numInputs_float128 ] = { 1731129203Scognet { LIT64( 0x3FDA200000100000 ), LIT64( 0x0000000000000000 ) }, 1732129203Scognet { LIT64( 0x3FFF000000000000 ), LIT64( 0x0000000000000000 ) }, 1733129203Scognet { LIT64( 0x05F14776190C8306 ), LIT64( 0xD8715F4E3D54BB92 ) }, 1734129203Scognet { LIT64( 0x72B00000007FFFFF ), LIT64( 0xFFFFFFFFFFF7FFFF ) }, 1735129203Scognet { LIT64( 0x0000000000000000 ), LIT64( 0x0000000000000000 ) }, 1736129203Scognet { LIT64( 0x3FFFFFFFFFE00000 ), LIT64( 0x0000008000000000 ) }, 1737129203Scognet { LIT64( 0x407F1719CE722F3E ), LIT64( 0xDA6B3FE5FF29425B ) }, 1738129203Scognet { LIT64( 0x43FFFF8000000000 ), LIT64( 0x0000000000400000 ) }, 1739129203Scognet { LIT64( 0x401E000000000100 ), LIT64( 0x0000000000002000 ) }, 1740129203Scognet { LIT64( 0x3FFED71DACDA8E47 ), LIT64( 0x4860E3C75D224F28 ) }, 1741129203Scognet { LIT64( 0x3F7ECFC1E90647D1 ), LIT64( 0x7A124FE55623EE44 ) }, 1742129203Scognet { LIT64( 0x0DF7007FFFFFFFFF ), LIT64( 0xFFFFFFFFEFFFFFFF ) }, 1743129203Scognet { LIT64( 0x3FE5FFEFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFEFFF ) }, 1744129203Scognet { LIT64( 0x403FFFFFFFFFFFFF ), LIT64( 0xFFFFFFFFFFFFFBFE ) }, 1745129203Scognet { LIT64( 0x3FFB2FBF7399AFEB ), LIT64( 0xA459EE6A5C16CA55 ) }, 1746129203Scognet { LIT64( 0x3DB8FFFFFFFFFFFC ), LIT64( 0x0000000000000400 ) }, 1747129203Scognet { LIT64( 0x3FC8FFDFFFFFFFFF ), LIT64( 0xFFFFFFFFF0000000 ) }, 1748129203Scognet { LIT64( 0x3FFBFFFFFFDFFFFF ), LIT64( 0xFFF8000000000000 ) }, 1749129203Scognet { LIT64( 0x407043C11737BE84 ), LIT64( 0xDDD58212ADC937F4 ) }, 1750129203Scognet { LIT64( 0x0001000000000000 ), LIT64( 0x0000001000000001 ) }, 1751129203Scognet { LIT64( 0x4036FFFFFFFFFFFF ), LIT64( 0xFE40000000000000 ) }, 1752129203Scognet { LIT64( 0x4002FFFFFE000002 ), LIT64( 0x0000000000000000 ) }, 1753129203Scognet { LIT64( 0x4000C3FEDE897773 ), LIT64( 0x326AC4FD8EFBE6DC ) }, 1754129203Scognet { LIT64( 0x3FFF0000000FFFFF ), LIT64( 0xFFFFFE0000000000 ) }, 1755129203Scognet { LIT64( 0x62C3E502146E426D ), LIT64( 0x43F3CAA0DC7DF1A0 ) }, 1756129203Scognet { LIT64( 0x35CBD32E52BB570E ), LIT64( 0xBCC477CB11C6236C ) }, 1757129203Scognet { LIT64( 0x6228FFFFFFC00000 ), LIT64( 0x0000000000000000 ) }, 1758129203Scognet { LIT64( 0x3F80000000000000 ), LIT64( 0x0000000080000008 ) }, 1759129203Scognet { LIT64( 0x41AFFFDFFFFFFFFF ), LIT64( 0xFFFC000000000000 ) }, 1760129203Scognet { LIT64( 0x496F000000000000 ), LIT64( 0x00000001FFFBFFFF ) }, 1761129203Scognet { LIT64( 0x3DE09BFE7923A338 ), LIT64( 0xBCC8FBBD7CEC1F4F ) }, 1762129203Scognet { LIT64( 0x401CFFFFFFFFFFFF ), LIT64( 0xFFFFFFFEFFFFFF80 ) } 1763129203Scognet}; 1764129203Scognet 1765129203Scognetstatic void time_az_float128_pos( float128 function( float128 ) ) 1766129203Scognet{ 1767129203Scognet clock_t startClock, endClock; 1768129203Scognet int32 count, i; 1769129203Scognet int8 inputNum; 1770129203Scognet float128 a; 1771129203Scognet 1772129203Scognet count = 0; 1773129203Scognet inputNum = 0; 1774129203Scognet startClock = clock(); 1775129203Scognet do { 1776129203Scognet for ( i = minIterations; i; --i ) { 1777129203Scognet a.low = inputs_float128_pos[ inputNum ].low; 1778129203Scognet a.high = inputs_float128_pos[ inputNum ].high; 1779129203Scognet function( a ); 1780129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_float128 - 1 ); 1781129203Scognet } 1782129203Scognet count += minIterations; 1783129203Scognet } while ( clock() - startClock < CLOCKS_PER_SEC ); 1784129203Scognet inputNum = 0; 1785129203Scognet startClock = clock(); 1786129203Scognet for ( i = count; i; --i ) { 1787129203Scognet a.low = inputs_float128_pos[ inputNum ].low; 1788129203Scognet a.high = inputs_float128_pos[ inputNum ].high; 1789129203Scognet function( a ); 1790129203Scognet inputNum = ( inputNum + 1 ) & ( numInputs_float128 - 1 ); 1791129203Scognet } 1792129203Scognet endClock = clock(); 1793129203Scognet reportTime( count, endClock - startClock ); 1794129203Scognet 1795129203Scognet} 1796129203Scognet 1797129203Scognet#endif 1798129203Scognet 1799129203Scognetenum { 1800129203Scognet INT32_TO_FLOAT32 = 1, 1801129203Scognet INT32_TO_FLOAT64, 1802129203Scognet#ifdef FLOATX80 1803129203Scognet INT32_TO_FLOATX80, 1804129203Scognet#endif 1805129203Scognet#ifdef FLOAT128 1806129203Scognet INT32_TO_FLOAT128, 1807129203Scognet#endif 1808129203Scognet INT64_TO_FLOAT32, 1809129203Scognet INT64_TO_FLOAT64, 1810129203Scognet#ifdef FLOATX80 1811129203Scognet INT64_TO_FLOATX80, 1812129203Scognet#endif 1813129203Scognet#ifdef FLOAT128 1814129203Scognet INT64_TO_FLOAT128, 1815129203Scognet#endif 1816129203Scognet FLOAT32_TO_INT32, 1817129203Scognet FLOAT32_TO_INT32_ROUND_TO_ZERO, 1818129203Scognet FLOAT32_TO_INT64, 1819129203Scognet FLOAT32_TO_INT64_ROUND_TO_ZERO, 1820129203Scognet FLOAT32_TO_FLOAT64, 1821129203Scognet#ifdef FLOATX80 1822129203Scognet FLOAT32_TO_FLOATX80, 1823129203Scognet#endif 1824129203Scognet#ifdef FLOAT128 1825129203Scognet FLOAT32_TO_FLOAT128, 1826129203Scognet#endif 1827129203Scognet FLOAT32_ROUND_TO_INT, 1828129203Scognet FLOAT32_ADD, 1829129203Scognet FLOAT32_SUB, 1830129203Scognet FLOAT32_MUL, 1831129203Scognet FLOAT32_DIV, 1832129203Scognet FLOAT32_REM, 1833129203Scognet FLOAT32_SQRT, 1834129203Scognet FLOAT32_EQ, 1835129203Scognet FLOAT32_LE, 1836129203Scognet FLOAT32_LT, 1837129203Scognet FLOAT32_EQ_SIGNALING, 1838129203Scognet FLOAT32_LE_QUIET, 1839129203Scognet FLOAT32_LT_QUIET, 1840129203Scognet FLOAT64_TO_INT32, 1841129203Scognet FLOAT64_TO_INT32_ROUND_TO_ZERO, 1842129203Scognet FLOAT64_TO_INT64, 1843129203Scognet FLOAT64_TO_INT64_ROUND_TO_ZERO, 1844129203Scognet FLOAT64_TO_FLOAT32, 1845129203Scognet#ifdef FLOATX80 1846129203Scognet FLOAT64_TO_FLOATX80, 1847129203Scognet#endif 1848129203Scognet#ifdef FLOAT128 1849129203Scognet FLOAT64_TO_FLOAT128, 1850129203Scognet#endif 1851129203Scognet FLOAT64_ROUND_TO_INT, 1852129203Scognet FLOAT64_ADD, 1853129203Scognet FLOAT64_SUB, 1854129203Scognet FLOAT64_MUL, 1855129203Scognet FLOAT64_DIV, 1856129203Scognet FLOAT64_REM, 1857129203Scognet FLOAT64_SQRT, 1858129203Scognet FLOAT64_EQ, 1859129203Scognet FLOAT64_LE, 1860129203Scognet FLOAT64_LT, 1861129203Scognet FLOAT64_EQ_SIGNALING, 1862129203Scognet FLOAT64_LE_QUIET, 1863129203Scognet FLOAT64_LT_QUIET, 1864129203Scognet#ifdef FLOATX80 1865129203Scognet FLOATX80_TO_INT32, 1866129203Scognet FLOATX80_TO_INT32_ROUND_TO_ZERO, 1867129203Scognet FLOATX80_TO_INT64, 1868129203Scognet FLOATX80_TO_INT64_ROUND_TO_ZERO, 1869129203Scognet FLOATX80_TO_FLOAT32, 1870129203Scognet FLOATX80_TO_FLOAT64, 1871129203Scognet#ifdef FLOAT128 1872129203Scognet FLOATX80_TO_FLOAT128, 1873129203Scognet#endif 1874129203Scognet FLOATX80_ROUND_TO_INT, 1875129203Scognet FLOATX80_ADD, 1876129203Scognet FLOATX80_SUB, 1877129203Scognet FLOATX80_MUL, 1878129203Scognet FLOATX80_DIV, 1879129203Scognet FLOATX80_REM, 1880129203Scognet FLOATX80_SQRT, 1881129203Scognet FLOATX80_EQ, 1882129203Scognet FLOATX80_LE, 1883129203Scognet FLOATX80_LT, 1884129203Scognet FLOATX80_EQ_SIGNALING, 1885129203Scognet FLOATX80_LE_QUIET, 1886129203Scognet FLOATX80_LT_QUIET, 1887129203Scognet#endif 1888129203Scognet#ifdef FLOAT128 1889129203Scognet FLOAT128_TO_INT32, 1890129203Scognet FLOAT128_TO_INT32_ROUND_TO_ZERO, 1891129203Scognet FLOAT128_TO_INT64, 1892129203Scognet FLOAT128_TO_INT64_ROUND_TO_ZERO, 1893129203Scognet FLOAT128_TO_FLOAT32, 1894129203Scognet FLOAT128_TO_FLOAT64, 1895129203Scognet#ifdef FLOATX80 1896129203Scognet FLOAT128_TO_FLOATX80, 1897129203Scognet#endif 1898129203Scognet FLOAT128_ROUND_TO_INT, 1899129203Scognet FLOAT128_ADD, 1900129203Scognet FLOAT128_SUB, 1901129203Scognet FLOAT128_MUL, 1902129203Scognet FLOAT128_DIV, 1903129203Scognet FLOAT128_REM, 1904129203Scognet FLOAT128_SQRT, 1905129203Scognet FLOAT128_EQ, 1906129203Scognet FLOAT128_LE, 1907129203Scognet FLOAT128_LT, 1908129203Scognet FLOAT128_EQ_SIGNALING, 1909129203Scognet FLOAT128_LE_QUIET, 1910129203Scognet FLOAT128_LT_QUIET, 1911129203Scognet#endif 1912129203Scognet NUM_FUNCTIONS 1913129203Scognet}; 1914129203Scognet 1915129203Scognetstatic struct { 1916129203Scognet char *name; 1917129203Scognet int8 numInputs; 1918129203Scognet flag roundingPrecision, roundingMode; 1919129203Scognet flag tininessMode, tininessModeAtReducedPrecision; 1920129203Scognet} functions[ NUM_FUNCTIONS ] = { 1921129203Scognet { 0, 0, 0, 0, 0, 0 }, 1922129203Scognet { "int32_to_float32", 1, FALSE, TRUE, FALSE, FALSE }, 1923129203Scognet { "int32_to_float64", 1, FALSE, FALSE, FALSE, FALSE }, 1924129203Scognet#ifdef FLOATX80 1925129203Scognet { "int32_to_floatx80", 1, FALSE, FALSE, FALSE, FALSE }, 1926129203Scognet#endif 1927129203Scognet#ifdef FLOAT128 1928129203Scognet { "int32_to_float128", 1, FALSE, FALSE, FALSE, FALSE }, 1929129203Scognet#endif 1930129203Scognet { "int64_to_float32", 1, FALSE, TRUE, FALSE, FALSE }, 1931129203Scognet { "int64_to_float64", 1, FALSE, TRUE, FALSE, FALSE }, 1932129203Scognet#ifdef FLOATX80 1933129203Scognet { "int64_to_floatx80", 1, FALSE, FALSE, FALSE, FALSE }, 1934129203Scognet#endif 1935129203Scognet#ifdef FLOAT128 1936129203Scognet { "int64_to_float128", 1, FALSE, FALSE, FALSE, FALSE }, 1937129203Scognet#endif 1938129203Scognet { "float32_to_int32", 1, FALSE, TRUE, FALSE, FALSE }, 1939129203Scognet { "float32_to_int32_round_to_zero", 1, FALSE, FALSE, FALSE, FALSE }, 1940129203Scognet { "float32_to_int64", 1, FALSE, TRUE, FALSE, FALSE }, 1941129203Scognet { "float32_to_int64_round_to_zero", 1, FALSE, FALSE, FALSE, FALSE }, 1942129203Scognet { "float32_to_float64", 1, FALSE, FALSE, FALSE, FALSE }, 1943129203Scognet#ifdef FLOATX80 1944129203Scognet { "float32_to_floatx80", 1, FALSE, FALSE, FALSE, FALSE }, 1945129203Scognet#endif 1946129203Scognet#ifdef FLOAT128 1947129203Scognet { "float32_to_float128", 1, FALSE, FALSE, FALSE, FALSE }, 1948129203Scognet#endif 1949129203Scognet { "float32_round_to_int", 1, FALSE, TRUE, FALSE, FALSE }, 1950129203Scognet { "float32_add", 2, FALSE, TRUE, FALSE, FALSE }, 1951129203Scognet { "float32_sub", 2, FALSE, TRUE, FALSE, FALSE }, 1952129203Scognet { "float32_mul", 2, FALSE, TRUE, TRUE, FALSE }, 1953129203Scognet { "float32_div", 2, FALSE, TRUE, FALSE, FALSE }, 1954129203Scognet { "float32_rem", 2, FALSE, FALSE, FALSE, FALSE }, 1955129203Scognet { "float32_sqrt", 1, FALSE, TRUE, FALSE, FALSE }, 1956129203Scognet { "float32_eq", 2, FALSE, FALSE, FALSE, FALSE }, 1957129203Scognet { "float32_le", 2, FALSE, FALSE, FALSE, FALSE }, 1958129203Scognet { "float32_lt", 2, FALSE, FALSE, FALSE, FALSE }, 1959129203Scognet { "float32_eq_signaling", 2, FALSE, FALSE, FALSE, FALSE }, 1960129203Scognet { "float32_le_quiet", 2, FALSE, FALSE, FALSE, FALSE }, 1961129203Scognet { "float32_lt_quiet", 2, FALSE, FALSE, FALSE, FALSE }, 1962129203Scognet { "float64_to_int32", 1, FALSE, TRUE, FALSE, FALSE }, 1963129203Scognet { "float64_to_int32_round_to_zero", 1, FALSE, FALSE, FALSE, FALSE }, 1964129203Scognet { "float64_to_int64", 1, FALSE, TRUE, FALSE, FALSE }, 1965129203Scognet { "float64_to_int64_round_to_zero", 1, FALSE, FALSE, FALSE, FALSE }, 1966129203Scognet { "float64_to_float32", 1, FALSE, TRUE, TRUE, FALSE }, 1967129203Scognet#ifdef FLOATX80 1968129203Scognet { "float64_to_floatx80", 1, FALSE, FALSE, FALSE, FALSE }, 1969129203Scognet#endif 1970129203Scognet#ifdef FLOAT128 1971129203Scognet { "float64_to_float128", 1, FALSE, FALSE, FALSE, FALSE }, 1972129203Scognet#endif 1973129203Scognet { "float64_round_to_int", 1, FALSE, TRUE, FALSE, FALSE }, 1974129203Scognet { "float64_add", 2, FALSE, TRUE, FALSE, FALSE }, 1975129203Scognet { "float64_sub", 2, FALSE, TRUE, FALSE, FALSE }, 1976129203Scognet { "float64_mul", 2, FALSE, TRUE, TRUE, FALSE }, 1977129203Scognet { "float64_div", 2, FALSE, TRUE, FALSE, FALSE }, 1978129203Scognet { "float64_rem", 2, FALSE, FALSE, FALSE, FALSE }, 1979129203Scognet { "float64_sqrt", 1, FALSE, TRUE, FALSE, FALSE }, 1980129203Scognet { "float64_eq", 2, FALSE, FALSE, FALSE, FALSE }, 1981129203Scognet { "float64_le", 2, FALSE, FALSE, FALSE, FALSE }, 1982129203Scognet { "float64_lt", 2, FALSE, FALSE, FALSE, FALSE }, 1983129203Scognet { "float64_eq_signaling", 2, FALSE, FALSE, FALSE, FALSE }, 1984129203Scognet { "float64_le_quiet", 2, FALSE, FALSE, FALSE, FALSE }, 1985129203Scognet { "float64_lt_quiet", 2, FALSE, FALSE, FALSE, FALSE }, 1986129203Scognet#ifdef FLOATX80 1987129203Scognet { "floatx80_to_int32", 1, FALSE, TRUE, FALSE, FALSE }, 1988129203Scognet { "floatx80_to_int32_round_to_zero", 1, FALSE, FALSE, FALSE, FALSE }, 1989129203Scognet { "floatx80_to_int64", 1, FALSE, TRUE, FALSE, FALSE }, 1990129203Scognet { "floatx80_to_int64_round_to_zero", 1, FALSE, FALSE, FALSE, FALSE }, 1991129203Scognet { "floatx80_to_float32", 1, FALSE, TRUE, TRUE, FALSE }, 1992129203Scognet { "floatx80_to_float64", 1, FALSE, TRUE, TRUE, FALSE }, 1993129203Scognet#ifdef FLOAT128 1994129203Scognet { "floatx80_to_float128", 1, FALSE, FALSE, FALSE, FALSE }, 1995129203Scognet#endif 1996129203Scognet { "floatx80_round_to_int", 1, FALSE, TRUE, FALSE, FALSE }, 1997129203Scognet { "floatx80_add", 2, TRUE, TRUE, FALSE, TRUE }, 1998129203Scognet { "floatx80_sub", 2, TRUE, TRUE, FALSE, TRUE }, 1999129203Scognet { "floatx80_mul", 2, TRUE, TRUE, TRUE, TRUE }, 2000129203Scognet { "floatx80_div", 2, TRUE, TRUE, FALSE, TRUE }, 2001129203Scognet { "floatx80_rem", 2, FALSE, FALSE, FALSE, FALSE }, 2002129203Scognet { "floatx80_sqrt", 1, TRUE, TRUE, FALSE, FALSE }, 2003129203Scognet { "floatx80_eq", 2, FALSE, FALSE, FALSE, FALSE }, 2004129203Scognet { "floatx80_le", 2, FALSE, FALSE, FALSE, FALSE }, 2005129203Scognet { "floatx80_lt", 2, FALSE, FALSE, FALSE, FALSE }, 2006129203Scognet { "floatx80_eq_signaling", 2, FALSE, FALSE, FALSE, FALSE }, 2007129203Scognet { "floatx80_le_quiet", 2, FALSE, FALSE, FALSE, FALSE }, 2008129203Scognet { "floatx80_lt_quiet", 2, FALSE, FALSE, FALSE, FALSE }, 2009129203Scognet#endif 2010129203Scognet#ifdef FLOAT128 2011129203Scognet { "float128_to_int32", 1, FALSE, TRUE, FALSE, FALSE }, 2012129203Scognet { "float128_to_int32_round_to_zero", 1, FALSE, FALSE, FALSE, FALSE }, 2013129203Scognet { "float128_to_int64", 1, FALSE, TRUE, FALSE, FALSE }, 2014129203Scognet { "float128_to_int64_round_to_zero", 1, FALSE, FALSE, FALSE, FALSE }, 2015129203Scognet { "float128_to_float32", 1, FALSE, TRUE, TRUE, FALSE }, 2016129203Scognet { "float128_to_float64", 1, FALSE, TRUE, TRUE, FALSE }, 2017129203Scognet#ifdef FLOATX80 2018129203Scognet { "float128_to_floatx80", 1, FALSE, TRUE, TRUE, FALSE }, 2019129203Scognet#endif 2020129203Scognet { "float128_round_to_int", 1, FALSE, TRUE, FALSE, FALSE }, 2021129203Scognet { "float128_add", 2, FALSE, TRUE, FALSE, FALSE }, 2022129203Scognet { "float128_sub", 2, FALSE, TRUE, FALSE, FALSE }, 2023129203Scognet { "float128_mul", 2, FALSE, TRUE, TRUE, FALSE }, 2024129203Scognet { "float128_div", 2, FALSE, TRUE, FALSE, FALSE }, 2025129203Scognet { "float128_rem", 2, FALSE, FALSE, FALSE, FALSE }, 2026129203Scognet { "float128_sqrt", 1, FALSE, TRUE, FALSE, FALSE }, 2027129203Scognet { "float128_eq", 2, FALSE, FALSE, FALSE, FALSE }, 2028129203Scognet { "float128_le", 2, FALSE, FALSE, FALSE, FALSE }, 2029129203Scognet { "float128_lt", 2, FALSE, FALSE, FALSE, FALSE }, 2030129203Scognet { "float128_eq_signaling", 2, FALSE, FALSE, FALSE, FALSE }, 2031129203Scognet { "float128_le_quiet", 2, FALSE, FALSE, FALSE, FALSE }, 2032129203Scognet { "float128_lt_quiet", 2, FALSE, FALSE, FALSE, FALSE }, 2033129203Scognet#endif 2034129203Scognet}; 2035129203Scognet 2036129203Scognetenum { 2037129203Scognet ROUND_NEAREST_EVEN = 1, 2038129203Scognet ROUND_TO_ZERO, 2039129203Scognet ROUND_DOWN, 2040129203Scognet ROUND_UP, 2041129203Scognet NUM_ROUNDINGMODES 2042129203Scognet}; 2043129203Scognetenum { 2044129203Scognet TININESS_BEFORE_ROUNDING = 1, 2045129203Scognet TININESS_AFTER_ROUNDING, 2046129203Scognet NUM_TININESSMODES 2047129203Scognet}; 2048129203Scognet 2049129203Scognetstatic void 2050129203Scognet timeFunctionVariety( 2051129203Scognet uint8 functionCode, 2052129203Scognet int8 roundingPrecision, 2053129203Scognet int8 roundingMode, 2054129203Scognet int8 tininessMode 2055129203Scognet ) 2056129203Scognet{ 2057129203Scognet uint8 roundingCode; 2058129203Scognet int8 tininessCode; 2059129203Scognet 2060129203Scognet functionName = functions[ functionCode ].name; 2061129203Scognet if ( roundingPrecision == 32 ) { 2062129203Scognet roundingPrecisionName = "32"; 2063129203Scognet } 2064129203Scognet else if ( roundingPrecision == 64 ) { 2065129203Scognet roundingPrecisionName = "64"; 2066129203Scognet } 2067129203Scognet else if ( roundingPrecision == 80 ) { 2068129203Scognet roundingPrecisionName = "80"; 2069129203Scognet } 2070129203Scognet else { 2071129203Scognet roundingPrecisionName = 0; 2072129203Scognet } 2073129203Scognet#ifdef FLOATX80 2074129203Scognet floatx80_rounding_precision = roundingPrecision; 2075129203Scognet#endif 2076129203Scognet switch ( roundingMode ) { 2077129203Scognet case 0: 2078129203Scognet roundingModeName = 0; 2079129203Scognet roundingCode = float_round_nearest_even; 2080129203Scognet break; 2081129203Scognet case ROUND_NEAREST_EVEN: 2082129203Scognet roundingModeName = "nearest_even"; 2083129203Scognet roundingCode = float_round_nearest_even; 2084129203Scognet break; 2085129203Scognet case ROUND_TO_ZERO: 2086129203Scognet roundingModeName = "to_zero"; 2087129203Scognet roundingCode = float_round_to_zero; 2088129203Scognet break; 2089129203Scognet case ROUND_DOWN: 2090129203Scognet roundingModeName = "down"; 2091129203Scognet roundingCode = float_round_down; 2092129203Scognet break; 2093129203Scognet case ROUND_UP: 2094129203Scognet roundingModeName = "up"; 2095129203Scognet roundingCode = float_round_up; 2096129203Scognet break; 2097129203Scognet } 2098129203Scognet float_rounding_mode = roundingCode; 2099129203Scognet switch ( tininessMode ) { 2100129203Scognet case 0: 2101129203Scognet tininessModeName = 0; 2102129203Scognet tininessCode = float_tininess_after_rounding; 2103129203Scognet break; 2104129203Scognet case TININESS_BEFORE_ROUNDING: 2105129203Scognet tininessModeName = "before"; 2106129203Scognet tininessCode = float_tininess_before_rounding; 2107129203Scognet break; 2108129203Scognet case TININESS_AFTER_ROUNDING: 2109129203Scognet tininessModeName = "after"; 2110129203Scognet tininessCode = float_tininess_after_rounding; 2111129203Scognet break; 2112129203Scognet } 2113129203Scognet float_detect_tininess = tininessCode; 2114129203Scognet switch ( functionCode ) { 2115129203Scognet case INT32_TO_FLOAT32: 2116129203Scognet time_a_int32_z_float32( int32_to_float32 ); 2117129203Scognet break; 2118129203Scognet case INT32_TO_FLOAT64: 2119129203Scognet time_a_int32_z_float64( int32_to_float64 ); 2120129203Scognet break; 2121129203Scognet#ifdef FLOATX80 2122129203Scognet case INT32_TO_FLOATX80: 2123129203Scognet time_a_int32_z_floatx80( int32_to_floatx80 ); 2124129203Scognet break; 2125129203Scognet#endif 2126129203Scognet#ifdef FLOAT128 2127129203Scognet case INT32_TO_FLOAT128: 2128129203Scognet time_a_int32_z_float128( int32_to_float128 ); 2129129203Scognet break; 2130129203Scognet#endif 2131129203Scognet case INT64_TO_FLOAT32: 2132129203Scognet time_a_int64_z_float32( int64_to_float32 ); 2133129203Scognet break; 2134129203Scognet case INT64_TO_FLOAT64: 2135129203Scognet time_a_int64_z_float64( int64_to_float64 ); 2136129203Scognet break; 2137129203Scognet#ifdef FLOATX80 2138129203Scognet case INT64_TO_FLOATX80: 2139129203Scognet time_a_int64_z_floatx80( int64_to_floatx80 ); 2140129203Scognet break; 2141129203Scognet#endif 2142129203Scognet#ifdef FLOAT128 2143129203Scognet case INT64_TO_FLOAT128: 2144129203Scognet time_a_int64_z_float128( int64_to_float128 ); 2145129203Scognet break; 2146129203Scognet#endif 2147129203Scognet case FLOAT32_TO_INT32: 2148129203Scognet time_a_float32_z_int32( float32_to_int32 ); 2149129203Scognet break; 2150129203Scognet case FLOAT32_TO_INT32_ROUND_TO_ZERO: 2151129203Scognet time_a_float32_z_int32( float32_to_int32_round_to_zero ); 2152129203Scognet break; 2153129203Scognet case FLOAT32_TO_INT64: 2154129203Scognet time_a_float32_z_int64( float32_to_int64 ); 2155129203Scognet break; 2156129203Scognet case FLOAT32_TO_INT64_ROUND_TO_ZERO: 2157129203Scognet time_a_float32_z_int64( float32_to_int64_round_to_zero ); 2158129203Scognet break; 2159129203Scognet case FLOAT32_TO_FLOAT64: 2160129203Scognet time_a_float32_z_float64( float32_to_float64 ); 2161129203Scognet break; 2162129203Scognet#ifdef FLOATX80 2163129203Scognet case FLOAT32_TO_FLOATX80: 2164129203Scognet time_a_float32_z_floatx80( float32_to_floatx80 ); 2165129203Scognet break; 2166129203Scognet#endif 2167129203Scognet#ifdef FLOAT128 2168129203Scognet case FLOAT32_TO_FLOAT128: 2169129203Scognet time_a_float32_z_float128( float32_to_float128 ); 2170129203Scognet break; 2171129203Scognet#endif 2172129203Scognet case FLOAT32_ROUND_TO_INT: 2173129203Scognet time_az_float32( float32_round_to_int ); 2174129203Scognet break; 2175129203Scognet case FLOAT32_ADD: 2176129203Scognet time_abz_float32( float32_add ); 2177129203Scognet break; 2178129203Scognet case FLOAT32_SUB: 2179129203Scognet time_abz_float32( float32_sub ); 2180129203Scognet break; 2181129203Scognet case FLOAT32_MUL: 2182129203Scognet time_abz_float32( float32_mul ); 2183129203Scognet break; 2184129203Scognet case FLOAT32_DIV: 2185129203Scognet time_abz_float32( float32_div ); 2186129203Scognet break; 2187129203Scognet case FLOAT32_REM: 2188129203Scognet time_abz_float32( float32_rem ); 2189129203Scognet break; 2190129203Scognet case FLOAT32_SQRT: 2191129203Scognet time_az_float32_pos( float32_sqrt ); 2192129203Scognet break; 2193129203Scognet case FLOAT32_EQ: 2194129203Scognet time_ab_float32_z_flag( float32_eq ); 2195129203Scognet break; 2196129203Scognet case FLOAT32_LE: 2197129203Scognet time_ab_float32_z_flag( float32_le ); 2198129203Scognet break; 2199129203Scognet case FLOAT32_LT: 2200129203Scognet time_ab_float32_z_flag( float32_lt ); 2201129203Scognet break; 2202129203Scognet case FLOAT32_EQ_SIGNALING: 2203129203Scognet time_ab_float32_z_flag( float32_eq_signaling ); 2204129203Scognet break; 2205129203Scognet case FLOAT32_LE_QUIET: 2206129203Scognet time_ab_float32_z_flag( float32_le_quiet ); 2207129203Scognet break; 2208129203Scognet case FLOAT32_LT_QUIET: 2209129203Scognet time_ab_float32_z_flag( float32_lt_quiet ); 2210129203Scognet break; 2211129203Scognet case FLOAT64_TO_INT32: 2212129203Scognet time_a_float64_z_int32( float64_to_int32 ); 2213129203Scognet break; 2214129203Scognet case FLOAT64_TO_INT32_ROUND_TO_ZERO: 2215129203Scognet time_a_float64_z_int32( float64_to_int32_round_to_zero ); 2216129203Scognet break; 2217129203Scognet case FLOAT64_TO_INT64: 2218129203Scognet time_a_float64_z_int64( float64_to_int64 ); 2219129203Scognet break; 2220129203Scognet case FLOAT64_TO_INT64_ROUND_TO_ZERO: 2221129203Scognet time_a_float64_z_int64( float64_to_int64_round_to_zero ); 2222129203Scognet break; 2223129203Scognet case FLOAT64_TO_FLOAT32: 2224129203Scognet time_a_float64_z_float32( float64_to_float32 ); 2225129203Scognet break; 2226129203Scognet#ifdef FLOATX80 2227129203Scognet case FLOAT64_TO_FLOATX80: 2228129203Scognet time_a_float64_z_floatx80( float64_to_floatx80 ); 2229129203Scognet break; 2230129203Scognet#endif 2231129203Scognet#ifdef FLOAT128 2232129203Scognet case FLOAT64_TO_FLOAT128: 2233129203Scognet time_a_float64_z_float128( float64_to_float128 ); 2234129203Scognet break; 2235129203Scognet#endif 2236129203Scognet case FLOAT64_ROUND_TO_INT: 2237129203Scognet time_az_float64( float64_round_to_int ); 2238129203Scognet break; 2239129203Scognet case FLOAT64_ADD: 2240129203Scognet time_abz_float64( float64_add ); 2241129203Scognet break; 2242129203Scognet case FLOAT64_SUB: 2243129203Scognet time_abz_float64( float64_sub ); 2244129203Scognet break; 2245129203Scognet case FLOAT64_MUL: 2246129203Scognet time_abz_float64( float64_mul ); 2247129203Scognet break; 2248129203Scognet case FLOAT64_DIV: 2249129203Scognet time_abz_float64( float64_div ); 2250129203Scognet break; 2251129203Scognet case FLOAT64_REM: 2252129203Scognet time_abz_float64( float64_rem ); 2253129203Scognet break; 2254129203Scognet case FLOAT64_SQRT: 2255129203Scognet time_az_float64_pos( float64_sqrt ); 2256129203Scognet break; 2257129203Scognet case FLOAT64_EQ: 2258129203Scognet time_ab_float64_z_flag( float64_eq ); 2259129203Scognet break; 2260129203Scognet case FLOAT64_LE: 2261129203Scognet time_ab_float64_z_flag( float64_le ); 2262129203Scognet break; 2263129203Scognet case FLOAT64_LT: 2264129203Scognet time_ab_float64_z_flag( float64_lt ); 2265129203Scognet break; 2266129203Scognet case FLOAT64_EQ_SIGNALING: 2267129203Scognet time_ab_float64_z_flag( float64_eq_signaling ); 2268129203Scognet break; 2269129203Scognet case FLOAT64_LE_QUIET: 2270129203Scognet time_ab_float64_z_flag( float64_le_quiet ); 2271129203Scognet break; 2272129203Scognet case FLOAT64_LT_QUIET: 2273129203Scognet time_ab_float64_z_flag( float64_lt_quiet ); 2274129203Scognet break; 2275129203Scognet#ifdef FLOATX80 2276129203Scognet case FLOATX80_TO_INT32: 2277129203Scognet time_a_floatx80_z_int32( floatx80_to_int32 ); 2278129203Scognet break; 2279129203Scognet case FLOATX80_TO_INT32_ROUND_TO_ZERO: 2280129203Scognet time_a_floatx80_z_int32( floatx80_to_int32_round_to_zero ); 2281129203Scognet break; 2282129203Scognet case FLOATX80_TO_INT64: 2283129203Scognet time_a_floatx80_z_int64( floatx80_to_int64 ); 2284129203Scognet break; 2285129203Scognet case FLOATX80_TO_INT64_ROUND_TO_ZERO: 2286129203Scognet time_a_floatx80_z_int64( floatx80_to_int64_round_to_zero ); 2287129203Scognet break; 2288129203Scognet case FLOATX80_TO_FLOAT32: 2289129203Scognet time_a_floatx80_z_float32( floatx80_to_float32 ); 2290129203Scognet break; 2291129203Scognet case FLOATX80_TO_FLOAT64: 2292129203Scognet time_a_floatx80_z_float64( floatx80_to_float64 ); 2293129203Scognet break; 2294129203Scognet#ifdef FLOAT128 2295129203Scognet case FLOATX80_TO_FLOAT128: 2296129203Scognet time_a_floatx80_z_float128( floatx80_to_float128 ); 2297129203Scognet break; 2298129203Scognet#endif 2299129203Scognet case FLOATX80_ROUND_TO_INT: 2300129203Scognet time_az_floatx80( floatx80_round_to_int ); 2301129203Scognet break; 2302129203Scognet case FLOATX80_ADD: 2303129203Scognet time_abz_floatx80( floatx80_add ); 2304129203Scognet break; 2305129203Scognet case FLOATX80_SUB: 2306129203Scognet time_abz_floatx80( floatx80_sub ); 2307129203Scognet break; 2308129203Scognet case FLOATX80_MUL: 2309129203Scognet time_abz_floatx80( floatx80_mul ); 2310129203Scognet break; 2311129203Scognet case FLOATX80_DIV: 2312129203Scognet time_abz_floatx80( floatx80_div ); 2313129203Scognet break; 2314129203Scognet case FLOATX80_REM: 2315129203Scognet time_abz_floatx80( floatx80_rem ); 2316129203Scognet break; 2317129203Scognet case FLOATX80_SQRT: 2318129203Scognet time_az_floatx80_pos( floatx80_sqrt ); 2319129203Scognet break; 2320129203Scognet case FLOATX80_EQ: 2321129203Scognet time_ab_floatx80_z_flag( floatx80_eq ); 2322129203Scognet break; 2323129203Scognet case FLOATX80_LE: 2324129203Scognet time_ab_floatx80_z_flag( floatx80_le ); 2325129203Scognet break; 2326129203Scognet case FLOATX80_LT: 2327129203Scognet time_ab_floatx80_z_flag( floatx80_lt ); 2328129203Scognet break; 2329129203Scognet case FLOATX80_EQ_SIGNALING: 2330129203Scognet time_ab_floatx80_z_flag( floatx80_eq_signaling ); 2331129203Scognet break; 2332129203Scognet case FLOATX80_LE_QUIET: 2333129203Scognet time_ab_floatx80_z_flag( floatx80_le_quiet ); 2334129203Scognet break; 2335129203Scognet case FLOATX80_LT_QUIET: 2336129203Scognet time_ab_floatx80_z_flag( floatx80_lt_quiet ); 2337129203Scognet break; 2338129203Scognet#endif 2339129203Scognet#ifdef FLOAT128 2340129203Scognet case FLOAT128_TO_INT32: 2341129203Scognet time_a_float128_z_int32( float128_to_int32 ); 2342129203Scognet break; 2343129203Scognet case FLOAT128_TO_INT32_ROUND_TO_ZERO: 2344129203Scognet time_a_float128_z_int32( float128_to_int32_round_to_zero ); 2345129203Scognet break; 2346129203Scognet case FLOAT128_TO_INT64: 2347129203Scognet time_a_float128_z_int64( float128_to_int64 ); 2348129203Scognet break; 2349129203Scognet case FLOAT128_TO_INT64_ROUND_TO_ZERO: 2350129203Scognet time_a_float128_z_int64( float128_to_int64_round_to_zero ); 2351129203Scognet break; 2352129203Scognet case FLOAT128_TO_FLOAT32: 2353129203Scognet time_a_float128_z_float32( float128_to_float32 ); 2354129203Scognet break; 2355129203Scognet case FLOAT128_TO_FLOAT64: 2356129203Scognet time_a_float128_z_float64( float128_to_float64 ); 2357129203Scognet break; 2358129203Scognet#ifdef FLOATX80 2359129203Scognet case FLOAT128_TO_FLOATX80: 2360129203Scognet time_a_float128_z_floatx80( float128_to_floatx80 ); 2361129203Scognet break; 2362129203Scognet#endif 2363129203Scognet case FLOAT128_ROUND_TO_INT: 2364129203Scognet time_az_float128( float128_round_to_int ); 2365129203Scognet break; 2366129203Scognet case FLOAT128_ADD: 2367129203Scognet time_abz_float128( float128_add ); 2368129203Scognet break; 2369129203Scognet case FLOAT128_SUB: 2370129203Scognet time_abz_float128( float128_sub ); 2371129203Scognet break; 2372129203Scognet case FLOAT128_MUL: 2373129203Scognet time_abz_float128( float128_mul ); 2374129203Scognet break; 2375129203Scognet case FLOAT128_DIV: 2376129203Scognet time_abz_float128( float128_div ); 2377129203Scognet break; 2378129203Scognet case FLOAT128_REM: 2379129203Scognet time_abz_float128( float128_rem ); 2380129203Scognet break; 2381129203Scognet case FLOAT128_SQRT: 2382129203Scognet time_az_float128_pos( float128_sqrt ); 2383129203Scognet break; 2384129203Scognet case FLOAT128_EQ: 2385129203Scognet time_ab_float128_z_flag( float128_eq ); 2386129203Scognet break; 2387129203Scognet case FLOAT128_LE: 2388129203Scognet time_ab_float128_z_flag( float128_le ); 2389129203Scognet break; 2390129203Scognet case FLOAT128_LT: 2391129203Scognet time_ab_float128_z_flag( float128_lt ); 2392129203Scognet break; 2393129203Scognet case FLOAT128_EQ_SIGNALING: 2394129203Scognet time_ab_float128_z_flag( float128_eq_signaling ); 2395129203Scognet break; 2396129203Scognet case FLOAT128_LE_QUIET: 2397129203Scognet time_ab_float128_z_flag( float128_le_quiet ); 2398129203Scognet break; 2399129203Scognet case FLOAT128_LT_QUIET: 2400129203Scognet time_ab_float128_z_flag( float128_lt_quiet ); 2401129203Scognet break; 2402129203Scognet#endif 2403129203Scognet } 2404129203Scognet 2405129203Scognet} 2406129203Scognet 2407129203Scognetstatic void 2408129203Scognet timeFunction( 2409129203Scognet uint8 functionCode, 2410129203Scognet int8 roundingPrecisionIn, 2411129203Scognet int8 roundingModeIn, 2412129203Scognet int8 tininessModeIn 2413129203Scognet ) 2414129203Scognet{ 2415129203Scognet int8 roundingPrecision, roundingMode, tininessMode; 2416129203Scognet 2417129203Scognet roundingPrecision = 32; 2418129203Scognet for (;;) { 2419129203Scognet if ( ! functions[ functionCode ].roundingPrecision ) { 2420129203Scognet roundingPrecision = 0; 2421129203Scognet } 2422129203Scognet else if ( roundingPrecisionIn ) { 2423129203Scognet roundingPrecision = roundingPrecisionIn; 2424129203Scognet } 2425129203Scognet for ( roundingMode = 1; 2426129203Scognet roundingMode < NUM_ROUNDINGMODES; 2427129203Scognet ++roundingMode 2428129203Scognet ) { 2429129203Scognet if ( ! functions[ functionCode ].roundingMode ) { 2430129203Scognet roundingMode = 0; 2431129203Scognet } 2432129203Scognet else if ( roundingModeIn ) { 2433129203Scognet roundingMode = roundingModeIn; 2434129203Scognet } 2435129203Scognet for ( tininessMode = 1; 2436129203Scognet tininessMode < NUM_TININESSMODES; 2437129203Scognet ++tininessMode 2438129203Scognet ) { 2439129203Scognet if ( ( roundingPrecision == 32 ) 2440129203Scognet || ( roundingPrecision == 64 ) ) { 2441129203Scognet if ( ! functions[ functionCode ] 2442129203Scognet .tininessModeAtReducedPrecision 2443129203Scognet ) { 2444129203Scognet tininessMode = 0; 2445129203Scognet } 2446129203Scognet else if ( tininessModeIn ) { 2447129203Scognet tininessMode = tininessModeIn; 2448129203Scognet } 2449129203Scognet } 2450129203Scognet else { 2451129203Scognet if ( ! functions[ functionCode ].tininessMode ) { 2452129203Scognet tininessMode = 0; 2453129203Scognet } 2454129203Scognet else if ( tininessModeIn ) { 2455129203Scognet tininessMode = tininessModeIn; 2456129203Scognet } 2457129203Scognet } 2458129203Scognet timeFunctionVariety( 2459129203Scognet functionCode, roundingPrecision, roundingMode, tininessMode 2460129203Scognet ); 2461129203Scognet if ( tininessModeIn || ! tininessMode ) break; 2462129203Scognet } 2463129203Scognet if ( roundingModeIn || ! roundingMode ) break; 2464129203Scognet } 2465129203Scognet if ( roundingPrecisionIn || ! roundingPrecision ) break; 2466129203Scognet if ( roundingPrecision == 80 ) { 2467129203Scognet break; 2468129203Scognet } 2469129203Scognet else if ( roundingPrecision == 64 ) { 2470129203Scognet roundingPrecision = 80; 2471129203Scognet } 2472129203Scognet else if ( roundingPrecision == 32 ) { 2473129203Scognet roundingPrecision = 64; 2474129203Scognet } 2475129203Scognet } 2476129203Scognet 2477129203Scognet} 2478129203Scognet 2479129203Scognetmain( int argc, char **argv ) 2480129203Scognet{ 2481129203Scognet char *argPtr; 2482129203Scognet flag functionArgument; 2483129203Scognet uint8 functionCode; 2484129203Scognet int8 operands, roundingPrecision, roundingMode, tininessMode; 2485129203Scognet 2486129203Scognet if ( argc <= 1 ) goto writeHelpMessage; 2487129203Scognet functionArgument = FALSE; 2488129203Scognet functionCode = 0; 2489129203Scognet operands = 0; 2490129203Scognet roundingPrecision = 0; 2491129203Scognet roundingMode = 0; 2492129203Scognet tininessMode = 0; 2493129203Scognet --argc; 2494129203Scognet ++argv; 2495129203Scognet while ( argc && ( argPtr = argv[ 0 ] ) ) { 2496129203Scognet if ( argPtr[ 0 ] == '-' ) ++argPtr; 2497129203Scognet if ( strcmp( argPtr, "help" ) == 0 ) { 2498129203Scognet writeHelpMessage: 2499129203Scognet fputs( 2500129203Scognet"timesoftfloat [<option>...] <function>\n" 2501129203Scognet" <option>: (* is default)\n" 2502129203Scognet" -help --Write this message and exit.\n" 2503129203Scognet#ifdef FLOATX80 2504129203Scognet" -precision32 --Only time rounding precision equivalent to float32.\n" 2505129203Scognet" -precision64 --Only time rounding precision equivalent to float64.\n" 2506129203Scognet" -precision80 --Only time maximum rounding precision.\n" 2507129203Scognet#endif 2508129203Scognet" -nearesteven --Only time rounding to nearest/even.\n" 2509129203Scognet" -tozero --Only time rounding to zero.\n" 2510129203Scognet" -down --Only time rounding down.\n" 2511129203Scognet" -up --Only time rounding up.\n" 2512129203Scognet" -tininessbefore --Only time underflow tininess before rounding.\n" 2513129203Scognet" -tininessafter --Only time underflow tininess after rounding.\n" 2514129203Scognet" <function>:\n" 2515129203Scognet" int32_to_<float> <float>_add <float>_eq\n" 2516129203Scognet" <float>_to_int32 <float>_sub <float>_le\n" 2517129203Scognet" <float>_to_int32_round_to_zero <float>_mul <float>_lt\n" 2518129203Scognet" int64_to_<float> <float>_div <float>_eq_signaling\n" 2519129203Scognet" <float>_to_int64 <float>_rem <float>_le_quiet\n" 2520129203Scognet" <float>_to_int64_round_to_zero <float>_lt_quiet\n" 2521129203Scognet" <float>_to_<float>\n" 2522129203Scognet" <float>_round_to_int\n" 2523129203Scognet" <float>_sqrt\n" 2524129203Scognet" -all1 --All 1-operand functions.\n" 2525129203Scognet" -all2 --All 2-operand functions.\n" 2526129203Scognet" -all --All functions.\n" 2527129203Scognet" <float>:\n" 2528129203Scognet" float32 --Single precision.\n" 2529129203Scognet" float64 --Double precision.\n" 2530129203Scognet#ifdef FLOATX80 2531129203Scognet" floatx80 --Extended double precision.\n" 2532129203Scognet#endif 2533129203Scognet#ifdef FLOAT128 2534129203Scognet" float128 --Quadruple precision.\n" 2535129203Scognet#endif 2536129203Scognet , 2537129203Scognet stdout 2538129203Scognet ); 2539129203Scognet return EXIT_SUCCESS; 2540129203Scognet } 2541129203Scognet#ifdef FLOATX80 2542129203Scognet else if ( strcmp( argPtr, "precision32" ) == 0 ) { 2543129203Scognet roundingPrecision = 32; 2544129203Scognet } 2545129203Scognet else if ( strcmp( argPtr, "precision64" ) == 0 ) { 2546129203Scognet roundingPrecision = 64; 2547129203Scognet } 2548129203Scognet else if ( strcmp( argPtr, "precision80" ) == 0 ) { 2549129203Scognet roundingPrecision = 80; 2550129203Scognet } 2551129203Scognet#endif 2552129203Scognet else if ( ( strcmp( argPtr, "nearesteven" ) == 0 ) 2553129203Scognet || ( strcmp( argPtr, "nearest_even" ) == 0 ) ) { 2554129203Scognet roundingMode = ROUND_NEAREST_EVEN; 2555129203Scognet } 2556129203Scognet else if ( ( strcmp( argPtr, "tozero" ) == 0 ) 2557129203Scognet || ( strcmp( argPtr, "to_zero" ) == 0 ) ) { 2558129203Scognet roundingMode = ROUND_TO_ZERO; 2559129203Scognet } 2560129203Scognet else if ( strcmp( argPtr, "down" ) == 0 ) { 2561129203Scognet roundingMode = ROUND_DOWN; 2562129203Scognet } 2563129203Scognet else if ( strcmp( argPtr, "up" ) == 0 ) { 2564129203Scognet roundingMode = ROUND_UP; 2565129203Scognet } 2566129203Scognet else if ( strcmp( argPtr, "tininessbefore" ) == 0 ) { 2567129203Scognet tininessMode = TININESS_BEFORE_ROUNDING; 2568129203Scognet } 2569129203Scognet else if ( strcmp( argPtr, "tininessafter" ) == 0 ) { 2570129203Scognet tininessMode = TININESS_AFTER_ROUNDING; 2571129203Scognet } 2572129203Scognet else if ( strcmp( argPtr, "all1" ) == 0 ) { 2573129203Scognet functionArgument = TRUE; 2574129203Scognet functionCode = 0; 2575129203Scognet operands = 1; 2576129203Scognet } 2577129203Scognet else if ( strcmp( argPtr, "all2" ) == 0 ) { 2578129203Scognet functionArgument = TRUE; 2579129203Scognet functionCode = 0; 2580129203Scognet operands = 2; 2581129203Scognet } 2582129203Scognet else if ( strcmp( argPtr, "all" ) == 0 ) { 2583129203Scognet functionArgument = TRUE; 2584129203Scognet functionCode = 0; 2585129203Scognet operands = 0; 2586129203Scognet } 2587129203Scognet else { 2588129203Scognet for ( functionCode = 1; 2589129203Scognet functionCode < NUM_FUNCTIONS; 2590129203Scognet ++functionCode 2591129203Scognet ) { 2592129203Scognet if ( strcmp( argPtr, functions[ functionCode ].name ) == 0 ) { 2593129203Scognet break; 2594129203Scognet } 2595129203Scognet } 2596129203Scognet if ( functionCode == NUM_FUNCTIONS ) { 2597129203Scognet fail( "Invalid option or function `%s'", argv[ 0 ] ); 2598129203Scognet } 2599129203Scognet functionArgument = TRUE; 2600129203Scognet } 2601129203Scognet --argc; 2602129203Scognet ++argv; 2603129203Scognet } 2604129203Scognet if ( ! functionArgument ) fail( "Function argument required" ); 2605129203Scognet if ( functionCode ) { 2606129203Scognet timeFunction( 2607129203Scognet functionCode, roundingPrecision, roundingMode, tininessMode ); 2608129203Scognet } 2609129203Scognet else if ( operands == 1 ) { 2610129203Scognet for ( functionCode = 1; functionCode < NUM_FUNCTIONS; ++functionCode 2611129203Scognet ) { 2612129203Scognet if ( functions[ functionCode ].numInputs == 1 ) { 2613129203Scognet timeFunction( 2614129203Scognet functionCode, roundingPrecision, roundingMode, tininessMode 2615129203Scognet ); 2616129203Scognet } 2617129203Scognet } 2618129203Scognet } 2619129203Scognet else if ( operands == 2 ) { 2620129203Scognet for ( functionCode = 1; functionCode < NUM_FUNCTIONS; ++functionCode 2621129203Scognet ) { 2622129203Scognet if ( functions[ functionCode ].numInputs == 2 ) { 2623129203Scognet timeFunction( 2624129203Scognet functionCode, roundingPrecision, roundingMode, tininessMode 2625129203Scognet ); 2626129203Scognet } 2627129203Scognet } 2628129203Scognet } 2629129203Scognet else { 2630129203Scognet for ( functionCode = 1; functionCode < NUM_FUNCTIONS; ++functionCode 2631129203Scognet ) { 2632129203Scognet timeFunction( 2633129203Scognet functionCode, roundingPrecision, roundingMode, tininessMode ); 2634129203Scognet } 2635129203Scognet } 2636129203Scognet return EXIT_SUCCESS; 2637129203Scognet 2638129203Scognet} 2639129203Scognet 2640