1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
|
/* Testing Code */
#include <math.h>
#include <stdio.h>
#include <limits.h>
/* Routines used by floation point test code */
/* Convert from bit level representation to floating point number */
float u2f(unsigned u) {
union {
unsigned u;
float f;
} a;
a.u = u;
return a.f;
}
/* Convert from floating point number to bit-level representation */
unsigned f2u(float f) {
union {
unsigned u;
float f;
} a;
a.f = f;
return a.u;
}
int test_bitAnd(int x, int y) {
return x & y;
}
int test_bitXor(int x, int y) {
return x ^ y;
}
int test_logtwo(int v) {
if (v <= 1)
return 0; // 32-bit value to find the log2 of
const unsigned int b[] = {0x2, 0xC, 0xF0, 0xFF00, 0xFFFF0000};
const unsigned int S[] = {1, 2, 4, 8, 16};
int i;
unsigned int r = 0; // result of log2(v) will go here
for (i = 4; i >= 0; i--) // unroll for speed...
{
if (v & b[i]) {
v >>= S[i];
r |= S[i];
}
}
return r;
}
int test_byteSwap(int x, int n, int m) {
/* little endiamachine */
/* least significant byte stored first */
unsigned int nmask, mmask;
switch (n) {
case 0:
nmask = x & 0xFF;
x &= 0xFFFFFF00;
break;
case 1:
nmask = (x & 0xFF00) >> 8;
x &= 0xFFFF00FF;
break;
case 2:
nmask = (x & 0xFF0000) >> 16;
x &= 0xFF00FFFF;
break;
default:
nmask = ((unsigned int)(x & 0xFF000000)) >> 24;
x &= 0x00FFFFFF;
break;
}
switch (m) {
case 0:
mmask = x & 0xFF;
x &= 0xFFFFFF00;
break;
case 1:
mmask = (x & 0xFF00) >> 8;
x &= 0xFFFF00FF;
break;
case 2:
mmask = (x & 0xFF0000) >> 16;
x &= 0xFF00FFFF;
break;
default:
mmask = ((unsigned int)(x & 0xFF000000)) >> 24;
x &= 0x00FFFFFF;
break;
}
nmask <<= 8 * m;
mmask <<= 8 * n;
return x | nmask | mmask;
}
int test_samesign(int x, int y) {
if (x < 0 && y < 0) {
return 1;
} else if (x > 0 && y > 0) {
return 1;
} else if (x == y && x == 0) {
return 1;
} else {
return 0;
}
}
int test_logicalShift(int x, int n) {
unsigned u = (unsigned)x;
unsigned shifted = u >> n;
return (int)shifted;
}
unsigned test_reverse(unsigned v) {
static const unsigned char BitReverseTable256[256] =
{
#define R2(n) n, n + 2 * 64, n + 1 * 64, n + 3 * 64
#define R4(n) R2(n), R2(n + 2 * 16), R2(n + 1 * 16), R2(n + 3 * 16)
#define R6(n) R4(n), R4(n + 2 * 4), R4(n + 1 * 4), R4(n + 3 * 4)
R6(0), R6(2), R6(1), R6(3)};
unsigned int c;
c = (BitReverseTable256[v & 0xff] << 24) |
(BitReverseTable256[(v >> 8) & 0xff] << 16) |
(BitReverseTable256[(v >> 16) & 0xff] << 8) |
(BitReverseTable256[(v >> 24) & 0xff]);
return c;
}
unsigned test_float_i2f(int x) {
float f = (float)x;
return f2u(f);
}
int test_float64_f2i(unsigned uf1, unsigned uf2) {
unsigned sign = uf2 >> 31;
unsigned exp = (uf2 >> 20) & 0x7FF;
unsigned val = 0x80000000u | ((uf2 & 0xFFFFF) << 11) | (uf1 >> 21);
if (exp < 1023) {
return 0;
}
if (exp > 1054)
return 0x80000000u;
val = val >> (1054 - exp);
if (sign) {
return val > 0x80000000u ? 0x80000000u : -val;
} else {
return val > 0x7FFFFFFF ? 0x80000000u : val;
}
}
int test_leftBitCount(int x) {
int result = 0;
int i;
for (i = 31; i >= 0; i--) {
int bit = (x >> i) & 0x1;
if (!bit)
break;
result++;
}
return result;
}
unsigned test_floatScale2(unsigned uf) {
float f = u2f(uf);
float tf = 2 * f;
if (isnan(f))
return uf;
else
return f2u(tf);
}
unsigned test_floatPower2(int x) {
float result = 1.0;
float p2 = 2.0;
int recip = (x < 0);
/* treat tmin specially */
if ((unsigned)x == 0x80000000) {
return 0;
}
if (recip) {
x = -x;
p2 = 0.5;
}
while (x > 0) {
if (x & 0x1)
result = result * p2;
p2 = p2 * p2;
x >>= 1;
}
return f2u(result);
}
|
