source: code/trunk/vendor/modernc.org/libc/ccgo.go@ 822

Last change on this file since 822 was 822, checked in by yakumo.izuru, 22 months ago

Prefer immortal.run over runit and rc.d, use vendored modules
for convenience.

Signed-off-by: Izuru Yakumo <yakumo.izuru@…>
File size: 75.7 KB
RevLine 
[822]1// Code generated by 'go generate' - DO NOT EDIT.
2
3package libc // import "modernc.org/libc"
4
5import (
6 "sync/atomic"
7 "unsafe"
8)
9
10func AtomicStoreNInt32(ptr uintptr, val int32, memorder int32) {
11 atomic.StoreInt32((*int32)(unsafe.Pointer(ptr)), val)
12}
13
14func AtomicStoreNInt64(ptr uintptr, val int64, memorder int32) {
15 atomic.StoreInt64((*int64)(unsafe.Pointer(ptr)), val)
16}
17
18func AtomicStoreNUint32(ptr uintptr, val uint32, memorder int32) {
19 atomic.StoreUint32((*uint32)(unsafe.Pointer(ptr)), val)
20}
21
22func AtomicStoreNUint64(ptr uintptr, val uint64, memorder int32) {
23 atomic.StoreUint64((*uint64)(unsafe.Pointer(ptr)), val)
24}
25
26func AtomicStoreNUintptr(ptr uintptr, val uintptr, memorder int32) {
27 atomic.StoreUintptr((*uintptr)(unsafe.Pointer(ptr)), val)
28}
29
30func AtomicLoadNInt32(ptr uintptr, memorder int32) int32 {
31 return atomic.LoadInt32((*int32)(unsafe.Pointer(ptr)))
32}
33
34func AtomicLoadNInt64(ptr uintptr, memorder int32) int64 {
35 return atomic.LoadInt64((*int64)(unsafe.Pointer(ptr)))
36}
37
38func AtomicLoadNUint32(ptr uintptr, memorder int32) uint32 {
39 return atomic.LoadUint32((*uint32)(unsafe.Pointer(ptr)))
40}
41
42func AtomicLoadNUint64(ptr uintptr, memorder int32) uint64 {
43 return atomic.LoadUint64((*uint64)(unsafe.Pointer(ptr)))
44}
45
46func AtomicLoadNUintptr(ptr uintptr, memorder int32) uintptr {
47 return atomic.LoadUintptr((*uintptr)(unsafe.Pointer(ptr)))
48}
49func AssignInt8(p *int8, v int8) int8 { *p = v; return v }
50func AssignInt16(p *int16, v int16) int16 { *p = v; return v }
51func AssignInt32(p *int32, v int32) int32 { *p = v; return v }
52func AssignInt64(p *int64, v int64) int64 { *p = v; return v }
53func AssignUint8(p *uint8, v uint8) uint8 { *p = v; return v }
54func AssignUint16(p *uint16, v uint16) uint16 { *p = v; return v }
55func AssignUint32(p *uint32, v uint32) uint32 { *p = v; return v }
56func AssignUint64(p *uint64, v uint64) uint64 { *p = v; return v }
57func AssignFloat32(p *float32, v float32) float32 { *p = v; return v }
58func AssignFloat64(p *float64, v float64) float64 { *p = v; return v }
59func AssignComplex64(p *complex64, v complex64) complex64 { *p = v; return v }
60func AssignComplex128(p *complex128, v complex128) complex128 { *p = v; return v }
61func AssignUintptr(p *uintptr, v uintptr) uintptr { *p = v; return v }
62
63func AssignPtrInt8(p uintptr, v int8) int8 { *(*int8)(unsafe.Pointer(p)) = v; return v }
64func AssignPtrInt16(p uintptr, v int16) int16 { *(*int16)(unsafe.Pointer(p)) = v; return v }
65func AssignPtrInt32(p uintptr, v int32) int32 { *(*int32)(unsafe.Pointer(p)) = v; return v }
66func AssignPtrInt64(p uintptr, v int64) int64 { *(*int64)(unsafe.Pointer(p)) = v; return v }
67func AssignPtrUint8(p uintptr, v uint8) uint8 { *(*uint8)(unsafe.Pointer(p)) = v; return v }
68func AssignPtrUint16(p uintptr, v uint16) uint16 { *(*uint16)(unsafe.Pointer(p)) = v; return v }
69func AssignPtrUint32(p uintptr, v uint32) uint32 { *(*uint32)(unsafe.Pointer(p)) = v; return v }
70func AssignPtrUint64(p uintptr, v uint64) uint64 { *(*uint64)(unsafe.Pointer(p)) = v; return v }
71func AssignPtrFloat32(p uintptr, v float32) float32 { *(*float32)(unsafe.Pointer(p)) = v; return v }
72func AssignPtrFloat64(p uintptr, v float64) float64 { *(*float64)(unsafe.Pointer(p)) = v; return v }
73func AssignPtrComplex64(p uintptr, v complex64) complex64 {
74 *(*complex64)(unsafe.Pointer(p)) = v
75 return v
76}
77func AssignPtrComplex128(p uintptr, v complex128) complex128 {
78 *(*complex128)(unsafe.Pointer(p)) = v
79 return v
80}
81func AssignPtrUintptr(p uintptr, v uintptr) uintptr { *(*uintptr)(unsafe.Pointer(p)) = v; return v }
82
83func AssignMulInt8(p *int8, v int8) int8 { *p *= v; return *p }
84func AssignMulInt16(p *int16, v int16) int16 { *p *= v; return *p }
85func AssignMulInt32(p *int32, v int32) int32 { *p *= v; return *p }
86func AssignMulInt64(p *int64, v int64) int64 { *p *= v; return *p }
87func AssignMulUint8(p *uint8, v uint8) uint8 { *p *= v; return *p }
88func AssignMulUint16(p *uint16, v uint16) uint16 { *p *= v; return *p }
89func AssignMulUint32(p *uint32, v uint32) uint32 { *p *= v; return *p }
90func AssignMulUint64(p *uint64, v uint64) uint64 { *p *= v; return *p }
91func AssignMulFloat32(p *float32, v float32) float32 { *p *= v; return *p }
92func AssignMulFloat64(p *float64, v float64) float64 { *p *= v; return *p }
93func AssignMulComplex64(p *complex64, v complex64) complex64 { *p *= v; return *p }
94func AssignMulComplex128(p *complex128, v complex128) complex128 { *p *= v; return *p }
95func AssignMulUintptr(p *uintptr, v uintptr) uintptr { *p *= v; return *p }
96
97func AssignDivInt8(p *int8, v int8) int8 { *p /= v; return *p }
98func AssignDivInt16(p *int16, v int16) int16 { *p /= v; return *p }
99func AssignDivInt32(p *int32, v int32) int32 { *p /= v; return *p }
100func AssignDivInt64(p *int64, v int64) int64 { *p /= v; return *p }
101func AssignDivUint8(p *uint8, v uint8) uint8 { *p /= v; return *p }
102func AssignDivUint16(p *uint16, v uint16) uint16 { *p /= v; return *p }
103func AssignDivUint32(p *uint32, v uint32) uint32 { *p /= v; return *p }
104func AssignDivUint64(p *uint64, v uint64) uint64 { *p /= v; return *p }
105func AssignDivFloat32(p *float32, v float32) float32 { *p /= v; return *p }
106func AssignDivFloat64(p *float64, v float64) float64 { *p /= v; return *p }
107func AssignDivComplex64(p *complex64, v complex64) complex64 { *p /= v; return *p }
108func AssignDivComplex128(p *complex128, v complex128) complex128 { *p /= v; return *p }
109func AssignDivUintptr(p *uintptr, v uintptr) uintptr { *p /= v; return *p }
110
111func AssignRemInt8(p *int8, v int8) int8 { *p %= v; return *p }
112func AssignRemInt16(p *int16, v int16) int16 { *p %= v; return *p }
113func AssignRemInt32(p *int32, v int32) int32 { *p %= v; return *p }
114func AssignRemInt64(p *int64, v int64) int64 { *p %= v; return *p }
115func AssignRemUint8(p *uint8, v uint8) uint8 { *p %= v; return *p }
116func AssignRemUint16(p *uint16, v uint16) uint16 { *p %= v; return *p }
117func AssignRemUint32(p *uint32, v uint32) uint32 { *p %= v; return *p }
118func AssignRemUint64(p *uint64, v uint64) uint64 { *p %= v; return *p }
119func AssignRemUintptr(p *uintptr, v uintptr) uintptr { *p %= v; return *p }
120
121func AssignAddInt8(p *int8, v int8) int8 { *p += v; return *p }
122func AssignAddInt16(p *int16, v int16) int16 { *p += v; return *p }
123func AssignAddInt32(p *int32, v int32) int32 { *p += v; return *p }
124func AssignAddInt64(p *int64, v int64) int64 { *p += v; return *p }
125func AssignAddUint8(p *uint8, v uint8) uint8 { *p += v; return *p }
126func AssignAddUint16(p *uint16, v uint16) uint16 { *p += v; return *p }
127func AssignAddUint32(p *uint32, v uint32) uint32 { *p += v; return *p }
128func AssignAddUint64(p *uint64, v uint64) uint64 { *p += v; return *p }
129func AssignAddFloat32(p *float32, v float32) float32 { *p += v; return *p }
130func AssignAddFloat64(p *float64, v float64) float64 { *p += v; return *p }
131func AssignAddComplex64(p *complex64, v complex64) complex64 { *p += v; return *p }
132func AssignAddComplex128(p *complex128, v complex128) complex128 { *p += v; return *p }
133func AssignAddUintptr(p *uintptr, v uintptr) uintptr { *p += v; return *p }
134
135func AssignSubInt8(p *int8, v int8) int8 { *p -= v; return *p }
136func AssignSubInt16(p *int16, v int16) int16 { *p -= v; return *p }
137func AssignSubInt32(p *int32, v int32) int32 { *p -= v; return *p }
138func AssignSubInt64(p *int64, v int64) int64 { *p -= v; return *p }
139func AssignSubUint8(p *uint8, v uint8) uint8 { *p -= v; return *p }
140func AssignSubUint16(p *uint16, v uint16) uint16 { *p -= v; return *p }
141func AssignSubUint32(p *uint32, v uint32) uint32 { *p -= v; return *p }
142func AssignSubUint64(p *uint64, v uint64) uint64 { *p -= v; return *p }
143func AssignSubFloat32(p *float32, v float32) float32 { *p -= v; return *p }
144func AssignSubFloat64(p *float64, v float64) float64 { *p -= v; return *p }
145func AssignSubComplex64(p *complex64, v complex64) complex64 { *p -= v; return *p }
146func AssignSubComplex128(p *complex128, v complex128) complex128 { *p -= v; return *p }
147func AssignSubUintptr(p *uintptr, v uintptr) uintptr { *p -= v; return *p }
148
149func AssignAndInt8(p *int8, v int8) int8 { *p &= v; return *p }
150func AssignAndInt16(p *int16, v int16) int16 { *p &= v; return *p }
151func AssignAndInt32(p *int32, v int32) int32 { *p &= v; return *p }
152func AssignAndInt64(p *int64, v int64) int64 { *p &= v; return *p }
153func AssignAndUint8(p *uint8, v uint8) uint8 { *p &= v; return *p }
154func AssignAndUint16(p *uint16, v uint16) uint16 { *p &= v; return *p }
155func AssignAndUint32(p *uint32, v uint32) uint32 { *p &= v; return *p }
156func AssignAndUint64(p *uint64, v uint64) uint64 { *p &= v; return *p }
157func AssignAndUintptr(p *uintptr, v uintptr) uintptr { *p &= v; return *p }
158
159func AssignXorInt8(p *int8, v int8) int8 { *p ^= v; return *p }
160func AssignXorInt16(p *int16, v int16) int16 { *p ^= v; return *p }
161func AssignXorInt32(p *int32, v int32) int32 { *p ^= v; return *p }
162func AssignXorInt64(p *int64, v int64) int64 { *p ^= v; return *p }
163func AssignXorUint8(p *uint8, v uint8) uint8 { *p ^= v; return *p }
164func AssignXorUint16(p *uint16, v uint16) uint16 { *p ^= v; return *p }
165func AssignXorUint32(p *uint32, v uint32) uint32 { *p ^= v; return *p }
166func AssignXorUint64(p *uint64, v uint64) uint64 { *p ^= v; return *p }
167func AssignXorUintptr(p *uintptr, v uintptr) uintptr { *p ^= v; return *p }
168
169func AssignOrInt8(p *int8, v int8) int8 { *p |= v; return *p }
170func AssignOrInt16(p *int16, v int16) int16 { *p |= v; return *p }
171func AssignOrInt32(p *int32, v int32) int32 { *p |= v; return *p }
172func AssignOrInt64(p *int64, v int64) int64 { *p |= v; return *p }
173func AssignOrUint8(p *uint8, v uint8) uint8 { *p |= v; return *p }
174func AssignOrUint16(p *uint16, v uint16) uint16 { *p |= v; return *p }
175func AssignOrUint32(p *uint32, v uint32) uint32 { *p |= v; return *p }
176func AssignOrUint64(p *uint64, v uint64) uint64 { *p |= v; return *p }
177func AssignOrUintptr(p *uintptr, v uintptr) uintptr { *p |= v; return *p }
178
179func AssignMulPtrInt8(p uintptr, v int8) int8 {
180 *(*int8)(unsafe.Pointer(p)) *= v
181 return *(*int8)(unsafe.Pointer(p))
182}
183
184func AssignMulPtrInt16(p uintptr, v int16) int16 {
185 *(*int16)(unsafe.Pointer(p)) *= v
186 return *(*int16)(unsafe.Pointer(p))
187}
188
189func AssignMulPtrInt32(p uintptr, v int32) int32 {
190 *(*int32)(unsafe.Pointer(p)) *= v
191 return *(*int32)(unsafe.Pointer(p))
192}
193
194func AssignMulPtrInt64(p uintptr, v int64) int64 {
195 *(*int64)(unsafe.Pointer(p)) *= v
196 return *(*int64)(unsafe.Pointer(p))
197}
198
199func AssignMulPtrUint8(p uintptr, v uint8) uint8 {
200 *(*uint8)(unsafe.Pointer(p)) *= v
201 return *(*uint8)(unsafe.Pointer(p))
202}
203
204func AssignMulPtrUint16(p uintptr, v uint16) uint16 {
205 *(*uint16)(unsafe.Pointer(p)) *= v
206 return *(*uint16)(unsafe.Pointer(p))
207}
208
209func AssignMulPtrUint32(p uintptr, v uint32) uint32 {
210 *(*uint32)(unsafe.Pointer(p)) *= v
211 return *(*uint32)(unsafe.Pointer(p))
212}
213
214func AssignMulPtrUint64(p uintptr, v uint64) uint64 {
215 *(*uint64)(unsafe.Pointer(p)) *= v
216 return *(*uint64)(unsafe.Pointer(p))
217}
218
219func AssignMulPtrFloat32(p uintptr, v float32) float32 {
220 *(*float32)(unsafe.Pointer(p)) *= v
221 return *(*float32)(unsafe.Pointer(p))
222}
223
224func AssignMulPtrFloat64(p uintptr, v float64) float64 {
225 *(*float64)(unsafe.Pointer(p)) *= v
226 return *(*float64)(unsafe.Pointer(p))
227}
228
229func AssignMulPtrComplex64(p uintptr, v complex64) complex64 {
230 *(*complex64)(unsafe.Pointer(p)) *= v
231 return *(*complex64)(unsafe.Pointer(p))
232}
233
234func AssignMulPtrComplex128(p uintptr, v complex128) complex128 {
235 *(*complex128)(unsafe.Pointer(p)) *= v
236 return *(*complex128)(unsafe.Pointer(p))
237}
238
239func AssignMulPtrUintptr(p uintptr, v uintptr) uintptr {
240 *(*uintptr)(unsafe.Pointer(p)) *= v
241 return *(*uintptr)(unsafe.Pointer(p))
242}
243
244func AssignDivPtrInt8(p uintptr, v int8) int8 {
245 *(*int8)(unsafe.Pointer(p)) /= v
246 return *(*int8)(unsafe.Pointer(p))
247}
248
249func AssignDivPtrInt16(p uintptr, v int16) int16 {
250 *(*int16)(unsafe.Pointer(p)) /= v
251 return *(*int16)(unsafe.Pointer(p))
252}
253
254func AssignDivPtrInt32(p uintptr, v int32) int32 {
255 *(*int32)(unsafe.Pointer(p)) /= v
256 return *(*int32)(unsafe.Pointer(p))
257}
258
259func AssignDivPtrInt64(p uintptr, v int64) int64 {
260 *(*int64)(unsafe.Pointer(p)) /= v
261 return *(*int64)(unsafe.Pointer(p))
262}
263
264func AssignDivPtrUint8(p uintptr, v uint8) uint8 {
265 *(*uint8)(unsafe.Pointer(p)) /= v
266 return *(*uint8)(unsafe.Pointer(p))
267}
268
269func AssignDivPtrUint16(p uintptr, v uint16) uint16 {
270 *(*uint16)(unsafe.Pointer(p)) /= v
271 return *(*uint16)(unsafe.Pointer(p))
272}
273
274func AssignDivPtrUint32(p uintptr, v uint32) uint32 {
275 *(*uint32)(unsafe.Pointer(p)) /= v
276 return *(*uint32)(unsafe.Pointer(p))
277}
278
279func AssignDivPtrUint64(p uintptr, v uint64) uint64 {
280 *(*uint64)(unsafe.Pointer(p)) /= v
281 return *(*uint64)(unsafe.Pointer(p))
282}
283
284func AssignDivPtrFloat32(p uintptr, v float32) float32 {
285 *(*float32)(unsafe.Pointer(p)) /= v
286 return *(*float32)(unsafe.Pointer(p))
287}
288
289func AssignDivPtrFloat64(p uintptr, v float64) float64 {
290 *(*float64)(unsafe.Pointer(p)) /= v
291 return *(*float64)(unsafe.Pointer(p))
292}
293
294func AssignDivPtrComplex64(p uintptr, v complex64) complex64 {
295 *(*complex64)(unsafe.Pointer(p)) /= v
296 return *(*complex64)(unsafe.Pointer(p))
297}
298
299func AssignDivPtrComplex128(p uintptr, v complex128) complex128 {
300 *(*complex128)(unsafe.Pointer(p)) /= v
301 return *(*complex128)(unsafe.Pointer(p))
302}
303
304func AssignDivPtrUintptr(p uintptr, v uintptr) uintptr {
305 *(*uintptr)(unsafe.Pointer(p)) /= v
306 return *(*uintptr)(unsafe.Pointer(p))
307}
308
309func AssignRemPtrInt8(p uintptr, v int8) int8 {
310 *(*int8)(unsafe.Pointer(p)) %= v
311 return *(*int8)(unsafe.Pointer(p))
312}
313
314func AssignRemPtrInt16(p uintptr, v int16) int16 {
315 *(*int16)(unsafe.Pointer(p)) %= v
316 return *(*int16)(unsafe.Pointer(p))
317}
318
319func AssignRemPtrInt32(p uintptr, v int32) int32 {
320 *(*int32)(unsafe.Pointer(p)) %= v
321 return *(*int32)(unsafe.Pointer(p))
322}
323
324func AssignRemPtrInt64(p uintptr, v int64) int64 {
325 *(*int64)(unsafe.Pointer(p)) %= v
326 return *(*int64)(unsafe.Pointer(p))
327}
328
329func AssignRemPtrUint8(p uintptr, v uint8) uint8 {
330 *(*uint8)(unsafe.Pointer(p)) %= v
331 return *(*uint8)(unsafe.Pointer(p))
332}
333
334func AssignRemPtrUint16(p uintptr, v uint16) uint16 {
335 *(*uint16)(unsafe.Pointer(p)) %= v
336 return *(*uint16)(unsafe.Pointer(p))
337}
338
339func AssignRemPtrUint32(p uintptr, v uint32) uint32 {
340 *(*uint32)(unsafe.Pointer(p)) %= v
341 return *(*uint32)(unsafe.Pointer(p))
342}
343
344func AssignRemPtrUint64(p uintptr, v uint64) uint64 {
345 *(*uint64)(unsafe.Pointer(p)) %= v
346 return *(*uint64)(unsafe.Pointer(p))
347}
348
349func AssignRemPtrUintptr(p uintptr, v uintptr) uintptr {
350 *(*uintptr)(unsafe.Pointer(p)) %= v
351 return *(*uintptr)(unsafe.Pointer(p))
352}
353
354func AssignAddPtrInt8(p uintptr, v int8) int8 {
355 *(*int8)(unsafe.Pointer(p)) += v
356 return *(*int8)(unsafe.Pointer(p))
357}
358
359func AssignAddPtrInt16(p uintptr, v int16) int16 {
360 *(*int16)(unsafe.Pointer(p)) += v
361 return *(*int16)(unsafe.Pointer(p))
362}
363
364func AssignAddPtrInt32(p uintptr, v int32) int32 {
365 *(*int32)(unsafe.Pointer(p)) += v
366 return *(*int32)(unsafe.Pointer(p))
367}
368
369func AssignAddPtrInt64(p uintptr, v int64) int64 {
370 *(*int64)(unsafe.Pointer(p)) += v
371 return *(*int64)(unsafe.Pointer(p))
372}
373
374func AssignAddPtrUint8(p uintptr, v uint8) uint8 {
375 *(*uint8)(unsafe.Pointer(p)) += v
376 return *(*uint8)(unsafe.Pointer(p))
377}
378
379func AssignAddPtrUint16(p uintptr, v uint16) uint16 {
380 *(*uint16)(unsafe.Pointer(p)) += v
381 return *(*uint16)(unsafe.Pointer(p))
382}
383
384func AssignAddPtrUint32(p uintptr, v uint32) uint32 {
385 *(*uint32)(unsafe.Pointer(p)) += v
386 return *(*uint32)(unsafe.Pointer(p))
387}
388
389func AssignAddPtrUint64(p uintptr, v uint64) uint64 {
390 *(*uint64)(unsafe.Pointer(p)) += v
391 return *(*uint64)(unsafe.Pointer(p))
392}
393
394func AssignAddPtrFloat32(p uintptr, v float32) float32 {
395 *(*float32)(unsafe.Pointer(p)) += v
396 return *(*float32)(unsafe.Pointer(p))
397}
398
399func AssignAddPtrFloat64(p uintptr, v float64) float64 {
400 *(*float64)(unsafe.Pointer(p)) += v
401 return *(*float64)(unsafe.Pointer(p))
402}
403
404func AssignAddPtrComplex64(p uintptr, v complex64) complex64 {
405 *(*complex64)(unsafe.Pointer(p)) += v
406 return *(*complex64)(unsafe.Pointer(p))
407}
408
409func AssignAddPtrComplex128(p uintptr, v complex128) complex128 {
410 *(*complex128)(unsafe.Pointer(p)) += v
411 return *(*complex128)(unsafe.Pointer(p))
412}
413
414func AssignAddPtrUintptr(p uintptr, v uintptr) uintptr {
415 *(*uintptr)(unsafe.Pointer(p)) += v
416 return *(*uintptr)(unsafe.Pointer(p))
417}
418
419func AssignSubPtrInt8(p uintptr, v int8) int8 {
420 *(*int8)(unsafe.Pointer(p)) -= v
421 return *(*int8)(unsafe.Pointer(p))
422}
423
424func AssignSubPtrInt16(p uintptr, v int16) int16 {
425 *(*int16)(unsafe.Pointer(p)) -= v
426 return *(*int16)(unsafe.Pointer(p))
427}
428
429func AssignSubPtrInt32(p uintptr, v int32) int32 {
430 *(*int32)(unsafe.Pointer(p)) -= v
431 return *(*int32)(unsafe.Pointer(p))
432}
433
434func AssignSubPtrInt64(p uintptr, v int64) int64 {
435 *(*int64)(unsafe.Pointer(p)) -= v
436 return *(*int64)(unsafe.Pointer(p))
437}
438
439func AssignSubPtrUint8(p uintptr, v uint8) uint8 {
440 *(*uint8)(unsafe.Pointer(p)) -= v
441 return *(*uint8)(unsafe.Pointer(p))
442}
443
444func AssignSubPtrUint16(p uintptr, v uint16) uint16 {
445 *(*uint16)(unsafe.Pointer(p)) -= v
446 return *(*uint16)(unsafe.Pointer(p))
447}
448
449func AssignSubPtrUint32(p uintptr, v uint32) uint32 {
450 *(*uint32)(unsafe.Pointer(p)) -= v
451 return *(*uint32)(unsafe.Pointer(p))
452}
453
454func AssignSubPtrUint64(p uintptr, v uint64) uint64 {
455 *(*uint64)(unsafe.Pointer(p)) -= v
456 return *(*uint64)(unsafe.Pointer(p))
457}
458
459func AssignSubPtrFloat32(p uintptr, v float32) float32 {
460 *(*float32)(unsafe.Pointer(p)) -= v
461 return *(*float32)(unsafe.Pointer(p))
462}
463
464func AssignSubPtrFloat64(p uintptr, v float64) float64 {
465 *(*float64)(unsafe.Pointer(p)) -= v
466 return *(*float64)(unsafe.Pointer(p))
467}
468
469func AssignSubPtrComplex64(p uintptr, v complex64) complex64 {
470 *(*complex64)(unsafe.Pointer(p)) -= v
471 return *(*complex64)(unsafe.Pointer(p))
472}
473
474func AssignSubPtrComplex128(p uintptr, v complex128) complex128 {
475 *(*complex128)(unsafe.Pointer(p)) -= v
476 return *(*complex128)(unsafe.Pointer(p))
477}
478
479func AssignSubPtrUintptr(p uintptr, v uintptr) uintptr {
480 *(*uintptr)(unsafe.Pointer(p)) -= v
481 return *(*uintptr)(unsafe.Pointer(p))
482}
483
484func AssignAndPtrInt8(p uintptr, v int8) int8 {
485 *(*int8)(unsafe.Pointer(p)) &= v
486 return *(*int8)(unsafe.Pointer(p))
487}
488
489func AssignAndPtrInt16(p uintptr, v int16) int16 {
490 *(*int16)(unsafe.Pointer(p)) &= v
491 return *(*int16)(unsafe.Pointer(p))
492}
493
494func AssignAndPtrInt32(p uintptr, v int32) int32 {
495 *(*int32)(unsafe.Pointer(p)) &= v
496 return *(*int32)(unsafe.Pointer(p))
497}
498
499func AssignAndPtrInt64(p uintptr, v int64) int64 {
500 *(*int64)(unsafe.Pointer(p)) &= v
501 return *(*int64)(unsafe.Pointer(p))
502}
503
504func AssignAndPtrUint8(p uintptr, v uint8) uint8 {
505 *(*uint8)(unsafe.Pointer(p)) &= v
506 return *(*uint8)(unsafe.Pointer(p))
507}
508
509func AssignAndPtrUint16(p uintptr, v uint16) uint16 {
510 *(*uint16)(unsafe.Pointer(p)) &= v
511 return *(*uint16)(unsafe.Pointer(p))
512}
513
514func AssignAndPtrUint32(p uintptr, v uint32) uint32 {
515 *(*uint32)(unsafe.Pointer(p)) &= v
516 return *(*uint32)(unsafe.Pointer(p))
517}
518
519func AssignAndPtrUint64(p uintptr, v uint64) uint64 {
520 *(*uint64)(unsafe.Pointer(p)) &= v
521 return *(*uint64)(unsafe.Pointer(p))
522}
523
524func AssignAndPtrUintptr(p uintptr, v uintptr) uintptr {
525 *(*uintptr)(unsafe.Pointer(p)) &= v
526 return *(*uintptr)(unsafe.Pointer(p))
527}
528
529func AssignXorPtrInt8(p uintptr, v int8) int8 {
530 *(*int8)(unsafe.Pointer(p)) ^= v
531 return *(*int8)(unsafe.Pointer(p))
532}
533
534func AssignXorPtrInt16(p uintptr, v int16) int16 {
535 *(*int16)(unsafe.Pointer(p)) ^= v
536 return *(*int16)(unsafe.Pointer(p))
537}
538
539func AssignXorPtrInt32(p uintptr, v int32) int32 {
540 *(*int32)(unsafe.Pointer(p)) ^= v
541 return *(*int32)(unsafe.Pointer(p))
542}
543
544func AssignXorPtrInt64(p uintptr, v int64) int64 {
545 *(*int64)(unsafe.Pointer(p)) ^= v
546 return *(*int64)(unsafe.Pointer(p))
547}
548
549func AssignXorPtrUint8(p uintptr, v uint8) uint8 {
550 *(*uint8)(unsafe.Pointer(p)) ^= v
551 return *(*uint8)(unsafe.Pointer(p))
552}
553
554func AssignXorPtrUint16(p uintptr, v uint16) uint16 {
555 *(*uint16)(unsafe.Pointer(p)) ^= v
556 return *(*uint16)(unsafe.Pointer(p))
557}
558
559func AssignXorPtrUint32(p uintptr, v uint32) uint32 {
560 *(*uint32)(unsafe.Pointer(p)) ^= v
561 return *(*uint32)(unsafe.Pointer(p))
562}
563
564func AssignXorPtrUint64(p uintptr, v uint64) uint64 {
565 *(*uint64)(unsafe.Pointer(p)) ^= v
566 return *(*uint64)(unsafe.Pointer(p))
567}
568
569func AssignXorPtrUintptr(p uintptr, v uintptr) uintptr {
570 *(*uintptr)(unsafe.Pointer(p)) ^= v
571 return *(*uintptr)(unsafe.Pointer(p))
572}
573
574func AssignOrPtrInt8(p uintptr, v int8) int8 {
575 *(*int8)(unsafe.Pointer(p)) |= v
576 return *(*int8)(unsafe.Pointer(p))
577}
578
579func AssignOrPtrInt16(p uintptr, v int16) int16 {
580 *(*int16)(unsafe.Pointer(p)) |= v
581 return *(*int16)(unsafe.Pointer(p))
582}
583
584func AssignOrPtrInt32(p uintptr, v int32) int32 {
585 *(*int32)(unsafe.Pointer(p)) |= v
586 return *(*int32)(unsafe.Pointer(p))
587}
588
589func AssignOrPtrInt64(p uintptr, v int64) int64 {
590 *(*int64)(unsafe.Pointer(p)) |= v
591 return *(*int64)(unsafe.Pointer(p))
592}
593
594func AssignOrPtrUint8(p uintptr, v uint8) uint8 {
595 *(*uint8)(unsafe.Pointer(p)) |= v
596 return *(*uint8)(unsafe.Pointer(p))
597}
598
599func AssignOrPtrUint16(p uintptr, v uint16) uint16 {
600 *(*uint16)(unsafe.Pointer(p)) |= v
601 return *(*uint16)(unsafe.Pointer(p))
602}
603
604func AssignOrPtrUint32(p uintptr, v uint32) uint32 {
605 *(*uint32)(unsafe.Pointer(p)) |= v
606 return *(*uint32)(unsafe.Pointer(p))
607}
608
609func AssignOrPtrUint64(p uintptr, v uint64) uint64 {
610 *(*uint64)(unsafe.Pointer(p)) |= v
611 return *(*uint64)(unsafe.Pointer(p))
612}
613
614func AssignOrPtrUintptr(p uintptr, v uintptr) uintptr {
615 *(*uintptr)(unsafe.Pointer(p)) |= v
616 return *(*uintptr)(unsafe.Pointer(p))
617}
618
619func AssignShlPtrInt8(p uintptr, v int) int8 {
620 *(*int8)(unsafe.Pointer(p)) <<= v
621 return *(*int8)(unsafe.Pointer(p))
622}
623
624func AssignShlPtrInt16(p uintptr, v int) int16 {
625 *(*int16)(unsafe.Pointer(p)) <<= v
626 return *(*int16)(unsafe.Pointer(p))
627}
628
629func AssignShlPtrInt32(p uintptr, v int) int32 {
630 *(*int32)(unsafe.Pointer(p)) <<= v
631 return *(*int32)(unsafe.Pointer(p))
632}
633
634func AssignShlPtrInt64(p uintptr, v int) int64 {
635 *(*int64)(unsafe.Pointer(p)) <<= v
636 return *(*int64)(unsafe.Pointer(p))
637}
638
639func AssignShlPtrUint8(p uintptr, v int) uint8 {
640 *(*uint8)(unsafe.Pointer(p)) <<= v
641 return *(*uint8)(unsafe.Pointer(p))
642}
643
644func AssignShlPtrUint16(p uintptr, v int) uint16 {
645 *(*uint16)(unsafe.Pointer(p)) <<= v
646 return *(*uint16)(unsafe.Pointer(p))
647}
648
649func AssignShlPtrUint32(p uintptr, v int) uint32 {
650 *(*uint32)(unsafe.Pointer(p)) <<= v
651 return *(*uint32)(unsafe.Pointer(p))
652}
653
654func AssignShlPtrUint64(p uintptr, v int) uint64 {
655 *(*uint64)(unsafe.Pointer(p)) <<= v
656 return *(*uint64)(unsafe.Pointer(p))
657}
658
659func AssignShlPtrUintptr(p uintptr, v int) uintptr {
660 *(*uintptr)(unsafe.Pointer(p)) <<= v
661 return *(*uintptr)(unsafe.Pointer(p))
662}
663
664func AssignShrPtrInt8(p uintptr, v int) int8 {
665 *(*int8)(unsafe.Pointer(p)) >>= v
666 return *(*int8)(unsafe.Pointer(p))
667}
668
669func AssignShrPtrInt16(p uintptr, v int) int16 {
670 *(*int16)(unsafe.Pointer(p)) >>= v
671 return *(*int16)(unsafe.Pointer(p))
672}
673
674func AssignShrPtrInt32(p uintptr, v int) int32 {
675 *(*int32)(unsafe.Pointer(p)) >>= v
676 return *(*int32)(unsafe.Pointer(p))
677}
678
679func AssignShrPtrInt64(p uintptr, v int) int64 {
680 *(*int64)(unsafe.Pointer(p)) >>= v
681 return *(*int64)(unsafe.Pointer(p))
682}
683
684func AssignShrPtrUint8(p uintptr, v int) uint8 {
685 *(*uint8)(unsafe.Pointer(p)) >>= v
686 return *(*uint8)(unsafe.Pointer(p))
687}
688
689func AssignShrPtrUint16(p uintptr, v int) uint16 {
690 *(*uint16)(unsafe.Pointer(p)) >>= v
691 return *(*uint16)(unsafe.Pointer(p))
692}
693
694func AssignShrPtrUint32(p uintptr, v int) uint32 {
695 *(*uint32)(unsafe.Pointer(p)) >>= v
696 return *(*uint32)(unsafe.Pointer(p))
697}
698
699func AssignShrPtrUint64(p uintptr, v int) uint64 {
700 *(*uint64)(unsafe.Pointer(p)) >>= v
701 return *(*uint64)(unsafe.Pointer(p))
702}
703
704func AssignShrPtrUintptr(p uintptr, v int) uintptr {
705 *(*uintptr)(unsafe.Pointer(p)) >>= v
706 return *(*uintptr)(unsafe.Pointer(p))
707}
708
709func AssignShlInt8(p *int8, v int) int8 { *p <<= v; return *p }
710
711func AssignShlInt16(p *int16, v int) int16 { *p <<= v; return *p }
712
713func AssignShlInt32(p *int32, v int) int32 { *p <<= v; return *p }
714
715func AssignShlInt64(p *int64, v int) int64 { *p <<= v; return *p }
716
717func AssignShlUint8(p *uint8, v int) uint8 { *p <<= v; return *p }
718
719func AssignShlUint16(p *uint16, v int) uint16 { *p <<= v; return *p }
720
721func AssignShlUint32(p *uint32, v int) uint32 { *p <<= v; return *p }
722
723func AssignShlUint64(p *uint64, v int) uint64 { *p <<= v; return *p }
724
725func AssignShlUintptr(p *uintptr, v int) uintptr { *p <<= v; return *p }
726
727func AssignShrInt8(p *int8, v int) int8 { *p >>= v; return *p }
728
729func AssignShrInt16(p *int16, v int) int16 { *p >>= v; return *p }
730
731func AssignShrInt32(p *int32, v int) int32 { *p >>= v; return *p }
732
733func AssignShrInt64(p *int64, v int) int64 { *p >>= v; return *p }
734
735func AssignShrUint8(p *uint8, v int) uint8 { *p >>= v; return *p }
736
737func AssignShrUint16(p *uint16, v int) uint16 { *p >>= v; return *p }
738
739func AssignShrUint32(p *uint32, v int) uint32 { *p >>= v; return *p }
740
741func AssignShrUint64(p *uint64, v int) uint64 { *p >>= v; return *p }
742
743func AssignShrUintptr(p *uintptr, v int) uintptr { *p >>= v; return *p }
744
745func PreIncInt8(p *int8, d int8) int8 { *p += d; return *p }
746func PreIncInt16(p *int16, d int16) int16 { *p += d; return *p }
747func PreIncInt32(p *int32, d int32) int32 { *p += d; return *p }
748func PreIncInt64(p *int64, d int64) int64 { *p += d; return *p }
749func PreIncUint8(p *uint8, d uint8) uint8 { *p += d; return *p }
750func PreIncUint16(p *uint16, d uint16) uint16 { *p += d; return *p }
751func PreIncUint32(p *uint32, d uint32) uint32 { *p += d; return *p }
752func PreIncUint64(p *uint64, d uint64) uint64 { *p += d; return *p }
753func PreIncFloat32(p *float32, d float32) float32 { *p += d; return *p }
754func PreIncFloat64(p *float64, d float64) float64 { *p += d; return *p }
755func PreIncComplex64(p *complex64, d complex64) complex64 { *p += d; return *p }
756func PreIncComplex128(p *complex128, d complex128) complex128 { *p += d; return *p }
757func PreIncUintptr(p *uintptr, d uintptr) uintptr { *p += d; return *p }
758
759func PreIncAtomicInt32(p *int32, d int32) int32 { return atomic.AddInt32(p, d) }
760func PreIncAtomicInt64(p *int64, d int64) int64 { return atomic.AddInt64(p, d) }
761func PreIncAtomicUint32(p *uint32, d uint32) uint32 { return atomic.AddUint32(p, d) }
762func PreIncAtomicUint64(p *uint64, d uint64) uint64 { return atomic.AddUint64(p, d) }
763func PreIncAtomicUintptr(p *uintptr, d uintptr) uintptr { return atomic.AddUintptr(p, d) }
764
765func PreDecInt8(p *int8, d int8) int8 { *p -= d; return *p }
766func PreDecInt16(p *int16, d int16) int16 { *p -= d; return *p }
767func PreDecInt32(p *int32, d int32) int32 { *p -= d; return *p }
768func PreDecInt64(p *int64, d int64) int64 { *p -= d; return *p }
769func PreDecUint8(p *uint8, d uint8) uint8 { *p -= d; return *p }
770func PreDecUint16(p *uint16, d uint16) uint16 { *p -= d; return *p }
771func PreDecUint32(p *uint32, d uint32) uint32 { *p -= d; return *p }
772func PreDecUint64(p *uint64, d uint64) uint64 { *p -= d; return *p }
773func PreDecFloat32(p *float32, d float32) float32 { *p -= d; return *p }
774func PreDecFloat64(p *float64, d float64) float64 { *p -= d; return *p }
775func PreDecComplex64(p *complex64, d complex64) complex64 { *p -= d; return *p }
776func PreDecComplex128(p *complex128, d complex128) complex128 { *p -= d; return *p }
777func PreDecUintptr(p *uintptr, d uintptr) uintptr { *p -= d; return *p }
778
779func PreDecAtomicInt32(p *int32, d int32) int32 { return atomic.AddInt32(p, -d) }
780func PreDecAtomicInt64(p *int64, d int64) int64 { return atomic.AddInt64(p, -d) }
781func PreDecAtomicUint32(p *uint32, d uint32) uint32 { return atomic.AddUint32(p, -d) }
782func PreDecAtomicUint64(p *uint64, d uint64) uint64 { return atomic.AddUint64(p, -d) }
783func PreDecAtomicUintptr(p *uintptr, d uintptr) uintptr { return atomic.AddUintptr(p, -d) }
784
785func PostIncInt8(p *int8, d int8) int8 { r := *p; *p += d; return r }
786func PostIncInt16(p *int16, d int16) int16 { r := *p; *p += d; return r }
787func PostIncInt32(p *int32, d int32) int32 { r := *p; *p += d; return r }
788func PostIncInt64(p *int64, d int64) int64 { r := *p; *p += d; return r }
789func PostIncUint8(p *uint8, d uint8) uint8 { r := *p; *p += d; return r }
790func PostIncUint16(p *uint16, d uint16) uint16 { r := *p; *p += d; return r }
791func PostIncUint32(p *uint32, d uint32) uint32 { r := *p; *p += d; return r }
792func PostIncUint64(p *uint64, d uint64) uint64 { r := *p; *p += d; return r }
793func PostIncFloat32(p *float32, d float32) float32 { r := *p; *p += d; return r }
794func PostIncFloat64(p *float64, d float64) float64 { r := *p; *p += d; return r }
795func PostIncComplex64(p *complex64, d complex64) complex64 { r := *p; *p += d; return r }
796func PostIncComplex128(p *complex128, d complex128) complex128 { r := *p; *p += d; return r }
797func PostIncUintptr(p *uintptr, d uintptr) uintptr { r := *p; *p += d; return r }
798
799func PostIncAtomicInt32(p *int32, d int32) int32 { return atomic.AddInt32(p, d) - d }
800func PostIncAtomicInt64(p *int64, d int64) int64 { return atomic.AddInt64(p, d) - d }
801func PostIncAtomicUint32(p *uint32, d uint32) uint32 { return atomic.AddUint32(p, d) - d }
802func PostIncAtomicUint64(p *uint64, d uint64) uint64 { return atomic.AddUint64(p, d) - d }
803func PostIncAtomicUintptr(p *uintptr, d uintptr) uintptr { return atomic.AddUintptr(p, d) - d }
804
805func PostDecInt8(p *int8, d int8) int8 { r := *p; *p -= d; return r }
806func PostDecInt16(p *int16, d int16) int16 { r := *p; *p -= d; return r }
807func PostDecInt32(p *int32, d int32) int32 { r := *p; *p -= d; return r }
808func PostDecInt64(p *int64, d int64) int64 { r := *p; *p -= d; return r }
809func PostDecUint8(p *uint8, d uint8) uint8 { r := *p; *p -= d; return r }
810func PostDecUint16(p *uint16, d uint16) uint16 { r := *p; *p -= d; return r }
811func PostDecUint32(p *uint32, d uint32) uint32 { r := *p; *p -= d; return r }
812func PostDecUint64(p *uint64, d uint64) uint64 { r := *p; *p -= d; return r }
813func PostDecFloat32(p *float32, d float32) float32 { r := *p; *p -= d; return r }
814func PostDecFloat64(p *float64, d float64) float64 { r := *p; *p -= d; return r }
815func PostDecComplex64(p *complex64, d complex64) complex64 { r := *p; *p -= d; return r }
816func PostDecComplex128(p *complex128, d complex128) complex128 { r := *p; *p -= d; return r }
817func PostDecUintptr(p *uintptr, d uintptr) uintptr { r := *p; *p -= d; return r }
818
819func PostDecAtomicInt32(p *int32, d int32) int32 { return atomic.AddInt32(p, -d) + d }
820func PostDecAtomicInt64(p *int64, d int64) int64 { return atomic.AddInt64(p, -d) + d }
821func PostDecAtomicUint32(p *uint32, d uint32) uint32 { return atomic.AddUint32(p, -d) + d }
822func PostDecAtomicUint64(p *uint64, d uint64) uint64 { return atomic.AddUint64(p, -d) + d }
823func PostDecAtomicUintptr(p *uintptr, d uintptr) uintptr { return atomic.AddUintptr(p, -d) + d }
824
825func Int8FromInt8(n int8) int8 { return int8(n) }
826func Int8FromInt16(n int16) int8 { return int8(n) }
827func Int8FromInt32(n int32) int8 { return int8(n) }
828func Int8FromInt64(n int64) int8 { return int8(n) }
829func Int8FromUint8(n uint8) int8 { return int8(n) }
830func Int8FromUint16(n uint16) int8 { return int8(n) }
831func Int8FromUint32(n uint32) int8 { return int8(n) }
832func Int8FromUint64(n uint64) int8 { return int8(n) }
833func Int8FromFloat32(n float32) int8 { return int8(n) }
834func Int8FromFloat64(n float64) int8 { return int8(n) }
835func Int8FromComplex64(n complex64) int8 { return int8(real(n)) }
836func Int8FromComplex128(n complex128) int8 { return int8(real(n)) }
837func Int8FromUintptr(n uintptr) int8 { return int8(n) }
838func Int16FromInt8(n int8) int16 { return int16(n) }
839func Int16FromInt16(n int16) int16 { return int16(n) }
840func Int16FromInt32(n int32) int16 { return int16(n) }
841func Int16FromInt64(n int64) int16 { return int16(n) }
842func Int16FromUint8(n uint8) int16 { return int16(n) }
843func Int16FromUint16(n uint16) int16 { return int16(n) }
844func Int16FromUint32(n uint32) int16 { return int16(n) }
845func Int16FromUint64(n uint64) int16 { return int16(n) }
846func Int16FromFloat32(n float32) int16 { return int16(n) }
847func Int16FromFloat64(n float64) int16 { return int16(n) }
848func Int16FromComplex64(n complex64) int16 { return int16(real(n)) }
849func Int16FromComplex128(n complex128) int16 { return int16(real(n)) }
850func Int16FromUintptr(n uintptr) int16 { return int16(n) }
851func Int32FromInt8(n int8) int32 { return int32(n) }
852func Int32FromInt16(n int16) int32 { return int32(n) }
853func Int32FromInt32(n int32) int32 { return int32(n) }
854func Int32FromInt64(n int64) int32 { return int32(n) }
855func Int32FromUint8(n uint8) int32 { return int32(n) }
856func Int32FromUint16(n uint16) int32 { return int32(n) }
857func Int32FromUint32(n uint32) int32 { return int32(n) }
858func Int32FromUint64(n uint64) int32 { return int32(n) }
859func Int32FromFloat32(n float32) int32 { return int32(n) }
860func Int32FromFloat64(n float64) int32 { return int32(n) }
861func Int32FromComplex64(n complex64) int32 { return int32(real(n)) }
862func Int32FromComplex128(n complex128) int32 { return int32(real(n)) }
863func Int32FromUintptr(n uintptr) int32 { return int32(n) }
864func Int64FromInt8(n int8) int64 { return int64(n) }
865func Int64FromInt16(n int16) int64 { return int64(n) }
866func Int64FromInt32(n int32) int64 { return int64(n) }
867func Int64FromInt64(n int64) int64 { return int64(n) }
868func Int64FromUint8(n uint8) int64 { return int64(n) }
869func Int64FromUint16(n uint16) int64 { return int64(n) }
870func Int64FromUint32(n uint32) int64 { return int64(n) }
871func Int64FromUint64(n uint64) int64 { return int64(n) }
872func Int64FromFloat32(n float32) int64 { return int64(n) }
873func Int64FromFloat64(n float64) int64 { return int64(n) }
874func Int64FromComplex64(n complex64) int64 { return int64(real(n)) }
875func Int64FromComplex128(n complex128) int64 { return int64(real(n)) }
876func Int64FromUintptr(n uintptr) int64 { return int64(n) }
877func Uint8FromInt8(n int8) uint8 { return uint8(n) }
878func Uint8FromInt16(n int16) uint8 { return uint8(n) }
879func Uint8FromInt32(n int32) uint8 { return uint8(n) }
880func Uint8FromInt64(n int64) uint8 { return uint8(n) }
881func Uint8FromUint8(n uint8) uint8 { return uint8(n) }
882func Uint8FromUint16(n uint16) uint8 { return uint8(n) }
883func Uint8FromUint32(n uint32) uint8 { return uint8(n) }
884func Uint8FromUint64(n uint64) uint8 { return uint8(n) }
885func Uint8FromFloat32(n float32) uint8 { return uint8(n) }
886func Uint8FromFloat64(n float64) uint8 { return uint8(n) }
887func Uint8FromComplex64(n complex64) uint8 { return uint8(real(n)) }
888func Uint8FromComplex128(n complex128) uint8 { return uint8(real(n)) }
889func Uint8FromUintptr(n uintptr) uint8 { return uint8(n) }
890func Uint16FromInt8(n int8) uint16 { return uint16(n) }
891func Uint16FromInt16(n int16) uint16 { return uint16(n) }
892func Uint16FromInt32(n int32) uint16 { return uint16(n) }
893func Uint16FromInt64(n int64) uint16 { return uint16(n) }
894func Uint16FromUint8(n uint8) uint16 { return uint16(n) }
895func Uint16FromUint16(n uint16) uint16 { return uint16(n) }
896func Uint16FromUint32(n uint32) uint16 { return uint16(n) }
897func Uint16FromUint64(n uint64) uint16 { return uint16(n) }
898func Uint16FromFloat32(n float32) uint16 { return uint16(n) }
899func Uint16FromFloat64(n float64) uint16 { return uint16(n) }
900func Uint16FromComplex64(n complex64) uint16 { return uint16(real(n)) }
901func Uint16FromComplex128(n complex128) uint16 { return uint16(real(n)) }
902func Uint16FromUintptr(n uintptr) uint16 { return uint16(n) }
903func Uint32FromInt8(n int8) uint32 { return uint32(n) }
904func Uint32FromInt16(n int16) uint32 { return uint32(n) }
905func Uint32FromInt32(n int32) uint32 { return uint32(n) }
906func Uint32FromInt64(n int64) uint32 { return uint32(n) }
907func Uint32FromUint8(n uint8) uint32 { return uint32(n) }
908func Uint32FromUint16(n uint16) uint32 { return uint32(n) }
909func Uint32FromUint32(n uint32) uint32 { return uint32(n) }
910func Uint32FromUint64(n uint64) uint32 { return uint32(n) }
911func Uint32FromFloat32(n float32) uint32 { return uint32(n) }
912func Uint32FromFloat64(n float64) uint32 { return uint32(n) }
913func Uint32FromComplex64(n complex64) uint32 { return uint32(real(n)) }
914func Uint32FromComplex128(n complex128) uint32 { return uint32(real(n)) }
915func Uint32FromUintptr(n uintptr) uint32 { return uint32(n) }
916func Uint64FromInt8(n int8) uint64 { return uint64(n) }
917func Uint64FromInt16(n int16) uint64 { return uint64(n) }
918func Uint64FromInt32(n int32) uint64 { return uint64(n) }
919func Uint64FromInt64(n int64) uint64 { return uint64(n) }
920func Uint64FromUint8(n uint8) uint64 { return uint64(n) }
921func Uint64FromUint16(n uint16) uint64 { return uint64(n) }
922func Uint64FromUint32(n uint32) uint64 { return uint64(n) }
923func Uint64FromUint64(n uint64) uint64 { return uint64(n) }
924func Uint64FromFloat32(n float32) uint64 { return uint64(n) }
925func Uint64FromFloat64(n float64) uint64 { return uint64(n) }
926func Uint64FromComplex64(n complex64) uint64 { return uint64(real(n)) }
927func Uint64FromComplex128(n complex128) uint64 { return uint64(real(n)) }
928func Uint64FromUintptr(n uintptr) uint64 { return uint64(n) }
929func Float32FromInt8(n int8) float32 { return float32(n) }
930func Float32FromInt16(n int16) float32 { return float32(n) }
931func Float32FromInt32(n int32) float32 { return float32(n) }
932func Float32FromInt64(n int64) float32 { return float32(n) }
933func Float32FromUint8(n uint8) float32 { return float32(n) }
934func Float32FromUint16(n uint16) float32 { return float32(n) }
935func Float32FromUint32(n uint32) float32 { return float32(n) }
936func Float32FromUint64(n uint64) float32 { return float32(n) }
937func Float32FromFloat32(n float32) float32 { return float32(n) }
938func Float32FromFloat64(n float64) float32 { return float32(n) }
939func Float32FromComplex64(n complex64) float32 { return float32(real(n)) }
940func Float32FromComplex128(n complex128) float32 { return float32(real(n)) }
941func Float32FromUintptr(n uintptr) float32 { return float32(n) }
942func Float64FromInt8(n int8) float64 { return float64(n) }
943func Float64FromInt16(n int16) float64 { return float64(n) }
944func Float64FromInt32(n int32) float64 { return float64(n) }
945func Float64FromInt64(n int64) float64 { return float64(n) }
946func Float64FromUint8(n uint8) float64 { return float64(n) }
947func Float64FromUint16(n uint16) float64 { return float64(n) }
948func Float64FromUint32(n uint32) float64 { return float64(n) }
949func Float64FromUint64(n uint64) float64 { return float64(n) }
950func Float64FromFloat32(n float32) float64 { return float64(n) }
951func Float64FromFloat64(n float64) float64 { return float64(n) }
952func Float64FromComplex64(n complex64) float64 { return float64(real(n)) }
953func Float64FromComplex128(n complex128) float64 { return float64(real(n)) }
954func Float64FromUintptr(n uintptr) float64 { return float64(n) }
955func Complex64FromInt8(n int8) complex64 { return complex64(complex(float32(n), 0)) }
956func Complex64FromInt16(n int16) complex64 { return complex64(complex(float32(n), 0)) }
957func Complex64FromInt32(n int32) complex64 { return complex64(complex(float32(n), 0)) }
958func Complex64FromInt64(n int64) complex64 { return complex64(complex(float32(n), 0)) }
959func Complex64FromUint8(n uint8) complex64 { return complex64(complex(float32(n), 0)) }
960func Complex64FromUint16(n uint16) complex64 { return complex64(complex(float32(n), 0)) }
961func Complex64FromUint32(n uint32) complex64 { return complex64(complex(float32(n), 0)) }
962func Complex64FromUint64(n uint64) complex64 { return complex64(complex(float32(n), 0)) }
963func Complex64FromFloat32(n float32) complex64 { return complex64(complex(float32(n), 0)) }
964func Complex64FromFloat64(n float64) complex64 { return complex64(complex(float32(n), 0)) }
965func Complex64FromComplex64(n complex64) complex64 { return complex64(n) }
966func Complex64FromComplex128(n complex128) complex64 { return complex64(n) }
967func Complex64FromUintptr(n uintptr) complex64 { return complex64(complex(float32(n), 0)) }
968func Complex128FromInt8(n int8) complex128 { return complex128(complex(float64(n), 0)) }
969func Complex128FromInt16(n int16) complex128 { return complex128(complex(float64(n), 0)) }
970func Complex128FromInt32(n int32) complex128 { return complex128(complex(float64(n), 0)) }
971func Complex128FromInt64(n int64) complex128 { return complex128(complex(float64(n), 0)) }
972func Complex128FromUint8(n uint8) complex128 { return complex128(complex(float64(n), 0)) }
973func Complex128FromUint16(n uint16) complex128 { return complex128(complex(float64(n), 0)) }
974func Complex128FromUint32(n uint32) complex128 { return complex128(complex(float64(n), 0)) }
975func Complex128FromUint64(n uint64) complex128 { return complex128(complex(float64(n), 0)) }
976func Complex128FromFloat32(n float32) complex128 { return complex128(complex(float64(n), 0)) }
977func Complex128FromFloat64(n float64) complex128 { return complex128(complex(float64(n), 0)) }
978func Complex128FromComplex64(n complex64) complex128 { return complex128(n) }
979func Complex128FromComplex128(n complex128) complex128 { return complex128(n) }
980func Complex128FromUintptr(n uintptr) complex128 { return complex128(complex(float64(n), 0)) }
981func UintptrFromInt8(n int8) uintptr { return uintptr(n) }
982func UintptrFromInt16(n int16) uintptr { return uintptr(n) }
983func UintptrFromInt32(n int32) uintptr { return uintptr(n) }
984func UintptrFromInt64(n int64) uintptr { return uintptr(n) }
985func UintptrFromUint8(n uint8) uintptr { return uintptr(n) }
986func UintptrFromUint16(n uint16) uintptr { return uintptr(n) }
987func UintptrFromUint32(n uint32) uintptr { return uintptr(n) }
988func UintptrFromUint64(n uint64) uintptr { return uintptr(n) }
989func UintptrFromFloat32(n float32) uintptr { return uintptr(n) }
990func UintptrFromFloat64(n float64) uintptr { return uintptr(n) }
991func UintptrFromComplex64(n complex64) uintptr { return uintptr(real(n)) }
992func UintptrFromComplex128(n complex128) uintptr { return uintptr(real(n)) }
993func UintptrFromUintptr(n uintptr) uintptr { return uintptr(n) }
994
995func Int8(n int8) int8 { return n }
996func Int16(n int16) int16 { return n }
997func Int32(n int32) int32 { return n }
998func Int64(n int64) int64 { return n }
999func Uint8(n uint8) uint8 { return n }
1000func Uint16(n uint16) uint16 { return n }
1001func Uint32(n uint32) uint32 { return n }
1002func Uint64(n uint64) uint64 { return n }
1003func Float32(n float32) float32 { return n }
1004func Float64(n float64) float64 { return n }
1005func Complex64(n complex64) complex64 { return n }
1006func Complex128(n complex128) complex128 { return n }
1007func Uintptr(n uintptr) uintptr { return n }
1008
1009func NegInt8(n int8) int8 { return -n }
1010func NegInt16(n int16) int16 { return -n }
1011func NegInt32(n int32) int32 { return -n }
1012func NegInt64(n int64) int64 { return -n }
1013func NegUint8(n uint8) uint8 { return -n }
1014func NegUint16(n uint16) uint16 { return -n }
1015func NegUint32(n uint32) uint32 { return -n }
1016func NegUint64(n uint64) uint64 { return -n }
1017func NegUintptr(n uintptr) uintptr { return -n }
1018
1019func CplInt8(n int8) int8 { return ^n }
1020func CplInt16(n int16) int16 { return ^n }
1021func CplInt32(n int32) int32 { return ^n }
1022func CplInt64(n int64) int64 { return ^n }
1023func CplUint8(n uint8) uint8 { return ^n }
1024func CplUint16(n uint16) uint16 { return ^n }
1025func CplUint32(n uint32) uint32 { return ^n }
1026func CplUint64(n uint64) uint64 { return ^n }
1027func CplUintptr(n uintptr) uintptr { return ^n }
1028
1029func BoolInt8(b bool) int8 {
1030 if b {
1031 return 1
1032 }
1033 return 0
1034}
1035
1036func BoolInt16(b bool) int16 {
1037 if b {
1038 return 1
1039 }
1040 return 0
1041}
1042
1043func BoolInt32(b bool) int32 {
1044 if b {
1045 return 1
1046 }
1047 return 0
1048}
1049
1050func BoolInt64(b bool) int64 {
1051 if b {
1052 return 1
1053 }
1054 return 0
1055}
1056
1057func BoolUint8(b bool) uint8 {
1058 if b {
1059 return 1
1060 }
1061 return 0
1062}
1063
1064func BoolUint16(b bool) uint16 {
1065 if b {
1066 return 1
1067 }
1068 return 0
1069}
1070
1071func BoolUint32(b bool) uint32 {
1072 if b {
1073 return 1
1074 }
1075 return 0
1076}
1077
1078func BoolUint64(b bool) uint64 {
1079 if b {
1080 return 1
1081 }
1082 return 0
1083}
1084
1085func BoolUintptr(b bool) uintptr {
1086 if b {
1087 return 1
1088 }
1089 return 0
1090}
1091
1092func SetBitFieldPtr8Int8(p uintptr, v int8, off int, mask uint8) {
1093 *(*uint8)(unsafe.Pointer(p)) = *(*uint8)(unsafe.Pointer(p))&^uint8(mask) | uint8(v)<<off&mask
1094}
1095
1096func SetBitFieldPtr8Int16(p uintptr, v int16, off int, mask uint8) {
1097 *(*uint8)(unsafe.Pointer(p)) = *(*uint8)(unsafe.Pointer(p))&^uint8(mask) | uint8(v)<<off&mask
1098}
1099
1100func SetBitFieldPtr8Int32(p uintptr, v int32, off int, mask uint8) {
1101 *(*uint8)(unsafe.Pointer(p)) = *(*uint8)(unsafe.Pointer(p))&^uint8(mask) | uint8(v)<<off&mask
1102}
1103
1104func SetBitFieldPtr8Int64(p uintptr, v int64, off int, mask uint8) {
1105 *(*uint8)(unsafe.Pointer(p)) = *(*uint8)(unsafe.Pointer(p))&^uint8(mask) | uint8(v)<<off&mask
1106}
1107
1108func SetBitFieldPtr8Uint8(p uintptr, v uint8, off int, mask uint8) {
1109 *(*uint8)(unsafe.Pointer(p)) = *(*uint8)(unsafe.Pointer(p))&^uint8(mask) | uint8(v)<<off&mask
1110}
1111
1112func SetBitFieldPtr8Uint16(p uintptr, v uint16, off int, mask uint8) {
1113 *(*uint8)(unsafe.Pointer(p)) = *(*uint8)(unsafe.Pointer(p))&^uint8(mask) | uint8(v)<<off&mask
1114}
1115
1116func SetBitFieldPtr8Uint32(p uintptr, v uint32, off int, mask uint8) {
1117 *(*uint8)(unsafe.Pointer(p)) = *(*uint8)(unsafe.Pointer(p))&^uint8(mask) | uint8(v)<<off&mask
1118}
1119
1120func SetBitFieldPtr8Uint64(p uintptr, v uint64, off int, mask uint8) {
1121 *(*uint8)(unsafe.Pointer(p)) = *(*uint8)(unsafe.Pointer(p))&^uint8(mask) | uint8(v)<<off&mask
1122}
1123
1124func SetBitFieldPtr16Int8(p uintptr, v int8, off int, mask uint16) {
1125 *(*uint16)(unsafe.Pointer(p)) = *(*uint16)(unsafe.Pointer(p))&^uint16(mask) | uint16(v)<<off&mask
1126}
1127
1128func SetBitFieldPtr16Int16(p uintptr, v int16, off int, mask uint16) {
1129 *(*uint16)(unsafe.Pointer(p)) = *(*uint16)(unsafe.Pointer(p))&^uint16(mask) | uint16(v)<<off&mask
1130}
1131
1132func SetBitFieldPtr16Int32(p uintptr, v int32, off int, mask uint16) {
1133 *(*uint16)(unsafe.Pointer(p)) = *(*uint16)(unsafe.Pointer(p))&^uint16(mask) | uint16(v)<<off&mask
1134}
1135
1136func SetBitFieldPtr16Int64(p uintptr, v int64, off int, mask uint16) {
1137 *(*uint16)(unsafe.Pointer(p)) = *(*uint16)(unsafe.Pointer(p))&^uint16(mask) | uint16(v)<<off&mask
1138}
1139
1140func SetBitFieldPtr16Uint8(p uintptr, v uint8, off int, mask uint16) {
1141 *(*uint16)(unsafe.Pointer(p)) = *(*uint16)(unsafe.Pointer(p))&^uint16(mask) | uint16(v)<<off&mask
1142}
1143
1144func SetBitFieldPtr16Uint16(p uintptr, v uint16, off int, mask uint16) {
1145 *(*uint16)(unsafe.Pointer(p)) = *(*uint16)(unsafe.Pointer(p))&^uint16(mask) | uint16(v)<<off&mask
1146}
1147
1148func SetBitFieldPtr16Uint32(p uintptr, v uint32, off int, mask uint16) {
1149 *(*uint16)(unsafe.Pointer(p)) = *(*uint16)(unsafe.Pointer(p))&^uint16(mask) | uint16(v)<<off&mask
1150}
1151
1152func SetBitFieldPtr16Uint64(p uintptr, v uint64, off int, mask uint16) {
1153 *(*uint16)(unsafe.Pointer(p)) = *(*uint16)(unsafe.Pointer(p))&^uint16(mask) | uint16(v)<<off&mask
1154}
1155
1156func SetBitFieldPtr32Int8(p uintptr, v int8, off int, mask uint32) {
1157 *(*uint32)(unsafe.Pointer(p)) = *(*uint32)(unsafe.Pointer(p))&^uint32(mask) | uint32(v)<<off&mask
1158}
1159
1160func SetBitFieldPtr32Int16(p uintptr, v int16, off int, mask uint32) {
1161 *(*uint32)(unsafe.Pointer(p)) = *(*uint32)(unsafe.Pointer(p))&^uint32(mask) | uint32(v)<<off&mask
1162}
1163
1164func SetBitFieldPtr32Int32(p uintptr, v int32, off int, mask uint32) {
1165 *(*uint32)(unsafe.Pointer(p)) = *(*uint32)(unsafe.Pointer(p))&^uint32(mask) | uint32(v)<<off&mask
1166}
1167
1168func SetBitFieldPtr32Int64(p uintptr, v int64, off int, mask uint32) {
1169 *(*uint32)(unsafe.Pointer(p)) = *(*uint32)(unsafe.Pointer(p))&^uint32(mask) | uint32(v)<<off&mask
1170}
1171
1172func SetBitFieldPtr32Uint8(p uintptr, v uint8, off int, mask uint32) {
1173 *(*uint32)(unsafe.Pointer(p)) = *(*uint32)(unsafe.Pointer(p))&^uint32(mask) | uint32(v)<<off&mask
1174}
1175
1176func SetBitFieldPtr32Uint16(p uintptr, v uint16, off int, mask uint32) {
1177 *(*uint32)(unsafe.Pointer(p)) = *(*uint32)(unsafe.Pointer(p))&^uint32(mask) | uint32(v)<<off&mask
1178}
1179
1180func SetBitFieldPtr32Uint32(p uintptr, v uint32, off int, mask uint32) {
1181 *(*uint32)(unsafe.Pointer(p)) = *(*uint32)(unsafe.Pointer(p))&^uint32(mask) | uint32(v)<<off&mask
1182}
1183
1184func SetBitFieldPtr32Uint64(p uintptr, v uint64, off int, mask uint32) {
1185 *(*uint32)(unsafe.Pointer(p)) = *(*uint32)(unsafe.Pointer(p))&^uint32(mask) | uint32(v)<<off&mask
1186}
1187
1188func SetBitFieldPtr64Int8(p uintptr, v int8, off int, mask uint64) {
1189 *(*uint64)(unsafe.Pointer(p)) = *(*uint64)(unsafe.Pointer(p))&^uint64(mask) | uint64(v)<<off&mask
1190}
1191
1192func SetBitFieldPtr64Int16(p uintptr, v int16, off int, mask uint64) {
1193 *(*uint64)(unsafe.Pointer(p)) = *(*uint64)(unsafe.Pointer(p))&^uint64(mask) | uint64(v)<<off&mask
1194}
1195
1196func SetBitFieldPtr64Int32(p uintptr, v int32, off int, mask uint64) {
1197 *(*uint64)(unsafe.Pointer(p)) = *(*uint64)(unsafe.Pointer(p))&^uint64(mask) | uint64(v)<<off&mask
1198}
1199
1200func SetBitFieldPtr64Int64(p uintptr, v int64, off int, mask uint64) {
1201 *(*uint64)(unsafe.Pointer(p)) = *(*uint64)(unsafe.Pointer(p))&^uint64(mask) | uint64(v)<<off&mask
1202}
1203
1204func SetBitFieldPtr64Uint8(p uintptr, v uint8, off int, mask uint64) {
1205 *(*uint64)(unsafe.Pointer(p)) = *(*uint64)(unsafe.Pointer(p))&^uint64(mask) | uint64(v)<<off&mask
1206}
1207
1208func SetBitFieldPtr64Uint16(p uintptr, v uint16, off int, mask uint64) {
1209 *(*uint64)(unsafe.Pointer(p)) = *(*uint64)(unsafe.Pointer(p))&^uint64(mask) | uint64(v)<<off&mask
1210}
1211
1212func SetBitFieldPtr64Uint32(p uintptr, v uint32, off int, mask uint64) {
1213 *(*uint64)(unsafe.Pointer(p)) = *(*uint64)(unsafe.Pointer(p))&^uint64(mask) | uint64(v)<<off&mask
1214}
1215
1216func SetBitFieldPtr64Uint64(p uintptr, v uint64, off int, mask uint64) {
1217 *(*uint64)(unsafe.Pointer(p)) = *(*uint64)(unsafe.Pointer(p))&^uint64(mask) | uint64(v)<<off&mask
1218}
1219
1220func AssignBitFieldPtr8Int8(p uintptr, v int8, w, off int, mask uint8) int8 {
1221 *(*uint8)(unsafe.Pointer(p)) = *(*uint8)(unsafe.Pointer(p))&^uint8(mask) | uint8(v)<<off&mask
1222 s := 8 - w
1223 return v << s >> s
1224}
1225
1226func AssignBitFieldPtr8Int16(p uintptr, v int16, w, off int, mask uint8) int16 {
1227 *(*uint8)(unsafe.Pointer(p)) = *(*uint8)(unsafe.Pointer(p))&^uint8(mask) | uint8(v)<<off&mask
1228 s := 16 - w
1229 return v << s >> s
1230}
1231
1232func AssignBitFieldPtr8Int32(p uintptr, v int32, w, off int, mask uint8) int32 {
1233 *(*uint8)(unsafe.Pointer(p)) = *(*uint8)(unsafe.Pointer(p))&^uint8(mask) | uint8(v)<<off&mask
1234 s := 32 - w
1235 return v << s >> s
1236}
1237
1238func AssignBitFieldPtr8Int64(p uintptr, v int64, w, off int, mask uint8) int64 {
1239 *(*uint8)(unsafe.Pointer(p)) = *(*uint8)(unsafe.Pointer(p))&^uint8(mask) | uint8(v)<<off&mask
1240 s := 64 - w
1241 return v << s >> s
1242}
1243
1244func AssignBitFieldPtr16Int8(p uintptr, v int8, w, off int, mask uint16) int8 {
1245 *(*uint16)(unsafe.Pointer(p)) = *(*uint16)(unsafe.Pointer(p))&^uint16(mask) | uint16(v)<<off&mask
1246 s := 8 - w
1247 return v << s >> s
1248}
1249
1250func AssignBitFieldPtr16Int16(p uintptr, v int16, w, off int, mask uint16) int16 {
1251 *(*uint16)(unsafe.Pointer(p)) = *(*uint16)(unsafe.Pointer(p))&^uint16(mask) | uint16(v)<<off&mask
1252 s := 16 - w
1253 return v << s >> s
1254}
1255
1256func AssignBitFieldPtr16Int32(p uintptr, v int32, w, off int, mask uint16) int32 {
1257 *(*uint16)(unsafe.Pointer(p)) = *(*uint16)(unsafe.Pointer(p))&^uint16(mask) | uint16(v)<<off&mask
1258 s := 32 - w
1259 return v << s >> s
1260}
1261
1262func AssignBitFieldPtr16Int64(p uintptr, v int64, w, off int, mask uint16) int64 {
1263 *(*uint16)(unsafe.Pointer(p)) = *(*uint16)(unsafe.Pointer(p))&^uint16(mask) | uint16(v)<<off&mask
1264 s := 64 - w
1265 return v << s >> s
1266}
1267
1268func AssignBitFieldPtr32Int8(p uintptr, v int8, w, off int, mask uint32) int8 {
1269 *(*uint32)(unsafe.Pointer(p)) = *(*uint32)(unsafe.Pointer(p))&^uint32(mask) | uint32(v)<<off&mask
1270 s := 8 - w
1271 return v << s >> s
1272}
1273
1274func AssignBitFieldPtr32Int16(p uintptr, v int16, w, off int, mask uint32) int16 {
1275 *(*uint32)(unsafe.Pointer(p)) = *(*uint32)(unsafe.Pointer(p))&^uint32(mask) | uint32(v)<<off&mask
1276 s := 16 - w
1277 return v << s >> s
1278}
1279
1280func AssignBitFieldPtr32Int32(p uintptr, v int32, w, off int, mask uint32) int32 {
1281 *(*uint32)(unsafe.Pointer(p)) = *(*uint32)(unsafe.Pointer(p))&^uint32(mask) | uint32(v)<<off&mask
1282 s := 32 - w
1283 return v << s >> s
1284}
1285
1286func AssignBitFieldPtr32Int64(p uintptr, v int64, w, off int, mask uint32) int64 {
1287 *(*uint32)(unsafe.Pointer(p)) = *(*uint32)(unsafe.Pointer(p))&^uint32(mask) | uint32(v)<<off&mask
1288 s := 64 - w
1289 return v << s >> s
1290}
1291
1292func AssignBitFieldPtr64Int8(p uintptr, v int8, w, off int, mask uint64) int8 {
1293 *(*uint64)(unsafe.Pointer(p)) = *(*uint64)(unsafe.Pointer(p))&^uint64(mask) | uint64(v)<<off&mask
1294 s := 8 - w
1295 return v << s >> s
1296}
1297
1298func AssignBitFieldPtr64Int16(p uintptr, v int16, w, off int, mask uint64) int16 {
1299 *(*uint64)(unsafe.Pointer(p)) = *(*uint64)(unsafe.Pointer(p))&^uint64(mask) | uint64(v)<<off&mask
1300 s := 16 - w
1301 return v << s >> s
1302}
1303
1304func AssignBitFieldPtr64Int32(p uintptr, v int32, w, off int, mask uint64) int32 {
1305 *(*uint64)(unsafe.Pointer(p)) = *(*uint64)(unsafe.Pointer(p))&^uint64(mask) | uint64(v)<<off&mask
1306 s := 32 - w
1307 return v << s >> s
1308}
1309
1310func AssignBitFieldPtr64Int64(p uintptr, v int64, w, off int, mask uint64) int64 {
1311 *(*uint64)(unsafe.Pointer(p)) = *(*uint64)(unsafe.Pointer(p))&^uint64(mask) | uint64(v)<<off&mask
1312 s := 64 - w
1313 return v << s >> s
1314}
1315
1316func AssignBitFieldPtr8Uint8(p uintptr, v uint8, w, off int, mask uint8) uint8 {
1317 *(*uint8)(unsafe.Pointer(p)) = *(*uint8)(unsafe.Pointer(p))&^uint8(mask) | uint8(v)<<off&mask
1318 return v & uint8(mask>>off)
1319}
1320
1321func AssignBitFieldPtr8Uint16(p uintptr, v uint16, w, off int, mask uint8) uint16 {
1322 *(*uint8)(unsafe.Pointer(p)) = *(*uint8)(unsafe.Pointer(p))&^uint8(mask) | uint8(v)<<off&mask
1323 return v & uint16(mask>>off)
1324}
1325
1326func AssignBitFieldPtr8Uint32(p uintptr, v uint32, w, off int, mask uint8) uint32 {
1327 *(*uint8)(unsafe.Pointer(p)) = *(*uint8)(unsafe.Pointer(p))&^uint8(mask) | uint8(v)<<off&mask
1328 return v & uint32(mask>>off)
1329}
1330
1331func AssignBitFieldPtr8Uint64(p uintptr, v uint64, w, off int, mask uint8) uint64 {
1332 *(*uint8)(unsafe.Pointer(p)) = *(*uint8)(unsafe.Pointer(p))&^uint8(mask) | uint8(v)<<off&mask
1333 return v & uint64(mask>>off)
1334}
1335
1336func AssignBitFieldPtr16Uint8(p uintptr, v uint8, w, off int, mask uint16) uint8 {
1337 *(*uint16)(unsafe.Pointer(p)) = *(*uint16)(unsafe.Pointer(p))&^uint16(mask) | uint16(v)<<off&mask
1338 return v & uint8(mask>>off)
1339}
1340
1341func AssignBitFieldPtr16Uint16(p uintptr, v uint16, w, off int, mask uint16) uint16 {
1342 *(*uint16)(unsafe.Pointer(p)) = *(*uint16)(unsafe.Pointer(p))&^uint16(mask) | uint16(v)<<off&mask
1343 return v & uint16(mask>>off)
1344}
1345
1346func AssignBitFieldPtr16Uint32(p uintptr, v uint32, w, off int, mask uint16) uint32 {
1347 *(*uint16)(unsafe.Pointer(p)) = *(*uint16)(unsafe.Pointer(p))&^uint16(mask) | uint16(v)<<off&mask
1348 return v & uint32(mask>>off)
1349}
1350
1351func AssignBitFieldPtr16Uint64(p uintptr, v uint64, w, off int, mask uint16) uint64 {
1352 *(*uint16)(unsafe.Pointer(p)) = *(*uint16)(unsafe.Pointer(p))&^uint16(mask) | uint16(v)<<off&mask
1353 return v & uint64(mask>>off)
1354}
1355
1356func AssignBitFieldPtr32Uint8(p uintptr, v uint8, w, off int, mask uint32) uint8 {
1357 *(*uint32)(unsafe.Pointer(p)) = *(*uint32)(unsafe.Pointer(p))&^uint32(mask) | uint32(v)<<off&mask
1358 return v & uint8(mask>>off)
1359}
1360
1361func AssignBitFieldPtr32Uint16(p uintptr, v uint16, w, off int, mask uint32) uint16 {
1362 *(*uint32)(unsafe.Pointer(p)) = *(*uint32)(unsafe.Pointer(p))&^uint32(mask) | uint32(v)<<off&mask
1363 return v & uint16(mask>>off)
1364}
1365
1366func AssignBitFieldPtr32Uint32(p uintptr, v uint32, w, off int, mask uint32) uint32 {
1367 *(*uint32)(unsafe.Pointer(p)) = *(*uint32)(unsafe.Pointer(p))&^uint32(mask) | uint32(v)<<off&mask
1368 return v & uint32(mask>>off)
1369}
1370
1371func AssignBitFieldPtr32Uint64(p uintptr, v uint64, w, off int, mask uint32) uint64 {
1372 *(*uint32)(unsafe.Pointer(p)) = *(*uint32)(unsafe.Pointer(p))&^uint32(mask) | uint32(v)<<off&mask
1373 return v & uint64(mask>>off)
1374}
1375
1376func AssignBitFieldPtr64Uint8(p uintptr, v uint8, w, off int, mask uint64) uint8 {
1377 *(*uint64)(unsafe.Pointer(p)) = *(*uint64)(unsafe.Pointer(p))&^uint64(mask) | uint64(v)<<off&mask
1378 return v & uint8(mask>>off)
1379}
1380
1381func AssignBitFieldPtr64Uint16(p uintptr, v uint16, w, off int, mask uint64) uint16 {
1382 *(*uint64)(unsafe.Pointer(p)) = *(*uint64)(unsafe.Pointer(p))&^uint64(mask) | uint64(v)<<off&mask
1383 return v & uint16(mask>>off)
1384}
1385
1386func AssignBitFieldPtr64Uint32(p uintptr, v uint32, w, off int, mask uint64) uint32 {
1387 *(*uint64)(unsafe.Pointer(p)) = *(*uint64)(unsafe.Pointer(p))&^uint64(mask) | uint64(v)<<off&mask
1388 return v & uint32(mask>>off)
1389}
1390
1391func AssignBitFieldPtr64Uint64(p uintptr, v uint64, w, off int, mask uint64) uint64 {
1392 *(*uint64)(unsafe.Pointer(p)) = *(*uint64)(unsafe.Pointer(p))&^uint64(mask) | uint64(v)<<off&mask
1393 return v & uint64(mask>>off)
1394}
1395
1396func PostDecBitFieldPtr8Int8(p uintptr, d int8, w, off int, mask uint8) (r int8) {
1397 x0 := *(*uint8)(unsafe.Pointer(p))
1398 s := 8 - w - off
1399 r = int8(x0) & int8(mask) << s >> (s + off)
1400 *(*uint8)(unsafe.Pointer(p)) = x0&^uint8(mask) | uint8(r-d)<<off&mask
1401 return r
1402}
1403
1404func PostDecBitFieldPtr8Int16(p uintptr, d int16, w, off int, mask uint8) (r int16) {
1405 x0 := *(*uint8)(unsafe.Pointer(p))
1406 s := 16 - w - off
1407 r = int16(x0) & int16(mask) << s >> (s + off)
1408 *(*uint8)(unsafe.Pointer(p)) = x0&^uint8(mask) | uint8(r-d)<<off&mask
1409 return r
1410}
1411
1412func PostDecBitFieldPtr8Int32(p uintptr, d int32, w, off int, mask uint8) (r int32) {
1413 x0 := *(*uint8)(unsafe.Pointer(p))
1414 s := 32 - w - off
1415 r = int32(x0) & int32(mask) << s >> (s + off)
1416 *(*uint8)(unsafe.Pointer(p)) = x0&^uint8(mask) | uint8(r-d)<<off&mask
1417 return r
1418}
1419
1420func PostDecBitFieldPtr8Int64(p uintptr, d int64, w, off int, mask uint8) (r int64) {
1421 x0 := *(*uint8)(unsafe.Pointer(p))
1422 s := 64 - w - off
1423 r = int64(x0) & int64(mask) << s >> (s + off)
1424 *(*uint8)(unsafe.Pointer(p)) = x0&^uint8(mask) | uint8(r-d)<<off&mask
1425 return r
1426}
1427
1428func PostDecBitFieldPtr16Int8(p uintptr, d int8, w, off int, mask uint16) (r int8) {
1429 x0 := *(*uint16)(unsafe.Pointer(p))
1430 s := 8 - w - off
1431 r = int8(x0) & int8(mask) << s >> (s + off)
1432 *(*uint16)(unsafe.Pointer(p)) = x0&^uint16(mask) | uint16(r-d)<<off&mask
1433 return r
1434}
1435
1436func PostDecBitFieldPtr16Int16(p uintptr, d int16, w, off int, mask uint16) (r int16) {
1437 x0 := *(*uint16)(unsafe.Pointer(p))
1438 s := 16 - w - off
1439 r = int16(x0) & int16(mask) << s >> (s + off)
1440 *(*uint16)(unsafe.Pointer(p)) = x0&^uint16(mask) | uint16(r-d)<<off&mask
1441 return r
1442}
1443
1444func PostDecBitFieldPtr16Int32(p uintptr, d int32, w, off int, mask uint16) (r int32) {
1445 x0 := *(*uint16)(unsafe.Pointer(p))
1446 s := 32 - w - off
1447 r = int32(x0) & int32(mask) << s >> (s + off)
1448 *(*uint16)(unsafe.Pointer(p)) = x0&^uint16(mask) | uint16(r-d)<<off&mask
1449 return r
1450}
1451
1452func PostDecBitFieldPtr16Int64(p uintptr, d int64, w, off int, mask uint16) (r int64) {
1453 x0 := *(*uint16)(unsafe.Pointer(p))
1454 s := 64 - w - off
1455 r = int64(x0) & int64(mask) << s >> (s + off)
1456 *(*uint16)(unsafe.Pointer(p)) = x0&^uint16(mask) | uint16(r-d)<<off&mask
1457 return r
1458}
1459
1460func PostDecBitFieldPtr32Int8(p uintptr, d int8, w, off int, mask uint32) (r int8) {
1461 x0 := *(*uint32)(unsafe.Pointer(p))
1462 s := 8 - w - off
1463 r = int8(x0) & int8(mask) << s >> (s + off)
1464 *(*uint32)(unsafe.Pointer(p)) = x0&^uint32(mask) | uint32(r-d)<<off&mask
1465 return r
1466}
1467
1468func PostDecBitFieldPtr32Int16(p uintptr, d int16, w, off int, mask uint32) (r int16) {
1469 x0 := *(*uint32)(unsafe.Pointer(p))
1470 s := 16 - w - off
1471 r = int16(x0) & int16(mask) << s >> (s + off)
1472 *(*uint32)(unsafe.Pointer(p)) = x0&^uint32(mask) | uint32(r-d)<<off&mask
1473 return r
1474}
1475
1476func PostDecBitFieldPtr32Int32(p uintptr, d int32, w, off int, mask uint32) (r int32) {
1477 x0 := *(*uint32)(unsafe.Pointer(p))
1478 s := 32 - w - off
1479 r = int32(x0) & int32(mask) << s >> (s + off)
1480 *(*uint32)(unsafe.Pointer(p)) = x0&^uint32(mask) | uint32(r-d)<<off&mask
1481 return r
1482}
1483
1484func PostDecBitFieldPtr32Int64(p uintptr, d int64, w, off int, mask uint32) (r int64) {
1485 x0 := *(*uint32)(unsafe.Pointer(p))
1486 s := 64 - w - off
1487 r = int64(x0) & int64(mask) << s >> (s + off)
1488 *(*uint32)(unsafe.Pointer(p)) = x0&^uint32(mask) | uint32(r-d)<<off&mask
1489 return r
1490}
1491
1492func PostDecBitFieldPtr64Int8(p uintptr, d int8, w, off int, mask uint64) (r int8) {
1493 x0 := *(*uint64)(unsafe.Pointer(p))
1494 s := 8 - w - off
1495 r = int8(x0) & int8(mask) << s >> (s + off)
1496 *(*uint64)(unsafe.Pointer(p)) = x0&^uint64(mask) | uint64(r-d)<<off&mask
1497 return r
1498}
1499
1500func PostDecBitFieldPtr64Int16(p uintptr, d int16, w, off int, mask uint64) (r int16) {
1501 x0 := *(*uint64)(unsafe.Pointer(p))
1502 s := 16 - w - off
1503 r = int16(x0) & int16(mask) << s >> (s + off)
1504 *(*uint64)(unsafe.Pointer(p)) = x0&^uint64(mask) | uint64(r-d)<<off&mask
1505 return r
1506}
1507
1508func PostDecBitFieldPtr64Int32(p uintptr, d int32, w, off int, mask uint64) (r int32) {
1509 x0 := *(*uint64)(unsafe.Pointer(p))
1510 s := 32 - w - off
1511 r = int32(x0) & int32(mask) << s >> (s + off)
1512 *(*uint64)(unsafe.Pointer(p)) = x0&^uint64(mask) | uint64(r-d)<<off&mask
1513 return r
1514}
1515
1516func PostDecBitFieldPtr64Int64(p uintptr, d int64, w, off int, mask uint64) (r int64) {
1517 x0 := *(*uint64)(unsafe.Pointer(p))
1518 s := 64 - w - off
1519 r = int64(x0) & int64(mask) << s >> (s + off)
1520 *(*uint64)(unsafe.Pointer(p)) = x0&^uint64(mask) | uint64(r-d)<<off&mask
1521 return r
1522}
1523
1524func PostDecBitFieldPtr8Uint8(p uintptr, d uint8, w, off int, mask uint8) (r uint8) {
1525 x0 := *(*uint8)(unsafe.Pointer(p))
1526 r = uint8(x0) & uint8(mask) >> off
1527 *(*uint8)(unsafe.Pointer(p)) = x0&^uint8(mask) | uint8(r-d)<<off&mask
1528 return r
1529}
1530
1531func PostDecBitFieldPtr8Uint16(p uintptr, d uint16, w, off int, mask uint8) (r uint16) {
1532 x0 := *(*uint8)(unsafe.Pointer(p))
1533 r = uint16(x0) & uint16(mask) >> off
1534 *(*uint8)(unsafe.Pointer(p)) = x0&^uint8(mask) | uint8(r-d)<<off&mask
1535 return r
1536}
1537
1538func PostDecBitFieldPtr8Uint32(p uintptr, d uint32, w, off int, mask uint8) (r uint32) {
1539 x0 := *(*uint8)(unsafe.Pointer(p))
1540 r = uint32(x0) & uint32(mask) >> off
1541 *(*uint8)(unsafe.Pointer(p)) = x0&^uint8(mask) | uint8(r-d)<<off&mask
1542 return r
1543}
1544
1545func PostDecBitFieldPtr8Uint64(p uintptr, d uint64, w, off int, mask uint8) (r uint64) {
1546 x0 := *(*uint8)(unsafe.Pointer(p))
1547 r = uint64(x0) & uint64(mask) >> off
1548 *(*uint8)(unsafe.Pointer(p)) = x0&^uint8(mask) | uint8(r-d)<<off&mask
1549 return r
1550}
1551
1552func PostDecBitFieldPtr16Uint8(p uintptr, d uint8, w, off int, mask uint16) (r uint8) {
1553 x0 := *(*uint16)(unsafe.Pointer(p))
1554 r = uint8(x0) & uint8(mask) >> off
1555 *(*uint16)(unsafe.Pointer(p)) = x0&^uint16(mask) | uint16(r-d)<<off&mask
1556 return r
1557}
1558
1559func PostDecBitFieldPtr16Uint16(p uintptr, d uint16, w, off int, mask uint16) (r uint16) {
1560 x0 := *(*uint16)(unsafe.Pointer(p))
1561 r = uint16(x0) & uint16(mask) >> off
1562 *(*uint16)(unsafe.Pointer(p)) = x0&^uint16(mask) | uint16(r-d)<<off&mask
1563 return r
1564}
1565
1566func PostDecBitFieldPtr16Uint32(p uintptr, d uint32, w, off int, mask uint16) (r uint32) {
1567 x0 := *(*uint16)(unsafe.Pointer(p))
1568 r = uint32(x0) & uint32(mask) >> off
1569 *(*uint16)(unsafe.Pointer(p)) = x0&^uint16(mask) | uint16(r-d)<<off&mask
1570 return r
1571}
1572
1573func PostDecBitFieldPtr16Uint64(p uintptr, d uint64, w, off int, mask uint16) (r uint64) {
1574 x0 := *(*uint16)(unsafe.Pointer(p))
1575 r = uint64(x0) & uint64(mask) >> off
1576 *(*uint16)(unsafe.Pointer(p)) = x0&^uint16(mask) | uint16(r-d)<<off&mask
1577 return r
1578}
1579
1580func PostDecBitFieldPtr32Uint8(p uintptr, d uint8, w, off int, mask uint32) (r uint8) {
1581 x0 := *(*uint32)(unsafe.Pointer(p))
1582 r = uint8(x0) & uint8(mask) >> off
1583 *(*uint32)(unsafe.Pointer(p)) = x0&^uint32(mask) | uint32(r-d)<<off&mask
1584 return r
1585}
1586
1587func PostDecBitFieldPtr32Uint16(p uintptr, d uint16, w, off int, mask uint32) (r uint16) {
1588 x0 := *(*uint32)(unsafe.Pointer(p))
1589 r = uint16(x0) & uint16(mask) >> off
1590 *(*uint32)(unsafe.Pointer(p)) = x0&^uint32(mask) | uint32(r-d)<<off&mask
1591 return r
1592}
1593
1594func PostDecBitFieldPtr32Uint32(p uintptr, d uint32, w, off int, mask uint32) (r uint32) {
1595 x0 := *(*uint32)(unsafe.Pointer(p))
1596 r = uint32(x0) & uint32(mask) >> off
1597 *(*uint32)(unsafe.Pointer(p)) = x0&^uint32(mask) | uint32(r-d)<<off&mask
1598 return r
1599}
1600
1601func PostDecBitFieldPtr32Uint64(p uintptr, d uint64, w, off int, mask uint32) (r uint64) {
1602 x0 := *(*uint32)(unsafe.Pointer(p))
1603 r = uint64(x0) & uint64(mask) >> off
1604 *(*uint32)(unsafe.Pointer(p)) = x0&^uint32(mask) | uint32(r-d)<<off&mask
1605 return r
1606}
1607
1608func PostDecBitFieldPtr64Uint8(p uintptr, d uint8, w, off int, mask uint64) (r uint8) {
1609 x0 := *(*uint64)(unsafe.Pointer(p))
1610 r = uint8(x0) & uint8(mask) >> off
1611 *(*uint64)(unsafe.Pointer(p)) = x0&^uint64(mask) | uint64(r-d)<<off&mask
1612 return r
1613}
1614
1615func PostDecBitFieldPtr64Uint16(p uintptr, d uint16, w, off int, mask uint64) (r uint16) {
1616 x0 := *(*uint64)(unsafe.Pointer(p))
1617 r = uint16(x0) & uint16(mask) >> off
1618 *(*uint64)(unsafe.Pointer(p)) = x0&^uint64(mask) | uint64(r-d)<<off&mask
1619 return r
1620}
1621
1622func PostDecBitFieldPtr64Uint32(p uintptr, d uint32, w, off int, mask uint64) (r uint32) {
1623 x0 := *(*uint64)(unsafe.Pointer(p))
1624 r = uint32(x0) & uint32(mask) >> off
1625 *(*uint64)(unsafe.Pointer(p)) = x0&^uint64(mask) | uint64(r-d)<<off&mask
1626 return r
1627}
1628
1629func PostDecBitFieldPtr64Uint64(p uintptr, d uint64, w, off int, mask uint64) (r uint64) {
1630 x0 := *(*uint64)(unsafe.Pointer(p))
1631 r = uint64(x0) & uint64(mask) >> off
1632 *(*uint64)(unsafe.Pointer(p)) = x0&^uint64(mask) | uint64(r-d)<<off&mask
1633 return r
1634}
1635
1636func PostIncBitFieldPtr8Int8(p uintptr, d int8, w, off int, mask uint8) (r int8) {
1637 x0 := *(*uint8)(unsafe.Pointer(p))
1638 s := 8 - w - off
1639 r = int8(x0) & int8(mask) << s >> (s + off)
1640 *(*uint8)(unsafe.Pointer(p)) = x0&^uint8(mask) | uint8(r+d)<<off&mask
1641 return r
1642}
1643
1644func PostIncBitFieldPtr8Int16(p uintptr, d int16, w, off int, mask uint8) (r int16) {
1645 x0 := *(*uint8)(unsafe.Pointer(p))
1646 s := 16 - w - off
1647 r = int16(x0) & int16(mask) << s >> (s + off)
1648 *(*uint8)(unsafe.Pointer(p)) = x0&^uint8(mask) | uint8(r+d)<<off&mask
1649 return r
1650}
1651
1652func PostIncBitFieldPtr8Int32(p uintptr, d int32, w, off int, mask uint8) (r int32) {
1653 x0 := *(*uint8)(unsafe.Pointer(p))
1654 s := 32 - w - off
1655 r = int32(x0) & int32(mask) << s >> (s + off)
1656 *(*uint8)(unsafe.Pointer(p)) = x0&^uint8(mask) | uint8(r+d)<<off&mask
1657 return r
1658}
1659
1660func PostIncBitFieldPtr8Int64(p uintptr, d int64, w, off int, mask uint8) (r int64) {
1661 x0 := *(*uint8)(unsafe.Pointer(p))
1662 s := 64 - w - off
1663 r = int64(x0) & int64(mask) << s >> (s + off)
1664 *(*uint8)(unsafe.Pointer(p)) = x0&^uint8(mask) | uint8(r+d)<<off&mask
1665 return r
1666}
1667
1668func PostIncBitFieldPtr16Int8(p uintptr, d int8, w, off int, mask uint16) (r int8) {
1669 x0 := *(*uint16)(unsafe.Pointer(p))
1670 s := 8 - w - off
1671 r = int8(x0) & int8(mask) << s >> (s + off)
1672 *(*uint16)(unsafe.Pointer(p)) = x0&^uint16(mask) | uint16(r+d)<<off&mask
1673 return r
1674}
1675
1676func PostIncBitFieldPtr16Int16(p uintptr, d int16, w, off int, mask uint16) (r int16) {
1677 x0 := *(*uint16)(unsafe.Pointer(p))
1678 s := 16 - w - off
1679 r = int16(x0) & int16(mask) << s >> (s + off)
1680 *(*uint16)(unsafe.Pointer(p)) = x0&^uint16(mask) | uint16(r+d)<<off&mask
1681 return r
1682}
1683
1684func PostIncBitFieldPtr16Int32(p uintptr, d int32, w, off int, mask uint16) (r int32) {
1685 x0 := *(*uint16)(unsafe.Pointer(p))
1686 s := 32 - w - off
1687 r = int32(x0) & int32(mask) << s >> (s + off)
1688 *(*uint16)(unsafe.Pointer(p)) = x0&^uint16(mask) | uint16(r+d)<<off&mask
1689 return r
1690}
1691
1692func PostIncBitFieldPtr16Int64(p uintptr, d int64, w, off int, mask uint16) (r int64) {
1693 x0 := *(*uint16)(unsafe.Pointer(p))
1694 s := 64 - w - off
1695 r = int64(x0) & int64(mask) << s >> (s + off)
1696 *(*uint16)(unsafe.Pointer(p)) = x0&^uint16(mask) | uint16(r+d)<<off&mask
1697 return r
1698}
1699
1700func PostIncBitFieldPtr32Int8(p uintptr, d int8, w, off int, mask uint32) (r int8) {
1701 x0 := *(*uint32)(unsafe.Pointer(p))
1702 s := 8 - w - off
1703 r = int8(x0) & int8(mask) << s >> (s + off)
1704 *(*uint32)(unsafe.Pointer(p)) = x0&^uint32(mask) | uint32(r+d)<<off&mask
1705 return r
1706}
1707
1708func PostIncBitFieldPtr32Int16(p uintptr, d int16, w, off int, mask uint32) (r int16) {
1709 x0 := *(*uint32)(unsafe.Pointer(p))
1710 s := 16 - w - off
1711 r = int16(x0) & int16(mask) << s >> (s + off)
1712 *(*uint32)(unsafe.Pointer(p)) = x0&^uint32(mask) | uint32(r+d)<<off&mask
1713 return r
1714}
1715
1716func PostIncBitFieldPtr32Int32(p uintptr, d int32, w, off int, mask uint32) (r int32) {
1717 x0 := *(*uint32)(unsafe.Pointer(p))
1718 s := 32 - w - off
1719 r = int32(x0) & int32(mask) << s >> (s + off)
1720 *(*uint32)(unsafe.Pointer(p)) = x0&^uint32(mask) | uint32(r+d)<<off&mask
1721 return r
1722}
1723
1724func PostIncBitFieldPtr32Int64(p uintptr, d int64, w, off int, mask uint32) (r int64) {
1725 x0 := *(*uint32)(unsafe.Pointer(p))
1726 s := 64 - w - off
1727 r = int64(x0) & int64(mask) << s >> (s + off)
1728 *(*uint32)(unsafe.Pointer(p)) = x0&^uint32(mask) | uint32(r+d)<<off&mask
1729 return r
1730}
1731
1732func PostIncBitFieldPtr64Int8(p uintptr, d int8, w, off int, mask uint64) (r int8) {
1733 x0 := *(*uint64)(unsafe.Pointer(p))
1734 s := 8 - w - off
1735 r = int8(x0) & int8(mask) << s >> (s + off)
1736 *(*uint64)(unsafe.Pointer(p)) = x0&^uint64(mask) | uint64(r+d)<<off&mask
1737 return r
1738}
1739
1740func PostIncBitFieldPtr64Int16(p uintptr, d int16, w, off int, mask uint64) (r int16) {
1741 x0 := *(*uint64)(unsafe.Pointer(p))
1742 s := 16 - w - off
1743 r = int16(x0) & int16(mask) << s >> (s + off)
1744 *(*uint64)(unsafe.Pointer(p)) = x0&^uint64(mask) | uint64(r+d)<<off&mask
1745 return r
1746}
1747
1748func PostIncBitFieldPtr64Int32(p uintptr, d int32, w, off int, mask uint64) (r int32) {
1749 x0 := *(*uint64)(unsafe.Pointer(p))
1750 s := 32 - w - off
1751 r = int32(x0) & int32(mask) << s >> (s + off)
1752 *(*uint64)(unsafe.Pointer(p)) = x0&^uint64(mask) | uint64(r+d)<<off&mask
1753 return r
1754}
1755
1756func PostIncBitFieldPtr64Int64(p uintptr, d int64, w, off int, mask uint64) (r int64) {
1757 x0 := *(*uint64)(unsafe.Pointer(p))
1758 s := 64 - w - off
1759 r = int64(x0) & int64(mask) << s >> (s + off)
1760 *(*uint64)(unsafe.Pointer(p)) = x0&^uint64(mask) | uint64(r+d)<<off&mask
1761 return r
1762}
1763
1764func PostIncBitFieldPtr8Uint8(p uintptr, d uint8, w, off int, mask uint8) (r uint8) {
1765 x0 := *(*uint8)(unsafe.Pointer(p))
1766 r = uint8(x0) & uint8(mask) >> off
1767 *(*uint8)(unsafe.Pointer(p)) = x0&^uint8(mask) | uint8(r+d)<<off&mask
1768 return r
1769}
1770
1771func PostIncBitFieldPtr8Uint16(p uintptr, d uint16, w, off int, mask uint8) (r uint16) {
1772 x0 := *(*uint8)(unsafe.Pointer(p))
1773 r = uint16(x0) & uint16(mask) >> off
1774 *(*uint8)(unsafe.Pointer(p)) = x0&^uint8(mask) | uint8(r+d)<<off&mask
1775 return r
1776}
1777
1778func PostIncBitFieldPtr8Uint32(p uintptr, d uint32, w, off int, mask uint8) (r uint32) {
1779 x0 := *(*uint8)(unsafe.Pointer(p))
1780 r = uint32(x0) & uint32(mask) >> off
1781 *(*uint8)(unsafe.Pointer(p)) = x0&^uint8(mask) | uint8(r+d)<<off&mask
1782 return r
1783}
1784
1785func PostIncBitFieldPtr8Uint64(p uintptr, d uint64, w, off int, mask uint8) (r uint64) {
1786 x0 := *(*uint8)(unsafe.Pointer(p))
1787 r = uint64(x0) & uint64(mask) >> off
1788 *(*uint8)(unsafe.Pointer(p)) = x0&^uint8(mask) | uint8(r+d)<<off&mask
1789 return r
1790}
1791
1792func PostIncBitFieldPtr16Uint8(p uintptr, d uint8, w, off int, mask uint16) (r uint8) {
1793 x0 := *(*uint16)(unsafe.Pointer(p))
1794 r = uint8(x0) & uint8(mask) >> off
1795 *(*uint16)(unsafe.Pointer(p)) = x0&^uint16(mask) | uint16(r+d)<<off&mask
1796 return r
1797}
1798
1799func PostIncBitFieldPtr16Uint16(p uintptr, d uint16, w, off int, mask uint16) (r uint16) {
1800 x0 := *(*uint16)(unsafe.Pointer(p))
1801 r = uint16(x0) & uint16(mask) >> off
1802 *(*uint16)(unsafe.Pointer(p)) = x0&^uint16(mask) | uint16(r+d)<<off&mask
1803 return r
1804}
1805
1806func PostIncBitFieldPtr16Uint32(p uintptr, d uint32, w, off int, mask uint16) (r uint32) {
1807 x0 := *(*uint16)(unsafe.Pointer(p))
1808 r = uint32(x0) & uint32(mask) >> off
1809 *(*uint16)(unsafe.Pointer(p)) = x0&^uint16(mask) | uint16(r+d)<<off&mask
1810 return r
1811}
1812
1813func PostIncBitFieldPtr16Uint64(p uintptr, d uint64, w, off int, mask uint16) (r uint64) {
1814 x0 := *(*uint16)(unsafe.Pointer(p))
1815 r = uint64(x0) & uint64(mask) >> off
1816 *(*uint16)(unsafe.Pointer(p)) = x0&^uint16(mask) | uint16(r+d)<<off&mask
1817 return r
1818}
1819
1820func PostIncBitFieldPtr32Uint8(p uintptr, d uint8, w, off int, mask uint32) (r uint8) {
1821 x0 := *(*uint32)(unsafe.Pointer(p))
1822 r = uint8(x0) & uint8(mask) >> off
1823 *(*uint32)(unsafe.Pointer(p)) = x0&^uint32(mask) | uint32(r+d)<<off&mask
1824 return r
1825}
1826
1827func PostIncBitFieldPtr32Uint16(p uintptr, d uint16, w, off int, mask uint32) (r uint16) {
1828 x0 := *(*uint32)(unsafe.Pointer(p))
1829 r = uint16(x0) & uint16(mask) >> off
1830 *(*uint32)(unsafe.Pointer(p)) = x0&^uint32(mask) | uint32(r+d)<<off&mask
1831 return r
1832}
1833
1834func PostIncBitFieldPtr32Uint32(p uintptr, d uint32, w, off int, mask uint32) (r uint32) {
1835 x0 := *(*uint32)(unsafe.Pointer(p))
1836 r = uint32(x0) & uint32(mask) >> off
1837 *(*uint32)(unsafe.Pointer(p)) = x0&^uint32(mask) | uint32(r+d)<<off&mask
1838 return r
1839}
1840
1841func PostIncBitFieldPtr32Uint64(p uintptr, d uint64, w, off int, mask uint32) (r uint64) {
1842 x0 := *(*uint32)(unsafe.Pointer(p))
1843 r = uint64(x0) & uint64(mask) >> off
1844 *(*uint32)(unsafe.Pointer(p)) = x0&^uint32(mask) | uint32(r+d)<<off&mask
1845 return r
1846}
1847
1848func PostIncBitFieldPtr64Uint8(p uintptr, d uint8, w, off int, mask uint64) (r uint8) {
1849 x0 := *(*uint64)(unsafe.Pointer(p))
1850 r = uint8(x0) & uint8(mask) >> off
1851 *(*uint64)(unsafe.Pointer(p)) = x0&^uint64(mask) | uint64(r+d)<<off&mask
1852 return r
1853}
1854
1855func PostIncBitFieldPtr64Uint16(p uintptr, d uint16, w, off int, mask uint64) (r uint16) {
1856 x0 := *(*uint64)(unsafe.Pointer(p))
1857 r = uint16(x0) & uint16(mask) >> off
1858 *(*uint64)(unsafe.Pointer(p)) = x0&^uint64(mask) | uint64(r+d)<<off&mask
1859 return r
1860}
1861
1862func PostIncBitFieldPtr64Uint32(p uintptr, d uint32, w, off int, mask uint64) (r uint32) {
1863 x0 := *(*uint64)(unsafe.Pointer(p))
1864 r = uint32(x0) & uint32(mask) >> off
1865 *(*uint64)(unsafe.Pointer(p)) = x0&^uint64(mask) | uint64(r+d)<<off&mask
1866 return r
1867}
1868
1869func PostIncBitFieldPtr64Uint64(p uintptr, d uint64, w, off int, mask uint64) (r uint64) {
1870 x0 := *(*uint64)(unsafe.Pointer(p))
1871 r = uint64(x0) & uint64(mask) >> off
1872 *(*uint64)(unsafe.Pointer(p)) = x0&^uint64(mask) | uint64(r+d)<<off&mask
1873 return r
1874}
Note: See TracBrowser for help on using the repository browser.