/////////////////////////////////////////////////////////////////////
|
/////////////////////////////////////////////////////////////////////
|
//// ////
|
//// ////
|
//// fptpg.c ////
|
//// fptpg.c ////
|
//// Floating Point Test Pattern Generator ////
|
//// Floating Point Test Pattern Generator ////
|
//// ////
|
//// ////
|
//// Author: Rudolf Usselmann ////
|
//// Author: Rudolf Usselmann ////
|
//// russelmann@hotmail.com ////
|
//// russelmann@hotmail.com ////
|
//// ////
|
//// ////
|
/////////////////////////////////////////////////////////////////////
|
/////////////////////////////////////////////////////////////////////
|
//// ////
|
//// ////
|
//// Copyright (C) 2000 Rudolf Usselmann ////
|
//// Copyright (C) 2000 Rudolf Usselmann ////
|
//// russelmann@hotmail.com ////
|
//// russelmann@hotmail.com ////
|
//// ////
|
//// ////
|
//// This source file may be used and distributed without ////
|
//// This source file may be used and distributed without ////
|
//// restriction provided that this copyright statement is not ////
|
//// restriction provided that this copyright statement is not ////
|
//// removed from the file and that any derivative work contains ////
|
//// removed from the file and that any derivative work contains ////
|
//// the original copyright notice and the associated disclaimer.////
|
//// the original copyright notice and the associated disclaimer.////
|
//// ////
|
//// ////
|
//// THIS SOURCE FILE IS PROVIDED "AS IS" AND WITHOUT ANY ////
|
//// THIS SOURCE FILE IS PROVIDED "AS IS" AND WITHOUT ANY ////
|
//// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT ////
|
//// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT ////
|
//// LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND ////
|
//// LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND ////
|
//// FITNESS FOR A PARTICULAR PURPOSE. ////
|
//// FITNESS FOR A PARTICULAR PURPOSE. ////
|
//// ////
|
//// ////
|
/////////////////////////////////////////////////////////////////////
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
|
#include "milieu.h"
|
#include "milieu.h"
|
#include "softfloat.h"
|
#include "softfloat.h"
|
|
|
// Global vars ...
|
// Global vars ...
|
int verb=0;
|
int verb=0;
|
int quiet=0;
|
int quiet=0;
|
int pat=0;
|
int pat=0;
|
int large=0;
|
int large=0;
|
int append=0;
|
int append=0;
|
int rall=0;
|
int rall=0;
|
int fcmp=0;
|
int fcmp=0;
|
char *ofile=0;
|
char *ofile=0;
|
|
|
// Prototypes ...
|
// Prototypes ...
|
float32 get_fp();
|
float32 get_fp();
|
int arop(int , int );
|
int arop(int , int );
|
float32 get_pat(int );
|
float32 get_pat(int );
|
float32 get_pat0(int );
|
float32 get_pat0(int );
|
float32 get_pat1(int );
|
float32 get_pat1(int );
|
float32 get_pat2(int );
|
float32 get_pat2(int );
|
|
|
|
|
main(int argc, char **argv)
|
main(int argc, char **argv)
|
{
|
{
|
int i;
|
int i;
|
int count=25;
|
int count=25;
|
int ar = 0;
|
int ar = 0;
|
int seed = 12345678;
|
int seed = 12345678;
|
|
|
float_rounding_mode = float_round_nearest_even; // Default Rounding Mode
|
float_rounding_mode = float_round_nearest_even; // Default Rounding Mode
|
|
|
if(argc<2) {
|
if(argc<2) {
|
printf("Usage:\n");
|
printf("Usage:\n");
|
printf(" -n <count> Specifies the number of tests\n");
|
printf(" -n <count> Specifies the number of tests\n");
|
printf(" vectors to generate. Default: 25.\n");
|
printf(" vectors to generate. Default: 25.\n");
|
printf(" -v Verbose\n");
|
printf(" -v Verbose\n");
|
printf(" -q Quiet\n");
|
printf(" -q Quiet\n");
|
printf(" -a Append to output file name. Default: Overwrite\n");
|
printf(" -a Append to output file name. Default: Overwrite\n");
|
printf(" -l Use large numbers\n");
|
printf(" -l Use large numbers\n");
|
printf(" -p N Use built in patterns. N=Patter Number:\n");
|
printf(" -p N Use built in patterns. N=Patter Number:\n");
|
printf(" 0 = Min/Max Bit patters, normalized numbers only (Max 92416 Vectors)\n");
|
printf(" 0 = Min/Max Bit patters, normalized numbers only (Max 92416 Vectors)\n");
|
printf(" 1 = Min/Max Bit patters, including denormalized numbers (Max 92416 Vectors)\n");
|
printf(" 1 = Min/Max Bit patters, including denormalized numbers (Max 92416 Vectors)\n");
|
printf(" 2 = Bit patterns test vectors (Max 15376 Vectors)\n");
|
printf(" 2 = Bit patterns test vectors (Max 15376 Vectors)\n");
|
printf(" -o <filename> Dump patterns to <filename>\n");
|
printf(" -o <filename> Dump patterns to <filename>\n");
|
printf(" -r N Round Option. Where N is one of:\n");
|
printf(" -r N Round Option. Where N is one of:\n");
|
printf(" 0 = float_round_nearest_eve (Default)\n");
|
printf(" 0 = float_round_nearest_eve (Default)\n");
|
printf(" 1 = float_round_down\n");
|
printf(" 1 = float_round_down\n");
|
printf(" 2 = float_round_up\n");
|
printf(" 2 = float_round_up\n");
|
printf(" 3 = float_round_to_zero\n");
|
printf(" 3 = float_round_to_zero\n");
|
printf(" -m N Generate Test patters for operation N.\n");
|
printf(" -m N Generate Test patters for operation N.\n");
|
printf(" Where N is a combination of:\n");
|
printf(" Where N is a combination of:\n");
|
printf(" 1 = Add operations\n");
|
printf(" 1 = Add operations\n");
|
printf(" 2 = Subtract Operations\n");
|
printf(" 2 = Subtract Operations\n");
|
printf(" 4 = Multiply Operations\n");
|
printf(" 4 = Multiply Operations\n");
|
printf(" 8 = Divide operations\n");
|
printf(" 8 = Divide operations\n");
|
printf(" 16 = Integer to Floating Point Conversion\n");
|
printf(" 16 = Integer to Floating Point Conversion\n");
|
printf(" 32 = Floating Point to Integer Conversion\n");
|
printf(" 32 = Floating Point to Integer Conversion\n");
|
printf(" 64 = Remainder Function\n");
|
printf(" 64 = Remainder Function\n");
|
printf(" -s N Use N as seed for rand() functions.\n");
|
printf(" -s N Use N as seed for rand() functions.\n");
|
printf(" -R Randomize rounding mode.\n");
|
printf(" -R Randomize rounding mode.\n");
|
return(0);
|
return(0);
|
}
|
}
|
|
|
i=1;
|
i=1;
|
|
|
while((argc-1)>=i) {
|
while((argc-1)>=i) {
|
if(strcmp(argv[i],"-fcmp")==0) fcmp=1;
|
if(strcmp(argv[i],"-fcmp")==0) fcmp=1;
|
else
|
else
|
if(strcmp(argv[i],"-v")==0) verb=1;
|
if(strcmp(argv[i],"-v")==0) verb=1;
|
else
|
else
|
if(strcmp(argv[i],"-q")==0) quiet=1;
|
if(strcmp(argv[i],"-q")==0) quiet=1;
|
else
|
else
|
if(strcmp(argv[i],"-R")==0) rall=1;
|
if(strcmp(argv[i],"-R")==0) rall=1;
|
else
|
else
|
if(strcmp(argv[i],"-p")==0) {
|
if(strcmp(argv[i],"-p")==0) {
|
i++;
|
i++;
|
pat = atoi(argv[i]) + 1;
|
pat = atoi(argv[i]) + 1;
|
if(pat>3 | pat<0) {
|
if(pat>3 | pat<0) {
|
printf("ERROR: 'pattern' out of range (%0d), resetting to pattern 0.\n",pat);
|
printf("ERROR: 'pattern' out of range (%0d), resetting to pattern 0.\n",pat);
|
pat = 1;
|
pat = 1;
|
}
|
}
|
}
|
}
|
else
|
else
|
if(strcmp(argv[i],"-l")==0) large=1;
|
if(strcmp(argv[i],"-l")==0) large=1;
|
else
|
else
|
if(strcmp(argv[i],"-ll")==0) large=2;
|
if(strcmp(argv[i],"-ll")==0) large=2;
|
else
|
else
|
if(strcmp(argv[i],"-a")==0) append=1;
|
if(strcmp(argv[i],"-a")==0) append=1;
|
else
|
else
|
if(strcmp(argv[i],"-n")==0) {
|
if(strcmp(argv[i],"-n")==0) {
|
i++;
|
i++;
|
count = atoi(argv[i]);
|
count = atoi(argv[i]);
|
if(count<0 | count>1000000) {
|
if(count<0 | count>1000000) {
|
printf("ERROR: 'count' out of range (%0d), resetting to default.\n",count);
|
printf("ERROR: 'count' out of range (%0d), resetting to default.\n",count);
|
count=25;
|
count=25;
|
}
|
}
|
}
|
}
|
else
|
else
|
if(strcmp(argv[i],"-o")==0) {
|
if(strcmp(argv[i],"-o")==0) {
|
i++;
|
i++;
|
ofile = argv[i];
|
ofile = argv[i];
|
}
|
}
|
else
|
else
|
if(strcmp(argv[i],"-m")==0) {
|
if(strcmp(argv[i],"-m")==0) {
|
i++;
|
i++;
|
ar = atoi(argv[i]);
|
ar = atoi(argv[i]);
|
}
|
}
|
else
|
else
|
if(strcmp(argv[i],"-r")==0) {
|
if(strcmp(argv[i],"-r")==0) {
|
i++;
|
i++;
|
float_rounding_mode = atoi(argv[i]);
|
float_rounding_mode = atoi(argv[i]);
|
}
|
}
|
else
|
else
|
if(strcmp(argv[i],"-s")==0) {
|
if(strcmp(argv[i],"-s")==0) {
|
i++;
|
i++;
|
seed = atoi(argv[i]);
|
seed = atoi(argv[i]);
|
}
|
}
|
else
|
else
|
printf("Unknown Option: %s\n\n",argv[i]);
|
printf("Unknown Option: %s\n\n",argv[i]);
|
i++;
|
i++;
|
}
|
}
|
|
|
srand( seed );
|
srand( seed );
|
|
|
if(!quiet) {
|
if(!quiet) {
|
printf("\n Floating Point Test Vector Generation V1.7\n");
|
printf("\n Floating Point Test Vector Generation V1.7\n");
|
printf("\t by Rudolf Usselmann rudi@asics.ws\n\n");
|
printf("\t by Rudolf Usselmann rudi@asics.ws\n\n");
|
|
|
switch(float_rounding_mode) {
|
switch(float_rounding_mode) {
|
case 0: printf("Rounding mode: float_round_nearest_even\n"); break;
|
case 0: printf("Rounding mode: float_round_nearest_even\n"); break;
|
case 1: printf("Rounding mode: float_round_down\n"); break;
|
case 1: printf("Rounding mode: float_round_down\n"); break;
|
case 2: printf("Rounding mode: float_round_up\n"); break;
|
case 2: printf("Rounding mode: float_round_up\n"); break;
|
case 3: printf("Rounding mode: float_round_to_zero\n"); break;
|
case 3: printf("Rounding mode: float_round_to_zero\n"); break;
|
|
|
default: printf("Rounding mode: Unknown (%0d)\n", float_rounding_mode ); break;
|
default: printf("Rounding mode: Unknown (%0d)\n", float_rounding_mode ); break;
|
}
|
}
|
}
|
}
|
|
|
if(count==25) {
|
if(count==25) {
|
|
|
if( (ar & 0x10) | (ar & 0x20) ) {
|
if( (ar & 0x10) | (ar & 0x20) ) {
|
|
|
if(pat==1) count = 304;
|
if(pat==1) count = 304;
|
else
|
else
|
if(pat==2) count = 304;
|
if(pat==2) count = 304;
|
else
|
else
|
if(pat==3) count = 124;
|
if(pat==3) count = 124;
|
|
|
} else {
|
} else {
|
|
|
if(pat==1) count = 92416;
|
if(pat==1) count = 92416;
|
else
|
else
|
if(pat==2) count = 92416;
|
if(pat==2) count = 92416;
|
else
|
else
|
if(pat==3) count = 15376;
|
if(pat==3) count = 15376;
|
|
|
}
|
}
|
|
|
}
|
}
|
|
|
if(ar) arop(count,ar);
|
if(ar) arop(count,ar);
|
if(fcmp) do_fcmp(count);
|
if(fcmp) do_fcmp(count);
|
|
|
return(0);
|
return(0);
|
}
|
}
|
|
|
|
|
int arop(int count, int op) {
|
int arop(int count, int op) {
|
float32 f1, f2, f3, f4;
|
float32 f1, f2, f3, f4;
|
int i;
|
int i;
|
int fp;
|
int fp;
|
char *mode;
|
char *mode;
|
int add=0;
|
int add=0;
|
int sub=0;
|
int sub=0;
|
int mul=0;
|
int mul=0;
|
int div=0;
|
int div=0;
|
int i2f=0;
|
int i2f=0;
|
int f2i=0;
|
int f2i=0;
|
int rem=0;
|
int rem=0;
|
int oper;
|
int oper;
|
int err;
|
int err;
|
int err_count=0;
|
int err_count=0;
|
int tmp;
|
int tmp;
|
|
|
if(!quiet) printf("\nGenerating %0d Arithmetic test vectors ...\n",count);
|
if(!quiet) printf("\nGenerating %0d Arithmetic test vectors ...\n",count);
|
|
|
if(append) mode = "a";
|
if(append) mode = "a";
|
else mode = "w";
|
else mode = "w";
|
if(ofile==0) ofile = "ar.hex";
|
if(ofile==0) ofile = "ar.hex";
|
|
|
fp = fopen(ofile,mode);
|
fp = fopen(ofile,mode);
|
if(fp == 0) {
|
if(fp == 0) {
|
printf("ERROR: Could not create file '%s'.\n",ofile);
|
printf("ERROR: Could not create file '%s'.\n",ofile);
|
return(-1);
|
return(-1);
|
}
|
}
|
|
|
if(!quiet) {
|
if(!quiet) {
|
if(op & 0x01) printf("Add OP\n");
|
if(op & 0x01) printf("Add OP\n");
|
if(op & 0x02) printf("Sub OP\n");
|
if(op & 0x02) printf("Sub OP\n");
|
if(op & 0x04) printf("Mul OP\n");
|
if(op & 0x04) printf("Mul OP\n");
|
if(op & 0x08) printf("Div OP\n");
|
if(op & 0x08) printf("Div OP\n");
|
if(op & 0x10) printf("int2float\n");
|
if(op & 0x10) printf("int2float\n");
|
if(op & 0x20) printf("float2int\n");
|
if(op & 0x20) printf("float2int\n");
|
if(op & 0x40) printf("Remainder\n");
|
if(op & 0x40) printf("Remainder\n");
|
}
|
}
|
|
|
if(op & 0x01) add=1;
|
if(op & 0x01) add=1;
|
if(op & 0x02) sub=1;
|
if(op & 0x02) sub=1;
|
if(op & 0x04) mul=1;
|
if(op & 0x04) mul=1;
|
if(op & 0x08) div=1;
|
if(op & 0x08) div=1;
|
if(op & 0x10) i2f=1;
|
if(op & 0x10) i2f=1;
|
if(op & 0x20) f2i=1;
|
if(op & 0x20) f2i=1;
|
if(op & 0x40) rem=1;
|
if(op & 0x40) rem=1;
|
|
|
f1 = get_pat(0); // Initialize pattern generator ...
|
f1 = get_pat(0); // Initialize pattern generator ...
|
|
|
for(i=0;i<count;i++) {
|
for(i=0;i<count;i++) {
|
|
|
err = 0;
|
err = 0;
|
|
|
if(pat>0) {
|
if(pat>0) {
|
f1 = get_pat(1);
|
f1 = get_pat(1);
|
f2 = get_pat(2);
|
f2 = get_pat(2);
|
} else {
|
} else {
|
f1 = get_fp();
|
f1 = get_fp();
|
f2 = get_fp();
|
f2 = get_fp();
|
}
|
}
|
|
|
|
|
if(rall) float_rounding_mode = (rand() % 4);
|
if(rall) float_rounding_mode = (rand() % 4);
|
|
|
|
|
oper = -1;
|
oper = -1;
|
while(oper == -1) {
|
while(oper == -1) {
|
float_exception_flags = 0; // Reset Exceptions
|
float_exception_flags = 0; // Reset Exceptions
|
|
|
if( (rand() % 8)==6 & rem) {
|
if( (rand() % 8)==6 & rem) {
|
oper = 0x40;
|
oper = 0x40;
|
f3 = float32_rem( f1, f2 );
|
f3 = float32_rem( f1, f2 );
|
float_exception_flags = 0; // Reset Exceptions
|
float_exception_flags = 0; // Reset Exceptions
|
f3 = float32_rem( f1, f2 );
|
f3 = float32_rem( f1, f2 );
|
}
|
}
|
|
|
if( (rand() % 8)==5 & f2i) {
|
if( (rand() % 8)==5 & f2i) {
|
oper = 0x20;
|
oper = 0x20;
|
f3 = float32_to_int32( f1 );
|
f3 = float32_to_int32( f1 );
|
float_exception_flags = 0; // Reset Exceptions
|
float_exception_flags = 0; // Reset Exceptions
|
f3 = float32_to_int32( f1 );
|
f3 = float32_to_int32( f1 );
|
f2 = 0;
|
f2 = 0;
|
}
|
}
|
|
|
if( (rand() % 8)==4 & i2f) {
|
if( (rand() % 8)==4 & i2f) {
|
oper = 0x10;
|
oper = 0x10;
|
|
|
|
|
tmp = (int) f1;
|
tmp = (int) f1;
|
|
|
|
|
f3 = int32_to_float32( tmp );
|
f3 = int32_to_float32( tmp );
|
float_exception_flags = 0; // Reset Exceptions
|
float_exception_flags = 0; // Reset Exceptions
|
f3 = int32_to_float32( tmp );
|
f3 = int32_to_float32( tmp );
|
f2 =0;
|
f2 =0;
|
}
|
}
|
|
|
|
|
if( (rand() % 8)==3 & div) {
|
if( (rand() % 8)==3 & div) {
|
oper = 0x08;
|
oper = 0x08;
|
f3 = float32_div( f1, f2);
|
f3 = float32_div( f1, f2);
|
float_exception_flags = 0; // Reset Exceptions
|
float_exception_flags = 0; // Reset Exceptions
|
f3 = float32_div( f1, f2);
|
f3 = float32_div( f1, f2);
|
|
|
//*( (float *) &f4 ) = *( (float *) &f1 ) / *( (float *) &f2 );
|
//*( (float *) &f4 ) = *( (float *) &f1 ) / *( (float *) &f2 );
|
//if( f4 != f3) {
|
//if( f4 != f3) {
|
// err = 1;
|
// err = 1;
|
// printf("FP Div Error: %x - %x: System: %x Lib: %x\n",f1, f2, f4, f3);
|
// printf("FP Div Error: %x - %x: System: %x Lib: %x\n",f1, f2, f4, f3);
|
// }
|
// }
|
}
|
}
|
|
|
if( (rand() % 8)==2 & mul) {
|
if( (rand() % 8)==2 & mul) {
|
oper = 0x04;
|
oper = 0x04;
|
f3 = float32_mul( f1, f2);
|
f3 = float32_mul( f1, f2);
|
float_exception_flags = 0; // Reset Exceptions
|
float_exception_flags = 0; // Reset Exceptions
|
f3 = float32_mul( f1, f2);
|
f3 = float32_mul( f1, f2);
|
|
|
//*( (float *) &f4 ) = *( (float *) &f1 ) * *( (float *) &f2 );
|
//*( (float *) &f4 ) = *( (float *) &f1 ) * *( (float *) &f2 );
|
//if( f4 != f3) {
|
//if( f4 != f3) {
|
// err = 1;
|
// err = 1;
|
// printf("FP Mul Error: %x - %x: System: %x Lib: %x\n",f1, f2, f4, f3);
|
// printf("FP Mul Error: %x - %x: System: %x Lib: %x\n",f1, f2, f4, f3);
|
// }
|
// }
|
}
|
}
|
|
|
if( (rand() % 8)==1 & sub) {
|
if( (rand() % 8)==1 & sub) {
|
oper = 0x02;
|
oper = 0x02;
|
f3 = float32_sub( f1, f2);
|
f3 = float32_sub( f1, f2);
|
float_exception_flags = 0; // Reset Exceptions
|
float_exception_flags = 0; // Reset Exceptions
|
f3 = float32_sub( f1, f2);
|
f3 = float32_sub( f1, f2);
|
|
|
//*( (float *) &f4 ) = *( (float *) &f1 ) - *( (float *) &f2 );
|
//*( (float *) &f4 ) = *( (float *) &f1 ) - *( (float *) &f2 );
|
//if( f4 != f3) {
|
//if( f4 != f3) {
|
// err = 1;
|
// err = 1;
|
// printf("FP Sub Error: %x - %x: System: %x Lib: %x\n",f1, f2, f4, f3);
|
// printf("FP Sub Error: %x - %x: System: %x Lib: %x\n",f1, f2, f4, f3);
|
// }
|
// }
|
}
|
}
|
|
|
if( (rand() % 8)==0 & add) {
|
if( (rand() % 8)==0 & add) {
|
oper = 0x01;
|
oper = 0x01;
|
f3 = float32_add( f1, f2);
|
f3 = float32_add( f1, f2);
|
float_exception_flags = 0; // Reset Exceptions
|
float_exception_flags = 0; // Reset Exceptions
|
f3 = float32_add( f1, f2);
|
f3 = float32_add( f1, f2);
|
|
|
//*( (float *) &f4 ) = *( (float *) &f1 ) + *( (float *) &f2 );
|
//*( (float *) &f4 ) = *( (float *) &f1 ) + *( (float *) &f2 );
|
//if( f4 != f3) {
|
//if( f4 != f3) {
|
// err = 1;
|
// err = 1;
|
// printf("FP Add Error: %x - %x: System: %x Lib: %x\n",f1, f2, f4, f3);
|
// printf("FP Add Error: %x - %x: System: %x Lib: %x\n",f1, f2, f4, f3);
|
// }
|
// }
|
}
|
}
|
|
|
}
|
}
|
|
|
if(err) err_count++;
|
if(err) err_count++;
|
|
|
if(!err) {
|
if(!err) {
|
|
|
//if(float_exception_flags != 0)
|
//if(float_exception_flags != 0)
|
// printf("Exceptions: %x\n",float_exception_flags);
|
// printf("Exceptions: %x\n",float_exception_flags);
|
|
|
|
|
if(verb) printf("rmode: %01x, except: %02x, oper: %02x opa: %08x, opb: %08x res: %08x\n", float_rounding_mode, float_exception_flags, oper, f1, f2, f3);
|
if(verb) printf("rmode: %01x, except: %02x, oper: %02x opa: %08x, opb: %08x res: %08x\n", float_rounding_mode, float_exception_flags, oper, f1, f2, f3);
|
fprintf(fp,"%01x%02x%02x%08x%08x%08x\n", float_rounding_mode, float_exception_flags, oper, f1, f2, f3);
|
fprintf(fp,"%01x%02x%02x%08x%08x%08x\n", float_rounding_mode, float_exception_flags, oper, f1, f2, f3);
|
}
|
}
|
else {
|
else {
|
printf("\t Vecor mismatch between library and system calculations. This Vector\n");
|
printf("\t Vecor mismatch between library and system calculations. This Vector\n");
|
printf("\t will not be placed in to vector file ...\n");
|
printf("\t will not be placed in to vector file ...\n");
|
}
|
}
|
|
|
}
|
}
|
|
|
|
|
close(fp);
|
close(fp);
|
|
|
if(!quiet) {
|
if(!quiet) {
|
printf("Found %d errors\n",err_count);
|
printf("Found %d errors\n",err_count);
|
printf("Wrote %d vectors from total %d specified.\n", (count-err_count), count);
|
printf("Wrote %d vectors from total %d specified.\n", (count-err_count), count);
|
|
|
printf("\n ... fptpg done.\n");
|
printf("\n ... fptpg done.\n");
|
}
|
}
|
return(0);
|
return(0);
|
}
|
}
|
|
|
|
|
|
|
do_fcmp(int count) {
|
do_fcmp(int count) {
|
float32 f1, f2, f3, f4;
|
float32 f1, f2, f3, f4;
|
int i;
|
int i;
|
int fp;
|
int fp;
|
char *mode;
|
char *mode;
|
int err;
|
int err;
|
int err_count=0;
|
int err_count=0;
|
int result;
|
int result;
|
int eq, le, lt;
|
int eq, le, lt;
|
|
|
if(!quiet) printf("\nGenerating %0d Arithmetic test vectors ...\n",count);
|
if(!quiet) printf("\nGenerating %0d Arithmetic test vectors ...\n",count);
|
|
|
if(append) mode = "a";
|
if(append) mode = "a";
|
else mode = "w";
|
else mode = "w";
|
if(ofile==0) ofile = "ar.hex";
|
if(ofile==0) ofile = "ar.hex";
|
|
|
fp = fopen(ofile,mode);
|
fp = fopen(ofile,mode);
|
if(fp == 0) {
|
if(fp == 0) {
|
printf("ERROR: Could not create file '%s'.\n",ofile);
|
printf("ERROR: Could not create file '%s'.\n",ofile);
|
return(-1);
|
return(-1);
|
}
|
}
|
|
|
|
|
for(i=0;i<count;i++) {
|
for(i=0;i<count;i++) {
|
|
|
float_exception_flags = 0; // Reset Exceptions
|
float_exception_flags = 0; // Reset Exceptions
|
|
|
if(pat>0) {
|
if(pat>0) {
|
f1 = get_pat(1);
|
f1 = get_pat(1);
|
f2 = get_pat(2);
|
f2 = get_pat(2);
|
} else {
|
} else {
|
f1 = get_fp();
|
f1 = get_fp();
|
f2 = get_fp();
|
f2 = get_fp();
|
}
|
}
|
|
|
eq = float32_eq( f1, f2 );
|
eq = float32_eq( f1, f2 );
|
le = float32_le( f1, f2 );
|
le = float32_le( f1, f2 );
|
lt = float32_lt( f1, f2 );
|
lt = float32_lt( f1, f2 );
|
|
|
float_exception_flags = 0; // Reset Exceptions
|
float_exception_flags = 0; // Reset Exceptions
|
|
|
eq = float32_eq( f1, f2 );
|
eq = float32_eq( f1, f2 );
|
le = float32_le( f1, f2 );
|
le = float32_le( f1, f2 );
|
lt = float32_lt( f1, f2 );
|
lt = float32_lt( f1, f2 );
|
|
|
eq = *( (float *) &f1 ) == *( (float *) &f2 );
|
eq = *( (float *) &f1 ) == *( (float *) &f2 );
|
le = *( (float *) &f1 ) < *( (float *) &f2 );
|
le = *( (float *) &f1 ) < *( (float *) &f2 );
|
lt = *( (float *) &f1 ) > *( (float *) &f2 );
|
lt = *( (float *) &f1 ) > *( (float *) &f2 );
|
|
|
|
|
if(eq) result = 1;
|
if(eq) result = 1;
|
else
|
else
|
if(le) result = 2;
|
if(le) result = 2;
|
else
|
else
|
if(lt) result = 4;
|
if(lt) result = 4;
|
else result = 0;
|
else result = 0;
|
|
|
|
|
if(verb) printf("except: %02x, opa: %08x, opb: %08x res: %01x\n", float_exception_flags, f1, f2, result);
|
if(verb) printf("except: %02x, opa: %08x, opb: %08x res: %01x\n", float_exception_flags, f1, f2, result);
|
fprintf(fp,"%02x%08x%08x%01x\n", float_exception_flags, f1, f2, result);
|
fprintf(fp,"%02x%08x%08x%01x\n", float_exception_flags, f1, f2, result);
|
}
|
}
|
|
|
close(fp);
|
close(fp);
|
|
|
if(!quiet) {
|
if(!quiet) {
|
printf("Found %d errors\n",err_count);
|
printf("Found %d errors\n",err_count);
|
printf("Wrote %d vectors from total %d specified.\n", (count-err_count), count);
|
printf("Wrote %d vectors from total %d specified.\n", (count-err_count), count);
|
|
|
printf("\n ... fptpg done.\n");
|
printf("\n ... fptpg done.\n");
|
|
|
}
|
}
|
|
|
return(0);
|
return(0);
|
|
|
}
|
}
|
|
|
|
|
|
|
float32 get_fp() {
|
float32 get_fp() {
|
float32 f1;
|
float32 f1;
|
int i1, i2, e;
|
int i1, i2, e;
|
|
|
if(large>0) i2 = rand();
|
if(large>0) i2 = rand();
|
else i2 = 0;
|
else i2 = 0;
|
|
|
if(large>1) i1 = rand() | (i2<<16);
|
if(large>1) i1 = rand() | (i2<<16);
|
else i1 = rand() | (i2<<10);
|
else i1 = rand() | (i2<<10);
|
|
|
i1 = i1 & 0x007fffff;
|
i1 = i1 & 0x007fffff;
|
|
|
e = rand();
|
e = rand();
|
e = e & 0x0ff;
|
e = e & 0x0ff;
|
|
|
f1 = (e << 23) + i1;
|
f1 = (e << 23) + i1;
|
|
|
if( rand() & 0x01) f1 = f1 | 0x80000000;
|
if( rand() & 0x01) f1 = f1 | 0x80000000;
|
|
|
return(f1);
|
return(f1);
|
}
|
}
|
|
|
static int p0, p1;
|
static int p0, p1;
|
|
|
// 0x00800000 Minimum Posetive Number
|
// 0x00800000 Minimum Posetive Number
|
// 0x7f7fffff Maximum Posetive Number
|
// 0x7f7fffff Maximum Posetive Number
|
|
|
|
|
float32 pat0[] = { 0x00800000, 0x00800001, 0x00800002, 0x00800004,
|
float32 pat0[] = { 0x00800000, 0x00800001, 0x00800002, 0x00800004,
|
0x00800008, 0x00880000, 0x00900000, 0x00a00000,
|
0x00800008, 0x00880000, 0x00900000, 0x00a00000,
|
0x00c00000, 0x00880001, 0x00900001, 0x00a00001,
|
0x00c00000, 0x00880001, 0x00900001, 0x00a00001,
|
0x00c00001, 0x00880002, 0x00900002, 0x00a00002,
|
0x00c00001, 0x00880002, 0x00900002, 0x00a00002,
|
0x00c00002, 0x00880004, 0x00900004, 0x00a00004,
|
0x00c00002, 0x00880004, 0x00900004, 0x00a00004,
|
0x00c00004, 0x00800003, 0x00800007, 0x0080000f,
|
0x00c00004, 0x00800003, 0x00800007, 0x0080000f,
|
0x00f80000, 0x00f00000, 0x00e00000, 0x00f80001,
|
0x00f80000, 0x00f00000, 0x00e00000, 0x00f80001,
|
0x00f00001, 0x00e00001, 0x00f80003, 0x00f00003,
|
0x00f00001, 0x00e00001, 0x00f80003, 0x00f00003,
|
0x00e00003, 0x00c00003, 0x00f80007, 0x00f00007,
|
0x00e00003, 0x00c00003, 0x00f80007, 0x00f00007,
|
0x00e00007, 0x00c00007, 0x00ffffff, 0x00fffffe,
|
0x00e00007, 0x00c00007, 0x00ffffff, 0x00fffffe,
|
0x00fffffd, 0x00fffffb, 0x00fffff7, 0x00f7ffff,
|
0x00fffffd, 0x00fffffb, 0x00fffff7, 0x00f7ffff,
|
0x00efffff, 0x00dfffff, 0x00bfffff, 0x00f7fffe,
|
0x00efffff, 0x00dfffff, 0x00bfffff, 0x00f7fffe,
|
0x00effffe, 0x00dffffe, 0x00bffffe, 0x00f7fffd,
|
0x00effffe, 0x00dffffe, 0x00bffffe, 0x00f7fffd,
|
0x00effffd, 0x00dffffd, 0x00bffffd, 0x00f7fffb,
|
0x00effffd, 0x00dffffd, 0x00bffffd, 0x00f7fffb,
|
0x00effffb, 0x00dffffb, 0x00bffffb, 0x00fffffc,
|
0x00effffb, 0x00dffffb, 0x00bffffb, 0x00fffffc,
|
0x00fffff8, 0x00fffff0, 0x0087ffff, 0x008fffff,
|
0x00fffff8, 0x00fffff0, 0x0087ffff, 0x008fffff,
|
0x009fffff, 0x0087fffe, 0x008ffffe, 0x009ffffe,
|
0x009fffff, 0x0087fffe, 0x008ffffe, 0x009ffffe,
|
0x0087fffc, 0x008ffffc, 0x009ffffc, 0x00bffffc,
|
0x0087fffc, 0x008ffffc, 0x009ffffc, 0x00bffffc,
|
0x0087fff8, 0x008ffff8, 0x009ffff8, 0x00bffff8,
|
0x0087fff8, 0x008ffff8, 0x009ffff8, 0x00bffff8,
|
0x7f000000, 0x7f000001, 0x7f000002, 0x7f000004,
|
0x7f000000, 0x7f000001, 0x7f000002, 0x7f000004,
|
0x7f000008, 0x7f080000, 0x7f100000, 0x7f200000,
|
0x7f000008, 0x7f080000, 0x7f100000, 0x7f200000,
|
0x7f400000, 0x7f080001, 0x7f100001, 0x7f200001,
|
0x7f400000, 0x7f080001, 0x7f100001, 0x7f200001,
|
0x7f400001, 0x7f080002, 0x7f100002, 0x7f200002,
|
0x7f400001, 0x7f080002, 0x7f100002, 0x7f200002,
|
0x7f400002, 0x7f080004, 0x7f100004, 0x7f200004,
|
0x7f400002, 0x7f080004, 0x7f100004, 0x7f200004,
|
0x7f400004, 0x7f000003, 0x7f000007, 0x7f00000f,
|
0x7f400004, 0x7f000003, 0x7f000007, 0x7f00000f,
|
0x7f780000, 0x7f700000, 0x7f600000, 0x7f780001,
|
0x7f780000, 0x7f700000, 0x7f600000, 0x7f780001,
|
0x7f700001, 0x7f600001, 0x7f780003, 0x7f700003,
|
0x7f700001, 0x7f600001, 0x7f780003, 0x7f700003,
|
0x7f600003, 0x7f400003, 0x7f780007, 0x7f700007,
|
0x7f600003, 0x7f400003, 0x7f780007, 0x7f700007,
|
0x7f600007, 0x7f400007, 0x7f7fffff, 0x7f7ffffe,
|
0x7f600007, 0x7f400007, 0x7f7fffff, 0x7f7ffffe,
|
0x7f7ffffd, 0x7f7ffffb, 0x7f7ffff7, 0x7f77ffff,
|
0x7f7ffffd, 0x7f7ffffb, 0x7f7ffff7, 0x7f77ffff,
|
0x7f6fffff, 0x7f5fffff, 0x7f3fffff, 0x7f77fffe,
|
0x7f6fffff, 0x7f5fffff, 0x7f3fffff, 0x7f77fffe,
|
0x7f6ffffe, 0x7f5ffffe, 0x7f3ffffe, 0x7f77fffd,
|
0x7f6ffffe, 0x7f5ffffe, 0x7f3ffffe, 0x7f77fffd,
|
0x7f6ffffd, 0x7f5ffffd, 0x7f3ffffd, 0x7f77fffb,
|
0x7f6ffffd, 0x7f5ffffd, 0x7f3ffffd, 0x7f77fffb,
|
0x7f6ffffb, 0x7f5ffffb, 0x7f3ffffb, 0x7f7ffffc,
|
0x7f6ffffb, 0x7f5ffffb, 0x7f3ffffb, 0x7f7ffffc,
|
0x7f7ffff8, 0x7f7ffff0, 0x7f07ffff, 0x7f0fffff,
|
0x7f7ffff8, 0x7f7ffff0, 0x7f07ffff, 0x7f0fffff,
|
0x7f1fffff, 0x7f07fffe, 0x7f0ffffe, 0x7f1ffffe,
|
0x7f1fffff, 0x7f07fffe, 0x7f0ffffe, 0x7f1ffffe,
|
0x7f07fffc, 0x7f0ffffc, 0x7f1ffffc, 0x7f3ffffc,
|
0x7f07fffc, 0x7f0ffffc, 0x7f1ffffc, 0x7f3ffffc,
|
0x7f07fff8, 0x7f0ffff8, 0x7f1ffff8, 0x7f3ffff8,
|
0x7f07fff8, 0x7f0ffff8, 0x7f1ffff8, 0x7f3ffff8,
|
0x80800000, 0x80800001, 0x80800002, 0x80800004,
|
0x80800000, 0x80800001, 0x80800002, 0x80800004,
|
0x80800008, 0x80880000, 0x80900000, 0x80a00000,
|
0x80800008, 0x80880000, 0x80900000, 0x80a00000,
|
0x80c00000, 0x80880001, 0x80900001, 0x80a00001,
|
0x80c00000, 0x80880001, 0x80900001, 0x80a00001,
|
0x80c00001, 0x80880002, 0x80900002, 0x80a00002,
|
0x80c00001, 0x80880002, 0x80900002, 0x80a00002,
|
0x80c00002, 0x80880004, 0x80900004, 0x80a00004,
|
0x80c00002, 0x80880004, 0x80900004, 0x80a00004,
|
0x80c00004, 0x80800003, 0x80800007, 0x8080000f,
|
0x80c00004, 0x80800003, 0x80800007, 0x8080000f,
|
0x80f80000, 0x80f00000, 0x80e00000, 0x80f80001,
|
0x80f80000, 0x80f00000, 0x80e00000, 0x80f80001,
|
0x80f00001, 0x80e00001, 0x80f80003, 0x80f00003,
|
0x80f00001, 0x80e00001, 0x80f80003, 0x80f00003,
|
0x80e00003, 0x80c00003, 0x80f80007, 0x80f00007,
|
0x80e00003, 0x80c00003, 0x80f80007, 0x80f00007,
|
0x80e00007, 0x80c00007, 0x80ffffff, 0x80fffffe,
|
0x80e00007, 0x80c00007, 0x80ffffff, 0x80fffffe,
|
0x80fffffd, 0x80fffffb, 0x80fffff7, 0x80f7ffff,
|
0x80fffffd, 0x80fffffb, 0x80fffff7, 0x80f7ffff,
|
0x80efffff, 0x80dfffff, 0x80bfffff, 0x80f7fffe,
|
0x80efffff, 0x80dfffff, 0x80bfffff, 0x80f7fffe,
|
0x80effffe, 0x80dffffe, 0x80bffffe, 0x80f7fffd,
|
0x80effffe, 0x80dffffe, 0x80bffffe, 0x80f7fffd,
|
0x80effffd, 0x80dffffd, 0x80bffffd, 0x80f7fffb,
|
0x80effffd, 0x80dffffd, 0x80bffffd, 0x80f7fffb,
|
0x80effffb, 0x80dffffb, 0x80bffffb, 0x80fffffc,
|
0x80effffb, 0x80dffffb, 0x80bffffb, 0x80fffffc,
|
0x80fffff8, 0x80fffff0, 0x8087ffff, 0x808fffff,
|
0x80fffff8, 0x80fffff0, 0x8087ffff, 0x808fffff,
|
0x809fffff, 0x8087fffe, 0x808ffffe, 0x809ffffe,
|
0x809fffff, 0x8087fffe, 0x808ffffe, 0x809ffffe,
|
0x8087fffc, 0x808ffffc, 0x809ffffc, 0x80bffffc,
|
0x8087fffc, 0x808ffffc, 0x809ffffc, 0x80bffffc,
|
0x8087fff8, 0x808ffff8, 0x809ffff8, 0x80bffff8,
|
0x8087fff8, 0x808ffff8, 0x809ffff8, 0x80bffff8,
|
0xff000000, 0xff000001, 0xff000002, 0xff000004,
|
0xff000000, 0xff000001, 0xff000002, 0xff000004,
|
0xff000008, 0xff080000, 0xff100000, 0xff200000,
|
0xff000008, 0xff080000, 0xff100000, 0xff200000,
|
0xff400000, 0xff080001, 0xff100001, 0xff200001,
|
0xff400000, 0xff080001, 0xff100001, 0xff200001,
|
0xff400001, 0xff080002, 0xff100002, 0xff200002,
|
0xff400001, 0xff080002, 0xff100002, 0xff200002,
|
0xff400002, 0xff080004, 0xff100004, 0xff200004,
|
0xff400002, 0xff080004, 0xff100004, 0xff200004,
|
0xff400004, 0xff000003, 0xff000007, 0xff00000f,
|
0xff400004, 0xff000003, 0xff000007, 0xff00000f,
|
0xff780000, 0xff700000, 0xff600000, 0xff780001,
|
0xff780000, 0xff700000, 0xff600000, 0xff780001,
|
0xff700001, 0xff600001, 0xff780003, 0xff700003,
|
0xff700001, 0xff600001, 0xff780003, 0xff700003,
|
0xff600003, 0xff400003, 0xff780007, 0xff700007,
|
0xff600003, 0xff400003, 0xff780007, 0xff700007,
|
0xff600007, 0xff400007, 0xff7fffff, 0xff7ffffe,
|
0xff600007, 0xff400007, 0xff7fffff, 0xff7ffffe,
|
0xff7ffffd, 0xff7ffffb, 0xff7ffff7, 0xff77ffff,
|
0xff7ffffd, 0xff7ffffb, 0xff7ffff7, 0xff77ffff,
|
0xff6fffff, 0xff5fffff, 0xff3fffff, 0xff77fffe,
|
0xff6fffff, 0xff5fffff, 0xff3fffff, 0xff77fffe,
|
0xff6ffffe, 0xff5ffffe, 0xff3ffffe, 0xff77fffd,
|
0xff6ffffe, 0xff5ffffe, 0xff3ffffe, 0xff77fffd,
|
0xff6ffffd, 0xff5ffffd, 0xff3ffffd, 0xff77fffb,
|
0xff6ffffd, 0xff5ffffd, 0xff3ffffd, 0xff77fffb,
|
0xff6ffffb, 0xff5ffffb, 0xff3ffffb, 0xff7ffffc,
|
0xff6ffffb, 0xff5ffffb, 0xff3ffffb, 0xff7ffffc,
|
0xff7ffff8, 0xff7ffff0, 0xff07ffff, 0xff0fffff,
|
0xff7ffff8, 0xff7ffff0, 0xff07ffff, 0xff0fffff,
|
0xff1fffff, 0xff07fffe, 0xff0ffffe, 0xff1ffffe,
|
0xff1fffff, 0xff07fffe, 0xff0ffffe, 0xff1ffffe,
|
0xff07fffc, 0xff0ffffc, 0xff1ffffc, 0xff3ffffc,
|
0xff07fffc, 0xff0ffffc, 0xff1ffffc, 0xff3ffffc,
|
0xff07fff8, 0xff0ffff8, 0xff1ffff8, 0xff3ffff8
|
0xff07fff8, 0xff0ffff8, 0xff1ffff8, 0xff3ffff8
|
};
|
};
|
|
|
|
|
int pat0_cnt = 304;
|
int pat0_cnt = 304;
|
|
|
|
|
float32 pat1[] = { 0x6c800000, 0x3a000001, 0x69800002, 0x79800004,
|
float32 pat1[] = { 0x6c800000, 0x3a000001, 0x69800002, 0x79800004,
|
0x37000008, 0x59080000, 0x7d900000, 0x23200000,
|
0x37000008, 0x59080000, 0x7d900000, 0x23200000,
|
0x59c00000, 0x23880001, 0x5e900001, 0x45a00001,
|
0x59c00000, 0x23880001, 0x5e900001, 0x45a00001,
|
0x1f400001, 0x63080002, 0x29100002, 0x15200002,
|
0x1f400001, 0x63080002, 0x29100002, 0x15200002,
|
0x43c00002, 0x5d880004, 0x29900004, 0x54200004,
|
0x43c00002, 0x5d880004, 0x29900004, 0x54200004,
|
0x09400004, 0x28800003, 0x7f800007, 0x0880000f,
|
0x09400004, 0x28800003, 0x7f800007, 0x0880000f,
|
0x3cf80000, 0x4af00000, 0x58e00000, 0x61780001,
|
0x3cf80000, 0x4af00000, 0x58e00000, 0x61780001,
|
0x20700001, 0x0fe00001, 0x15780003, 0x73700003,
|
0x20700001, 0x0fe00001, 0x15780003, 0x73700003,
|
0x52e00003, 0x7b400003, 0x10780007, 0x7c700007,
|
0x52e00003, 0x7b400003, 0x10780007, 0x7c700007,
|
0x30e00007, 0x3dc00007, 0x5f7fffff, 0x45fffffe,
|
0x30e00007, 0x3dc00007, 0x5f7fffff, 0x45fffffe,
|
0x407ffffd, 0x18fffffb, 0x48fffff7, 0x60f7ffff,
|
0x407ffffd, 0x18fffffb, 0x48fffff7, 0x60f7ffff,
|
0x27efffff, 0x145fffff, 0x3e3fffff, 0x5277fffe,
|
0x27efffff, 0x145fffff, 0x3e3fffff, 0x5277fffe,
|
0x3ceffffe, 0x73dffffe, 0x233ffffe, 0x67f7fffd,
|
0x3ceffffe, 0x73dffffe, 0x233ffffe, 0x67f7fffd,
|
0x33effffd, 0x4e5ffffd, 0x243ffffd, 0x4f77fffb,
|
0x33effffd, 0x4e5ffffd, 0x243ffffd, 0x4f77fffb,
|
0x6feffffb, 0x31dffffb, 0x673ffffb, 0x207ffffc,
|
0x6feffffb, 0x31dffffb, 0x673ffffb, 0x207ffffc,
|
0x07fffff8, 0x3dfffff0, 0x6187ffff, 0x7f8fffff,
|
0x07fffff8, 0x3dfffff0, 0x6187ffff, 0x7f8fffff,
|
0x7f1fffff, 0x1887fffe, 0x170ffffe, 0x011ffffe,
|
0x7f1fffff, 0x1887fffe, 0x170ffffe, 0x011ffffe,
|
0x3a87fffc, 0x280ffffc, 0x0a9ffffc, 0x753ffffc,
|
0x3a87fffc, 0x280ffffc, 0x0a9ffffc, 0x753ffffc,
|
0x4187fff8, 0x7b8ffff8, 0x2c1ffff8, 0x40bffff8,
|
0x4187fff8, 0x7b8ffff8, 0x2c1ffff8, 0x40bffff8,
|
0x00000000, 0x00000001, 0x00000002, 0x00000004,
|
0x00000000, 0x00000001, 0x00000002, 0x00000004,
|
0x00000008, 0x00080000, 0x00100000, 0x00200000,
|
0x00000008, 0x00080000, 0x00100000, 0x00200000,
|
0x00400000, 0x00080001, 0x00100001, 0x00200001,
|
0x00400000, 0x00080001, 0x00100001, 0x00200001,
|
0x00400001, 0x00080002, 0x00100002, 0x00200002,
|
0x00400001, 0x00080002, 0x00100002, 0x00200002,
|
0x00400002, 0x00080004, 0x00100004, 0x00200004,
|
0x00400002, 0x00080004, 0x00100004, 0x00200004,
|
0x00400004, 0x00000003, 0x00000007, 0x0000000f,
|
0x00400004, 0x00000003, 0x00000007, 0x0000000f,
|
0x00780000, 0x00700000, 0x00600000, 0x00780001,
|
0x00780000, 0x00700000, 0x00600000, 0x00780001,
|
0x00700001, 0x00600001, 0x00780003, 0x00700003,
|
0x00700001, 0x00600001, 0x00780003, 0x00700003,
|
0x00600003, 0x00400003, 0x00780007, 0x00700007,
|
0x00600003, 0x00400003, 0x00780007, 0x00700007,
|
0x00600007, 0x00400007, 0x007fffff, 0x007ffffe,
|
0x00600007, 0x00400007, 0x007fffff, 0x007ffffe,
|
0x007ffffd, 0x007ffffb, 0x007ffff7, 0x0077ffff,
|
0x007ffffd, 0x007ffffb, 0x007ffff7, 0x0077ffff,
|
0x006fffff, 0x005fffff, 0x003fffff, 0x0077fffe,
|
0x006fffff, 0x005fffff, 0x003fffff, 0x0077fffe,
|
0x006ffffe, 0x005ffffe, 0x003ffffe, 0x0077fffd,
|
0x006ffffe, 0x005ffffe, 0x003ffffe, 0x0077fffd,
|
0x006ffffd, 0x005ffffd, 0x003ffffd, 0x0077fffb,
|
0x006ffffd, 0x005ffffd, 0x003ffffd, 0x0077fffb,
|
0x006ffffb, 0x005ffffb, 0x003ffffb, 0x007ffffc,
|
0x006ffffb, 0x005ffffb, 0x003ffffb, 0x007ffffc,
|
0x007ffff8, 0x007ffff0, 0x0007ffff, 0x000fffff,
|
0x007ffff8, 0x007ffff0, 0x0007ffff, 0x000fffff,
|
0x001fffff, 0x0007fffe, 0x000ffffe, 0x001ffffe,
|
0x001fffff, 0x0007fffe, 0x000ffffe, 0x001ffffe,
|
0x0007fffc, 0x000ffffc, 0x001ffffc, 0x003ffffc,
|
0x0007fffc, 0x000ffffc, 0x001ffffc, 0x003ffffc,
|
0x0007fff8, 0x000ffff8, 0x001ffff8, 0x003ffff8,
|
0x0007fff8, 0x000ffff8, 0x001ffff8, 0x003ffff8,
|
0xc7800000, 0xc3800001, 0x84000002, 0xf6800004,
|
0xc7800000, 0xc3800001, 0x84000002, 0xf6800004,
|
0x90000008, 0xca880000, 0xee900000, 0xc8200000,
|
0x90000008, 0xca880000, 0xee900000, 0xc8200000,
|
0xb0c00000, 0xd3080001, 0xa7100001, 0x84a00001,
|
0xb0c00000, 0xd3080001, 0xa7100001, 0x84a00001,
|
0xb6400001, 0xbc880002, 0xee100002, 0xc7a00002,
|
0xb6400001, 0xbc880002, 0xee100002, 0xc7a00002,
|
0xbec00002, 0xe4880004, 0x90100004, 0xfea00004,
|
0xbec00002, 0xe4880004, 0x90100004, 0xfea00004,
|
0x82c00004, 0x9d000003, 0x9b800007, 0xef00000f,
|
0x82c00004, 0x9d000003, 0x9b800007, 0xef00000f,
|
0xe3780000, 0xadf00000, 0x83e00000, 0xe7f80001,
|
0xe3780000, 0xadf00000, 0x83e00000, 0xe7f80001,
|
0xf9700001, 0xbae00001, 0x81f80003, 0xbef00003,
|
0xf9700001, 0xbae00001, 0x81f80003, 0xbef00003,
|
0xb8600003, 0x88400003, 0xf7f80007, 0xcbf00007,
|
0xb8600003, 0x88400003, 0xf7f80007, 0xcbf00007,
|
0xa3600007, 0xf2400007, 0x9dffffff, 0xfefffffe,
|
0xa3600007, 0xf2400007, 0x9dffffff, 0xfefffffe,
|
0xa27ffffd, 0x8ffffffb, 0xc07ffff7, 0xc3f7ffff,
|
0xa27ffffd, 0x8ffffffb, 0xc07ffff7, 0xc3f7ffff,
|
0x806fffff, 0xdcdfffff, 0xda3fffff, 0xd3f7fffe,
|
0x806fffff, 0xdcdfffff, 0xda3fffff, 0xd3f7fffe,
|
0x916ffffe, 0xde5ffffe, 0xd2bffffe, 0x9df7fffd,
|
0x916ffffe, 0xde5ffffe, 0xd2bffffe, 0x9df7fffd,
|
0x97effffd, 0x9cdffffd, 0xa43ffffd, 0xf377fffb,
|
0x97effffd, 0x9cdffffd, 0xa43ffffd, 0xf377fffb,
|
0xe0effffb, 0xe9dffffb, 0xb43ffffb, 0x9c7ffffc,
|
0xe0effffb, 0xe9dffffb, 0xb43ffffb, 0x9c7ffffc,
|
0xaafffff8, 0xcafffff0, 0xa887ffff, 0xf98fffff,
|
0xaafffff8, 0xcafffff0, 0xa887ffff, 0xf98fffff,
|
0xda1fffff, 0xff87fffe, 0xff0ffffe, 0xe19ffffe,
|
0xda1fffff, 0xff87fffe, 0xff0ffffe, 0xe19ffffe,
|
0x8287fffc, 0x808ffffc, 0xab1ffffc, 0xddbffffc,
|
0x8287fffc, 0x808ffffc, 0xab1ffffc, 0xddbffffc,
|
0xd387fff8, 0xe40ffff8, 0x8d1ffff8, 0xefbffff8,
|
0xd387fff8, 0xe40ffff8, 0x8d1ffff8, 0xefbffff8,
|
0x80000000, 0x80000001, 0x80000002, 0x80000004,
|
0x80000000, 0x80000001, 0x80000002, 0x80000004,
|
0x80000008, 0x80080000, 0x80100000, 0x80200000,
|
0x80000008, 0x80080000, 0x80100000, 0x80200000,
|
0x80400000, 0x80080001, 0x80100001, 0x80200001,
|
0x80400000, 0x80080001, 0x80100001, 0x80200001,
|
0x80400001, 0x80080002, 0x80100002, 0x80200002,
|
0x80400001, 0x80080002, 0x80100002, 0x80200002,
|
0x80400002, 0x80080004, 0x80100004, 0x80200004,
|
0x80400002, 0x80080004, 0x80100004, 0x80200004,
|
0x80400004, 0x80000003, 0x80000007, 0x8000000f,
|
0x80400004, 0x80000003, 0x80000007, 0x8000000f,
|
0x80780000, 0x80700000, 0x80600000, 0x80780001,
|
0x80780000, 0x80700000, 0x80600000, 0x80780001,
|
0x80700001, 0x80600001, 0x80780003, 0x80700003,
|
0x80700001, 0x80600001, 0x80780003, 0x80700003,
|
0x80600003, 0x80400003, 0x80780007, 0x80700007,
|
0x80600003, 0x80400003, 0x80780007, 0x80700007,
|
0x80600007, 0x80400007, 0x807fffff, 0x807ffffe,
|
0x80600007, 0x80400007, 0x807fffff, 0x807ffffe,
|
0x807ffffd, 0x807ffffb, 0x807ffff7, 0x8077ffff,
|
0x807ffffd, 0x807ffffb, 0x807ffff7, 0x8077ffff,
|
0x806fffff, 0x805fffff, 0x803fffff, 0x8077fffe,
|
0x806fffff, 0x805fffff, 0x803fffff, 0x8077fffe,
|
0x806ffffe, 0x805ffffe, 0x803ffffe, 0x8077fffd,
|
0x806ffffe, 0x805ffffe, 0x803ffffe, 0x8077fffd,
|
0x806ffffd, 0x805ffffd, 0x803ffffd, 0x8077fffb,
|
0x806ffffd, 0x805ffffd, 0x803ffffd, 0x8077fffb,
|
0x806ffffb, 0x805ffffb, 0x803ffffb, 0x807ffffc,
|
0x806ffffb, 0x805ffffb, 0x803ffffb, 0x807ffffc,
|
0x807ffff8, 0x807ffff0, 0x8007ffff, 0x800fffff,
|
0x807ffff8, 0x807ffff0, 0x8007ffff, 0x800fffff,
|
0x801fffff, 0x8007fffe, 0x800ffffe, 0x801ffffe,
|
0x801fffff, 0x8007fffe, 0x800ffffe, 0x801ffffe,
|
0x8007fffc, 0x800ffffc, 0x801ffffc, 0x803ffffc,
|
0x8007fffc, 0x800ffffc, 0x801ffffc, 0x803ffffc,
|
0x8007fff8, 0x800ffff8, 0x801ffff8, 0x803ffff8,
|
0x8007fff8, 0x800ffff8, 0x801ffff8, 0x803ffff8,
|
};
|
};
|
|
|
|
|
int pat1_cnt = 304;
|
int pat1_cnt = 304;
|
int pat2_cnt = 124;
|
int pat2_cnt = 124;
|
|
|
float32 pat2[] = { 0x00000000,
|
float32 pat2[] = { 0x00000000,
|
0x00000001,
|
0x00000001,
|
0x00000002,
|
0x00000002,
|
0x00000004,
|
0x00000004,
|
0x00000008,
|
0x00000008,
|
0x00000010,
|
0x00000010,
|
0x00000020,
|
0x00000020,
|
0x00000040,
|
0x00000040,
|
0x00000080,
|
0x00000080,
|
0x00000100,
|
0x00000100,
|
0x00000200,
|
0x00000200,
|
0x00000400,
|
0x00000400,
|
0x00000800,
|
0x00000800,
|
0x00001000,
|
0x00001000,
|
0x00002000,
|
0x00002000,
|
0x00004000,
|
0x00004000,
|
0x00008000,
|
0x00008000,
|
0x00010000,
|
0x00010000,
|
0x00020000,
|
0x00020000,
|
0x00040000,
|
0x00040000,
|
0x00080000,
|
0x00080000,
|
0x00100000,
|
0x00100000,
|
0x00200000,
|
0x00200000,
|
0x00400000,
|
0x00400000,
|
0x00800000,
|
0x00800000,
|
0x01000000,
|
0x01000000,
|
0x02000000,
|
0x02000000,
|
0x04000000,
|
0x04000000,
|
0x08000000,
|
0x08000000,
|
0x10000000,
|
0x10000000,
|
0x20000000,
|
0x20000000,
|
0x40000000,
|
0x40000000,
|
0x80000000,
|
0x80000000,
|
0xC0000000,
|
0xC0000000,
|
0xE0000000,
|
0xE0000000,
|
0xF0000000,
|
0xF0000000,
|
0xF8000000,
|
0xF8000000,
|
0xFC000000,
|
0xFC000000,
|
0xFE000000,
|
0xFE000000,
|
0xFF000000,
|
0xFF000000,
|
0xFF800000,
|
0xFF800000,
|
0xFFC00000,
|
0xFFC00000,
|
0xFFE00000,
|
0xFFE00000,
|
0xFFF00000,
|
0xFFF00000,
|
0xFFF80000,
|
0xFFF80000,
|
0xFFFC0000,
|
0xFFFC0000,
|
0xFFFE0000,
|
0xFFFE0000,
|
0xFFFF0000,
|
0xFFFF0000,
|
0xFFFF8000,
|
0xFFFF8000,
|
0xFFFFC000,
|
0xFFFFC000,
|
0xFFFFE000,
|
0xFFFFE000,
|
0xFFFFF000,
|
0xFFFFF000,
|
0xFFFFF800,
|
0xFFFFF800,
|
0xFFFFFC00,
|
0xFFFFFC00,
|
0xFFFFFE00,
|
0xFFFFFE00,
|
0xFFFFFF00,
|
0xFFFFFF00,
|
0xFFFFFF80,
|
0xFFFFFF80,
|
0xFFFFFFC0,
|
0xFFFFFFC0,
|
0xFFFFFFE0,
|
0xFFFFFFE0,
|
0xFFFFFFF0,
|
0xFFFFFFF0,
|
0xFFFFFFF8,
|
0xFFFFFFF8,
|
0xFFFFFFFC,
|
0xFFFFFFFC,
|
0xFFFFFFFE,
|
0xFFFFFFFE,
|
0xFFFFFFFF,
|
0xFFFFFFFF,
|
0xFFFFFFFD,
|
0xFFFFFFFD,
|
0xFFFFFFFB,
|
0xFFFFFFFB,
|
0xFFFFFFF7,
|
0xFFFFFFF7,
|
0xFFFFFFEF,
|
0xFFFFFFEF,
|
0xFFFFFFDF,
|
0xFFFFFFDF,
|
0xFFFFFFBF,
|
0xFFFFFFBF,
|
0xFFFFFF7F,
|
0xFFFFFF7F,
|
0xFFFFFEFF,
|
0xFFFFFEFF,
|
0xFFFFFDFF,
|
0xFFFFFDFF,
|
0xFFFFFBFF,
|
0xFFFFFBFF,
|
0xFFFFF7FF,
|
0xFFFFF7FF,
|
0xFFFFEFFF,
|
0xFFFFEFFF,
|
0xFFFFDFFF,
|
0xFFFFDFFF,
|
0xFFFFBFFF,
|
0xFFFFBFFF,
|
0xFFFF7FFF,
|
0xFFFF7FFF,
|
0xFFFEFFFF,
|
0xFFFEFFFF,
|
0xFFFDFFFF,
|
0xFFFDFFFF,
|
0xFFFBFFFF,
|
0xFFFBFFFF,
|
0xFFF7FFFF,
|
0xFFF7FFFF,
|
0xFFEFFFFF,
|
0xFFEFFFFF,
|
0xFFDFFFFF,
|
0xFFDFFFFF,
|
0xFFBFFFFF,
|
0xFFBFFFFF,
|
0xFF7FFFFF,
|
0xFF7FFFFF,
|
0xFEFFFFFF,
|
0xFEFFFFFF,
|
0xFDFFFFFF,
|
0xFDFFFFFF,
|
0xFBFFFFFF,
|
0xFBFFFFFF,
|
0xF7FFFFFF,
|
0xF7FFFFFF,
|
0xEFFFFFFF,
|
0xEFFFFFFF,
|
0xDFFFFFFF,
|
0xDFFFFFFF,
|
0xBFFFFFFF,
|
0xBFFFFFFF,
|
0x7FFFFFFF,
|
0x7FFFFFFF,
|
0x3FFFFFFF,
|
0x3FFFFFFF,
|
0x1FFFFFFF,
|
0x1FFFFFFF,
|
0x0FFFFFFF,
|
0x0FFFFFFF,
|
0x07FFFFFF,
|
0x07FFFFFF,
|
0x03FFFFFF,
|
0x03FFFFFF,
|
0x01FFFFFF,
|
0x01FFFFFF,
|
0x00FFFFFF,
|
0x00FFFFFF,
|
0x007FFFFF,
|
0x007FFFFF,
|
0x003FFFFF,
|
0x003FFFFF,
|
0x001FFFFF,
|
0x001FFFFF,
|
0x000FFFFF,
|
0x000FFFFF,
|
0x0007FFFF,
|
0x0007FFFF,
|
0x0003FFFF,
|
0x0003FFFF,
|
0x0001FFFF,
|
0x0001FFFF,
|
0x0000FFFF,
|
0x0000FFFF,
|
0x00007FFF,
|
0x00007FFF,
|
0x00003FFF,
|
0x00003FFF,
|
0x00001FFF,
|
0x00001FFF,
|
0x00000FFF,
|
0x00000FFF,
|
0x000007FF,
|
0x000007FF,
|
0x000003FF,
|
0x000003FF,
|
0x000001FF,
|
0x000001FF,
|
0x000000FF,
|
0x000000FF,
|
0x0000007F,
|
0x0000007F,
|
0x0000003F,
|
0x0000003F,
|
0x0000001F,
|
0x0000001F,
|
0x0000000F,
|
0x0000000F,
|
0x00000007,
|
0x00000007,
|
0x00000003
|
0x00000003
|
};
|
};
|
|
|
|
|
float32 get_pat(int mode) {
|
float32 get_pat(int mode) {
|
|
|
if(mode==0) {
|
if(mode==0) {
|
p0 = 0;
|
p0 = 0;
|
p1 = 0;
|
p1 = 0;
|
return(0);
|
return(0);
|
}
|
}
|
else
|
else
|
if(pat==1) return(get_pat0(mode));
|
if(pat==1) return(get_pat0(mode));
|
else
|
else
|
if(pat==2) return(get_pat1(mode));
|
if(pat==2) return(get_pat1(mode));
|
else
|
else
|
if(pat==3) return(get_pat2(mode));
|
if(pat==3) return(get_pat2(mode));
|
|
|
else return(0);
|
else return(0);
|
|
|
}
|
}
|
|
|
|
|
|
|
float32 get_pat0(int mode) {
|
float32 get_pat0(int mode) {
|
float32 x;
|
float32 x;
|
|
|
if(mode==1) {
|
if(mode==1) {
|
if(p0==pat0_cnt) p0 = 0;
|
if(p0==pat0_cnt) p0 = 0;
|
x = pat0[p0];
|
x = pat0[p0];
|
p0++;
|
p0++;
|
return(x);
|
return(x);
|
}
|
}
|
|
|
if(mode==2) {
|
if(mode==2) {
|
x = pat0[p1];
|
x = pat0[p1];
|
if(p0==(pat0_cnt) ) p1++;
|
if(p0==(pat0_cnt) ) p1++;
|
if(p1==pat0_cnt) p1 = 0;
|
if(p1==pat0_cnt) p1 = 0;
|
return(x);
|
return(x);
|
}
|
}
|
|
|
return(0);
|
return(0);
|
}
|
}
|
|
|
|
|
|
|
float32 get_pat1(int mode) {
|
float32 get_pat1(int mode) {
|
float32 x;
|
float32 x;
|
|
|
if(mode==1) {
|
if(mode==1) {
|
if(p0==pat1_cnt) p0 = 0;
|
if(p0==pat1_cnt) p0 = 0;
|
x = pat1[p0];
|
x = pat1[p0];
|
p0++;
|
p0++;
|
return(x);
|
return(x);
|
}
|
}
|
|
|
if(mode==2) {
|
if(mode==2) {
|
x = pat1[p1];
|
x = pat1[p1];
|
if(p0==(pat1_cnt) ) p1++;
|
if(p0==(pat1_cnt) ) p1++;
|
if(p1==pat1_cnt) p1 = 0;
|
if(p1==pat1_cnt) p1 = 0;
|
return(x);
|
return(x);
|
}
|
}
|
|
|
return(0);
|
return(0);
|
}
|
}
|
|
|
|
|
float32 get_pat2(int mode) {
|
float32 get_pat2(int mode) {
|
float32 x;
|
float32 x;
|
|
|
if(mode==1) {
|
if(mode==1) {
|
if(p0==pat2_cnt) p0 = 0;
|
if(p0==pat2_cnt) p0 = 0;
|
x = pat2[p0];
|
x = pat2[p0];
|
p0++;
|
p0++;
|
return(x);
|
return(x);
|
}
|
}
|
|
|
if(mode==2) {
|
if(mode==2) {
|
x = pat2[p1];
|
x = pat2[p1];
|
if(p0==(pat2_cnt) ) p1++;
|
if(p0==(pat2_cnt) ) p1++;
|
if(p1==pat2_cnt) p1 = 0;
|
if(p1==pat2_cnt) p1 = 0;
|
return(x);
|
return(x);
|
}
|
}
|
|
|
return(0);
|
return(0);
|
|
|
