23
23
*/
24
24
25
25
#include < stdlib.h>
26
+ #include < stdint.h>
26
27
#include " immediate_aarch64.hpp"
27
28
28
29
// there are at most 2^13 possible logical immediate encodings
@@ -34,14 +35,14 @@ static int li_table_entry_count;
34
35
// for forward lookup we just use a direct array lookup
35
36
// and assume that the cient has supplied a valid encoding
36
37
// table[encoding] = immediate
37
- static u_int64_t LITable[LI_TABLE_SIZE];
38
+ static uint64_t LITable[LI_TABLE_SIZE];
38
39
39
40
// for reverse lookup we need a sparse map so we store a table of
40
41
// immediate and encoding pairs sorted by immediate value
41
42
42
43
struct li_pair {
43
- u_int64_t immediate;
44
- u_int32_t encoding;
44
+ uint64_t immediate;
45
+ uint32_t encoding;
45
46
};
46
47
47
48
static struct li_pair InverseLITable[LI_TABLE_SIZE];
@@ -63,71 +64,71 @@ int compare_immediate_pair(const void *i1, const void *i2)
63
64
// helper functions used by expandLogicalImmediate
64
65
65
66
// for i = 1, ... N result<i-1> = 1 other bits are zero
66
- static inline u_int64_t ones (int N)
67
+ static inline uint64_t ones (int N)
67
68
{
68
- return (N == 64 ? (u_int64_t )-1UL : ((1UL << N) - 1 ));
69
+ return (N == 64 ? (uint64_t )-1UL : ((1UL << N) - 1 ));
69
70
}
70
71
71
72
/*
72
73
* bit twiddling helpers for instruction decode
73
74
*/
74
75
75
76
// 32 bit mask with bits [hi,...,lo] set
76
- static inline u_int32_t mask32 (int hi = 31 , int lo = 0 )
77
+ static inline uint32_t mask32 (int hi = 31 , int lo = 0 )
77
78
{
78
79
int nbits = (hi + 1 ) - lo;
79
80
return ((1 << nbits) - 1 ) << lo;
80
81
}
81
82
82
- static inline u_int64_t mask64 (int hi = 63 , int lo = 0 )
83
+ static inline uint64_t mask64 (int hi = 63 , int lo = 0 )
83
84
{
84
85
int nbits = (hi + 1 ) - lo;
85
86
return ((1L << nbits) - 1 ) << lo;
86
87
}
87
88
88
89
// pick bits [hi,...,lo] from val
89
- static inline u_int32_t pick32 (u_int32_t val, int hi = 31 , int lo = 0 )
90
+ static inline uint32_t pick32 (uint32_t val, int hi = 31 , int lo = 0 )
90
91
{
91
92
return (val & mask32 (hi, lo));
92
93
}
93
94
94
95
// pick bits [hi,...,lo] from val
95
- static inline u_int64_t pick64 (u_int64_t val, int hi = 31 , int lo = 0 )
96
+ static inline uint64_t pick64 (uint64_t val, int hi = 31 , int lo = 0 )
96
97
{
97
98
return (val & mask64 (hi, lo));
98
99
}
99
100
100
101
// mask [hi,lo] and shift down to start at bit 0
101
- static inline u_int32_t pickbits32 (u_int32_t val, int hi = 31 , int lo = 0 )
102
+ static inline uint32_t pickbits32 (uint32_t val, int hi = 31 , int lo = 0 )
102
103
{
103
104
return (pick32 (val, hi, lo) >> lo);
104
105
}
105
106
106
107
// mask [hi,lo] and shift down to start at bit 0
107
- static inline u_int64_t pickbits64 (u_int64_t val, int hi = 63 , int lo = 0 )
108
+ static inline uint64_t pickbits64 (uint64_t val, int hi = 63 , int lo = 0 )
108
109
{
109
110
return (pick64 (val, hi, lo) >> lo);
110
111
}
111
112
112
113
// result<0> to val<N>
113
- static inline u_int64_t pickbit (u_int64_t val, int N)
114
+ static inline uint64_t pickbit (uint64_t val, int N)
114
115
{
115
116
return pickbits64 (val, N, N);
116
117
}
117
118
118
- static inline u_int32_t uimm (u_int32_t val, int hi, int lo)
119
+ static inline uint32_t uimm (uint32_t val, int hi, int lo)
119
120
{
120
121
return pickbits32 (val, hi, lo);
121
122
}
122
123
123
124
// SPEC bits(M*N) Replicate(bits(M) x, integer N);
124
125
// this is just an educated guess
125
126
126
- u_int64_t replicate (u_int64_t bits, int nbits, int count)
127
+ uint64_t replicate (uint64_t bits, int nbits, int count)
127
128
{
128
- u_int64_t result = 0 ;
129
+ uint64_t result = 0 ;
129
130
// nbits may be 64 in which case we want mask to be -1
130
- u_int64_t mask = ones (nbits);
131
+ uint64_t mask = ones (nbits);
131
132
for (int i = 0 ; i < count ; i++) {
132
133
result <<= nbits;
133
134
result |= (bits & mask);
@@ -140,24 +141,24 @@ u_int64_t replicate(u_int64_t bits, int nbits, int count)
140
141
// encoding must be treated as an UNALLOC instruction
141
142
142
143
// construct a 32 bit immediate value for a logical immediate operation
143
- int expandLogicalImmediate (u_int32_t immN, u_int32_t immr,
144
- u_int32_t imms, u_int64_t &bimm)
144
+ int expandLogicalImmediate (uint32_t immN, uint32_t immr,
145
+ uint32_t imms, uint64_t &bimm)
145
146
{
146
- int len; // ought to be <= 6
147
- u_int32_t levels; // 6 bits
148
- u_int32_t tmask_and; // 6 bits
149
- u_int32_t wmask_and; // 6 bits
150
- u_int32_t tmask_or; // 6 bits
151
- u_int32_t wmask_or; // 6 bits
152
- u_int64_t imm64; // 64 bits
153
- u_int64_t tmask, wmask; // 64 bits
154
- u_int32_t S, R, diff; // 6 bits?
147
+ int len; // ought to be <= 6
148
+ uint32_t levels; // 6 bits
149
+ uint32_t tmask_and; // 6 bits
150
+ uint32_t wmask_and; // 6 bits
151
+ uint32_t tmask_or; // 6 bits
152
+ uint32_t wmask_or; // 6 bits
153
+ uint64_t imm64; // 64 bits
154
+ uint64_t tmask, wmask; // 64 bits
155
+ uint32_t S, R, diff; // 6 bits?
155
156
156
157
if (immN == 1 ) {
157
158
len = 6 ; // looks like 7 given the spec above but this cannot be!
158
159
} else {
159
160
len = 0 ;
160
- u_int32_t val = (~imms & 0x3f );
161
+ uint32_t val = (~imms & 0x3f );
161
162
for (int i = 5 ; i > 0 ; i--) {
162
163
if (val & (1 << i)) {
163
164
len = i;
@@ -170,7 +171,7 @@ int expandLogicalImmediate(u_int32_t immN, u_int32_t immr,
170
171
// for valid inputs leading 1s in immr must be less than leading
171
172
// zeros in imms
172
173
int len2 = 0 ; // ought to be < len
173
- u_int32_t val2 = (~immr & 0x3f );
174
+ uint32_t val2 = (~immr & 0x3f );
174
175
for (int i = 5 ; i > 0 ; i--) {
175
176
if (!(val2 & (1 << i))) {
176
177
len2 = i;
@@ -199,12 +200,12 @@ int expandLogicalImmediate(u_int32_t immN, u_int32_t immr,
199
200
200
201
for (int i = 0 ; i < 6 ; i++) {
201
202
int nbits = 1 << i;
202
- u_int64_t and_bit = pickbit (tmask_and, i);
203
- u_int64_t or_bit = pickbit (tmask_or, i);
204
- u_int64_t and_bits_sub = replicate (and_bit, 1 , nbits);
205
- u_int64_t or_bits_sub = replicate (or_bit, 1 , nbits);
206
- u_int64_t and_bits_top = (and_bits_sub << nbits) | ones (nbits);
207
- u_int64_t or_bits_top = (0 << nbits) | or_bits_sub;
203
+ uint64_t and_bit = pickbit (tmask_and, i);
204
+ uint64_t or_bit = pickbit (tmask_or, i);
205
+ uint64_t and_bits_sub = replicate (and_bit, 1 , nbits);
206
+ uint64_t or_bits_sub = replicate (or_bit, 1 , nbits);
207
+ uint64_t and_bits_top = (and_bits_sub << nbits) | ones (nbits);
208
+ uint64_t or_bits_top = (0 << nbits) | or_bits_sub;
208
209
209
210
tmask = ((tmask
210
211
& (replicate (and_bits_top, 2 * nbits, 32 / nbits)))
@@ -218,12 +219,12 @@ int expandLogicalImmediate(u_int32_t immN, u_int32_t immr,
218
219
219
220
for (int i = 0 ; i < 6 ; i++) {
220
221
int nbits = 1 << i;
221
- u_int64_t and_bit = pickbit (wmask_and, i);
222
- u_int64_t or_bit = pickbit (wmask_or, i);
223
- u_int64_t and_bits_sub = replicate (and_bit, 1 , nbits);
224
- u_int64_t or_bits_sub = replicate (or_bit, 1 , nbits);
225
- u_int64_t and_bits_top = (ones (nbits) << nbits) | and_bits_sub;
226
- u_int64_t or_bits_top = (or_bits_sub << nbits) | 0 ;
222
+ uint64_t and_bit = pickbit (wmask_and, i);
223
+ uint64_t or_bit = pickbit (wmask_or, i);
224
+ uint64_t and_bits_sub = replicate (and_bit, 1 , nbits);
225
+ uint64_t or_bits_sub = replicate (or_bit, 1 , nbits);
226
+ uint64_t and_bits_top = (ones (nbits) << nbits) | and_bits_sub;
227
+ uint64_t or_bits_top = (or_bits_sub << nbits) | 0 ;
227
228
228
229
wmask = ((wmask
229
230
& (replicate (and_bits_top, 2 * nbits, 32 / nbits)))
@@ -248,9 +249,9 @@ static void initLITables()
248
249
{
249
250
li_table_entry_count = 0 ;
250
251
for (unsigned index = 0 ; index < LI_TABLE_SIZE; index++) {
251
- u_int32_t N = uimm (index, 12 , 12 );
252
- u_int32_t immr = uimm (index, 11 , 6 );
253
- u_int32_t imms = uimm (index, 5 , 0 );
252
+ uint32_t N = uimm (index, 12 , 12 );
253
+ uint32_t immr = uimm (index, 11 , 6 );
254
+ uint32_t imms = uimm (index, 5 , 0 );
254
255
if (expandLogicalImmediate (N, immr, imms, LITable[index])) {
255
256
InverseLITable[li_table_entry_count].immediate = LITable[index];
256
257
InverseLITable[li_table_entry_count].encoding = index;
@@ -264,12 +265,12 @@ static void initLITables()
264
265
265
266
// public APIs provided for logical immediate lookup and reverse lookup
266
267
267
- u_int64_t logical_immediate_for_encoding (u_int32_t encoding)
268
+ uint64_t logical_immediate_for_encoding (uint32_t encoding)
268
269
{
269
270
return LITable[encoding];
270
271
}
271
272
272
- u_int32_t encoding_for_logical_immediate (u_int64_t immediate)
273
+ uint32_t encoding_for_logical_immediate (uint64_t immediate)
273
274
{
274
275
struct li_pair pair;
275
276
struct li_pair *result;
@@ -293,15 +294,15 @@ u_int32_t encoding_for_logical_immediate(u_int64_t immediate)
293
294
// fpimm[3:0] = fraction (assuming leading 1)
294
295
// i.e. F = s * 1.f * 2^(e - b)
295
296
296
- u_int64_t fp_immediate_for_encoding (u_int32_t imm8, int is_dp)
297
+ uint64_t fp_immediate_for_encoding (uint32_t imm8, int is_dp)
297
298
{
298
299
union {
299
300
float fpval;
300
301
double dpval;
301
- u_int64_t val;
302
+ uint64_t val;
302
303
};
303
304
304
- u_int32_t s, e, f;
305
+ uint32_t s, e, f;
305
306
s = (imm8 >> 7 ) & 0x1 ;
306
307
e = (imm8 >> 4 ) & 0x7 ;
307
308
f = imm8 & 0xf ;
@@ -329,7 +330,7 @@ u_int64_t fp_immediate_for_encoding(u_int32_t imm8, int is_dp)
329
330
return val;
330
331
}
331
332
332
- u_int32_t encoding_for_fp_immediate (float immediate)
333
+ uint32_t encoding_for_fp_immediate (float immediate)
333
334
{
334
335
// given a float which is of the form
335
336
//
@@ -341,10 +342,10 @@ u_int32_t encoding_for_fp_immediate(float immediate)
341
342
342
343
union {
343
344
float fpval;
344
- u_int32_t val;
345
+ uint32_t val;
345
346
};
346
347
fpval = immediate;
347
- u_int32_t s, r, f, res;
348
+ uint32_t s, r, f, res;
348
349
// sign bit is 31
349
350
s = (val >> 31 ) & 0x1 ;
350
351
// exponent is bits 30-23 but we only want the bottom 3 bits
0 commit comments