zenithsiz/ftmemsim-valgrind
1
0
Fork 0
mirror of https://github.com/Zenithsiz/ftmemsim-valgrind.git synced 2026-02-04 02:18:37 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
ftmemsim-valgrind/VEX/switchback/test_emfloat.c
Florian Krohm 20c839559a Companion patch of valgrind r14664. 
git-svn-id: svn://svn.valgrind.org/vex/trunk@2978
2014-10-25 20:10:30 +00:00

1943 lines
52 KiB
C
Raw Blame History

/*
** emfloat.c
** Source for emulated floating-point routines.
** BYTEmark (tm)
** BYTE's Native Mode Benchmarks
** Rick Grehan, BYTE Magazine.
**
** Created:
** Last update: 3/95
**
** DISCLAIMER
** The source, executable, and documentation files that comprise
** the BYTEmark benchmarks are made available on an "as is" basis.
** This means that we at BYTE Magazine have made every reasonable
** effort to verify that the there are no errors in the source and
** executable code. We cannot, however, guarantee that the programs
** are error-free. Consequently, McGraw-HIll and BYTE Magazine make
** no claims in regard to the fitness of the source code, executable
** code, and documentation of the BYTEmark.
** Furthermore, BYTE Magazine, McGraw-Hill, and all employees
** of McGraw-Hill cannot be held responsible for any damages resulting
** from the use of this code or the results obtained from using
** this code.
*/
#include "../pub/libvex_basictypes.h"
static HWord (*serviceFn)(HWord,HWord) = 0;
/////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////
static char* my_strcpy ( char* dest, const char* src )
{
char* dest_orig = dest;
while (*src) *dest++ = *src++;
*dest = 0;
return dest_orig;
}
static void* my_memcpy ( void *dest, const void *src, int sz )
{
const char *s = (const char *)src;
char *d = (char *)dest;
while (sz--)
*d++ = *s++;
return dest;
}
static void* my_memmove( void *dst, const void *src, unsigned int len )
{
register char *d;
register char *s;
if ( dst > src ) {
d = (char *)dst + len - 1;
s = (char *)src + len - 1;
while ( len >= 4 ) {
*d-- = *s--;
*d-- = *s--;
*d-- = *s--;
*d-- = *s--;
len -= 4;
}
while ( len-- ) {
*d-- = *s--;
}
} else if ( dst < src ) {
d = (char *)dst;
s = (char *)src;
while ( len >= 4 ) {
*d++ = *s++;
*d++ = *s++;
*d++ = *s++;
*d++ = *s++;
len -= 4;
}
while ( len-- ) {
*d++ = *s++;
}
}
return dst;
}
/////////////////////////////////////////////////////////////////////
static void vexxx_log_bytes ( char* p, int n )
{
int i;
for (i = 0; i < n; i++)
(*serviceFn)( 1, (int)p[i] );
}
/*---------------------------------------------------------*/
/*--- vexxx_printf ---*/
/*---------------------------------------------------------*/
/* This should be the only <...> include in the entire VEXXX library.
New code for vexxx_util.c should go above this point. */
#include <stdarg.h>
static HChar vexxx_toupper ( HChar c )
{
if (c >= 'a' && c <= 'z')
return toHChar(c + ('A' - 'a'));
else
return c;
}
static Int vexxx_strlen ( const HChar* str )
{
Int i = 0;
while (str[i] != 0) i++;
return i;
}
Bool vexxx_streq ( const HChar* s1, const HChar* s2 )
{
while (True) {
if (*s1 == 0 && *s2 == 0)
return True;
if (*s1 != *s2)
return False;
s1++;
s2++;
}
}
/* Some flags. */
#define VG_MSG_SIGNED 1 /* The value is signed. */
#define VG_MSG_ZJUSTIFY 2 /* Must justify with '0'. */
#define VG_MSG_LJUSTIFY 4 /* Must justify on the left. */
#define VG_MSG_PAREN 8 /* Parenthesize if present (for %y) */
#define VG_MSG_COMMA 16 /* Add commas to numbers (for %d, %u) */
/* Copy a string into the buffer. */
static UInt
myvprintf_str ( void(*send)(HChar), Int flags, Int width, HChar* str,
Bool capitalise )
{
# define MAYBE_TOUPPER(ch) toHChar(capitalise ? vexxx_toupper(ch) : (ch))
UInt ret = 0;
Int i, extra;
Int len = vexxx_strlen(str);
if (width == 0) {
ret += len;
for (i = 0; i < len; i++)
send(MAYBE_TOUPPER(str[i]));
return ret;
}
if (len > width) {
ret += width;
for (i = 0; i < width; i++)
send(MAYBE_TOUPPER(str[i]));
return ret;
}
extra = width - len;
if (flags & VG_MSG_LJUSTIFY) {
ret += extra;
for (i = 0; i < extra; i++)
send(' ');
}
ret += len;
for (i = 0; i < len; i++)
send(MAYBE_TOUPPER(str[i]));
if (!(flags & VG_MSG_LJUSTIFY)) {
ret += extra;
for (i = 0; i < extra; i++)
send(' ');
}
# undef MAYBE_TOUPPER
return ret;
}
/* Write P into the buffer according to these args:
* If SIGN is true, p is a signed.
* BASE is the base.
* If WITH_ZERO is true, '0' must be added.
* WIDTH is the width of the field.
*/
static UInt
myvprintf_int64 ( void(*send)(HChar), Int flags, Int base, Int width, ULong pL)
{
HChar buf[40];
Int ind = 0;
Int i, nc = 0;
Bool neg = False;
HChar *digits = "0123456789ABCDEF";
UInt ret = 0;
UInt p = (UInt)pL;
if (base < 2 || base > 16)
return ret;
if ((flags & VG_MSG_SIGNED) && (Int)p < 0) {
p = - (Int)p;
neg = True;
}
if (p == 0)
buf[ind++] = '0';
else {
while (p > 0) {
if ((flags & VG_MSG_COMMA) && 10 == base &&
0 == (ind-nc) % 3 && 0 != ind)
{
buf[ind++] = ',';
nc++;
}
buf[ind++] = digits[p % base];
p /= base;
}
}
if (neg)
buf[ind++] = '-';
if (width > 0 && !(flags & VG_MSG_LJUSTIFY)) {
for(; ind < width; ind++) {
//vassert(ind < 39);
buf[ind] = toHChar((flags & VG_MSG_ZJUSTIFY) ? '0': ' ');
}
}
/* Reverse copy to buffer. */
ret += ind;
for (i = ind -1; i >= 0; i--) {
send(buf[i]);
}
if (width > 0 && (flags & VG_MSG_LJUSTIFY)) {
for(; ind < width; ind++) {
ret++;
send(' '); // Never pad with zeroes on RHS -- changes the value!
}
}
return ret;
}
/* A simple vprintf(). */
static
UInt vprintf_wrk ( void(*send)(HChar), const HChar *format, va_list vargs )
{
UInt ret = 0;
int i;
int flags;
int width;
Bool is_long;
/* We assume that vargs has already been initialised by the
caller, using va_start, and that the caller will similarly
clean up with va_end.
*/
for (i = 0; format[i] != 0; i++) {
if (format[i] != '%') {
send(format[i]);
ret++;
continue;
}
i++;
/* A '%' has been found. Ignore a trailing %. */
if (format[i] == 0)
break;
if (format[i] == '%') {
/* `%%' is replaced by `%'. */
send('%');
ret++;
continue;
}
flags = 0;
is_long = False;
width = 0; /* length of the field. */
if (format[i] == '(') {
flags |= VG_MSG_PAREN;
i++;
}
/* If ',' follows '%', commas will be inserted. */
if (format[i] == ',') {
flags |= VG_MSG_COMMA;
i++;
}
/* If '-' follows '%', justify on the left. */
if (format[i] == '-') {
flags |= VG_MSG_LJUSTIFY;
i++;
}
/* If '0' follows '%', pads will be inserted. */
if (format[i] == '0') {
flags |= VG_MSG_ZJUSTIFY;
i++;
}
/* Compute the field length. */
while (format[i] >= '0' && format[i] <= '9') {
width *= 10;
width += format[i++] - '0';
}
while (format[i] == 'l') {
i++;
is_long = True;
}
switch (format[i]) {
case 'd': /* %d */
flags |= VG_MSG_SIGNED;
if (is_long)
ret += myvprintf_int64(send, flags, 10, width,
(ULong)(va_arg (vargs, Long)));
else
ret += myvprintf_int64(send, flags, 10, width,
(ULong)(va_arg (vargs, Int)));
break;
case 'u': /* %u */
if (is_long)
ret += myvprintf_int64(send, flags, 10, width,
(ULong)(va_arg (vargs, ULong)));
else
ret += myvprintf_int64(send, flags, 10, width,
(ULong)(va_arg (vargs, UInt)));
break;
case 'p': /* %p */
ret += 2;
send('0');
send('x');
ret += myvprintf_int64(send, flags, 16, width,
(ULong)((HWord)va_arg (vargs, void *)));
break;
case 'x': /* %x */
if (is_long)
ret += myvprintf_int64(send, flags, 16, width,
(ULong)(va_arg (vargs, ULong)));
else
ret += myvprintf_int64(send, flags, 16, width,
(ULong)(va_arg (vargs, UInt)));
break;
case 'c': /* %c */
ret++;
send(toHChar(va_arg (vargs, int)));
break;
case 's': case 'S': { /* %s */
char *str = va_arg (vargs, char *);
if (str == (char*) 0) str = "(null)";
ret += myvprintf_str(send, flags, width, str,
toBool(format[i]=='S'));
break;
}
# if 0
case 'y': { /* %y - print symbol */
Addr a = va_arg(vargs, Addr);
HChar *name;
if (VG_(get_fnname_w_offset)(a, &name)) {
HChar buf[1 + VG_strlen(name) + 1 + 1];
if (flags & VG_MSG_PAREN) {
VG_(sprintf)(str, "(%s)", name):
} else {
VG_(sprintf)(str, "%s", name):
}
ret += myvprintf_str(send, flags, width, buf, 0);
}
break;
}
# endif
default:
break;
}
}
return ret;
}
/* A general replacement for printf(). Note that only low-level
debugging info should be sent via here. The official route is to
to use vg_message(). This interface is deprecated.
*/
static HChar myprintf_buf[1000];
static Int n_myprintf_buf;
static void add_to_myprintf_buf ( HChar c )
{
if (c == '\n' || n_myprintf_buf >= 1000-10 /*paranoia*/ ) {
(*vexxx_log_bytes)( myprintf_buf, vexxx_strlen(myprintf_buf) );
n_myprintf_buf = 0;
myprintf_buf[n_myprintf_buf] = 0;
}
myprintf_buf[n_myprintf_buf++] = c;
myprintf_buf[n_myprintf_buf] = 0;
}
static UInt vexxx_printf ( const char *format, ... )
{
UInt ret;
va_list vargs;
va_start(vargs,format);
n_myprintf_buf = 0;
myprintf_buf[n_myprintf_buf] = 0;
ret = vprintf_wrk ( add_to_myprintf_buf, format, vargs );
if (n_myprintf_buf > 0) {
(*vexxx_log_bytes)( myprintf_buf, n_myprintf_buf );
}
va_end(vargs);
return ret;
}
/*---------------------------------------------------------------*/
/*--- end vexxx_util.c ---*/
/*---------------------------------------------------------------*/
/////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////
//#include <stdio.h>
//#include <string.h>
//#include <malloc.h>
typedef unsigned char uchar;
typedef unsigned int uint;
typedef unsigned short ushort;
typedef unsigned long ulong;
typedef int int32; /* Signed 32 bit integer */
#define INTERNAL_FPF_PRECISION 4
#define CPUEMFLOATLOOPMAX 500000L
#define EMFARRAYSIZE 3000L
typedef struct {
int adjust; /* Set adjust code */
ulong request_secs; /* # of seconds requested */
ulong arraysize; /* Size of array */
ulong loops; /* Loops per iterations */
double emflops; /* Results */
} EmFloatStruct;
/* Is this a 64 bit architecture? If so, this will define LONG64 */
/* Uwe F. Mayer 15 November 1997 */
// #include "pointer.h"
#define u8 unsigned char
#define u16 unsigned short
#ifdef LONG64
#define u32 unsigned int
#else
#define u32 unsigned long
#endif
#define uchar unsigned char
#define ulong unsigned long
#define MAX_EXP 32767L
#define MIN_EXP (-32767L)
#define IFPF_IS_ZERO 0
#define IFPF_IS_SUBNORMAL 1
#define IFPF_IS_NORMAL 2
#define IFPF_IS_INFINITY 3
#define IFPF_IS_NAN 4
#define IFPF_TYPE_COUNT 5
#define ZERO_ZERO 0
#define ZERO_SUBNORMAL 1
#define ZERO_NORMAL 2
#define ZERO_INFINITY 3
#define ZERO_NAN 4
#define SUBNORMAL_ZERO 5
#define SUBNORMAL_SUBNORMAL 6
#define SUBNORMAL_NORMAL 7
#define SUBNORMAL_INFINITY 8
#define SUBNORMAL_NAN 9
#define NORMAL_ZERO 10
#define NORMAL_SUBNORMAL 11
#define NORMAL_NORMAL 12
#define NORMAL_INFINITY 13
#define NORMAL_NAN 14
#define INFINITY_ZERO 15
#define INFINITY_SUBNORMAL 16
#define INFINITY_NORMAL 17
#define INFINITY_INFINITY 18
#define INFINITY_NAN 19
#define NAN_ZERO 20
#define NAN_SUBNORMAL 21
#define NAN_NORMAL 22
#define NAN_INFINITY 23
#define NAN_NAN 24
#define OPERAND_ZERO 0
#define OPERAND_SUBNORMAL 1
#define OPERAND_NORMAL 2
#define OPERAND_INFINITY 3
#define OPERAND_NAN 4
typedef struct
{
u8 type; /* Indicates, NORMAL, SUBNORMAL, etc. */
u8 sign; /* Mantissa sign */
short exp; /* Signed exponent...no bias */
u16 mantissa[INTERNAL_FPF_PRECISION];
} InternalFPF;
static
void SetupCPUEmFloatArrays(InternalFPF *abase,
InternalFPF *bbase, InternalFPF *cbase, ulong arraysize);
static
ulong DoEmFloatIteration(InternalFPF *abase,
InternalFPF *bbase, InternalFPF *cbase,
ulong arraysize, ulong loops);
static void SetInternalFPFZero(InternalFPF *dest,
uchar sign);
static void SetInternalFPFInfinity(InternalFPF *dest,
uchar sign);
static void SetInternalFPFNaN(InternalFPF *dest);
static int IsMantissaZero(u16 *mant);
static void Add16Bits(u16 *carry,u16 *a,u16 b,u16 c);
static void Sub16Bits(u16 *borrow,u16 *a,u16 b,u16 c);
static void ShiftMantLeft1(u16 *carry,u16 *mantissa);
static void ShiftMantRight1(u16 *carry,u16 *mantissa);
static void StickyShiftRightMant(InternalFPF *ptr,int amount);
static void normalize(InternalFPF *ptr);
static void denormalize(InternalFPF *ptr,int minimum_exponent);
static void RoundInternalFPF(InternalFPF *ptr);
static void choose_nan(InternalFPF *x,InternalFPF *y,InternalFPF *z,
int intel_flag);
static void AddSubInternalFPF(uchar operation,InternalFPF *x,
InternalFPF *y,InternalFPF *z);
static void MultiplyInternalFPF(InternalFPF *x,InternalFPF *y,
InternalFPF *z);
static void DivideInternalFPF(InternalFPF *x,InternalFPF *y,
InternalFPF *z);
static void Int32ToInternalFPF(int32 mylong,
InternalFPF *dest);
static int InternalFPFToString(char *dest,
InternalFPF *src);
static int32 randnum(int32 lngval);
static int32 randwc(int32 num)
{
return(randnum((int32)0)%num);
}
static int32 randw[2] = { (int32)13 , (int32)117 };
static int32 randnum(int32 lngval)
{
register int32 interm;
if (lngval!=(int32)0)
{ randw[0]=(int32)13; randw[1]=(int32)117; }
interm=(randw[0]*(int32)254754+randw[1]*(int32)529562)%(int32)999563;
randw[1]=randw[0];
randw[0]=interm;
return(interm);
}
static
void SetupCPUEmFloatArrays(InternalFPF *abase,
InternalFPF *bbase,
InternalFPF *cbase,
ulong arraysize)
{
ulong i;
InternalFPF locFPF1,locFPF2;
randnum((int32)13);
for(i=0;i<arraysize;i++)
{/* LongToInternalFPF(randwc(50000L),&locFPF1); */
Int32ToInternalFPF(randwc((int32)50000),&locFPF1);
/* LongToInternalFPF(randwc(50000L)+1L,&locFPF2); */
Int32ToInternalFPF(randwc((int32)50000)+(int32)1,&locFPF2);
DivideInternalFPF(&locFPF1,&locFPF2,abase+i);
/* LongToInternalFPF(randwc(50000L)+1L,&locFPF2); */
Int32ToInternalFPF(randwc((int32)50000)+(int32)1,&locFPF2);
DivideInternalFPF(&locFPF1,&locFPF2,bbase+i);
}
return;
}
static char* str1 = "loops %d\n";
static
ulong DoEmFloatIteration(InternalFPF *abase,
InternalFPF *bbase,
InternalFPF *cbase,
ulong arraysize, ulong loops)
{
static uchar jtable[16] = {0,0,0,0,1,1,1,1,2,2,2,2,2,3,3,3};
ulong i;
int number_of_loops;
loops = 100;
number_of_loops=loops-1; /* the index of the first loop we run */
vexxx_printf(str1, (int)loops);
/*
** Each pass through the array performs operations in
** the followingratios:
** 4 adds, 4 subtracts, 5 multiplies, 3 divides
** (adds and subtracts being nearly the same operation)
*/
{
for(i=0;i<arraysize;i++)
switch(jtable[i % 16])
{
case 0: /* Add */
AddSubInternalFPF(0,abase+i,
bbase+i,
cbase+i);
break;
case 1: /* Subtract */
AddSubInternalFPF(1,abase+i,
bbase+i,
cbase+i);
break;
case 2: /* Multiply */
MultiplyInternalFPF(abase+i,
bbase+i,
cbase+i);
break;
case 3: /* Divide */
DivideInternalFPF(abase+i,
bbase+i,
cbase+i);
break;
}
{
ulong j[8]; /* we test 8 entries */
int k;
ulong i;
char buffer[1024];
if (100==loops) /* the first loop */
{
j[0]=(ulong)2;
j[1]=(ulong)6;
j[2]=(ulong)10;
j[3]=(ulong)14;
j[4]=(ulong)(arraysize-14);
j[5]=(ulong)(arraysize-10);
j[6]=(ulong)(arraysize-6);
j[7]=(ulong)(arraysize-2);
for(k=0;k<8;k++){
i=j[k];
InternalFPFToString(buffer,abase+i);
vexxx_printf("%6d: (%s) ",i,buffer);
switch(jtable[i % 16])
{
case 0: my_strcpy(buffer,"+"); break;
case 1: my_strcpy(buffer,"-"); break;
case 2: my_strcpy(buffer,"*"); break;
case 3: my_strcpy(buffer,"/"); break;
}
vexxx_printf("%s ",buffer);
InternalFPFToString(buffer,bbase+i);
vexxx_printf("(%s) = ",buffer);
InternalFPFToString(buffer,cbase+i);
vexxx_printf("%s\n",buffer);
}
return 0;
}
}
}
return 0;
}
/***********************
** SetInternalFPFZero **
************************
** Set an internal floating-point-format number to zero.
** sign determines the sign of the zero.
*/
static void SetInternalFPFZero(InternalFPF *dest,
uchar sign)
{
int i; /* Index */
dest->type=IFPF_IS_ZERO;
dest->sign=sign;
dest->exp=MIN_EXP;
for(i=0;i<INTERNAL_FPF_PRECISION;i++)
dest->mantissa[i]=0;
return;
}
/***************************
** SetInternalFPFInfinity **
****************************
** Set an internal floating-point-format number to infinity.
** This can happen if the exponent exceeds MAX_EXP.
** As above, sign picks the sign of infinity.
*/
static void SetInternalFPFInfinity(InternalFPF *dest,
uchar sign)
{
int i; /* Index */
dest->type=IFPF_IS_INFINITY;
dest->sign=sign;
dest->exp=MIN_EXP;
for(i=0;i<INTERNAL_FPF_PRECISION;i++)
dest->mantissa[i]=0;
return;
}
/**********************
** SetInternalFPFNaN **
***********************
** Set an internal floating-point-format number to Nan
** (not a number). Note that we "emulate" an 80x87 as far
** as the mantissa bits go.
*/
static void SetInternalFPFNaN(InternalFPF *dest)
{
int i; /* Index */
dest->type=IFPF_IS_NAN;
dest->exp=MAX_EXP;
dest->sign=1;
dest->mantissa[0]=0x4000;
for(i=1;i<INTERNAL_FPF_PRECISION;i++)
dest->mantissa[i]=0;
return;
}
/*******************
** IsMantissaZero **
********************
** Pass this routine a pointer to an internal floating point format
** number's mantissa. It checks for an all-zero mantissa.
** Returns 0 if it is NOT all zeros, !=0 otherwise.
*/
static int IsMantissaZero(u16 *mant)
{
int i; /* Index */
int n; /* Return value */
n=0;
for(i=0;i<INTERNAL_FPF_PRECISION;i++)
n|=mant[i];
return(!n);
}
/**************
** Add16Bits **
***************
** Add b, c, and carry. Retult in a. New carry in carry.
*/
static void Add16Bits(u16 *carry,
u16 *a,
u16 b,
u16 c)
{
u32 accum; /* Accumulator */
/*
** Do the work in the 32-bit accumulator so we can return
** the carry.
*/
accum=(u32)b;
accum+=(u32)c;
accum+=(u32)*carry;
*carry=(u16)((accum & 0x00010000) ? 1 : 0); /* New carry */
*a=(u16)(accum & 0xFFFF); /* Result is lo 16 bits */
return;
}
/**************
** Sub16Bits **
***************
** Additive inverse of above.
*/
static void Sub16Bits(u16 *borrow,
u16 *a,
u16 b,
u16 c)
{
u32 accum; /* Accumulator */
accum=(u32)b;
accum-=(u32)c;
accum-=(u32)*borrow;
*borrow=(u32)((accum & 0x00010000) ? 1 : 0); /* New borrow */
*a=(u16)(accum & 0xFFFF);
return;
}
/*******************
** ShiftMantLeft1 **
********************
** Shift a vector of 16-bit numbers left 1 bit. Also provides
** a carry bit, which is shifted in at the beginning, and
** shifted out at the end.
*/
static void ShiftMantLeft1(u16 *carry,
u16 *mantissa)
{
int i; /* Index */
int new_carry;
u16 accum; /* Temporary holding placed */
for(i=INTERNAL_FPF_PRECISION-1;i>=0;i--)
{ accum=mantissa[i];
new_carry=accum & 0x8000; /* Get new carry */
accum=accum<<1; /* Do the shift */
if(*carry)
accum|=1; /* Insert previous carry */
*carry=new_carry;
mantissa[i]=accum; /* Return shifted value */
}
return;
}
/********************
** ShiftMantRight1 **
*********************
** Shift a mantissa right by 1 bit. Provides carry, as
** above
*/
static void ShiftMantRight1(u16 *carry,
u16 *mantissa)
{
int i; /* Index */
int new_carry;
u16 accum;
for(i=0;i<INTERNAL_FPF_PRECISION;i++)
{ accum=mantissa[i];
new_carry=accum & 1; /* Get new carry */
accum=accum>>1;
if(*carry)
accum|=0x8000;
*carry=new_carry;
mantissa[i]=accum;
}
return;
}
/*****************************
** StickyShiftMantRight **
******************************
** This is a shift right of the mantissa with a "sticky bit".
** I.E., if a carry of 1 is shifted out of the least significant
** bit, the least significant bit is set to 1.
*/
static void StickyShiftRightMant(InternalFPF *ptr,
int amount)
{
int i; /* Index */
u16 carry; /* Self-explanatory */
u16 *mantissa;
mantissa=ptr->mantissa;
if(ptr->type!=IFPF_IS_ZERO) /* Don't bother shifting a zero */
{
/*
** If the amount of shifting will shift everyting
** out of existence, then just clear the whole mantissa
** and set the lowmost bit to 1.
*/
if(amount>=INTERNAL_FPF_PRECISION * 16)
{
for(i=0;i<INTERNAL_FPF_PRECISION-1;i++)
mantissa[i]=0;
mantissa[INTERNAL_FPF_PRECISION-1]=1;
}
else
for(i=0;i<amount;i++)
{
carry=0;
ShiftMantRight1(&carry,mantissa);
if(carry)
mantissa[INTERNAL_FPF_PRECISION-1] |= 1;
}
}
return;
}
/**************************************************
** POST ARITHMETIC PROCESSING **
** (NORMALIZE, ROUND, OVERFLOW, AND UNDERFLOW) **
**************************************************/
/**************
** normalize **
***************
** Normalize an internal-representation number. Normalization
** discards empty most-significant bits.
*/
static void normalize(InternalFPF *ptr)
{
u16 carry;
/*
** As long as there's a highmost 0 bit, shift the significand
** left 1 bit. Each time you do this, though, you've
** gotta decrement the exponent.
*/
while ((ptr->mantissa[0] & 0x8000) == 0)
{
carry = 0;
ShiftMantLeft1(&carry, ptr->mantissa);
ptr->exp--;
}
return;
}
/****************
** denormalize **
*****************
** Denormalize an internal-representation number. This means
** shifting it right until its exponent is equivalent to
** minimum_exponent. (You have to do this often in order
** to perform additions and subtractions).
*/
static void denormalize(InternalFPF *ptr,
int minimum_exponent)
{
long exponent_difference;
if (IsMantissaZero(ptr->mantissa))
{
vexxx_printf("Error: zero significand in denormalize\n");
}
exponent_difference = ptr->exp-minimum_exponent;
if (exponent_difference < 0)
{
/*
** The number is subnormal
*/
exponent_difference = -exponent_difference;
if (exponent_difference >= (INTERNAL_FPF_PRECISION * 16))
{
/* Underflow */
SetInternalFPFZero(ptr, ptr->sign);
}
else
{
ptr->exp+=exponent_difference;
StickyShiftRightMant(ptr, exponent_difference);
}
}
return;
}
/*********************
** RoundInternalFPF **
**********************
** Round an internal-representation number.
** The kind of rounding we do here is simplest...referred to as
** "chop". "Extraneous" rightmost bits are simply hacked off.
*/
void RoundInternalFPF(InternalFPF *ptr)
{
/* int i; */
if (ptr->type == IFPF_IS_NORMAL ||
ptr->type == IFPF_IS_SUBNORMAL)
{
denormalize(ptr, MIN_EXP);
if (ptr->type != IFPF_IS_ZERO)
{
/* clear the extraneous bits */
ptr->mantissa[3] &= 0xfff8;
/* for (i=4; i<INTERNAL_FPF_PRECISION; i++)
{
ptr->mantissa[i] = 0;
}
*/
/*
** Check for overflow
*/
/* Does not do anything as ptr->exp is a short and MAX_EXP=37268
if (ptr->exp > MAX_EXP)
{
SetInternalFPFInfinity(ptr, ptr->sign);
}
*/
}
}
return;
}
/*******************************************************
** ARITHMETIC OPERATIONS ON INTERNAL REPRESENTATION **
*******************************************************/
/***************
** choose_nan **
****************
** Called by routines that are forced to perform math on
** a pair of NaN's. This routine "selects" which NaN is
** to be returned.
*/
static void choose_nan(InternalFPF *x,
InternalFPF *y,
InternalFPF *z,
int intel_flag)
{
int i;
/*
** Compare the two mantissas,
** return the larger. Note that we will be emulating
** an 80387 in this operation.
*/
for (i=0; i<INTERNAL_FPF_PRECISION; i++)
{
if (x->mantissa[i] > y->mantissa[i])
{
my_memmove((void *)x,(void *)z,sizeof(InternalFPF));
return;
}
if (x->mantissa[i] < y->mantissa[i])
{
my_memmove((void *)y,(void *)z,sizeof(InternalFPF));
return;
}
}
/*
** They are equal
*/
if (!intel_flag)
/* if the operation is addition */
my_memmove((void *)x,(void *)z,sizeof(InternalFPF));
else
/* if the operation is multiplication */
my_memmove((void *)y,(void *)z,sizeof(InternalFPF));
return;
}
/**********************
** AddSubInternalFPF **
***********************
** Adding or subtracting internal-representation numbers.
** Internal-representation numbers pointed to by x and y are
** added/subtracted and the result returned in z.
*/
static void AddSubInternalFPF(uchar operation,
InternalFPF *x,
InternalFPF *y,
InternalFPF *z)
{
int exponent_difference;
u16 borrow;
u16 carry;
int i;
InternalFPF locx,locy; /* Needed since we alter them */
/*
** Following big switch statement handles the
** various combinations of operand types.
*/
switch ((x->type * IFPF_TYPE_COUNT) + y->type)
{
case ZERO_ZERO:
my_memmove((void *)x,(void *)z,sizeof(InternalFPF));
if (x->sign ^ y->sign ^ operation)
{
z->sign = 0; /* positive */
}
break;
case NAN_ZERO:
case NAN_SUBNORMAL:
case NAN_NORMAL:
case NAN_INFINITY:
case SUBNORMAL_ZERO:
case NORMAL_ZERO:
case INFINITY_ZERO:
case INFINITY_SUBNORMAL:
case INFINITY_NORMAL:
my_memmove((void *)x,(void *)z,sizeof(InternalFPF));
break;
case ZERO_NAN:
case SUBNORMAL_NAN:
case NORMAL_NAN:
case INFINITY_NAN:
my_memmove((void *)y,(void *)z,sizeof(InternalFPF));
break;
case ZERO_SUBNORMAL:
case ZERO_NORMAL:
case ZERO_INFINITY:
case SUBNORMAL_INFINITY:
case NORMAL_INFINITY:
my_memmove((void *)y,(void *)z,sizeof(InternalFPF));
z->sign ^= operation;
break;
case SUBNORMAL_SUBNORMAL:
case SUBNORMAL_NORMAL:
case NORMAL_SUBNORMAL:
case NORMAL_NORMAL:
/*
** Copy x and y to locals, since we may have
** to alter them.
*/
my_memmove((void *)&locx,(void *)x,sizeof(InternalFPF));
my_memmove((void *)&locy,(void *)y,sizeof(InternalFPF));
/* compute sum/difference */
exponent_difference = locx.exp-locy.exp;
if (exponent_difference == 0)
{
/*
** locx.exp == locy.exp
** so, no shifting required
*/
if (locx.type == IFPF_IS_SUBNORMAL ||
locy.type == IFPF_IS_SUBNORMAL)
z->type = IFPF_IS_SUBNORMAL;
else
z->type = IFPF_IS_NORMAL;
/*
** Assume that locx.mantissa > locy.mantissa
*/
z->sign = locx.sign;
z->exp= locx.exp;
}
else
if (exponent_difference > 0)
{
/*
** locx.exp > locy.exp
*/
StickyShiftRightMant(&locy,
exponent_difference);
z->type = locx.type;
z->sign = locx.sign;
z->exp = locx.exp;
}
else /* if (exponent_difference < 0) */
{
/*
** locx.exp < locy.exp
*/
StickyShiftRightMant(&locx,
-exponent_difference);
z->type = locy.type;
z->sign = locy.sign ^ operation;
z->exp = locy.exp;
}
if (locx.sign ^ locy.sign ^ operation)
{
/*
** Signs are different, subtract mantissas
*/
borrow = 0;
for (i=(INTERNAL_FPF_PRECISION-1); i>=0; i--)
Sub16Bits(&borrow,
&z->mantissa[i],
locx.mantissa[i],
locy.mantissa[i]);
if (borrow)
{
/* The y->mantissa was larger than the
** x->mantissa leaving a negative
** result. Change the result back to
** an unsigned number and flip the
** sign flag.
*/
z->sign = locy.sign ^ operation;
borrow = 0;
for (i=(INTERNAL_FPF_PRECISION-1); i>=0; i--)
{
Sub16Bits(&borrow,
&z->mantissa[i],
0,
z->mantissa[i]);
}
}
else
{
/* The assumption made above
** (i.e. x->mantissa >= y->mantissa)
** was correct. Therefore, do nothing.
** z->sign = x->sign;
*/
}
if (IsMantissaZero(z->mantissa))
{
z->type = IFPF_IS_ZERO;
z->sign = 0; /* positive */
}
else
if (locx.type == IFPF_IS_NORMAL ||
locy.type == IFPF_IS_NORMAL)
{
normalize(z);
}
}
else
{
/* signs are the same, add mantissas */
carry = 0;
for (i=(INTERNAL_FPF_PRECISION-1); i>=0; i--)
{
Add16Bits(&carry,
&z->mantissa[i],
locx.mantissa[i],
locy.mantissa[i]);
}
if (carry)
{
z->exp++;
carry=0;
ShiftMantRight1(&carry,z->mantissa);
z->mantissa[0] |= 0x8000;
z->type = IFPF_IS_NORMAL;
}
else
if (z->mantissa[0] & 0x8000)
z->type = IFPF_IS_NORMAL;
}
break;
case INFINITY_INFINITY:
SetInternalFPFNaN(z);
break;
case NAN_NAN:
choose_nan(x, y, z, 1);
break;
}
/*
** All the math is done; time to round.
*/
RoundInternalFPF(z);
return;
}
/************************
** MultiplyInternalFPF **
*************************
** Two internal-representation numbers x and y are multiplied; the
** result is returned in z.
*/
static void MultiplyInternalFPF(InternalFPF *x,
InternalFPF *y,
InternalFPF *z)
{
int i;
int j;
u16 carry;
u16 extra_bits[INTERNAL_FPF_PRECISION];
InternalFPF locy; /* Needed since this will be altered */
/*
** As in the preceding function, this large switch
** statement selects among the many combinations
** of operands.
*/
switch ((x->type * IFPF_TYPE_COUNT) + y->type)
{
case INFINITY_SUBNORMAL:
case INFINITY_NORMAL:
case INFINITY_INFINITY:
case ZERO_ZERO:
case ZERO_SUBNORMAL:
case ZERO_NORMAL:
my_memmove((void *)x,(void *)z,sizeof(InternalFPF));
z->sign ^= y->sign;
break;
case SUBNORMAL_INFINITY:
case NORMAL_INFINITY:
case SUBNORMAL_ZERO:
case NORMAL_ZERO:
my_memmove((void *)y,(void *)z,sizeof(InternalFPF));
z->sign ^= x->sign;
break;
case ZERO_INFINITY:
case INFINITY_ZERO:
SetInternalFPFNaN(z);
break;
case NAN_ZERO:
case NAN_SUBNORMAL:
case NAN_NORMAL:
case NAN_INFINITY:
my_memmove((void *)x,(void *)z,sizeof(InternalFPF));
break;
case ZERO_NAN:
case SUBNORMAL_NAN:
case NORMAL_NAN:
case INFINITY_NAN:
my_memmove((void *)y,(void *)z,sizeof(InternalFPF));
break;
case SUBNORMAL_SUBNORMAL:
case SUBNORMAL_NORMAL:
case NORMAL_SUBNORMAL:
case NORMAL_NORMAL:
/*
** Make a local copy of the y number, since we will be
** altering it in the process of multiplying.
*/
my_memmove((void *)&locy,(void *)y,sizeof(InternalFPF));
/*
** Check for unnormal zero arguments
*/
if (IsMantissaZero(x->mantissa) || IsMantissaZero(y->mantissa))
SetInternalFPFInfinity(z, 0);
/*
** Initialize the result
*/
if (x->type == IFPF_IS_SUBNORMAL ||
y->type == IFPF_IS_SUBNORMAL)
z->type = IFPF_IS_SUBNORMAL;
else
z->type = IFPF_IS_NORMAL;
z->sign = x->sign ^ y->sign;
z->exp = x->exp + y->exp ;
for (i=0; i<INTERNAL_FPF_PRECISION; i++)
{
z->mantissa[i] = 0;
extra_bits[i] = 0;
}
for (i=0; i<(INTERNAL_FPF_PRECISION*16); i++)
{
/*
** Get rightmost bit of the multiplier
*/
carry = 0;
ShiftMantRight1(&carry, locy.mantissa);
if (carry)
{
/*
** Add the multiplicand to the product
*/
carry = 0;
for (j=(INTERNAL_FPF_PRECISION-1); j>=0; j--)
Add16Bits(&carry,
&z->mantissa[j],
z->mantissa[j],
x->mantissa[j]);
}
else
{
carry = 0;
}
/*
** Shift the product right. Overflow bits get
** shifted into extra_bits. We'll use it later
** to help with the "sticky" bit.
*/
ShiftMantRight1(&carry, z->mantissa);
ShiftMantRight1(&carry, extra_bits);
}
/*
** Normalize
** Note that we use a "special" normalization routine
** because we need to use the extra bits. (These are
** bits that may have been shifted off the bottom that
** we want to reclaim...if we can.
*/
while ((z->mantissa[0] & 0x8000) == 0)
{
carry = 0;
ShiftMantLeft1(&carry, extra_bits);
ShiftMantLeft1(&carry, z->mantissa);
z->exp--;
}
/*
** Set the sticky bit if any bits set in extra bits.
*/
if (IsMantissaZero(extra_bits))
{
z->mantissa[INTERNAL_FPF_PRECISION-1] |= 1;
}
break;
case NAN_NAN:
choose_nan(x, y, z, 0);
break;
}
/*
** All math done...do rounding.
*/
RoundInternalFPF(z);
return;
}
/**********************
** DivideInternalFPF **
***********************
** Divide internal FPF number x by y. Return result in z.
*/
static void DivideInternalFPF(InternalFPF *x,
InternalFPF *y,
InternalFPF *z)
{
int i;
int j;
u16 carry;
u16 extra_bits[INTERNAL_FPF_PRECISION];
InternalFPF locx; /* Local for x number */
/*
** As with preceding function, the following switch
** statement selects among the various possible
** operands.
*/
switch ((x->type * IFPF_TYPE_COUNT) + y->type)
{
case ZERO_ZERO:
case INFINITY_INFINITY:
SetInternalFPFNaN(z);
break;
case ZERO_SUBNORMAL:
case ZERO_NORMAL:
if (IsMantissaZero(y->mantissa))
{
SetInternalFPFNaN(z);
break;
}
case ZERO_INFINITY:
case SUBNORMAL_INFINITY:
case NORMAL_INFINITY:
SetInternalFPFZero(z, x->sign ^ y->sign);
break;
case SUBNORMAL_ZERO:
case NORMAL_ZERO:
if (IsMantissaZero(x->mantissa))
{
SetInternalFPFNaN(z);
break;
}
case INFINITY_ZERO:
case INFINITY_SUBNORMAL:
case INFINITY_NORMAL:
SetInternalFPFInfinity(z, 0);
z->sign = x->sign ^ y->sign;
break;
case NAN_ZERO:
case NAN_SUBNORMAL:
case NAN_NORMAL:
case NAN_INFINITY:
my_memmove((void *)x,(void *)z,sizeof(InternalFPF));
break;
case ZERO_NAN:
case SUBNORMAL_NAN:
case NORMAL_NAN:
case INFINITY_NAN:
my_memmove((void *)y,(void *)z,sizeof(InternalFPF));
break;
case SUBNORMAL_SUBNORMAL:
case NORMAL_SUBNORMAL:
case SUBNORMAL_NORMAL:
case NORMAL_NORMAL:
/*
** Make local copy of x number, since we'll be
** altering it in the process of dividing.
*/
my_memmove((void *)&locx,(void *)x,sizeof(InternalFPF));
/*
** Check for unnormal zero arguments
*/
if (IsMantissaZero(locx.mantissa))
{
if (IsMantissaZero(y->mantissa))
SetInternalFPFNaN(z);
else
SetInternalFPFZero(z, 0);
break;
}
if (IsMantissaZero(y->mantissa))
{
SetInternalFPFInfinity(z, 0);
break;
}
/*
** Initialize the result
*/
z->type = x->type;
z->sign = x->sign ^ y->sign;
z->exp = x->exp - y->exp +
((INTERNAL_FPF_PRECISION * 16 * 2));
for (i=0; i<INTERNAL_FPF_PRECISION; i++)
{
z->mantissa[i] = 0;
extra_bits[i] = 0;
}
while ((z->mantissa[0] & 0x8000) == 0)
{
carry = 0;
ShiftMantLeft1(&carry, locx.mantissa);
ShiftMantLeft1(&carry, extra_bits);
/*
** Time to subtract yet?
*/
if (carry == 0)
for (j=0; j<INTERNAL_FPF_PRECISION; j++)
{
if (y->mantissa[j] > extra_bits[j])
{
carry = 0;
goto no_subtract;
}
if (y->mantissa[j] < extra_bits[j])
break;
}
/*
** Divisor (y) <= dividend (x), subtract
*/
carry = 0;
for (j=(INTERNAL_FPF_PRECISION-1); j>=0; j--)
Sub16Bits(&carry,
&extra_bits[j],
extra_bits[j],
y->mantissa[j]);
carry = 1; /* 1 shifted into quotient */
no_subtract:
ShiftMantLeft1(&carry, z->mantissa);
z->exp--;
}
break;
case NAN_NAN:
choose_nan(x, y, z, 0);
break;
}
/*
** Math complete...do rounding
*/
RoundInternalFPF(z);
}
/**********************
** LongToInternalFPF **
** Int32ToInternalFPF **
***********************
** Convert a signed (long) 32-bit integer into an internal FPF number.
*/
/* static void LongToInternalFPF(long mylong, */
static void Int32ToInternalFPF(int32 mylong,
InternalFPF *dest)
{
int i; /* Index */
u16 myword; /* Used to hold converted stuff */
/*
** Save the sign and get the absolute value. This will help us
** with 64-bit machines, since we use only the lower 32
** bits just in case. (No longer necessary after we use int32.)
*/
/* if(mylong<0L) */
if(mylong<(int32)0)
{ dest->sign=1;
mylong=(int32)0-mylong;
}
else
dest->sign=0;
/*
** Prepare the destination floating point number
*/
dest->type=IFPF_IS_NORMAL;
for(i=0;i<INTERNAL_FPF_PRECISION;i++)
dest->mantissa[i]=0;
/*
** See if we've got a zero. If so, make the resultant FP
** number a true zero and go home.
*/
if(mylong==0)
{ dest->type=IFPF_IS_ZERO;
dest->exp=0;
return;
}
/*
** Not a true zero. Set the exponent to 32 (internal FPFs have
** no bias) and load the low and high words into their proper
** locations in the mantissa. Then normalize. The action of
** normalizing slides the mantissa bits into place and sets
** up the exponent properly.
*/
dest->exp=32;
myword=(u16)((mylong >> 16) & 0xFFFFL);
dest->mantissa[0]=myword;
myword=(u16)(mylong & 0xFFFFL);
dest->mantissa[1]=myword;
normalize(dest);
return;
}
#if 1
/************************
** InternalFPFToString **
*************************
** FOR DEBUG PURPOSES
** This routine converts an internal floating point representation
** number to a string. Used in debugging the package.
** Returns length of converted number.
** NOTE: dest must point to a buffer big enough to hold the
** result. Also, this routine does append a null (an effect
** of using the sprintf() function). It also returns
** a length count.
** NOTE: This routine returns 5 significant digits. Thats
** about all I feel safe with, given the method of
** conversion. It should be more than enough for programmers
** to determine whether the package is properly ported.
*/
static int InternalFPFToString(char *dest,
InternalFPF *src)
{
InternalFPF locFPFNum; /* Local for src (will be altered) */
InternalFPF IFPF10; /* Floating-point 10 */
InternalFPF IFPFComp; /* For doing comparisons */
int msign; /* Holding for mantissa sign */
int expcount; /* Exponent counter */
int ccount; /* Character counter */
int i,j,k; /* Index */
u16 carryaccum; /* Carry accumulator */
u16 mycarry; /* Local for carry */
/*
** Check first for the simple things...Nan, Infinity, Zero.
** If found, copy the proper string in and go home.
*/
switch(src->type)
{
case IFPF_IS_NAN:
my_memcpy(dest,"NaN",3);
return(3);
case IFPF_IS_INFINITY:
if(src->sign==0)
my_memcpy(dest,"+Inf",4);
else
my_memcpy(dest,"-Inf",4);
return(4);
case IFPF_IS_ZERO:
if(src->sign==0)
my_memcpy(dest,"+0",2);
else
my_memcpy(dest,"-0",2);
return(2);
}
/*
** Move the internal number into our local holding area, since
** we'll be altering it to print it out.
*/
my_memcpy((void *)&locFPFNum,(void *)src,sizeof(InternalFPF));
/*
** Set up a floating-point 10...which we'll use a lot in a minute.
*/
/* LongToInternalFPF(10L,&IFPF10); */
Int32ToInternalFPF((int32)10,&IFPF10);
/*
** Save the mantissa sign and make it positive.
*/
msign=src->sign;
/* src->sign=0 */ /* bug, fixed Nov. 13, 1997 */
(&locFPFNum)->sign=0;
expcount=0; /* Init exponent counter */
/*
** See if the number is less than 10. If so, multiply
** the number repeatedly by 10 until it's not. For each
** multiplication, decrement a counter so we can keep track
** of the exponent.
*/
while(1)
{ AddSubInternalFPF(1,&locFPFNum,&IFPF10,&IFPFComp);
if(IFPFComp.sign==0) break;
MultiplyInternalFPF(&locFPFNum,&IFPF10,&IFPFComp);
expcount--;
my_memcpy((void *)&locFPFNum,(void *)&IFPFComp,sizeof(InternalFPF));
}
/*
** Do the reverse of the above. As long as the number is
** greater than or equal to 10, divide it by 10. Increment the
** exponent counter for each multiplication.
*/
while(1)
{
AddSubInternalFPF(1,&locFPFNum,&IFPF10,&IFPFComp);
if(IFPFComp.sign!=0) break;
DivideInternalFPF(&locFPFNum,&IFPF10,&IFPFComp);
expcount++;
my_memcpy((void *)&locFPFNum,(void *)&IFPFComp,sizeof(InternalFPF));
}
/*
** About time to start storing things. First, store the
** mantissa sign.
*/
ccount=1; /* Init character counter */
if(msign==0)
*dest++='+';
else
*dest++='-';
/*
** At this point we know that the number is in the range
** 10 > n >=1. We need to "strip digits" out of the
** mantissa. We do this by treating the mantissa as
** an integer and multiplying by 10. (Not a floating-point
** 10, but an integer 10. Since this is debug code and we
** could care less about speed, we'll do it the stupid
** way and simply add the number to itself 10 times.
** Anything that makes it to the left of the implied binary point
** gets stripped off and emitted. We'll do this for
** 5 significant digits (which should be enough to
** verify things).
*/
/*
** Re-position radix point
*/
carryaccum=0;
while(locFPFNum.exp>0)
{
mycarry=0;
ShiftMantLeft1(&mycarry,locFPFNum.mantissa);
carryaccum=(carryaccum<<1);
if(mycarry) carryaccum++;
locFPFNum.exp--;
}
while(locFPFNum.exp<0)
{
mycarry=0;
ShiftMantRight1(&mycarry,locFPFNum.mantissa);
locFPFNum.exp++;
}
for(i=0;i<6;i++)
if(i==1)
{ /* Emit decimal point */
*dest++='.';
ccount++;
}
else
{ /* Emit a digit */
*dest++=('0'+carryaccum);
ccount++;
carryaccum=0;
my_memcpy((void *)&IFPF10,
(void *)&locFPFNum,
sizeof(InternalFPF));
/* Do multiply via repeated adds */
for(j=0;j<9;j++)
{
mycarry=0;
for(k=(INTERNAL_FPF_PRECISION-1);k>=0;k--)
Add16Bits(&mycarry,&(IFPFComp.mantissa[k]),
locFPFNum.mantissa[k],
IFPF10.mantissa[k]);
carryaccum+=mycarry ? 1 : 0;
my_memcpy((void *)&locFPFNum,
(void *)&IFPFComp,
sizeof(InternalFPF));
}
}
/*
** Now move the 'E', the exponent sign, and the exponent
** into the string.
*/
*dest++='E';
/* sprint is supposed to return an integer, but it caused problems on SunOS
* with the native cc. Hence we force it.
* Uwe F. Mayer
*/
if (expcount < 0) {
*dest++ = '-';
expcount =- expcount;
}
else *dest++ = ' ';
*dest++ = (char)(expcount + '0');
*dest++ = 0;
ccount += 3;
/*
** All done, go home.
*/
return(ccount);
}
#endif
////////////////////////////////////////////////////////////////////////
static
void* AllocateMemory ( unsigned long n, int* p )
{
*p = 0;
void* r = (void*) (*serviceFn)(2,n);
return r;
}
static
void FreeMemory ( void* p, int* zz )
{
*zz = 0;
// free(p);
}
/**************
** DoEmFloat **
***************
** Perform the floating-point emulation routines portion of the
** CPU benchmark. Returns the operations per second.
*/
static
void DoEmFloat(void)
{
EmFloatStruct *locemfloatstruct; /* Local structure */
InternalFPF *abase; /* Base of A array */
InternalFPF *bbase; /* Base of B array */
InternalFPF *cbase; /* Base of C array */
ulong tickcount; /* # of ticks */
char *errorcontext; /* Error context string pointer */
int systemerror; /* For holding error code */
ulong loops; /* # of loops */
/*
** Link to global structure
*/
EmFloatStruct global_emfloatstruct;
global_emfloatstruct.adjust = 0;
global_emfloatstruct.request_secs = 0;
global_emfloatstruct.arraysize = 100;
global_emfloatstruct.loops = 1;
global_emfloatstruct.emflops = 0.0;
locemfloatstruct=&global_emfloatstruct;
/*
** Set the error context
*/
errorcontext="CPU:Floating Emulation";
abase=(InternalFPF *)AllocateMemory(locemfloatstruct->arraysize*sizeof(InternalFPF),
&systemerror);
bbase=(InternalFPF *)AllocateMemory(locemfloatstruct->arraysize*sizeof(InternalFPF),
&systemerror);
cbase=(InternalFPF *)AllocateMemory(locemfloatstruct->arraysize*sizeof(InternalFPF),
&systemerror);
/*
** Set up the arrays
*/
SetupCPUEmFloatArrays(abase,bbase,cbase,locemfloatstruct->arraysize);
loops=100;
tickcount=DoEmFloatIteration(abase,bbase,cbase,
locemfloatstruct->arraysize,
loops);
FreeMemory((void *)abase,&systemerror);
FreeMemory((void *)bbase,&systemerror);
FreeMemory((void *)cbase,&systemerror);
return;
}
//////////////////
void entry ( HWord(*f)(HWord,HWord) )
{
serviceFn = f;
vexxx_printf("starting\n");
DoEmFloat();
(*serviceFn)(0,0);
}
Reference in New Issue View Git Blame Copy Permalink