1
2
3
4
5
6
7 package codegen
8
9
10
11
12
13 func lshConst64x64(v int64) int64 {
14
15
16
17 return v << uint64(33)
18 }
19
20 func rshConst64Ux64(v uint64) uint64 {
21
22
23
24 return v >> uint64(33)
25 }
26
27 func rshConst64x64(v int64) int64 {
28
29
30
31 return v >> uint64(33)
32 }
33
34 func lshConst32x64(v int32) int32 {
35
36
37
38 return v << uint64(29)
39 }
40
41 func rshConst32Ux64(v uint32) uint32 {
42
43
44
45 return v >> uint64(29)
46 }
47
48 func rshConst32x64(v int32) int32 {
49
50
51
52 return v >> uint64(29)
53 }
54
55 func lshConst64x32(v int64) int64 {
56
57
58
59 return v << uint32(33)
60 }
61
62 func rshConst64Ux32(v uint64) uint64 {
63
64
65
66 return v >> uint32(33)
67 }
68
69 func rshConst64x32(v int64) int64 {
70
71
72
73 return v >> uint32(33)
74 }
75
76
77
78
79
80 func lshMask64x64(v int64, s uint64) int64 {
81
82
83
84
85
86 return v << (s & 63)
87 }
88
89 func rshMask64Ux64(v uint64, s uint64) uint64 {
90
91
92
93
94
95 return v >> (s & 63)
96 }
97
98 func rshMask64x64(v int64, s uint64) int64 {
99
100
101
102
103
104 return v >> (s & 63)
105 }
106
107 func lshMask32x64(v int32, s uint64) int32 {
108
109
110
111
112
113 return v << (s & 63)
114 }
115
116 func rshMask32Ux64(v uint32, s uint64) uint32 {
117
118
119
120
121
122 return v >> (s & 63)
123 }
124
125 func rshMask32x64(v int32, s uint64) int32 {
126
127
128
129
130
131 return v >> (s & 63)
132 }
133
134 func lshMask64x32(v int64, s uint32) int64 {
135
136
137
138
139
140 return v << (s & 63)
141 }
142
143 func rshMask64Ux32(v uint64, s uint32) uint64 {
144
145
146
147
148
149 return v >> (s & 63)
150 }
151
152 func rshMask64x32(v int64, s uint32) int64 {
153
154
155
156
157
158 return v >> (s & 63)
159 }
160
161 func lshMask64x32Ext(v int64, s int32) int64 {
162
163
164
165
166 return v << uint(s&63)
167 }
168
169 func rshMask64Ux32Ext(v uint64, s int32) uint64 {
170
171
172
173
174 return v >> uint(s&63)
175 }
176
177 func rshMask64x32Ext(v int64, s int32) int64 {
178
179
180
181
182 return v >> uint(s&63)
183 }
184
185
186
187
188
189
190 func lshSigned(v8 int8, v16 int16, v32 int32, v64 int64, x int) {
191
192 _ = x << v8
193
194 _ = x << v16
195
196 _ = x << v32
197
198 _ = x << v64
199 }
200
201
202 func lshSignedMasked(v8 int8, v16 int16, v32 int32, v64 int64, x int) {
203
204 _ = x << (v8 & 7)
205
206 _ = x << (v16 & 15)
207
208 _ = x << (v32 & 31)
209
210 _ = x << (v64 & 63)
211 }
212
213
214
215
216
217 func lshGuarded64(v int64, s uint) int64 {
218 if s < 64 {
219
220
221
222
223 return v << s
224 }
225 panic("shift too large")
226 }
227
228 func rshGuarded64U(v uint64, s uint) uint64 {
229 if s < 64 {
230
231
232
233
234 return v >> s
235 }
236 panic("shift too large")
237 }
238
239 func rshGuarded64(v int64, s uint) int64 {
240 if s < 64 {
241
242
243
244
245 return v >> s
246 }
247 panic("shift too large")
248 }
249
250 func provedUnsignedShiftLeft(val64 uint64, val32 uint32, val16 uint16, val8 uint8, shift int) (r1 uint64, r2 uint32, r3 uint16, r4 uint8) {
251 if shift >= 0 && shift < 64 {
252
253 r1 = val64 << shift
254 }
255 if shift >= 0 && shift < 32 {
256
257 r2 = val32 << shift
258 }
259 if shift >= 0 && shift < 16 {
260
261 r3 = val16 << shift
262 }
263 if shift >= 0 && shift < 8 {
264
265 r4 = val8 << shift
266 }
267 return r1, r2, r3, r4
268 }
269
270 func provedSignedShiftLeft(val64 int64, val32 int32, val16 int16, val8 int8, shift int) (r1 int64, r2 int32, r3 int16, r4 int8) {
271 if shift >= 0 && shift < 64 {
272
273 r1 = val64 << shift
274 }
275 if shift >= 0 && shift < 32 {
276
277 r2 = val32 << shift
278 }
279 if shift >= 0 && shift < 16 {
280
281 r3 = val16 << shift
282 }
283 if shift >= 0 && shift < 8 {
284
285 r4 = val8 << shift
286 }
287 return r1, r2, r3, r4
288 }
289
290 func provedUnsignedShiftRight(val64 uint64, val32 uint32, val16 uint16, val8 uint8, shift int) (r1 uint64, r2 uint32, r3 uint16, r4 uint8) {
291 if shift >= 0 && shift < 64 {
292
293 r1 = val64 >> shift
294 }
295 if shift >= 0 && shift < 32 {
296
297 r2 = val32 >> shift
298 }
299 if shift >= 0 && shift < 16 {
300
301 r3 = val16 >> shift
302 }
303 if shift >= 0 && shift < 8 {
304
305 r4 = val8 >> shift
306 }
307 return r1, r2, r3, r4
308 }
309
310 func provedSignedShiftRight(val64 int64, val32 int32, val16 int16, val8 int8, shift int) (r1 int64, r2 int32, r3 int16, r4 int8) {
311 if shift >= 0 && shift < 64 {
312
313 r1 = val64 >> shift
314 }
315 if shift >= 0 && shift < 32 {
316
317 r2 = val32 >> shift
318 }
319 if shift >= 0 && shift < 16 {
320
321 r3 = val16 >> shift
322 }
323 if shift >= 0 && shift < 8 {
324
325 r4 = val8 >> shift
326 }
327 return r1, r2, r3, r4
328 }
329
330 func checkUnneededTrunc(tab *[100000]uint32, d uint64, v uint32, h uint16, b byte) (uint32, uint64) {
331
332
333
334 f := tab[byte(v)^b]
335
336
337 f += tab[byte(v)&b]
338
339
340 f += tab[byte(v)|b]
341
342
343 f += tab[uint16(v)&h]
344
345
346 f += tab[uint16(v)^h]
347
348
349 f += tab[uint16(v)|h]
350
351
352 f += tab[v&0xff]
353
354
355 f += 2 * uint32(uint16(d))
356
357
358 g := 2 * uint64(uint32(d))
359 return f, g
360 }
361
362 func checkCombinedShifts(v8 uint8, v16 uint16, v32 uint32, x32 int32, v64 uint64) (uint8, uint16, uint32, uint64, int64) {
363
364
365
366 f := (v8 & 0xF) << 2
367
368
369 f += byte(v16) << 3
370
371
372 g := (v16 & 0xFF) << 3
373
374
375 h := (v32 & 0xFFFFF) << 2
376
377
378 i := (v64 & 0xFFFFFFFF) << 5
379
380
381 i += (v64 & 0xFFFFFFF) << 38
382
383
384 i += (v64 & 0xFFFF00) << 10
385
386
387 j := int64(x32+32) * 8
388 return f, g, h, i, j
389 }
390
391 func checkWidenAfterShift(v int64, u uint64) (int64, uint64) {
392
393
394 f := int32(v >> 32)
395
396 f += int32(v >> 31)
397
398 g := int16(v >> 48)
399
400 g += int16(v >> 30)
401
402 g += int16(f >> 16)
403
404 h := int8(v >> 56)
405
406 h += int8(v >> 28)
407
408 h += int8(f >> 24)
409
410 h += int8(f >> 16)
411 return int64(h), uint64(g)
412 }
413
414 func checkShiftAndMask32(v []uint32) {
415 i := 0
416
417
418
419 v[i] = (v[i] & 0xFF00000) >> 8
420 i++
421
422
423 v[i] = (v[i] & 0xFF00) >> 6
424 i++
425
426
427 v[i] = (v[i] & 0xFF) >> 8
428 i++
429
430
431 v[i] = (v[i] & 0xF000000) >> 28
432 i++
433
434
435 v[i] = (v[i] >> 6) & 0xFF
436 i++
437
438
439 v[i] = (v[i] >> 6) & 0xFF000
440 i++
441
442
443 v[i] = (v[i] >> 20) & 0xFF000
444 i++
445
446
447 v[i] = (v[i] >> 24) & 0xFF00
448 i++
449 }
450
451 func checkMergedShifts32(a [256]uint32, b [256]uint64, u uint32, v uint32) {
452
453
454 a[0] = a[uint8(v>>24)]
455
456
457 b[0] = b[uint8(v>>24)]
458
459
460 b[1] = b[(v>>20)&0xFF]
461
462
463 b[2] = b[v>>25]
464 }
465
466
467
468 func check128bitShifts(x, y uint64, bits uint) (uint64, uint64) {
469 s := bits & 63
470 ŝ := (64 - bits) & 63
471
472
473 shr := x>>s | y<<ŝ
474
475 shl := x<<s | y>>ŝ
476 return shr, shl
477 }
478
479 func checkShiftToMask(u []uint64, s []int64) {
480
481 u[0] = u[0] >> 5 << 5
482
483 s[0] = s[0] >> 5 << 5
484
485 u[1] = u[1] << 5 >> 5
486 }
487
View as plain text